SpringBoot框架学习(一)——注解配置

一、概述

1.简介

• SpringBoot是Spring家族中一个全新的框架，它用来简化Spring应用程序的创建和开发，也可以说它简化了ssm框架进行开发的过程
• 使用了SpringBoot之后，我们可以说是抛弃了繁琐的xml配置过程，采用大量默认配置来简化我们的开发过程
• 所以采用了SpringBoot可以非常容易和快速的创建基于Spring框架的应用程序，它让各方面的配置变得更简单了。

2.特性

• 能够快速创建基于Spring的应用程序
• 能够直接使用java main方法启动内嵌的Tomcat，Jetty服务器运行SpringBoot程序，不需要部署war包文件
• 提供约定的starter POM来简化了Maven的配置，让Maven的配置更简单
• 根据项目的Maven依赖配置，SpringBoot自动配置Spring，Springmvc
• 提供了程序的健康检查等功能
• 基本可以完全不使用xml来配置文件，采用注解配置

3.四大核心

• 自动配置：针对很多应用程序和常见的应用功能，SpringBoot能自动提供相关配置
• 起步依赖：告诉SpringBoot需要什么功能就可以自动引入所需要的依赖库
• Actuator：让你能深入运行SpringBoot，探查内部信息
• 命令行界面：可选特性

二、搭建开发环境

之后等待下载即可

下载完成。

最后在application.propertyes内设置一个闲置的端口号，以防端口冲突，
然后就可以开始写我们的第一个程序了

三、开始写我们的第一个程序 HelloWorld

创建一个springboot应用类，也就是像我们mvc的index.jsp一样的那个启动类，起名叫HelloworldApplication
标明一个注解@SpringBootApplication，说明他是一个springboot应用类，然后创建一个controller的class，与我们的启动类连接上，就完成了。

HelloWorldApplication.java

/**
 * 标注一个主程序，说明这是一个Spring Boot应用
 */
@SpringBootApplication
public class HelloWorldApplication {
    public static void main(String[] args) {
//      让Spring程序应用能跑起来
        SpringApplication.run(HelloWorldApplication.class);
    }
}

HelloController

@Controller
public class HelloController {
    @ResponseBody
    @RequestMapping("/hello")
    public String hello(){
        return "hello world";
    }
}

然后运行启动类即可。
记录一下主程序类注解@SpringBootApplication的作用:此注解做标明的类是SpringBoot的主配置类，SpringBoot就应该在运行这个类的main方法来启动SpringBoot应用
首先这是一个组合注解

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

@SpringBootConfiguration：SpringBoot的配置类
标注在某个类上，标明这是一个SpringBoot的配置类
@Configuration：配置类会标明这个注解，或者对其进行实例化
同时他也是类似于 @Component 的容器内的组件之一

@EnableAutoConfiguration：开启自动配置功能
它也是一个组合注解

@AutoConfigurationPackage
@Import({AutoConfigurationImportSelector.class})

@AutoConfigurationPackage:自动配置包
@Import(AutoConfigurationPackages.Registrar.class)
Spring的底层注解，将主配置类的所在包及包下所有子包扫描到Spring容器

@Import({AutoConfigurationImportSelector.class})
给容器导入组件
EnableAutoConfigurationImportSelector：导入哪些组件的选择器；
将所有需要导入的组件以全类名的形式进行返回，这些组件就会被添加到容器中；
会给容器中导入非常多的自动配置类(xxxAutoConfiguration);导入组件并且自动进行配置

四、配置文件

1.YML文件

我们之前使用了.properties去配置端口号，现在我们可以开始使用.yml的方式来配置我们的port
我们在resource目录下新建一个.yml的文件，然后这样编写就可以了

server:
	port: 9999

2.YML语法

<1>基本语法

基本都以键值对的格式去存在，但是要在k：的后面加上一个空格然后再写我们的value值，也就是k: v
并且也存在大小写敏感

<2>值的写法

1.字面量(数字，字符串，布尔)

k: v直接来写，字符串默认不用加上单引号或者双引号，但是如果要是使用转义字符就要注意
“”：双引号，不会转义字符串里面的特殊字符
例如：name: “zhangsan \n lisi” 输出：zhangsan 换行 lisi
‘’:单引号，会转义字符串里面的特殊字符
例如：name: “zhangsan \n lisi” 输出：zhangsan \n lisi

2.对象或者Map

k: v在下一行来写对象与属性之间的关系；但是要注意缩进
对象也还是k: v的形式

friends:
	lastName:zhangsan
	age:20

行内写法：

friends:{lastName:zhangsan,age:18}

3.数组(List,Map)

用- 值表示数组中的一个元素

pets:
- cat
- dag
- pig

行内写法：

pets:[cat,dog,pig]

下面我们针对上述所提到的，写一个简单的实现。

首先创建一个主类Person,自己编写几个私有属性，补全get set方法

/**
 * 将配置文件中配置的每一个值，映射到组件中
 * @ConfigurationProperties 告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定
 *
 * prefix内填入要映射的内容
 *
 * 只有组件是容器内部的组件才能使用容器提供的 @ConfigurationProperties 功能
 */
@Component
@ConfigurationProperties(prefix = "person")
public class Person {
    private String lastName;
    private Integer age;
    private Boolean boss;
    private Date birth;

    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;

    @Override
    public String toString() {
        return "Person{" +
                "lastName='" + lastName + '\'' +
                ", age=" + age +
                ", boss=" + boss +
                ", birth=" + birth +
                ", maps=" + maps +
                ", lists=" + lists +
                ", dog=" + dog +
                '}';
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public Boolean getBoss() {
        return boss;
    }

    public void setBoss(Boolean boss) {
        this.boss = boss;
    }

    public Date getBirth() {
        return birth;
    }

    public void setBirth(Date birth) {
        this.birth = birth;
    }

    public Map<String, Object> getMaps() {
        return maps;
    }

    public void setMaps(Map<String, Object> maps) {
        this.maps = maps;
    }

    public List<Object> getLists() {
        return lists;
    }

    public void setLists(List<Object> lists) {
        this.lists = lists;
    }

    public Dog getDog() {
        return dog;
    }

    public void setDog(Dog dog) {
        this.dog = dog;
    }
}

这是在Person类提到的Dog类，里面内容相似，只初始化了一个String name和Integer age，接下来开始进行yml文件的配置

person:
  lastName: 张三
  age: 18
  boss: false
  birth: 2000/08/01
  maps:
    k1: v1
    k2: v2
  lists:
    - 穷
    - 光
  dog:
    age: 2
    name: 旺财

之后在测试类中写我们的测试方法

/**
 * Springboot单元测试；
 *
 * 可以在测试期间很方便的类似编码一样的进行自动的注入容器
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootApplicationTests {

    @Autowired
    private Person person;

    @Test
    public void contextLoads() {
        System.out.println(person);
    }

}

然后直接运行即可。

这时我们再根据yml的数值，思考一下平时经常配置的properties文件应该如何配置
在配置之前，我们要在设置中改一个选项，以防运行之后会出现乱码的情况

server.port=9999

#配置person
person.lastName = 张三
person.age = 18
person.boss = false
person.birth = 2000/08/01
person.maps.k1=v1
person.maps.k2=v2
person.lists=穷,光
person.dog.name=旺财
person.dog.age=2

这样我们就可以用properties来配置了。

3.加载指定的配置文件

<1>使用@PropertySource

我们写的类，默认加载配置都会从resource目录下加载application.yml和application.properties这两个文件的配置
，但是我们也可以按照自己的想法，让它指定去读取我们所创建的配置文件。
以properties为例：
我们先在resource下创建一个配置文件

然后把配置拿过来

最后修改我们的Person类
在类前加一个注解即可

@PropertySource(value = {"classpath:person.properties"})

<2>使用@ImportSource

这个注解的作用在于可以导入Spring的配置文件，让配置文件里面的内容生效
我们自己编写的Spring配置文件在SpringBoot内不识别也不生效，但是要是想要让配置文件生效，就必须使用@ImportSource注解，标明在主配置类上就可以了。

我们可以在测试类中运行此测试方法，来验证。

@Test
    public void testHelloService(){
        boolean b = ioc.containsBean("helloService");
        System.out.println(b);
    }

但是以上两种方法均为手动添加组件来完成配置，而在SpringBoot内部，也是有给容器添加组件的方法的，下面就来介绍一下：

推荐使用全注解的方式，而不是手写配置的方法

/**
 * @Configuration 指明当前类是一个配置类，就是来替代之前的Spring配置文件的
 *
 *
 */
@Configuration
public class MyApplicationConfig {

//    将方法的返回值添加到容器中，容器中的组件默认id就是方法名
    @Bean
    public HelloService helloService(){
        System.out.println("配置类@Bean给容器中添加组件了...");
        return new HelloService();
    }
}

然后再进行一遍测试，记得把beans.xml的配置打上注释，不然会报错，测试之后我们发现成功了。

4.配置文件的占位符

意思其实就跟之前是一样的

server.port=9999

//配置person
person.lastName = 张三${random.uuid}
person.age = 18
person.boss = false
person.birth = 2000/08/01
person.maps.k1=v1
person.maps.k2=v2
person.lists=穷,光
person.dog.name=${person.lastName}-旺财
person.dog.age=2

并且也可以使用默认值例如：person.birth = ${person.a=2000}/08/01

5.Profile

profile是spring对不同环境提供不同配置功能的支持，可以通过激活、指定参数等方式快速切换环境

<1>多profile文件

我们在主配置文件编写的时候，文件名可以是application-{profile}.properties/yml
配置完成之后就可以动态切换模式了。
默认使用application.properties配置

<2>yml文件支持多文档块方式

server:
  port: 9999
spring:
  profiles:
    active: dev
#表示默认为9999，但是一旦为激活状态就会转为dev，也就是9998
---
server:
  port: 9998
spring:
  profiles: dev
---
server:
  port: 9997
spring:
  profiles: produce #指定所属环境

<3>激活指定profile

1.在配置文件中注明spring.profile.active=dev这样就可以切换到开发模式了
2.命令行方式激活
–spring.profiles.active=dev
这个是在打包测试的时候，末尾需要加的命令指示
3.虚拟机参数
-Dspring.profiles.active=dev

6.配置文件的加载位置

优先级顺序：
1.根目录的config目录下
2.根目录下
3.resource/config目录下
4.resource目录下

要灵活使用互补配置，高优先级配置局部，低优先级配置整体。

同时我们也可以通过spring.config.location来改变默认配置，但是前提是项目已经打包，可以使用命令行参数来修改

7.自动配置原理

<1>SpringBoot启动的时候加载主配置类，开启自动配置功能EnableAutoConfiguration

<2>EnableAutoConfiguration的作用：

• 利用EnableAutoConfigurationImportSelector给容器倒入一些组件
• 也可以查询SelectImports()方法内的内容
• List<String> configurations = getCandidateConfigurations(annotationMetaData,attributes);
  来获取候选配置
  将类路径下 META-INF/spring.factories里面配置的所有EnableAutoConfiguration的值加入到了容器中

<3>每一个自动配置类进行自动配置

<4>例如：

这是一个类

@Configuration//表示这是一个配置类，和以前编写的配置文件一样，也可以给容器中添加组件
@EnableConfigurationProperties({HttpProperties.class}) //启动指定类，ConfigurationProperties功能，看下面的<5>
@ConditionalOnWebApplication(//Spring底层@Condition注解，根据不同的条件，如果满足指定的条件，整个配置类里面的配置就会生效    
//并且判断当前应用是否是web应用，是就生效，不是就不生效
    type = Type.SERVLET
)
@ConditionalOnClass({CharacterEncodingFilter.class})
//判断当前项目是否有CharacterEncodingFilter这个类，而这个类是SpringMVC解决乱码的时候才会用到的
@ConditionalOnProperty(//判断配置文件中是否存在某种配置 spring.http.encoding.enabled，如果不存在，判断也是成立的
//而对于spring.http.encoding.enabled=true，即使我们不配置也是默认生效的
    prefix = "spring.http.encoding",
    value = {"enabled"},
    matchIfMissing = true
)
public class HttpEncodingAutoConfiguration {
  //这个私有类的实例此时已经完成了和Springboot的映射关系
	private final Encoding properties;
	
	    public HttpEncodingAutoConfiguration(HttpProperties properties) {
	        this.properties = properties.getEncoding();
	    }
	
	    @Bean//给容器添加一个组件，这个组件的某些值需要从properties中获取
	    @ConditionalOnMissingBean
	    public CharacterEncodingFilter characterEncodingFilter() {
	        CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
	        filter.setEncoding(this.properties.getCharset().name());
	        filter.setForceRequestEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.REQUEST));
	        filter.setForceResponseEncoding(this.properties.shouldForce(org.springframework.boot.autoconfigure.http.HttpProperties.Encoding.Type.RESPONSE));
	        return filter;
    }

总结：根绝当前不同的条件进行判断，决定配置类是否生效

<5>所有的配置类都是在不同的Properties类中进行封装的

@ConfigurationProperties(
    prefix = "spring.http"
)//从配置文件中获取bean的相关属性进行绑定
public class HttpProperties {

我们究竟可以在我们的properties中配置什么属性，其根源都是来源于它底层的properties类，我们可以根据它去进行直接性的定义，所以我们即使不用调用他的方法，也是可以定义好的。
总结：
1.SpringBoot启动的时候会加载大量的自动配置类
2.我们看我们需要的功能有没有SpringBoot默认写好的自动配置类
3.我们再来看这个自动配置类中到底配置了哪些组件，只要我们要用的组件有，就不需要再来配置了
4.给容器中自动添加组件的时候，会从properties中获取某些属性，我们就可以根据这些属性去指定具体的值

xxxAutoConfiguration：自动配置类
给容器中添加组件
xxxProperties：封装配置文件中的相关属性