In an Web or Enterprise Application perspective, you need a webserver as a first entry point since all the requests have to be originated from a single place. Say, your login page to the application. But processing the login operation may not be the job of a Web Server and it would be done by a Web Application.

As such, a Web Server is preferred to serve any static files, which is not changing in nature for any type of requests. Whereas, you need a Web application to produce a dynamic response according to the type of inputs you provide along with your request.

The XML DOM defines a standard way for accessing and manipulating XML documents.

The DOM presents an XML document as a tree-structure.

Knowing the XML DOM is a must for anyone working with XML.

SAX

Simple API for XML (SAX)

for the events-based parsing of XML documents

Difference

SAX parsers operate on each piece of the XML document sequentially while the DOM operates on the document as a whole.

The quantity of memory that a SAX parser must use in order to function is typically much smaller than that of a DOM parser.

DOM parsers must have the entire tree in memory before any processing can begin, so the amount of memory used by a DOM parser depends entirely on the size of the input data. The memory footprint of a SAX parser, by contrast, is based only on the maximum depth of the XML file (the maximum depth of the XML tree) and the maximum data stored in XML attributes on a single XML element

JDOM

The JDOM is open source Java API for manipulating XML files within Java Program.

it allow writing Java programs that can read, manipulate and output XML data

The JDOM API is faster than DOM API and it simplifies the interaction with the XML.

JDOM’s provide XPath support.

StAX 

goal of the StAX API is to give “parsing control to the programmer by exposing a simple iterator based API

Namespace

When a namespace is defined for an element, all child elements with the same prefix are associated with the same namespace.

Defining a default namespace for an element saves us from using prefixes in all the child elements. It has the following syntax:

<root
xmlns:h=”http://www.w3.org/TR/html4/”
xmlns:f=”http://www.w3schools.com/furniture”>

<h:table>
<h:tr>
<h:td>Apples</h:td>
<h:td>Bananas</h:td>
</h:tr>
</h:table>

<f:table>
<f:name>African Coffee Table</f:name>
<f:width>80</f:width>
<f:length>120</f:length>
</f:table>

</root>

CDATA

All text in an XML document will be parsed by the parser.

But text inside a CDATA section will be ignored by the parser.

service contract

= data contract + operational contract

data contract will define the messages going in and out of the service.

operational contract will define the operations that our service will perform.

WSDL file contains both:-

1) contains an embedded xsd file that defines data contract.

2) The rest of he WSDL file defines the opeartional contract,including one or more <wsdl:operation> elements within the <wsdl:binding> element

XPath

is used for identifying or extracting parts of an XML structure.

You could say that XPath is to XML what SQL is to relation database.

It is not work that kills men, it is worry. Work is healthy; you can hardly put more on a man than he can bear. But worry is rust upon the blade. It is not movement that destroys the machinery, but friction. ~ Henry Ward Beecher

Converts the interface of the class to another one that client expects.

eg: Converting a Turkey into a Duck.

we wrap Turkey into a TurkeyAdapter and send the adapter to the client.

Client has a Target Interface,

Adapter implements Target Interface and has a Adaptee.

Two types of adapter:-

1. object adapter

2. class adapter

1. Object Adapter:- is what we read so far.

2. Class Adapter:- Require multiple inheritance by sub-classing both target and adaptee.

Difference between Object and Class Adapter:-

Object Adapter, based on composition, can adapt the adaptee or any of its sub class.

Class Adapter, can override behavior

Real world adapter example:-

Adapting an Enumeration to an Iterator.

Bridge Pattern

Use Bridge Pattern to vary not only your implementations, but your abstractions.

example:- Universal remote and controller and various TV implementation.

Both TV remote and TV implementation.

Decorator Pattern
Inheritance: behavior is set statically at compile time.
All sub class inherit the same behavior.
Composition: dynamically composing objects, we can add functionality in the new code, rather than altering existing code.

Design Principal: Classes should be open for extension but closed for modification.

Definition: Decorator pattern attaches additional responsibility to an object dynamically. It provides a flexible alternative to sub classing for extending the functionality.

Component is the base class, eg Beverage
Concrete component & Decorator, both extends Component, eg. Expresso & CondimentDecorator (for type matching, not for inheriting behavior.
We acquire behavior by composing objects together.
With composition, we can mix and match behavior as we want.)
Decorator also has a Component eg. Condiment also has a Beverage.
Concerete Decorators extend Decorator, eg. Milk & Soya extend Condiment.

Similar objects doing similar operations, abstract class Beverage, abstract method cost(), requirement is to call cost method on some object in hierarchy dynamically is a candidate for such pattern

Requirement:
Write code as per abstract component, writing to concrete will brake decorator.

Cost in implementing decorator:
Many small classes
Following type is necessary
Increase code complexity that factory pattern can help to reduce.

Adapter is used to match with the client requirement for an adaptee, while facade is used to simplify the interface

The facade pattern provide a unified interface to a set of interfaces. It defines a higher level of interface that make the subsystem easy to use.

Design principle : principle of least knowledge, talk only to your immediate friends.

Flyweight: one single instance of a class can be used to provide many virtual instances, in this way you are able to flw away the memory weight of creation of multiple instance

Its Approach is to collect the state of many object and rather centralize the state at one location and form virtual objects out of one object.

It is used when class has many state and can be controlled identically.
Single logical instance of a class can not behave independently from other

Example : large tree plantation project

Proxy pattern provides a surrogate or placeholder for another object to control access to.

Another object, which may be remote, expensive to create or in the need of securing.

Both RealSubject and the Proxy implement Subject interface.
This allows any client to treat the proxy just like the real subject.

Proxy keep the reference to the real object, so it can forward the requests to the subject when necessary. it also often instantiate or handles the creation of the realsubject
Realsubject is usually the object the does most of the work.

Composite pattern: allows to compose objects into tree structure to represent part-whole hierarchies.
It let client treat individual & composition of objects uniformly.
We can apply same operations over both composite & individual object.

Eg: menu & sub menu

Client has a component, which is extended by leaf & composite. Composite contains component ( recursive )

A. Servlets dint have a main() method. They are under control of another Java application called a “Container”.

Example of a Container is Tomcat.

Example of a web server is Apache.

Container provides:-

1. Communication Support: provide easy way for servlet to talk to your web server.

2. Lifecycle Management: of servlet

3. Multithreading support: a new java thread is create to handle each servlet request.

4. Declarative security: via xml configuration.

5. JSP Support: converting JSP to real java code.

Q. Explain Life-cycle of a servlet

A.1 Container Load class

2. Instantiate Servlet (Invoke its default constructor)

2.A Load ServletConfig

2.B Load ServletContext

3. Call init() -> which may contain, getting a DB Connection.

4. service(), which eventually generate a thread to process each request and subsequently call doGet() & doPost()

5. destroy()

!Note

When you have multiple parameter values for a single parameter, you need getPatameterValues() that returns an array instead of getParameter()

Q. Beside parameter, what can I get from request object?

A. request.getHeader(“User-Agent”); -> Get request header

request.getCookies();

request.getSession();

request.getMethod();

request.getInputStream(); -> get all raw request information.

Q. Important method to call on response

A. setContentType()

getWriter()

getOutputStream()

Q. Difference between forward and sendRedirect

A.1 forward (page 89)

• Control can be forward to resources available within the server from where the call is made. This transfer of control is done by the container internally and browser / client is not involved.
• The original request and response objects are transfered along with additional parameters if needed.

RequestDispatcher view = request.getRequestDispatcher(“result.jsp”);

view.forward(request, response);

A.2 sendRedirect (page 136)

if (workforme)

{

//hadel request

}else {

response.sendRedirect(“http://www.oreilly.com”);

}

Control can be redirect to resources to different servers or domains. This transfer of control task is delegated to the browser by the container. That is, the redirect sends a header back to the browser / client. This header contains the resource url to be redirected by the browser. Then the browser initiates a new request to the given url. Since it is a new request, the old request and response object is lost.

For example, sendRedirect can transfer control from http://javapapers.com to http://anydomain.com but forward cannot do this.

‘session’ is not lost in both forward and redirect.

To feel the difference between forward and sendRedirect visually see the address bar of your browser,
in forward, you will not see the forwarded address (since the browser is not involved)
in redirect, you can see the redirected address.

You can call sendRedirect() after response is already written. ->IlligalStateException.

Attributes are not parameters!
3 Attribute types:-
1. Application/context
2. Request
3. Session

1. Application/context
getServletContext().set/getAttribute(“”,”");
They are not thread safe. to make it thread safe, we need to lock servletContext as below:-
Synchronized (getServletContext()) {}

2. Session
requirest.getSession().get/setAttribute(“”,”");
Multiple request from same session, say multiple browser window
Lock on session
Synchronized (session){}

Implementing SingleThreadModel interface is also not a solution , it is as good as synchronizing service method.
Also result in poor performance.

3. Request
Only request attribute and local variable are thread safe
Use when some other component of the app take over all or part of the request via
RequestDispatcher.
By two of its method forward() & include() ()
Get RD from request or servletContext(/ is must, root of application, not relative to current request)

Session
If http uses state less connection so how container keep track of the user session ?
On first request , container generate a unique session Id to send with the response & client keep sending it for each subsequent request.
This happen via cookie maintained by the container.
What if client has cookies disabled on his browser ?
URL re-writing happen automatically if cookies not supported, we only need to call response.encodeUrl()
Invalidate the session if not active

Now! JSP

Page directives:-
@
scriptlet
%%
expression
=
s and e land up in service method

Declaration
!
Added to class outside of the service method, it can be variable declaration or method.

Implicit objects :-
out JspWriter
session HttpSession
request HttpServletRequest
response HttpServletResponse
config ServletConfig
application ServletContext
exception JspException
pageContext PageContext
page Object

Comments
HTML !
Jsp %%

Static members:-

• Certain member should only belong to class, and not be part of any object created from the class.
• Static member is initialized when a class is loaded at run time.

Access Specifiers:-
Modifier    | Class | Package | Subclass | World

public      |  Y    |    Y    |    Y     |   Y

protected   |  Y    |    Y    |    Y     |   N

no modifier |  Y    |    Y    |    N     |   N

private     |  Y    |    N    |    N     |   N

A. The collection framework presents a set of standard utility classes for manging group of objects.

Arbitrary objects can be stored, retrieved and manipulated as elements of collection.

Q. Which package has collection framework ?

this framework is provided in java.util package

Q. What is Mathamatical concept of a set?

A. A set is just a group of unique items, meaning that the group contains no duplicates.

Some real-world examples of sets include the following:

• The set of uppercase letters ‘A’ through ‘Z’
• The set of nonnegative integers {0, 1, 2 …}

• The Collection interface is a group of objects, with duplicates allowed
• Set extends Collection but forbids duplicates
• List extends Collection also, allows duplicates and introduces positional indexing (order of element is retained)
• Map extends neither Set nor Collection

The following table shows the six collection implementations introduced with the Java 2 framework

Interface	Implementation				Historical
Set(.) no duplicate(.)at most one null	HashSet(.) No OrderHashing: Constant time for add, remove, contain, size Key->Hashcode->Index (.) no guaranty of order		TreeSet(.) Sorted Assenting (.) Use tree for storage (.) large data, sorted order, found quickly Comparator	LinkedHashSet(.) Insertion Order
List(.)allow duplicate(.)Positional indexing(.) Insertion Order		ArrayList(.)notSynchronized(.)Random Access (.)Easy Tail manipulation (.)default size 0.		LinkedList(.)Sequential Access(.)Add Remove Element in between	Vector Stack(.)synchronized, make it slow(.) default size 10Then double
Map(.)Unique Key	HashMap(.)Allow Null as key & value(.)unsynchronized(.)no order (.) get/put constant time for larger map		TreeMap(.) Sorted in Key order(.)Natural ordering Comparator	LinkeHashMap(.) Key insertion order.	Hashtable Properties(.)synchronized(.)can only store object the override hashCode() and equals() Sting does.

Collection Interface

The Collection interface is used to represent any group of objects, or elements. You use the interface when you wish to work with a group of elements in as general a manner as possible.

Iterator Interface

Q. What is the difference between HashSet & TreeSet

A. HashSet is not sorted while TreeSet is.

1) HashSet: For efficiency, objects added to a HashSet need to implement the hashCode() method in a manner that properly distributes the hash codes. While most system classes override the default hashCode() implementation in Object, when creating your own classes to add to a HashSet remember to override hashCode()

2) TreeSet: The TreeSet implementation is useful when you need to extract elements from a collection in a sorted manner. In order to work property, elements added to a TreeSet must be sortable.

public class SetExample {
  public static void main(String args[]) {
    Set set = new HashSet();
    set.add("Bernadine");
    set.add("Elizabeth");
    set.add("Gene");
    set.add("Elizabeth");
    set.add("Clara");
    System.out.println(set);
    Set sortedSet = new TreeSet(set);
    System.out.println(sortedSet);
  }
}
Running the program produces the following output. Notice that the duplicate entry is only present once, and the second list output is sorted.
[Gene, Clara, Bernadine, Elizabeth]
[Bernadine, Clara, Elizabeth, Gene]

They can be differentiated on two basis:-

1) The nature of lock:-

Synchronized method of an object is synchronized on the lock of the object or class (static synchronized method) of the method, while

Synchronized block allows execution of arbitrary code to be synchronized on the lock of an arbitrary object.

2)  Granularity of lock:-

Synchronization Block mechanism allows fine-grained synchronization, while

Synchronized method are to be used when a method can manipulate the state of the object in ways that can corrupt the state if executed concurrently.

Q. What are Locks ?

A. Lock is used to synchronize access to shared resources

A thread gain access to a shared resource by first acquiring the lock associated with the resource

A lock thus implements mutual exclusion

All objects have a lock, only one thread at a time can access the shared resource guarded by the lock.

Q. Number of ways access of the resource can be synchronized ?

There are two ways in which access of the resource can be syncronized

a. Synchronized method

b. Synchronized block

a. Synchronized method:-

A thread wish to execute synchronized method must first obtain the OBJECTS LOCK before it can enter the object to execute the method.

In other words, Synchronized method of an object is synchronized on the lock of the object

Q. How is lock of the object achieved ?

A. This is simply achieved Lock is by calling the method,  if the object’s lock is acquired by some other thread, the calling thread waits.

Q. When to Use synchronized method ?

Synchronized method are to be used when a method can manipulate the state of the object in ways that can corrupt the state if executed concurrently.

Example:- Stack Push & Pop methods. When one thread is pushing other thread can not pop.

When one thread is executing the synchronized method of an object, all other threads that wish to execute this or any other sync. method have to wait.

This does not applies to thread that already has the lock, such a method can call other sync. method without being blocked.

Important Note:-

Q. How Static method are synchronized ?

Static method synchronize on the class lock.

Also, synchronization of static method in a class is independent from the synchronization of instance method of the class.

Q. A synchronized method, when overridden in sub class, what happens to its synchronized quality ?

A sub class decides whether the  new definition of an inherited synchronized method will remain synchronized in the subclass.

b. Synchronized block

Synchronized block allows execution of arbitrary code to be synchronized on the lock of an arbitrary object.

synchronized (<object reference expression>) {<Code block>}

“object reference expression” must evaluate to a non null reference value, else a null pointer exception is thrown

The code block is usually related to the object on which synchronization is done.

example:- synchronized (this) {}

Once the thread had entered the code block, no other thread will be able to execute the code block, or any other code requiring the same object lock.

This mechanism allows fine-grained synchronization of code on arbitrary object.

Q. Synchronization Block, are all part of the sytex mandatory?

“synchronized (<object reference expression>) {<Code block>}” 

Object specification & {} are mandatory even if we have a single line of code.

Q. An inner object might need to synchronize on its associated outer object, how is it achievable ?

class Outer{

private double myPi;

protected class inner{

public void setPi(){

synchronized void setPi(Outer.this){

myPi = Math.PI;

}

}

}

}

Q. Can Synchronized block be specified on class lock ?

Yes, by:-

synchronized (<class name>.class) {<code block>}

A static synchronized method of class A is equivalent to

static void classAction(){

synchronized (A.class)  {

…

}

}

Q. In how many ways a thread can hold a lock on an object ? 

1) By executing a member synchronized method, object lock.

2) By executing a static  synchronized method, class lock.

3) By executing a synchronized block, lock on an object or class.

System is a built-in class present in java.lang package.
This class has a final modifier, which means that, it cannot be inherited by other classes.
It contains pre-defined methods and fields, which provides facilities like standard input, output, etc.

out is a static final field (ie, variable)in System class which is of the type PrintStream (a built-in class, contains methods to print the different data values).
static fields and methods must be accessed by using the class name, so ( System.out ).

out here denotes the reference variable of the type PrintStream class.

println() is a public method in PrintStream class to print the data values.
Hence to access a method in PrintStream class, we use out.println() (as non static methods and fields can only be accessed by using the refrence varialble)

System.out.println();

eg:

int i = 3;
System.out.println(i);

the above code prints the value of 3 in the screen and brings the control to the next line.

 
Demo Program:-
class SystemTester
{
	public static void main(String[] args)
	{
		int i = 3;
		System.out.println(i);
		System.out.println(System.currentTimeMillis());
		//Return the current time in terms of milliseconds.
		System.out.println(System.getProperty("user.dir"));
	}
}

Output:-
E:\Java\Examples>java SystemTester
3
1306662087283
E:\Java\Examples

The best thing to start programming in seam is by going through the examples bundled with the seam distribution from http://labs.jboss.com/jbossseam/download/index.html, any thing else to start of will be second best for sure, I tried two books but non could give me a jump start like the start given by the seam examples.

Here I would also like to give you some comments about the two books I have gon through so that I could support you in making a choice of book for learning ahead after this post.

1) Apress.Beginning.JBoss.Seam.Feb.2007

Is a beginners book and assume that you have very little knowledge of EJBs and starts from scratch. the book clearly shows how easy and fast it is to program in JBoss Seam by comparing the way we program in struts with jboss for the same problem at hand.

2) Prentice.Hall.JBoss.Seam.Simplicity.and.Power.Beyond.Java.EE.Apr.2007

this book is not a beginners book but an intermediate one, the book is a comprehensive guide on Seam.

Let’s start Learning

Here we will cover one of the seam example application to understand how easy it is to develop application in JBoss Seam, various features of JBoss seam has been covered in my previous post titled “Features of JBoss Seam”.

Here we will also cover the way we can run the same examples using eclipse IDE and use the examples as template for our custom application development.

before starting with the example, lets have a quick look where seam sits in an enterprise application.

Seam does the role of a Context Management and JSF serving as a Request Controller, while in the presentation tier we have the option to use any of the three, JSP, Facelets and Portal and similarly for the State Management we can use EJB3, JBossjBPM or Hibernate.

It turns out that the combination of Seam, JSF and EJB3 is the simplest way to write a complex web application in Java. You won’t believe how little code is required!

Before starting the example please follow the steps in my earlier post “Install and configure JBoss Seam” for performing the necessary setup for running JBoss Seam application.

“Registration Example”

The registration example is a fairly trivial application that lets a new user store his username, real name and password in the database. The example isn’t intended to show off all of the cool functionality of Seam. However, it demonstrates the use of an EJB3 session bean as a JSF action listener, and basic configuration of Seam.

Following is the registration screen of the application

Understanding the structure of application.

The application is implemented using two JSP pages, one entity bean and one stateless session bean.

Let’s take a look at the code, starting from the “bottom”.

The entity bean: User.java

This class serve two purposes

1) define persistence

2) and validation declaratively, via anotations

The code of this class is as follows, please find my comments with code as the explanation of the code with “->” mark

@Entity // -> indicates that the User class is an entity bean
@Name(“user”) // -> Seam components requre a component name provided by @Name anotations
@Scope(SESSION) // -> User bean is a session scope component.
@Table(name=”users”) // -> Persistence: User class is mapped to user table.
public class User implements Serializable {
private static final long serialVersionUID = 1881413500711441951L;
 // -> name, password and username are the persistent attributes of the entity bean
private String username; (5)
 private String password;
 private String name;
public User(String name, String password, String username) {
  this.name = name;
  this.password = password;
this.username = username;
 }
 public User() {} (6)
 // -> The @NotNull and @Lengthannotations are part of the Hibernate Validator framework
@NotNull @Length(min=5, max=15) (7)
public String getPassword() { return password; }
public void setPassword(String password) { this.password = password; }
@NotNull
public String getName() { return name; }
public void setName(String name) { this.name = name; }
// -> EJB standard @Id annotation indicates primary key attribute of entity bean.
@Id @NotNull @Length(min=5, max=15) (8)
public String getUsername() { return username; }
public void setUsername(String username) { this.username = username; }
}

Properties of our Userclass are bound to directly to JSF components and are populated by JSF during the update model values phase.

Now we will have a look at the state less session bean class RegisterAction.java which defines the action listner method.

RegisterAction.java

@Stateless // -> stateless session bean.@Name(“register”)public class RegisterAction implements Register{
  @In // -> marks an attribute injected by Seam, In this case, the attribute is injected
  // from a context variable named user private User user; @PersistenceContext // -> used to inject the EJB3 entity manager. private EntityManager em; @Logger // -> used to inject the component’s Log instance private Log log;public String register() (5)

1) The LogAPI lets us easily display templated log messages.

2) JSF action listener methods return a string-valued outcome that determines what page will be displayed next. A null outcome (or a void action listener method) redisplays the previous page. In plain JSF, it is normal to always use a JSF navigation ruleto determine the JSF view id from the outcome. For complex application this indirection is useful and a good practice. However, for very simple examples like this one, Seam lets you use the JSF view id as the outcome, eliminating the requirement for a navigation rule. Note that when you use a view id as an outcome, Seam always performs a browser redirect.

3) Seam provides a number of built-in components to help solve common problems.
The FacesMessagescomponent makes it easy to display templated error or success messages. Built-in Seam components may be obtained by injection, or by calling an instance() method.

The session bean local interface:

Register.java

@Local public interface Register { public String register(); }

That’s the end of the Java code.

Now we will cover some of the deployment descriptors as most of the deployment files have common code among various applications.

1) components.xml

<components xmlns=”http://jboss.com/products/seam/components”
  xmlns:core=”http://jboss.com/products/seam/core”>
  <core:init jndi-pattern=”@jndiPattern@”/>
</components>

This code configures a property named jndiPattern of a built-in Seam component named org.jboss.seam.core.init.

2) web.xml

This web.xmlfile configures Seam and MyFaces

3) faces-config.xml

The faces-config.xmlfile integrates Seam into JSF

In fact, once you have all the basic descriptors set up, the onlyXML you need to write as you add new functionality to a Seam application is the navigation rules, and possibly jBPM process definitions. Seam takes the view that process flow and configuration data are the only things that truly belong in XML.

In this simple example, we don’t even need a navigation rule, since we decided to embed the view id in our action code.

4) ejb-jar.xml

The ejb-jar.xml file integrates Seam with EJB3, by attaching the SeamInterceptor to all session beans in the archive.

5) persistence.xml

The persistence.xmlfile tells the EJB persistence provider where to find the datasource

The view files

1) register.jsp

<%@ taglib uri=”http://java.sun.com/jsf/html” prefix=”h” %>
<%@ taglib uri=”http://java.sun.com/jsf/core” prefix=”f” %>
<%@ taglib uri=”http://jboss.com/products/seam/taglib” prefix=”s” %>
<html>
 <head>
  <title>Register New User</title>
 </head>
 <body>
  <f:view>
  <h:form>
  <table border=”0″>
  <s:validateAll>
  <tr>
  <td>Username</td>
  <td><h:inputText value=”#{user.username}”/></td>
  </tr>
  <tr>
  <td>Real Name</td>
  <td><h:inputText value=”#{user.name}”/></td>
  </tr>
  <tr>
  <td>Password</td>
  <td><h:inputSecret value=”#{user.password}”/></td>
  </tr>
  </s:validateAll>
  </table>
  <h:messages/>
  <h:commandButton type=”submit” value=”Register” action=”#{register.register}”/>
  </h:form>
  </f:view>
 </body>
</html>

The only thing here that is specific to Seam is the <s:validateAll>tag. This JSF component tells JSF to validate all the contained input fields against the Hibernate Validator annotations specified on the entity bean.

2) registered.jsp

<%@ taglib uri=”http://java.sun.com/jsf/html” prefix=”h” %>
<%@ taglib uri=”http://java.sun.com/jsf/core” prefix=”f” %>
<html>
 <head>
  <title>Successfully Registered New User</title>
 </head>
 <body>
  <f:view>
  Welcome, <h:outputText value=”#{user.name}”/>,
  you are successfully registered as <h:outputText value=”#{user.username}”/>.
  </f:view>
 </body>
</html>

How it works

When the form is submitted, JSF asks Seam to resolve the variable named user. Since there is no value already bound to that name (in any Seam context), Seam instantiates the user component, and returns the resulting Userentity bean instance to JSF after storing it in the Seam session context.

The form input values are now validated against the Hibernate Validator constraints specified on the Userentity. If the constraints are violated, JSF redisplays the page. Otherwise, JSF binds the form input values to properties of the User entity bean.

Next, JSF asks Seam to resolve the variable named register. Seam finds the RegisterActionstateless session bean in the stateless context and returns it. JSF invokes the register() action listener method.

Seam intercepts the method call and injects the User entity from the Seam session context, before continuing the invocation.

The register()method checks if a user with the entered username already exists. If so, an error message is queued with the FacesMessages component, and a null outcome is returned, causing a page redisplay. The FacesMessagescomponent interpolates the JSF expression embedded in the message string and adds a JSF FacesMessage to the view.

If no user with that username exists, the "/registered.jsp" outcome triggers a browser redirect to the registered.jsppage. When JSF comes to render the page, it asks Seam to resolve the variable named user and uses property values of the returned User entity from Seam’s session scope.

To run the example from eclipse

Step 1) In eclipse create a new java project with existing source code and give the name of the project as “registration”, browse to pint the directory where the “registration” example source code is unziped, then click on finish.

Step 2) add

testng.jar
myfaces-all.jar
jsf-api.jar
jboss-seam.jar
jboss-ejb3-all.jar
jboss-4.2.1.GA.jar
hibernate-all.jar
ejb3-persistence.jar

to your classpath.

Step 3) Right click build.xml of the registration project and select Run As – > Ant Build

Step 4) (make sure you have jboss server add before doing this step)

Select the “registration project” tree node from the navigator window to select “Debug As” -> “Open Debug Dialog” -> “Debug” to start the server in debug mode.

Step 5) open the browser window and type http://localhost:8080/seam-registration to start the “registration application”.