La anotación @Value en Spring

    Introducción

    El enfoque principal de este artículo es ayudarlo a comprender cómo Spring’s @Valor la anotación funciona.

    @Value es una anotación de Java que se utiliza en el nivel de parámetro de campo o método / constructor e indica un valor predeterminado para el argumento afectado. Se usa comúnmente para inyectar valores en variables de configuración, que mostraremos y explicaremos en la siguiente parte del artículo.

    Tarea básica

    Para los ejemplos más fáciles, asignaremos valores a tres campos diferentes usando el @Value anotación dándoles valores explícitos:

    @Value("John")
    private String trainee;
    
    @Value("100")
    private int hoursOfCode;
    
    @Value("true")
    private boolean passedAssesmentTest;
    

    Es muy importante tener en cuenta que el argumento pasado al @Value La anotación solo puede ser una String. Spring convertirá el valor al tipo especificado y la asignación se realizará sin ningún problema, incluso si estamos pasando String valores a int o boolean variables.

    Ambiente Springl

    Inyectando valores de archivos de propiedades con la ayuda de @Value La anotación es probablemente el caso de uso más utilizado en aplicaciones de la vida real.

    Usaremos el archivo de propiedades predeterminado para Spring Boot – application.properties, donde podemos definir variables a las que podemos acceder posteriormente:

    car.brand=Audi
    car.color=Red
    car.power=150
    
    @Value("${car.brand")
    private String brand;
    
    @Value("${car.color}")
    private String color;
    
    @Value("${car.power}")
    private int power;
    

    En este ejemplo, los valores de las variables se leen del application.properties archivo y asignado a ellos durante la creación del bean.

    La mayoría de las veces, usamos este enfoque para inyectar valores de configuración desde el application.properties lima en frijoles.

    Valor por defecto

    Los valores predeterminados se utilizan como “respaldo” si la propiedad que deseamos inyectar no está definida o falta:

    @Value("${car.type:Sedan}")
    private String type;
    

    En el ejemplo anterior, porque no tenemos ninguna car.type propiedad en application.properties, Spring asignará Sedan al type variable como valor predeterminado.

    Si el car.type la propiedad se inserta en el archivo de propiedades, en su lugar se utilizará el nuevo valor.

    Variables del sistema

    También podemos acceder a las variables del sistema que se almacenan como propiedades por la aplicación Spring al inicio:

    @Value("${user.name}")
    // Or
    @Value("${username}")
    private String userName;
    
    @Value("${number.of.processors}")
    // Or
    @Value("${number_of_processors}")
    private int numberOfProcessors;
    
    @Value("${java.home}")
    private String java;
    

    Las variables se pueden llamar con diferentes convenciones de nomenclatura: Spring nos busca y asigna el valor correcto.

    Valor del método global

    Porque @Value es procesado por el BeanPostProcessor class, se invocará cuando Spring esté construyendo el contexto Spring creando instancias de archivos de configuración y beans.

    Esto significa que al tener @Value en un método, todos los argumentos se asignarán con el valor proporcionado a la anotación:

    @Value("${car.brand}")
    public CarData setCarData(String color, String brand) {
        carData.setCarColor(color);
        carData.setCarBrand(brand);
    }
    

    Si estamos imprimiendo carData.getCarColor() y carData.getCarBrand() obtendremos el car.brand valor en ambas ocasiones, porque como dijimos, todos los argumentos se asignarán con el valor proporcionado.

    Valor del método del parámetro

    Podemos arreglar esto usando @Value directamente en el parámetro del método:

    @Value("${car.brand}")
    public CarData setCarData(@Value("${car.color}") String color, String brand) {
        carData.setCarColor(color);
        carData.setCarBrand(brand);
    }
    

    Ahora, si estamos imprimiendo los valores del carData objeto: el campo de color tendrá el car.color value, porque proporcionamos el valor al parámetro del método en sí.

    Lenguaje de expresión de Spring (SpEL)

    Spring Expression Language (SpEL) es un lenguaje de expresión que sirve como base para la evaluación de expresiones dentro del portafolio de Spring.

    Básicamente, cuando se usa SpEL junto con el @Value anotación, solo estamos cambiando la forma en que le decimos a Spring lo que necesitamos. Miremos más de cerca:

    @Value("#{systemProperties['user.name']}")
    private String userName;
    

    Así es como inyectarías una propiedad específica del sistema. Por otro lado, podríamos inyectar todas las propiedades mediante:

    @Value("#{systemProperties}")
    private Map<String, String> properties;
    

    Ahora sabemos que podemos usar el @Value anotación para métodos como valor global o como valor de parámetro.

    Dado que los constructores son esencialmente métodos, también podemos usar la anotación en los constructores:

    public Driver(@Value("#{systemProperties['user.name']}") String name, String location) {
        this.name = name;
        this.location = location;
    }
    

    Inyectar en mapas

    Con SpEL, podemos hacer algunas otras cosas bastante interesantes cuando se combina con el @Value anotación. Por ejemplo, hagamos un Map eso representa indoor y outdoor aficiones de un estudiante. Cada uno de estos puede tener varios valores:

    student.hobbies={indoor: 'reading, drawing', outdoor: 'fishing, hiking, bushcraft'}
    

    Ahora, para inyectar esto, necesitaremos un Map<String, List<String>>:

    @Value("#{${student.hobbies}}")
    private Map<String, List<String>> hobbies;
    

    Inyectar en listas

    Si una propiedad tiene valores separados por comas, como una lista simple de libros, podemos usar SpEL para interpretarla y transformarla en una lista:

    student.booksRead=Harry Potter,The Hobbit,Game of Thrones
    

    Usando el split() método, y dividir por cada coma (,), podemos inyectar estos valores en una lista:

    @Value("#{'${student.booksRead}'.split(',')}")
    private List<String> booksRead;
    

    Conclusión

    Tan pronto como termine trabajando en una aplicación real, se dará cuenta de que la configuración es un tema importante y si está utilizando Spring. Existe una gran posibilidad de que ya use o tendrá que usar el @Value anotación extensamente.

    Comprender esta funcionalidad básica es muy importante porque si no lo hace, podría terminar usándola totalmente mal.

    También debemos ser conscientes de que no todo lo que parece simple también es muy bueno para soluciones a largo plazo. Por ejemplo, solo deberíamos usar @Value en componentes / servicios encapsulados (podemos llamarlos servicios de configuración).

    De esta forma, tendremos todas nuestras configuraciones en un solo lugar, y ese componente solo tendrá la responsabilidad de cargarlas y proporcionarlas a otros componentes.

    Etiquetas:

    Deja una respuesta

    Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *