---
title: 微服务架构之 SpringBoot
date: 2019-04-04 18:17:48
categories:
- 应用框架
tags:
- 分布式
---

# 微服务架构之 SpringBoot

## 目录

- [简介](#简介)
- [快速入门](#快速入门)
- [正篇](#正篇)
- [参考链接](#参考链接)
- [结束语](#结束语)

## 简介

### `什么是SpringBoot`

```
SpringBoot是一个快速开发的框架,能够快速整合第三方框架,简化XML配置完全采用注解形式,内置Web服务器(Jetty和Tomcat),最终以java应用程序进行执行。
SpringBoot不是微服务框架。
```

### `为什么要用SpringBoot`

```
解决传统SSM项目的开发效率低、Jar冲突、配置多的问题。
```

### `与SpringMVC、SpringCloud之间的关系`

```
SpringCloud：
    是一套完整的微服务解决框架,采用Http+Json格式的通讯协议,底层依赖于SpringBoot框架(web组件集成springmvc),使用SpringMVC书写Http协议接口。
    采用SpringBoot+Dubbo也能实现微服务。
SpringMVC：
    SpringBoot默认集成了SpringMVC作为web层的框架。
总结：
    如果需要做微服务的话,就需要整合SpringBoot+SpringCloud;如果项目中不需要实现微服务,可以只单纯使用SpringBoot而不使用SpringCloud。
```

## 快速入门

1. 创建一个普通 maven 工程,packaging类型为jar(可省略)
2. pom文件中引入SpringBoot相关依赖
    ```
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.0.RELEASE</version>
    </parent>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
    </dependencies>
    ```
    ```
    spring-boot-starter-parent作用
        统一整合第三方框架依赖信息,以后再申明其它dependency的时候就不需要写版本号了。
    spring-boot-starter-web作用
        把传统方式的SpringMVC依赖的所有jar全部给下载下来,
    spring-boot-maven-plugin作用
        如果直接通过Main启动spring，那么以下plugin必须要添加，否则是无法启动的。如果使用maven 的spring-boot:run的话是不需要此配置的。
    ```
3. 编写helloworld服务
    ```
    package top.lvzhiqiang.controller;
    @RestController
    @EnableAutoConfiguration
    public class IndexController {
    
        @RequestMapping("/index")
        public String index(){
            return "hello springboot!";
        }
    
        public static void main(String[] args) {
            SpringApplication.run(IndexController.class,args);
        }
    }
    ```
    ```
    @RestController的作用
        表示该Controller下所有的方法返回JSON格式,可以直接编写Restful接口;省略了在方法上加上@ResponseBody。
        如果项目中的类加上了此注解,说明这个项目可能是一个微服务项目,需要统一接口,提供服务接口。
    @EnableAutoConfiguration的作用
        表示让Spring Boot根据添加的jar依赖来对Spring框架进行自动配置。
        由于spring-boot-starter-web添加了Tomcat和Spring MVC，所以auto-configuration将假定你正在开发一个web应用并相应地对Spring进行设置。
    @Configuration的作用
        底层含有@Component,标注在类上,相当于把该类作为spring的xml配置文件中的<beans>
        用来来配置spring容器(应用上下文)
    @Bean的作用
        标注在方法上(返回某个实例的方法),相当于spring的xml配置文件中的<bean>
        用来注册bean对象(实例化bean,并交给spring管理)
    ```
4. 启动应用
    ```
    方法1：
        直接启动main方法,main方法中指定IndexController为启动入口,默认端口号为8080。
    方法2：
        @ComponentScan(basePackages = "top.lvzhiqiang.controller")
        @EnableAutoConfiguration
        public class App {
        	public static void main(String[] args) {
        		SpringApplication.run(App.class, args);
        	}
        }
        单独写个类并使用@ComponentScan注解添加自动扫包范围。
    方法3：
        @SpringBootApplication
        public class App {
            public static void main(String[] args) {
                SpringApplication.run(App.class, args);
            }
        }
        单独写个类并使用@SpringBootApplication注解,等同于@ComponentScan + @EnableAutoConfiguration。
        扫包范围：当前包下或者子包下所有的类都可以扫到。
    ```

## 正篇

### Web开发

- `静态资源访问`
    ```
    在我们开发Web应用的时候，需要引用大量的js、css、图片等静态资源。
    Spring Boot默认提供静态资源目录位置需置于classpath(src/main/java或者src/main/resources)下，目录命名如下：
        static、public、resources、META-INF/resources
    ```
- `渲染Web页面`
    ```
    如果需要返回html等页面时,Spring Boot提供了多种模板引擎,来帮助我们很快的上手开发动态网站。
        Thymeleaf、FreeMarker、Velocity、Groovy、Mustache
    Spring Boot建议使用模板引擎(例如FreeMarker)，避免使用JSP，若一定要使用JSP将无法实现Spring Boot的多种特性。
        如果使用模板引擎,它们默认的模板配置路径为：src/main/resources/templates。当然也可以修改这个路径。
    ```
- `使用Freemarker模板引擎渲染Web视图`
    ```
    1.pom文件引入FreeMarker的依赖包
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-freemarker</artifactId>
        </dependency>
    2.在src/main/resources/创建一个templates文件夹,在templates下新建ftlIndex.ftl
        @Controller
        @EnableAutoConfiguration
        public class IndexController {
            @RequestMapping("/ftlIndex")
            public String ftlIndex(Model model) {
                model.addAttribute("name", "张三");
                model.addAttribute("sex", 1);
                List<String> userList = new ArrayList<>();
                userList.add("a");
                userList.add("b");
                userList.add("c");
                model.addAttribute("userList", userList);
                return "ftlIndex";
            }
            ...
        }
    3.在ftl文件中填充数据
        ${name}
        <#if sex == 1>男
        <#elseif sex == 2>女
        <#else>其他
        </#if>
        <#list userList as user>${user}
        </#list>
    4.新建src/main/resources/下新建application.properties文件进行Freemarker配置(可以不配置,采用默认)
        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
    ```
- `使用JSP渲染Web视图`
    ```
    1.pom文件引入Jsp相关的依赖包
        <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>
    2.新建src/main/resources/下新建application.properties文件进行Jsp配置
        spring.mvc.view.prefix=/WEB-INF/jsp/
        spring.mvc.view.suffix=.jsp
    3.在src/main/webapp下创建/WEB-INF/jsp/目录,并在jsp目录下新建jspIndex.jsp
        @Controller
        @EnableAutoConfiguration
        public class IndexController {
            @RequestMapping("/jspIndex")
            public String jspIndex() {
                return "jspIndex";
            }
            ...
        }
    4.如果找不到页面,可在pom文件中改为war类型项目
    ```
- `全局捕获异常`
    ```
    @ControllerAdvice(basePackages = "top.lvzhiqiang.controller")
    public class GlobalExceptionHandler {
        @ExceptionHandler(RuntimeException.class)
        @ResponseBody
        public Map<String, Object> exceptionHandler() {
            Map<String, Object> map = new HashMap<>();
            map.put("errorCode", "101");
            map.put("errorMsg", "系統错误!");
            return map;
        }
    }
    ```
    ```
    @ExceptionHandler表示拦截异常
    @ControllerAdvice是controller的一个辅助类，最常用的就是作为全局异常处理的切面类
        @ControllerAdvice可以指定扫描范围
        @ControllerAdvice约定了几种可行的返回值，如果是直接
            返回json，需要使用@ResponseBody进行json转换
            返回页面，返回值类型为ModelAndView或者String
    实际开发中,可在全局捕获异常中将异常日志信息写入nosql数据库中,如果是集群环境,可采用分布式日志收集系统(kafka,logstash等),方便排查
    ```

### 日志管理

1. `使用log4j记录日志`
    ```
    1.pom文件引入log4j相关的依赖包
        <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>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-log4j</artifactId>
            <version>1.3.8.RELEASE</version>
        </dependency>
    2.新建src/main/resources/下新建log4j.properties文件进行log4j配置
        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=D:\\log4j\\springbootdemo\\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=D:\\log4j\\springbootdemo\\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=D:\\log4j\\springbootdemo\\debug
    ```
2. `使用AOP统一处理Web请求日志`
    ```
    1.pom文件新增aop依赖
        <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-aop</artifactId>
        </dependency>
    2.aop代码
        @Aspect
        @Component
        public class WebLogAspect {
            private static final Logger logger = LoggerFactory.getLogger(WebLogAspect.class);
        
            @Pointcut("execution(public * top.lvzhiqiang.controller.*.*(..))")
            public void webLog() {
            }
        
            @Before("webLog()")
            public void doBefore(JoinPoint joinPoint) throws Throwable {
                // 接收到请求，记录请求内容
                ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
                HttpServletRequest request = attributes.getRequest();
                // 记录下请求内容
                logger.info("URL : " + request.getRequestURL().toString());
                logger.info("HTTP_METHOD : " + request.getMethod());
                logger.info("IP : " + request.getRemoteAddr());
                Enumeration<String> enu = request.getParameterNames();
                while (enu.hasMoreElements()) {
                    String name = (String) enu.nextElement();
                    logger.info("name:{},value:{}", name, request.getParameter(name));
                }
            }
        
            @AfterReturning(returning = "ret", pointcut = "webLog()")
            public void doAfterReturning(Object ret) throws Throwable {
                // 处理完请求，返回内容
                logger.info("RESPONSE : " + ret);
            }
        }
    ```
3. `Spring Boot集成lombok让代码更简洁`
    ```
    0.IDE开发工具需要先安装lombok插件(lombok底层使用asm字节码技术,在编译时修改字节码文件,来生成相应的set,get等相应方法)
    1.pom文件引入lombok相关的依赖包
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    2.实体类测试
        @Slf4j
        @Setter
        @Getter
        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: 自动生成set/get方法，toString方法，equals方法，hashCode方法，不带参数的构造方法
        @Setter/@Getter: 自动生成set和get方法 
        @ToString: 自动生成toString方法 
        @NonNull: 让你不在担忧并且爱上NullPointerException 
        @CleanUp: 自动资源管理,不用再在finally中添加资源的close方法 
        @EqualsAndHashcode: 从对象的字段中生成hashCode和equals的实现 
        @NoArgsConstructor/@RequiredArgsConstructor/@AllArgsConstructor: 自动生成构造方法
        @Value: 用于注解final类 
        @Builder: 产生复杂的构建器api类 
        @SneakyThrows: 异常处理（谨慎使用） 
        @Synchronized : 同步方法安全的转化 
        @Log: 支持各种logger对象，使用时用对应的注解，如：@Log4j
    ```
    
### 数据访问

- `整合mybatis`
    ```
    1.pom文件引入mybatis相关的依赖包
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.1.1</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.21</version>
        </dependency>
    2.修改application.properties
        spring.datasource.jdbc-url=jdbc:mysql://localhost:3306/test
        spring.datasource.username=root
        spring.datasource.password=root
        spring.datasource.driver-class-name=com.mysql.jdbc.Driver
    3.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);
        }
    4.在启动类上加上@MapperScan(basePackages = "top.lvzhiqiang.mapper")
        也可以在Mapper接口上加上@Mapper,不过这样比较繁琐
    ```
    ```
    Mybatis整合分页插件(pageHelper)
        PageHelper是一款好用的开源免费的Mybatis第三方物理分页插件
        支持常见的12种数据库。Oracle,MySql,MariaDB,SQLite,DB2,PostgreSQL,SqlServer等
        支持多种分页方式
        支持常见的 RowBounds(PageRowBounds)，PageHelper.startPage方法调用，Mapper接口参数调用
    ------------------
    1.添加maven依赖
        <dependency>
            <groupId>com.github.pagehelper</groupId>
            <artifactId>pagehelper-spring-boot-starter</artifactId>
            <version>1.2.5</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.7</version>
        </dependency>
    2.添加配置
        pagehelper.helperDialect=mysql
        pagehelper.reasonable=true
        pagehelper.supportMethodsArguments=true
        pagehelper.params=count=countSql
        pagehelper.page-size-zero=true
    3.service层
        public PageInfo<User> findUserList(int pageNo, int pageSize) {
            // 开启分页插件,放在查询语句上面
            PageHelper.startPage(pageNo, pageSize);
            List<User> listUser = userMapper.findUserList();
            // 封装分页之后的数据
            PageInfo<User> pageInfoUser = new PageInfo<User>(listUser);
            return pageInfoUser;
        }
        //以上方法上的公共代码可用模板设计模式或者aop思想抽出来
    ```
- `整合jdbcTemplate`
    ```
    1.pom文件引入jdbcTemplate相关的依赖包
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.21</version>
        </dependency>
    2.修改application.properties
        spring.datasource.jdbc-url=jdbc:mysql://localhost:3306/test
        spring.datasource.username=root
        spring.datasource.password=root
        spring.datasource.driver-class-name=com.mysql.jdbc.Driver
    3.代码
        @Service
        public class UserServiceImpl implements UserService {
        	@Autowired
        	private JdbcTemplate jdbcTemplate;
        	public void createUser(String name, Integer age) {
        		jdbcTemplate.update("insert into users values(null,?,?);", name, age);
        	}
        }
    ```
- `整合多数据源`
    ```
    1.修改application.properties新增两个数据源
        ###datasource1
        spring.datasource.test1.driver-class-name = com.mysql.jdbc.Driver
        spring.datasource.test1.jdbc-url = jdbc:mysql://localhost:3306/test01?useUnicode=true&characterEncoding=utf-8
        spring.datasource.test1.username = root
        spring.datasource.test1.password = root
        ###datasource2
        spring.datasource.test2.driver-class-name = com.mysql.jdbc.Driver
        spring.datasource.test2.jdbc-url = jdbc:mysql://localhost:3306/test02?useUnicode=true&characterEncoding=utf-8
        spring.datasource.test2.username = root
        spring.datasource.test2.password = root
    2.在top/lvzhiqiang/下新建datasource目录(任意),新建DataSourceConfig类,采用分包(业务)机制来读取不同的数据源
        //datasource1
        @Configuration
        @MapperScan(basePackages = "top.lvzhiqiang.user1", sqlSessionFactoryRef = "test1SqlSessionFactory")
        public class DataSource1Config {
            @Bean(name = "test1DataSource")
            @Primary
            @ConfigurationProperties(prefix = "spring.datasource.test1")
            public DataSource testDataSource() {
                return DataSourceBuilder.create().build();
            }
            @Bean(name = "test1SqlSessionFactory")
            @Primary
            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();
            }
            @Bean(name = "test1TransactionManager")
            @Primary
            public DataSourceTransactionManager testTransactionManager(@Qualifier("test1DataSource") DataSource dataSource) {
                return new DataSourceTransactionManager(dataSource);
            }
        
            @Bean(name = "test1SqlSessionTemplate")
            public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("test1SqlSessionFactory") SqlSessionFactory sqlSessionFactory)
                    throws Exception {
                return new SqlSessionTemplate(sqlSessionFactory);
            }
        }
        ------------------------------
        //datasource2
        @Configuration
        @MapperScan(basePackages = "top.lvzhiqiang.user2", sqlSessionFactoryRef = "test2SqlSessionFactory")
        public class DataSource2Config {
            @Bean(name = "test2DataSource")
            @ConfigurationProperties(prefix = "spring.datasource.test2")
            public DataSource testDataSource() {
                return DataSourceBuilder.create().build();
            }
            ...
        }
    3.创建分包Mapper
        public interface User1Mapper {
        	@Insert("insert into users values(null,#{name},#{age});")
        	public int addUser(@Param("name") String name, @Param("age") Integer age);
        }
    4.多数据源事务注意事项
        在多数据源的情况下，使用@Transactional注解时，应该指定事务管理器
        @Transactional(transactionManager = "test2TransactionManager")
    ```

### 事务管理

- `SpringBoot整合事物管理`
    ```
    springboot默认集成并开启事物,只要在方法上加上@Transactional即可
    ```
- `SpringBoot分布式事物管理`
    ```
    针对多数据源的分布式事务解决方案：jta+atomikos
    针对微服务的分布式事务解决方案：mq或者tcc等
    ```
    ```
    1.pom文件引入atomikos相关的依赖包
        <dependency>
        	<groupId>org.springframework.boot</groupId>
        	<artifactId>spring-boot-starter-jta-atomikos</artifactId>
        </dependency>
    2.新增多数据源配置信息,修改application.properties
        # Mysql 1
        mysql.datasource.test1.url = jdbc:mysql://localhost:3306/test01?useUnicode=true&characterEncoding=utf-8
        mysql.datasource.test1.username = root
        mysql.datasource.test1.password = root
        mysql.datasource.test1.minPoolSize = 3
        mysql.datasource.test1.maxPoolSize = 25
        mysql.datasource.test1.maxLifetime = 20000
        mysql.datasource.test1.borrowConnectionTimeout = 30
        mysql.datasource.test1.loginTimeout = 30
        mysql.datasource.test1.maintenanceInterval = 60
        mysql.datasource.test1.maxIdleTime = 60
        # Mysql 2
        mysql.datasource.test2.url =jdbc:mysql://localhost:3306/test02?useUnicode=true&characterEncoding=utf-8
        mysql.datasource.test2.username =root
        mysql.datasource.test2.password =root
        mysql.datasource.test2.minPoolSize = 3
        mysql.datasource.test2.maxPoolSize = 25
        mysql.datasource.test2.maxLifetime = 20000
        mysql.datasource.test2.borrowConnectionTimeout = 30
        mysql.datasource.test2.loginTimeout = 30
        mysql.datasource.test2.maintenanceInterval = 60
        mysql.datasource.test2.maxIdleTime = 60
    3.读取多数据源配置信息,可在top/lvzhiqiang/下新建config目录(任意),新建2个config类
        @Data
        @ConfigurationProperties(prefix = "mysql.datasource.test1")
        public class DBConfig1 {
        	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 DBConfig2 {
        	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;
        }
    4.将多数据源注册到atomikos中去,在top/lvzhiqiang/下新建datasource目录(任意),新建DataSourceConfig类
        @Configuration
        @MapperScan(basePackages = "top.lvzhiqiang.test01", sqlSessionTemplateRef = "testSqlSessionTemplate")
        public class MyBatisConfig1 {
        	@Primary
        	@Bean(name = "testDataSource")
        	public DataSource testDataSource(DBConfig1 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;
        	}
        	@Primary
        	@Bean(name = "testSqlSessionFactory")
        	public SqlSessionFactory testSqlSessionFactory(@Qualifier("testDataSource") DataSource dataSource)
        			throws Exception {
        		SqlSessionFactoryBean bean = new SqlSessionFactoryBean();
        		bean.setDataSource(dataSource);
        		return bean.getObject();
        	}
        	@Primary
        	@Bean(name = "testSqlSessionTemplate")
        	public SqlSessionTemplate testSqlSessionTemplate(@Qualifier("testSqlSessionFactory") SqlSessionFactory sqlSessionFactory)
        	        throws Exception {
        		return new SqlSessionTemplate(sqlSessionFactory);
        	}
        }
        ----------------------
        @Configuration
        @MapperScan(basePackages = "top.lvzhiqiang.test02", sqlSessionTemplateRef = "test2SqlSessionTemplate")
        public class MyBatisConfig2 {
        	@Bean(name = "test2DataSource")
        	public DataSource testDataSource(DBConfig2 testConfig) throws SQLException {
        		MysqlXADataSource mysqlXaDataSource = new MysqlXADataSource();
        		mysqlXaDataSource.setUrl(testConfig.getUrl());
        		mysqlXaDataSource.setPinGlobalTxToPhysicalConnection(true);
        		...
        	}
            ...
        }
    5.在启动类加上此注解以开启读取配置文件
        @EnableConfigurationProperties(value = { DBConfig1.class, DBConfig2.class })
    ```

### 监控管理

- `Actuator监控应用`
    ```
    什么是SpringBoot监控中心
        Actuator是spring boot的一个附加功能,可帮助你在应用程序生产环境时监视和管理应用程序。
        特别对于微服务管理十分有意义,缺点是没有可视化界面(返回json格式)。
        默认情况下,监控中心只提供3个接口权限。
        在SpringBoot2.0后,监控中心接口地址发生变化,需要在访问接口前面中上/actuator。
    主要用途
        针对微服务服务器监控,包括服务器的内存变化(堆内存、线程、日志管理等)
        检测服务配置连接地址(懒加载形式)是否可用(模拟访问)
        统计当前Spring容器中有多少个bean
        统计SpringMVC有多少个@RuquestMapping(http接口)
    应用场景
        生产环境
    ```
    ```
    1.添加maven依赖
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>
    2.yml配置
        ###通过下面的配置启用所有的监控端点，默认情况下，这些端点是禁用的
        management:
            endpoints:
                web:
                    exposure:
                        include: "*"
    3.开始访问(通过actuator/+端点名就可以获取相应的信息)
        /actuator/beans	显示应用程序中所有Spring bean的完整列表。
        /actuator/mappings	显示所有@RequestMapping的url完整列表。
        /actuator/configprops	显示所有配置信息。
        /actuator/env	显示所有的环境变量。
        /actuator/health	显示应用程序运行状况信息,up表示成功,down失败。
        /actuator/info	查看自定义应用信息(显示在配置文件配置info开头的配置信息)     
    ```
- `Admin-UI分布式微服务监控中心`
    - Admin-UI底层基于actuator实现能够返回界面展示监控信息,原理是将所有服务的监控中心管理存放在admin-ui平台上。
    ---
    ```
    Admin-UI-Server
    --------------------
    1.添加maven依赖
        <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>
        <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>
    2.yml配置
        spring:
            application:
                name: spring-boot-admin-server
    3.启动server端
        @Configuration
        @EnableAutoConfiguration
        @EnableAdminServer
        public class AdminServerApplication {
        	public static void main(String[] args) {
        		SpringApplication.run(AdminServerApplication.class, args);
        	}
        }
    4.访问
        http://localhost:8080
    ```
    ```
    Admin-UI-Client
    --------------------
    1.添加maven依赖
        <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>
    2.yml配置
        spring:
            boot:
                admin:
                    client:
                        url: http://localhost:8080    ###配置client端注册到admin-ui平台
        server:
            port: 8081
        management:
            endpoints:
                web:
                    exposure:
                        include: "*"
                endpoint:
                    health:
                        show-details: ALWAYS
    3.启动client端
        @SpringBootApplication
        public class AppClient {
        	public static void main(String[] args) {
        		SpringApplication.run(AppClient.class, args);
        	}
        }
    ```

### 性能优化

- `JVM参数调优(运行优化)`
    ```
    -Xms和-Xmx最好设置成一样,不然会频繁造成GC
    外部运行调优使用：java -server -Xms32m -Xmx32m  -jar springboot.jar
    ```
- `扫包优化(启动优化,非运行优化)`
    ```
    针对大项目时不要用@SpringBootApplication注解,会扫描到无用的包,可以采用@ComponentScan来扫描指定的包
    ```
- `将Servlet容器变成Undertow`
    ```
    默认情况下，Spring Boot 使用 Tomcat 来作为内嵌的 Servlet 容器,可以将 Web 服务器切换到 Undertow 来提高应用性能。
        Undertow 是一个采用 Java 开发的灵活的高性能 Web 服务器，提供包括阻塞和基于NIO的非堵塞机制。
        Undertow 是红帽公司的开源产品，是 Wildfly 默认的 Web 服务器。
    可用jmeter作吞吐量测试,结果是tomcat吞吐量为5000,undertow为8000
    ```
    ```
    1.从依赖信息里移除Tomcat
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-starter-tomcat</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    2.添加Undertow依赖
        <dependency>
        	<groupId>org.springframework.boot</groupId>
        	<artifactId>spring-boot-starter-undertow</artifactId>
        </dependency>
    ```

### 其他内容

- `使用@Scheduled创建定时任务`
    ```
    在启动类中加入@EnableScheduling注解，启用定时任务的配置
    -------------------
    @Component
    public class ScheduledTasks {
        private static final SimpleDateFormat dateFormat = new SimpleDateFormat("HH:mm:ss");
        @Scheduled(fixedRate = 5000)
        public void reportCurrentTime() {
            System.out.println("现在时间：" + dateFormat.format(new Date()));
        }
    }
    ```
- `使用@Async异步执行方法`
    ```
    在启动类加上@EnableAsync来开启异步调用,并在需要执行异步的方法上加上@Async
        @Async注解使用AOP技术在运行时创建一个单线程来执行这个方法
    ```
- `使用@Value自定义参数`
    ```
    application.properties文件
        name=lvzhiqiang.top
    代码中
    	@Value("${name}")
    	private String name;
        @ResponseBody
    	@RequestMapping("/getValue")
    	public String getValue() {
    		return name;
    	}
    ```
- `区分不同环境配置文件`
    ```
    1.在src/main/resources下新建各个环境的配置文件
        application-dev.properties：开发环境
        application-uat.properties：测试环境
        application-pre.properties：生产环境
    2.在application.properties中进行切换
        spring.profiles.active=uat
    ```
- `修改端口号`
    ```
    server.port=8888
    server.context-path=/springbootdemo
    ```
- `Spring Boot yml 使用`
    ```
    SpringBoot默认读取application.yml|properties
    YML比properties配置文件更加简约（结构）
    ---------------
    server:
      port: 8081
      context-path: /springbootdemo
    ```
- `发布打包`
    ```
    jar类型打包方式
        1.使用mvn celan  package 打包
        2.使用java –jar 包名
    war类型打包方式
        1.使用mvn celan  package 打包
        2.将war包放入到tomcat webapps下运行即可
        注意:springboot2.0内置tomcat8.5.25，建议使用外部Tomcat9.0版本运行即可,否则报错版本不兼容。
    ```
    ```
    如果执行java -jar命令提示没有主清单属性时,可在pom文件中新增如下代码
        <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>top.lvzhiqiang.StartApp</mainClass>
                    </configuration>
                    <executions>
                        <execution>
                            <goals>
                                <goal>repackage</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    ```
- `热部署`
    ```
    1.什么是热部署
        在应用程序不停止的情况下，实现新的部署
    2.热部署原理
        使用类加载器重新读取字节码文件到JVM中去
    3.纯手写实现一个热部署功能
        监听class文件是否发生改变(版本号或者修改时间),如果class文件发生改变,就使用classloader进行得新读取
    4.优缺点
        适合本地开发,提高运行效率,不用重启服务器;缺点是项目比较大时,非常卡,比较占内存.
    ```
    ```
    1.引入devtools依赖
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <optional>true</optional>
            <scope>true</scope>
        </dependency>
    2.Devtools原理
        1.devtools会监听classpath下的文件变动，并且会立即重启应用（发生在保存时机），注意：因为其采用的虚拟机机制，该项重启是很快的。  
        2.devtools可以实现页面热部署（即页面修改后会立即生效，这个可以直接在application.properties文件中配置spring.thymeleaf.cache=false来实现(这里注意不同的模板配置不一样) 
    3.不推荐使用
    ```
- `整合拦截器`
    ```
    1.创建拦截器
        @Slf4j
        @Component
        //创建模拟登录拦截器，验证请求是否有token参数
        public class LoginIntercept implements HandlerInterceptor {
            public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
                    throws Exception {
                log.info("开始拦截登录请求....");
                String token = request.getParameter("token");
                if (StringUtils.isEmpty(token)) {
                    response.getWriter().println("not found token");
                    return false;
                }
                return true;
            }
        }
    2.注册拦截器
        @Configuration
        public class WebAppConfig {
        	@Autowired
        	private LoginIntercept loginIntercept;
        	@Bean
        	public WebMvcConfigurer WebMvcConfigurer() {
        		return new WebMvcConfigurer() {
        			public void addInterceptors(InterceptorRegistry registry) {
        				registry.addInterceptor(loginIntercept).addPathPatterns("/*");
        			};
        		};
        	}
        }
    ```
    ```
    拦截器与过滤器区别
        拦截器是AOP( Aspect-Oriented Programming)的一种实现，底层通过动态代理模式完成。
        （1）拦截器是基于java的反射机制的，而过滤器是基于函数回调。
        （2）拦截器不依赖于servlet容器，而过滤器依赖于servlet容器。
        （3）拦截器只能对Controller请求起作用，而过滤器则可以对几乎所有的请求起作用。
        （4）在Controller的生命周期中，拦截器可以多次被调用，而过滤器只能在容器初始化时被调用一次。
    过滤器应用场景:设置编码字符、过滤铭感字符
    拦截器应用场景:拦截未登陆用户、审计日志
    ```
    
### 2.0版本新特性

- `以Java 8 为基准`
    ```
    Spring Boot 2.0 要求 Java 版本必须 8 以上， Java 6 和 7 不再支持。
    ```
- `内嵌容器包结构调整`
    ```
    为了支持reactive使用场景，内嵌的容器包结构被重构了的幅度有点大。EmbeddedServletContainer被重命名为WebServer，
    并且org.springframework.boot.context.embedded 包被重定向到了org.springframework.boot.web.embedded包下。
    举个例子，如果你要使用TomcatEmbeddedServletContainerFactory回调接口来自定义内嵌Tomcat容器，你现在应该使用TomcatServletWebServerFactory。
    ```
- `Servlet-specific 的server properties调整`
    ```
    大量的Servlet专属的server.* properties被移到了server.servlet下：
        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了，还有其他的要加入。
    ```
- `Actuator 默认映射`
    ```
    actuator的端点（endpoint）现在默认映射到/application，比如，/info 端点现在就是在/application/info。但你可以使用management.context-path来覆盖此默认值。
    ```
- `Spring Loaded不再支持`
    ```
    由于Spring Loaded项目已被移到了attic了，所以不再支持Spring Loaded了。现在建议你去使用Devtools。Spring Loaded不再支持了。
    ```
- `支持Quartz Scheduler`
    ```
    Spring Boot 2.0针对Quartz调度器提供了支持。你可以加入spring-boot-starter-quartz starter来启用。而且支持基于内存和基于jdbc两种存储。
    ```
- `OAuth 2.0 支持`
    ```
    Spring Security OAuth 项目中的功能将会迁移到Spring Security中。将会OAuth 2.0。
    ```
- `支持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。
    ```
- `版本要求`
    ```
    Jetty
        要求Jetty最低版本为9.4。
    Tomcat
        要求Tomcat最低版本为8.5。
    Hibernate
        要求Hibernate最低版本为5.2。
    Gradle
        要求Gradle最低版本为3.4。
    SendGrid
        SendGrid最低支持版本是3.2。为了支持这次升级，username和password已经被干掉了。因为API key现在是唯一支持的认证方式。
    ```
    
### 手写springboot框架

- springboot核心原理
    ```
    基于springmvc无配置文件完全注解化(纯java)+内置tomcat-embed-core来实现springboot框架,main函数启动
    快速整合第三方框架
        原理:Maven继承依赖关系
    完全无配置文件采用注解化
        原理:使用java代码(spring3内置注解)来对springmvc容器进行初始化
    内置web服务器
        原理:Java提供内置Tomcat容器框架,使用java语言创建并操作tomcat容器,加载class文件
    ```
- 内置web服务器
    ```
    1.添加pom依赖
        <!--Java语言操作tomcat -->
        <dependency>
            <groupId>org.apache.tomcat.embed</groupId>
            <artifactId>tomcat-embed-core</artifactId>
            <version>8.5.16</version>
        </dependency>
        <!-- spring-web -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-web</artifactId>
            <version>5.0.4.RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <!-- spring-mvc -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>5.0.4.RELEASE</version>
            <scope>compile</scope>
        </dependency>
        <!-- tomcat对jsp支持 -->
        <dependency>
            <groupId>org.apache.tomcat</groupId>
            <artifactId>tomcat-jasper</artifactId>
            <version>8.5.16</version>
        </dependency>
    2.创建servlet类
        public class IndexServet extends HttpServlet {
        	@Override
        	protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        		doPost(req, resp);
        	}
        	@Override
        	protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        		resp.getWriter().print("springboot2.0");
        	}
        }
    3.创建tomcat运行
        private static int PORT = 8080;// 端口号
        private static String CONTEXTPATH = "/demo";// 项目名称
    
        public static void main(String[] args) throws LifecycleException {
            // 创建Tomcat服务器
            Tomcat tomcatServer = new Tomcat();
            // 设置Tomcat端口号
            tomcatServer.setPort(PORT);
            tomcatServer.getHost().setAutoDeploy(false);
            // 创建Context上下文
            StandardContext standardContext = new StandardContext();
            standardContext.setPath(CONTEXTPATH);
            standardContext.addLifecycleListener(new FixContextListener());
            // tomcat容器添加standardContext
            tomcatServer.getHost().addChild(standardContext);
            // 创建servlet
            tomcatServer.addServlet(CONTEXTPATH, "IndexServet", new IndexServet());
            // 添加servleturl映射
            standardContext.addServletMappingDecoded("/index", "IndexServet");
            tomcatServer.start();
            tomcatServer.getServer().await();
        }
    ```
- 完全无配置文件采用注解化
    ```
    1.加载SpringMVC的DispatcherServlet
        AbstractAnnotationConfigDispatcherServletInitializer这个类负责配置DispatcherServlet、初始化Spring MVC容器和Spring容器。
        getRootConfigClasses()方法用于获取Spring应用容器的配置文件，这里我们给定预先定义的RootConfig.class；
        getServletConfigClasses负责获取Spring MVC应用容器，这里传入预先定义好的WebConfig.class；
        getServletMappings()方法负责指定需要由DispatcherServlet映射的路径，这里给定的是"/"，意思是由DispatcherServlet处理所有向该应用发起的请求。
        
        public class SpittrWebAppInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {
        	// 加载根容器
        	protected Class<?>[] getRootConfigClasses() {
        		return new Class[] { RootConfig.class };
        	}
            // 加载SpringMVC容器
        	protected Class<?>[] getServletConfigClasses() {
        		return new Class[] { WebConfig.class };
        	}
        	// SpringMVCDispatcherServlet 拦截的请求
        	protected String[] getServletMappings() {
        		return new String[] { "/" };
        	}
        }
    2.加载SpringMVC容器
        @Configuration
        @EnableWebMvc
        @ComponentScan("top.lvzhiqiang.controller")
        public class WebConfig extends WebMvcConfigurerAdapter {
            // 创建SpringMVC视图解析器
        	@Bean
        	public ViewResolver viewResolver() {
        		InternalResourceViewResolver viewResolver = new InternalResourceViewResolver();
        		viewResolver.setPrefix("/WEB-INF/views/");
        		viewResolver.setSuffix(".jsp");
        		viewResolver.setExposeContextBeansAsAttributes(true);//可以在JSP页面中通过${}访问beans
        		return viewResolver;
        	}
        }
    3.加载RootConfig容器
        @Configuration
        @ComponentScan(basePackages = "top.lvzhiqiang")
        public class RootConfig {
        }
    4.运行
        public static void main(String[] args) throws ServletException, LifecycleException {
            start();
        }
        public static void start() throws ServletException, LifecycleException {
            // 创建Tomcat容器
            Tomcat tomcatServer = new Tomcat();
            // 端口号设置
            tomcatServer.setPort(9090);
            // 读取项目路径,主要用来加载一些静态资源
            StandardContext ctx = (StandardContext) tomcatServer.addWebapp("/", new File("src/main").getAbsolutePath());
            // 禁止重新载入
            ctx.setReloadable(false);
            // class文件读取地址
            File additionWebInfClasses = new File("target/classes");
            // 创建WebRoot
            WebResourceRoot resources = new StandardRoot(ctx);
            // tomcat内部读取Class执行
            resources.addPreResources(new DirResourceSet(resources, "/WEB-INF/classes", additionWebInfClasses.getAbsolutePath(), "/"));
            tomcatServer.start();
            // 异步等待请求执行
            tomcatServer.getServer().await();
        }
    ```

## 参考链接

## 结束语

- 未完待续...