SeamFramework.orgCommunity Documentation
Attualmente Web Bean RI funziona solo in JBoss AS 5; l'integrazione di RI in altri ambienti EE (per esempio in un application server come Glassfish), in un servlet container (come Tomcat), o con un'implementazione EJB3.1 Embedded è abbastanza facile. In questo appendice si discuterà brevemente dei passi necessari.
Dovrebbe essere possibile far funzionare Web Beans in un ambiente SE, ma occorre molto lavoro per aggiungere i propri contesti ed il ciclo di vita. Web Beans RI attualmente non espone punti di estensione del ciclo di vita, così occorre codificare direttamente nelle classi Web Beans RI.
Web Beans SPI è collocato nel modulo webbeans-ri-spi, ed è impacchettato come webbeans-ri-spi.jar. Alcuni SPI sono opzionali se occorre fare override del comportamento di default, altri sono richiesti.
Si può specificare l'implementazione di un SPI sia come proprietà di sistema, sia in un file di proprietà META-INF/web-beans-ri.properties. Tutti i nomi delle proprietà sono nomi di classi fully qualified dell'interfaccia di implementazione; tutti i valori sono nomi di classi fully qualified della classe di implementazione.
Tutte le interfacce in SPI supportano il pattern decorator e forniscono una classe Forwarding.
public interface WebBeanDiscovery {
/**
* Gets list of all classes in classpath archives with web-beans.xml files
*
* @return An iterable over the classes
*/
public Iterable<Class<?>
> discoverWebBeanClasses();
/**
* Gets a list of all web-beans.xml files in the app classpath
*
* @return An iterable over the web-beans.xml files
*/
public Iterable<URL
> discoverWebBeansXml();
}
L'analisi dei file delle classi Web Bean e di web-bean.xml è molto istruttiva (l'algoritmo è descritto nella sezione 11.1 della specifica JSR-299 e non viene qua ripetuto).
Web Beans RI può essere istruita a caricare la propria implementazione di WebBeanDiscovery usando la proprietà org.jboss.webbeans.bootstrap.spi.WebBeanDiscovery con il nome della classe pienamente qualificato (fully qualified) come valore. Per esempio:
org.jboss.webbeans.bootstrap.spi.WebBeanDiscovery=org.jboss.webbeans.integration.jbossas.WebBeanDiscoveryImpl
Se Web Beans RI viene usato in un servlet container, si aspetta un costruttore della forma:
public WebBeanDiscoveryImpl(ServletContext servletContext) {}Il contesto del servlet può essere usato per consentire all'implementazione di WebBeanDiscovery di interagire con il container.
Web Beans RI delega al container la rilevazione dei bean EJB3 e quindi risulta non essere necessario eseguire lo scan delle annotazioni EJB3 o fare il parsing di ejb-jar.xml. Per ciascun EJB nell'applicazione dovrebbe essere rilevato un EJBDescriptor:
public interface EjbDiscovery
{
public static final String PROPERTY_NAME = EjbDiscovery.class.getName();
/**
* Gets a descriptor for each EJB in the application
*
* @return The bean class to descriptor map
*/
public Iterable<EjbDescriptor<?>
> discoverEjbs();
}
public interface EjbDescriptor<T
> {
/**
* Gets the EJB type
*
* @return The EJB Bean class
*/
public Class<T
> getType();
/**
* Gets the local business interfaces of the EJB
*
* @return An iterator over the local business interfaces
*/
public Iterable<BusinessInterfaceDescriptor<?>
> getLocalBusinessInterfaces();
/**
* Gets the remote business interfaces of the EJB
*
* @return An iterator over the remote business interfaces
*/
public Iterable<BusinessInterfaceDescriptor<?>
> getRemoteBusinessInterfaces();
/**
* Get the remove methods of the EJB
*
* @return An iterator over the remove methods
*/
public Iterable<Method
> getRemoveMethods();
/**
* Indicates if the bean is stateless
*
* @return True if stateless, false otherwise
*/
public boolean isStateless();
/**
* Indicates if the bean is a EJB 3.1 Singleton
*
* @return True if the bean is a singleton, false otherwise
*/
public boolean isSingleton();
/**
* Indicates if the EJB is stateful
*
* @return True if the bean is stateful, false otherwise
*/
public boolean isStateful();
/**
* Indicates if the EJB is and MDB
*
* @return True if the bean is an MDB, false otherwise
*/
public boolean isMessageDriven();
/**
* Gets the EJB name
*
* @return The name
*/
public String getEjbName();
}
Il EjbDescriptor è abbastanza auto-esplicatorio e dovrebbe restituire i metadati rilevanti definiti nella specifica EJB. In aggiunta a queste due interfacce, vi è BusinessInterfaceDescriptor a rappresentare un'interfaccia locale di business (che incapsula la classe d'interfaccia ed il nome jndi usato per la ricerca di una istanza EJB).
Web Beans RI può essere istruita a caricare la propria implementazione di EjbDiscovery usando la proprietà org.jboss.webbeans.bootstrap.spi.EjbDiscovery con il nome della classe pienamente qualificato (fully qualified) come valore. Per esempio:
org.jboss.webbeans.bootstrap.spi.EjbDiscovery=org.jboss.webbeans.integration.jbossas.EjbDiscoveryImpl
Se Web Beans RI viene usato in un servlet container, si aspetta un costruttore della forma:
public EjbDiscoveryImpl(ServletContext servletContext) {}Il contesto del servlet può essere usato per consentire all'implementazione di EjbDiscovery di interagire con il container.
Web Beans RI implementa la ricerca e l'associazione JNDI secondo gli standard, ma può capitare di dover modificare la ricerca e l'associazione (per esempio in un ambiente dove JNDI non è disponibile). Per fare questo occorre implementare org.jboss.webbeans.spi.resources.NamingContext:
public interface NamingContext extends Serializable {
/**
* Typed JNDI lookup
*
* @param <T
> The type
* @param name The JNDI name
* @param expectedType The expected type
* @return The object
*/
public <T
> T lookup(String name, Class<? extends T
> expectedType);
/**
* Binds an item to JNDI
*
* @param name The key to bind under
* @param value The item to bind
*/
public void bind(String name, Object value);
}
e dire a RI di usarlo:
org.jboss.webbeans.resources.spi.NamingContext=com.acme.MyNamingContext
Se Web Beans RI viene usato in un servlet container, si aspetta un costruttore della forma:
public MyNamingContext(ServletContext servletContext) {}Il contesto del servlet può essere usato per consentire all'implementazione di NamingContext di interagire con il container.
Web Beans RI deve caricare le classi e le risorse dal classpath in vari momenti. Di default vengono caricati dallo stesso classloader usato per caricare RI, comunque questo potrebbe non essere corretto in alcuni ambienti. Se è questo il caso si può implementare org.jboss.webbeans.spi.ResourceLoader:
public interface ResourceLoader {
/**
* Creates a class from a given FQCN
*
* @param name The name of the clsas
* @return The class
*/
public Class<?> classForName(String name);
/**
* Gets a resource as a URL by name
*
* @param name The name of the resource
* @return An URL to the resource
*/
public URL getResource(String name);
/**
* Gets resources as URLs by name
*
* @param name The name of the resource
* @return An iterable reference to the URLS
*/
public Iterable<URL
> getResources(String name);
}
e dire a RI di usarlo:
org.jboss.webbeans.resources.spi.ResourceLoader=com.acme.ResourceLoader
Se Web Beans RI viene usato in un servlet container, si aspetta un costruttore della forma:
public MyResourceLoader(ServletContext servletContext) {}Il contesto del servlet può essere usato per consentire all'implementazione di ResourceLoader di interagire con il container.
Per il corretto funzionamento al di fuori dell'implementazione delle API, ci sono un numero di requisiti che Web Beans RI pone nel container.
Se si integra Web Beans in un ambiente che supporta il deploy di applicazioni, occorre abilitare, automaticamente o attraverso la configurazione utente, l'isolamento del classloader per ogni applicazione Web Beans.
Se si integra Web Beans in un ambiente Servlet occorre registrare org.jboss.webbeans.servlet.WebBeansListener come Servlet listener, o automaticamente, o attraverso una configurazione utente, per ciascuna applicazione Web Beans che usa Servlet.
Se si integra Web Beans in un ambiente EJB occorre registrare org.jboss.webbeans.ejb.SessionBeanInterceptor come interceptor EJB per ogni EJB dell'applicazione, o automaticamente o attraverso una configurazione utente, per ciascuna applicazione Web Beans che utilizza bean enterprise.
webbeans-ri.jar Se si integra Web Beans in un ambiente che supporta il deploy di applicazioni, occorre inserire webbeans-ri.jar nel classloader isolato delle applicazioni. Non può essere caricato da un classloader condiviso.