Anotaciones Spring JSR-250

Spring también admite anotaciones basadas en JSR-250 que incluyen anotaciones @PostConstruct, @PreDestroy y @Resource. Aunque estas anotaciones no son realmente necesarias porque ya tiene otras alternativas, permítanos tener una breve idea sobre ellas.

@PostConstruct y @PreDestroy Anotaciones

Para definir la configuración y el desmontaje de un bean, simplemente declaramos el <bean> con init-method y / o destroy-methodparámetros. El atributo init-method especifica un método que se llamará en el bean inmediatamente después de la instanciación. De manera similar, el método destroy especifica un método que se llama justo antes de que se elimine un bean del contenedor.

Puedes usar @PostConstruct anotación como alternativa a la devolución de llamada de inicialización y @PreDestroy anotación como alternativa a la devolución de llamada de destrucción como se explica en el siguiente ejemplo.

Ejemplo

Tengamos un IDE de Eclipse en funcionamiento y sigamos los siguientes pasos para crear una aplicación Spring:

Paso	Descripción
1	Cree un proyecto con un nombre SpringExample y cree un paquete com.tutorialspoint bajo elsrc carpeta en el proyecto creado.
2	Agregue las bibliotecas Spring requeridas usando la opción Agregar JAR externos como se explica en el capítulo Ejemplo de Spring Hello World .
3	Cree clases Java HelloWorld y MainApp en el paquete com.tutorialspoint .
4	Cree el archivo de configuración de Beans Beans.xml bajo elsrc carpeta.
5	El paso final es crear el contenido de todos los archivos Java y el archivo de configuración de Bean y ejecutar la aplicación como se explica a continuación.

Aquí está el contenido de HelloWorld.java archivo -

package com.tutorialspoint;
import javax.annotation.*;

public class HelloWorld {
   private String message;

   public void setMessage(String message){
      this.message  = message;
   }
   public String getMessage(){
      System.out.println("Your Message : " + message);
      return message;
   }
   
   @PostConstruct
   public void init(){
      System.out.println("Bean is going through init.");
   }
   
   @PreDestroy
   public void destroy(){
      System.out.println("Bean will destroy now.");
   }
}

A continuación se muestra el contenido de la MainApp.javaarchivo. Aquí, debe registrar un gancho de cierreregisterShutdownHook()método que se declara en la clase AbstractApplicationContext. Esto asegurará un cierre ordenado y llamará a los métodos de destrucción relevantes.

package com.tutorialspoint;

import org.springframework.context.support.AbstractApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class MainApp {
   public static void main(String[] args) {
      AbstractApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");

      HelloWorld obj = (HelloWorld) context.getBean("helloWorld");
      obj.getMessage();
      context.registerShutdownHook();
   }
}

A continuación se muestra el archivo de configuración Beans.xml requerido para los métodos de inicio y destrucción -

<?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:context = "http://www.springframework.org/schema/context"
   xsi:schemaLocation = "http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
   http://www.springframework.org/schema/context
   http://www.springframework.org/schema/context/spring-context-3.0.xsd">

   <context:annotation-config/>
   <bean id = "helloWorld" class = "com.tutorialspoint.HelloWorld"
      init-method = "init" destroy-method = "destroy">
      <property name = "message" value = "Hello World!"/>
   </bean>

</beans>

Una vez que haya terminado de crear los archivos de configuración de fuente y bean, ejecutemos la aplicación. Si todo está bien con su aplicación, imprimirá el siguiente mensaje:

Bean is going through init.
Your Message : Hello World!
Bean will destroy now.

@Anotación de recursos

Puedes usar @Resourceanotación en campos o métodos de establecimiento y funciona igual que en Java EE 5. La anotación @Resource toma un atributo 'nombre' que se interpretará como el nombre del bean que se inyectará. Puedes decir que sigueby-name semántica de cableado automático como se demuestra en el siguiente ejemplo:

package com.tutorialspoint;

import javax.annotation.Resource;

public class TextEditor {
   private SpellChecker spellChecker;

   @Resource(name = "spellChecker")
   public void setSpellChecker( SpellChecker spellChecker ){
      this.spellChecker = spellChecker;
   }
   public SpellChecker getSpellChecker(){
      return spellChecker;
   }
   public void spellCheck(){
      spellChecker.checkSpelling();
   }
}

Si no se especifica un 'nombre' explícitamente, el nombre predeterminado se deriva del nombre del campo o del método de establecimiento. En el caso de un campo, toma el nombre del campo; en el caso de un método setter, toma el nombre de propiedad del bean.

↰ Previous page