People who downloaded this DZone Refcard also liked:

Seam UI

By Jacob Orshalick

ABOUT Seam UI

Seam is a next generation web framework that integrates standard Java EE technologies with a wide variety of nonstandard technologies into a consistent, unified, programming model. Seam drove the development of Web Beans (JSR-299) and continues to develop innovations that are changing the face of web development as well as Java EE technologies. If you haven't taken a look at Seam, I suggest you do.

As you develop Seam applications, you'll find this reference a handy guide for understanding how Seam simplifies JSF development. This reference does not cover all of what Seam provides, but covers the most commonly used UI annotations and XML elements as of Seam 2.1.

Simplifying jsf

While Seam is no longer limited to JSF as it's view layer, one of the framework's initial goals was simplifying JSF development. Seam plugs into the JSF lifecycle to provide a number of enhancements including:

• Direct Facelets support (https://facelets.dev.java.net/)
• n A unified component model
• n Additional contexts including conversations
• n Bean validations
• n A component event model
• n Exception handling
• n RESTful URLs
• n Extended EL support
• n And much more...

Page Navigation

Page navigation with JSF can be verbose and only provides a limited feature set. Seam provides a concise navigation language that incorporates conversation management, security, exception handling, request parameters, event notification, and more. Here we will discuss the pages namespace which defines the navigation flow of a Seam application as well as the navigation namespace for configuring the navigation components.

The Pages Namespace

Schema URI

http://jboss.com/products/seam/pages

Schema XSD

http://jboss.com/products/seam/pages-2.1.xsd

The pages namespace is used to define the WEB-INF/pages. xml definition. The pages.xml file unifies navigation logic

Page Navigation, continued

with Seam "orchestration” logic. This logic includes page parameters, conversation management, and allows navigation to be based on evaluation of arbitrary EL expressions instead of relying on return values. In addition, event notification is possible, generic exception handling, security restrictions, etc.

Seam XML Diagram Key

The Seam XML diagrams use the following notations to indicate required elements, cardinality, and containment:

Pages Namespace Elements

Page Navigation, continued

Pages Namespace Examples

Defining Navigation Rules

The following example defines a few pages with some simple navigation rules based on the execution of EL expressions:

<pages xmlns=”http://jboss.com/progucts/seam/pages”
   xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
   xsi:schemaLocation=
     "http://jboss.com/products/seam/pages
      http://jboss.com/products/seam/pages-2.1.xsd”
   no-conversation-view-id=”/main.xhtml”
   login-view-id=”/home.xhtml”>
  ... ...
  <page view-id=”/main.xhtml” login-required=”true”>
   <navigation from-action=
         "#{hotelBooking.selectHotel(hotel.id)}”>
      <begin-conversation />
      <redirect view-id=”/hotel.xhtml”/>
   </navigation>
  ... ...
  </page>
  <page view-id=”/rewards.xhtml”>
     <restrict>#{s:hasRole(‘REWARDS')}
  </page>
  ... ...
  <exception class=
       "org.jboss.seam.security.AuthorizationException”>
   <end-conversation/>
   <redirect view-id=”/generalError.xhtml”>
     <message>You are not authorized</message>
   </redirect>
  </exception>
  ... ...
</pages>

When a hotel is selected on the /main.xhtml view and the selectHotel method is invoked, we begin a long-running conversation and the user is redirected to the /hotelxhtml view. A user is required to be logged in to access /main. xhtml. If the user is not logged in, he or she will be redirected

to the login-view-id, or /home.xhtml in this case. The /rewards.xhtml page is further restricted to users with the REWARDS role. The s:hasRole EL function throws an

Page Navigation, continued

AuthorizationException if the user is not authorized thereby ending the conversation and sending the user to the error page with an appropriate message.

Using Page Parameters and Natural Conversations
The following example defines a natural conversation named Booking. The parameter-name and parameter-value define the parameter that will be using to uniquely identify a conversation instance. You must ensure that the EL expression evaluates to a value when the conversation is initialized.

<pages xmlns=”http://jboss.com/products/seam/pages”
  xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
  xsi:schemaLocation=
    "http://jboss.com/products/seam/pages
     http://jboss.com/products/seam/pages-2.1xsd”
  no-conversation-view-id=”/main.xhtml”
  login-view-id=”/home.xhtml”>
  ... ...
 <conversation name=”Booking” parameter-name=”hotelId”
    parameter-value=”#{hotel.hotelId}” />
 <page view-id=”/hotel.xhtml” conversation=”Booking”
    login-required=”true”>
  <param name=”hotelId” value=”#{hotelBooking.hotelId}” />
  <begin-conversation join=”true” />
  ... ...
    </page>
  <page view-id=”/book.xhtml” conversation=”Booking”
    conversation-required=”true” login-required=”true”>
  ... ...
  </page>
  <page view-id=”/confirm.xhtml” conversation=”Booking”
    conversation-required=”true” login-required=”true”>
  ... ...
 </page>
</pages>

Each of the pages defined participate in the natural conversation by specifying Booking as the conversation attribute. The /hotel.xhtml page begins the natural conversation by loading the current hotel according to the value of the hotelId param. This param is initialized from a request query parameter: http://seam-booking-example/ hotel.seam?hotelId=10. The hotelBooking action then uses this parameter value to initialize the hotel in the conversation context through an @Factory method.

Note that all pages other than /hotel.xhtml specify conversation-required=”true”. This ensures that should a user attempt to access one of these pages outside the context of a long-runningconversation, the user will be redirected to the no-conversation-view-id defined in the <pages> tag.

Navigation Namespace

Schema URI

http://jboss.com/products/seam/navigation

Schema XSD

http://jboss.com/products/seam/navigation-2.1.xsd

The navigation namespace provides the ability to externalize configuration of the Pages component from the pages.xml file and override the location of pages configuration files.

Navigation Namespace Diagram

Page Navigation, continued

Navigation Namespace Elements

Navigation Namespace Example

Below is an example of <navigation:pages> definition:

<components
  xmlns=”http://jboss.com/products/seam/components”
  xmlns:navigation=
    "http://jboss.com/products/seam/navigation”
  xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
  xsi:schemaLocation=
    "http://jboss.com/products/seam/navigation
     http://jboss.com/products/seam/navigation-2.1.xsd
     http://jboss.com/products/seam/components
	 http://jboss.com/products/seam/components-2.1.xsd”>
  <navigation:pages http-port=”8080” https-port=”8443”
   no-conversation-view-id=”/main.xhtml”
   login-view-id=”/home.xhtml” />
  ... ...
</components>

The ports have now been defined for both HTTP and HTTPS. In addition, if a page has been configured as conversationrequired=” true”, the user will be redirected to /main.xhtml if a long-running conversation is not in progress. The loginview- id specifies that the user should be redirected to /home. xhtml if a login is required by a page definition and the user has not yet logged in.

JSF component annotations

The definition of components found in a typical JSF application is simple when using Seam. Data models, converters, and validators can be defined quickly with no XML configuration required through use of component annotations.

Datamodel Annotations

The following annotations simplify display of a clickable <h:dataTable> in JSF backed by a DataModel by directly binding a Collection to action attributes.

Conversion and Validation Annotations

The following annotations allow you to quickly define Seam components as custom JSF converters and validators

Jsf Component tags

An extended JSF tag library is defined by Seam to provide control over conversational navigation, simplified dropdowns, bean validation, and component formatting.

Integrating the Seam Taglib

Taglib URI

http://jboss.com/products/seam/taglib

Taglib Declaration

Controlling Navigation

Seam provides a set of JSF components for controlling conversation propagation across both GET and POST requests. These components also extend the capabilities of JSF to allow GET requests to trigger actions and make it simple to define default page actions.

Navigation Tags

Navigation Examples

The conversation propagation can be controlled from a link through use of the component. For instance, if you click on the following link, Seam leaves the current conversation when the main.xhtml page is loaded, just as a regular HTTP GET request would do.

We can also trigger an action during an HTTP GET request:

<s:link view-id=”/hotel.xhtml”
   action=”#{hotelBooking.selectHotel(hotel.id)}”
   value=”Select Hotel” /><

The <s:link> component has richer conversation-management capabilities than the plain JSF <commandbutton>, which simply propagates the conversation context between pages.

JSF Component Tags, continued

What if you want to exit, begin, or end a conversation context from a button click? The following example shows a button that exits the current conversation context.

<h:commandButton action=”main”value=”Back to Main”>
   <s:conversationPropagation type=”none”/>
   <s:defaultAction />
</h:commandButton>

In addition, by specifying the button is the <s:defaultAction/> the user is returned to /main.xhtml through a navigation rule should the user submit the form by pressing the enter key.

Dropdown Selection

When developing JSF pages it is commonly required to associate the possible selections of a dropdown component with a list of objects or an enumeration of values. Unfortunately with standard JSF this requires quite a bit of glue code to achieve. Seam makes this simple through the <s:selectItems> and <s:enumItem> tags. Even further when the<s:convertEntity> and the <s:selectItems> tags are combined, you can directly associate JPA or Hibernate managed entities by simply binding a dropdown component to an entity association attribute.

Dropdown Tags

Dropdown Examples

The following example demonstrates directly associating a managed entity from a List of entities. The CreditCard class represents types of credit cards and the @NamedQuery allows us to load all CreditCard types from the data store.

@Entity
@NamedQuery(name=”loadCreditCardTypes”,
   query=”select c from CreditCard as c " +
     "order by c.description”)
public class CreditCard implements Serializable {
   @Id
   private Long id;
   private String description;
 // ... ...
}

JSF Component Tags, continued

The Booking class is then be defined with a @ManyToOne reference to the CreditCard entity.

			@Entity
public class Booking implements Serializable {
   // ... ...
   @ManyToOne
   @JoinColumn(name=”CC_ID”)
   private CreditCard creditCard;
   public CreditCard getCreditCard() {
     return creditCard;
   }
   public void setCreditCard(CreditCard creditCard) {
     this.creditCard = creditCard;
   }
   // ... ...
}

In order to load the list of credit card types, the Booking Action can define an @Factory method which initializes the list of CreditCard entities in the conversation context.

@Name("bookingAction”)
@Scope(CONVERSATION)
public class BookingAction implements Serializable {
   // ... ...
   @In private EntityManager entityManager;
   @Factory("creditCardTypes”)
   public List<CreditCard> loadCreditCardTypes() {
     return entityManager
      .createNamedQuery("loadCreditCardTypes”)
      .getResultList();
   }
   // ... ...
}

The method simply uses the named query we defined previously to load the entities from the current Entity- Manager instance. Note that our Seam-managed Persistence Context (SMPC) is named entityManager. If your SMPC is named something other than entityManager, you will have to configure the EntityConverter in components.xml (see the UI Namespace).

Finally, we can define a JSF<h:selectOneMenu> component which simply binds directly to the creditCard attribute of the current booking instance.

<h:selectOneMenu id=”creditCard”
    value=”#{booking.creditCard}” required=”true”>
  <s:selectItems noSelectionLabel=””
    var=”type” value=”#{creditCardTypes}”
    itemLabel=”#{type.description}” />
  <s:convertEntity />
</h:selectOneMenu>

The #{creditCardTypes} are loaded into the conversation context from the @Factory method we defined previously. The <s:selectItems> component allows us to iterate over the list of CreditCard entities and display the description by referencing the type variable. The <s:convertEntity> tag ensures that the user selection is converted to an entity for association with the booking instance.

Simplifying Validation

When using Seam you can define validations directly on your entity beans that behave like JSF validators. These bean validators are provided by the Hibernate Validator framework

JSF Component Tags, continued

(http://validatior.hibernate.org), but with Seam can be triggered as JSF validations.

Validation Tags

Validation Examples

The Seam Booking example allows a user to enter her credit card number while booking a hotel. Credit card numbers have a common pattern and should be validated on input. The following example demonstrates how we can apply these restrictions using Hibernate Validator annotations:

@Entity
public class Booking {
   ... ...
   @Length(min=16, max=16,
     message=”Credit card number must be 16 digits long”)
   @Pattern(regex=”\\d*”,
     message=”Credit card number must be numeric”)
   private String creditCardNumber;
   public Booking() {}
... ...

The @Length annotation restricts the String length to 16 characters while the @Pattern annotation specifies a regular expression restricting the String to digits only. Once these annotations are added to the entity, we can trigger them as validations during the JSF validations phase. Simply embedding the <s:validate> tag within the <h:inputText> component ensures the validation is triggered. If an invalid credit card number is input, the user will be presented with the message defined in the annotation.

<div class=”entry”>
  <div class=”label”>
   	Credit Card #:
  </div>
  <div class=”input”>
    <h:inputText id=”creditCard”
       value=”#{booking.creditCardNumber}”>
     <s:validate />
  </h:inputText>
  <s:message id=”message”
     styleClass=”error errors” />
  </div>
</div>

Formatting

While validation becomes simple with Seam, standard JSF validation messages are not very flexible. Although you can

JSF Component Tags, continued

assign CSS classes to customize the look of the error message itself, you cannot alter the appearance of the input field that contains the invalid input. The following formatting tags allow you to decorate invalid fields with styles and messages. In addition to validation message formatting Seam provides formatting components for applying labels directly to JSF input fields, optionally rendering HTML <div> and <span> tags, and optionally rendering page fragments.

Formatting Examples

To use a Seam decorator, you first define how the decorator behaves using special named JSF facets. The beforeInvalidField facet defines what to display in front of the invalid field; the afterInvalidField facet defines what to display after the invalid field, and the <s:message> tag shows the error message for the input field; and the aroundInvalidField facet defines a span or div element that encloses the invalid field and the error message. You also can use the aroundField facet to decorate the appearance of valid (or initial) input fields.

Formatting Examples

To use a Seam decorator, you first define how the decorator behaves using special named JSF facets. The beforeInvalidField facet defines what to display in front of the invalid field; the afterInvalidField facet defines what to display after the invalid field, and the <s:message> tag shows the error message for the input field; and the aroundInvalidField facet defines a span or div element that encloses the invalid field and the error message. You also can use the aroundField facet to decorate the appearance of valid (or initial) input fields.

<f:facet name=”beforeInvalidField”>
   <h:graphicImage styleClass=”errorImg”value=”error.png”/>
</f:facet>
<f:facet name=”afterInvalidField”>
   <s:message/>
</f:facet>
<f:facet name=”aroundInvalidField”>
   <s:span styleClass=”error”/>
</f:facet>

Now you can simply enclose each input field in a pair of <s:decorate> tags as shown below:

<s:validateAll>
	... ...
	<s:decorate>
	  <h:inputText value=”#{booking.creditCardNumber}”/>
	</s:decorate>
	... ...
</s:validateAll>

The UI Namespace

Schema URI

http://jboss.com/products/seam/ui

Schema XSD

http://jboss.com/products/seam/ui-2.1.xsd

As you have seen, the <s:convertEntity/> tag provides the ability to convert entities to and from dropdown selections. In most cases this is as simple as defining <s:convertEntity> within the dropdown, but there are cases where this needs to be customized. The UI namespace allows you to configure

JSF Component Tags, continued

the EntityConverter component in the following cases:

JPA is the persistence provider and your Seam-Managed Persistence Context (SMPC) is named something other than EntityManager Hibernate is being used directly as the persistence provider You would like to use more than one EntityManager with the EntityConverter

In each of these cases, it is necessary to configure the Entity-Converter component using the UI namespace.

UI Namespace Diagram

UI Namespace Elements

JSF Component Tags, continued

UI Namespace Examples

The following example configures the EntityConverter with a custom EntityManager name:

<components xmlns=
    ”http://jboss.com/products/seam/components”
  xmlns:persistence=
    "http://jboss.com/products/seam/persistence”
  xmlns:ui=”http://jboss.com/products/seam/ui”
  xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
  xsi:schemaLocation=
   "http://jboss.com/products/seam/persistence
	http://jboss.com/products/seam/persistence-2.1.xsd
	http://jboss.com/products/seam/ui
	http://jboss.com/products/seam/ui-2.1.xsd
	http://jboss.com/products/seam/components
	http://jboss.com/products/seam/components-2.1.xsd”>
  <persistence:managed-persistence-context name=”em”
    auto-create=”true”persistence-unit-jndi-name=
     "java:/EMFactories/bookingEntityManagerFactory”/>
  <ui:jpa-entity-loader entity-manager=”#{em}” />
  ... ...
</components>

As you can see, the Seam-managed Persistence Context is given the name em. This is simply referenced through an EL expression in the jpa-entity-loader configuration.

About The Author

Jacob Orshalick

Jacob Orshalick is an independent software consultant, open source enthusiast, and the owner of Focus IT Solutions, an independent software consulting firm. He has a Masters degree in Software Engineering from The University of Texas at Dallas and has eight years of development experience in the retail, financial, and telecommunications industries. You can also find Jacob writing about Seam in his blog.

Blog: http://solutionsfit.com/blog/

Projects: Committer to Seam Framework

Recommended Book

The Seam Framework has simplified Java enterprise Web development forthousands of developers and significantly influenced the broader Java Enterprise Edition platform. Now, the authors of the leading guide to Seam development have systematically updated it to reflect the major improvements and new features introduced with Seam 2.x. The book also introduces Web Beans (JSR-299), the future core of Seam that will transform Java EE Web development.

---

BUY NOW

books.dzone.com/books/seam-framework

People who downloaded this DZone Refcard also liked:

Core Seam

By Jacob Orshalick

About SEAM

Seam is a next generation web framework that integrates standard Java EE technologies with a wide variety of nonstandard technologies into a consistent, unified, programming model. Seam drove the development of the Web Beans specification (JSR-299) and continues to develop innovations that are changing the face of web development as well as Java EE technologies. If you haven't taken a look at Seam, I suggest you do.

a handy guide for understanding core concepts, configuration, and tool usage. This quick reference is not intended to cover all of what Seam provides, but will cover the most commonly used annotations and XML elements as of Seam 2.1. In addition, this guide will point you to examples distributed with Seam to see real examples of how the configuration options can be used in practice.

Dependency Injection In A Nutshell

Dependency injection is an inversion of control technique that forms the core of modern-day frameworks. Traditionally objects have held the responsibility for obtaining references to the objects they collaborate with. These objects are extroverted as they reach out to get their dependencies. This leads to tight coupling and hard to test code.

Dependency injection allows us to create introverted objects. The objects dependencies are injected by a container or by some external object (e.g. a test class). Bijection is described by the following formula:

dependency injection + context = bijection

With bijection, when dependencies are injected context counts! Dependencies are injected prior to each component method invocation. In addition, components can contribute to the context by outjecting values

As you can see the HotelBookingAction is scoped to and executes within a context. This behavior allows us to quit worrying about shuffling values into and out of contexts like the HttpSession, allows components to hold state, and unifies the component model across application tiers.

Contextual Components

When a method is invoked on a component, its dependencies are injected from the current context. Seam performs a context lookup in the following order of precedence: Event Scope, Page Scope, Conversation Scope, Session Scope, Business Scope, Application Scope.

Component Annotations

Component Definition Annotations

In order for your Seam components to take advantage of bijection, you must register them with the Seam container. Registering your component with Seam is as simple as annotating it with @Name. The following annotations will register your component and define its lifecycle.

Component Bijection Annotations: Once you have defined a component, you can specify the dependencies of your component and what the component contributes back to the context.

Component Lifecycle Annotations: The following annotations allow you to control the lifecycle of a component either by reacting to events or wrapping the component entirely.

Component Events Annotations: Through Seam's event model, components can raise events or listen for events raised by other components through simple annotation. In addition, Seam defines a number of built-in events that the application can use to perform special kinds of framework integration (see http://seamframework.org/Documentation, Contextual Events).

The Components Namespace

Schema URI

http://jboss.com/products/seam/components

Schema XSD

http://jboss.com/products/seam/components-2.1.xsd

So far we've seen how components can be declared using annotations. In most cases this is the preferred approach, but there are some situations when component definition through annotations is not an option:

• when a class from a library outside of your control is to be exposed as a component
• when the same class is being configured as multiple components

In addition, you may want to configure values into a component that could change by environment, e.g. ip-addresses, ports, etc. In any of these cases, we can use XML to configure the component through the components namespace.

Seam XML Diagram Key

The Seam XML diagrams use the following notations to indicate required elements, cardinality, and containment:

Components Namespace Diagram

Components Namespace Elements

Component Element Attributes: The attributes of the component element are synonymous with component definition through annotations.

<?xml version="1.0" encoding="UTF-8"?>
<components
xmlns="http://jboss.com/products/seam/components"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation=
"http://jboss.com/products/seam/components
http://jboss.com/products/seam/components-2.1.xsd">
	<component name="hotelBooking">
		<property name="paymentService">
		#{paymentService}
		</property>
	</component>
	<component name="paymentService" scope="APPLICATION"
	class="com.othercompany.PaymentServiceClient">
		<property name="ipAddress">127.0.0.1
		<property name="port">9998
	</component>
</components>

@Namespace(value="http://solutionsfit.com/example/booking")
package com.solutionsfit.example.booking;
import org.jboss.seam.annotations.Namespace;

<components xmlns=
	"http://jboss.com/products/seam/components"
	xmlns:payment="http://solutionsfit.com/example/booking">
	... ...
	<payment:hotel-booking
		payment-service="#{paymentService}">

Rapid Application Development

Seam-gen is a rapid application generator shipped with the Seam distribution. With a few command line commands, seam-gen generates an array of artifacts for Seam projects to help you get started. In particular, seam-gen is useful for the following.

• Automatically generate an empty Seam project with common configuration files, a build script, and directories for Java code and JSF view pages.
• Automatically generate complete Eclipse and NetBeans project files for the Seam project.
• Reverse-engineer entity bean objects from relational database tables.
• Generate template files for common Seam components.

Seam-gen Commands

Seam-gen command should be executed in the directory of your Seam distribution. To get started execute the seam setup command. Each command provides useful prompts that will guide you through the configuration specifics.

Seam-gen Source Directories

The source directories created by seam-gen are each dedicated to holding certain types of source files. This enables seam-gen to determine what tests need to be executed as well as selectively hot-deploy your Seam components.

Seam-gen Profiles

Seam-gen supports the concept of "profile". The idea is that the application probably needs different settings (e.g. database settings, etc) in the development, test, and production phases. So, the project provides alternative configuration files for each of the three scenarios. In the resources directory, you will find the following configuration files:

Conversation Management

The Conversation Model in a Nutshell

The conversation model is the core of Seam. It provides the basis of context management in Seam applications. A session holds potentially many concurrent conversations with a user, each tied to its own unit of work with its own context.

On every user request a temporary conversation is created or a long-running conversation is resumed. A conversation is resumed when a valid conversation-id (cid) is sent with the request.

* Note that the filled circle indicates the initial state, while the hollow circle containing a smaller filled circle indicates an end state.

Conversation Management Annotations

These annotations provide declarative conversation management through Seam components.

Conversation Management Usage

Some example usage patterns for conversation propagation.

@Begin
public void selectHotel(Hotel selectedHotel)
{
	hotel = em.merge(selectedHotel);
}

@End(beforeRedirect="true")
	public void confirm()
	{
		em.persist(booking);
		...

@In private EntityManager em;
@Begin(flushMode=FlushModeType.MANUAL)
public void editBooking(int selectedId)
{
	booking = em.find(Booking.class, selectedId);
}

<page view-id="/hotel.xhtml"
	login-required="true">
	<description>
	View hotel: #{hotel.name}
	</description>
	<begin-conversation join="true">

<s:link view-id="/main.xhtml" value="Return to main"
	propagation="none" />

Seam Distribution Conversation Management Examples

The following examples are distributed with Seam and provide great resources for configuring your application.

Common Application Configuration

The Core Namespace

Schema URI

http://jboss.com/products/seam/core

Schema XSD

http://jboss.com/products/seam/core-2.1.xsd

The core namespace includes support for configuration of Seam components found in org.jboss.seam.core. This includes the JNDI pattern used to lookup EJB components, debug mode settings, conversation management, inclusion of custom resource bundles, and POJO cache settings.

Core Namespace Diagram

Core Namespace Elements

<?xml version="1.0" encoding="UTF-8"?>
<components
	xmlns="http://jboss.com/products/seam/components"
	xmlns:core="http://jboss.com/products/seam/core"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation=
		"http://jboss.com/products/seam/core
		http://jboss.com/products/seam/core-2.1.xsd
		http://jboss.com/products/seam/components
		http://jboss.com/products/seam/components-2.1.xsd">
	<core:init jndi-pattern="@jndiPattern@" debug="@debug@"/>
	
	<core:manager conversation-timeout="600000"
			conversation-id-parameter="cid"
			default-flush-mode="MANUAL" />

Note the use of the default-flush-mode setting. If you are using a Seam-managed Persistence Context (SMPC), which will be discussed shortly, this setting will save constant repetition of the flush-mode setting when beginning conversations.

The Transaction Namespace

Transaction Namespace URI

http://jboss.com/products/seam/transaction

Transaction Namespace XSD

http://jboss.com/products/seam/transaction-2.1.xsd

Transactions are an essential feature for database-driven web applications. In each conversation, we typically need to update multiple database tables. If an error occurs in the database operation (e.g. a database server crashes), the application needs to inform the user, and all the updates this conversation has written into the database must be rolled back to avoid partially updated records. In other words, all database updates in the conversation must happen inside an atomic operation. Seam-managed transactions along with Seam-managed persistence enables you to do just that.

Transaction Namespace Diagram

<components
	xmlns="http://jboss.com/products/seam/components"
	xmlns:persistence=
	"http://jboss.com/products/seam/persistence"
	xmlns:transaction=
	"http://jboss.com/products/seam/transaction"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation=
		"http://jboss.com/products/seam/persistence
		http://jboss.com/products/seam/persistence-2.1.xsd
		http://jboss.com/products/seam/transaction
		http://jboss.com/products/seam/transaction-2.1.xsd
		http://jboss.com/products/seam/components
		http://jboss.com/products/seam/components-2.1.xsd">
			
	<persistence:managed-persistence-context name="em"
		auto-create="true" persistence-unit-jndi-name=
			"java:/EMFactories/bookingEntityManagerFactory"/>
	<transaction:ejb-transaction/>
... ...

Note that this indicates the application is being deployed to a JEE 5 environment.

The Persistence Namespace

Persistence Namespace URI

http://jboss.com/products/seam/persistence

Persistence Namespace XSD

http://jboss.com/products/seam/persistence-2.1.xsd

When JPA is used within an EJB environment, an extended persistence context can be associated with a stateful session bean. An extended persistence context lives between requests and is scoped to the stateful component allowing entities to remain managed. The EJB3 approach has several shortcomings:

• What if my application does not operate in an EJB environment?
• It can be tricky to ensure that the persistence context is shared between loosely coupled components.
• EJB3 does not include the concept of manual flushing.

A Seam-managed persistence context (or SMPC) is available for use in both environments and alleviates these issues altogether. An SMPC is just a built-in Seam component that manages an instance of EntityManager or Hibernate Session in the conversation context. You can inject it with @In.

Note that many of the options for configuring a HibernateSessionFactory have been omitted due to space constraints. For more options on configuring your HibernateSessionFactory, see the Seam Reference Documentation (http://seamframework.org/Documentation).

Persistence Namespace Diagram

Persistence Namespace Elements

<components
	xmlns="http://jboss.com/products/seam/components"
	xmlns:persistence=
	"http://jboss.com/products/seam/persistence"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation=
		"http://jboss.com/products/seam/persistence
		http://jboss.com/products/seam/persistence-2.1.xsd
		http://jboss.com/products/seam/components
		http://jboss.com/products/seam/components-2.1.xsd">
	<persistence:managed-persistence-context name="em"
		auto-create="true" persistence-unit-jndi-name=
			"java:/EMFactories/bookingEntityManagerFactory"/>
... ...
</components>

@In EntityManager em;

<property name="jboss.entity.manager.factory.jndi.name"
	value="java:/EMFactories/bookingEntityManagerFactory"/>

Seam Distribution Persistence Configuration Examples

The following examples are distributed with Seam and provide great resources for configuring your application.

Seam Security

Security is arguably one of the most important aspects of application development. Unfortunately due to its complexity security is often an afterthought which can lead to gaping holes in an application for malicious users to take advantage of. Fortunately, when using Seam this complexity is hidden making it simple to ensure that your next application is secure.

Seam security provides extensive configuration options making it useful in a wide array of implementations but also making it worthy of its own reference card. The basics of Seam security will be covered here which will address most use-cases and will allow you to get up-and-running quickly.

The Security Namespace

Security Namespace URI

http://jboss.com/products/seam/security

Security Namespace XSD

http://jboss.com/products/seam/security-2.1.xsd

The security namespace provides the hooks necessary to customize Seam security to fit your application needs whether you intend to use LDAP, a relational database, or any other custom authentication/authorization scheme.

Security Namespace Elements

Security Namespace Diagram

<components
	xmlns="http://jboss.com/products/seam/components"
	xmlns:drools="http://jboss.com/products/seam/drools"
	xmlns:security="http://jboss.com/products/seam/security"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation=
		"http://jboss.com/products/seam/security
		http://jboss.com/products/seam/security-2.1.xsd
		http://jboss.com/products/seam/drools
		http://jboss.com/products/seam/drools-2.0.xsd
		http://jboss.com/products/seam/components
		http://jboss.com/products/seam/components-2.1.xsd">
<security:jpa-identity-store
user-class="org.jboss.seam.example.booking.MemberAccount"
role-class="org.jboss.seam.example.booking.MemberRole" />
... ...

Securing your Application

Seam makes it easy to declare access constraints on web pages, UI components, and Java methods via tags, annotations, and JSF Expression Language (EL) expressions. Through this declarative approach Seam provides you with the ability to easily achieve a layered approach to security.

Security Annotations

Security Expression Language (EL) Functions

These functions provide convenience for invoking role or permission checks through Expression Language (EL). This can be useful in your Facelets pages, in pages.xml, or in using the @Restrict annotation to provide security restrictions.

Seam Distribution Security Examples

The following examples are distributed with Seam and provide great resources for configuring your application.

APPLICATION FRAMEWORK

The Seam CRUD application framework essentially provides prepackaged Data Access Objects (DAOs). DAOs are highly repetitive as the DAOs for each entity class are largely the same. They are ideal for code reuse. Seam provides an application framework with built-in generic DAO components. You can develop simple CRUD web applications in Seam without writing a single line of Java "business logic" code.

The Framework Namespace

Framework Namespace URI

http://jboss.com/products/seam/framework

Framework Namespace XSD

http://jboss.com/products/seam/framework-2.1.xsd

The framework namespace configures components found in the org.jboss.seam.framework package.

Framework Namespace Diagram

Framework Namespace Elements

<?xml version="1.0" encoding="UTF-8"?>
<components xmlns=
	"http://jboss.com/products/seam/components"
	xmlns:persistence=
	"http://jboss.com/products/seam/persistence"
	xmlns:framework="http://jboss.com/products/seam/framework"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation=
	"http://jboss.com/product s/seam/framework
	http://jboss.com/products/seam/framework-2.1.xsd
	http://jboss.com/products/seam/components
	http://jboss.com/products/seam/components-2.1.xsd">
... ...
<persistence:managed-persistence-context name="em"
	auto-create="true"persistence-unit-jndi-name=
		"java:/EMFactories/bookingEntityManagerFactory"/>
<factory name="hotel"
	value="#{hotelHome.instance}"
	scope="stateless"
	auto-create="true"/>
<framework:entity-home name="hotelHome"
	entity-class="com.jboss.seam.booking.Hotel"
	scope="conversation" entity-manager="#{em}"
	auto-create="true">
	<framework:id>#{hotelId}</framework:id>
</framework:entity-home>
... ...

Seam Distribution Framework Examples

The following examples are distributed with Seam and provide great resources for configuring your application.

About The Author

Jacob Orshalick

Jacob Orshalick is an independent software consultant, open source enthusiast, and the owner of Focus IT Solutions, an independent software consulting firm. He has a Masters degree in Software Engineering from The University of Texas at Dallas and has eight years of development experience in the retail, financial, and telecommunications industries. You can also find Jacob writing about Seam in his blog.

Publications

• Seam Framework: Experience the Evolution of Java EE

Blog

http://solutionsfit.com/blog/

Projects

Committer to Seam Framework

Recommended Book

The Seam Framework has simplified Java enterprise Web development for thousands of developers and significantly influenced the broader Java Enterprise Edition platform. Now, the authors of the leading guide to Seam development have systematically updated it to reflect the major improvements and new features introduced with Seam 2.x. The book also introduces Web Beans (JSR-299), the future core of Seam that will transform Java EE Web development.

---

BUY NOW

books.dzone.com/books/seam-framework