Mondo Java: Utilizzando JSR-250 è @ PostConstruct Annotazione per sostituire Spring InitializingBean

JSR-250 Annotazioni aka comuni per la piattaforma Java è stata introdotta come parte di Java EE 5 uno è di solito utilizzato per EJB3s annotati. Cosa non così noto è che la Primavera ha sostenuto tre delle annotazioni a partire dalla versione 2.5. Le annotazioni supportati sono:

@ PostContruct - Questa annotazione è applicato a un metodo per indicare che esso dovrebbe essere invocato dopo tutto l'iniezione di dipendenza è completa.
@ PreDestroy - Questo è applicato a un metodo per indicare che dovrebbe essere invocato prima che il fagiolo è stato rimosso dal contesto primavera, cioè subito prima che sia distrutto.
@ Resource - Questo duplica la funzionalità di @ Autowired combinato con @ Qualifier come si ottiene l'ulteriore vantaggio di poter nome che si sta iniettando di fagioli, senza la necessità di due annotazioni.

Questo blog vuole un rapido sguardo alla prima annotazione nell'elenco @ PostConstruct, dimostrando come sia applicata e confrontandola con l'interfaccia equivalente InitializingBean. InitializingBean dispone di un metodo, afterPropertiesSet (), e fa quello che dice sulla latta. Il metodo afterPropertiesSet () viene chiamato dopo la primavera ha completato il cablaggio cose insieme. Il frammento di codice seguente mostra come InitializingBean è implementata.

pubblico classe ImplementInitializingBean implementa InitializingBean {
 
private boolean risultato;
 
pubblico businessMethod String () {
 
System.out.println ( "Inside - ImplementInitializingBean" );
ritorno "InitializingBeanResult" ;
}
 
/ **
* Questo fa parte dell'interfaccia InitializingBean - chiamato dopo che il fagiolo è stata messa a punto. Utilizzare questo metodo per controllare che la
fagiolo * è stata messa a punto correttamente. Anche così usarlo per configurare le risorse esterne, come i database, ecc
* /
@ Override
pubblico vuoto afterPropertiesSet () throws Exception {
 
result = true ;
System.out.println ( "In aferPropertiesSet () - controlla il set-up del fagiolo.");
}
 
pubblico boolean getResult () {
rientro risultato;
}
}

Le annotazioni sono tenuti a rendere la vita più facile, ma fanno in questo caso? In primo luogo usare la @ PostConstruct annotazione è necessario includere le seguenti dipendenze del file POM:

<- Richiesto per le annotazioni Primavera ->         
< dipendenza >
< groupId > org.springframework </ groupId >
< artifactId > primavera-web </ artifactId >
< versione > spring.version $ {} </ version >
</ dipendenza >
< dipendenza >
< groupId > org.springframework </ groupId >
< artifactId > primavera-webmvc </ artifactId >
< versione > spring.version $ {} </ version >
</ dipendenza >
< dipendenza >
< groupId > javax.servlet </ groupId >
< artifactId > servlet-api </ artifactId >
< versione > 2.5 </ version >
< ambito > fornito </ portata >
</ dipendenza >

È inoltre necessario dire Primavera di usare le annotazioni aggiungendo quanto segue al file di configurazione di primavera:

<? xml version = "1.0" encoding = "UTF-8" ?>
< fagioli xmlns = " http://www.springframework.org/schema/beans "
xmlns: xsi = " http://www.w3.org/2001/XMLSchema-instance "
. 04xmlns: contesto = " http://www.springframework.org/schema/context "
xmlns: MVC = " http://www.springframework.org/schema/mvc "
xsi:schemaLocation="http://www.springframework.org/schema/mvchttp://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-3.0.xsd">
 
<!-- Scans the classpath of this application for @Components to deploy as beans -->
<context:component-scan base-package="jsr250annotations" />
 
<!-- Configures the @Controller programming model -->
<mvc:annotation-driven />
</beans>

Having setup the environment, you can now use the @PostConstruct annotation.

@Component
public class ImplementPostConstruct implements MyPostConstructExample {
 
private boolean result;
 
@Override
public String businessMethod() {
 
System.out.println("Inside - ImplementPostConstruct");
return "ImplementPostConstruct";
}
 
/**
* @PostConstruct means that this is called after the bean has been set-up.
*                Use this method to check that the bean has been set-up
*                correctly. Also so use it to configure external resources
*                such as databases etc.
*/
@PostConstruct
public void postConstruct() {
 
result = true;
System.out
.println("In postConstruct() - check the set-up of the bean.");
}
 
@Override
public boolean getResult() {
return result;
}
}
 
This is tested using the JUnit Test below:
@Test
public void postConstructTest() {
 
instance1 = ctx.getBean(ImplementPostConstruct.class);
 
String result = instance1.businessMethod();
assertEquals("ImplementPostConstruct", result);
 
boolean var = instance1.getResult();
assertTrue(var);
}

I due ammassi di codice di cui sopra fanno la stessa cosa con PostConstruct () viene chiamato alasafterPropertiesSet tempo stesso (). E 'facile vedere che le annotazioni aspetto più ordinato, ma sono anche più difficili da installare? Ti lascerò essere il giudice di tutto questo. Infine, un ultima cosa da notare, le annotazioniJSR-250 forniscono utili funzionalità di base, ma sono parte del progetto Spring MVC garantendo una dipendenzapossibile superfluo sulla javax.servlet-api vaso, in modo forse un po 'di refactoring può essere una buona idea un certo punto.

Corso Java - Corsi Java - Corsi programmazione Java

Corso programmazione Android - Certificazione Android

Mondo Java

lunedì 7 novembre 2011

Utilizzando JSR-250 è @ PostConstruct Annotazione per sostituire Spring InitializingBean

Nessun commento:

Posta un commento