Spring es uno de los marcos Java EE más populares. Es un marco ligero de código abierto que permite a los desarrolladores de Java EE 7 crear aplicaciones empresariales sencillas, fiables y escalables. Este marco se centra principalmente en proporcionar varias formas de ayudarlo a administrar sus objetos comerciales. Hizo que el desarrollo de aplicaciones web fuera mucho más fácil en comparación con los marcos Java clásicos y las interfaces de programación de aplicaciones (API), como la conectividad de base de datos Java (JDBC), JavaServer Pages (JSP) y Java Servlet. Este marco utiliza varias técnicas nuevas, como la programación orientada a aspectos (AOP), el objeto Java antiguo simple (POJO) y la inyección de dependencia (DI), para desarrollar aplicaciones empresariales.
El contenedor de primavera tiene dos tipos de frijoles:
- Frijol ordinario: utilizado por defecto por Spring.
- Bean de fábrica: se utiliza para producir beans (objetos) que son administrados por Spring Framework.
Factory Bean es un bean que actúa como una fábrica para crear otros beans e instanciarlos con el contenedor Spring IOC. Los beans de fábrica se usan principalmente para implementar las instalaciones del marco y, por lo tanto, son específicos del marco y no se pueden usar fuera del alcance de los contenedores IOC de Spring. Por ejemplo:
- JndiObjectFactoryBean: se utiliza para buscar fuentes de datos de JNDI
- ProxyFactoryBean: se usa para crear un proxy para un bean usando AOP
¿Cómo crear un bean de fábrica?
- Podemos crear un bean de fábrica que necesitamos para implementar la interfaz FactoryBean mediante nuestro bean (definido por el usuario) que creará los otros beans que el bean de fábrica debe devolver.
- Un método simple es extender la clase AbstractFactoryBean . Estamos obligados a anular el método createInstance() utilizando el bean de fábrica para crear las instancias de los beans de destino. Después de eso, necesitamos devolver el tipo de beans objetivo usando el método getObjectType().
- getObjectType(): este método devolverá el tipo de objeto producido por el bean de fábrica.
Ejemplo
En este ejemplo, crearemos un bean de fábrica que producirá diferentes tipos de beans de estudiante según sus departamentos con su id, nombre y apellido como datos completos.
Paso 1: crear un proyecto Maven
En este paso, crearemos un nuevo proyecto maven y nos aseguraremos de que creará un proyecto simple (omita la selección de arquetipos).
Figura 1: detalles del proyecto Maven
Paso 2: agregar dependencias
Ahora agregaremos las dependencias maven a nuestra aplicación. Agregue las siguientes dependencias a su pom.xml
XML
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelVersion>4.0.0</modelVersion> <groupId>com.geeksforgeeks</groupId> <artifactId>GeeksForGeeks</artifactId> <version>0.0.1-SNAPSHOT</version> <dependencies> <!-- https://mvnrepository.com/artifact/org.springframework/spring-context --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-beans</artifactId> <version>5.0.8.RELEASE</version> </dependency> <!-- https://mvnrepository.com/artifact/org.springframework/spring-context --> <dependency> <groupId>org.springframework</groupId> <artifactId>spring-context</artifactId> <version>5.0.8.RELEASE</version> </dependency> </dependencies> </project>
Paso 3: crear una clase de modelo (bean)
En este paso, crearemos una clase modelo Student.java para nuestra aplicación. Esta clase tendrá id, nombre, apellido y departamento como variables miembro. Crearemos su método getter y setters y proporcionaremos una definición del método toString().
Java
public class Student {
// member variable
private int id;
private String first_name;
private String last_name;
private String department;
// getters and setters
public int getId() { return id; }
public void setId(int id) { this.id = id; }
public String getFirst_name() { return first_name; }
public void setFirst_name(String first_name)
{
this.first_name = first_name;
}
public String getLast_name() { return last_name; }
public void setLast_name(String last_name)
{
this.last_name = last_name;
}
public String getDepartment() { return department; }
public void setDepartment(String department)
{
this.department = department;
}
// toStirng() method
@Override public String toString()
{
return "Student [id=" + id + ", first_name="
+ first_name + ", last_name=" + last_name
+ ", department=" + department + "]";
}
}
Paso 4: Crea la clase StudentFactoryBean
En este paso, crearemos una clase FactoryBean que extenderá la clase AbstractFactoryBean y también debemos implementar sus métodos createInstance() y getObjectType().
Java
import org.springframework.beans.factory.config.AbstractFactoryBean;
import com.gfg.model.Student;
public class StudentFactoryBean extends AbstractFactoryBean<Object>{
// Member variables
private String department;
public String getDepartment() {
return department;
}
public void setDepartment(String department) {
this.department = department;
}
// This will return the bean type
// that factory bean will create
@Override
public Class<Student> getObjectType() {
// TODO Auto-generated method stub
return Student.class;
}
// This method will create the
// beans using factory bean
@Override
protected Object createInstance() throws Exception {
// TODO Auto-generated method stub
Student student = new Student();
student.setId(1);
student.setFirst_name("geeks");
student.setLast_name("geeks");
student.setDepartment(department);
return student;
}
@Override
public String toString() {
return "StudentFactoryBean [department=" + department + "]";
}
}
Paso 5: Configuración de Bean
En este paso, crearemos un archivo de configuración Spring y lo llamaremos application-contex.xml. Configuraremos nuestros beans y usaremos la etiqueta de propiedad del elemento bean para establecer el valor del departamento del estudiante. (Nota: en el contexto de la aplicación, debe definir la ruta completa de su clase de bean de fábrica)
XML
<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation=" http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd"> <!-- Here, full path of StudentFactoryBean class is given you need to define your own package module name --> <bean id="CSE" class="com.gfg.factory.StudentFactoryBean"> <property name="department" value="Computer Science Department"></property> </bean> </beans>
Paso 6: Creando Clase de Utilidades
Ahora, crearemos una clase de utilidad para probar nuestro método de bean de fábrica. Para esto, cree una nueva clase y asígnele el nombre TestSpringFactoryBean.java y agregue el siguiente código.
Java
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.gfg.model.Student;
public class TestSpringFactoryBean {
@SuppressWarnings("resource")
public static void main(String []args) throws Exception {
// Reading the application-context file using
// class path of spring context xml file
AbstractApplicationContext context = new ClassPathXmlApplicationContext("application-context.xml");
// Spring check the blueprint for Student bean
// from application-context.xml file and return it
Student computer_student = (Student)context.getBean("CSE");
System.out.println(computer_student.toString());
}
}
Producción:
Ahora ejecutaremos nuestra aplicación.
