Una de las anotaciones más importantes en Spring es la anotación @Bean que se aplica a un método para especificar que devuelve un bean para ser administrado por el contexto de Spring. La anotación Spring Bean generalmente se declara en los métodos de clases de configuración. Esta anotación también es parte del marco Spring Core. Entonces, entendamos @Bean Annotation con un proyecto de ejemplo.
requisito previo :
- Anotación Spring @ComponentScan con ejemplo
- Anotación Spring @Configuration con ejemplo
Implementación: Proyecto
Supongamos que ya tenemos un proyecto Java y todos los archivos Spring JAR se importan a ese proyecto. Ahora vamos a crear una clase simple llamada College y dentro de la clase, tenemos un método simple. A continuación se muestra el código para el archivo College.java y usando la anotación @ Component y @ComponentScan vamos a crear el bean de esta clase universitaria. Entonces podemos escribir código para el archivo College.java algo como esto.
A. Archivo: Colegio.java
Java
// Java Program to Illustrate College Class
package BeanAnnotation;
// Importing required classes
import org.springframework.stereotype.Component;
// Annotation
@Component("collegeBean")
// Class
public class College {
// Method
public void test()
{
// Print statement
System.out.println("Test College Method");
}
}
Ahora vamos a crear una clase de configuración llamada CollegeConfig . A continuación se muestra el código para el archivo CollegeConfig.java
Clase de configuración
Java
// Java Program to Illustrate Configuration Class
package ComponetAnnotation;
// Importing required classes
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
// Annotation
@Configuration
@ComponentScan(basePackages = "BeanAnnotation")
// Class
public class CollegeConfig {
}
Pero no queremos usar las anotaciones @Component y @ComponentScan para crear los beans. Analicemos otra manera de hacer la misma tarea. Así que vamos a crear los frijoles primavera usando la anotación @Bean . Para crear el bean de clase College utilizando la anotación @Bean dentro de la clase de configuración, podemos escribir algo como esto dentro de nuestro archivo CollegeConfig.java . Por favor, consulte los comentarios para una mejor comprensión.
@Bean
// Here the method name is the
// bean id/bean name
public College collegeBean()
{
// Returns the College object
return new College();
}
B. Archivo: CollegeConfig.java
Java
// Java Program to Illustrate
// Configuration of College Class
package BeanAnnotation;
// Importing required classes
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
// Annotation
@Configuration
// Class
public class CollegeConfig {
// Creating College class Bean
// using Bean annotation
@Bean
// Here the method name is the
// bean id/bean name
public College collegeBean()
{
// Returns the College class object
return new College();
}
}
Nota : siempre que use la anotación @Bean para crear el bean, no necesita usar la anotación @ComponentScan dentro de su clase de configuración.
Ahora, para verificar nuestra aplicación, creemos un método principal dentro de nuestra clase Principal. A continuación se muestra el código del archivo Main.java . Se agregan comentarios dentro del código para comprender el código con más detalle.
C. Clase de aplicación
Java
// Java Program to Illustrate Application Class
package BeanAnnotation;
// Importing required classes
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
// Main(Application) Class
public class Main {
// Main driver method
public static void main(String[] args)
{
// Using AnnotationConfigApplicationContext
// instead of ClassPathXmlApplicationContext
// because we are not using XML Configuration
ApplicationContext context
= new AnnotationConfigApplicationContext(
CollegeConfig.class);
// Getting the bean
College college
= context.getBean("collegeBean", College.class);
// Invoking the method
// inside main() method
college.test();
}
}
Producción:
Test College Method
Sugerencia: ahora eliminemos la anotación @Bean antes del método collegeBean() y ejecutemos nuestro programa nuevamente y podrá ver que obtendremos la excepción «NoSuchBeanDefinitionException».
Exception in thread "main" org.springframework.beans.factory.NoSuchBeanDefinitionException: No bean named 'collegeBean' available
at org.springframework.beans.factory.support.DefaultListableBeanFactory.getBeanDefinition(DefaultListableBeanFactory.java:863)
at org.springframework.beans.factory.support.AbstractBeanFactory.getMergedLocalBeanDefinition(AbstractBeanFactory.java:1344)
at org.springframework.beans.factory.support.AbstractBeanFactory.doGetBean(AbstractBeanFactory.java:309)
at org.springframework.beans.factory.support.AbstractBeanFactory.getBean(AbstractBeanFactory.java:213)
at org.springframework.context.support.AbstractApplicationContext.getBean(AbstractApplicationContext.java:1160)
at BeanAnnotation.Main.main(Main.java:15)
Entonces, el punto es hacer que el método collegeBean() funcione como un frijol, necesita definir la anotación @Bean antes de ese método en particular.
Dando diferentes ID de Bean/Nombre de Bean
Ahora la pregunta es ¿podemos dar una ID de Bean diferente para este método collegeBean()? Si podemos. Podemos modificar nuestro código algo como esto.
// Annotation
@Bean(name = "myCollegeBean")
// Class
public College collegeBean()
{
return new College();
}
Entonces, siempre que desee probar su aplicación, también debe cambiar su archivo Main.java a algo como esto.
D. Clase de aplicación
Java
// Java Program to Illustrate Application Class
package BeanAnnotation;
// Importing required classes
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
// Application(Main) class
public class Main {
// main driver method
public static void main(String[] args)
{
// Using AnnotationConfigApplicationContext
// instead of ClassPathXmlApplicationContext
// because we are not using XML Configuration
ApplicationContext context
= new AnnotationConfigApplicationContext(
CollegeConfig.class);
// Getting the bean
College college = context.getBean("myCollegeBean",
College.class);
// Invoking the method
// inside main() method
college.test();
}
}
Dando múltiples nombres al mismo frijol
Una cosa más interesante es que podemos dar varios nombres a este método particular de collegeBean(). Entonces, podemos modificar nuestro código algo como esto.
@Bean(name = {"myCollegeBean", "yourCollegeBean"})
public College collegeBean()
{
return new College();
}
De manera similar, debe modificar su archivo Main.java durante la ejecución de su aplicación.
Inyección de dependencia con anotación @Bean
Ahora hablemos de otro escenario. Supongamos que tenemos una clase de dependencia llamada Principal dentro de nuestra clase universitaria, ¿qué hacer? Así que el escenario es así. Tenemos una clase llamada Principal.java y hemos definido un método simple dentro de esta.
Ejemplo
Java
// Java Program to Illustrate Principal Class
package BeanAnnotation;
// Class
public class Principal {
// Method
public void principalInfo()
{
// Print statement
System.out.println("Hi, I am your principal");
}
}
Y nuestra clase College.class es algo como esto
Java
// Java Program to Illustrate College Class
package BeanAnnotation;
// Class
public class College {
// Class data member
private Principal principal;
// Method
public void test()
{
principal.principalInfo();
// Print statement
System.out.println("Test College Method");
}
}
Entonces ahora queremos hacer la inyección de dependencia. Entonces podemos hacerlo de 2 maneras como se enumeran más adelante implementadas como se muestra a continuación:
- Inyección de dependencia del constructor (CDI)
- Inyección de dependencia del setter (SDI)
Vía 1: Inyección de dependencia del constructor (CDI)
En ese caso, primero, creemos un constructor dentro de la clase College. Así que nuestro archivo College.java modificado es
A. Clase universitaria
Java
// Java Program to Illustrate College Class
package BeanAnnotation;
// Class
public class College {
private Principal principal;
public College(Principal principal)
{
this.principal = principal;
}
public void test()
{
principal.principalInfo();
System.out.println("Test College Method");
}
}
Ahora vaya al archivo CollegeConfig.java y el CollegeConfig.java modificado se muestra a continuación. Consulte los comentarios para una mejor comprensión.
B. Clase de configuración
Java
// Java Program to Illustrate Configuration Class
package BeanAnnotation;
// Importing required classes
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
// Annotation
@Configuration
public class CollegeConfig {
// Creating the Bean for Principal Class
@Bean public Principal principalBean()
{
return new Principal();
}
@Bean public College collegeBean()
{
// Constructor Injection
return new College(principalBean());
}
}
Y finalmente Abajo está el código para el archivo Main.java .
C. Clase de aplicación
Java
// Java Program to Illustrate Application Class
package BeanAnnotation;
// Importing required classes
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
// Main class
public class Main {
// Main driver method
public static void main(String[] args)
{
// Using AnnotationConfigApplicationContext
// instead of ClassPathXmlApplicationContext
// because we are not using XML Configuration
ApplicationContext context
= new AnnotationConfigApplicationContext(
CollegeConfig.class);
// Getting the bean
College college
= context.getBean("collegeBean", College.class);
// Invoking the method
// inside main() method
college.test();
}
}
Producción:
Hi, I am your principal Test College Method
Vía 2: Inyección de Dependencia de Setter (SDI)
En ese caso, primero, creemos un método setter dentro de la clase College. Así que nuestro archivo College.java modificado es el siguiente:
A. Clase universitaria
Java
// Java Program to Illustrate College Class
package BeanAnnotation;
// Class
public class College {
// Class data members
private Principal principal;
// Setter
public void setPrincipal(Principal principal)
{
// this keywords refers to current instance itself
this.principal = principal;
}
// Method
public void test()
{
principal.principalInfo();
// Print statement
System.out.println("Test College Method");
}
}
Ahora vaya al archivo CollegeConfig.java y el CollegeConfig.java modificado se proporciona a continuación de la siguiente manera:
B. Clase de configuración
Java
// Java Program to Illustrate Configuration Class
package BeanAnnotation;
// Importing required classes
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
// Annotation
@Configuration
// Class
public class CollegeConfig {
// Creating the Bean for Principal Class
@Bean public Principal principalBean()
{
return new Principal();
}
@Bean public College collegeBean()
{
// Setter Injection
College college = new College();
college.setPrincipal(principalBean());
return college;
}
}
Y finalmente Abajo está el código para el archivo Main.java .
C. Clase de aplicación
Java
// Java Program to Illustrate Application (Main) Class
package BeanAnnotation;
// Importing required classes
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
// Application (Main) class
public class Main {
// Main driver method
public static void main(String[] args)
{
// Using AnnotationConfigApplicationContext
// instead of ClassPathXmlApplicationContext
// because we are not using XML Configuration
ApplicationContext context
= new AnnotationConfigApplicationContext(
CollegeConfig.class);
// Getting the bean
College college
= context.getBean("collegeBean", College.class);
// Invoking the method
// inside main() method
college.test();
}
}
Producción:
Hi, I am your principal Test College Method
Publicación traducida automáticamente
Artículo escrito por AmiyaRanjanRout y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA