Spring Boot 复习

简介

Spring Boot 是由 Pivotal 团队提供的全新框架，其设计目的是用来简化新 Spring 应用的初始搭建以及开发过程。该框架使用了特定的方式来进行配置，从而使开发人员不再需要定义样板化的配置。通过这种方式，Spring Boot 致力于在蓬勃发展的快速应用开发领域(rapid application development)成为领导者。其特点如下：

创建独立的Spring应用程序
嵌入的Tomcat，无需部署war文件
简化Maven配置
自动配置Spring
提供生产就绪型功能，如指标、健康检查和外部配置
没有代码生成和不要求配置xml

环境搭建

创建maven工程（不用骨架，打包方式jar）

添加起步依赖

继承SpringBoot的起步依赖

<parent>

	<groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-parent</artifactId>

    <version>2.0.1.RELEASE</version>

</parent>

导入web的启动依赖

<dependencies>

	<dependency>

    	<groupId>org.springframework.boot</groupId>

    	<artifactId>spring-boot-starter-web</artifactId>

    </dependency>

</dependencies>

编写引导类（任意命名）

@SpringBootApplication

public class NewSpringBootApplication{

    public static void main(String[] args){

        SpringApplication.run(NewMySpringBootApplication.class);

    }

}

编写Controller

@Controller

public class HelloController{

    @RequestMapping("/hello")

    @ResponseBody			//说明返回的是json字符串

    public String hello(){

        return "hello springboot";

    }

}

注意事项

所有的SpringBoot项目必须继承SpringBoot的起步依赖
添加依赖时以功能为单位
@SpringBootApplication 声明该类是一个SpringBoot引导类
SpringApplication.run(引导类.class) 表示运行SpringBoot的引导类（引导类和main方法可以分开）
SpringBoot工程的热部署，更改代码后不需要重启项目即可生效
```
<dependency>

	<groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-devtools</artifactId>

</dependency>
```
导入坐标后设置IDEA自动编译：
- Settings --> Compiler --> select Build project automatically --> apply
- press control+shift+/ --> Registry --> select compiler.automake.allow.when.app.running
IDEA快速创建SpringBoot项目

new project --> Spring Initializr --> select dependencies --> [delete .gitignore & mvnw & mvnw.cmd] --> create Controller
@RestController = @Controller + @ResponseBody

原理分析

起步依赖

parent：当前项目 --> 继承spring-boot-starter-parent(处理配置文件，插件管理) --> 继承spring-boot-dependencies(maven 版本约定，依赖管理)
web：spring-boot-starter-web-2.0.1.RELEASE.pom中导入了tomcat,json等坐标

自动配置

@SpringBootApplication

@Target({ElementType.TYPE})

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Inherited

@SpringBootConfiguration		//配置类

@EnableAutoConfiguration		//允许自动配置

@ComponentScan(					//自动扫描组件，约定引导类所在的包及子包所有的类都会扫描

    excludeFilters = {@Filter(

    type = FilterType.CUSTOM,

    classes = {TypeExcludeFilter.class}

), @Filter(

    type = FilterType.CUSTOM,

    classes = {AutoConfigurationExcludeFilter.class}

)}

)

public @interface SpringBootApplication {...}

@SpringBootConfiguration

@Target({ElementType.TYPE})

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Configuration	//spring的配置类注解

public @interface SpringBootConfiguration {...}

@EnableAutoConfiguration

@Target({ElementType.TYPE})

@Retention(RetentionPolicy.RUNTIME)

@Documented

@Inherited

@AutoConfigurationPackage

@Import({AutoConfigurationImportSelector.class})	//当前配置类引入其他配置类

public @interface EnableAutoConfiguration {...}

AutoConfiturationImportSelector.class

    public String[] selectImports(AnnotationMetadata annotationMetadata) {

        if (!this.isEnabled(annotationMetadata)) {

            return NO_IMPORTS;

        } else {

            AutoConfigurationMetadata autoConfigurationMetadata = AutoConfigurationMetadataLoader.loadMetadata(this.beanClassLoader);

            //调用getAutoConfigurationEntry()

            AutoConfigurationImportSelector.AutoConfigurationEntry autoConfigurationEntry = this.getAutoConfigurationEntry(autoConfigurationMetadata, annotationMetadata);

            return StringUtils.toStringArray(autoConfigurationEntry.getConfigurations());

        }

    }

    protected AutoConfigurationImportSelector.AutoConfigurationEntry getAutoConfigurationEntry(AutoConfigurationMetadata autoConfigurationMetadata, AnnotationMetadata annotationMetadata) {

        if (!this.isEnabled(annotationMetadata)) {

            return EMPTY_ENTRY;

        } else {

            AnnotationAttributes attributes = this.getAttributes(annotationMetadata);

            //调用getCandidateConfigurations()，返回配置类的全包名

            List<String> configurations = this.getCandidateConfigurations(annotationMetadata, attributes);

            configurations = this.removeDuplicates(configurations);

            Set<String> exclusions = this.getExclusions(annotationMetadata, attributes);

            this.checkExcludedClasses(configurations, exclusions);

            configurations.removeAll(exclusions);

            configurations = this.filter(configurations, autoConfigurationMetadata);

            this.fireAutoConfigurationImportEvents(configurations, exclusions);

            return new AutoConfigurationImportSelector.AutoConfigurationEntry(configurations, exclusions);

        }

    }

    protected List<String> getCandidateConfigurations(AnnotationMetadata metadata, AnnotationAttributes attributes) {

        List<String> configurations = SpringFactoriesLoader.loadFactoryNames(this.getSpringFactoriesLoaderFactoryClass(), this.getBeanClassLoader());

        //错误信息说明了配置类的信息存在spring.factories中

        Assert.notEmpty(configurations, "No auto configuration classes found in META-INF/spring.factories. If you are using a custom packaging, make sure that file is correct.");

        return configurations;

    }

org.springframework.boot:spring-boot-autoconfigure:2.2.2.RELEASE/spring-boot-autoconfigure-2.2.2.RELEASE.jar/META-INF/spring.factories

...

# Auto Configure

org.springframework.boot.autoconfigure.EnableAutoConfiguration=\

org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\

org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\

org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\

...

流程
1. 通过配置文件提前进行默认配置
2. 用ServerProperties类加载配置
3. 用XxxAutoConfiguration类引入
4. 用spring.factories存入多个AutoConfiguration全限定类名
5. AutoConfigurationImportSelector类加载spring.factories获取配置信息
6. @EnableAutoConfiguration引入AutoConfigurationImportSelector完成自动配置
覆盖配置

spring-boot-starter-parent-2.0.1.RELEASE.pom中include标签有application*.yml(.yaml/.properties)，可以通过自定义对应配置文件进行覆盖

配置文件

位置：resources目录下
顺序：多个配置文件时，yml > yaml > properties，后加载的会覆盖之前的

yml语法

# 普通数据

name: whteway

# 对象(常用)

user:

	username: root

	password: 1234

# 行内对象配置

user: {username: root,password: 1234}

读取配置信息

@Value 精确，繁琐

@Value("${name}")

private String name;

@Value("${user.username}")

private String username;

@ConfigurationProperties 自动封装，需要配置configuration processor

@Controller

@ConfigurationProperties(prefix="user")

public class LoginController{

    private String username;

    private String password;

    //generate getters and setters

}

<dependency>

	<groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-configuration-processor</artifactId>

    <optional>true</optional>

</dependency>

集成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>

</dependency>

添加数据库连接信息，application.yml

spring:

	datasource:

		driverClassName=com.mysql.jdbc.Driver

		url=jdbc:mysql://localhost:3306/dbName?useUnicode=true?characterEncoding=utf8

		username=root

		password=root

建库建表
配置映射关系

UserMapper.xml

SpringBoot的配置文件中配置Mybatis的信息

mybatis:

	type-aliases-package=com.whteway.entity

	mapper-locations=classpath:mapper/*Mapper.xml

集成Junit

添加起步依赖

<dependency>

	<groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-test</artifactId>

    <scope>test</scope>

</dependency>

编写测试类

@RunWith(SpringRunner.class)

@SpringBootTes(classes="引导类全包名")

public class Test{

    @Test

    public void test(){...}

}

集成SpringDataJPA

添加起步依赖

<dependency>

	<groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-data-jpa</artifactId>

</dependency>

添加数据库驱动坐标

<dependency>

	<groupId>mysql</groupId>

    <artifactId>mysql-connector-java</artifactId>

</dependency>

添加数据库连接信息，application.yml

spring:

	datasource:

		driverClassName=com.mysql.jdbc.Driver

		url=jdbc:mysql://localhost:3306/dbName

		username=root

		password=root

建库建表

建实体类

@Entity

public class User{

    @Id

    @GeneratedValue(strategy=GenerationType.IDENTITY)

    private Long id;

    private String username;

    ...

}

建接口

public interface UserRepository extends JpaRepository<User, Long>{

    public List<User> findAll();

}

SpringBoot的配置文件中配置Mybatis的信息

spring:

	jpa:

		database: MySQL

		show-sql: true

		generate-ddl: true

		hibernate:

			ddl-auto: update

			naming_strategy: org.hibernate.cfg.ImprovedNamingStrategy

集成Redis

添加起步依赖

<dependency>

	<groupId>org.springframework.boot</groupId>

    <artifactId>spring-boot-starter-data-redis</artifactId>

</dependency>

配置连接信息

spring:

	redis:

		host=127.0.0.1

		port=6379

测试

@RunWith(SpringRunner.class)

@SpringBootTes(classes="引导类全包名")

public class Test{

    @Autowired

    private RedisTemplate<String, String> redisTemplate;

    @Autowired

    private UserRepository userRepository;

    @Test

    public void test(){

        String userListJson = redisTemplate.boundValueOps("user.findAll").get();

        if(null==userListJson){

            List<User> all = userRepository.findAll();

            ObjectMapper objectMapper = new ObjectMapper();

            userListJson = objectMapper.writeValueAsString(all);

            redisTemplate.boundValueOps("user.findAll").set(userListJson);

        }

        System.out.println(userListJson);

    }

}