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=/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
@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后是否注册成功。
21万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
