1 SpringBoot概述

敏捷开发（整合框架，直接加入依赖就好，自动配置）；

无须Tomcat（Java应用程序方式运行，实际jar包），内置Tomcat

减少xml配置（甚至没有），配置文件properties/yml

注解形式

SpringBoot 是一个快速开发的框架,能够快速的整合第三方框架，简化XML配置，全部采用注解形式，内置Tomcat容器,帮助开发者能够实现快速开发，SpringBoot的Web组件 默认集成的是SpringMVC框架。SpringMVC是控制层。

1.1 SpringBoot和SpringMVC区别

SpringBoot 是一个快速开发的框架,能够快速的整合第三方框架，简化XML配置，全部采用注解形式，内置Tomcat容器,帮助开发者能够实现快速开发，SpringBoot的Web组件 默认集成的是SpringMVC框架。

SpringMVC是控制层。

1.2 SpringBoot和SpringCloud区别

SpringBoot 是一个快速开发的框架,能够快速的整合第三方框架，简化XML配置，全部采用注解形式，内置Tomcat容器,帮助开发者能够实现快速开发，SpringBoot的Web组件 默认集成的是SpringMVC框架。

SpringMVC是控制层。

SpringCloud依赖与SpringBoot组件，使用SpringMVC编写Http协议接口，同时SpringCloud是一套完整的微服务解决框架。

2 快速入门

依赖：

    <!--提供dependency management,也就是说依赖管理，引入以后在申明其它dependency的时候就不需要version了，后面可以看到。-->
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
<!--springweb 核心组件-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>

<!--如果我们要直接Main启动spring，那么以下plugin必须要添加，否则是无法启动的。如果使用maven 的spring-boot:run的话是不需要此配置的。-->

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

后台程序：


@RestController
@EnableAutoConfiguration
public class HelloController {
	@RequestMapping("/hello")
	public String index() {
		return "Hello World";
	}	
public static void main(String[] args) {
		SpringApplication.run(HelloController.class, args);
	}
}

启动main主程序，访问http://127.0.0.1:8080/index看看是否有输出。

2.1 @EnableAutoConfiguration

 Spring Boot   根据应用所声明的依赖来对 Spring 框架进行自动配置。这个注解告诉Spring Boot根据添加的jar依赖猜测你想如何配置Spring。由于spring-boot-starter-web添加了Tomcat和Spring MVC，所以auto-configuration将假定你正在开发一个web应用并相应地对Spring进行设置。但是这个注解仅仅扫描当前类声明的bean，其他类的bean不会注册。

2.2 @RestController

在类上加上RestController 表示该类所有的方法返回JSON格式,直接可以编写Restful接口

2.3 SpringBoot启动方式2

@ComponentScan(basePackages = "com.itmayiedu.controller")---控制器扫包范围

@ComponentScan(basePackages = "com.itboy.spboot.controller")
@EnableAutoConfiguration
public class App {
	public static void main(String[] args) {
		SpringApplication.run(App.class, args);
	}
}

2.3 springboot启动方式3

@SpringBootApplication 被 @Configuration、@EnableAutoConfiguration、@ComponentScan 注解所修饰，换言之 Springboot 提供了统一的注解来替代以上三个注解

扫包范围：在启动类上加上@SpringBootApplication注解,当前包下或者子包下所有的类都可以扫到。

@SpringBootApplication
public class SpbootApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpbootApplication.class, args);
    }
}

3 web开发

3.1 静态资源访问

开发Web应用的时候，需要引用大量的js、css、图片等静态资源。

Spring Boot默认提供静态资源目录位置需置于resources下，目录名需符合如下规则：

/static

/public

/resources        

/META-INF/resources

在src/main/resources/目录下创建static，在该位置放置一个图片文件。启动程序后，尝试访问http://localhost:8080/D.jpg。如能显示图片，配置成功。

3.2 渲染web界面

在之前的示例中，都是通过@RestController来处理请求，所以返回的内容为json对象。那么如果需要渲染html页面的时候，要如何实现呢？

模板引擎

在动态HTML实现上Spring Boot依然可以完美胜任，并且提供了多种模板引擎的默认配置支持，所以在推荐的模板引擎下，我们可以很快的上手开发动态网站。

Spring Boot提供了默认配置的模板引擎主要有以下几种：

  • Thymeleaf
  • FreeMarker
  • Velocity
  • Groovy
  • Mustache

Spring Boot建议使用这些模板引擎，避免使用JSP，若一定要使用JSP将无法实现Spring Boot的多种特性，具体可见后文：支持JSP的配置

当你使用上述模板引擎中的任何一个，它们默认的模板配置路径为：src/main/resources/templates。当然也可以修改这个路径，具体如何修改，可在后续各模板引擎的配置属性中查询并修改。

3.2.1 使用Freemarker模板引擎渲染web视图

依赖：

<!-- 引入freeMarker的依赖包. -->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-freemarker</artifactId>
</dependency>

后台代码，返回“index”表示到src/main/resources/templates路径下寻找index.ftl的伪静态页面文件，然后根据ModelAndView渲染显示

	@RequestMapping("/index")
	public String index(Map<String, Object> map) {
	    map.put("name","美丽的天使...");
	   return "index";
	}

前台：

<!DOCTYPE html>
<html>
<head lang="en">
<meta charset="UTF-8" />
<title></title>
</head>
<body>
	  ${name}
</body> 
</html>

补充：

@RequestMapping("/freemarkerIndex")
	public String index(Map<String, Object> result) {
		result.put("name", "小明");
		result.put("sex", "0");
		List<String> listResult = new ArrayList<String>();
		listResult.add("zhangsan");
		listResult.add("lisi");
		listResult.add("李大爷");
		result.put("listResult", listResult);
		return "index";
	}

<!DOCTYPE html>
<html>
<head lang="en">
<meta charset="UTF-8" />
<title>首页</title>
</head>
<body>
	  ${name}
<#if sex=="1">
            男
      <#elseif sex=="2">
            女
     <#else>
        其他      
	  
	  </#if>	  
	 <#list userlist as user>
	   ${user}
	 </#list>
</body> 
</html>

freemarker的一些基本配置，配置在application.properties

########################################################
###FREEMARKER (FreeMarkerAutoConfiguration)
########################################################
spring.freemarker.allow-request-override=false
spring.freemarker.cache=true
spring.freemarker.check-template-location=true
spring.freemarker.charset=UTF-8
spring.freemarker.content-type=text/html
spring.freemarker.expose-request-attributes=false
spring.freemarker.expose-session-attributes=false
spring.freemarker.expose-spring-macro-helpers=false
#spring.freemarker.prefix=
#spring.freemarker.request-context-attribute=
#spring.freemarker.settings.*=
spring.freemarker.suffix=.ftl
spring.freemarker.template-loader-path=classpath:/templates/
#comma-separated list
#spring.freemarker.view-names= # whitelist of view names that can be resolved

3.2.2 使用jsp渲染web视图

依赖，因为Spring boot内嵌Tomcat不支持jsp，所以需要添加外部Tomcat支持

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.0.RELEASE</version>
	</parent>
	<dependencies>
		<!-- SpringBoot web 核心组件 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-tomcat</artifactId>
		</dependency>
	<!-- SpringBoot 外部tomcat支持 -->	
	<dependency>
			<groupId>org.apache.tomcat.embed</groupId>
			<artifactId>tomcat-embed-jasper</artifactId>
		</dependency>
	</dependencies>

application.properties配置读取jsp的目录，jsp文件不要放在resources目录下，因为这个目录会被打包然后是classpath，所以只能重新在main下新建webapp/WEB..不然访问不到。

spring.mvc.view.prefix=/WEB-INF/jsp/
spring.mvc.view.suffix=.jsp

后台代码，和freemarker一样，只不过文件后缀名为application.properties指定的jsp

@Controller
public class IndexController {
	@RequestMapping("/index")
	public String index() {
		return "index";
	}
}

注意:创建SpringBoot整合JSP，一定要为war类型，否则会找不到页面.不要把JSP页面存放在resources// jsp 不能被访问到

3.3 全局捕获异常

@ExceptionHandler 表示拦截异常

  • @ControllerAdvice 是 controller 的一个辅助类，最常用的就是作为全局异常处理的切面类
  • @ControllerAdvice 可以指定扫描范围
  • @ControllerAdvice 约定了几种可行的返回值，如果是直接返回 model 类的话，需要使用 @ResponseBody 进行 json 转换
    • 返回 String，表示跳到某个 view
    • 返回 modelAndView
    • 返回 model + @ResponseBody
@ControllerAdvice(basePackages = {"com.itboy.spboot.controller"})
public class GlobalExceptionHandler {

    @ExceptionHandler(RuntimeException.class)
    @ResponseBody
    public Map<String,Object> error(){
        Map<String,Object> map=new HashMap<>();
        map.put("errorCode","500");
        map.put("errorMsg","系统错误！");
        return map;
    }
}

4 日志管理

4.1 使用log4j记录日志

依赖：

<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>2.0.0.RELEASE</version>
	</parent>
	<dependencies>
		<!-- SpringBoot 核心组件 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-tomcat</artifactId>
		</dependency>
		<dependency>
			<groupId>org.apache.tomcat.embed</groupId>
			<artifactId>tomcat-embed-jasper</artifactId>
		</dependency>
		<!-- spring boot start -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter</artifactId>
			<exclusions>
				<!-- 排除自带的logback依赖 -->
				<exclusion>
					<groupId>org.springframework.boot</groupId>
					<artifactId>spring-boot-starter-logging</artifactId>
				</exclusion>
			</exclusions>
		</dependency>

		<!-- springboot-log4j -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-log4j</artifactId>
			<version>1.3.8.RELEASE</version>
		</dependency>
	</dependencies>

新建log4配置文件log4j.properties:

#log4j.rootLogger=CONSOLE,info,error,DEBUG
log4j.rootLogger=info,error,CONSOLE,DEBUG
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender     
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout     
log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n     
log4j.logger.info=info
log4j.appender.info=org.apache.log4j.DailyRollingFileAppender
log4j.appender.info.layout=org.apache.log4j.PatternLayout     
log4j.appender.info.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
log4j.appender.info.datePattern='.'yyyy-MM-dd
log4j.appender.info.Threshold = info   
log4j.appender.info.append=true   
#log4j.appender.info.File=/home/admin/pms-api-services/logs/info/api_services_info
log4j.appender.info.File=/Users/dddd/Documents/testspace/pms-api-services/logs/info/api_services_info
log4j.logger.error=error  
log4j.appender.error=org.apache.log4j.DailyRollingFileAppender
log4j.appender.error.layout=org.apache.log4j.PatternLayout     
log4j.appender.error.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
log4j.appender.error.datePattern='.'yyyy-MM-dd
log4j.appender.error.Threshold = error   
log4j.appender.error.append=true   
#log4j.appender.error.File=/home/admin/pms-api-services/logs/error/api_services_error
log4j.appender.error.File=/Users/dddd/Documents/testspace/pms-api-services/logs/error/api_services_error
log4j.logger.DEBUG=DEBUG
log4j.appender.DEBUG=org.apache.log4j.DailyRollingFileAppender
log4j.appender.DEBUG.layout=org.apache.log4j.PatternLayout     
log4j.appender.DEBUG.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
log4j.appender.DEBUG.datePattern='.'yyyy-MM-dd
log4j.appender.DEBUG.Threshold = DEBUG   
log4j.appender.DEBUG.append=true   
#log4j.appender.DEBUG.File=/home/admin/pms-api-services/logs/debug/api_services_debug
log4j.appender.DEBUG.File=/Users/dddd/Documents/testspace/pms-api-services/logs/debug/api_services_debug

通过在类中这样获取private static final Logger logger = LoggerFactory.getLogger(IndexController.class);使用

4.2 使用AOP统一处理web请求日志

依赖：

	<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-aop</artifactId>
	</dependency>

aop:

@Aspect
@Component
public class WebLogApect {
    private static final Logger logger=LoggerFactory.getLogger(WebLogApect.class);
    @Pointcut("execution(public * com.itboy.spboot.controller.*.*(..))")
    public void webLog(){

    }

    @Before("webLog()")
    public void doBefore(JoinPoint joinPoint){
        //接受到请求，记录请求内容
        ServletRequestAttributes attributes= (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
        HttpServletRequest request=attributes.getRequest();

        logger.info("URL :"+request.getRequestURI().toString());
        logger.info("HTTP_METHOD: "+request.getMethod());
        logger.info("IP: "+request.getRemoteAddr());

        Enumeration<String> eu=request.getParameterNames();
        while (eu.hasMoreElements()){
            String name=eu.nextElement();
            logger.info("name:{},value{}",name,request.getParameter(name));
        }
    }

    @AfterReturning(returning = "ret", pointcut = "webLog()")
    public void doAfterReturning(Object ret){
        logger.info("RESPONSE :"+ret);
    }
}

此时任意访问一个URL都会记录在日志文件中。

4.3 lombok

底层通过asm框架修改字节码文件，生成相应的方法。

注意需要在开发工具中先安装lombok插件，然后引入依赖：

<dependency>
	<groupId>org.projectlombok</groupId>
	<artifactId>lombok</artifactId>
</dependency>

例子：

@Slf4j
@Data
public class UserEntity {
	// @Getter
	// @Setter
	private String userName;
	// @Getter
	// @Setter
	private Integer age;

	@Override
	public String toString() {
		return "UserEntity [userName=" + userName + ", age=" + age + "]";
	}

	public static void main(String[] args) {
		UserEntity userEntity = new UserEntity();
		userEntity.setUserName("zhangsan");
		userEntity.setAge(20);
		System.out.println(userEntity.toString());
		log.info("####我是日志##########");
	}

}

其他特性：

@Data 标签，生成getter/setter toString()等方法 
@NonNull : 让你不在担忧并且爱上NullPointerException 
@CleanUp : 自动资源管理：不用再在finally中添加资源的close方法 
@Setter/@Getter : 自动生成set/get方法 
@ToString : 自动生成toString方法 
@EqualsAndHashcode : 从对象的字段中生成hashCode和equals的实现 
@NoArgsConstructor/@RequiredArgsConstructor/@AllArgsConstructor 
自动生成构造方法 
@Data : 自动生成set/get方法，toString方法，equals方法，hashCode方法，不带参数的构造方法 
@Value : 用于注解final类 
@Builder : 产生复杂的构建器api类
@SneakyThrows : 异常处理（谨慎使用） 
@Synchronized : 同步方法安全的转化 
@Getter(lazy=true) : 
@Log : 支持各种logger对象，使用时用对应的注解，如：@Log4

5 简单但好用一些内容

5.1 使用@Scheduled创建定时任务

在Spring Boot主类中添加@EnableScheduling注解，启动定时任务的配置

然后声明定时任务：

@Component
@Slf4j
public class ScheduledTasks {
    private static final SimpleDateFormat dateFormat=new SimpleDateFormat("HH:mm:ss");
    //周期5秒
    @Scheduled(fixedRate = 5000)
    public void reportCurrentTime(){
        log.info("现在时间:"+dateFormat.format(new Date()));
    }
}

5.2 使用@Async实现异步调用

在启动主类上加上#EnableAsync，需要执行方法上加入@Async后，底层就会使用多线程技术


IndexController .java

@RestController//表示该类所有方法返回json格式，等价于@Controller@ResponseBody
@Slf4j
public class IndexController {
    @Autowired
    private IndexService indexService;

    @RequestMapping("/async")
    public String asyncTest(){
        log.info("##01##");
        indexService.userThread();
        log.info("##04##");
        return "async success";
    }

}


IndexService.java
@Service
@Slf4j
public class IndexService {
    @Async//相当于这个方法重新开辟了一个单独的线程执行
    //思路：使用aop技术，在运行时创建一个单独的线程执行
    public void userThread(){
        log.info("##02##");
        try{
            Thread.sleep(5*1000);
        } catch (Exception e){

        }
        log.info("##03##");
//        加上注解后类似下面这样执行
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                log.info("##02##");
//                try{
//                    Thread.sleep(5*1000);
//                } catch (Exception e){
//
//                }
//                log.info("##03##");
//            }
//        }).start();
    }
}

本来是要输出1234的，但是异步之后，结果是1423，所以采用了异步

5.3 @Value自定义参数

配置文件值

name=xiaoming.com

初始化时，就去配置文件读取该配置

	@Value("${name}")
	private String name;
@ResponseBody
	@RequestMapping("/getValue")
	public String getValue() {
		return name;
	}

5.4 多环境配置

application.properties:

spring.profiles.active=prod#test#dev三个表名使用哪个配置文件，也就是什么环境

下面三个配置文件表示不同的环境。

application-dev.properties开发环境

application-test.properties测试环境

application-prod.properties生产环境

5.5 修改端口号和项目路径

server.port=8080
server.servlet.context-path=/spboot

5.6 Spring Boot yml使用

SpringBoot 默认读取 application.yml|properties

server:
  port: 8080
  servlet:
    context-path: /

5.7 发布打包

打包方式指定？

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.itboy</groupId>
    <artifactId>spboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <packaging>war或者jar选择一种</packaging>

5.7.1 Jar类型打包方式（打包后后缀名.jar）

1.使用mvn celan  package 打包

2.使用java –jar 包名

5.7.2 war类型打包方式（打包后后缀名.war）

1.使用mvn celan package 打包

2.使用java –jar 包名

5.7.3 外部Tomcat运行

1.pom.xml

<!-- 打包类型-->
    <packaging>war</packaging>



    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

1.启动类重写configure的方法

public class SpbootApplication extends SpringBootServletInitializer {
    @Override
    protected SpringApplicationBuilder configure(SpringApplicationBuilder builder) {
        // TODO Auto-generated method stub
        return builder.sources(SpbootApplication.class);
    }
    public static void main(String[] args) {
        SpringApplication.run(SpbootApplication.class, args);
    }
}

1.使用mvn celan package 打包

2. 将war包 放入到tomcat webapps下运行即可。

http://localhost:8080/spboot-0.0.1-SNAPSHOT/indexDev其中spboot-0.0.1-SNAPSHOT。

为包名

5.7.4 打包常见错误

代表你打包的时候没有指定主函数，在pom.xml文件中添加以下内容：

	<build>
		<plugins>
			<plugin>
				<groupId>org.apache.maven.plugins</groupId>
				<artifactId>maven-compiler-plugin</artifactId>
				<configuration>
					<source>1.8</source>
					<target>1.8</target>
				</configuration>
			</plugin>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
				<configuration>
					<mainClass>com.itboy.spboot.SpbootApplication</mainClass>
				</configuration>
				<executions>
					<execution>
						<goals>
							<goal>repackage</goal>
						</goals>
					</execution>
				</executions>

			</plugin>
		</plugins>
	</build>

5.8 Spring Boot整合拦截器

拦截器是AOP的一种实现，底层通过动态代理实现。

与过滤器区别：

（1）拦截器是基于Java反射机制，过滤器基于函数回调

（2）拦截器不依赖于Servlet容器，过滤器依赖于Servlet

（3）拦截器只能对controller请求起作用，而过滤器可以几乎对所有的请求起作用

（4）在controller的生命周期中，拦截器可以多次被调用，过滤器只能在容器初始化时被调用一次

场景：1、过滤器常用于设置编码字符、过滤敏感字符2、拦截器常用于拦截未登录用户、审计日志

创建拦截器：

@Slf4j
@Component
public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws IOException {
        log.info("开始拦截登录请求");
        String token=request.getParameter("token");
        if(StringUtils.isEmpty(token)){
            response.getWriter().write("not found token");
            return false;
         }
        return true;
    }
}

注册拦截器：

@Configuration
public class WebAppConfig {
    @Autowired
    private LoginInterceptor loginInterceptor;

    @Bean
    public WebMvcConfigurer webMvcConfigurer(){
        return new WebMvcConfigurer() {
            @Override
            public void addInterceptors(InterceptorRegistry registry) {
                registry.addInterceptor(loginInterceptor).addPathPatterns("/*");
            }
        };
    }
}

6 数据访问

6.1 springboot整合使用JdbcTemplate

添加依赖：

        <!--JdbcTemplate依赖-->

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

配置文件.yml：

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver

IndexController.java
@RestController//表示该类所有方法返回json格式，等价于@Controller@ResponseBody
@Slf4j
public class IndexController {
    @Autowired
    private IndexService indexService;

    @RequestMapping("/createUser")
    public String createUser(){
        int xiaoming = indexService.createUser("xiaoming", 23);
        return "success:"+xiaoming;
    }

}

IndexService.java
@Service
@Slf4j
public class IndexService {

    @Autowired
    private JdbcTemplate jdbcTemplate;
    public int createUser(String name,Integer age){
        int update = jdbcTemplate.update("insert into users (name,age) values (?,?);", name, age);
        return update;
    }

访问http://127.0.0.1:8080/createUser查看数据库是否创建成功以及页面是否正确响应。

6.2 Spring boot整合使用mybatis

添加依赖：

        <!--mybatis集成依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>

实体类：

@Data
public class User {
    private int id;
    private String name;
    private Integer age;
}

mapper类：

@Mapper
public interface UserMapper {
    //查询
    @Select("SELECT * FROM USERS WHERE NAME=#{name}")
    User findByName(@Param("name") String name);
    //添加
    @Insert("INSERT INTO USERS(NAME,AGE) VALUES (#{name},#{age})")
    int insert(@Param("name")String name,@Param("age")Integer age);
}

service类：

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;

    public User findByName(String name){
        return userMapper.findByName(name);
    }
    //添加
    public int insert(String name,Integer age){
        return userMapper.insert(name,age);
    }

}

controller类：

@RestController//表示该类所有方法返回json格式，等价于@Controller@ResponseBody
@Slf4j
public class IndexController {
    @Autowired
    private UserService userService;
    @RequestMapping("/getUser")
    public User findByName(@RequestParam("name") String name){
        return userService.findByName(name);
    }

    @RequestMapping("/addUser")
    public int addUser(@RequestParam("name") String name,@RequestParam("age") Integer age){
        return userService.insert(name,age);
    }

}

访问http://127.0.0.1:8080/addUser?name=xiaogou&age=23后再访问http://127.0.0.1:8080/getUser?name=xiaogou查看两次请求是否正确；

注意如果不想再mapper类中添加@Mapper注解，可以在启动类中天@MapperScan指定扫mapper包范围，多个以逗号隔开类似ComponentScan。两处必有一处需要添加。

6.3 mybatis整合分页插件pageHelper

PageHelper 是一款好用的开源免费的 Mybatis 第三方物理分页插件物理分页

支持常见的 12 种数据库。Oracle,MySql,MariaDB,SQLite,DB2,PostgreSQL,SqlServer 等

支持多种分页方式

支持常见的 RowBounds(PageRowBounds)，PageHelper.startPage 方法调用，Mapper 接口参数调用

添加依赖：

        <!--Spring boot整合pageHelper-->
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.5</version>
        </dependency>

 

配置文件application.yml：

server:
  port: 8080
  servlet:
    context-path: /
spring:
  datasource:
    url: jdbc:mysql://localhost:3306/test
    username: root
    password: root
    driver-class-name: com.mysql.jdbc.Driver

logging.level.com.example.demo.dao: DEBUG
pagehelper:
  helper-dialect: mysql
  reasonable: true
  support-methods-arguments: true
  params: count=countSql
  page-size-zero: true

mapper：

@Mapper
public interface UserMapper {
    //列表查询
    @Select("SELECT * FROM USERS")
    List<User> findUserList();
}

service：

@Service
public class UserService {
    @Autowired
    private UserMapper userMapper;
    //分页列表
    public List<User> findUserList(int page,int pageSize){
        //开启分页插件，放在查询语句上面
        PageHelper.startPage(page,pageSize);//因为不同数据库的分页语句不同，所以底层是通过改写SQL语句来实现分页的

        List<User> userList=userMapper.findUserList();//通过debug此时这里其实也只有两条数据
        //封装分页之后的数据
        PageInfo<User> userPageInfo=new PageInfo<>(userList);//这样只是返回的数据中包含一些分页参数而已，一般都是这种返回较好，这里为了简便
        return userList;
    }


}

controller：

@RestController
@Slf4j
public class IndexController {


    @Autowired
    private UserService userService;
    @RequestMapping("/listUsers")
    public List<User> listUser(@RequestParam("page") Integer page,
                               @RequestParam("pageSize") Integer pageSize){
        return userService.findUserList(page,pageSize);
    }

}

访问http://127.0.0.1:8080/listUsers?page=1&pageSize=2查看结果

6.4 springboot 整合使用Springjpa

这个东东其实就是通过封装hibernate得来的

添加依赖：


        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

实体类：

@Data
@Entity(name="users")//name表示数据库中对应的表名，默认为类名首字母小写，其他大写字母为下划线
public class UserEntity {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;
    @Column(name="name")//name=数据库中对应的列名，不写默认为成员变量名称，其他大写字母为下划线
    private String name;
    @Column(name = "age")
    private Integer age;
}

dao层：

public interface UserEntityRepository extends JpaRepository<UserEntity,Integer> {

}

controller：

@RestController
@Slf4j
public class IndexController {
    @Autowired
    private UserEntityRepository userEntityRepository;

    @RequestMapping("/jpaFindUser")
    public Object japIndex(UserEntity userEntity){
        Optional<UserEntity> userEntity1=userEntityRepository.findById(userEntity.getId());
        UserEntity userEntity2=userEntity1.get();
        return userEntity2==null?"没有找到用户":userEntity2;
    }
}

访问http://127.0.0.1:8080/jpaFindUser?id=25检查是否正确。

6.5 Spring Boot整合多数据源

在一个项目中有多个数据源（连接不同数据库jdbc），一般来说这个连接数是无线大的，不过具体还是根据主机内存大小来设定合适大小较好。

那我怎么划分呢？一般有两种：分包名（业务不同包名肯定不同嘛） |  注解方式（有点类似于mybatis中的多数据源，通过注解选择相应的数据源）。

这里主要以分包方式来实践一下。

主要依赖：

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

        <!--JdbcTemplate依赖-->

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>

        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </dependency>

        <!--mybatis集成依赖-->
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>

配置文件：

spring:
  datasource:
    #数据源1
    test2:
      jdbc-url: jdbc:mysql://localhost:3306/shiro?useSSL=false
      username: root
      password: root
      driver-class-name: com.mysql.jdbc.Driver
    #数据源2
    test1:
      jdbc-url: jdbc:mysql://localhost:3306/test?useSSL=false
      username: root
      password: root
      driver-class-name: com.mysql.jdbc.Driver

两个数据库shiro和test并且都有一个users表。

实体类，分别在test1包和test2都有

@Data
public class User {
    private int id;
    private String name;
    private Integer age;
}

mapper，分别在test1和test2下都有

public interface UserMapper2 {
    //查询
    @Select("SELECT * FROM USERS WHERE NAME=#{name}")
    User findByName(@Param("name") String name);
    //添加
    @Insert("INSERT INTO USERS(NAME,AGE) VALUES (#{name},#{age})")
    int insert(@Param("name") String name, @Param("age") Integer age);
    //列表查询
    @Select("SELECT * FROM USERS")
    List<User> findUserList();
}

service:也是test1和test2都有，这里仅展示一个

@Service
public class UserService2 {
    @Autowired
    private UserMapper2 userMapper;

    public User findByName(String name){
        return userMapper.findByName(name);
    }
    //添加
    public int insert(String name,Integer age){
        return userMapper.insert(name,age);
    }

    //分页列表
    public List<User> findUserList(int page,int pageSize){
        //开启分页插件，放在查询语句上面
        PageHelper.startPage(page,pageSize);//因为不同数据库的分页语句不同，所以底层是通过改写SQL语句来实现分页的

        List<User> userList=userMapper.findUserList();//通过debug此时这里其实也只有两条数据
        //封装分页之后的数据
        PageInfo<User> userPageInfo=new PageInfo<>(userList);//这样只是返回的数据中包含一些分页参数而已，一般都是这种返回较好，这里为了简便
        return userList;
    }


}

数据源1配置文件：

package com.itboy.spboot.datasource;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;


/**
 * @ClassName: Datasource1Config
 * @Description: 数据源1
 * @Version: v1.0
 * @Copyright: ilose自主开发
 **/
@Configuration
@MapperScan(basePackages  = "com.itboy.spboot.test1.mapper",sqlSessionFactoryRef = "test1SqlSessionFactory")
public class Datasource1Config {
    /**
     *  数据源1配置信息
     * @return
     */
    @Bean(name = "test1DataSource")
    @ConfigurationProperties(prefix = "spring.datasource.test1")
    public DataSource testDataSource(){
        return DataSourceBuilder.create().build();
    }

    /**
     * 数据源1会话工厂
     * @param dataSource
     * @return
     * @throws Exception
     */
    @Bean(name = "test1SqlSessionFactory")
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("test1DataSource" ) DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean=new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
//        bean.setMapperLocations(
//                new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper/test1/*.xml")
//        );
        return bean.getObject();
    }

    /**
     * 数据源1事务管理
     * @param dataSource
     * @return
     */
    @Bean(name = "test1TransactionManager")
    public DataSourceTransactionManager testDataSourceTransactionManager(@Qualifier("test1DataSource") DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }

    /**
     *
     * @param sqlSessionFactory
     * @return
     */
    @Bean(name = "test1SqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("test1SqlSessionFactory") SqlSessionFactory sqlSessionFactory){
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}

数据源2配置文件：

package com.itboy.spboot.datasource;

import org.apache.ibatis.session.SqlSessionFactory;
import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.SqlSessionTemplate;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.boot.jdbc.DataSourceBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;

import javax.sql.DataSource;

/**
 * @ClassName: Datasource1Config
 * @Description: 数据源1
 * @Version: v1.0
 * @Copyright: ilose自主开发
 **/
@Configuration
@MapperScan(basePackages  = "com.itboy.spboot.test2.mapper",sqlSessionFactoryRef = "test2SqlSessionFactory")
public class Datasource2Config {
    /**
     *  数据源2配置信息
     * @return
     */
    @Bean(name = "test2DataSource")
    @ConfigurationProperties(prefix = "spring.datasource.test2")
    public DataSource testDataSource(){
        return DataSourceBuilder.create().build();
    }

    /**
     * 数据源2会话工厂
     * @param dataSource
     * @return
     * @throws Exception
     */
    @Bean(name = "test2SqlSessionFactory")
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("test2DataSource" ) DataSource dataSource) throws Exception {
        SqlSessionFactoryBean bean=new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
//        bean.setMapperLocations(
//                new PathMatchingResourcePatternResolver().getResources("classpath:mybatis/mapper/test1/*.xml")
//        );
        return bean.getObject();
    }

    /**
     * 数据源1事务管理
     * @param dataSource
     * @return
     */
    @Bean(name = "test2TransactionManager")
    public DataSourceTransactionManager testDataSourceTransactionManager(@Qualifier("test2DataSource") DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }

    /**
     *
     * @param sqlSessionFactory
     * @return
     */
    @Bean(name = "test2SqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("test2SqlSessionFactory") SqlSessionFactory sqlSessionFactory){
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}

controller:

@RestController
@Slf4j
public class IndexController {

    @Autowired
    private UserService1 userService1;
    @RequestMapping("/multiDataSourceAdd")
    public int multiDataSourceAdd(){
        return userService1.insert("spring boot2.0",23);
    }

    @Autowired
    private UserService2 userService2;
    @RequestMapping("/multiDataSourceAdd2")
    public int multiDataSourceAdd2(){
        return userService2.insert("spring boot2.0",23);
    }
}

访问http://127.0.0.1:8080/multiDataSourceAdd和http://127.0.0.1:8080/multiDataSourceAdd2查看两个数据库是否添加陈宫。

听说在Spring boot1.5的时候要指定1个主数据源通过添加@Primary可解决。

6.5.1 注意事项

在多数据源的情况下，使用@Transactional注解时，应该指定事务管理者@Transactional(transactionManager = "test...")

7 事务管理

7.1 SpringBoot整合事物管理

Springboot默认集成事物,只主要在方法上加上@Transactional即可

在多数据源的情况下如下使用，否则会报错，单数据源直接使用@Transactional，在6.5的基础上试试添加age为0 的记录。

    //添加
    @Transactional(transactionManager = "test1TransactionManager")
    public int insert(String name,Integer age){
        int i=1/age;
        return userMapper.insert(name,age);
    }

7.2 spring boot解决分布式事务问题

7.2.1 怎么产生的？

以6.5的多数据源为例，如果添加数据的代码为以下代码：

@Service
public class UserService2 {
    @Autowired
    private UserMapper2 userMapper2;
    @Autowired
    private UserMapper1 userMapper1;

    //添加
    @Transactional(transactionManager = "test2TransactionManager")
    public int insertUser1AndInsertUser2(String name,Integer age){
        //第一个数据源
        int t1 = userMapper2.insert(name, age);
        //第二个数据源
        int t2 = userMapper1.insert(name, age);
        int i=1/age;
        return t1+t2;
    }

}

此时访问http://127.0.0.1:8080/multiDataSourceAdd2?name=springboot2.2&age=0会两条都添加成功吗？还是仅有一条（哪一条）?还是两条都失败？

真实情况是int t2 = userMapper1.insert(name, age);添加成功，而另一条失败。原因很简单，一个事务对应一个数据源嘛，那么这种情况怎么解决呢？

7.2.2 spring boot使用jta+atomikos 解决分布式事务问题（传统方式）

添加依赖：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jta-atomikos</artifactId>
        </dependency>

配置文件.yml

mysql:
  datasource:
    # Mysql 1
    test1:
      url: jdbc:mysql://localhost:3306/test?useSSL=false&useUnicode=true&characterEncoding=utf-8
      username: root
      password: root
      minPoolSize: 3
      maxPoolSize: 25
      maxLifetime: 20000
      borrowConnectionTimeout: 30
      loginTimeout: 30
      maintenanceInterval: 60
      maxIdleTime: 60
    # Mysql 2
    test2:
      url: jdbc:mysql://localhost:3306/shiro?useSSL=false&useUnicode=true&characterEncoding=utf-8
      username: root
      password: root
      minPoolSize: 3
      maxPoolSize: 25
      maxLifetime: 20000
      borrowConnectionTimeout: 30
      loginTimeout: 30
      maintenanceInterval: 60
      maxIdleTime: 60

读取配置文件类：

@Data
@ConfigurationProperties(prefix = "mysql.datasource.test1")
public class DB1Config {
    private String url;
    private String username;
    private String password;
    private int minPoolSize;
    private int maxPoolSize;
    private int maxLifetime;
    private int borrowConnectionTimeout;
    private int loginTimeout;
    private int maintenanceInterval;
    private int maxIdleTime;
    private String testQuery;
}



@Data
@ConfigurationProperties(prefix = "mysql.datasource.test2")
public class DB2Config {
    private String url;
    private String username;
    private String password;
    private int minPoolSize;
    private int maxPoolSize;
    private int maxLifetime;
    private int borrowConnectionTimeout;
    private int loginTimeout;
    private int maintenanceInterval;
    private int maxIdleTime;
    private String testQuery;
}

数据源配置类，很明显，这里没有任何事物管理器，和6.5有很大区别。因为这里是将本地事务注册到了atomikos全局事务了，所以是没有的

@Configuration
@MapperScan(basePackages = "com.itboy.spboot.test1.mapper",sqlSessionTemplateRef  = "testSqlSessionTemplate" )
public class MybatisConfig1 {
    // 配置数据源
    @Bean(name = "testDataSource")
    public DataSource testDataSource(DB1Config testConfig) throws SQLException {
        MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
        mysqlXaDataSource.setUrl(testConfig.getUrl());
        mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
        mysqlXaDataSource.setPassword(testConfig.getPassword());
        mysqlXaDataSource.setUser(testConfig.getUsername());
        mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);

        AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
        xaDataSource.setXaDataSource(mysqlXaDataSource);
        xaDataSource.setUniqueResourceName("testDataSource");

        xaDataSource.setMinPoolSize(testConfig.getMinPoolSize());
        xaDataSource.setMaxPoolSize(testConfig.getMaxPoolSize());
        xaDataSource.setMaxLifetime(testConfig.getMaxLifetime());
        xaDataSource.setBorrowConnectionTimeout(testConfig.getBorrowConnectionTimeout());
        xaDataSource.setLoginTimeout(testConfig.getLoginTimeout());
        xaDataSource.setMaintenanceInterval(testConfig.getMaintenanceInterval());
        xaDataSource.setMaxIdleTime(testConfig.getMaxIdleTime());
        xaDataSource.setTestQuery(testConfig.getTestQuery());
        return xaDataSource;
    }

    @Bean(name = "testSqlSessionFactory")
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("testDataSource") DataSource dataSource)
            throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        return bean.getObject();
    }

    @Bean(name = "testSqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(
            @Qualifier("testSqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}





@Configuration
@MapperScan(basePackages = "com.itboy.spboot.test2.mapper",sqlSessionTemplateRef  = "test2SqlSessionTemplate" )
public class MybatisConfig2 {
    // 配置数据源
    @Bean(name = "test2DataSource")
    public DataSource testDataSource(DB2Config testConfig) throws SQLException {
        MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
        mysqlXaDataSource.setUrl(testConfig.getUrl());
        mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
        mysqlXaDataSource.setPassword(testConfig.getPassword());
        mysqlXaDataSource.setUser(testConfig.getUsername());
        mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);

        //这里的意思就是将本地事务注册到Atomikos全局事务
        AtomikosDataSourceBean xaDataSource = new AtomikosDataSourceBean();
        xaDataSource.setXaDataSource(mysqlXaDataSource);
        xaDataSource.setUniqueResourceName("test2DataSource");

        xaDataSource.setMinPoolSize(testConfig.getMinPoolSize());
        xaDataSource.setMaxPoolSize(testConfig.getMaxPoolSize());
        xaDataSource.setMaxLifetime(testConfig.getMaxLifetime());
        xaDataSource.setBorrowConnectionTimeout(testConfig.getBorrowConnectionTimeout());
        xaDataSource.setLoginTimeout(testConfig.getLoginTimeout());
        xaDataSource.setMaintenanceInterval(testConfig.getMaintenanceInterval());
        xaDataSource.setMaxIdleTime(testConfig.getMaxIdleTime());
        xaDataSource.setTestQuery(testConfig.getTestQuery());
        return xaDataSource;
    }

    @Bean(name = "test2SqlSessionFactory")
    public SqlSessionFactory testSqlSessionFactory(@Qualifier("test2DataSource") DataSource dataSource)
            throws Exception {
        SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        bean.setDataSource(dataSource);
        return bean.getObject();
    }

    @Bean(name = "test2SqlSessionTemplate")
    public SqlSessionTemplate testSqlSessionTemplate(
            @Qualifier("test2SqlSessionFactory") SqlSessionFactory sqlSessionFactory) throws Exception {
        return new SqlSessionTemplate(sqlSessionFactory);
    }

}

通过在主类上添加@EnableConfigurationProperties(value = {DB1Config.class,DB2Config.class})注解运行，访问以下ip

http://127.0.0.1:8080/insertUser1AndInsertUser2?name=springboot2.2&age=0添加失败，表示分布式配置成功。这里注解掉6.5所配置的两个类，通过去掉

//@Configuration
//@MapperScan(basePackages  = "com.itboy.spboot.test2.mapper",sqlSessionFactoryRef = "test2SqlSessionFactory")

两个注解即可。

8 缓存支持

8.1 注解配置与EhCache使用

添加依赖：

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>

新建ehcache.xml文件：

<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
	updateCheck="false">
	<diskStore path="java.io.tmpdir/Tmp_EhCache" />

	<!-- 默认配置 -->
	<defaultCache maxElementsInMemory="5000" eternal="false"
		timeToIdleSeconds="120" timeToLiveSeconds="120"
		memoryStoreEvictionPolicy="LRU" overflowToDisk="false" />

	<cache name="baseCache" maxElementsInMemory="10000"
		maxElementsOnDisk="100000" />

 <!--  
	       name:缓存名称。  
	       maxElementsInMemory：缓存最大个数。  
	       eternal:对象是否永久有效，一但设置了，timeout将不起作用。  
	       timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。  
	       timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。  
	       overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。  
	       diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。  
	       maxElementsOnDisk：硬盘最大缓存个数。  
	       diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.  
	       diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。  
	       memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。  
	       clearOnFlush：内存数量最大时是否清除。  
	    --> 


</ehcache>

使用缓存：

@CacheConfig(cacheNames = "baseCache")
public interface UserMapper {
	@Select("select * from users where name=#{name}")
	@Cacheable
	UserEntity findName(@Param("name") String name);
}

清除缓存：

@Autowired
private CacheManager cacheManager;
@RequestMapping("/remoKey")
public void remoKey() {
	cacheManager.getCache("baseCache").clear();
}

启动类@EnableCaching // 开启缓存注解运行

9 热部署

9.1 热部署原理

所谓的热部署：比如项目的热部署，就是在应用程序在不停止的情况下，实现新的部署

其实底层就是使用类加载器（classloader）重新读取字节码文件到jvm内存。

怎么实现呢？1、监听class文件是否有发生改变（版本号或者最近修改时间）；2、当class文件发生改变时，使用classloader进行重新读取。

一般用于本地开发，提高开发效率，不需要重启服务器。

缺点：如果项目比较大，会非常卡--比较占内存

9.2 devtools

spring-boot-devtools 是一个为开发者服务的一个模块，其中最重要的功能就是自动应用代码更改到最新的App上面去。原理是在发现代码有更改之后，重新启动应用，但是速度比手动停止后再启动还要更快，更快指的不是节省出来的手工操作的时间。 

其深层原理是使用了两个ClassLoader，一个Classloader加载那些不会改变的类（第三方Jar包），另一个ClassLoader加载会更改的类，称为  restart ClassLoader  ,这样在有代码更改的时候，原来的restart ClassLoader 被丢弃，重新创建一个restart ClassLoader，由于需要加载的类相比较少，所以实现了较快的重启时间（5秒以内） 

当修改controller里面的代码，比如新增一个requestMapping时，他就会将其注册到MVC容器中，这样就相当于重启了嘛。

添加依赖：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
            <scope>true</scope>
        </dependency>

1. devtools会监听classpath下的文件变动，并且会立即重启应用（发生在保存时机），注意：因为其采用的虚拟机机制，该项重启是很快的。 

2. devtools可以实现页面热部署（即页面修改后会立即生效，这个可以直接在application.properties文件中配置spring.thymeleaf.cache=false来实现(这里注意不同的模板配置不一样)

10 2.0新特性

10.1 以Java8为基准

Spring Boot 2.0 要求Java 版本必须8以上， Java 6 和 7 不再支持。

10.2 内嵌容器包结构调整

为了支持reactive使用场景，内嵌的容器包结构被重构了的幅度有点大。EmbeddedServletContainer被重命名为WebServer，并且org.springframework.boot.context.embedded 包被重定向到了org.springframework.boot.web.embedded包下。举个例子，如果你要使用TomcatEmbeddedServletContainerFactory回调接口来自定义内嵌Tomcat容器，你现在应该使用TomcatServletWebServerFactory。

10.3 Servlet-specific 的server properties调整

Old property

New property

server.context-parameters.*

server.servlet.context-parameters.*

server.context-path

server.servlet.context-path

server.jsp.class-name

server.servlet.jsp.class-name

server.jsp.init-parameters.*

server.servlet.jsp.init-parameters.*

server.jsp.registered

server.servlet.jsp.registered

server.servlet-path

server.servlet.path

server不再是只有servlet了，还有其他的要加入。

10.4 Actuator 默认映射

Actuator的端点（endpoint）现在默认映射到/application，比如，/info 端点现在就是在/application/info。但你可以使用management.context-path来覆盖此默认值。

10.5 Spring Loaded不再支持

由于Spring Loaded项目已被移到了attic了，所以不再支持Spring Loaded了。现在建议你去使用Devtools。Spring Loaded不再支持了。

10.6 支持Quartz Scheduler

Spring Boot 2 针对Quartz调度器提供了支持。你可以加入spring-boot-starter-quartz starter来启用。而且支持基于内存和基于jdbc两种存储

10.7 支持Spring WebFlux

WebFlux 模块的名称是 spring-webflux，名称中的 Flux 来源于 Reactor 中的类 Flux。该模块中包含了对反应式 HTTP、服务器推送事件和 WebSocket 的客户端和服务器端的支持。对于开发人员来说，比较重要的是服务器端的开发。在服务器端，WebFlux 支持两种不同的编程模型：第一种是 Spring MVC 中使用的基于 Java 注解的方式；第二种是基于 Java 8 的 lambda 表达式的函数式编程模型。这两种编程模型只是在代码编写方式上存在不同。它们运行在同样的反应式底层架构之上，因此在运行时是相同的。WebFlux 需要底层提供运行时的支持，WebFlux 可以运行在支持 Servlet 3.1 非阻塞 IO API 的 Servlet 容器上，或是其他异步运行时环境，如 Netty 和 Undertow。

10.8 版本要求

Jetty

要求Jetty最低版本为9.4。

Tomcat

要求Tomcat最低版本为8.5。

Hibernate

要求Hibernate最低版本为5.2。

Gradle

要求Gradle最低版本为3.4。

SendGrid

SendGrid最低支持版本是3.2。为了支持这次升级，username和password已经被干掉了。因为API key现在是唯一支持的认证方式。

11 Spring boot监控中心

11.1 Springboot监控中心概述

Spring boot监控中心：针对微服务服务器监控，服务器内存变化（堆内存、线程、日志管理等）、检测服务配置连接地址是否可用（比如一些mysql、redis的配置，当懒加载的情况，就需要模拟请求去检测一下）、统计现在有多少个bean（Spring容器中的bean实例）、统计SpringMVC@RequestMapping（http接口）。

Actuator监控：没有界面、返回json格式

AdminUI：底层使用Actuator监控应用 ，实现可视化页面

应用场景：生产环境

为什么要有这个东西？

Actuator是Springboot的一个附加功能，可帮助你在应用程序生产环境时监视和管理应用程序。可以使用HTTP的各种请求来监管，审计，收集应用的运行情况，对于微服务管理十分有意义。缺点：没有可视化界面。

11.2 Actuator

默认情况下开启只开启三个接口，Spring boot2.0之后接口发生了变化，需要加一个/actuator，不过可以通过配置文件修改。

添加依赖：

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

配置文件：

#开启所有接口，默认情况下只有info、health、/三个
management:
  endpoints:
    web:
      exposure:
        include: "*"

启动应用后可以看到增加了很多/actuator/..这样的接口。

测试一下检测服务配置连接是否可用？新增一个mysql连接配置和依赖后，如果密码错误默认是懒加载形式，程序启动正常。但是通过访问http://localhost:8080/actuator/health这个接口后发现程序抛出异常返回{status:"down"}，说明模拟请求发送一个请求到mysql，而密码错误所以抛出异常，状态为down否则为up。

常用：

路径

作用

/actuator/beans

显示应用程序中所有Spring bean的完整列表。

/actuator/configprops

显示所有配置信息。

/actuator/env

陈列所有的环境变量。

/actuator/mappings

显示所有@RequestMapping的url整理列表。

/actuator/health

显示应用程序运行状况信息 up表示成功 down失败

/actuator/info

查看自定义应用信息，配置文件中以info开头的

11.3 AdminUI

11.3.1 原理

Admin-UI基于actuator实现能够返回界面展示监控信息。

1、服务1和服务2两个服务内部集成自己的Actualtor监控应用，比如开发哪些接口啊等等，之后将这些接口注册到AdminUI平台上进行展示。

2、或者 说对于服务1和服务2两个服务（类似于client），将他们的监控中心管理存放在AdminUI（类似于server）平台上。

这样当AdminUI平台要展示服务1或者2的时候，服务1/2通过Actuator发送一个json串（Actuator返回的就是json）给AdminUI，AdminUI解析这个json串然后再页面上进行展示。

11.3.2 搭建一个AdminUI server

添加依赖：

        <dependency>
            <groupId>de.codecentric</groupId>
            <artifactId>spring-boot-admin-starter-server</artifactId>
            <version>2.0.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-webflux</artifactId>
        </dependency>
        <!-- Spring Boot Actuator对外暴露应用的监控信息，Jolokia提供使用HTTP接口获取JSON格式 的数据 -->
        <dependency>
            <groupId>org.jolokia</groupId>
            <artifactId>jolokia-core</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>com.googlecode.json-simple</groupId>
            <artifactId>json-simple</artifactId>
            <version>1.1</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

配置文件：

spring:
  application:
    name: spring-boot-admin-server

启动类：

@Configuration
@EnableAutoConfiguration
@EnableAdminServer
public class AdminUiServerApplication {

    public static void main(String[] args) {
        SpringApplication.run(AdminUiServerApplication.class, args);
    }
}

访问http://localhost:8080检查是否成功。

11.3.3 搭建一个AdminUI client

添加依赖：

        <dependency>
            <groupId>de.codecentric</groupId>
            <artifactId>spring-boot-admin-starter-client</artifactId>
            <version>2.0.0</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
        <dependency>
            <groupId>org.jolokia</groupId>
            <artifactId>jolokia-core</artifactId>
        </dependency>
        <dependency>
            <groupId>com.googlecode.json-simple</groupId>
            <artifactId>json-simple</artifactId>
            <version>1.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>

配置文件：

spring:
  boot:
    admin:
      client:
        url: http://localhost:8080
server:
  port: 8081

management:
  endpoints:
    web:
      exposure:
        include: "*"
  endpoint:
    health:
      show-details: ALWAYS

启动类：

@SpringBootApplication
public class AdminUiClientApplication {

    public static void main(String[] args) {
        SpringApplication.run(AdminUiClientApplication.class, args);
    }
}

访问http://localhost:8081/actuator/health是否成功以及刷新http://localhost:8080后是否注册成功。

Logo
向您推荐>>Eolink开发者社区

权威｜前沿｜技术｜干货｜国内首个API全生命周期开发者社区

更多推荐

深入理解 Mocha 测试框架：从零实现一个 Mocha

前言什么是自动化测试自动化测试在很多团队中都是Devops环节中很难执行起来的一个环节，主要原因在于测试代码的编写工作很难抽象，99%的场景都需要和业务强绑定，而且写测试代码的编写工作量往往比编写实际业务代码的工作量更多。在一些很多业务场景中投入产出比很低，适合写自动化测试的应该是那些中长期业务以及一些诸如组件一样的基础库。自动化测试是个比较大的概念，其中分类也比较多，比如单元测试，端对端测试，集

avatar 云原生

ELK实现containerd的容器日志采集展示【基于logging的全栈监测】

企业级ELK Stack构建介绍

avatar 云原生

(20200916 Solved)docker-compose up创建容器自动退出

问题描述如题，创建容器后自动退出了。并且docker start container无效解决方案原因是缺失了控制终端的配置，需要在docker-compose.yml中增加tty:true ，有时候这样也不行，需要再增加一个command:/bin/bash，命令不一定是这个，需要是一个不会退出的命令，然后用-d后台启动容器。Referencesdocker-compose启动容器后自动退出...

avatar 云原生