Seam provides a method for configuring JSR-299 beans using alternate metadata sources, such as XML configuration. (Currently, the XML provider is the only alternative available, though others are planned). Using a "type-safe" XML syntax, it's possible to add new beans, override existing beans, and add extra configuration to existing beans.

         <dependency>

            <groupId>org.jboss.seam.config</groupId>

            <artifactId>seam-config-xml</artifactId>

            <version>${seam.config.version}</version>

            <scope>runtime</scope>

         </dependency>



         <dependency>

            <groupId>org.jboss.seam.solder</groupId>

            <artifactId>seam-solder</artifactId>

            <version>${weld.extensions.version}</version>

         </dependency>

      

class Report {

    String filename;

    

    @Inject

    Datasource datasource;

    

    //getters and setters

}

interface Datasource {

    public Data getData();

}


@SalesQualifier

class SalesDatasource implements Datasource {

  public Data getData()

  {

    //return sales data

  }

}


class BillingDatasource implements Datasource {

  public Data getData()

  {

    //return billing data

  }

}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://java.sun.com/xml/ns/javaee"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:s="urn:java:ee" 
       xmlns:r="urn:java:org.example.reports">

 	<r:Report>  
 		<s:modifies/>
 		<r:filename>sales.jrxml<r:filename>
 		<r:datasource>
 			<r:SalesQualifier/>
 		</r:datasource>
  	</r:Report>
  	
 	<r:Report filename="billing.jrxml">
 		<s:replaces/>
 		<r:datasource>
 			<s:Inject/>
 			<s:Exact>org.example.reports.BillingDatasource</s:Exact>
 		</r:datasource>
  	</r:Report>  	
</beans>
    
         

mvn jetty:run

Seam provides extensive support for the two most popular persistence architectures for Java: Hibernate3, and the Java Persistence API introduced with EJB 3.0. Seam's unique state-management architecture allows the most sophisticated ORM integration of any web application framework.

<dependency>

  <groupId>org.jboss.seam.persistence</groupId>

  <artifactId>seam-persistence-api</artifactId>

  <version>${seam.persistence.version}</version>

</dependency>



<dependency>

  <groupId>org.jboss.seam.persistence</groupId>

  <artifactId>seam-persistence-impl</artifactId>

  <version>${seam.persistence.version}</version>

</dependency>



<dependency>

  <groupId>org.jboss.seam.solder</groupId>

  <artifactId>seam-solder</artifactId>

  <version>${seam.solder.version}</version>

</dependency>



<dependency>

  <groupId>org.jboss.seam.config</groupId>

  <artifactId>seam-config-xml</artifactId>

  <version>${seam.config.version}</version>

</dependency>  

<dependency>

  <groupId>org.hibernate</groupId>

  <artifactId>hibernate-core</artifactId>

  <version>3.5.1-Final</version>

</dependency>

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://java.sun.com/xml/ns/javaee"

   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

   xsi:schemaLocation="

      http://java.sun.com/xml/ns/javaee 

      http://docs.jboss.org/cdi/beans_1_0.xsd">

   <interceptors>

      <class>org.jboss.seam.persistence.transaction.TransactionInterceptor</class>

   </interceptors>

</beans>

<beans xmlns="http://java.sun.com/xml/ns/javaee"

   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

   xmlns:s="urn:java:ee" 

   xmlns:t="urn:java:org.jboss.seam.persistence.transaction"

   xsi:schemaLocation="

      http://java.sun.com/xml/ns/javaee 

      http://docs.jboss.org/cdi/beans_1_0.xsd">



      <t:SeSynchronizations>

         <s:modifies/>

      </t:SeSynchronizations>



      <t:EntityTransaction>

         <s:modifies />         

      </t:EntityTransaction>

      

</beans>

<t:SeSynchronizations>

  <s:modifies/>

</t:SeSynchronizations>

<t:EntityTransaction>

   <s:modifies />         

</t:EntityTransaction>

@TransactionAttribute /*Defaults to TransactionAttributeType.REQUIRED */

class TransactionaBean

{


   /* This is a transactional method, when this method is called a transaction

    * will be started if one does not already exist.

    * This behavior is inherited from the @TransactionAttribute annotation on

    * the class.

    */

    void doWork()

    {

      ...

    }

    

    /* A transaction will not be started for this method, however it      */

    /* will not complain if there is an existing transaction active.      */

    @TransactionAttributeType(TransactionAttributeType.SUPPORTED)

    void doMoreWork()

    {

      ...

    }

    

    /* This method will throw an exception if there is no transaction active when */

    /* it is invoked.                                                             */

     

    @TransactionAttributeType(TransactionAttributeType.MANDATORY)

    void doEvenMoreWork()

    {

      ...

    }  

    

    /* This method will throw an exception if there is a transaction active when */

    /* it is invoked.                                                            */

    @TransactionAttributeType(TransactionAttributeType.NOT_SUPPORTED)

    void doOtherWork()

    {

      ...

    }

}         

@SeamManaged
@Produces
@PersistenceUnit
@ConversationScoped
EntityManagerFactory producerField;
         

@Inject EntityManager entityManager;

@Inject EntityManager em; //a Seam-managed persistence context

   

   @Begin(flushMode=MANUAL)

   public void beginClaimWizard() {

       claim = em.find(Claim.class, claimId);

   }

public void addPartyToClaim() {

       Party party = ....;

       claim.addParty(party);

   }

@End

   public void commitClaim() {

       em.flush();

   }

<begin-conversation flush-mode="MANUAL" />

<components xmlns="http://jboss.com/products/seam/components"
            xmlns:core="http://jboss.com/products/seam/core">
            <core:manager conversation-timeout="120000" default-flush-mode="manual" />
         </components>

User user = em.createQuery("from User where username=#{user.username}")

   .getSingleResult();

User user = em.createQuery("from User where username=:username")

   .setParameter("username", user.getUsername())

   .getSingleResult();

User user = em.createQuery("from User where username=" + user.getUsername()) //BAD!

   .getSingleResult();

public void setupEntityManager(@Observes SeamManagedPersistenceContextCreated event) {

   Session session = (Session)event.getEntityManager().getDelegate();

   session.enableFilter("myfilter");     

}

To use the Seam Servlet module, you need to put the API and implementation JARs on the classpath of your web application. Most of the features of Seam Servlet are enabled automatically when it's added to the classpath. Some extra configuration, covered below, is required if you are not using a Servlet 3-compliant container.

<dependency>

   <groupId>org.jboss.seam.servlet</groupId>

   <artifactId>seam-servlet</artifactId>

   <version>${seam.servlet.version}</version>

</dependency>

<dependency>

   <groupId>org.jboss.seam.servlet</groupId>

   <artifactId>seam-servlet-api</artifactId>

   <version>${seam.servlet.version}</version>

   <scope>compile</scope>

</dependency>



<dependency>

   <groupId>org.jboss.seam.servlet</groupId>

   <artifactId>seam-servlet-impl</artifactId>

   <version>${seam.servlet.version}</version>

   <scope>runtime</scope>

</dependency>

<dependency>

   <groupId>org.jboss.logging</groupId>

   <artifactId>jboss-logging</artifactId>

   <version>3.0.0.Beta4</version>

   <scope>compile</scope>

</dependency>

<listener>

   <listener-class>org.jboss.seam.servlet.event.ServletEventBridgeListener</listener-class>

</listener>



<servlet>

   <servlet-name>Servlet Event Bridge Servlet</servlet-name>

   <servlet-class>org.jboss.seam.servlet.event.ServletEventBridgeServlet</servlet-class>

</servlet>



<filter>

   <filter-name>Servlet Event Bridge Filter</filter-name>

   <filter-class>org.jboss.seam.servlet.event.ServletEventBridgeFilter</filter-class>

</filter>



<filter-mapping>

   <filter-name>Servlet Event Bridge Filter</filter-name>

   <url-pattern>/*</url-pattern>

</filter-mapping>



<filter>

   <filter-name>Catch Exception Filter</filter-name>

   <filter-class>org.jboss.seam.servlet.CatchExceptionFilter</filter-class>

</filter>



<filter-mapping>

   <filter-name>Catch Exception Filter</filter-name>

   <url-pattern>/*</url-pattern>

</filter-mapping>

You're now ready to dive into the Servlet enhancements provided for you by the Seam Servlet module!

By including the Seam Servlet module in your web application (and performing the necessary listener configuration for pre-Servlet 3.0 environments), the servlet lifecycle events will be propagated to the CDI event bus so you can observe them using observer methods on CDI beans. Seam Servlet also fires additional lifecycle events not offered by the Servlet API, such as when the response is initialized and destroyed.

public void observeServletContext(@Observes ServletContext ctx) {

   System.out.println(ctx.getServletContextName() + " initialized or destroyed");

}

public void observeServletContextInitialized(@Observes @Initialized ServletContext ctx) {

   System.out.println(ctx.getServletContextName() + " initialized");

}

@Stateless

@Development

public class SeedDataImporter {

   @PersistenceContext

   private EntityManager em;


   public void loadData(@Observes @Initialized ServletContext ctx) {

      em.persist(new Product(1, "Black Hole", 100.0));

   }

}

public void loadData(@Observes @Initialized WebApplication webapp) {

   System.out.println(webapp.getName() + " initialized at " + new Date(webapp.getStartTime()));

}

public void onStartup(@Observes @Started WebApplication webapp) {

   System.out.println("Application at " + webapp.getContextPath() + " ready to handle requests");

}

public void onShutdown(@Observes @Destroyed WebApplication webapp) {

   System.out.println("Application at " + webapp.getContextPath() + " no longer handling requests");

}

public void observeRequest(@Observes ServletRequest request) {

   // Do something with the servlet "request" object

}

public void observeRequestInitialized(@Observes @Initialized ServletRequest request) {

   // Do something with the servlet "request" object upon initialization

}

public void observeRequestInitialized(@Observes @Initialized HttpServletRequest request) {

   // Do something with the HTTP servlet "request" object upon initialization

}

public void observeRequestInitialized(@Observes @Initialized @Path("offer") HttpServletRequest request) {

   // Do something with the HTTP servlet "request" object upon initialization

   // only when servlet path /offer is requested

}

public void observeResponse(@Observes ServletResponse response) {

   // Do something with the servlet "response" object

}

public void observeResponseInitialized(@Observes @Initialized ServletResponse response) {

   // Do something with the servlet "response" object upon initialization

}

public void observeResponseInitialized(@Observes @Initialized HttpServletResponse response) {

   // Do something with the HTTP servlet "response" object upon initialization

}

public void setupEncoding(@Observes @Initialized ServletResponse res, ServletRequest req) throws Exception {

   if (this.override || req.getCharacterEncoding() == null) {

      req.setCharacterEncoding(encoding);

      if (override) {

         res.setCharacterEncoding(encoding);

      }

   }

}

public void setupEncoding(@Observes @Initialized ServletRequestContext ctx) throws Exception {

   if (this.override || ctx.getRequest().getCharacterEncoding() == null) {

      ctx.getRequest().setCharacterEncoding(encoding);

      if (override) {

         ctx.getResponse().setCharacterEncoding(encoding);

      }

   }

}

public void redirectToStartPage(@Observes @Path("") @Initialized HttpServletRequestContext ctx)

      throws Exception {

   String startPage = ctx.getResponse().encodeRedirectURL(ctx.getContextPath() + "/start.jsf");

   ctx.getResponse().sendRedirect(startPage);

}

public void observeSession(@Observes HttpSession session) {

   // Do something with the "session" object

}

public void observeSessionInitialized(@Observes @Initialized HttpSession session) {

   // Do something with the "session" object upon being initialized

}

public void observeSession(@Observes HttpSession session) {

   // Do something with the "session" object

}

public void observeSessionCreated(@Observes @WillPassivate HttpSession session) {

   // Do something with the "session" object when it's being passivated

}

Seam Servlet provides producers that expose a wide-range of information available in a Servlet environment (e.g., implicit objects such as ServletContext and HttpSession and state such as HTTP request parameters) as beans. You access this information by injecting the beans produced. This chapter documents the Servlet objects and request state that Seam Servlet exposes and how to inject them.

@Inject @RequestParam("id")

private String bookId;

@Inject @RequestParam

private String id;

@Inject @RequestParam @DefaultValue("25")

private String pageSize;

@Inject @RequestParam("id")

private Instance<String> bookIdResolver;

...

String bookId = bookIdResolver.get();

@Inject @HeaderParam("User-Agent")

private String userAgent;

@Inject @HeaderParam("User-Agent")

private Instance<String> userAgentResolver;

...

String userAgent = userAgentResolver.get();

@Inject

private ServletContext context;

@Inject

private ServletRequest request;

@Inject

private HttpServletRequest httpRequest;

@Inject

private ServletResponse reponse;

@Inject

private HttpServletResponse httpResponse;

@Inject

private HttpSession session;

@Inject

private HttpSessionStatus sessionStatus;

if (!sessionStatus.isActive()) {

   System.out.println("Session does not exist. Creating it now.");

   HttpSession session = sessionStatus.get();

   assert session.isNew();

}

@Inject @ContextPath

private String contextPath;

@Inject @ContextPath

private Instance<String> contextPathProvider;

...

String contextPath = contextPathProvider.get();

@Inject

private List<Cookie> cookies;

@Inject @CookieParam

private String username;

@Inject @CookieParam

private Cookie username;

@Inject @CookieParam("username")

private Instance<String> usernameResolver;

...

String username = usernameResolver.get();

@Inject @ServerInfo

private String serverInfo;

@Inject

private Principal principal;

Seam Catch provides a simple, yet robust foundation for modules and/or applications to establish a customized exception handling process. Seam Servlet ties into the exception handling model by forwarding all unhandled Servlet exceptions to Catch so that they can be handled in a centralized, extensible and uniform manner.

@HandlesExceptions

public class ExceptionHandlers {

   void handleAll(@Handles CaughtException<Throwable> caught, HttpServletResponse response) {

      response.sendError(500, "You've been caught by Catch!"); 

   }

}

@HandlesExceptions

public class ExceptionHandlers {

   void handleAll(@Handles @WebRequest

         CaughtException<Throwable> caught, HttpServletResponse response) {

      response.sendError(500, "You've been caught by Catch!"); 

   }

}

void handleAccountNotFound(@Handles @WebRequest

      CaughtException<AccountNotFound> caught, HttpServletResponse response) {

   response.sendError(404, "Account not found: " + caught.getException().getAccountId()); 

}

Typically, the BeanManager is obtained using some form of injection. However, there are scenarios where the code being executed is outside of a managed bean environment and you need a way in. In these cases, it's necessary to lookup the BeanManager from a well-known location.

The standard mechanism for locating the BeanManager from outside a managed bean environment, as defined by the JSR-299 specification, is to look it up in JNDI. However, JNDI isn't the most convenient technology to depend on when you consider all popular deployment environments (think Tomcat and Jetty).

As a simpler alternative, Seam Servlet binds the BeanManager to the following servlet context attribute (whose name is equivalent to the fully-qualified class name of the BeanManager interface:

javax.enterprise.inject.spi.BeanManager

Seam Servlet also includes a provider that retrieves the BeanManager from this location. Anytime the Seam Servlet module needs a reference to the BeanManager, it uses this lookup mechanism to ensure that the module works consistently across deployment environments, especially in Servlet containers.

You can retrieve the BeanManager in the same way. If you want to hide the lookup, you can extend the BeanManagerAware class and retrieve the BeanManager from the the method getBeanManager(), as shown here:

public class NonManagedClass extends BeanManagerAware {

   public void fireEvent() {

      getBeanManager().fireEvent("Send me to a managed bean");

   }

}

   

Alternatively, you can retrieve the BeanManager from the method getBeanManager() on the BeanManagerLocator class, as shown here:

public class NonManagedClass {

   public void fireEvent() {

      new BeanManagerLocator().getBeanManager().fireEvent("Send me to a managed bean");

   }

}

   

Under the covers, these classes look for the BeanManager in the servlet context attribute covered in this section, amongst other available strategies. Refer to the BeanManager provider chapter of the Seam Solder reference guide for information on how to leverage the servlet context attribute provider to access the BeanManager from outside the CDI environment.

To use the Seam Faces module, you need to put the API and implementation JARs on the classpath of your web application. Most of the features of Seam Faces are enabled automatically when it's added to the classpath. Some extra configuration, covered below, is required if you are not using a Servlet 3-compliant container.

<dependency>

   <groupId>org.jboss.seam.faces</groupId>

   <artifactId>seam-faces</artifactId>

   <version>${seam.faces.version}</version>

</dependency>

<dependency>

   <groupId>org.jboss.seam.faces</groupId>

   <artifactId>seam-faces-api</artifactId>

   <version>${seam.faces.version}</version>

   <scope>compile</scope>

</dependency>



<dependency>

   <groupId>org.jboss.seam.faces</groupId>

   <artifactId>seam-faces-impl</artifactId>

   <version>${seam.faces.version}</version>

   <scope>runtime</scope>

</dependency>

<listener>

   <listener-class>org.jboss.seam.faces.beanManager.BeanManagerServletContextListener</listener-class>

</listener>

You're now ready to dive into the JSF enhancements provided for you by the Seam Faces module!

When the seam-faces module is installed in a web application, JSF events will automatically be propagated via the CDI event-bridge, enabling managed beans to easily observe all Faces events.

There are two categories of events: JSF phase events, and JSF system events. Phase events are triggered as JSF processes each lifecycle phase, while system events are raised at more specific, fine-grained events during request processing.

public void observeAll(@Observes PhaseEvent e)

{

    // Do something with the event object

} 

public void observeBefore(@Observes @Before PhaseEvent e)

{

    // Do something with the "before" event object

}


public void observeAfter(@Observes @After PhaseEvent e)

{

    // Do something with the "after" event object

} 

public void observeRenderResponse(@Observes @RenderResponse PhaseEvent e)

{

    // Do something with the "render response" event object

} 

public void observeBeforeRenderResponse(@Observes @Before @RenderResponse PhaseEvent e)

{

    // Do something with the "before render response" event object

} 

public void observesThisEvent(@Observes ExceptionQueuedEvent e)

{

    // Do something with the event object

} 

public void observePrePasswordValidation(@Observes @Component("form:password") PreValidateEvent e)

{

// Do something with the "before password is validated" event object

} 

public void observeApplicationConstructed(@Observes PostConstructApplicationEvent e)

{

// Do something with the "after application is constructed" event object

} 

JSF 2.0 introduced the concept of the Flash object and the @ViewScope; however, JSF 2.0 did not provide annotations accessing the Flash, and CDI does not support the non-standard ViewScope by default. The Seam Faces module does both, in addition to adding a new @RenderScoped context. Beans stored in the Render Scope will survive until the next page is rendered. For the most part, beans stored in the ViewScope will survive as long as a user remains on the same page, and data in the JSF 2 Flash will survive as long as the flash survives).

@RenderScoped

public class Bean {

    // ...

}

public class Bean {

   @Inject private Flash flash;

   // ...

}

@ViewScoped

public class Bean {

    // ...

}

While JSF already has the concept of adding FacesMessage objects to the FacesContext in order for those messages to be displayed to the user when the view is rendered, Seam Faces takes this concept one step farther with the Messages API provided by the Seam International module. Messages are template-based, and can be added directly via the code, or templates can be loaded from resource bundles using a BundleKey.

@Named

public class Example

{

   @Inject

   Messages messages;


   public String action()

   {

      messages.info("This is an {0} message, and will be displayed to {1}.", "INFO", "the user");

      return null;

   }

}

public String action()

{

   messages.warn(new BundleKey("org.jboss.seam.faces.exampleBundle", "messageKey"), "unique");

   return null;

}

messageKey=This {0} parameter is not so {0}, see?