Spring Framework proporciona Inyección de dependencia para eliminar la relación de dependencia convencional entre objetos. Para inyectar dependencias usando el método de fábrica, usaremos dos de los atributos factory-method y factory-bean de los elementos bean.
Nota : los métodos de fábrica son aquellos métodos que devuelven la instancia de la clase.
- Método de fábrica: estos son aquellos tipos de métodos que se invocan para inyectar los beans.
- Factory Bean: Estas son las referencias de los beans mediante los cuales se invocan los métodos de fábrica.
Tipos de método de fábrica
Hay tres tipos de métodos de fábrica:
- Método de fábrica estático : se utiliza para devolver la instancia de su propia clase. Los métodos de fábrica estáticos se utilizan para el patrón de diseño Singleton .
- Método de fábrica estático : se utiliza para devolver la instancia de tiempo de ejecución de otra clase.
- Método de fábrica no estático : se utiliza para devolver la instancia de tiempo de ejecución de otra clase.
Implementación: aquí inyectaremos las dependencias usando un patrón de fábrica. Para esto, crearemos una clase y la llamaremos Geeks.java e inyectaremos esta clase como dependencia.
A. Método de fábrica estático: una instancia de retorno de su propia clase
En este ejemplo, crearemos una clase única Geeks.java e inyectaremos su dependencia en nuestra clase principal utilizando el método de fábrica.
Paso 1: Crea una clase Geeks
Para esto crea un Geeks.java . También definiremos un método geeksMessage() para probar la inyección de dependencia usando el método de fábrica. A continuación se muestra el código para la clase Geeks.java.
Archivo: Geeks.java
Java
// Java Program to Illustrate Geeks Class
// Class
public class Geeks {
// define a private static instance
public static final Geeks geeks = new Geeks();
// private constructor
private Geeks() {}
// this method will return the above instance
// which was created when the class loaded in the memory
public static Geeks getGeeks() {
return geeks;
}
// this method is used to check the dependency injection
public void geeksMessage() {
System.out.println("Welcome to geeksforgeeks. DI for static factory method working good");
}
}
Paso 2: agregar dependencias
En este paso, agregaremos las siguientes dependencias en el archivo pom.xml.
Archivo: 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>DIFactoryMethods</artifactId> <version>0.0.1-SNAPSHOT</version> <dependencies> <!-- 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: Configuración de Bean
Ahora, crearemos el archivo application-context.xml en nuestra ruta de clase. Usaremos el archivo de contexto de la aplicación para configurar nuestro bean usando el método de fábrica. A continuación se muestra el código para el archivo application-context.xml.
Archivo: application-context.xml
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" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> <!-- Note: You need to define your whole class path for your Geeks.java class --> <bean id="geeksId" class="com.geeksforgeeks.model.Geeks" factory-method="getGeeks"> </bean> </beans>
Paso 4: Crear clase de utilidad
Ahora, crearemos una clase de utilidad para probar nuestra aplicación. Para esto, cree una nueva clase y asígnele el nombre TestDIFactoryMethod.java y agregue el siguiente código.
Archivo: TestDIFactoryMethod.java
Java
// Java Program to Illustrate TestDIFactoryMethod Class
// Importing required classes
import com.geeksforgeeks.model.Geeks;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
// Class
public class TestDIFactoryMethod {
// Main driver method
public static void main(String[] args)
{
// Reading the application-context file
// from the class-path
AbstractApplicationContext context
= new ClassPathXmlApplicationContext(
"application-context.xml");
// Spring check the blueprint for Geeks bean
// from application-context.xml file and return it
Geeks geeksObj = (Geeks)context.getBean("geeksId");
// geeksObj contain the dependency of Geeks class
geeksObj.geeksMessage();
}
}
Paso 5: Ejecute la aplicación
Producción:
Fig. 1 – Método de fábrica estático para instancia de clase propia
B. Método de fábrica estático: devolución de instancia de otra clase
En este ejemplo, inyectaremos dependencias de otras clases utilizando el método de fábrica estática.
Paso 1: crear una interfaz
Crearemos una interfaz y la llamaremos GeeksCourses.java y definiremos un método getCourseDetail() en ella.
Archivo: GeeksCourses.java
Java
// Java Program to Illustrate GeeksCourses interface
// Interface
public interface GeeksCourses {
// Print statement
public void getCourseDetail();
}
Paso 2: crear clases dependientes
En este paso, crearemos dos clases diferentes DSACourses y JavaCourses . Implementaremos la interfaz GeeksCourses de esta clase y anularemos el método getCourseDetail() . A continuación se muestra el código para ambas clases.
Archivo: DSACourses.java
Java
// Java Program to Illustrate DSACourses Class
// Class
// Implementing GeeksCourses interface
public class DSACourses implements GeeksCourses {
// Method
// Override the getCourseDeail()
public void getCourseDetail()
{
// Print statement
System.out.println("Data Structure & Algorithms");
}
Archivo: JavaCourses.java
Java
// Java Program to Illustrate JavaCourses Class
// Class
// Implementing GeeksCources interface
public class JavaCourses implements GeeksCourses {
// Method
// Override the getCourseDeail()
public void getCourseDetail()
{
// Print statement
System.out.println("Core Java Collections");
}
}
Paso 3: crear una clase de fábrica
Ahora, crearemos una clase de CourseFactory . Esta clase tendrá un método de fábrica estático para la interfaz GeeksCourses que devolverá la instancia de otra clase (DSACourses y JavaCourses). A continuación se muestra el código de la clase CourseFactory.java.
Archivo: CourseFactory.java
Java
// Java Program to Illustrate CourseFactory Class
package com.geeksforgeeks.model;
// Importing required classes
import com.geeksforgeeks.dao.GeeksCourses;
import com.geeksforgeeks.dao.JavaCourses;
// Class
public class CourseFactory {
// Method
// factory method returning instance to another class
public static GeeksCourses getCourses()
{
// Returning the instance of JavaCourses class
// One can also return the instance of DSACourses
return new JavaCourses();
}
}
Paso 4: Configuración de Bean
Ahora, crearemos el archivo application-context.xml en nuestro classpath. Usaremos el archivo de contexto de la aplicación para configurar nuestro bean usando el método de fábrica.
Archivo: application-context.xml
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" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> <!-- Note: You need to define your whole class path for your CourseFactory.java class --> <bean id="courseId" class="com.geeksforgeeks.model.CourseFactory" factory-method="getCourses"> </bean> </beans>
Paso 5: Crear clase de utilidad
Ahora, crearemos una clase de utilidad para probar nuestra aplicación. Para esto, cree una nueva clase y asígnele el nombre TestDIFactoryMethod.java y agregue el siguiente código.
Archivo: TestDIFactoryMethod.java
Java
// Java Program to Illustrate TestDIFactoryMethod Class
// importing required classes
import com.geeksforgeeks.dao.GeeksCourses;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
// Class
public class TestDIFactoryMethod {
// Main driver method
public static void main(String[] args)
{
// Reading the application-context file
// from the class-path
AbstractApplicationContext context
= new ClassPathXmlApplicationContext(
"application-context.xml");
// Spring check the blueprint for GeeksCourses bean
// from application-context.xml file and return it
GeeksCourses geeksCourses
= (GeeksCourses)context.getBean("courseId");
// geeksCourses contain the dependency
// of GeeksCourses class
geeksCourses.getCourseDetail();
}
}
Paso 6: Ejecute la aplicación.
Producción:
Fig. 2: método de fábrica estático para otra instancia de clase
C. Método de fábrica no estático: instancia de devolución de otra clase
En este ejemplo, inyectaremos dependencias de otras clases utilizando el método de fábrica no estático.
Paso 1: crear una interfaz
Crearemos una interfaz y la llamaremos GeeksCourses.java y definiremos un método getCourseDetail() en ella.
Archivo: GeeksCourses.java
Java
// Java Program to Illustrate GeeksCourses Interface
// Interface
public interface GeeksCourses
{
// Print statement
public void getCourseDetail();
}
Paso 2: crear clases dependientes
En este paso, crearemos dos clases diferentes DSACourses y JavaCourses . Implementaremos la interfaz GeeksCourses desde estas clases y anularemos el método getCourseDetail(). A continuación se muestra el código para ambas clases.
Archivo: DSACourses.java
Java
// Java Program to illustrate DSACourses Class
// Class
// Implementing GeeksCourses interface
public class DSACourses implements GeeksCourses {
// Override the getCourseDeail() method
public void getCourseDetail()
{
// Print statement
System.out.println("Data Structure & Algorithms");
}
}
Archivo: JavaCourses.java
Java
// Java Program to Illustrate JavaCourses Class
// Class
public class JavaCourses implements GeeksCourses {
// Method
// Override the getCourseDeail() method
public void getCourseDetail()
{
// Print statement
System.out.println("Core Java Collections");
}
}
Paso 3: crear una clase de fábrica
Ahora, crearemos una clase de CourseFactory . Esta clase tendrá un método de fábrica no estático para la interfaz GeeksCourses que devolverá la instancia de otra clase (DSACourses y JavaCourses).
Archivo: CourseFactory.java
Java
// Java Program to Illustrate CourseFactory Class
// Importing required classes
import com.geeksforgeeks.dao.DSACourses;
import com.geeksforgeeks.dao.GeeksCourses;
// Class
public class CourseFactory {
// Non-static factory method that returns
// the instance to another class
public GeeksCourses getCourses()
{
// Returning the instance of JavaCourses class
// One can also return the instance of DSACourses
return new DSACourses();
}
}
Paso 4: Configuración de Bean
Ahora, crearemos un archivo application-context.xml en nuestra class-path. Usaremos el archivo de contexto de la aplicación para configurar nuestro bean usando el método de fábrica.
Archivo: application-context.xml
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" xmlns:p="http://www.springframework.org/schema/p" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> <!-- Note: You need to define your whole class path for your CourseFactory.java class --> <bean id="courseFactory" class="com.geeksforgeeks.model.CourseFactory"></bean> <bean id="courseId" class="com.geeksforgeeks.model.CourseFactory" factory-method="getCourses" factory-bean="courseFactory"> </bean> </beans>
Paso 5: Crear clase de utilidad
Ahora, crearemos una clase de utilidad para probar nuestra aplicación. Para esto, cree una nueva clase y asígnele el nombre ‘ TestDIFactoryMethod.java y agregue el siguiente código.
Archivo: TestDIFactoryMethod.java
Java
// Java Program to Illustrate TestDIFactoryMethod Class
// Importing required classes
import com.geeksforgeeks.dao.GeeksCourses;
import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
// Class
public class TestDIFactoryMethod {
// Main driver method
public static void main(String[] args)
{
// Reading the application-context file
// from the class-path
AbstractApplicationContext context
= new ClassPathXmlApplicationContext(
"application-context.xml");
// Spring check the blueprint for GeeksCourses bean
// from application-context.xml file and return it
GeeksCourses geeksCourses
= (GeeksCourses)context.getBean("courseId");
// geeksCourses contain the dependency
// of GeeksCourses class
geeksCourses.getCourseDetail();
}
}
Paso 6: Ejecute la aplicación
Producción:
Fig. 2: método de fábrica no estático para otra instancia de clase