Anotaciones de Spring Core

Las anotaciones de Spring son una forma de metadatos que proporcionan datos sobre un programa. Las anotaciones se utilizan para proporcionar información complementaria sobre un programa. No tiene un efecto directo sobre el funcionamiento del código que anotan. No cambia la acción del programa compilado. En el framework Spring, las anotaciones se clasifican en diferentes tipos. 

Tipos de anotaciones de Spring Framework

Básicamente, hay 6 tipos de anotaciones disponibles en todo el marco de Spring.

1. Anotaciones de Spring Core
2. Anotaciones web de primavera
3. Anotaciones de arranque de primavera
4. Anotaciones de programación de primavera
5. Anotaciones de datos de primavera
6. Anotaciones de frijol primavera

Entonces, en este artículo, vamos a discutir las anotaciones de Spring Core.

Anotaciones de Spring Core

Las anotaciones Spring presentes en los paquetes org.springframework.beans.factory.annotation y org.springframework.context.annotation se conocen comúnmente como anotaciones Spring Core. Podemos dividirlos en dos categorías:

1. Anotaciones relacionadas con DI
2. Anotaciones de configuración de contexto

1. Anotaciones relacionadas con DI

Algunas de las anotaciones relacionadas con DI que están disponibles en Spring Framework se enumeran a continuación

• @autocableado
• @Calificatorio
• @Primario
• @Frijol
• @Perezoso
• @Requerido
• @Valor
• @Alcance
• @Buscar, etc

@Anotación autocableada

La anotación @Autowired se aplica a los campos, métodos de establecimiento y constructores . Inyecta dependencia de objetos implícitamente. Usamos @Autowired para marcar la dependencia que inyectará el contenedor Spring.

Ejemplos

1.1: Inyección de campo

class Student {
    @Autowired
    Address address;
}

1.2: Inyección de constructor

class Student {
    Address address;
  
    @Autowired
    Student(Address address) {
        this.address = address;
    }
}

1.3: Inyección de setter

class Student {
    Address address;
  
    @Autowired
    void setaddress(Address address) {
        this.address = address;
    }
}

Anotación @Qualifier

La anotación @Qualifier se usa para resolver el conflicto de cableado automático cuando hay varios beans del mismo tipo. La anotación @Qualifier se puede usar en cualquier clase anotada con @Component o en métodos anotados con @Bean. Esta anotación también se puede aplicar a argumentos de constructor o parámetros de método.

Ilustración:

public interface Vehicle {
     public void start();
}

Implementación: 

Supongamos que hay dos frijoles, implementos para automóviles y bicicletas. Interfaz del vehículo.

Ejemplo:

@Component(value="car")
public class Car implements Vehicle {
  
     @Override
     public void start() {
           System.out.println("Car started");
     }
  
 }
  
@Component(value="bike")
public class Bike implements Vehicle {
  
     @Override
     public void start() {
          System.out.println("Bike started");
     }
  
}

Entonces, en este caso, si desea inyectar el bean Bike en VehicleService, debe usar @Autowired con la anotación @Qualifier. Si no usó @Qualifier, lanzará NoUniqueBeanDefinitionException .

Ejemplo:

@Component
public class VehicleService {
  
    @Autowired
    @Qualifier("bike")
    private Vehicle vehicle;
  
    public void service() {
         vehicle.start();
    }
}

@Anotación primaria

Esto indica que se debe dar preferencia a un bean en particular cuando varios beans son candidatos para conectarse automáticamente a una dependencia de un solo valor. Si existe exactamente un bean ‘primario’ entre los candidatos, será el valor de conexión automática. Entendamos esta afirmación con un ejemplo.

Ejemplo: En algunos casos, necesitamos registrar más de un bean del mismo tipo. En este ejemplo, los beans Employee1() y Employee2() del tipo Employee:

@Configuration
public class Config {
  
    @Bean
    public Employee Employee1() {
        return new Employee("Employee1");
    }
  
    @Bean
    public Employee Employee2() {
        return new Employee("Employee2");
    }
}

En este caso, si intentamos ejecutar la aplicación, Spring lanzará NoUniqueBeanDefinitionException . Para resolver este problema, Spring ofrece la anotación @Primary.

@Configuration
public class Config {
  
    @Bean
    public Employee Employee1() {
        return new Employee("Employee1");
    }
  
    @Bean
      @Primary
    public Employee Employee2() {
        return new Employee("Employee2");
    }
}

En el código anterior, marcamos el bean Employee2() con @Primary. Spring inyectará el bean Employee2() preferentemente sobre el Employee1().

2. Anotaciones de configuración de contexto

Algunas de las anotaciones de configuración de contexto que están disponibles en Spring Framework se enumeran a continuación

• @Perfil
• @Importar
• @ImportResource
• @PropertySource, etc.

@Anotación de perfil

Si desea que Spring use una clase @Component o un método @Bean solo cuando un perfil específico está activo, puede marcarlo con @Profile. 

Ejemplo

@Component
@Profile("developer")
public class Employee {}

@Importar anotación

La anotación Spring @Import importa una o más clases de @Configuration. Es equivalente al elemento <import> en Spring XML. Si la aplicación usa @ComponentScan, todas las clases de @Configuration se escanearán automáticamente y no será necesario usar la anotación @Import. Pero en algunos casos, queremos escanear solo las clases @Configuration seleccionadas y, en este caso, la anotación @Import es útil.

Ejemplo:

@Configuration
@Import(Conf1.class)
public class Config {
   ------
}

También podemos importar más de una clase de configuración de la siguiente manera.

@Configuration
@Import({Conf1.class, Conf2.class})
public class Config {
   ------
}

Anotación @PropertySource

La anotación Spring @PropertySource se usa para proporcionar un archivo de propiedades a Spring Environment. Esta anotación se usa con las clases @Configuration. 

Ejemplo:

@Configuration
@PropertySource("classpath:db.properties")
public class DBConfiguration {
    //...
}

Esta anotación es repetible, lo que significa que podemos tener múltiples PropertySource en una clase de configuración. Esta función está disponible si utiliza Java 8 o versiones superiores. 

Ejemplo:

@Configuration
@PropertySource("classpath:db.properties")
@PropertySource("classpath:root.properties")
public class DBConfiguration {
    //...
}