Spring-Boot基础教程

比眉伴天荒 2022-12-23 11:11 161阅读 0赞

# Spring-Boot 1.x版本 #

传送门：[https://gitee.com/didispace/SpringBoot-Learning/tree/master/1.x][https_gitee.com_didispace_SpringBoot-Learning_tree_master_1.x]

## 快速入门 ##

> 提示：我们在学习Spring Boot、Spring Cloud的时候，一定要知道它们的版本关系，以避免不必要的困恼。

### [Spring Cloud Alibaba与Spring Boot、Spring Cloud之间不得不说的版本关系][Spring Cloud Alibaba_Spring Boot_Spring Cloud] ###

### [基本项目构建（可作为工程脚手架），引入web模块，完成一个简单的RESTful API][web_RESTful API] ###

### [使用Intellij中的Spring Initializr来快速构建Spring Boot/Cloud工程][Intellij_Spring Initializr_Spring Boot_Cloud] ###

## 工程配置 ##

### [配置文件详解：自定义属性、随机数、多环境配置等][Link 1] ###

我们在Spring Boot使用过程中，最直观的感受就是没有了原来自己整合Spring应用时繁多的XML配置内容，替代它的是在`pom.xml`中引入模块化的`Starter POMs`，其中各个模块都有自己的默认配置，所以如果不是特殊应用场景，就只需要在`application.properties`中完成一些属性配置就能开启各模块的应用。

## Web开发 ##

### [构建一个较为复杂的RESTful API以及单元测试][RESTful API] ###

*  `@Controller`：修饰class，用来创建处理http请求的对象
 *  `@RestController`：Spring4之后加入的注解，原来在`@Controller`中返回json需要`@ResponseBody`来配合，如果直接用`@RestController`替代`@Controller`就不需要再配置`@ResponseBody`，默认返回json格式。
 *  `@RequestMapping`：配置url映射
 *  `@RequestBody`：请求体内容
 *  `@ModelAttribute`
 *  `@RequestParam`：用于将请求参数区数据映射到功能处理方法的参数上
 *  `@PathVariable`：绑定URL模板变量值

### [使用Thymeleaf模板引擎渲染web视图][Thymeleaf_web] ###

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

*  Thymeleaf
 *  FreeMarker
 *  Velocity
 *  Groovy
 *  Mustache

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

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

### [使用Swagger2构建RESTful API][Swagger2_RESTful API] ###

#### 添加Swagger2依赖 ####

在`pom.xml`中加入Swagger2的依赖

<dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger2</artifactId>
        <version>2.2.2</version>
    </dependency>
    <dependency>
        <groupId>io.springfox</groupId>
        <artifactId>springfox-swagger-ui</artifactId>
        <version>2.2.2</version>
    </dependency>

#### 创建Swagger2配置类 ####

在`Application.java`同级创建Swagger2的配置类`Swagger2`。

@Configuration
    @EnableSwagger2
    public class Swagger2 {
    
        @Bean
        public Docket createRestApi() {
            return new Docket(DocumentationType.SWAGGER_2)
                    .apiInfo(apiInfo())
                    .select()
                    .apis(RequestHandlerSelectors.basePackage("com.didispace.web"))
                    .paths(PathSelectors.any())
                    .build();
        }
    
        private ApiInfo apiInfo() {
            return new ApiInfoBuilder()
                    .title("Spring Boot中使用Swagger2构建RESTful APIs")
                    .description("更多Spring Boot相关文章请关注：http://blog.didispace.com/")
                    .termsOfServiceUrl("http://blog.didispace.com/")
                    .contact("测试人")
                    .version("1.0")
                    .build();
        }
    
    }

如上代码所示，通过`@Configuration`注解，让Spring来加载该类配置。再通过`@EnableSwagger2`注解来启用Swagger2。

再通过`createRestApi`函数创建`Docket`的Bean之后，`apiInfo()`用来创建该Api的基本信息（这些基本信息会展现在文档页面中）。`select()`函数返回一个`ApiSelectorBuilder`实例用来控制哪些接口暴露给Swagger来展现，本例采用指定扫描的包路径来定义，Swagger会扫描该包下所有Controller定义的API，并产生文档内容（除了被`@ApiIgnore`指定的请求）。

#### 添加文档内容 ####

在完成了上述配置后，其实已经可以生产文档内容，但是这样的文档主要针对请求本身，而描述主要来源于函数等命名产生，对用户并不友好，我们通常需要自己增加一些说明来丰富文档内容。如下所示，我们通过`@ApiOperation`注解来给API增加说明、通过`@ApiImplicitParams`、`@ApiImplicitParam`注解来给参数增加说明。

@RestController
    @RequestMapping(value="/users")     // 通过这里配置使下面的映射都在/users下，可去除
    public class UserController {
    
        static Map<Long, User> users = Collections.synchronizedMap(new HashMap<Long, User>());
    
        @ApiOperation(value="更新用户详细信息", notes="根据url的id来指定更新对象，并根据传过来的user信息来更新用户详细信息")
        @ApiImplicitParams({
                @ApiImplicitParam(name = "id", value = "用户ID", required = true, dataType = "Long"),
                @ApiImplicitParam(name = "user", value = "用户详细实体user", required = true, dataType = "User")
        })
        @RequestMapping(value="/{id}", method=RequestMethod.PUT)
        public String putUser(@PathVariable Long id, @RequestBody User user) {
            User u = users.get(id);
            u.setName(user.getName());
            u.setAge(user.getAge());
            users.put(id, u);
            return "success";
        }
    
    }

完成上述代码添加上，启动Spring Boot程序，访问：[http://localhost:8080/swagger-ui.html][http_localhost_8080_swagger-ui.html]。

### [统一异常处理][Link 2] ###

我们只需要在Controller中抛出Exception，当然我们可能会有多种不同的Exception。然后在@ControllerAdvice类中，根据抛出的具体Exception类型匹配@ExceptionHandler中配置的异常类型来匹配错误映射和处理。

当我们要实现RESTful API时，返回的错误是JSON格式的数据，而不是HTML页面，这时候我们也能轻松支持。本质上，只需在`@ExceptionHandler`之后加入`@ResponseBody`，就能让处理函数return的内容转换为JSON格式。

### [使用Java 8中LocalDate等时间日期类的问题解决][Java 8_LocalDate] ###

### [扩展XML请求和响应的支持][XML] ###

**第一步：引入Xml消息转换器**

在Spring Boot应用只需要加入`jackson-dataformat-xml`依赖，Spring Boot就会自动引入`MappingJackson2XmlHttpMessageConverter`的实现：

<dependency>
        <groupId>com.fasterxml.jackson.dataformat</groupId>
        <artifactId>jackson-dataformat-xml</artifactId>
    </dependency>

同时，为了配置Xml数据与维护对象属性的关系所要使用的注解也在上述依赖中，所以这个依赖也是必须的。

**第二步：定义对象与Xml的关系**

做好了基础扩展之后，下面就可以定义Xml内容对应的Java对象了，比如：

@Data
    @NoArgsConstructor
    @AllArgsConstructor
    @JacksonXmlRootElement(localName = "User")
    public class User {
    
        @JacksonXmlProperty(localName = "name")
        private String name;
        @JacksonXmlProperty(localName = "age")
        private Integer age;
    
    }

其中：`@Data`、`@NoArgsConstructor`、`@AllArgsConstructor`是lombok简化代码的注解，主要用于生成get、set以及构造函数。`@JacksonXmlRootElement`、`@JacksonXmlProperty`注解是用来维护对象属性在xml中的对应关系。

上述配置的User对象，其可以映射的Xml样例如下（后续可以使用上述xml来请求接口）：

**第三步：创建接收xml请求的接口**

完成了要转换的对象之后，可以编写一个接口来接收xml并返回xml，比如：

@Controller
    public class UserController {
    
        @PostMapping(value = "/user", 
            consumes = MediaType.APPLICATION_XML_VALUE, 
            produces = MediaType.APPLICATION_XML_VALUE)
        @ResponseBody
        public User create(@RequestBody User user) {
            user.setName("didispace.com : " + user.getName());
            user.setAge(user.getAge() + 100);
            return user;
        }
    
    }

## 数据访问 ##

### [使用JdbcTemplate][JdbcTemplate] ###

### [使用Spring-data-jpa简化数据访问层（推荐）][Spring-data-jpa] ###

### [多数据源配置（一）：JdbcTemplate][JdbcTemplate 1] ###

### [多数据源配置（二）：Spring-data-jpa][JdbcTemplate 1] ###

### [使用NoSQL数据库（一）：Redis][NoSQL_Redis] ###

#### 引入依赖 ####

Spring Boot提供的数据访问框架Spring Data Redis基于Jedis。可以通过引入`spring-boot-starter-redis`来配置依赖关系。

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

> 注意不同版本的spring boot下，redis的starter依赖名略有不同，如果上面的不行，可以尝试`spring-boot-starter-data-redis`

#### 参数配置 ####

按照惯例在`application.properties`中加入Redis服务端的相关配置，具体说明如下：

# REDIS (RedisProperties)
    # Redis数据库索引（默认为0）
    spring.redis.database=0
    # Redis服务器地址
    spring.redis.host=localhost
    # Redis服务器连接端口
    spring.redis.port=6379
    # Redis服务器连接密码（默认为空）
    spring.redis.password=
    # 连接池最大连接数（使用负值表示没有限制）
    spring.redis.pool.max-active=8
    # 连接池最大阻塞等待时间（使用负值表示没有限制）
    spring.redis.pool.max-wait=-1
    # 连接池中的最大空闲连接
    spring.redis.pool.max-idle=8
    # 连接池中的最小空闲连接
    spring.redis.pool.min-idle=0
    # 连接超时时间（毫秒）
    spring.redis.timeout=0

**其中spring.redis.database的配置通常使用0即可，Redis在配置的时候可以设置数据库数量，默认为16，可以理解为数据库的schema**

### [使用NoSQL数据库（二）：MongoDB][NoSQL_MongoDB] ###

#### 引入依赖 ####

Spring Boot中可以通过在`pom.xml`中加入`spring-boot-starter-data-mongodb`引入对mongodb的访问支持依赖。它的实现依赖`spring-data-mongodb`。是的，您没有看错，又是`spring-data`的子项目，之前介绍过`spring-data-jpa`、`spring-data-redis`，对于mongodb的访问，`spring-data`也提供了强大的支持，下面就开始动手试试吧。

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

#### 快速开始使用Spring-data-mongodb ####

若MongoDB的安装配置采用默认端口，那么在自动配置的情况下，我们不需要做任何参数配置，就能马上连接上本地的MongoDB。下面直接使用`spring-data-mongodb`来尝试对mongodb的存取操作。（记得mongod启动您的mongodb）

#### 参数配置 ####

通过上面的例子，我们可以轻而易举的对MongoDB进行访问，但是实战中，应用服务器与MongoDB通常不会部署于同一台设备之上，这样就无法使用自动化的本地配置来进行使用。这个时候，我们也可以方便的配置来完成支持，只需要在application.properties中加入mongodb服务端的相关配置，具体示例如下：

spring.data.mongodb.uri=mongodb://name:pass@localhost:27017/test

*在尝试此配置时，记得在mongo中对test库创建具备读写权限的用户（用户名为name，密码为pass），不同版本的用户创建语句不同，注意查看文档做好准备工作*

若使用mongodb 2.x，也可以通过如下参数配置，该方式不支持mongodb 3.x。

spring.data.mongodb.host=localhost spring.data.mongodb.port=27017

### [整合MyBatis][MyBatis] ###

*  `pom.xml`中引入依赖
    
     *  这里用到spring-boot-starter基础和spring-boot-starter-test用来做单元测试验证数据访问
     *  引入连接mysql的必要依赖mysql-connector-java
     *  引入整合MyBatis的核心依赖mybatis-spring-boot-starter
     *  这里不引入spring-boot-starter-jdbc依赖，是由于mybatis-spring-boot-starter中已经包含了此依赖
        
            <parent>
            	<groupId>org.springframework.boot</groupId>
            	<artifactId>spring-boot-starter-parent</artifactId>
            	<version>1.3.2.RELEASE</version>
            	<relativePath/> 
            </parent>
            
            <dependencies>
            
            	<dependency>
            		<groupId>org.springframework.boot</groupId>
            		<artifactId>spring-boot-starter</artifactId>
            	</dependency>
            
            	<dependency>
            		<groupId>org.springframework.boot</groupId>
            		<artifactId>spring-boot-starter-test</artifactId>
            		<scope>test</scope>
            	</dependency>
            
            	<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>
            
            </dependencies>
 *  同之前介绍的使用jdbc和spring-data连接数据库一样，在`application.properties`中配置mysql的连接配置

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

同其他Spring Boot工程一样，简单且简洁的的完成了基本配置，下面看看如何在这个基础下轻松方便的使用MyBatis访问数据库。

#### 使用MyBatis ####

*  在Mysql中创建User表，包含id(BIGINT)、name(INT)、age(VARCHAR)字段。同时，创建映射对象User

public class User {
    
        private Long id;
        private String name;
        private Integer age;
    
        // 省略getter和setter
    
    }

*  创建User映射的操作UserMapper，为了后续单元测试验证，实现插入和查询操作

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

*  创建Spring Boot主类

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

*  创建单元测试
    
     *  测试逻辑：插入一条name=AAA，age=20的记录，然后根据name=AAA查询，并判断age是否为20
     *  测试结束回滚数据，保证测试单元每次运行的数据环境独立

@RunWith(SpringJUnit4ClassRunner.class)
    @SpringApplicationConfiguration(classes = Application.class)
    public class ApplicationTests {
    
    	@Autowired
    	private UserMapper userMapper;
    
    	@Test
    	@Rollback
    	public void findByName() throws Exception {
    		userMapper.insert("AAA", 20);
    		User u = userMapper.findByName("AAA");
    		Assert.assertEquals(20, u.getAge().intValue());
    	}
    
    }

### [MyBatis注解配置详解][MyBatis 1] ###

#### 传参方式 ####

下面通过几种不同传参方式来实现前文中实现的插入操作。

##### 使用@Param #####

在之前的整合示例中我们已经使用了这种最简单的传参方式，如下：

@Insert("INSERT INTO USER(NAME, AGE) VALUES(#{name}, #{age})")
    int insert(@Param("name") String name, @Param("age") Integer age);

这种方式很好理解，`@Param`中定义的`name`对应了SQL中的`#{name}`，`age`对应了SQL中的`#{age}`。

##### 使用Map #####

如下代码，通过Map<String, Object>对象来作为传递参数的容器：

@Insert("INSERT INTO USER(NAME, AGE) VALUES(#{name,jdbcType=VARCHAR}, #{age,jdbcType=INTEGER})")
    int insertByMap(Map<String, Object> map);

对于Insert语句中需要的参数，我们只需要在map中填入同名的内容即可，具体如下面代码所示：

Map<String, Object> map = new HashMap<>();
    map.put("name", "CCC");
    map.put("age", 40);
    userMapper.insertByMap(map);

##### 使用对象 #####

除了Map对象，我们也可直接使用普通的Java对象来作为查询条件的传参，比如我们可以直接使用User对象:

@Insert("INSERT INTO USER(NAME, AGE) VALUES(#{name}, #{age})")
    int insertByUser(User user);

这样语句中的`#{name}`、`#{age}`就分别对应了User对象中的`name`和`age`属性。

#### 增删改查 ####

MyBatis针对不同的数据库操作分别提供了不同的注解来进行配置，在之前的示例中演示了`@Insert`，下面针对User表做一组最基本的增删改查作为示例：

public interface UserMapper {
    
        @Select("SELECT * FROM user WHERE name = #{name}")
        User findByName(@Param("name") String name);
    
        @Insert("INSERT INTO user(name, age) VALUES(#{name}, #{age})")
        int insert(@Param("name") String name, @Param("age") Integer age);
    
        @Update("UPDATE user SET age=#{age} WHERE name=#{name}")
        void update(User user);
    
        @Delete("DELETE FROM user WHERE id =#{id}")
        void delete(Long id);
    }

在完成了一套增删改查后，不妨我们试试下面的单元测试来验证上面操作的正确性：

@RunWith(SpringJUnit4ClassRunner.class)
    @SpringApplicationConfiguration(classes = Application.class)
    @Transactional
    public class ApplicationTests {
    
    	@Autowired
    	private UserMapper userMapper;
    
    	@Test
    	@Rollback
    	public void testUserMapper() throws Exception {
    		// insert一条数据，并select出来验证
    		userMapper.insert("AAA", 20);
    		User u = userMapper.findByName("AAA");
    		Assert.assertEquals(20, u.getAge().intValue());
    		// update一条数据，并select出来验证
    		u.setAge(30);
    		userMapper.update(u);
    		u = userMapper.findByName("AAA");
    		Assert.assertEquals(30, u.getAge().intValue());
    		// 删除这条数据，并select验证
    		userMapper.delete(u.getId());
    		u = userMapper.findByName("AAA");
    		Assert.assertEquals(null, u);
    	}
    }

#### 返回结果的绑定 ####

对于增、删、改操作相对变化较小。而对于“查”操作，我们往往需要进行多表关联，汇总计算等操作，那么对于查询的结果往往就不再是简单的实体对象了，往往需要返回一个与数据库实体不同的包装类，那么对于这类情况，就可以通过`@Results`和`@Result`注解来进行绑定，具体如下：

@Results({
        @Result(property = "name", column = "name"),
        @Result(property = "age", column = "age")
    })
    @Select("SELECT name, age FROM user")
    List<User> findAll();

在上面代码中，@Result中的property属性对应User对象中的成员名，column对应SELECT出的字段名。

### [使用Flyway来管理数据库版本][Flyway] ###

### [使用LDAP来统一管理用户信息][LDAP] ###

### [Spring Boot中增强对MongoDB的配置（连接池等）][Spring Boot_MongoDB] ###

## 事务管理 ##

### [使用事务管理][Link 3] ###

#### 使用 ####

在开发业务逻辑时，我们通常在service层接口中使用`@Transactional`来对各个业务逻辑进行事务管理的配置，例如：

public interface UserService {
        
        @Transactional
        User login(String name, String password);
        
    }

#### 隔离级别 ####

隔离级别是指若干个并发的事务之间的隔离程度，与我们开发时候主要相关的场景包括：脏读取、重复读、幻读。

我们可以看`org.springframework.transaction.annotation.Isolation`枚举类中定义了五个表示隔离级别的值：

public enum Isolation {
        DEFAULT(-1),
        READ_UNCOMMITTED(1),
        READ_COMMITTED(2),
        REPEATABLE_READ(4),
        SERIALIZABLE(8);
    }

*  `DEFAULT`：这是默认值，表示使用底层数据库的默认隔离级别。对大部分数据库而言，通常这值就是：`READ_COMMITTED`。
 *  `READ_UNCOMMITTED`：该隔离级别表示一个事务可以读取另一个事务修改但还没有提交的数据。该级别不能防止脏读和不可重复读，因此很少使用该隔离级别。
 *  `READ_COMMITTED`：该隔离级别表示一个事务只能读取另一个事务已经提交的数据。该级别可以防止脏读，这也是大多数情况下的推荐值。
 *  `REPEATABLE_READ`：该隔离级别表示一个事务在整个过程中可以多次重复执行某个查询，并且每次返回的记录都相同。即使在多次查询之间有新增的数据满足该查询，这些新增的记录也会被忽略。该级别可以防止脏读和不可重复读。
 *  `SERIALIZABLE`：所有的事务依次逐个执行，这样事务之间就完全不可能产生干扰，也就是说，该级别可以防止脏读、不可重复读以及幻读。但是这将严重影响程序的性能。通常情况下也不会用到该级别。

指定方法：通过使用`isolation`属性设置，例如：

@Transactional(isolation = Isolation.DEFAULT)

#### 传播行为 ####

所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。

我们可以看`org.springframework.transaction.annotation.Propagation`枚举类中定义了6个表示传播行为的枚举值：

public enum Propagation {
        REQUIRED(0),
        SUPPORTS(1),
        MANDATORY(2),
        REQUIRES_NEW(3),
        NOT_SUPPORTED(4),
        NEVER(5),
        NESTED(6);
    }

*  `REQUIRED`：如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务。
 *  `SUPPORTS`：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行。
 *  `MANDATORY`：如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常。
 *  `REQUIRES_NEW`：创建一个新的事务，如果当前存在事务，则把当前事务挂起。
 *  `NOT_SUPPORTED`：以非事务方式运行，如果当前存在事务，则把当前事务挂起。
 *  `NEVER`：以非事务方式运行，如果当前存在事务，则抛出异常。
 *  `NESTED`：如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行；如果当前没有事务，则该取值等价于`REQUIRED`。

指定方法：通过使用`propagation`属性设置，例如：

@Transactional(propagation = Propagation.REQUIRED)

## 定时任务与异步回调 ##

### [使用@Scheduled创建定时任务][Scheduled] ###

#### 创建定时任务 ####

在Spring Boot中编写定时任务是非常简单的事，下面通过实例介绍如何在Spring Boot中创建定时任务，实现每过5秒输出一下当前时间。

*  在Spring Boot的主类中加入`@EnableScheduling`注解，启用定时任务的配置

@SpringBootApplication
    @EnableScheduling
    public class Application {
    
    	public static void main(String[] args) {
    		SpringApplication.run(Application.class, args);
    	}
    
    }

*  创建定时任务实现类

@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()));
        }
    
    }

#### @Scheduled详解 ####

在上面的入门例子中，使用了`@Scheduled(fixedRate = 5000)` 注解来定义每过5秒执行的任务，对于`@Scheduled`的使用可以总结如下几种方式：

*  `@Scheduled(fixedRate = 5000)` ：上一次开始执行时间点之后5秒再执行
 *  `@Scheduled(fixedDelay = 5000)` ：上一次执行完毕时间点之后5秒再执行
 *  `@Scheduled(initialDelay=1000, fixedRate=5000)` ：第一次延迟1秒后执行，之后按fixedRate的规则每5秒执行一次
 *  `@Scheduled(cron="*/5 * * * * *")` ：通过cron表达式定义规则

### [使用@Async实现异步调用][Async] ###

在Spring Boot中，我们只需要通过使用`@Async`注解就能简单的将原来的同步函数变为异步函数；为了让@Async注解能够生效，还需要在Spring Boot的主程序中配置`@EnableAsync`。

**注： @Async所修饰的函数不要定义为static类型，这样异步调用不会生效**

那么我们如何判断上述三个异步调用是否已经执行完成呢？我们需要使用`Future<T>`来返回异步调用的结果，就像如下方式改造`doTaskOne`函数：

@Async
    public Future<String> doTaskOne() throws Exception {
        System.out.println("开始做任务一");
        long start = System.currentTimeMillis();
        Thread.sleep(random.nextInt(10000));
        long end = System.currentTimeMillis();
        System.out.println("完成任务一，耗时：" + (end - start) + "毫秒");
        return new AsyncResult<>("任务一完成");
    }

然后通过isDone()判断执行完成

Future<String> task1 = task.doTaskOne();
    task1.isDone()

### [使用@Async实现异步调用：自定义线程池][Async 1] ###

#### 定义线程池 ####

第一步，先在Spring Boot主类中定义一个线程池，比如：

@SpringBootApplication
    public class Application {
    
        public static void main(String[] args) {
            SpringApplication.run(Application.class, args);
        }
    
        @EnableAsync
        @Configuration
        class TaskPoolConfig {
    
            @Bean("taskExecutor")
            public Executor taskExecutor() {
                ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
                executor.setCorePoolSize(10);
                executor.setMaxPoolSize(20);
                executor.setQueueCapacity(200);
                executor.setKeepAliveSeconds(60);
                executor.setThreadNamePrefix("taskExecutor-");
                executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
                return executor;
            }
        }
    
    }

上面我们通过使用`ThreadPoolTaskExecutor`创建了一个线程池，同时设置了以下这些参数：

*  核心线程数10：线程池创建时候初始化的线程数
 *  最大线程数20：线程池最大的线程数，只有在缓冲队列满了之后才会申请超过核心线程数的线程
 *  缓冲队列200：用来缓冲执行任务的队列
 *  允许线程的空闲时间60秒：当超过了核心线程出之外的线程在空闲时间到达之后会被销毁
 *  线程池名的前缀：设置好了之后可以方便我们定位处理任务所在的线程池
 *  线程池对拒绝任务的处理策略：这里采用了`CallerRunsPolicy`策略，当线程池没有处理能力的时候，该策略会直接在 execute 方法的调用线程中运行被拒绝的任务；如果执行程序已关闭，则会丢弃该任务

#### 使用线程池 ####

在定义了线程池之后，我们如何让异步调用的执行任务使用这个线程池中的资源来运行呢？方法非常简单，我们只需要在`@Async`注解中指定线程池名即可，比如：

@Slf4j
    @Component
    public class Task {
    
        public static Random random = new Random();
    
        @Async("taskExecutor")
        public void doTaskOne() throws Exception {
            log.info("开始做任务一");
            long start = System.currentTimeMillis();
            Thread.sleep(random.nextInt(10000));
            long end = System.currentTimeMillis();
            log.info("完成任务一，耗时：" + (end - start) + "毫秒");
        }
    }

### [使用@Async实现异步调用：资源优雅关闭][Async 2] ###

Spring的`ThreadPoolTaskScheduler`为我们提供了相关的配置，只需要加入如下设置即可：

@Bean("taskExecutor")
    public Executor taskExecutor() {
        ThreadPoolTaskScheduler executor = new ThreadPoolTaskScheduler();
        executor.setPoolSize(20);
        executor.setThreadNamePrefix("taskExecutor-");
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setAwaitTerminationSeconds(60);
        return executor;
    }

说明：`setWaitForTasksToCompleteOnShutdown（true）`该方法就是这里的关键，用来设置线程池关闭的时候等待所有任务都完成再继续销毁其他的Bean，这样这些异步任务的销毁就会先于Redis线程池的销毁。同时，这里还设置了`setAwaitTerminationSeconds(60)`，该方法用来设置线程池中任务的等待时间，如果超过这个时候还没有销毁就强制销毁，以确保应用最后能够被关闭，而不是阻塞住。

### [使用@Async实现异步调用：使用Future以及定义超时][Async_Future] ###

**Tips：什么是Future类型？**

`Future`是对于具体的`Runnable`或者`Callable`任务的执行结果进行取消、查询是否完成、获取结果的接口。必要时可以通过get方法获取执行结果，该方法会阻塞直到任务返回结果。

它的接口定义如下：

public interface Future<V> {
        boolean cancel(boolean mayInterruptIfRunning);
        boolean isCancelled();
        boolean isDone();
        V get() throws InterruptedException, ExecutionException;
        V get(long timeout, TimeUnit unit)
            throws InterruptedException, ExecutionException, TimeoutException;
    }

它声明这样的五个方法：

*  cancel方法用来取消任务，如果取消任务成功则返回true，如果取消任务失败则返回false。参数mayInterruptIfRunning表示是否允许取消正在执行却没有执行完毕的任务，如果设置true，则表示可以取消正在执行过程中的任务。如果任务已经完成，则无论mayInterruptIfRunning为true还是false，此方法肯定返回false，即如果取消已经完成的任务会返回false；如果任务正在执行，若mayInterruptIfRunning设置为true，则返回true，若mayInterruptIfRunning设置为false，则返回false；如果任务还没有执行，则无论mayInterruptIfRunning为true还是false，肯定返回true。
 *  isCancelled方法表示任务是否被取消成功，如果在任务正常完成前被取消成功，则返回 true。
 *  isDone方法表示任务是否已经完成，若任务完成，则返回true；
 *  get()方法用来获取执行结果，这个方法会产生阻塞，会一直等到任务执行完毕才返回；
 *  get(long timeout, TimeUnit unit)用来获取执行结果，如果在指定时间内，还没获取到结果，就直接返回null。

也就是说Future提供了三种功能：

1.  判断任务是否完成；
2.  能够中断任务；
3.  能够获取任务执行结果。

## 日志管理 ##

### [默认日志的配置][Link 4] ###

#### 多彩输出 ####

如果你的终端支持ANSI，设置彩色输出会让日志更具可读性。通过在`application.properties`中设置`spring.output.ansi.enabled`参数来支持。

*  NEVER：禁用ANSI-colored输出（默认项）
 *  DETECT：会检查终端是否支持ANSI，是的话就采用彩色输出（推荐项）
 *  ALWAYS：总是使用ANSI-colored格式输出，若终端不支持的时候，会有很多干扰信息，不推荐使用

#### 文件输出 ####

Spring Boot默认配置只会输出到控制台，并不会记录到文件中，但是我们通常生产环境使用时都需要以文件方式记录。

若要增加文件输出，需要在`application.properties`中配置`logging.file`或`logging.path`属性。

*  logging.file，设置文件，可以是绝对路径，也可以是相对路径。如：`logging.file=my.log`
 *  logging.path，设置目录，会在该目录下创建spring.log文件，并写入日志内容，如：`logging.path=/var/log`

**日志文件会在10Mb大小的时候被截断，产生新的日志文件，默认级别为：ERROR、WARN、INFO**

#### 级别控制 ####

在Spring Boot中只需要在`application.properties`中进行配置完成日志记录的级别控制。

配置格式：`logging.level.*=LEVEL`

*  `logging.level`：日志级别控制前缀，`*`为包名或Logger名
 *  `LEVEL`：选项TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF

举例：

*  `logging.level.com.didispace=DEBUG`：`com.didispace`包下所有class以DEBUG级别输出
 *  `logging.level.root=WARN`：root日志以WARN级别输出

#### 自定义日志配置 ####

由于日志服务一般都在ApplicationContext创建前就初始化了，它并不是必须通过Spring的配置文件控制。因此通过系统属性和传统的Spring Boot外部配置文件依然可以很好的支持日志控制和管理。

根据不同的日志系统，你可以按如下规则组织配置文件名，就能被正确加载：

*  Logback：`logback-spring.xml`, `logback-spring.groovy`, `logback.xml`, `logback.groovy`
 *  Log4j：`log4j-spring.properties`, `log4j-spring.xml`, `log4j.properties`, `log4j.xml`
 *  Log4j2：`log4j2-spring.xml`, `log4j2.xml`
 *  JDK (Java Util Logging)：`logging.properties`

**Spring Boot官方推荐优先使用带有-spring的文件名作为你的日志配置（如使用logback-spring.xml，而不是logback.xml）**

#### 自定义输出格式 ####

在Spring Boot中可以通过在`application.properties`配置如下参数控制输出格式：

*  logging.pattern.console：定义输出到控制台的样式（不支持JDK Logger）
 *  logging.pattern.file：定义输出到文件的样式（不支持JDK Logger）

### [使用log4j记录日志][log4j] ###

### [对log4j进行多环境不同日志级别的控制][log4j 1] ###

### [使用AOP统一处理Web请求日志][AOP_Web] ###

### [使用log4j记录日志到MongoDB][log4j_MongoDB] ###

### [Spring Boot 1.5.x新特性：动态修改日志级别][Spring Boot 1.5.x] ###

## 安全管理 ##

### [使用Spring Security][Spring Security] ###

## 缓存支持 ##

### **[注解配置与EhCache使用][EhCache]** ###

### [使用Redis做集中式缓存][Redis] ###

## 邮件发送 ##

### [实现邮件发送：简单邮件、附件邮件、嵌入资源的邮件、模板邮件][Link 5] ###

## 消息服务 ##

### [Spring Boot中使用RabbitMQ][Spring Boot_RabbitMQ] ###

## 其他功能 ##

### [使用Spring StateMachine框架实现状态机][Spring StateMachine] ###

### [Spring Boot Actuator监控端点小结][Spring Boot Actuator] ###

### [在传统Spring应用中使用spring-boot-actuator模块提供监控端点][Spring_spring-boot-actuator] ###

### [Spring Boot应用的后台运行配置][Spring Boot] ###

### [Spring Boot自定义Banner][Spring Boot_Banner] ###

# Spring-Boot 2.x版本 #

传送门：[https://gitee.com/didispace/SpringBoot-Learning/tree/master/2.1.x][https_gitee.com_didispace_SpringBoot-Learning_tree_master_2.1.x]

## 基础知识 ##

### [快速入门][Link 6] ###

IDEA可以使用intellij idea

*  `src/main/java`下的程序入口：`xxxxApplication`
 *  `src/main/resources`下的配置文件：`application.properties`
 *  `src/test/`下的测试入口：`xxxxApplicationTests`
 *  `pom.xml`中是项目依赖
    
        项目元数据：创建时候输入的Project Metadata部分，也就是Maven项目的基本元素，包括：groupId、artifactId、version、name、description等
        
        parent：继承`spring-boot-starter-parent`的依赖管理，控制版本与打包等内容
        
        dependencies：项目具体依赖，这里包含了`spring-boot-starter-web`用于实现HTTP接口（该依赖中包含了Spring MVC）；`spring-boot-starter-test`用于编写单元测试的依赖包。更多功能模块的使用我们将在后面的教程中逐步展开。
        
        build：构建配置部分。默认使用了`spring-boot-maven-plugin`，配合`spring-boot-starter-parent`就可以把Spring Boot应用打包成JAR来直接运行。

#### 编写一个HTTP接口 ####

*  创建`HelloController`类，内容如下：

@RestController
    public class HelloController {
    
        @RequestMapping("/hello")
        public String index() {
            return "Hello World";
        }
    
    }

### [工程结构推荐][Link 7] ###

以下结构是比较推荐的package组织方式：

*  `root package`：`com.example.myproject`，所有的类和其他package都在root package之下。
 *  应用主类：`Application.java`，该类直接位于`root package`下。通常我们会在应用主类中做一些框架配置扫描等配置，我们放在root package下可以帮助程序减少手工配置来加载到我们希望被Spring加载的内容
 *  `com.example.myproject.domain`包：用于定义实体映射关系与数据访问相关的接口和实现
 *  `com.example.myproject.service`包：用于编写业务逻辑相关的接口与实现
 *  `com.example.myproject.web`：用于编写Web层相关的实现，比如：Spring MVC的Controller等

### [配置文件详解][Link 8] ###

## Web开发 ##

### [构建RESTful API与单元测试][RESTful API 1] ###

一些参数的意思

*  `@Controller`：修饰class，用来创建处理http请求的对象
 *  `@RestController`：Spring4之后加入的注解，原来在`@Controller`中返回json需要`@ResponseBody`来配合，如果直接用`@RestController`替代`@Controller`就不需要再配置`@ResponseBody`，默认返回json格式
 *  `@RequestMapping`：配置url映射。现在更多的也会直接用以Http Method直接关联的映射注解来定义，比如：`GetMapping`、`PostMapping`、`DeleteMapping`、`PutMapping`等

定义User实体

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

这里使用`@Data`注解可以实现在编译器自动添加set和get函数的效果。只需要在pom中引入加入下面的依赖就可以支持，`@NoArgsConstructor`为类提供一个无参构造函数，`@AllArgsConstructor`为类提供一个全参数构造函数：

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

### [使用Swagger2构建强大的API文档][Swagger2_API] ###

传送门：http://blog.didispace.com/spring-boot-learning-21-2-2/

#### 引入Swagger2 ####

**第一步**：添加swagger-spring-boot-starter依赖

在`pom.xml`中加入依赖，具体如下：

<dependency>
        <groupId>com.spring4all</groupId>
        <artifactId>swagger-spring-boot-starter</artifactId>
        <version>1.9.0.RELEASE</version>
    </dependency>

**第二步**：应用主类中添加`@EnableSwagger2Doc`注解，具体如下

@EnableSwagger2Doc
    @SpringBootApplication
    public class Chapter22Application {
    
        public static void main(String[] args) {
            SpringApplication.run(Chapter22Application.class, args);
        }
    
    }

**第三步**：`application.properties`中配置文档相关内容，比如

swagger.title=spring-boot-starter-swagger
    swagger.description=Starter for swagger 2.x
    swagger.version=1.4.0.RELEASE
    swagger.license=Apache License, Version 2.0
    swagger.licenseUrl=https://www.apache.org/licenses/LICENSE-2.0.html
    swagger.termsOfServiceUrl=https://github.com/dyc87112/spring-boot-starter-swagger
    swagger.contact.name=didi
    swagger.contact.url=http://blog.didispace.com
    swagger.contact.email=dyc87112@qq.com
    swagger.base-package=com.didispace
    swagger.base-path=/**

各参数配置含义如下：

*  `swagger.title`：标题
 *  `swagger.description`：描述
 *  `swagger.version`：版本
 *  `swagger.license`：许可证
 *  `swagger.licenseUrl`：许可证URL
 *  `swagger.termsOfServiceUrl`：服务条款URL
 *  `swagger.contact.name`：维护人
 *  `swagger.contact.url`：维护人URL
 *  `swagger.contact.email`：维护人email
 *  `swagger.base-package`：swagger扫描的基础包，默认：全扫描
 *  `swagger.base-path`：需要处理的基础URL规则，默认：/\*\*

更多配置说明可见官方说明：[https://github.com/SpringForAll/spring-boot-starter-swagger][https_github.com_SpringForAll_spring-boot-starter-swagger]

**第四步**：启动应用，访问：`http://localhost:8080/swagger-ui.html`

#### 添加文档内容 ####

我们通过`@Api`，`@ApiOperation`注解来给API增加说明、通过`@ApiImplicitParam`、`@ApiModel`、`@ApiModelProperty`注解来给参数增加说明。

比如下面的例子：

@Api(tags = "用户管理")
    @RestController
    @RequestMapping(value = "/users")     // 通过这里配置使下面的映射都在/users下
    public class UserController {
    
        // 创建线程安全的Map，模拟users信息的存储
        static Map<Long, User> users = Collections.synchronizedMap(new HashMap<>());
    
        @PutMapping("/{id}")
        @ApiImplicitParam(paramType = "path", dataType = "Long", name = "id", value = "用户编号", required = true, example = "1")
        @ApiOperation(value = "更新用户详细信息", notes = "根据url的id来指定更新对象，并根据传过来的user信息来更新用户详细信息")
        public String putUser(@PathVariable Long id, @RequestBody User user) {
            User u = users.get(id);
            u.setName(user.getName());
            u.setAge(user.getAge());
            users.put(id, u);
            return "success";
        }
    }
    
    @Data
    @ApiModel(description="用户实体")
    public class User {
    
        @ApiModelProperty("用户编号")
        private Long id;
        @ApiModelProperty("用户姓名")
        private String name;
        @ApiModelProperty("用户年龄")
        private Integer age;
    
    }

#### API文档访问与调试 ####

Swagger除了查看接口功能外，还提供了调试测试功能，我们可以点击右侧的Model Schema（黄色区域：它指明了User的数据结构），此时Value中就有了user对象的模板，我们只需要稍适修改，点击下方`“Try it out！”`按钮，即可完成了一次请求调用！

### [JSR-303实现请求参数校验][JSR-303] ###

**第一步**：在要校验的字段上添加上`@NotNull`注解，具体如下：

@Data
    @ApiModel(description="用户实体")
    public class User {
    
        @ApiModelProperty("用户编号")
        private Long id;
    
        @NotNull
        @Size(min = 2, max = 5)
        @ApiModelProperty("用户姓名")
        private String name;
    
        @NotNull
        @Max(100)
        @Min(10)
        @ApiModelProperty("用户年龄")
        private Integer age;
    
        @NotNull
        @Email
        @ApiModelProperty("用户邮箱")
        private String email;
    
    }

**第二步**：在需要校验的参数实体前添加`@Valid`注解，具体如下：

@PostMapping("/")
    @ApiOperation(value = "创建用户", notes = "根据User对象创建用户")
    public String postUser(@Valid @RequestBody User user) {
        users.put(user.getId(), user);
        return "success";
    }

### [Swagger接口分类与各元素排序问题详解][Swagger] ###

### [Swagger静态文档的生成][Swagger 1] ###

### [找回启动日志中的请求路径列表][Link 9] ###

## 数据访问----关系型数据库 ##

### [使用JdbcTemplate访问MySQL数据库][JdbcTemplate_MySQL] ###

### [默认数据源Hikari的配置详解][Hikari] ###

### [使用国产数据库连接池Druid][Druid] ###

### [使用Spring Data JPA访问MySQL][Spring Data JPA_MySQL] ###

#### 工程配置 ####

在`pom.xml`中添加相关依赖，加入以下内容：

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

在`application.xml`中配置：数据库连接信息（如使用嵌入式数据库则不需要）、自动创建表结构的设置，例如使用mysql的情况如下：

spring.datasource.url=jdbc:mysql://localhost:3306/test
    spring.datasource.username=root
    spring.datasource.password=
    spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
    
    spring.jpa.properties.hibernate.hbm2ddl.auto=create-drop

`spring.jpa.properties.hibernate.hbm2ddl.auto`是hibernate的配置属性，其主要作用是：自动创建、更新、验证数据库表结构。该参数的几种配置如下：

*  `create`：每次加载hibernate时都会删除上一次的生成的表，然后根据你的model类再重新来生成新表，哪怕两次没有任何改变也要这样执行，这就是导致数据库表数据丢失的一个重要原因。
 *  `create-drop`：每次加载hibernate时根据model类生成表，但是sessionFactory一关闭,表就自动删除。
 *  `update`：最常用的属性，第一次加载hibernate时根据model类会自动建立起表的结构（前提是先建立好数据库），以后加载hibernate时根据model类自动更新表结构，即使表结构改变了但表中的行仍然存在不会删除以前的行。要注意的是当部署到服务器后，表结构是不会被马上建立起来的，是要等应用第一次运行起来后才会。
 *  `validate`：每次加载hibernate时，验证创建数据库表结构，只会和数据库中的表进行比较，不会创建新表，但是会插入新值。

至此已经完成基础配置，如果您有在Spring下整合使用过它的话，相信你已经感受到Spring Boot的便利之处：JPA的传统配置在`persistence.xml`文件中，但是这里我们不需要。当然，最好在构建项目时候按照之前提过的[最佳实践的工程结构][Link 7]来组织，这样以确保各种配置都能被框架扫描到。

#### 创建实体 ####

创建一个User实体，包含id（主键）、name（姓名）、age（年龄）属性，通过ORM框架其会被映射到数据库表中，由于配置了`hibernate.hbm2ddl.auto`，在应用启动的时候框架会自动去数据库中创建对应的表。

@Entity
    @Data
    @NoArgsConstructor
    public class User {
    
        @Id
        @GeneratedValue
        private Long id;
    
        private String name;
        private Integer age;
    
        public User(String name, Integer age) {
            this.name = name;
            this.age = age;
        }
    }

*  `@Entity`注解标识了User类是一个持久化的实体
 *  `@Data`和`@NoArgsConstructor`是Lombok中的注解。用来自动生成各参数的Set、Get函数以及不带参数的构造函数。如果您对Lombok还不了解，可以看看这篇文章：[Java开发神器Lombok的使用与原理][Java_Lombok]
 *  `@Id`和`@GeneratedValue`用来标识User对应对应数据库表中的主键

**注意**：除了这些注解之外，还有很多用来精细化配置映射关系的注解，这里不做具体介绍。后续会出专门一篇来介绍常用注解。读者也可以自行阅读Hibernate的文档来学习这些注解的详细使用方法。

#### 创建数据访问接口 ####

下面针对User实体创建对应的`Repository`接口实现对该实体的数据访问，如下代码：

public interface UserRepository extends JpaRepository<User, Long> {
    
        User findByName(String name);
    
        User findByNameAndAge(String name, Integer age);
    
        @Query("from User u where u.name=:name")
        User findUser(@Param("name") String name);
    
    }

在Spring Data JPA中，只需要编写类似上面这样的接口就可实现数据访问。不再像我们以往编写了接口时候还需要自己编写接口实现类，直接减少了我们的文件清单。

下面对上面的`UserRepository`做一些解释，该接口继承自`JpaRepository`，通过查看`JpaRepository`接口的[API文档][API]，可以看到该接口本身已经实现了创建（save）、更新（save）、删除（delete）、查询（findAll、findOne）等基本操作的函数，因此对于这些基础操作的数据访问就不需要开发者再自己定义。

在上例中，我们可以看到下面两个函数：

*  `User findByName(String name)`
 *  `User findByNameAndAge(String name, Integer age)`

它们分别实现了按name查询User实体和按name和age查询User实体，可以看到我们这里没有任何类SQL语句就完成了两个条件查询方法。这就是Spring-data-jpa的一大特性：**通过解析方法名创建查询**。

除了通过解析方法名来创建查询外，它也提供通过使用@Query 注解来创建查询，您只需要编写JPQL语句，并通过类似“:name”来映射@Param指定的参数，就像例子中的第三个findUser函数一样。

#### 拓展阅读：关于Spring Data ####

Spring Data JPA在Spring家族中实际上是一个二级项目，它隶属于[Spring Data][]这个顶级项目。读者可以看一下关于这个项目的介绍，它除了涵盖对关系型数据库的抽象之外，其实还有很多对其他数据存储中间件的实现，比如我们常用的Redis、MongoDB、Elasticsearch等。

如果再找几个项目看一下它们的简单示例，你会发现：不论你是要访问什么数据存储产品，它们的编码方式几乎都是一样的！这就是Spring Data这个项目充满魅力的地方！通过对数据访问操作的抽象来屏蔽细节，用不同子项目的方式去实现细节。让开发者只需要学会使用Spring Data，就能方便快捷的学会对各种数据存储的操作。所以，对于Spring Data，我是强烈推荐Java开发者们可以学、甚至读一下源码的重要框架。虽然，目前来说很多大型互联网公司并不会选择它（性能考量居多，能真正用好它的人不多）作为主要的开发框架，但是其背后的抽象思想是非常值得我们学习的。并且，在做一些非高并发项目的时候，这简直就是一个快捷开发神器，它可以帮助我们少写非常多的代码！

### [使用MyBatis访问MySQL][MyBatis_MySQL] ###

虽然Spring Data JPA在国外广泛流行，但是在国内还是MyBatis的天下。所以，今天这篇我们将具体说说如何在Spring Boot中整合MyBatis完成关系型数据库的增删改查操作。

#### 整合MyBatis ####

**第一步**：新建Spring Boot项目，在`pom.xml`中引入MyBatis的Starter以及MySQL Connector依赖，具体如下：

<dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
        <version>2.1.1</version>
    </dependency>
    
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
    </dependency>

关于`mybatis-spring-boot-starter`的版本需要注意：

*  `2.1.x`版本适用于：MyBatis 3.5+、Java 8+、Spring Boot 2.1+
 *  `2.0.x`版本适用于：MyBatis 3.5+、Java 8+、Spring Boot 2.0/2.1
 *  `1.3.x`版本适用于：MyBatis 3.4+、Java 6+、Spring Boot 1.5

其中，目前还在维护的是`2.1.x`版本和`1.3.x`版本。

**第二步**：同之前介绍的使用jdbc模块和jpa模块连接数据库一样，在`application.properties`中配置mysql的连接配置

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

当然，也可以不用默认数据源，如果要使用Druid作为数据库连接池的话，可以参见[《Spring Boot 2.x：使用国产数据库连接池Druid》][Druid]一文。

**第三步**：Mysql中创建一张用来测试的表，比如：User表，其中包含id(BIGINT)、age(INT)、name(VARCHAR)字段。

具体创建命令如下：

CREATE TABLE `User` (
      `id` bigint NOT NULL AUTO_INCREMENT,
      `name` varchar(100) COLLATE utf8mb4_general_ci DEFAULT NULL,
      `age` int DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci

**第四步**：创建User表的映射对象User：

@Data
    @NoArgsConstructor
    public class User {
    
        private Long id;
    
        private String name;
        private Integer age;
    
        public User(String name, Integer age) {
            this.name = name;
            this.age = age;
        }
    }

**第五步**：创建User表的操作接口：UserMapper。在接口中定义两个数据操作，一个插入，一个查询，用于后续单元测试验证。

#### 使用@Param ####

在之前的整合示例中我们已经使用了这种最简单的传参方式，如下：

@Insert("INSERT INTO USER(NAME, AGE) VALUES(#{name}, #{age})")
    int insert(@Param("name") String name, @Param("age") Integer age);

这种方式很好理解，`@Param`中定义的`name`对应了SQL中的`#{name}`，`age`对应了SQL中的`#{age}`。

#### 使用Map ####

如下代码，通过`Map<String, Object>`对象来作为传递参数的容器：

@Insert("INSERT INTO USER(NAME, AGE) VALUES(#{name,jdbcType=VARCHAR}, #{age,jdbcType=INTEGER})")
    int insertByMap(Map<String, Object> map);

对于Insert语句中需要的参数，我们只需要在map中填入同名的内容即可，具体如下面代码所示：

Map<String, Object> map = new HashMap<>();
    map.put("name", "CCC");
    map.put("age", 40);
    userMapper.insertByMap(map);

#### 使用对象 ####

除了Map对象，我们也可直接使用普通的Java对象来作为查询条件的传参，比如我们可以直接使用User对象:

@Insert("INSERT INTO USER(NAME, AGE) VALUES(#{name}, #{age})")
    int insertByUser(User user);

这样语句中的`#{name}`、`#{age}`就分别对应了User对象中的`name`和`age`属性。

#### 增删改查 ####

MyBatis针对不同的数据库操作分别提供了不同的注解来进行配置，在之前的示例中演示了`@Insert`，下面针对User表做一组最基本的增删改查作为示例：

#### 返回结果绑定 ####

@Results({
        @Result(property = "name", column = "name"),
        @Result(property = "age", column = "age")
    })
    @Select("SELECT name, age FROM user")
    List<User> findAll();

在上面代码中，@Result中的property属性对应User对象中的成员名，column对应SELECT出的字段名。

### [使用MyBatis的XML配置方式][MyBatis_XML] ###

### [JdbcTemplate的多数据源配置][JdbcTemplate 2] ###

### [Spring Data JPA的多数据源配置][Spring Data JPA] ###

### [MyBatis的多数据源配置][MyBatis 2] ###

### [事务管理入门][Link 10] ###

#### 使用 ####

在开发业务逻辑时，我们通常在service层接口中使用`@Transactional`来对各个业务逻辑进行事务管理的配置，例如：

public interface UserService {
        
        @Transactional
        User login(String name, String password);
        
    }

#### 隔离级别 ####

隔离级别是指若干个并发的事务之间的隔离程度，与我们开发时候主要相关的场景包括：脏读取、重复读、幻读。

我们可以看`org.springframework.transaction.annotation.Isolation`枚举类中定义了五个表示隔离级别的值：

public enum Isolation {
        DEFAULT(-1),
        READ_UNCOMMITTED(1),
        READ_COMMITTED(2),
        REPEATABLE_READ(4),
        SERIALIZABLE(8);
    }

指定方法：通过使用`isolation`属性设置，例如：

@Transactional(isolation = Isolation.DEFAULT)

#### 传播行为 ####

所谓事务的传播行为是指，如果在开始当前事务之前，一个事务上下文已经存在，此时有若干选项可以指定一个事务性方法的执行行为。

我们可以看`org.springframework.transaction.annotation.Propagation`枚举类中定义了6个表示传播行为的枚举值：

public enum Propagation {
        REQUIRED(0),
        SUPPORTS(1),
        MANDATORY(2),
        REQUIRES_NEW(3),
        NOT_SUPPORTED(4),
        NEVER(5),
        NESTED(6);
    }

指定方法：通过使用`propagation`属性设置，例如：

@Transactional(propagation = Propagation.REQUIRED)

## **加速利器：各种缓存的使用** ##

### [进程内缓存的使用与Cache注解详解][Cache] ###

### [EhCache缓存的使用][EhCache 1] ###

### [使用EhCache缓存集群][EhCache 2] ###

### [使用集中式缓存Redis][Redis 1] ###

## Web界面开发 ##

### [使用 Thymeleaf开发Web页面][Thymeleaf_Web] ###

### [使用 ECharts 绘制各种华丽的数据图表][ECharts] ###

# 1.x到2.x #

### [Spring Boot 2.0 正式发布，升还是不升呢？][Spring Boot 2.0] ###

各种功能性的兄弟项目，比如：简化数据访问的Spring Data、提供批处理能力的Spring Batch、用于保护应用安全的Spring Security等。

在未来的一段时间内，您是否想要使用Java 9将是一个影响升级与否的重要决策依据，因为Spring Boot 1.x版本明确说明了没有对Java 9的支持计划；换言之，如果你想将Spring Boot运行在Java 9上，那么你必须升级到Spring Boot 2.0。

### [Spring Boot 2.0 新特性和发展方向][Spring Boot 2.0 1] ###

### [Spring Boot 2.0 与 Java 9][Spring Boot 2.0 _ Java 9] ###

### [2.0 新特性（一）：配置绑定全解析][2.0] ###

在Spring Boot 2.0中对配置属性加载的时候会除了像1.x版本时候那样**移除特殊字符**外，还会将配置均以**全小写**的方式进行匹配和加载。所以，下面的4种配置方式都是等价的：

*  properties格式：

spring.jpa.databaseplatform=mysql
    spring.jpa.database-platform=mysql
    spring.jpa.databasePlatform=mysql
    spring.JPA.database_platform=mysql

*  yaml格式：

spring:
      jpa:
        databaseplatform: mysql
        database-platform: mysql
        databasePlatform: mysql
        database_platform: mysql

**Tips：推荐使用全小写配合-分隔符的方式来配置，比如：spring.jpa.database-platform=mysql**

如果我们要读取配置文件中`spring.jpa.database-platform`的配置，可以这样写：

this.environment.containsProperty("spring.jpa.database-platform")

**注意：使用@Value获取配置内容的时候也需要这样的特点**

### [2.0 新特性（二）：新增事件ApplicationStartedEvent][2.0 _ApplicationStartedEvent] ###

[https_gitee.com_didispace_SpringBoot-Learning_tree_master_1.x]: https://gitee.com/didispace/SpringBoot-Learning/tree/master/1.x
[Spring Cloud Alibaba_Spring Boot_Spring Cloud]: http://blog.didispace.com/spring-cloud-alibaba-version/
[web_RESTful API]: http://blog.didispace.com/spring-boot-learning-1/
[Intellij_Spring Initializr_Spring Boot_Cloud]: http://blog.didispace.com/spring-initializr-in-intellij/
[Link 1]: http://blog.didispace.com/springbootproperties/
[RESTful API]: http://blog.didispace.com/springbootrestfulapi/
[Thymeleaf_web]: http://blog.didispace.com/springbootweb/
[Swagger2_RESTful API]: http://blog.didispace.com/springbootswagger2/
[http_localhost_8080_swagger-ui.html]: http://localhost:8080/swagger-ui.html
[Link 2]: http://blog.didispace.com/springbootexception/
[Java 8_LocalDate]: http://blog.didispace.com/Spring-Boot-And-Feign-Use-localdate/
[XML]: http://blog.didispace.com/spring-boot-xml-httpmessageconverter
[JdbcTemplate]: http://blog.didispace.com/springbootdata1/
[Spring-data-jpa]: http://blog.didispace.com/springbootdata2/
[JdbcTemplate 1]: http://blog.didispace.com/springbootmultidatasource/
[NoSQL_Redis]: http://blog.didispace.com/springbootredis/
[NoSQL_MongoDB]: http://blog.didispace.com/springbootmongodb/
[MyBatis]: http://blog.didispace.com/springbootmybatis/
[MyBatis 1]: http://blog.didispace.com/mybatisinfo/
[Flyway]: http://blog.didispace.com/spring-boot-flyway-db-version/
[LDAP]: http://blog.didispace.com/spring-boot-ldap-user/
[Spring Boot_MongoDB]: http://blog.didispace.com/springbootmongodb-plus/
[Link 3]: http://blog.didispace.com/springboottransactional/
[Scheduled]: http://blog.didispace.com/springbootscheduled/
[Async]: http://blog.didispace.com/springbootasync/
[Async 1]: http://blog.didispace.com/springbootasync-2/
[Async 2]: http://blog.didispace.com/springbootasync-3/
[Async_Future]: http://blog.didispace.com/springbootasync-4/
[Link 4]: http://blog.didispace.com/springbootlog/
[log4j]: http://blog.didispace.com/springbootlog4j/
[log4j 1]: http://blog.didispace.com/springbootlog4jmuilt/
[AOP_Web]: http://blog.didispace.com/springbootaoplog/
[log4j_MongoDB]: http://blog.didispace.com/springbootlog4jmongodb/
[Spring Boot 1.5.x]: http://blog.didispace.com/spring-boot-1-5-x-feature-1/
[Spring Security]: http://blog.didispace.com/springbootsecurity/
[EhCache]: http://blog.didispace.com/springbootcache1/
[Redis]: http://blog.didispace.com/springbootcache2/
[Link 5]: http://blog.didispace.com/springbootmailsender/
[Spring Boot_RabbitMQ]: http://blog.didispace.com/spring-boot-rabbitmq/
[Spring StateMachine]: http://blog.didispace.com/spring-statemachine/
[Spring Boot Actuator]: http://blog.didispace.com/spring-boot-actuator-1/
[Spring_spring-boot-actuator]: http://blog.didispace.com/spring-boot-actuator-without-boot/
[Spring Boot]: http://blog.didispace.com/spring-boot-run-backend/
[Spring Boot_Banner]: http://blog.didispace.com/spring-boot-banner/
[https_gitee.com_didispace_SpringBoot-Learning_tree_master_2.1.x]: https://gitee.com/didispace/SpringBoot-Learning/tree/master/2.1.x
[Link 6]: http://blog.didispace.com/spring-boot-learning-21-1-1/
[Link 7]: http://blog.didispace.com/spring-boot-learning-21-1-2/
[Link 8]: http://blog.didispace.com/spring-boot-learning-21-1-3/
[RESTful API 1]: http://blog.didispace.com/spring-boot-learning-21-2-1/
[Swagger2_API]: http://blog.didispace.com/spring-boot-learning-21-2-2/
[https_github.com_SpringForAll_spring-boot-starter-swagger]: https://github.com/SpringForAll/spring-boot-starter-swagger
[JSR-303]: http://blog.didispace.com/spring-boot-learning-21-2-3/
[Swagger]: http://blog.didispace.com/spring-boot-learning-21-2-4/
[Swagger 1]: http://blog.didispace.com/spring-boot-learning-21-2-5/
[Link 9]: http://blog.didispace.com/spring-boot-learning-21-2-6/
[JdbcTemplate_MySQL]: http://blog.didispace.com/spring-boot-learning-21-3-1/
[Hikari]: http://blog.didispace.com/spring-boot-learning-21-3-2/
[Druid]: http://blog.didispace.com/spring-boot-learning-21-3-3/
[Spring Data JPA_MySQL]: http://blog.didispace.com/spring-boot-learning-21-3-4/
[Java_Lombok]: http://blog.didispace.com/java-lombok-how-to-use/
[API]: http://docs.spring.io/spring-data/data-jpa/docs/current/api/
[Spring Data]: https://spring.io/projects/spring-data
[MyBatis_MySQL]: http://blog.didispace.com/spring-boot-learning-21-3-5/
[MyBatis_XML]: http://blog.didispace.com/spring-boot-learning-21-3-6/
[JdbcTemplate 2]: http://blog.didispace.com/spring-boot-learning-21-3-7/
[Spring Data JPA]: http://blog.didispace.com/spring-boot-learning-21-3-8/
[MyBatis 2]: http://blog.didispace.com/spring-boot-learning-21-3-9/
[Link 10]: http://blog.didispace.com/spring-boot-learning-21-3-10/
[Cache]: http://blog.didispace.com/spring-boot-learning-21-5-1/
[EhCache 1]: http://blog.didispace.com/spring-boot-learning-21-5-2/
[EhCache 2]: http://blog.didispace.com/spring-boot-learning-21-5-3/
[Redis 1]: http://blog.didispace.com/spring-boot-learning-21-5-4/
[Thymeleaf_Web]: http://blog.didispace.com/spring-boot-learning-21-4-1/
[ECharts]: http://blog.didispace.com/spring-boot-learning-21-4-2/
[Spring Boot 2.0]: http://blog.didispace.com/spring-boot-2-release/
[Spring Boot 2.0 1]: http://blog.didispace.com/Spring-Boot-2-0-%E6%96%B0%E7%89%B9%E6%80%A7%E5%92%8C%E5%8F%91%E5%B1%95%E6%96%B9%E5%90%91/
[Spring Boot 2.0 _ Java 9]: http://blog.didispace.com/Spring-Boot-2.0%E4%B8%8EJava-9/
[2.0]: http://blog.didispace.com/Spring-Boot-2-0-feature-1-relaxed-binding-2/
[2.0 _ApplicationStartedEvent]: http://blog.didispace.com/Spring-Boot-2-0-feature-2-ApplicationStartedEvent/