Spring Boot Configuration --- 02

Second, the configuration file

1. Profiles

SpringBoot use a global configuration file, the configuration file name is fixed

• application.properies
• application.yml

Profile role: Modify the default value SpringBoot auto-configuration; SpringBot on the ground floor gave us automatically configured;

Yamla (Yamla an't Markup Language)

YAML A Markup Language: is a markup language

YANL is not Markup Language: is not a markup language

Markup Language:

Previous profile: Most are using xxxx.xml file

YAML: data-centric than json, xml and so is more suitable for the configuration file

YAML: Configuration example

server:
    port:8081

​ XML：

<server>
    <port>8081</port>
</server>

2. YAML syntax

1. Basic grammar

k: Space v: designates a key-value pair (space must);

Whitespace indentation to control the hierarchy; as long as one is left-aligned data, is a hierarchy

server:
    port: 8081
    path: /hello

Attributes and values ​​are case sensitive

2. The value of the wording

Literal: Common values ​​(numbers, strings, Boolean)

k: v: literally write directly

String default without adding a single or double quotes

"": Double quotes; there will not escape the string of special characters; special characters as themselves wish of intention

name: "zhangsan \ n lisi": line feed output zhangsan lisi

'': Single quote; will escape special characters, special characters ultimately just an ordinary character

name: 'zhangsan \ n lisi': output zhangsan \ n lisi

Object, Map (attributes and values) (key-value pairs):

k: v: the relationship between attributes and values ​​of an object to write the next line; note indentation

Object or k: v way

friends
    lastName: zhangsan
    age: 20

Inline wording:

friends: {lastName: zhangsan,age: 18}

Array (List, Set)

Represents an element in the array values ​​- with

pets:
 - cat
 - dog
 - pig

Inline wording

pets: [cat,dog,pig]

3. The injection profile values

1. properties utf-8 default configuration file may be garbled in the idea of

2. @Value acquisition value and acquisition value comparison @ComfigurationProperties

	@ComfigurationProperties	@Value
Features	Batch injection configuration file	A designated
Loosely bound (loose syntax)	stand by	not support
Game	not support	stand by
JSR303 data check	stand by	not support

Profile yml or properties they can get to value;

If you say that we just need to get some business logic at a particular value of the configuration file, use the @Value;

If we say that we wrote a javaBean dedicated to mapping and configuration files, we just use @ComfigurationProperties;

3. The values ​​of the check injection profile

@Component
@ConfigurationProperties(prefix = "person")  //默认从全局文件中获取值
@Validated   //校验
public class Person {

    /**
     *  <bean class="person">
     *     <property name="lastName" value="字面量/${key}从环境、配置文件中获取值/#{SpEL}"
     *  </bean>
     */
    //@Value("${person.last-name}")
    //@Email    //lastName必须是邮箱格式
    private String lastName;
    //@Value("#{11*2}")
    private Integer age;
    //@Value("true")
    private Boolean boss;
    
    private Date birth;
    private Map<String,Object> maps;
    private List<Object> lists;
    private Dog dog;
}

4. @PropertySource&@ImportResource

@ PropertySource : load the specified configuration file

@PropertySource(value = {"classpath:person.properties"})
@Component
@ConfigurationProperties(prefix = "person")
@Validated   //校验
public class Person {}

@ ImportResource : Importing Spring configuration file, so that the contents of the configuration file which is to take effect;

Spring Boot there is no Spring configuration file, write our own configuration files, it can not automatically identify;

Would like Spring configuration file to take effect, came loaded; @ ImportResource marked on a configuration class

//导入Spring的配置文件，让其生效
@ImportResource(locations = {"classpath:beans.xml"})
@SpringBootApplication
public class SpringBootQuickApplication {

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

}

Not to write the Spring configuration file

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd">

    <bean id="helloService" class="com.spring.springbootquick.service.HelloService"></bean>
</beans>

SpringBoot recommended way to add components to the container; recommended full annotation

1. 配置类========Spring的配置文件

2. 使用@Bean给容器中添加组件

/**
 * @Configuration，指明当前类是一个配置类；就是用来替代之前的Sping配置文件
 * 在配置文件中用<bean></bean>标签添加组件
 */
@Configuration
public class MyAppConfig {

    //将方法的返回值添加到容器中，容器中这个组件默认的id就是方法名
    @Bean
    public HelloService helloService(){
        return new HelloService();
    }
}

4. configuration file placeholder

1. Random Number

$(random.value)
$(random.int)
$(random.long)
$(random.int(10))
$(random.int[1024,65536])

2. placeholder value acquired previously configured, may be used if not: specify the default value

person.lastName=zhangsan${random.uuid}
person.age=${random.int}
person.birth=2010/10/10
person.boss=false
person.maps.k1=v1
person.maps.k2=v2
person.lists=a,b,c
person.dog.name=${person.hello:hello}_dog
person.dog.age=15

5. Profile

Spring Profile is configured to provide different functions to different environments to support, through activation of fast switching, the specified parameters, etc.

1. Multi-Profile file

We in the preparation of the master configuration file, the file name may be application- (profile) .properties / yml

Application.properties use the default configuration;

2. yml support multiple block the way

server:
  port: 8081
spring:
  profiles:
    active: prod

---
server:
  port: 8082
spring:
  profiles: dev

---
server:
  port: 8083
spring:
  profiles: prod  #指定属于哪个环境

3. Activate the specified profile

1. Specified in the configuration file

   spring.profiles.active=dev

2. Command Line

   java -jar spring-boot-config.0.0.1-SNAPSHOT.jar --spring.profiles.active=dev

3. Virtual machine parameters:

   -Dspring-profiles.active=dev

6. The configuration file is loaded position

application.properties application.yml file or scan the following Spring Boot startup location as Spring Boot default configuration file

-file:./config/
-file:./
-classpath:/config/
-classpath:/

These are in descending order of priority, all the files are loaded position, the high priority of the contents will be overwritten low priority configuration content

SpringBoot will be loaded from the four positions of all main configuration file: complementary configuration

We can also change the default configuration by configuring spring.config.location

After a good project package, we can use the command-line parameters in the form of, when the project started to specify the new location of the configuration file; specify the configuration file and the default load of these configuration files work together to form a complementary configuration;

7. The external configuration loading sequence

SpringBoot may also be loaded from the location profile; low priority level; high priority configuration override lower priority configuration, all configuration complementary configuration formed

1. Command line parameters

java -jar spring-boot-config.0.0.1-SNAPSHOT.jar --server.port=8085 --server.context.path=/abc

1. NDI properties comp / env: From java

2. Java system properties (System.getProperties ())

3. Operating system environment variables

4. random RandomValuePropertySource configuration. * Property Value

From the outer to the inner jar package jar package
is loaded first profile strip

1. jar outer package or application- {profile} .properties application.yml (with spring.profile) profile

2. Internal jar package application- {profile} .properties or application.yml (with spring.profile) profile

3. jar or outer package application.properties application.yml (without spring.profile) profile

4. Internal jar package application.properties or application.yml (without spring.profile) profile

5. @PropertySource class notes on @Configuration

6. By SpringApplication.setDefaultProperties specified default property

All supported configurations loaded Source: refer to the official documentation

8. Automatic Configuration Principle

Profiles in the end what to write? how to write? Automatic Configuration principle:

Profiles can be configured with reference to the attributes

1. Automatic Configuration Principle

• SpringBoot activated when the load master class configuration, open the automatic configuration @EnableAutoConfiguration

• @EnableAutoConfiguration作用：

  • EnableAutoConfigurationImportSelector introduced using some components to vessel

  • Content can be viewed selectimports () method

  • List configurations = this.getCandidateConfigurations (annotationMetadata, attributes); obtaining candidates configuration

    • SpringFactoriesLoader.loadFactoryNames
      扫描所有jar包类路径下的  META-INF/spring.factories
      把扫描到的这些文件内容包装成properties对象
      从properties中获取到EnableAutoConfiguration.class类 (类名)对应的值，然后把他们添加到容器中

    The values ​​of all EnableAutoConfiguration the META-INF / spring.factories classpath arranged inside added to the vessel;

    # 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,\
    org.springframework.boot.autoconfigure.batch.BatchAutoConfiguration,\
    org.springframework.boot.autoconfigure.cache.CacheAutoConfiguration,\
    org.springframework.boot.autoconfigure.cassandra.CassandraAutoConfiguration,\
    org.springframework.boot.autoconfigure.cloud.CloudAutoConfiguration,\
    org.springframework.boot.autoconfigure.context.ConfigurationPropertiesAutoConfiguration,\
    org.springframework.boot.autoconfigure.context.MessageSourceAutoConfiguration,\
    org.springframework.boot.autoconfigure.context.PropertyPlaceholderAutoConfiguration,\
    org.springframework.boot.autoconfigure.couchbase.CouchbaseAutoConfiguration,\
    org.springframework.boot.autoconfigure.dao.PersistenceExceptionTranslationAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.cassandra.CassandraDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.cassandra.CassandraRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.couchbase.CouchbaseDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.couchbase.CouchbaseRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.elasticsearch.ElasticsearchRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.jpa.JpaRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.ldap.LdapDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.ldap.LdapRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.mongo.MongoDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.mongo.MongoRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.neo4j.Neo4jDataAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.neo4j.Neo4jRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.solr.SolrRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.redis.RedisRepositoriesAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.rest.RepositoryRestMvcAutoConfiguration,\
    org.springframework.boot.autoconfigure.data.web.SpringDataWebAutoConfiguration,\
    org.springframework.boot.autoconfigure.elasticsearch.jest.JestAutoConfiguration,\
    org.springframework.boot.autoconfigure.freemarker.FreeMarkerAutoConfiguration,\
    org.springframework.boot.autoconfigure.gson.GsonAutoConfiguration,\
    org.springframework.boot.autoconfigure.h2.H2ConsoleAutoConfiguration,\
    org.springframework.boot.autoconfigure.hateoas.HypermediaAutoConfiguration,\
    org.springframework.boot.autoconfigure.hazelcast.HazelcastAutoConfiguration,\
    org.springframework.boot.autoconfigure.hazelcast.HazelcastJpaDependencyAutoConfiguration,\
    org.springframework.boot.autoconfigure.info.ProjectInfoAutoConfiguration,\
    org.springframework.boot.autoconfigure.integration.IntegrationAutoConfiguration,\
    org.springframework.boot.autoconfigure.jackson.JacksonAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.JdbcTemplateAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.JndiDataSourceAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.XADataSourceAutoConfiguration,\
    org.springframework.boot.autoconfigure.jdbc.DataSourceTransactionManagerAutoConfiguration,\
    org.springframework.boot.autoconfigure.jms.JmsAutoConfiguration,\
    org.springframework.boot.autoconfigure.jmx.JmxAutoConfiguration,\
    org.springframework.boot.autoconfigure.jms.JndiConnectionFactoryAutoConfiguration,\
    org.springframework.boot.autoconfigure.jms.activemq.ActiveMQAutoConfiguration,\
    org.springframework.boot.autoconfigure.jms.artemis.ArtemisAutoConfiguration,\
    org.springframework.boot.autoconfigure.flyway.FlywayAutoConfiguration,\
    org.springframework.boot.autoconfigure.groovy.template.GroovyTemplateAutoConfiguration,\
    org.springframework.boot.autoconfigure.jersey.JerseyAutoConfiguration,\
    org.springframework.boot.autoconfigure.jooq.JooqAutoConfiguration,\
    org.springframework.boot.autoconfigure.kafka.KafkaAutoConfiguration,\
    org.springframework.boot.autoconfigure.ldap.embedded.EmbeddedLdapAutoConfiguration,\
    org.springframework.boot.autoconfigure.ldap.LdapAutoConfiguration,\
    org.springframework.boot.autoconfigure.liquibase.LiquibaseAutoConfiguration,\
    org.springframework.boot.autoconfigure.mail.MailSenderAutoConfiguration,\
    org.springframework.boot.autoconfigure.mail.MailSenderValidatorAutoConfiguration,\
    org.springframework.boot.autoconfigure.mobile.DeviceResolverAutoConfiguration,\
    org.springframework.boot.autoconfigure.mobile.DeviceDelegatingViewResolverAutoConfiguration,\
    org.springframework.boot.autoconfigure.mobile.SitePreferenceAutoConfiguration,\
    org.springframework.boot.autoconfigure.mongo.embedded.EmbeddedMongoAutoConfiguration,\
    org.springframework.boot.autoconfigure.mongo.MongoAutoConfiguration,\
    org.springframework.boot.autoconfigure.mustache.MustacheAutoConfiguration,\
    org.springframework.boot.autoconfigure.orm.jpa.HibernateJpaAutoConfiguration,\
    org.springframework.boot.autoconfigure.reactor.ReactorAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.SecurityAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.SecurityFilterAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.FallbackWebSecurityAutoConfiguration,\
    org.springframework.boot.autoconfigure.security.oauth2.OAuth2AutoConfiguration,\
    org.springframework.boot.autoconfigure.sendgrid.SendGridAutoConfiguration,\
    org.springframework.boot.autoconfigure.session.SessionAutoConfiguration,\
    org.springframework.boot.autoconfigure.social.SocialWebAutoConfiguration,\
    org.springframework.boot.autoconfigure.social.FacebookAutoConfiguration,\
    org.springframework.boot.autoconfigure.social.LinkedInAutoConfiguration,\
    org.springframework.boot.autoconfigure.social.TwitterAutoConfiguration,\
    org.springframework.boot.autoconfigure.solr.SolrAutoConfiguration,\
    org.springframework.boot.autoconfigure.thymeleaf.ThymeleafAutoConfiguration,\
    org.springframework.boot.autoconfigure.transaction.TransactionAutoConfiguration,\
    org.springframework.boot.autoconfigure.transaction.jta.JtaAutoConfiguration,\
    org.springframework.boot.autoconfigure.validation.ValidationAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.DispatcherServletAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.EmbeddedServletContainerAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.ErrorMvcAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.HttpEncodingAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.HttpMessageConvertersAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.MultipartAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.ServerPropertiesAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.WebClientAutoConfiguration,\
    org.springframework.boot.autoconfigure.web.WebMvcAutoConfiguration,\
    org.springframework.boot.autoconfigure.websocket.WebSocketAutoConfiguration,\
    org.springframework.boot.autoconfigure.websocket.WebSocketMessagingAutoConfiguration,\
    org.springframework.boot.autoconfigure.webservices.WebServicesAutoConfiguration

    Each of these classes are xxxAutoConfiguration a container assembly, are added to the vessel; to do with their auto-configuration;

• Each class is automatically configure auto-configuration;

• HttpEncodingAutoConfiguration an example to explain the principle of auto-configuration;

  @Configuration  //表示这是一个配置类，以前编写的配置文件一样，也可以给容器中添加组件
  @EnableConfigurationProperties({HttpEncodingProperties.class})  //启动指定类的ConfigurationProperties功能；将配置文件中对应的值和HttpEncodingProperties绑定起来；并把HttpEncodingProperties加入到ioc容器中
  
  @ConditionalOnWebApplication  //Spring底层@Conditional注解，根据不同的条件，如果满足指定的条件，整个配置类里面的配置就会生效； 判断当前应用是否是web应用，如果是，当前配置类生效
  
  @ConditionalOnClass({CharacterEncodingFilter.class})  //判断当前这个项目有没有这个类 CharacterEncodingFilter：SpringMVC中进行乱码解决的过滤器
  
  @ConditionalOnProperty(
      prefix = "spring.http.encoding",
      value = {"enabled"},
      matchIfMissing = true
  )  //判断配置文件中是否存在某个配置 spring.http.encoding.enabled ;如果不存在，判断也是成立的
  //即使我们配置文件中不配置spring.http.encoding.enabled-true，也是默认生效的
  public class HttpEncodingAutoConfiguration {
  
      //他已经和SpringBoot的配置文件映射了
      private final HttpEncodingProperties properties;
  
      //只有一个有参构造器的情况下，参数的值就会从容器中拿
      public HttpEncodingAutoConfiguration(HttpEncodingProperties properties) {
          this.properties = properties;
      }
  
  
      @Bean  //给容器中添加一个组件，这个组件的某些值需要从properties中获取
      @ConditionalOnMissingBean({CharacterEncodingFilter.class})
      public CharacterEncodingFilter characterEncodingFilter() {
          CharacterEncodingFilter filter = new OrderedCharacterEncodingFilter();
          filter.setEncoding(this.properties.getCharset().name());
          filter.setForceRequestEncoding(this.properties.shouldForce(Type.REQUEST));
          filter.setForceResponseEncoding(this.properties.shouldForce(Type.RESPONSE));
          return filter;
      }  //给容器中

  Depending on the current conditions is determined, the decision is in effect the configuration class

  Once the configuration class into effect, this class will be added to the configuration of the various components in the container; properties of these components are obtained from the corresponding properties of the class, each of these classes which is a property of binding and profile;

• All the attributes in the configuration file that can be configured are encapsulated in the class xxxxProperties; what configuration file can be configured to reference a function corresponding to the attribute class

  @ConfigurationProperties(    
      prefix = "spring.http.encoding"
  )   //从配置文件中获取指定的值和bean的属性进行绑定
  public class HttpEncodingProperties {    
      public static final Charset DEFAULT_CHARSET = Charset.forName("UTF-8");

Spring Boot essence:

• SpringBoot will start loading large amounts of specified configuration class
• We need to look at the features we have not specified the default configuration class SpringBoot written
• Let's look at this in the end configuration automatically configures the class in which components; (as long as we have to use component, we do not need to come back configuration)
• Find the configuration class to add components when the container will get certain properties from the properties in class, we can specify the values ​​of these properties in the configuration file

xxxxAutoConfiguration: automatic configuration class;

Adding components to the container

xxxxProperties: encapsulation configuration file related attributes