1. Defina el formato del archivo de configuración

Esto se refiere principalmente a los archivos de configuración comunes: propiedades, yaml.

Por supuesto, json también se puede usar como configuración, pero no se prefiere.

Archivo de configuración utilizado:

application.properties

api.key=jimo
api.password=password

application.yml

api:
  username: admin

2. Carga de inyección dinámica

2.1 @Value

@Component
public class ApiConfig {
    @Value("${api.key}")
    private String key;
    @Value("${api.username}")
    private String username;
    @Value("${api.password}")
    private String password;
}

2.2 @ConfigurationProperties (prefijo = "api")

@Component
@ConfigurationProperties(prefix = "api")
public class ApiConfig {
    private String key;
    private String username;
    private String password;
}

2.3 Especifique el archivo de configuración @PropertySource

@PropertySourceEs una anotación proporcionada por spring para cargar configuraciones específicas en Environmentvariables de entorno. El uso estándar es Configurationcon.

Nota: @PropertySource(value = {"classpath:test.conf"})Para el mismo archivo, solo necesita estar registrado en un lugar y puede usarse en otros lugares.

Por ejemplo: Registrarse en la clase principal

@PropertySource(value = {"classpath:test.conf"})
@SpringBootApplication
public class ConfigTestApplication {

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

Se puede usar en todos los demás frijoles:

@Component
public class Api {
    @Value("${test.a}")
    private String a;
    @Value("${test.b}")
    private String b;
}

Además: @Valuey @ConfigurationPropertiesse puede usar en combinación con @PropertySource, solo preste atención a la duplicación de la configuración que causa problemas de cobertura (después de cargar se cubrirá lo anterior).

@Data
@Component
@PropertySource(value = {"classpath:test.conf"})
public class Api4Config {
    @Value("${test.a}")
    private String a;
    @Value("${test.b}")
    private String b;
}

3. Carga estática

Se refiere a leer el contenido del archivo de configuración en una clase estática

3.1 Lectura directa

3.1.1 Propiedades

Podemos usar la clase de herramienta Propiedades más básica: esta es la forma Java

import java.io.IOException;
import java.util.Properties;
import org.springframework.core.io.ClassPathResource;

/**
 * 直接读取配置文件
 *
 * @author jimo
 * @version 1.0.0
 */
public class RawConfigUtil {

    private static Properties properties = readProperties("test.conf", "test2.conf");

    private static Properties readProperties(String... confFile) {
        final Properties properties = new Properties();
        try {
            for (String path : confFile) {
                final ClassPathResource resource = new ClassPathResource(path);
                properties.load(resource.getInputStream());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return properties;
    }

    public static String getString(String key) {
        return properties.getProperty(key);
    }
}

3.1.2 typesafe.config

O mediante herramientas de terceros: https://github.com/lightbend/config lectura

        <dependency>
            <groupId>com.typesafe</groupId>
            <artifactId>config</artifactId>
            <version>1.4.0</version>
        </dependency>

Código:

import com.typesafe.config.Config;
import com.typesafe.config.ConfigFactory;

/**
 * @author jimo
 * @version 1.0.0
 */
public class ConfigUtils {

    private static Config load;

    // 默认加载classpath下的application.*
    static {
        load = ConfigFactory.load();
    }

    /**
     * 读取配置文件中指定Key的值
     *
     * @param key 配置文件中的key
     * @return 指定key的value
     */
    public static String getString(String key) {
        return load.getString(key);
    }

    /**
     * 读取配置文件中指定Key的值
     *
     * @param key 配置文件中的key
     * @return 指定key的value
     */
    public static int getInt(String key) {
        return load.getInt(key);
    }

    /**
     * 读取配置文件中指定Key的值
     *
     * @param key 配置文件中的key
     * @return 指定key的value
     */
    public static boolean getBoolean(String key) {
        return load.getBoolean(key);
    }

}

Según su introducción , estos archivos de configuración se pueden cargar de forma predeterminada:

system properties
application.conf (all resources on classpath with this name)
application.json (all resources on classpath with this name)
application.properties (all resources on classpath with this name)
reference.conf (all resources on classpath with this name)

Lo especial es que puedes leer la configuración json, pero no la uso mucho.

3.1.3 Resumen

Sin embargo, estos dos métodos tienen las siguientes desventajas:

No se puede leer la configuración en formato yaml
No se puede usar springboot para cargar la configuración desde variables externas y de entorno, por lo que solo puede ser una configuración muerta, no lo suficientemente flexible

3.2 Ambiente de uso

Para apuntar al entorno de primavera, use herramientas de primavera.

EnvironmentEn nombre del medio ambiente se está ejecutando actualmente en la primavera, incluyen: profilesy properties,
que hereda PropertyResolverla interfaz por lo que tiene una función para leer la configuración:

public interface Environment extends PropertyResolver {...}

Por lo tanto, la implementación de la configuración se PropertyResolverrealiza realmente mediante la clase de implementación de la interfaz.

Si podemos mantener esta clase en un entorno estático, entonces se puede obtener una variable, simplemente resorte para proporcionar una interfaz de este tipo: EnvironmentAware.

public interface EnvironmentAware extends Aware {

	/**
	 * Set the {@code Environment} that this component runs in.
	 */
	void setEnvironment(Environment environment);
}

Esta interfaz es solo un método: cuando el entorno esté listo, llamará a la clase de implementación de esta interfaz y luego configurará la instancia.

Entonces, implementamos esta interfaz para obtener el entorno:

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.EnvironmentAware;
import org.springframework.core.env.Environment;
import org.springframework.stereotype.Component;

/**
 * @author jimo
 * @version 1.0.0
 */
@Slf4j
@Component
public class MyEnvBeanUtil implements EnvironmentAware {

    private static Environment env;

    @Override
    public void setEnvironment(Environment environment) {
        env = environment;
    }

    public static String getString(String key) {
        return env.getProperty(key);
    }
}

Cuando realmente llamamos:

    @Test
    void testEnv() {
        assertEquals("password", MyEnvBeanUtil.getString("api.password"));
        assertEquals("admin", MyEnvBeanUtil.getString("api.username"));
    }

3.3 继承 PropertySourcesPlaceholderConfigurer

PropertySourcesPlaceholderConfigurerRealizado EnvironmentAware, por lo que es más rico, porque puede establecer la información de marcador de posición para marcadores de posición personalizados. Utilice este método

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.support.PropertySourcesPlaceholderConfigurer;
import org.springframework.core.env.ConfigurablePropertyResolver;
import org.springframework.core.env.PropertyResolver;
import org.springframework.stereotype.Component;

/**
 * @author jimo
 * @version 1.0.0
 */
@Component
public class PropertyUtil extends PropertySourcesPlaceholderConfigurer {

    private static PropertyResolver propertyResolver;

    @Override
    protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess,
                                     ConfigurablePropertyResolver propertyResolver) throws BeansException {
        super.processProperties(beanFactoryToProcess, propertyResolver);
        PropertyUtil.propertyResolver = propertyResolver;
    }

    public static String getString(String key) {
        return propertyResolver.getProperty(key);
    }
}