Spring Boot proporciona dos archivos de configuración comúnmente utilizados, a saber, el archivo de propiedades y el archivo YML. Su función es modificar el valor predeterminado de la configuración automática de arranque de primavera. En comparación con los archivos de propiedades, los archivos YML son más jóvenes y tienen muchas dificultades. Se puede decir que Xiao tiene éxito y falla a Xiao él. YML determina la relación de jerarquía a través de espacios, que es una estructura de archivo de configuración y clara, pero también destruirá la relación de jerarquía debido a espacios insignificantes. Este capítulo se centra en la sintaxis de YML y tomando valores de los archivos de configuración. ¿Qué estás esperando? ¡Ven y estudia rápidamente!
Tecnología: YAML, Propiedades Sintaxis, el uso de ConfigurationProperties y Annotaciones de valor, el uso de marcadores de posición del archivo de configuración
Nota: Este capítulo se centra en la sintaxis de YAML y el uso de anotaciones de ConfigurationProperties. Muévase a GitHub para el código de prueba y complete el código. Amigos a los que les gusta pueden hacer clic en una estrella.
Código fuente: https://github.com/itdragonblog/daydayup/tree/master/springboot/spring-boot-yml
Artículo Estructura del directorio:
1. Introducción a Yaml
YML es un archivo en el lenguaje YAML (Yaml Ain't Markup Language), que está centrado en los datos y es más adecuado para archivos de configuración que JSON, XML, etc.
En comparación con XML, YML tiene un código menos estructurado, lo que hace que los datos sean más directos y claros de un vistazo.
¿Qué pasa con YML y JSON? Nadie es bueno o malo, el correcto es el mejor. La sintaxis de YML es elegante que JSON, con más anotaciones estándar, y es adecuada para archivos de configuración. Como formato de intercambio de máquinas, JSON es más fuerte que YML y es más adecuado para el intercambio de datos para las llamadas de API.
1) Sintaxis Yaml
Controle las relaciones jerárquicas por el grado de sangría de los espacios. El número de espacios no es importante, siempre que los espacios de la izquierda estén alineados, se consideran el mismo nivel. Tenga en cuenta que las pestañas no se pueden usar en lugar de espacios. Y sensible a la caja. Admite tres estructuras de datos: valor literal, objeto y matriz, y también admite estructuras compuestas.
Valor literal: cadena, tipo booleano, valor numérico, fecha. Las cadenas no se citan de forma predeterminada, y las citas individuales escaparán de caracteres especiales. El formato de fecha es compatible
Objeto: consta de pares de valor clave, datos en forma de clave: (espacio) Valor. Los espacios después del colon son necesarios. Cada conjunto de pares de valor clave ocupa una línea y el grado de sangría debe ser consistente. También puede usar el método de escritura en línea: {K1: V1, .... KN: VN}
Array: consiste en datos con una forma de valor (espacio). Los espacios detrás de la línea horizontal corta son necesarios. Cada conjunto de datos ocupa una línea y el grado de sangría debe ser consistente. También puede usar el método de escritura en línea: [1,2, ... n]
Estructura compuesta: cualquier combinación de las tres estructuras de datos anteriores
Ii) Aplicación de YAML
Cree un archivo de configuración global de Boot Spring Application.yml y configure los parámetros de propiedad. Hay principalmente cadenas, cadenas con caracteres especiales, tipos booleanos, valores, colecciones, colecciones en línea, objetos en línea y objetos de recolección.
yaml: str: la cadena puede ser sin cotizaciones especialst: "Cotizaciones dobles directamente salidas /n caracteres especiales" SpecialStr2: 'Cotizaciones individuales puede escapar /n Caracteres especiales' Flager: False NUM: 666 DNUM: 88.88 Lista: - One - Dos - Dos establecidos Salario: 18888.88
Crear clase de entidad Yamlentity.java Obtenga el valor de la propiedad en el archivo de configuración, obtenga el valor especificado en el archivo de configuración anotando @ConfigurtionProperties y inyectéelo en la clase de entidad. ¡Continúe mirando sus métodos de prueba específicos y el principio de obtener valores!
importar org.springframework.boot.context.properties.configurationProperties; import org.springframework.stereotype.component; import java.util.list; import java.util.map; import java.util.set;/*** yaml syntax Class* recuerdo puntos:* 1 1. (espacio) Valor * 2. El número de espacios en el lado izquierdo de cada parámetro de línea determina el nivel del parámetro y no ingresa al azar. */@Componente@configurationProperties (prefix = "yaml") public class Yamlentity {// valor literal, cadena, boolean, numérica cadena privada str; // cadena normal de cadena privada especialstr; // Escape Special String String Private String SpecialStr2; // Salida de cadena especial Bandera booleana privada; // boolean type private entero num; // entero de doble dnum privado; // decimal // matriz, lista y conjunto, dos formas de escribir: el primero: - el valor de espacio, cada valor ocupa una fila y debe ser sangrada y alineada; El segundo: [1,2, ... n] en línea Escribir lista privada <S Object> List; // enumere el set private set private <S Object> set; // set no se puede repetir establecer // clases de mapa y entidad, dos formas de escribir: el primero: el valor de espacio clave, cada valor ocupa una línea y debe ser sangrada y alineada; el segundo: {clave: valor, ...} en línea Escribir mapa privado <cadena, objeto> map; // Mape KV Lista privada <Cosition> Posiciones; // Estructura compuesta, objeto de colección // omitir getter, setter, tostring métodos}3) Resumen YML
1. La cadena puede ser sin citas. Si se agregan cotizaciones dobles, se emitirán caracteres especiales. Si no se agregan citas individuales, se escapará de caracteres especiales;
2. Para el tipo de matriz, debe haber espacios detrás de líneas horizontales cortas; Para el tipo de objeto, debe haber espacios detrás de colon;
3. Yaml controla las relaciones jerárquicas basadas en el grado de sangría espacial, pero la tecla TAB no se puede usar en lugar de los espacios, y es sensible a la caja;
4. ¿Cómo hacer que un programador se bloquee? ¡Agregue algunos espacios al archivo YML! (〃＞ plato ＜)
2. Introducción a las propiedades
Todos a menudo usan archivos de propiedades, por lo que los presentaré brevemente aquí. Su estructura de sintaxis es como: Key = Value. Preste atención al problema del código confuso chino y debe transcodarse a ASCII. Los detalles son los siguientes:
userInfo.account = itdragonBlogUserInfo.age = 25UserInfo.active = trueuserInfo.created-date = 2018/03/11 16: 54: 30userInfo.map.k1 = v1userInfo.map.k2 = v2userInfo.list = uno, dos, tres, tresuserinfo.position.position.posit. userInfo.position.salary = 19999.99
Tome valores de los archivos de configuración y los inyecte en clases de entidad, que es lo mismo que YAML.
importar org.springframework.boot.context.properties.ConfigurationProperties; import org.springframework.stereotype.component; import java.util.date; import java.util.list; import java.util.utMap;/*** Información de usuario* @Configuras En el archivo de configuración (el valor se encuentra a través del prefijo)*/@componente@configurationProperties (prefix = "userInfo") public class UserInfo {private String cuenta; edad de entero privado; booleano privado activo; fecha privada creada date; mapa privado <cadena, objeto> mapa; Lista de lista privada <S Object>; posición de posición privada; // omitir getter, setter, tostring métodos}3. Valor de archivo de configuración
Spring Boot obtiene propiedades de los archivos de configuración a través de la anotación ConfigurationProperties. Del ejemplo anterior, podemos ver que la anotación de ConfigurationProperties puede especificar los datos que deben importarse en lotes configurando el prefijo. Admite la obtención de datos complejos como literales, colecciones, mapas, objetos, etc. ¿Hay algo más sobre la anotación de ConfigurationProperties? ¿Cuál es la diferencia entre la anotación de valor de TI y Spring? Con estas preguntas en mente, sigamos leyendo. (๑ • ̀ㅂ • ́) و✧
A) pros y contras de ConfigurationProperties y Value
Pros y contras de las anotaciones de ConfigurationProperties
1. Puede lote de propiedades de inyección de inyección del archivo de configuración;
2. Admite la obtención de tipos de datos complejos;
3. Los requisitos para los nombres de atributos coincidentes son bajos, como el nombre del usuario, el usuario, nombre de usuario, nombre de usuario y user_name pueden obtener valores;
4. Soporte de verificación de datos JSR303 de Java;
5. La desventaja es que no admite poderosas expresiones de spel;
Las ventajas y desventajas de la anotación de valor son todo lo contrario. Solo puede configurar los valores de inyección uno por uno; No admite tipos de datos complejos, como matrices y colecciones; No admite la verificación de datos; Tiene requisitos estrictos para la coincidencia de nombre de la propiedad. La característica más importante es que admite expresiones de Spel, por lo que es funciones más ricas.
2) @ConfigurationProperties Explicación detallada
Paso 1: Dependencias de importación. Para utilizar la anotación de ConfigurationProperties, debe importar el procesador de configuración de boot de dependencia de dependencia;
Paso 2: Configure los datos. En el archivo de configuración Application.yml, configure los parámetros de atributo, prefijados por Itdragon, y los parámetros tienen valores y matrices literal, que se utilizan para determinar si la capacidad de obtener atributos complejos es compatible con;
Paso 3: Haga coincidir los datos. Agregue la configuración de anotación Properties en la clase y establezca el valor de la propiedad de prefijo en ItDragon. Y agregue esta clase al contenedor IOC de Spring.
Paso 4: Verifique los datos. Agregue la anotación validada de verificación de datos, habilite la verificación de datos y pruebe si admite la verificación de datos;
Paso 5: Pruebe si la anotación de ConfigurationProperties admite expresiones Spel;
Dependencias de importación: Pom.xml Agregar dependencias de procesador de configuración de boot de resorte
<Spendency> <MoupRupid> org.springframework.boot </groupid> <artifactID> spring-boot-configuation-procesador </artifactid> <pectional> true </pectional> </pendency>
Datos de configuración: Application.yml Parámetros de propiedad de configuración, Nick-Name se utiliza para juzgar la flojencia de las propiedades coincidentes. Si se cambia a Nick_Name, aún puede obtener el valor.
itdragon: nick-name: itdragonblog Correo electrónico: [email protected] iPhone: 1234567890 Habilidades: [Java, SQL, html] creado_date: 2018/03/31 15:27:30
Coincidir y verificar datos:
importar org.springframework.boot.context.properties.configurationProperties; import org.springframework.stereotype.component; import org.springframework.validation.annotation.validated; import javax.validation.constrainss.email; import java.utilia; import java.util.list;/*** ConfigurationProperties Annotation Syntax Class* Paso 1: Dependencia de la importación Spring-Boot-Configuration-procesador; * Paso 2: Agregue la clase modificada por la anotación ConfigurationProperties al contenedor IOC de Spring; * Paso 3: Establezca el atributo de prefijo y especifique el prefijo que debe inyectarse; * Paso 4: Agregar anotación de verificación de datos para habilitar la verificación de datos; ** Nota:* 1. Nombre y Date CreateDate están en el archivo de configuración YML, y los parámetros correspondientes son mallas y subrayos, respectivamente, se utilizan para probar su flojencia de los nombres de atributos coincidentes* 2. Correo electrónico y prueba de iPhone que admite JSR303 Verificación de datos* 3. ConfigurationPropertiesEntity {apodo de cadena privada; // analizando correctamente, admitiendo atributos de correspondencia sueltos por correo electrónico de cadena privada; // @email // El análisis falló, y la verificación de datos fue exitosa: BindValidationException: errores de validación vinculante en Itdragon Private String iPhone; Lista privada <String> habilidades; fecha privada creada date; // analizando con éxito, admitiendo atributos de correspondencia sueltos // @ConfigurationProperties ("#{(1+2-3)/4*5}") Operador de cadena privada; // Error de sintaxis, no es compatible con la expresión de Spel: no aplicable al campo // omitir getter, setter, toString Methods}3) Detalles de @Value
El blog anterior ha introducido el uso de anotaciones de valor, y aquí hay una breve explicación.
Paso 1: agregue la anotación de valor al atributo e inyecte el valor del archivo de configuración a través del parámetro de configuración $ {};
Paso 2: Modifique el valor del parámetro en $ {itdragon.ceatred_date} y cámbielo a $ {itdragon.ceatredDate} para probar si el análisis puede ser exitoso;
Paso 3: Agregar anotación validada de verificación de datos, habilitar la verificación de datos y probar si admite la verificación de datos;
Paso 4: Pruebe si la anotación de valor admite expresiones SPEL;
importar org.springframework.beans.factory.annotation.value; import org.springframework.stereotype.component; import org.springframework.validation.annotation.validated; import javax.validation.Constraints.Email; import java.util.util.date; import java.util.list;//ovalt annot annot annotnot; Clase de sintaxis* Paso 1: Agregar parámetros de inyección de valor de anotación en los atributos* Paso 2: Agregue la clase modificada por la anotación de valor al contenedor del IOC de resorte; * Paso 3: Agregar anotación de verificación de datos para verificar si la verificación de datos es compatible; * * Puntos de nota: * 1. Nombre y creado Date En el archivo de configuración YML, los parámetros correspondientes son mallas y subrayos, respectivamente, se utilizan para probar su flojencia de los nombres de atributos coincidentes * 2. Correo electrónico y pruebas de iPhone que admiten JSR303 VERIFICACIÓN DE DATOS * 3. Las habilidades de la configuración de complejos * * concluye: * 1. El valor de creación de creación debe ser de acuerdo con el archivo de los parámetros. * 2. Dado que es agregar anotaciones de verificación del buzón en el iPhone, aún puede pasar la prueba. * 3. La estructura de datos compleja no es compatible, y el error de inmediato es el mismo que el primero: ilegalArgumentException: no pudo resolver el marcador de posición 'itdragon.Abities' in valor "$ {itdragon.Ability}" */@component@validatedpublic clase de clase {@Value ("$ {itdragon.nicknicknicknick-name}") Private String Nickname; @Value ("$ {itdragon.email}") Correo electrónico de cadena privada; @Email @Value ("$ {itdragon.iphone}") // El análisis es exitoso y la verificación de datos no es compatible con cadena privada iPhone; // @Value ("$ {itdragon.eatreddate}") // El error es un error, la estructura de datos compleja no es compatible // Errores de análisis, no admite propiedades de correspondencia suelta y debe ser una fecha privada estrictamente consistente creada; // El lado poderoso de la anotación del valor: admite la expresión de Spel @Value ("#{(1+2-3)/4*5}") // operador de cadena privada de operación aritmética; @Value ("#{1> 2 || 2 <= 3}") // Operación relacional comparación booleana privada; @Value ("#{SystemProperties ['java.version']}") // Configuración del sistema: OS.Name Private String SystemProperties; @Value ("#{t (java.lang.math) .abs (-18)}") // Expression private String mapexpression; // omitir getter, setter, tostring métodos}4) Resumen del valor del archivo de configuración
1. Las anotaciones de ConfigurationProperties admiten la inyección por lotes, mientras que las anotaciones de valor son adecuadas para una sola inyección;
2. Las anotaciones de ConfigurationProperties admiten la verificación de datos, mientras que las anotaciones de valor no;
3. Las anotaciones de ConfigurationProperties admiten propiedades de coincidencia suelta, mientras que las anotaciones de valor deben coincidir estrictamente las propiedades;
4. ConfigurationProperties no admite potentes expresiones de spel, pero el valor las admite;
4. Partidos de posición de archivo de configuración
Los marcadores de posición y los números aleatorios son relativamente simples, por lo que publicaré el código aquí directamente. Lo que debe tenerse en cuenta es:
1. El valor del marcador de posición debe ser el camino completo
2. Establezca el valor predeterminado del marcador de posición, no debe haber espacio después del colon
ran: # el prefijo aquí no puede ser aleatorio, ran-value: $ {random.value} ran-int: $ {random.int} ran-long: $ {random.long} ran-in-num: $ {random.int (10)} ran-int-range: $ {random.int [10,20]} ran-holding: posholder _ $ {ran-ran-val. aquí, y la clave es la ruta completa} importar org.springframework.boot.context.properties.configurationProperties; import org.springframework.stereotype.component;/*** Número aleatorio y clase de syntax syntax*/@component@configurationProperties (prefix = "ran") public class Randomentity {String Ranvalue privado Ranvalue; // Generar aleatoriamente una cadena privada Ranint privada; // Generar aleatoriamente un entero privado Long Ranlong; // Generar aleatoriamente un Integer Integer Ranintnum de Integer Integer Long Integer; // Generar aleatoriamente un entero privado dentro de un rango especificado Integer RanIntrange; // Generar aleatoriamente una cadena privada de Integer RanPlaceHolder; // PlaceHolder // omite getter, setter, método toString e} prueba de prueba: @runwith (springrunner.classsssss) @SpringBoottestpublic Class treingMlapplApplicationTestationTesteStesteTests {@autfoutsinfoutsinfoutsinfoutsinfoutsinfoutsinfoutsinfoutsinfouted UserInfo; @Autowired Private Yamlentity Yamlentity; @AUTOWIREDEDIREDEDIRD CONFIGURACIÓN PRIVATIVA CONFIGURACIÓN PROPERTIESENTITY; @AutoWired ValueEtity Private ValueEntity; @AUtowired private randomeTity RandomEntity; @Test public void contextloads () {// system.out.println ("yaml grammar:" + yamlentity); // system.out.println ("userInfo:" + userInfo); // system.out.println ("ConfigurationPreperties Grammar:" + ConfigurationPpertiesEntity); // System.Out.Println ("GRAMMAR GRAMMAR (" GRAMAR DE GRAMAR: " + valoración); System.out.println ("Gramática aleatoria:" + randomEntity); }}5. Resumen
1. Spring Boot admite archivos de configuración en dos formatos, entre los cuales la estructura de datos de YAML es más clara que las propiedades.
2. Yaml es un idioma especialmente utilizado para escribir archivos de configuración, que es muy conciso y potente.
3. Yaml tiene requisitos estrictos en los espacios y no puede ser reemplazado por la tecla TAB.
4. Yaml determina el nivel por el grado de sangría espacial, con espacios que siguen el colon y los espacios que siguen la línea horizontal corta.
5. Las anotaciones de ConfigurationProperties son adecuadas para la inyección por lotes de propiedades en los archivos de configuración, y las anotaciones de valor son adecuadas para obtener un elemento en el archivo de configuración.
6. Las anotaciones de ConfigurationProperties admiten la suma de verificación de datos para obtener datos complejos, y las anotaciones de valor admiten expresiones SPEL.
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.