SpringBoot obtiene el valor del atributo personalizado en el archivo de configuración YAML

SpringBoot admite dos métodos de configuración: Propiedades y YAML. Ambos tienen funciones similares y pueden completar la configuración de SpringBoot, pero la prioridad de Propiedades es mayor que la de YAML (los archivos de idioma YAML tienen el sufijo ".yml").

Utilice el archivo application.yml para configurar el proyecto SpringBoot. Configure principalmente el número de puerto, el período de tiempo de espera, el valor del parámetro, etc. del proyecto SpringBoot. La ventaja del archivo YAML es que utiliza una estructura de árbol, que es clara de un vistazo. como sigue:

server:
  port: 8080
  servlet:
    session:
      timeout: 30M
  tomcat:
    uri-encoding: UTF-8
userinfo:
  user-id: 1
  user-name: pan_junbiao的博客
  blog-url: https://blog.csdn.net/pan_junbiao
  hobbys: -[篮球,足球,羽毛球,乒乓球,游泳]
  blog-remark: 您好，欢迎访问 pan_junbiao的博客

A continuación, se presentará el valor del atributo personalizado obtenido en el archivo de configuración YAML en el proyecto SpringBoot.

1. Método 1: use la anotación @Value

Ejemplo: cree el paquete com.pjb.properties, cree la clase UserProperties (clase de información de configuración del usuario) y use la anotación @Value para inyectar el contenido del archivo de configuración para cargar la información del archivo de configuración.

package com.pjb.properties;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

/**
 * 用户配置信息类
 * @author pan_junbiao
 **/
@Component
public class UserProperties
{
    /**
     * 用户编号
     */
    @Value("${userinfo.user-id}")
    private int userId;

    /**
     * 用户名称
     */
    @Value("${userinfo.user-name}")
    private String userName;

    /**
     * 博客地址
     */
    @Value("${userinfo.blog-url}")
    private String blogUrl;

    /**
     * 兴趣爱好
     */
    @Value("${userinfo.hobbys}")
    private String[] hobbys;

    /**
     * 备注信息
     */
    @Value("${userinfo.blog-remark}")
    private String blogRemark;

    //省略getter与setter方法...
}

Escriba un método de prueba para obtener la información de configuración YAML del usuario.

import com.pjb.properties.UserProperties;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.Arrays;

/**
 * 用户配置测试类
 * @author pan_junbiao
 **/
@SpringBootTest
public class UserTest
{
    @Autowired
    private UserProperties userProperties;

    /**
     * 获取用户YAML配置信息
     * @author pan_junbiao
     */
    @Test
    public void getUserProperties()
    {
        System.out.println("获取application.yml配置文件中的信息：");
        System.out.println("用户编号：" + userProperties.getUserId());
        System.out.println("用户名称：" + userProperties.getUserName());
        System.out.println("博客地址：" + userProperties.getBlogUrl());
        System.out.println("兴趣爱好：共" + userProperties.getHobbys().length + "个，" + Arrays.toString(userProperties.getHobbys()));
        System.out.println("备注信息：" + userProperties.getBlogRemark());
    }
}

Resultados del:

 

2. Método 2: usar la anotación @ConfigurationProperties

Ejemplo: Modifique la clase UserProperties (clase de información de configuración del usuario) y use la anotación @ConfigurationProperties para procesar el valor del elemento de configuración con el prefijo "userinfo" en el archivo de configuración para cargar la información del archivo de configuración.

package com.pjb.properties;

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * 用户配置信息类
 * @author pan_junbiao
 **/
@Component
@ConfigurationProperties(prefix = "userinfo")
public class UserProperties
{
    /**
     * 用户编号
     */
    private int userId;

    /**
     * 用户名称
     */
    private String userName;

    /**
     * 博客地址
     */
    private String blogUrl;

    /**
     * 兴趣爱好
     */
    private String[] hobbys;

    /**
     * 备注信息
     */
    private String blogRemark;

    //省略getter与setter方法...
}

Descripción del código:

@Anotación de componente: declara que esta clase es una clase de gestión de Spring.

Anotación @ConfigurationProperties: encapsula automáticamente información de configuración similar en una clase de entidad. Su prefijo de atributo representa el prefijo del elemento de configuración en el archivo de configuración, como "userinfo" definido en el archivo de configuración.

También puede definir la anotación @ConfigurationProperties directamente en la anotación @Bean. En este momento, la clase de entidad Bean no necesita la anotación @Component y la anotación @ConfigurationProperties, y todavía se llama cuando se llama, como en el siguiente código :

@Bean
@ConfigurationProperties(prefix = "userinfo")
public UserInfo userInfo()
{
    return new UserInfo();
}

Resultados del:

 

3. Método 3: utilizar la forma de parámetros

Ejemplo: cree el archivo RedisConfig.java para leer la información de configuración del archivo application.yml.

/**
 * Redis配置类
 * @author pan_junbiao
 **/
@Configuration
public class RedisConfig
{
    /**
     * Jedis连接池
     */
    @Bean("jedis.pool")
    @Autowired
    public JedisPool jedisPool(@Qualifier("jedis.pool.config") JedisPoolConfig config,
                               @Value("${spring.redis.host}") String host,
                               @Value("${spring.redis.port}") int port)
    {
        return new JedisPool(config, host, port);
    }

    /**
     * Jedis连接池配置信息
     */
    @Bean(name = "jedis.pool.config")
    public JedisPoolConfig jedisPoolConfig(@Value("${spring.redis.jedis.pool.max-active}") int maxActive,
                                           @Value("${spring.redis.jedis.pool.max-wait}") Duration maxWait,
                                           @Value("${spring.redis.jedis.pool.max-idle}") int maxIdle,
                                           @Value("${spring.redis.jedis.pool.min-idle}") int minIdle)
    {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();

        //连接池最大连接数（使用负值表示没有限制）
        jedisPoolConfig.setMaxTotal(maxActive);

        //连接池最大阻塞等待时间（使用负值表示没有限制）
        jedisPoolConfig.setMaxWaitMillis(maxWait.toMillis());

        //连接池中的最大空闲连接
        jedisPoolConfig.setMaxIdle(maxIdle);

        //连接池中的最小空闲连接
        jedisPoolConfig.setMinIdle(minIdle);

        return jedisPoolConfig;
    }
}

 

4. Ejemplo completo

Ejemplo: configure la información de Redis en el archivo de configuración application.yml, cree la clase RedisConfig.java (clase de configuración de Redis) e inicialice el servicio de Redis.

(1) Configure la información de Redis en el archivo de configuración application.yml.

spring:
  redis:
    database: 0 #Redis数据库索引（默认为0）
    host: 127.0.0.1 #Redis服务器地址
    port: 6379 #Redis服务器连接端口
    password:  #Redis服务器连接密码（默认为空）
    jedis:
      pool:
        max-active: 8 #连接池最大连接数（使用负值表示没有限制）
        max-wait: -1s #连接池最大阻塞等待时间（使用负值表示没有限制）
        max-idle: 8  #连接池中的最大空闲连接
        min-idle: 0 #连接池中的最小空闲连接
    lettuce:
      shutdown-timeout: 100ms #关闭超时时间，默认值100ms

(2) Cree RedisProperties.java (clase de propiedad de configuración de Redis) y use la anotación @Value para inyectar el contenido del archivo de configuración para cargar la información del archivo de configuración.

package com.pjb.ems.properties;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import java.time.Duration;

/**
 * Redis配置属性类
 * @author pan_junbiao
 **/
@Component
public class RedisProperties
{
    /**
     * Redis数据库索引
     */
    @Value("${spring.redis.database}")
    private int database;

    /**
     * Redis服务器地址
     */
    @Value("${spring.redis.host}")
    private String host;

    /**
     * Redis服务器连接端口
     */
    @Value("${spring.redis.port}")
    private int port;

    /**
     * Redis服务器连接密码
     */
    @Value("${spring.redis.port}")
    private String password;

    /**
     * 连接池最大连接数
     */
    @Value("${spring.redis.jedis.pool.max-active}")
    private int maxActive;

    /**
     * 连接池最大连接数
     */
    @Value("${spring.redis.jedis.pool.max-wait}")
    private Duration maxWait;

    /**
     * 连接池中的最大空闲连接
     */
    @Value("${spring.redis.jedis.pool.max-idle}")
    private int maxIdle;

    /**
     * 连接池中的最小空闲连接
     */
    @Value("${spring.redis.jedis.pool.min-idle}")
    private int minIdle;

    public int getDatabase()
    {
        return database;
    }

    public void setDatabase(int database)
    {
        this.database = database;
    }

    public String getHost()
    {
        return host;
    }

    public void setHost(String host)
    {
        this.host = host;
    }

    public int getPort()
    {
        return port;
    }

    public void setPort(int port)
    {
        this.port = port;
    }

    public String getPassword()
    {
        return password;
    }

    public void setPassword(String password)
    {
        this.password = password;
    }

    public int getMaxActive()
    {
        return maxActive;
    }

    public void setMaxActive(int maxActive)
    {
        this.maxActive = maxActive;
    }

    public Duration getMaxWait()
    {
        return maxWait;
    }

    public void setMaxWait(Duration maxWait)
    {
        this.maxWait = maxWait;
    }

    public int getMaxIdle()
    {
        return maxIdle;
    }

    public void setMaxIdle(int maxIdle)
    {
        this.maxIdle = maxIdle;
    }

    public int getMinIdle()
    {
        return minIdle;
    }

    public void setMinIdle(int minIdle)
    {
        this.minIdle = minIdle;
    }
}

(3) Cree la clase RedisConfig.java (clase de configuración de Redis) e inicialice el servicio de Redis.

/**
 * Redis配置类
 * @author pan_junbiao
 **/
@Configuration
public class RedisConfig
{
    @Autowired
    private RedisProperties redisProperties;

    /**
     * Jedis连接池
     */
    @Bean("jedis.pool")
    @Autowired
    public JedisPool jedisPool(@Qualifier("jedis.pool.config") JedisPoolConfig config)
    {
        return new JedisPool(config, redisProperties.getHost(), redisProperties.getPort());
    }

    /**
     * Jedis连接池配置信息
     */
    @Bean(name = "jedis.pool.config")
    public JedisPoolConfig jedisPoolConfig()
    {
        JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();

        //连接池最大连接数（使用负值表示没有限制）
        jedisPoolConfig.setMaxTotal(redisProperties.getMaxActive());

        //连接池最大阻塞等待时间（使用负值表示没有限制）
        jedisPoolConfig.setMaxWaitMillis(redisProperties.getMaxWait().toMillis());

        //连接池中的最大空闲连接
        jedisPoolConfig.setMaxIdle(redisProperties.getMaxIdle());

        //连接池中的最小空闲连接
        jedisPoolConfig.setMinIdle(redisProperties.getMinIdle());

        return jedisPoolConfig;
    }
}