SeamFramework.orgCommunity Documentation
Web Beans è pienamente integrata nell'ambiente Java EE. Web Beans ha accesso alle risorse Java EE ed ai contesti di persistenza JPA. I Web Beans possono essere usati in espressioni Unified EL dentro pagine JSF e JSP. Possono anche essere iniettati negli oggetti, come Servlet e Message-Driven Beans, che non sono Web Beans.
Tutti i Web Beans sia semplici che enterprise si avvantaggiano della dependency injection di Java EE usando @Resource, @EJB e @PersistenceContext. Abbiamo già visto un paio di esempi a riguardo, sebbene non ci siamo soffermati molto a suo tempo.
@Transactional @Interceptor
public class TransactionInterceptor {
@Resource Transaction transaction;
@AroundInvoke public Object manageTransaction(InvocationContext ctx) { ... }
}
@SessionScoped
public class Login {
@Current Credentials credentials;
@PersistenceContext EntityManager userDatabase;
...
}
Le chiamate Java EE @PostConstruct e @PreDestroy vengono anche supportate per tutti i Web Beans (semplici e enterprise). Il metodo @PostConstruct viene chiamato dopo che tutta l'injection è stata eseguita.
C'è una restrizione di cui essere informati: @PersistenceContext(type=EXTENDED) non è supportato per i Web Beans semplici.
E' facile utilizzare i Web Beans da un Servlet in Java EE 6. Semplicemente si inietti il Web Bean utilizzando l'injection del campo Web Bean o del metodo inizializzatore.
public class Login extends HttpServlet {
@Current Credentials credentials;
@Current Login login;
@Override
public void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
credentials.setUsername( request.getAttribute("username") ):
credentials.setPassword( request.getAttribute("password") ):
login.login();
if ( login.isLoggedIn() ) {
response.sendRedirect("/home.jsp");
}
else {
response.sendRedirect("/loginError.jsp");
}
}
}
Il client proxy Web Beans si occupa di instradare le invocazioni dei metodi da un Servlet alle corrette istanze di Credentials e Login per la richiesta corrente e la sessione HTTP.
L'injection dei Web Beans si applica a tutti gli EJB3, perfino quando non sono sotto il controllo del manager Web Bean (per esempio se sono stati ottenuti da ricerca JNDI diretta, o injection usando @EJB) In particolaresi può usare l'injection di Web Beans nei Message-Driven Beans, che non sono considerati Web Beans poiché non possono essere iniettati.
Si possono perfino associare degli interceptor Web Beans ai Message-Driven Beans.
@Transactional @MessageDriven
public class ProcessOrder implements MessageListener {
@Current Inventory inventory;
@PersistenceContext EntityManager em;
public void onMessage(Message message) {
...
}
}
Quindi ricevere i messaggi è veramente facile in ambiente Web Beans. Ma attenzione che non è disponibile alcun contesto di sessione o conversazione quando il messaggio viene consegnato al Message-Driven Bean. Solamente i Web Beans @RequestScoped and @ApplicationScoped sono disponibili.
E' anche molto facile spedire messaggi usando Web Beans.
La spedizione dei messaggi usando JMS può essere abbastanza complessa, a causa del numero di oggetti differenti da trattare. Per le code si hanno Queue, QueueConnectionFactory, QueueConnection, QueueSession e QueueSender. Per i topic si hanno Topic, TopicConnectionFactory, TopicConnection, TopicSession e TopicPublisher. Ciascuno di questi oggetti ha il proprio ciclo di vita e modello di thread di cui bisogna (pre)occuparsi.
I Web Beans si prendono cura di tutto questo per noi. Tutto ciò che occorre fare è dichiarare la coda od il topic in web-beans.xml, specificando un
<Queue>
<destination
>java:comp/env/jms/OrderQueue</destination>
<connectionFactory
>java:comp/env/jms/QueueConnectionFactory</connectionFactory>
<myapp:OrderProcessor/>
</Queue
>
<Topic>
<destination
>java:comp/env/jms/StockPrices</destination>
<connectionFactory
>java:comp/env/jms/TopicConnectionFactory</connectionFactory>
<myapp:StockPrices/>
</Topic
>
Ora è possibile iniettare Queue, QueueConnection, QueueSession o QueueSender per una coda, oppure Topic, TopicConnection, TopicSession o TopicPublisher per un topic.
@OrderProcessor QueueSender orderSender;
@OrderProcessor QueueSession orderSession;
public void sendMessage() {
MapMessage msg = orderSession.createMapMessage();
...
orderSender.send(msg);
}
@StockPrices TopicPublisher pricePublisher;
@StockPrices TopicSession priceSession;
public void sendMessage(String price) {
pricePublisher.send( priceSession.createTextMessage(price) );
}
Il ciclo di vita degli oggetti JMS iniettati è interamente controllato dal manager Web Bean.
Web Beans non definisce nessuno archivio speciale per il deploy. Si può impacchettare i Web Beans in JAR, EJB-JAR o WAR qualsiasi locazione di deploy nel classpath dell'applicazione. Comunque ciascun archivio che contiene Web Beans devi includere un file chiamato web-beans.xml nella directory META-INF o WEB-INF. Il file può essere vuoto. I Web Beans collocati negli archivi che non hanno un file web-beans.xml non saranno disponibili per l'uso nell'applicazione.
Per l'esecuzione in Java SE, Web Beans può essere deployato in un qualsiasi posto nel quale gli EJB siano stati messi per essere eseguito da un embeddable EJB Lite container. Di nuovo ogni locazioni deve contenere un file web-beans.xml.