springboot中application.yml的文件配置是怎样的

#配置内置tomcat启动端口
server.port=8080
#给程序起个名字
spring.application.name=boot-helloworld

#配置内置tomcat启动端口
server:
  port: 8080
#应用名称
spring:
  application:
    name: boot-helloworld

spring:
  application:
    name: boot-helloworld
#redis连接池配置， 可以换行保持缩进，连着写
  redis:
    host: localhost
    port: 6379
    password: password
    timeOut: 5000
    maxIdle: 50
    maxWaitMillis: 5000
    maxTotal: 500

server:
  port: 8081

spring:
  application:
    name: boot-helloworld

#默认情况下springboot使用Logback作为日志框架
#logging.level开头，指定一个依赖的groupId然后，指定日志级别
logging:
  level:
    org.springframeword.web: debug

#只需要在application.properties中设置spring.profiles.active=prod来指定活动的profile即可
#如下表示采用application-test.yml
#默认使用default(application.yml),这样可以区分开发、线上、测试，preview等环境
spring:
  profiles:
    active: test

#在所有接口访问路径之前需要加/boot
server:
  servlet:
    context-path: /boot

/**
 * 当作一个配置项，简单处理
 * @author Calvin
 * @date 2019/07/24
 */
public class User {

    /**
     * ID
     */
    private String id;

    /**
     * 名字
     */
    private String userName;

    /**
     * 年龄
     */
    private Integer age;

    /**
     * 性别
     */
    private String gender;

    /**
     * 所使用的操作系统
     */
    private String systemName;


    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public Integer getAge() {
        return age;
    }

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

    public String getGender() {
        return gender;
    }

    public void setGender(String gender) {
        this.gender = gender;
    }

    public String getSystemName() {
        return systemName;
    }

    public void setSystemName(String systemName) {
        this.systemName = systemName;
    }

    @Override
    public String toString() {
        return "User{" +
                "id='" + id + '\'' +
                ", userName='" + userName + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", systemName='" + systemName + '\'' +
                '}';
    }
}

spring:
  application:
    name: boot-helloworld

logging:
  level:
    org.springframeword.web: debug
server:
  servlet:
    context-path: /boot

# admin年龄的值配置
admin:
  age: 20

/**
 * 测试@Value注解的各种方式
 * @author Calvin
 * @date 2019/07/24
 */
@RestController
@RequestMapping("/value")
public class ValueController {


    /**
     * ID 采用表达式注解
     */
    @Value("#{ T(java.util.UUID).randomUUID()}")
    private String adminId;

    /**
     * name 采用值注解获取一个UUID
     */
    @Value("Calvin")
    private String adminName;

    /**
     * gender 给定一个默认值，如果没有定义，就采用默认值
     */
    @Value("${admin.gender: 男}")
    private String adminGender;

    /**
     * 注入yml文件中的admin.age
     */
    @Value("${admin.age}")
    private Integer adminAge;

    /**
     * 采用表达式获取系统变量
     */
    @Value("#{systemProperties['os.name']}")
    private String systemName;

    /**
     * 获取用户信息
     * @return
     */
    @GetMapping("/getUserInfo")
    public User getAdminInfo(){
        User admin = new User();
        admin.setId(adminId);
        admin.setUserName(adminName);
        admin.setAge(adminAge);
        admin.setGender(adminGender);
        admin.setSystemName(systemName);
        return admin;
    }

}

//main方法，程序入口
SpringApplication.run(BootApplication.class, args);

//实例化SpringApplication并且调用run方法
return new SpringApplication(primarySources).run(args);

//此方法中实例化Environment
ConfigurableEnvironment environment = prepareEnvironment(listeners, applicationArguments);

//因为我是Web程序，用的是spring-boot-starter-web依赖，所以是StandardServletEnvironment
private ConfigurableEnvironment getOrCreateEnvironment() {
	//省略部分代码
	return new StandardServletEnvironment();
}
//因为StandardServletEnviroment extends AbstractEnvironment
//而AbstractEnvironment构造器中中调用了customizePropertySources()方法
public AbstractEnvironment() {
	//模板方法，大家都懂得
	customizePropertySources(this.propertySources);
}

protected void customizePropertySources(MutablePropertySources propertySources) {
	//将servletConfigInitParams添加进PropertySource中
	propertySources.addLast(new StubPropertySource(SERVLET_CONFIG_PROPERTY_SOURCE_NAME));
	//将servletContextInitParams添加进PropertySource中
	propertySources.addLast(new StubPropertySource(SERVLET_CONTEXT_PROPERTY_SOURCE_NAME));
	if (JndiLocatorDelegate.isDefaultJndiEnvironmentAvailable()) {
		propertySources.addLast(new JndiPropertySource(JNDI_PROPERTY_SOURCE_NAME));
	}
	//调用AbstractEnvironment.customizePropertySources()方法
	super.customizePropertySources(propertySources);
}

@Override
protected void customizePropertySources(MutablePropertySources propertySources) {
	//添加systemProperties， 添加的是System.getProperties()，是一个Native方法，主要属性是
	//java.runtime.name | java.vm.version等系统配置的属性
	propertySources.addLast(
		new PropertiesPropertySource(SYSTEM_PROPERTIES_PROPERTY_SOURCE_NAME, getSystemProperties()));
	//添加systemEnvironment, 也就是系统环境变量， 其中包含JAVA_HOME等属性
	propertySources.addLast(
		new SystemEnvironmentPropertySource(SYSTEM_ENVIRONMENT_PROPERTY_SOURCE_NAME, getSystemEnvironment()));
}

public void environmentPrepared(ConfigurableEnvironment environment) {
	for (SpringApplicationRunListener listener : this.listeners) {
		listener.environmentPrepared(environment);
	}
}

@Override
public void onApplicationEvent(ApplicationEvent event) {
	if (event instanceof ApplicationEnvironmentPreparedEvent) {
		onApplicationEnvironmentPreparedEvent((ApplicationEnvironmentPreparedEvent) event);
	}
	if (event instanceof ApplicationPreparedEvent) {
		onApplicationPreparedEvent(event);
	}
}

private void load(String location, String name, Profile profile, DocumentFilterFactory filterFactory,
		DocumentConsumer consumer) {
	if (!StringUtils.hasText(name)) {
		for (PropertySourceLoader loader : this.propertySourceLoaders) {
			if (canLoadFileExtension(loader, location)) {
				load(loader, location, profile, filterFactory.getDocumentFilter(profile), consumer);
				return;
			}
		}
	}
	Set<String> processed = new HashSet<>();
	//遍历propertySourceLoaders
	for (PropertySourceLoader loader : this.propertySourceLoaders) {
		for (String fileExtension : loader.getFileExtensions()) {
			if (processed.add(fileExtension)) {
				//寻找配置文件
				loadForFileExtension(loader, location + name, "." + fileExtension, profile, filterFactory,
						consumer);
			}
		}
	}
}

[
	org.springframework.boot.env.PropertiesPropertySourceLoader, 
	org.springframework.boot.env.YamlPropertySourceLoader
]

/**
 *<p>
 *  <li>此类负责加载["properties", "xml"]后缀的配置文件
 *  <li>loadProerties负责读取配置文件中的内容
 *</p>
 */
public class PropertiesPropertySourceLoader implements PropertySourceLoader {

	private static final String XML_FILE_EXTENSION = ".xml";

	@Override
	public String[] getFileExtensions() {
		return new String[] { "properties", "xml" };
	}

	@Override
	public List<PropertySource<?>> load(String name, Resource resource) throws IOException {
		Map<String, ?> properties = loadProperties(resource);
		if (properties.isEmpty()) {
			return Collections.emptyList();
		}
		return Collections.singletonList(new OriginTrackedMapPropertySource(name, properties));
	}

	@SuppressWarnings({ "unchecked", "rawtypes" })
	private Map<String, ?> loadProperties(Resource resource) throws IOException {
		String filename = resource.getFilename();
		if (filename != null && filename.endsWith(XML_FILE_EXTENSION)) {
			return (Map) PropertiesLoaderUtils.loadProperties(resource);
		}
		return new OriginTrackedPropertiesLoader(resource).load();
	}

}

/**
 *<p>
 *  <li>此类负责加载["yml", "yaml"]后缀的配置文件
 *  <li>load负责读取配置文件中的内容
 *</p>
 */
public class YamlPropertySourceLoader implements PropertySourceLoader {

	@Override
	public String[] getFileExtensions() {
		return new String[] { "yml", "yaml" };
	}

	@Override
	public List<PropertySource<?>> load(String name, Resource resource) throws IOException {
		if (!ClassUtils.isPresent("org.yaml.snakeyaml.Yaml", null)) {
			throw new IllegalStateException(
					"Attempted to load " + name + " but snakeyaml was not found on the classpath");
		}
		List<Map<String, Object>> loaded = new OriginTrackedYamlLoader(resource).load();
		if (loaded.isEmpty()) {
			return Collections.emptyList();
		}
		List<PropertySource<?>> propertySources = new ArrayList<>(loaded.size());
		for (int i = 0; i < loaded.size(); i++) {
			String documentNumber = (loaded.size() != 1) ? " (document #" + i + ")" : "";
			propertySources.add(new OriginTrackedMapPropertySource(name + documentNumber, loaded.get(i)));
		}
		return propertySources;
	}

}

public List<Map<String, Object>> load() {
	final List<Map<String, Object>> result = new ArrayList<>();
	process((properties, map) -> result.add(getFlattenedMap(map)));
	return result;
}

private void buildFlattenedMap(Map<String, Object> result, Map<String, Object> source, @Nullable String path) {
	source.forEach((key, value) -> {
		if (StringUtils.hasText(path)) {
			if (key.startsWith("[")) {
				key = path + key;
			}
			else {
				key = path + '.' + key;
			}
		}
		if (value instanceof String) {
			result.put(key, value);
		}
		else if (value instanceof Map) {
			// Need a compound key
			@SuppressWarnings("unchecked")
			Map<String, Object> map = (Map<String, Object>) value;
			buildFlattenedMap(result, map, key);
		}
		else if (value instanceof Collection) {
			// Need a compound key
			@SuppressWarnings("unchecked")
			Collection<Object> collection = (Collection<Object>) value;
			if (collection.isEmpty()) {
				result.put(key, "");
			}
			else {
				int count = 0;
				for (Object object : collection) {
					buildFlattenedMap(result, Collections.singletonMap(
							"[" + (count++) + "]", object), key);
				}
			}
		}
		else {
			result.put(key, (value != null ? value : ""));
		}
	});
}