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@EnableAutoConfigurationpublic 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")@EnableAutoConfigurationpublic class App { public static void main(String[] args) { SpringApplication.run(App.class, args); }}2.3 springboot启动方式3
@SpringBootApplication 被 @Configuration、@EnableAutoConfiguration、@ComponentScan 注解所修饰，换言之 Springboot 提供了统一的注解来替代以上三个注解
扫包范围：在启动类上加上@SpringBootApplication注解,当前包下或者子包下所有的类都可以扫到。
@SpringBootApplicationpublic 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=falsespring.freemarker.cache=truespring.freemarker.check-template-location=truespring.freemarker.charset=UTF-8spring.freemarker.content-type=text/htmlspring.freemarker.expose-request-attributes=falsespring.freemarker.expose-session-attributes=falsespring.freemarker.expose-spring-macro-helpers=false#spring.freemarker.prefix=#spring.freemarker.request-context-attribute=#spring.freemarker.settings.*=spring.freemarker.suffix=.ftlspring.freemarker.template-loader-path=classpath:/templates/#comma-separated list#spring.freemarker.view-names= # whitelist of view names that can be resolved3.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
@Controllerpublic 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,DEBUGlog4j.rootLogger=info,error,CONSOLE,DEBUGlog4j.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=infolog4j.appender.info=org.apache.log4j.DailyRollingFileAppenderlog4j.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-ddlog4j.appender.info.Threshold = info log4j.appender.info.append=true #log4j.appender.info.File=/home/admin/pms-api-services/logs/info/api_services_infolog4j.appender.info.File=/Users/dddd/Documents/testspace/pms-api-services/logs/info/api_services_infolog4j.logger.error=error log4j.appender.error=org.apache.log4j.DailyRollingFileAppenderlog4j.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-ddlog4j.appender.error.Threshold = error log4j.appender.error.append=true #log4j.appender.error.File=/home/admin/pms-api-services/logs/error/api_services_errorlog4j.appender.error.File=/Users/dddd/Documents/testspace/pms-api-services/logs/error/api_services_errorlog4j.logger.DEBUG=DEBUGlog4j.appender.DEBUG=org.apache.log4j.DailyRollingFileAppenderlog4j.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-ddlog4j.appender.DEBUG.Threshold = DEBUG log4j.appender.DEBUG.append=true #log4j.appender.DEBUG.File=/home/admin/pms-api-services/logs/debug/api_services_debuglog4j.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@Componentpublic 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@Datapublic 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对象，使用时用对应的注解，如：@Log45 简单但好用一些内容
5.1 使用@Scheduled创建定时任务
在Spring Boot主类中添加@EnableScheduling注解，启动定时任务的配置
然后声明定时任务：
@Component@Slf4jpublic 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@Slf4jpublic 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@Slf4jpublic 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=8080server.servlet.context-path=/spboot5.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@Componentpublic 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; }}注册拦截器：
@Configurationpublic 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.DriverIndexController.java@RestController//表示该类所有方法返回json格式，等价于@Controller@ResponseBody@Slf4jpublic class IndexController { @Autowired private IndexService indexService; @RequestMapping("/createUser") public String createUser(){ int xiaoming = indexService.createUser("xiaoming", 23); return "success:"+xiaoming; } } IndexService.java@Service@Slf4jpublic 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>实体类：
@Datapublic class User { private int id; private String name; private Integer age;}mapper类：
@Mapperpublic 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类：
@Servicepublic 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@Slf4jpublic 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: DEBUGpagehelper: helper-dialect: mysql reasonable: true support-methods-arguments: true params: count=countSql page-size-zero: true mapper：
@Mapperpublic interface UserMapper { //列表查询 @Select("SELECT * FROM USERS") List<User> findUserList();}service：
@Servicepublic 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@Slf4jpublic 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@Slf4jpublic 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都有
@Datapublic 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都有，这里仅展示一个
@Servicepublic 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@Slf4jpublic 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的多数据源为例，如果添加数据的代码为以下代码：
@Servicepublic 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);}清除缓存：
@Autowiredprivate 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@EnableAdminServerpublic 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:8080server: port: 8081 management: endpoints: web: exposure: include: "*" endpoint: health: show-details: ALWAYS启动类：
@SpringBootApplicationpublic class AdminUiClientApplication { public static void main(String[] args) { SpringApplication.run(AdminUiClientApplication.class, args); }}访问http://localhost:8081/actuator/health是否成功以及刷新http://localhost:8080后是否注册成功。
扫一扫
21万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
