Ciclo de vida del frijol en Java Spring

Prerrequisito: Introducción a Spring Framework

El ciclo de vida de cualquier objeto significa cuándo y cómo nace, cómo se comporta a lo largo de su vida y cuándo y cómo muere. De manera similar, el ciclo de vida del frijol se refiere a cuándo y cómo se instancia el frijol, qué acción realiza hasta que vive y cuándo y cómo se destruye. En este artículo, discutiremos el ciclo de vida del frijol. 

El ciclo de vida del frijol es administrado por el contenedor de primavera. Cuando ejecutamos el programa, en primer lugar, se inicia el contenedor de primavera. Después de eso, el contenedor crea la instancia de un bean según la solicitud y luego se inyectan las dependencias. Y finalmente, el frijol se destruye cuando se cierra el contenedor de resorte. Por lo tanto, si queremos ejecutar algún código en la instanciación del bean y justo después de cerrar el contenedor de primavera, podemos escribir ese código dentro del método init() personalizado y el método destroy() .

La siguiente imagen muestra el flujo de proceso del ciclo de vida del bean.  

Flujo de proceso del ciclo de vida del frijol

Nota: Podemos elegir un nombre de método personalizado en lugar de init() y destroy() . Aquí, usaremos el método init() para ejecutar todo su código a medida que se inicia el contenedor Spring y se crea una instancia del bean, y el método destroy() para ejecutar todo su código al cerrar el contenedor. 

Formas de implementar el ciclo de vida de un frijol
Spring proporciona tres formas de implementar el ciclo de vida de un frijol. Para entender estas tres formas, tomemos un ejemplo. En este ejemplo, escribiremos y activaremos los métodos init() y destroy() para nuestro bean (HelloWorld.java) para imprimir algún mensaje al inicio y cierre del contenedor Spring. Por lo tanto, las tres formas de implementar esto son: 

1. Por XML: en este enfoque, para aprovechar el método personalizado init() y destroy() para un bean, debemos registrar estos dos métodos dentro del archivo de configuración XML de Spring al definir un bean. Por lo tanto, se siguen los siguientes pasos: 

• Primero, necesitamos crear un bean HelloWorld.java en este caso y escribir los métodos init() y destroy() en la clase.

// Java program to create a bean
// in the spring framework
package beans;
 
public class HelloWorld {
 
    // This method executes
    // automatically as the bean
    // is instantiated
    public void init() throws Exception
    {
        System.out.println(
            "Bean HelloWorld has been "
            + "instantiated and I'm "
            + "the init() method");
    }
 
    // This method executes
    // when the spring container
    // is closed
    public void destroy() throws Exception
    {
        System.out.println(
            "Container has been closed "
            + "and I'm the destroy() method");
    }
}

• Ahora, necesitamos configurar el archivo Spring XML spring.xml y registrar los métodos init() y destroy() en él.

<!DOCTYPE
    beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"
        "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
             
<beans>
    <bean id="hw" class="beans.HelloWorld"
            init-method="init" destroy-method="destroy"/>
     
</beans>

• Finalmente, necesitamos crear una clase de controlador para ejecutar este bean.

// Java program to call the
// bean initialized above
 
package test;
 
import org.springframework
    .context
    .ConfigurableApplicationContext;
 
import org.springframework
    .context.support
    .ClassPathXmlApplicationContext;
 
import beans.HelloWorld;
 
// Driver class
public class Client {
 
    public static void main(String[] args)
        throws Exception
    {
 
        // Loading the Spring XML configuration
        // file into the spring container and
        // it will create the instance of
        // the bean as it loads into container
 
        ConfigurableApplicationContext cap
            = new ClassPathXmlApplicationContext(
                "resources/spring.xml");
 
        // It will close the spring container
        // and as a result invokes the
        // destroy() method
        cap.close();
    }
}

Producción: 

Bean HelloWorld ha sido instanciado y soy el método init() El 
contenedor ha sido cerrado y soy el método destroy() 
 

2. Por enfoque programático: para proporcionar al bean creado la posibilidad de invocar el método personalizado init() al iniciar un contenedor Spring y para invocar el método personalizado destroy() al cerrar el contenedor, necesitamos implementar nuestro bean con dos las interfaces, a saber , InitializingBean , AvailableBean y tendrán que anular el método afterPropertiesSet() y destroy() . El método afterPropertiesSet() se invoca cuando se inicia el contenedor y se crea una instancia del bean, mientras que el método destroy() se invoca justo después de que se cierra el contenedor. 

Nota: para invocar el método de destrucción, debemos llamar al método close() de ConfigurableApplicationContext.

Por lo tanto, se siguen los siguientes pasos: 

• En primer lugar, necesitamos crear un bean HelloWorld.java en este caso implementando InitializingBean, WasteBean y anulando los métodos afterPropertiesSet() y destroy().

// Java program to create a bean
// in the spring framework
package beans;
 
import org.springframework
    .beans.factory.DisposableBean;
 
import org.springframework
    .beans.factory.InitializingBean;
 
// HelloWorld class which implements the
// interfaces
public class HelloWorld
    implements InitializingBean,
 DisposableBean {
 
    @Override
    // It is the init() method
    // of our bean and it gets
    // invoked on bean instantiation
    public void afterPropertiesSet()
throws Exception
    {
        System.out.println(
            "Bean HelloWorld has been "
            + "instantiated and I'm the "
            + "init() method");
    }
 
    @Override
    // This method is invoked
    // just after the container
    // is closed
    public void destroy() throws Exception
    {
        System.out.println(
            "Container has been closed "
            + "and I'm the destroy() method");
    }
}

• Ahora, necesitamos configurar el archivo Spring XML spring.xml y definir el bean.

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"
            "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
             
<beans>
    <bean id="hw" class="beans.HelloWorld"/>
     
</beans>

• Finalmente, necesitamos crear una clase de controlador para ejecutar este bean.

// Java program to call the
// bean initialized above
 
package test;
 
import org.springframework
    .context
    .ConfigurableApplicationContext;
 
import org.springframework
    .context.support
    .ClassPathXmlApplicationContext;
 
import beans.HelloWorld;
 
// Driver class
public class Client {
 
    public static void main(String[] args)
        throws Exception
    {
 
        // Loading the Spring XML configuration
        // file into the spring container and
        // it will create the instance of the bean
        // as it loads into container
        ConfigurableApplicationContext cap
            = new ClassPathXmlApplicationContext(
                "resources/spring.xml");
 
        // It will close the spring container
        // and as a result invokes the
        // destroy() method
        cap.close();
    }
}

Producción: 

Bean HelloWorld ha sido instanciado y soy el método init() El 
contenedor ha sido cerrado y soy el método destroy() 
 

3. Uso de la anotación: para proporcionar al bean creado la posibilidad de invocar el método init() personalizado al iniciar un contenedor Spring y para invocar el método destroy() personalizado al cerrar el contenedor, necesitamos anotar el método init() con @ Anotación PostConstruct y método destroy() por anotación @PreDestroy .
Nota: Para invocar el método destroy() tenemos que llamar al método close() de ConfigurableApplicationContext.

Por lo tanto, se siguen los siguientes pasos:

• En primer lugar, necesitamos crear un bean HelloWorld.java en este caso y anotar el método init() personalizado con @PostConstruct y el método destroy() con @PreDestroy.

// Java program to create a bean
// in the spring framework
package beans;
 
import javax.annotation.PostConstruct;
import javax.annotation.PreDestroy;
 
// HelloWorld class
public class HelloWorld {
 
    // Annotate this method to execute it
    // automatically as the bean is
    // instantiated
    @PostConstruct
    public void init() throws Exception
    {
        System.out.println(
            "Bean HelloWorld has been "
            + "instantiated and I'm the "
            + "init() method");
    }
 
    // Annotate this method to execute it
    // when Spring container is closed
    @PreDestroy
    public void destroy() throws Exception
    {
        System.out.println(
            "Container has been closed "
            + "and I'm the destroy() method");
    }
}

• Ahora, necesitamos configurar el archivo Spring XML spring.xml y definir el bean.

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN 2.0//EN"
            "http://www.springframework.org/dtd/spring-beans-2.0.dtd">
             
<beans>
 
    <!-- activate the @PostConstruct and
@PreDestroy annotation -->
 
    <bean class="org.springframework
.context.annotation
.CommonAnnotationBeanPostProcessor"/>
 
    <!-- configure the bean -->
    <bean class="beans.HelloWorld"/>
     
</beans>

• Finalmente, necesitamos crear una clase de controlador para ejecutar este bean.

// Java program to call the
// bean initialized above
 
package test;
 
import org.springframework
    .context
    .ConfigurableApplicationContext;
 
import org.springframework
    .context.support
    .ClassPathXmlApplicationContext;
 
import beans.HelloWorld;
 
// Driver class
public class Client {
 
    public static void main(String[] args)
        throws Exception
    {
 
        // Loading the Spring XML configuration
        // file into Spring container and
        // it will create the instance of the
        // bean as it loads into container
        ConfigurableApplicationContext cap
            = new ClassPathXmlApplicationContext(
                "resources/spring.xml");
 
        // It will close the Spring container
        // and as a result invokes the
        // destroy() method
        cap.close();
    }
}

Producción: 

Bean HelloWorld ha sido instanciado y soy el método init() El 
contenedor ha sido cerrado y soy el método destroy()