糖糖IT

1
    <parent>
2
        <groupId>org.springframework.boot</groupId>
3
        <artifactId>spring-boot-starter-parent</artifactId>
4
        <version>1.5.9.RELEASE</version>
5
    </parent>
6
    <dependencies>
7
        <dependency>
8
            <groupId>org.springframework.boot</groupId>
9
            <artifactId>spring-boot-starter-web</artifactId>
10
        </dependency>
11
    </dependencies>

1
/**
2
 *  @SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用
3
 */
4
@SpringBootApplication
5
public class HelloWorldMainApplication {
6

7
    public static void main(String[] args) {
8

9
        // Spring应用启动起来
10
        SpringApplication.run(HelloWorldMainApplication.class,args);
11
    }
12
}

1
@Controller
2
public class HelloController {
3

4
    @ResponseBody
5
    @RequestMapping("/hello")
6
    public String hello(){
7
        return "Hello World!";
8
    }
9
}

1
 <!-- 这个插件，可以将应用打包成一个可执行的jar包；-->
2
    <build>
3
        <plugins>
4
            <plugin>
5
                <groupId>org.springframework.boot</groupId>
6
                <artifactId>spring-boot-maven-plugin</artifactId>
7
            </plugin>
8
        </plugins>
9
    </build>

1
/**
2
 *  @SpringBootApplication 来标注一个主程序类，说明这是一个Spring Boot应用
3
 */
4
@SpringBootApplication
5
public class HelloWorldMainApplication {
6

7
    public static void main(String[] args) {
8

9
        // Spring应用启动起来
10
        SpringApplication.run(HelloWorldMainApplication.class,args);
11
    }
12
}

1
@Target(ElementType.TYPE)
2
@Retention(RetentionPolicy.RUNTIME)
3
@Documented
4
@Inherited
5
@SpringBootConfiguration
6
@EnableAutoConfiguration
7
@ComponentScan(excludeFilters = {
8
      @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class),
9
      @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) })
10
public @interface SpringBootApplication {

1
#############################Configuration使用示例######################################################
2
/**
3
 * 1、配置类里面使用@Bean标注在方法上给容器注册组件，默认也是单实例的
4
 * 2、配置类本身也是组件
5
 * 3、proxyBeanMethods：代理bean的方法
6
 *      Full(proxyBeanMethods = true)、【保证每个@Bean方法被调用多少次返回的组件都是单实例的】
7
 *      Lite(proxyBeanMethods = false)【每个@Bean方法被调用多少次返回的组件都是新创建的】
8
 *      组件依赖必须使用Full模式默认。其他默认是否Lite模式
9
 */
10
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
11
public class MyConfig {
12

13
    /**
14
     * Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
15
     * @return
16
     */
17
    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
18
    public User user01(){
19
        User zhangsan = new User("zhangsan", 18);
20
        //user组件依赖了Pet组件
21
        zhangsan.setPet(tomcatPet());
22
        return zhangsan;
23
    }
24

25
    @Bean("tom")//自定义组件名
26
    public Pet tomcatPet(){
27
        return new Pet("tomcat");
28
    }
29
}
30

31

32
################################@Configuration测试代码如下########################################
33
@SpringBootConfiguration
34
@EnableAutoConfiguration
35
@ComponentScan("com.atguigu.boot")
36
public class MainApplication {
37

38
    public static void main(String[] args) {
39
        //1、返回我们IOC容器
40
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
41

42
        //2、查看容器里面的组件
43
        String[] names = run.getBeanDefinitionNames();
44
        for (String name : names) {
45
            System.out.println(name);
46
        }
47

48
        //3、从容器中获取组件
49
        Pet tom01 = run.getBean("tom", Pet.class);
50

51
        Pet tom02 = run.getBean("tom", Pet.class);
52

53
        System.out.println("组件："+(tom01 == tom02));
54

55
        //4、com.atguigu.boot.config.MyConfig$$EnhancerBySpringCGLIB$$51f1e1ca@1654a892
56
        MyConfig bean = run.getBean(MyConfig.class);
57
        System.out.println(bean);
58

59
        //如果@Configuration(proxyBeanMethods = true)代理对象调用方法。SpringBoot总会检查这个组件是否在容器中有。
60
        //保持组件单实例
61
        User user = bean.user01();
62
        User user1 = bean.user01();
63
        System.out.println(user == user1);
64

65

66
        User user01 = run.getBean("user01", User.class);
67
        Pet tom = run.getBean("tom", Pet.class);
68

69
        System.out.println("用户的宠物："+(user01.getPet() == tom));
70

71
    }
72
}

1
 * 4、@Import({User.class, DBHelper.class})
2
 *      给容器中自动创建出这两个类型的组件、默认组件的名字就是全类名
3
 *
4
 *
5
 *
6
 */
7

8
@Import({User.class, DBHelper.class})
9
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
10
public class MyConfig {
11
}

1
**=****=****=****=**=测试条件装配**=****=****=****=****=**=
2
@Configuration(proxyBeanMethods = false) //告诉SpringBoot这是一个配置类 == 配置文件
3
//@ConditionalOnBean(name = "tom")
4
@ConditionalOnMissingBean(name = "tom")
5
public class MyConfig {
6

7

8
    /**
9
     * Full:外部无论对配置类中的这个组件注册方法调用多少次获取的都是之前注册容器中的单实例对象
10
     * @return
11
     */
12

13
    @Bean //给容器中添加组件。以方法名作为组件的id。返回类型就是组件类型。返回的值，就是组件在容器中的实例
14
    public User user01(){
15
        User zhangsan = new User("zhangsan", 18);
16
        //user组件依赖了Pet组件
17
        zhangsan.setPet(tomcatPet());
18
        return zhangsan;
19
    }
20

21
    @Bean("tom22")
22
    public Pet tomcatPet(){
23
        return new Pet("tomcat");
24
    }
25
}
26

27
public static void main(String[] args) {
28
        //1、返回我们IOC容器
29
        ConfigurableApplicationContext run = SpringApplication.run(MainApplication.class, args);
30

31
        //2、查看容器里面的组件
32
        String[] names = run.getBeanDefinitionNames();
33
        for (String name : names) {
34
            System.out.println(name);
35
        }
36

37
        boolean tom = run.containsBean("tom");
38
        System.out.println("容器中Tom组件："+tom);
39

40
        boolean user01 = run.containsBean("user01");
41
        System.out.println("容器中user01组件："+user01);
42

43
        boolean tom22 = run.containsBean("tom22");
44
        System.out.println("容器中tom22组件："+tom22);
45

46
    }

1
**=****=****=****=****beans.xml****=****=****=****=**===
2
<?xml version="1.0" encoding="UTF-8"?>
3
<beans xmlns="http://www.springframework.org/schema/beans"
4
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
5
       xmlns:context="http://www.springframework.org/schema/context"
6
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">
7

8
    <bean id="haha" class="com.atguigu.boot.bean.User">
9
        <property name="name" value="zhangsan"></property>
10
        <property name="age" value="18"></property>
11
    </bean>
12

13
    <bean id="hehe" class="com.atguigu.boot.bean.Pet">
14
        <property name="name" value="tomcat"></property>
15
    </bean>
16
</beans>

1
@ImportResource("classpath:beans.xml")
2
public class MyConfig {}
3

4
**=****=****=****=****测试****=****=****=**
5
        boolean haha = run.containsBean("haha");
6
        boolean hehe = run.containsBean("hehe");
7
        System.out.println("haha："+haha);//true
8
        System.out.println("hehe："+hehe);//true

1
@AutoConfigurationPackage
2
@Import(EnableAutoConfigurationImportSelector.class)
3
public @interface EnableAutoConfiguration {

1
server:
2
    port: 8081
3
    path: /hello

1
@Data
2
public class Person {
3

4
  private String userName;
5
  private Boolean boss;
6
  private Date birth;
7
  private Integer age;
8
  private Pet pet;
9
  private String[] interests;
10
  private List<String> animal;
11
  private Map<String, Object> score;
12
  private Set<Double> salarys;
13
  private Map<String, List<Pet>> allPets;
14
}
15

16
@Data
17
public class Pet {
18
  private String name;
19
  private Double weight;
20
}

1
## yaml表示以上对象
2
person:
3
  userName: zhangsan
4
  boss: false
5
  birth: 2019/12/12 20:12:33
6
  age: 18
7
  pet:
8
    name: tomcat
9
    weight: 23.4
10
  interests: [篮球,游泳]
11
  animal:
12
    - jerry
13
    - mario
14
  score:
15
    english:
16
      first: 30
17
      second: 40
18
      third: 50
19
    math: [131,140,148]
20
    chinese: {first: 128,second: 136}
21
  salarys: [3999,4999.98,5999.99]
22
  allPets:
23
    sick:
24
      - {name: tom}
25
      - {name: jerry,weight: 47}
26
    health: [{name: mario,weight: 47}]

1
/**
2
 * 将配置文件中配置的每一个属性的值，映射到这个组件中
3
 * @ConfigurationProperties：告诉SpringBoot将本类中的所有属性和配置文件中相关的配置进行绑定；
4
 *      prefix = "person"：配置文件中哪个下面的所有属性进行一一映射
5
 *
6
 * 只有这个组件是容器中的组件，才能容器提供的@ConfigurationProperties功能；
7
 *
8
 */
9
@Component
10
@ConfigurationProperties(prefix = "person")
11
public class Person {
12

13
    private String lastName;
14
    private Integer age;
15
    private Boolean boss;
16
    private Date birth;
17

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

1
@Configuration
2
@EnableConfigurationProperties(Car.class)
3
//1、开启Car配置绑定功能
4
//2、把这个Car这个组件自动注册到容器中
5
public class MyConfig {
6
}

1
@Component
2
@ConfigurationProperties(prefix = "person")
3
@Validated
4
public class Person {
5

6
    /**
7
     * <bean class="Person">
8
     *      <property name="lastName" value="字面量/${key}从环境变量、配置文件中获取值/#{SpEL}"></property>
9
     * <bean/>
10
     */
11

12
   //lastName必须是邮箱格式
13
    @Email
14
    //@Value("${person.last-name}")
15
    private String lastName;
16
    //@Value("#{11*2}")
17
    private Integer age;
18
    //@Value("true")
19
    private Boolean boss;
20

21
    private Date birth;
22
    private Map<String,Object> maps;
23
    private List<Object> lists;
24
    private Dog dog;

1
属性配置类的
2
server:
3
  port: 8082
4
spring:
5
  main:
6
    banner-mode: console
7
    自定义
8
alipay:
9
  pay:
10
    appid: 123456
11
    notify: http://www.xxx.com

1
package com.kuangstudy.web.properties;
2

3
import org.springframework.beans.factory.annotation.Autowired;
4
import org.springframework.core.env.Environment;
5
import org.springframework.web.bind.annotation.GetMapping;
6
import org.springframework.web.bind.annotation.RestController;
7

8
import java.util.HashMap;
9
import java.util.Map;
10
import java.util.Properties;
11
import java.util.Set;
12

13
   @RestController
14
   public class ReadPropertiesEnvironment {
15

16
       @Autowired
17
       private Environment environment;
18

19
        @GetMapping("/read/file")
20
        public Map<String,Object> readInfo(){
21
            Map<String,Object> map = new HashMap<>();
22
            map.put("port",environment.getProperty("server.port"));
23
            map.put("appid",environment.getProperty("alipay.pay.appid"));
24
            map.put("notify",environment.getProperty("alipay.pay.notify"));
25
            map.put("javaversion",environment.getProperty("java.version"));
26
            map.put("javahome",environment.getProperty("JAVA_HOME"));
27
            map.put("mavenhome",environment.getProperty("MAVEN_HOME"));
28
            return  map;
29
        }
30

31
        public static void main(String[] args) {
32
            Properties properties = System.getProperties();
33
            Set<String> strings = properties.stringPropertyNames();
34
            for (String string : strings) {
35
                System.out.println(string+"===>"+properties.get(string));
36
            }
37

38
        }
39
  }

1
package com.kuangstudy.web.properties;
2

3
import org.springframework.beans.factory.annotation.Autowired;
4
import org.springframework.beans.factory.annotation.Value;
5
import org.springframework.core.env.Environment;
6
import org.springframework.web.bind.annotation.GetMapping;
7
import org.springframework.web.bind.annotation.RestController;
8

9
import java.util.HashMap;
10
import java.util.Map;
11
import java.util.Properties;
12
import java.util.Set;
13

14
/**
15
 * Description:
16
 * Author: yykk Administrator
17
 * Version: 1.0
18
 * Create Date Time: 2021/12/11 21:25.
19
 * Update Date Time:
20
 *
21
 * @see
22
 */
23
@RestController
24
public class ReadPropertiesValue {
25

26
    @Value("${server.port}")
27
    private Integer port;
28
    @Value("${alipay.pay.appid}")
29
    private String appid;
30
    @Value("${alipay.pay.notify}")
31
    private String notify;
32
    @Value("${java.version}")
33
    private String javaVersion;
34
    @Value("${JAVA_HOME}")
35
    private String javaHome;
36
    @Value("${MAVEN_HOME}")
37
    private String mavenHome;
38

39

40
    @GetMapping("/read/value")
41
    public Map<String, Object> readInfo() {
42
        Map<String, Object> map = new HashMap<>();
43
        map.put("port", port);
44
        map.put("appid", appid);
45
        map.put("notify", notify);
46
        map.put("javaversion", javaVersion);
47
        map.put("javahome", javaHome);
48
        map.put("mavenhome", mavenHome);
49
        return map;
50
    }
51

52
}

1
## 自定义属性
2
ksd:
3
  alipay:
4
    appid: 2021003100625328
5
    mkey: MIIEvwIBADANBgkqhkiG9w0BAQEFAASCBKkwggSlAgEAAoIBAQC9kGK4VMbYm
6
    ckey: MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAx5i5LhEtDZw6Q6mUxkC5f6sAvZm9OncAkRXwfoBdDeKk
7
    callback: https://www.txnh.net/api/alipay/returnUrl
8
    charset: utf-8

1
package com.kuangstudy.web.properties;
2

3
import lombok.Data;
4
import org.springframework.beans.factory.annotation.Value;
5
import org.springframework.boot.context.properties.ConfigurationProperties;
6

7
/**
8
 * Description:
9
 * Author: yykk Administrator
10
 * Version: 1.0
11
 * Create Date Time: 2021/12/14 20:53.
12
 * Update Date Time:
13
 *
14
 * @see
15
 */
16
@Configuration
17
@ConfigurationProperties(prefix = "ksd.alipay")//这个注解是用找到类
18
@Data
19
public class AlipayProperties {
20
    private String appid;
21
    private String mkey;
22
    private String ckey;
23
    private String callback;
24
    private String charset;
25
}

1
${random.value}、${random.int}、${random.long}
2
${random.int(10)}、${random.int[1024,65536]}

1
person.last-name=张三${random.uuid}
2
person.age=${random.int}
3
person.birth=2017/12/15
4
person.boss=false
5
person.maps.k1=v1
6
person.maps.k2=14
7
person.lists=a,b,c
8
person.dog.name=${person.hello:hello}_dog
9
person.dog.age=15

1
当需要在springboot中引用其他的yml文件时，需要在application.yml里配置
2

3
spring:
4
    profiles:
5
        include: email,xmyb
6

7

8
值得注意的是：application-email.yml的前缀一定要和主在配置文件application.yml的名字一致

1
server:
2
  port: 8081
3
spring:
4
  profiles:
5
    active: prod
6

7
---
8
server:
9
  port: 8083
10
spring:
11
  profiles: dev
12

13

14
---
15

16
server:
17
  port: 8084
18
spring:
19
  profiles: prod  #指定属于哪个环境

1
@AutoConfigurationPackage
2
@Import(AutoConfigurationImportSelector.class)
3
public @interface EnableAutoConfiguration {}

1
虽然我们127个场景的所有自动配置启动的时候默认全部加载。xxxxAutoConfiguration
2
按照条件装配规则（@Conditional），最终会按需配置。

1
        @Bean
2
    @ConditionalOnBean(MultipartResolver.class)  //容器中有这个类型组件
3
    @ConditionalOnMissingBean(name = DispatcherServlet.MULTIPART_RESOLVER_BEAN_NAME) //容器中没有这个名字 multipartResolver 的组件
4
    public MultipartResolver multipartResolver(MultipartResolver resolver) {
5
            //给@Bean标注的方法传入了对象参数，这个参数的值就会从容器中找。
6
            //SpringMVC multipartResolver。防止有些用户配置的文件上传解析器不符合规范
7
      // Detect if the user has created a MultipartResolver but named it incorrectly
8
      return resolver;
9
    }
10
给容器中加入了文件上传解析器；

1
@Bean
2
  @ConditionalOnMissingBean
3
  public CharacterEncodingFilter characterEncodingFilter() {
4
    }

1
## Auto Configure
2
org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
3
org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
4
org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
5
org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration,\
6
org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
7
org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
8
org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
9
org.springframework.boot.autoconfigure.cloud.CloudAutoConfiguration,\
10
org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
11
org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
12
org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
13
org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
14
org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
15
org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
16
org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
17
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
18
org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
19
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,\
20
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
21
org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
22
org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
23
org.springframework.boot.autoconfigure.data.ldap.LdapDataAutoConfiguration,\
24
org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
25
org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
26
org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
27
org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
28
org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
29
org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
30
org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
31
org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\
32
org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,\
33
org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration,\
34
org.springframework.boot.autoconfigure.elasticsearch.jest.JestAutoConfiguration,\
35
org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
36
org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration,\
37
org.springframework.boot.autoconfigure.h2.H2ConsoleAutoConfiguration,\
38
org.springframework.boot.autoconfigure.hateoas.HypermediaAutoConfiguration,\
39
org.springframework.boot.autoconfigure.hazelcast.HazelcastAutoConfiguration,\
40
org.springframework.boot.autoconfigure.hazelcast.HazelcastJpaDependencyAutoConfiguration,\
41
org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration,\
42
org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration,\
43
org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration,\
44
org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
45
org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\
46
org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,\
47
org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,\
48
org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\
49
org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration,\
50
org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,\
51
org.springframework.boot.autoconfigure.jms.JndiConnectionFactoryAutoConfiguration,\
52
org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration,\
53
org.springframework.boot.autoconfigure.jms.artemis.ArtemisAutoConfiguration,\
54
org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
55
org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,\
56
org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration,\
57
org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
58
org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,\
59
org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration,\
60
org.springframework.boot.autoconfigure.ldap.LdapAutoConfiguration,\
61
org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration,\
62
org.springframework.boot.autoconfigure.mail.MailSenderAutoConfiguration,\
63
org.springframework.boot.autoconfigure.mail.MailSenderValidatorAutoConfiguration,\
64
org.springframework.boot.autoconfigure.mobile.DeviceResolverAutoConfiguration,\
65
org.springframework.boot.autoconfigure.mobile.DeviceDelegatingViewResolverAutoConfiguration,\
66
org.springframework.boot.autoconfigure.mobile.SitePreferenceAutoConfiguration,\
67
org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,\
68
org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
69
org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration,\
70
org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
71
org.springframework.boot.autoconfigure.reactor.ReactorAutoConfiguration,\
72
org.springframework.boot.autoconfigure.security.SecurityAutoConfiguration,\
73
org.springframework.boot.autoconfigure.security.SecurityFilterAutoConfiguration,\
74
org.springframework.boot.autoconfigure.security.FallbackWebSecurityAutoConfiguration,\
75
org.springframework.boot.autoconfigure.security.oauth2.OAuth2AutoConfiguration,\
76
org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration,\
77
org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
78
org.springframework.boot.autoconfigure.social.SocialWebAutoConfiguration,\
79
org.springframework.boot.autoconfigure.social.FacebookAutoConfiguration,\
80
org.springframework.boot.autoconfigure.social.LinkedInAutoConfiguration,\
81
org.springframework.boot.autoconfigure.social.TwitterAutoConfiguration,\
82
org.springframework.boot.autoconfigure.solr.SolrAutoConfiguration,\
83
org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,\
84
org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,\
85
org.springframework.boot.autoconfigure.transaction.jta.JtaAutoConfiguration,\
86
org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration,\
87
org.springframework.boot.autoconfigure.web.DispatcherServletAutoConfiguration,\
88
org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration,\
89
org.springframework.boot.autoconfigure.web.ErrorMvcAutoConfiguration,\
90
org.springframework.boot.autoconfigure.web.HttpEncodingAutoConfiguration,\
91
org.springframework.boot.autoconfigure.web.HttpMessageConvertersAutoConfiguration,\
92
org.springframework.boot.autoconfigure.web.MultipartAutoConfiguration,\
93
org.springframework.boot.autoconfigure.web.ServerPropertiesAutoConfiguration,\
94
org.springframework.boot.autoconfigure.web.WebClientAutoConfiguration,\
95
org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration,\
96
org.springframework.boot.autoconfigure.websocket.WebSocketAutoConfiguration,\
97
org.springframework.boot.autoconfigure.websocket.WebSocketMessagingAutoConfiguration,\
98
org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration

1
@Configuration   //表示这是一个配置类，以前编写的配置文件一样，也可以给容器中添加组件
2
@EnableConfigurationProperties(HttpEncodingProperties.class)  //启动指定类的ConfigurationProperties功能；将配置文件中对应的值和HttpEncodingProperties绑定起来；并把HttpEncodingProperties加入到ioc容器中
3

4
@ConditionalOnWebApplication //Spring底层@Conditional注解（Spring注解版），根据不同的条件，如果满足指定的条件，整个配置类里面的配置就会生效；    判断当前应用是否是web应用，如果是，当前配置类生效
5

6
@ConditionalOnClass(CharacterEncodingFilter.class)  //判断当前项目有没有这个类CharacterEncodingFilter；SpringMVC中进行乱码解决的过滤器；
7

8
@ConditionalOnProperty(prefix = "spring.http.encoding", value = "enabled", matchIfMissing = true)  //判断配置文件中是否存在某个配置  spring.http.encoding.enabled；如果不存在，判断也是成立的
9
//即使我们配置文件中不配置pring.http.encoding.enabled=true，也是默认生效的；
10
public class HttpEncodingAutoConfiguration {
11

12
    //他已经和SpringBoot的配置文件映射了
13
    private final HttpEncodingProperties properties;
14

15
   //只有一个有参构造器的情况下，参数的值就会从容器中拿
16
    public HttpEncodingAutoConfiguration(HttpEncodingProperties properties) {
17
    this.properties = properties;
18
  }
19

20
    @Bean   //给容器中添加一个组件，这个组件的某些值需要从properties中获取
21
  @ConditionalOnMissingBean(CharacterEncodingFilter.class) //判断容器没有这个组件？
22
  public CharacterEncodingFilter characterEncodingFilter() {
23
    CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
24
    filter.setEncoding(this.properties.getCharset().name());
25
    filter.setForceRequestEncoding(this.properties.shouldForce(Type.REQUEST));
26
    filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));
27
    return filter;
28
  }

1
**=****=****=****=****=**
2
AUTO-CONFIGURATION REPORT
3
**=****=****=****=****=**
4

5

6
Positive matches:（自动配置类启用的）
7
-----------------
8

9
   DispatcherServletAutoConfiguration matched:
10
      - @ConditionalOnClass found required class 'org.springframework.web.servlet.DispatcherServlet'; @ConditionalOnMissingClass did not find unwanted class (OnClassCondition)
11
      - @ConditionalOnWebApplication (required) found StandardServletEnvironment (OnWebApplicationCondition)
12

13

14
Negative matches:（没有启动，没有匹配成功的自动配置类）
15
-----------------
16

17
   ActiveMQAutoConfiguration:
18
      Did not match:
19
         - @ConditionalOnClass did not find required classes 'javax.jms.ConnectionFactory', 'org.apache.activemq.ActiveMQConnectionFactory' (OnClassCondition)
20

21
   AopAutoConfiguration:
22
      Did not match:
23
         - @ConditionalOnClass did not find required classes 'org.aspectj.lang.annotation.Aspect', 'org.aspectj.lang.reflect.Advice' (OnClassCondition)