Los métodos de fábrica estáticos son aquellos que pueden devolver el mismo tipo de objeto que los implementa . Los métodos de fábrica estáticos son más flexibles con los tipos de retorno, ya que también pueden devolver subtipos y primitivos. Los métodos de fábrica estáticos se utilizan para encapsular el proceso de creación de objetos. En el marco de Spring, si queremos crear un bean usando el método de fábrica estático, entonces podríamos usar los atributos del método de fábrica.
Ejemplo
En este ejemplo, usaremos el método de fábrica estático para crear un bean y encapsular el proceso de creación del bean. Usaremos una clase de Estudiante y crearemos diferentes objetos de esta clase basados en el departamento de los estudiantes usando el método de fábrica estática.
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).
Fig. 1 – Descripciones de proyectos
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: Implementación de la clase de fábrica
En este paso, crearemos una clase StudentFactory y en esta clase, crearemos nuestro método de fábrica createStudentOfDepartmentType(String department) y proporcionaremos su implementación. Esta clase creará diferentes instancias de Alumno dependiendo del departamento al que pertenezca el alumno.
Java
public class StudentFactory {
public static Student createStudentOfDepartmentType(String department) {
// Student instance
Student student = null;
// if student belongs to CSE department
if(department.equals("CSE")) {
student = new Student();
student.setId(1);
student.setFirst_name("geeks");
student.setLast_name("geeks");
student.setDepartment(department);
}
// if student belongs to MECH department
else if(department.equals("MECH")) {
student = new Student();
student.setId(2);
student.setFirst_name("dummy");
student.setLast_name("dummy");
student.setDepartment(department);
}
// if department passed through
// beans is not known it will
// throw an exception
else {
throw new IllegalArgumentException("Unknown department");
}
return student;
}
}
Paso 5: Configuración de Bean
En este paso, crearemos el archivo de configuración de Spring y lo llamaremos application-contex.xml . Configuraremos nuestros beans y usaremos el atributo de método de fábrica para la creación de beans.
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"> <bean id="CSE" class="com.gfg.factory.StudentFactory" factory-method="createStudentOfDepartmentType"> <constructor-arg value="CSE" /> </bean> <bean id="MECH" class="com.gfg.factory.StudentFactory" factory-method="createStudentOfDepartmentType"> <constructor-arg value="MECH" /> </bean> </beans>
Paso 6: Creando Clase de Utilidades
Ahora, crearemos una clase de utilidad para probar nuestro método de fábrica estático de primavera. Para esto, cree una nueva clase y asígnele el nombre TestSpringFactoryMethod.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 TestSpringFactoryMethod {
@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());
Student mechanical_student = (Student)context.getBean("MECH");
System.out.println(mechanical_student.toString());
}
}
Producción:
Ejecute la aplicación como aplicación Java.
