Annotazioni Spring JSR-250

Spring supporta anche annotazioni basate su JSR-250 che includono annotazioni @PostConstruct, @PreDestroy e @Resource. Sebbene queste annotazioni non siano realmente richieste perché hai già altre alternative, facci comunque una breve idea su di esse.

Annotazioni @PostConstruct e @PreDestroy

Per definire la configurazione e lo smontaggio di un bean, dichiariamo semplicemente <bean> con init-method e / o destroy-methodparametri. L'attributo init-method specifica un metodo che deve essere chiamato sul bean immediatamente dopo l'istanza. Allo stesso modo, il metodo destroy specifica un metodo che viene chiamato appena prima che un bean venga rimosso dal contenitore.

Puoi usare @PostConstruct annotazione come alternativa al callback di inizializzazione e @PreDestroy annotazione come alternativa al callback di distruzione come spiegato nell'esempio seguente.

Esempio

Cerchiamo di avere un IDE Eclipse funzionante e di eseguire i seguenti passaggi per creare un'applicazione Spring:

Passo	Descrizione
1	Crea un progetto con un nome SpringExample e crea un pacchetto com.tutorialspoint sottosrc cartella nel progetto creato.
2	Aggiungere le librerie Spring richieste utilizzando l' opzione Aggiungi JAR esterni come spiegato nel capitolo Esempio Spring Hello World .
3	Crea classi Java HelloWorld e MainApp nel pacchetto com.tutorialspoint .
4	Crea il file di configurazione Beans Beans.xml sottosrc cartella.
5	Il passaggio finale consiste nel creare il contenuto di tutti i file Java e nel file di configurazione Bean ed eseguire l'applicazione come spiegato di seguito.

Ecco il contenuto di HelloWorld.java file -

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.");
   }
}

Di seguito è riportato il contenuto del file MainApp.javafile. Qui è necessario registrare un hook di spegnimentoregisterShutdownHook()metodo dichiarato nella classe AbstractApplicationContext. Ciò garantirà un arresto regolare e chiamerà i metodi di distruzione pertinenti.

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();
   }
}

Di seguito è riportato il file di configurazione Beans.xml richiesto per i metodi di inizializzazione e distruzione -

<?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 volta terminata la creazione dei file di configurazione dei bean e dei sorgenti, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, stamperà il seguente messaggio:

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

@ Annotazione risorsa

Puoi usare @Resourceannotazione sui campi o metodi setter e funziona allo stesso modo di Java EE 5. L'annotazione @Resource accetta un attributo 'name' che verrà interpretato come il nome del bean da iniettare. Puoi dire, segueby-name semantica di autowiring come dimostrato nel seguente esempio:

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();
   }
}

Se nessun "nome" è specificato esplicitamente, il nome predefinito viene derivato dal nome del campo o dal metodo setter. Nel caso di un campo, prende il nome del campo; nel caso di un metodo setter, prende il nome della proprietà del bean.