These steps describe adding a very simplistic batch job and calling it from a Seam class. As a simple batch example, the database tables usually used by Spring batch will be held in memory and not persisted to a database.

The first step in the batch process is to upload a csv file and extract the list of people contained in it. The test file is: title,firstname,surname,dateOfBirth,country Mr,John,Smith,1949,United States Ms,Jane,Smith,03/09/1994,England Mr,David,Moore,13/04/1972,France Mr,Robert,Fisher,26/06/1946,Brazil

You need to add the following jar files to your ear file (in addition to the ones here.

spring/org.springframework.batch.core-2.0.0.RELEASE.jar
spring/org.springframework.batch.infrastructure-2.0.0.RELEASE.jar
spring/aopalliance-1.0.jar
spring/org.springframework.aop-3.0.0.RELEASE.jar
spring/org.springframework.jdbc-3.0.0.RELEASE.jar
spring/org.springframework.transaction-3.0.0.RELEASE.jar

You should create a new folder to hold the configuration files for your batch jobs on the class path, eg. WEB-INF/classes/exampleJob.xml. You can import these files into your applicationContext.xml. <import resource="classpath:/jobs/exampleJob.xml" />

Rather than persisting information about the batch job to a database, you can define an in-memory data source to hold the information in applicationContext.xml. You need a job repository and a transaction manager defined. <bean id="jobRepository" class="org.springframework.batch.core.repository.support.MapJobRepositoryFactoryBean"> <property name="transactionManager" ref="transactionManager"/> </bean> <bean id="transactionManager" class="org.springframework.batch.support.transaction.ResourcelessTransactionManager"/>

The exampleJob.xml contains the configuration for the batch job itself: <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:seam="http://jboss.com/products/seam/spring-seam" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:batch="http://www.springframework.org/schema/batch" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://jboss.com/products/seam/spring-seam http://jboss.com/products/seam/spring-seam-2.2.xsd http://www.springframework.org/schema/batch http://www.springframework.org/schema/batch/spring-batch-2.0.xsd"> <bean id="exampleJob" class="com.example.ExampleJob"> <seam:component/> </bean> <bean id="jobLauncher" class="org.springframework.batch.core.launch.support.SimpleJobLauncher"> <property name="jobRepository" ref="jobRepository" /> <seam:component/> </bean> <batch:job id="personUpload"> <batch:step id="personload"> <batch:tasklet> <batch:chunk reader="personItemReader" writer="exampleWriter" commit-interval="5"/> </batch:tasklet> </batch:step> </batch:job> <bean id="personItemReader" class="org.springframework.batch.item.file.FlatFileItemReader"> <property name="resource" value="file://C:/workspaces/test/v3_crime/testdata/watchlist/uploadwatchlist1.csv" /> <property name="lineMapper"> <bean class="org.springframework.batch.item.file.mapping.DefaultLineMapper"> <property name="lineTokenizer"> <bean class="org.springframework.batch.item.file.transform.DelimitedLineTokenizer"> <property name="names" value="title,firstname,surname,dateOfBirth,country" /> </bean> </property> <property name="fieldSetMapper"> <bean class="com.example.ExampleFieldSetMapper" /> </property> </bean> </property> </bean> <bean id="exampleWriter" class="com.example.ExampleWriter" /> </beans>
In this file we define the exampleJob bean which is a java class called ExampleJob. This is a spring class that is wrapped as a seam component. We also define a job launcher that uses the job repository already defined in applicationContext.xml.

The batch job called personUpload contains the step personload which defines a reader and writer for the data. To read the csv file we use Spring Batch’s FlatFileItemReader and tell it the names of the fields that are contained in the file. It uses the ExampleFieldSetMapper class to do the mapping. We also define an exampleWriter bean that will be used to display the data uploaded in the logs.

The ExampleJob.java class simply launches the batch job. public class ExampleJob { @Autowired private JobLauncher jobLauncher; @Autowired private Job job; public void launchJob() throws Exception { jobLauncher.run(job, new JobParameters()); } }

The ExampleFieldSetMapper.java takes the data read in from each line in the csv file and stores it as an UploadedPerson (a simple class containing the properties and getters/setters required). public class ExampleFieldSetMapper implements FieldSetMapper<UploadedPerson> { public UploadedPerson mapFieldSet(FieldSet fs) { if(fs == null){ return null; } UploadedPerson person = new UploadedPerson(); person.setTitle(fs.readString("title")); person.setFirstname(fs.readString("firstname")); person.setSurname(fs.readString("surname")); person.setDateOfBirth(fs.readString("dateOfBirth")); person.setCountry(fs.readString("country")); return person; } }

ExampleWriter.java just logs the list of UploadedPerson objects to the log files: public class ExampleWriter implements ItemWriter<Object> { UploadWatchlistService watchlistService; private static final Log log = LogFactory.getLog(ExampleWriter.class); /** * @see ItemWriter#write(Object) */ public void write(List<? extends Object> data) throws Exception { log.info(data); } }

Now in the seam component that calls the job we inject the ExampleJob and @In(create=true) private ExampleJob exampleJob; ... try { exampleJob.launchJob(); } catch (Exception e) { log.info("There was an error: " + e); }

In order to integrate Spring into Seam, you need the ability to start up both of the containers and allow them access to each others components. To assist with this Seam provides a special ContextLoader in the jboss-seam-ioc jar file, so that Seam can read the Spring configuration files and start up the Spring container. To configure this you need to edit Seam’s components.xml and add the following namespace and schema entry: <?xml version="1.0" encoding="UTF-8"?> <components ... xmlns:spring="http://jboss.com/products/seam/spring" ... http://jboss.com/products/seam/spring http://jboss.com/products/seam/spring-2.2.xsd

Further down the file within the components section you instruct Seam to bootstrap the Spring container, assuming by default that there is a WEB-INF/applicationContext.xml containing the Spring configuration. <spring:context-loader/>

You then add a basic applicationContext.xml <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:seam="http://jboss.com/products/seam/spring-seam" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd http://jboss.com/products/seam/spring-seam http://jboss.com/products/seam/spring-seam-2.2.xsd"> </beans>

Any additional spring configuration will be added to this file.

For this code to work, you need to add the following jar files to your ear file. The jboss-seam-ioc.jar contains the classes that allow you to integrate Spring and the other jars are required for the Spring configuration files.

jboss-seam-ioc-2.2.0.GA.jar
org.springframework.asm-3.0.0.RELEASE.jar
org.springframework.beans-3.0.0.RELEASE.jar
org.springframework.core-3.0.0.RELEASE.jar
org.springframework.context-3.0.0.RELEASE.jar
org.springframework.expression-3.0.0.RELEASE.jar
org.springframework.web-3.0.0.RELEASE.jar

You can now add a spring bean into your applicationContext.xml <bean id="exampleSpringBean" class="com.example.exampleSpringBean"> <property name="testString" value="This is a test" /> <seam:component/> </bean>

You will obviously need to create a corresponding class for this bean. The seam:component tag marks this bean as a SpringComponent which is registered for use as a Seam component by the Seam container.

You can now inject the bean into another class as a seam component. @In(create=true) private ExampleSpringBean exampleSpringBean; ... String value = exampleSpringBean.getTestString();

This is a very simple example with basic configuration that doesn’t take into account any of the issues you may need to watch out for when mixing Spring and Seam.

Enable the Facelets Debug Page:
In web.xml you set Facelets to development mode.
WEB-INF/web.xml <context-param> <param-name>facelets.DEVELOPMENT</param-name> <param-value>true</param-value> </context-param>

The Facelets debug page gives you the line number in the .xhtml page where the error occured and access to the JSF component tree.

You can access the facelets debug page at any point by setting a hot key for that page.  To launch a debug popup on a page using CTRL-SHIFT-D, add <ui:debug hotkey=”d”/> in the page.

Enable the Seam Debug Page:
You need to add Facelets and Seam UI Support, then enable debugging in components.xml

WEB-INF/components.xml <core:init jndi-pattern="example/#{ejbName}/local" debug=true/>where example is the name of the application.

You can always access the seam debug page by going to the /debug.seam page in your browser.

It’s also recommended that you add seam’s UI tags which allow the use of Hibernate’s validator annotations and provide conversation and business process management along with other extra tags.

To enable these you need to edit your configuration files and add some jar files.

Add required jar files:
WEB-INF/lib: jsf-facelets.jar jboss-seam-ui.jar jboss-seam-debug.jar

Add el-api.jar and el-ri.jar to the ear file so they can be used by both your war and jar files.  Make an entry in the application.xml file to make the jars available on the ear classpath.

META-INF/application.xml <module> <java>el-api.jar</java> </module> <module> <java>el-ri.jar</java> </module>

Add a View Handler:
The view handler renders html pages from facelets pages and templates.

WEB-INF/faces-config.xml <application> <view-handler>org.jboss.seam.ui.facelets.SeamFaceletViewHandler</view-handler> </application>

Update the web.xml so that the facelets suffix .xhtml will be used for web pages.

WEB-INF/web.xml <context-param> <param-name>javax.faces.DEFAULT_SUFFIX</param-name> <param-value>.xhtml</param-value> </context-param>

Add the Filter and Resource Servlet:
The SeamFilter supports JSF redirects, error pages and file uploads.  The resource servlet gives access to images and css files in jboss-seam-ui.jar and gives direct access to seam components from javascript.  You add these to your web.xml.

WEB-INF/web.xml <servlet> <servlet-name>Seam Resource Servlet</servlet-name> <servlet-class>org.jboss.seam.servlet.SeamResourceServlet</servlet-class> </servlet> <servlet-mapping> <servlet-name>Seam Resource Servlet</servlet-name> <url-pattern>/seam/resource/*</url-pattern> </servlet-mapping> <filter> <filter-name>Seam Filter</filter-name> <filter-class>org.jboss.seam.servlet.SeamFilter</filter-class> </filter> <filter-mapping> <filter-name>Seam Filter</filter-name> <url-pattern>/*</url-pattern> </filter-mapping>

You can now use .xhtml pages in your application and make use of the seam ui tags.

While it’s still nowhere near as widespread as Spring, it brings some functionality that was missing in Spring, and can complement or replace Spring depending on what features you value in your web application.  From first experiences using the framework I can see many benefits to Seam, but would caution that it’s not quite so easy to use as some of the documentation might lead you to believe.  It can solve the problems it was designed to fix, but you have to be careful that you not only understand the problems, but also the solutions being applied.  You really need to code your application in a way that allows it to make use of what Seam is able to do well, otherwise you may inadvertantly bypass what you wanted.  If you don’t really understand the nuances of how Seam is solving typical problems, chances are your code isn’t going to be able to take advantage of what Seam does offer.  The other disadvantage is that in being able to use the framework in many different ways, a beginner can have trouble figuring out which way is best to implement something for their own particular scenario.  If you have a lot of very experienced developers on your team, these won’t be such big issues.  But it’s something to be aware of if you don’t already have Seam experience on the team.

So what problems is Seam supposed to solve?
One of Seam’s purposes is to fill in the gap between using JSF for the web tier which is usually based on stateless simple requests and responses, and EJB3 for the business tier which can deal with transactional resources.  Ordinarily to use these two frameworks together you need to write extra configuration code and backing beans.  Seam annotations allow business components to be used directly by the front end.  You use Entity objects to represent data that is mapped to a relational database table.  JSF web pages can display and capture data using the JSF Expression Language (EL) and map the data directly back to the backend.  You then have handlers that can update the data or perform business logic. There are also some extra seam tags available to use that fix some issues with JSF tags.

Another thing Seam brings to the table is more than just a Session scope or context.  The most interesting one being the Conversation scope.  The extra scopes mean that less data is stored in the session and can be managed in a wiser manner. More on the conversation scope another time as it’s a big area to get your head around.

The next solution Seam offers is to help end the LazyInitialization exceptions seen when using Hibernate (which was designed for use in Stateful applications) or other ORM (Object Relational Mapping) solutions with a Stateless framework.  These LazyInitialization exceptions occur because Hibernate is based on using objects containing data that can have other associated objects.  Lazy loading is used to avoid fetching large amounts of data that might not be used when loading a parent object that has other child objects associated with it.   The associated child objects are not loaded unless specifically requested.  But we run into a problem in a Stateless framework as the persistence context is destroyed once the parent is passed to the presentation layer.  If the presentation layer requests a child object, then a lazy loading exception is thrown as the persistence context is no longer available for the second request.  This means that DTOs (Data Transfer Objects) have to be used. Seam can keep the persistence context open until a page is fully rendered, or longer across a number of pages or a session.  So there should be no lazy loading exceptions and the performance improves when changes are only flushed to the database at the end of a conversation.

These are some of the main reasons why you might choose to use Seam in a project.  There’s a lot to cover in the Seam framework however, so this only scratches the surface before going into more detail in each area.

In the frament page you can reference the location value in the normal way: <ice:outputText value="#{manager.getLocation( '#{location}')}" />

And can use that value to pass to a backing bean method called from the fragment.

So the current conversation should be brought through to the new window (to keep the current result set), and then the selected Car should be set (starting a new conversation). The s:link tag maintains the conversation, but currently does not work correctly as it is missing a backing datamodel. To add that datamodel would require substantial refactoring, adding a lot of extra seam components just to allow the selection to work.

The broken url is http://localhost:8080/app/page.seam?actionMethod=page.xhtml:selectedCar.setCar(thisCar)&cid=3

Without the backing datamodel, the thisCar variable gets passed into the setCar method as null.

A workaround for this is to use a request parameter in the backing bean and a new method that retrieves the list of results and identifies the correct car to select from that.

In the xhtml page use the s:link tag with a parameter set to the current row id: <s:link id="selectCar" value="#{thisCar.id}" style="color:blue" action="#{selectedCar.setCar()}"> <f:param name="rowId" value="#{thisCar.id}" />
In the backing bean that row id is a request parameter: @RequestParameter private String rowId;
Use the rowId to determine the correct car: public void setCar() { int selected = (Integer.parseInt(rowId));</p> Iterator it = results.iterator(); while (it.hasNext()) { Car car= (Car) it.next(); if (car.getId() == selected) { selectedCar = car;< } }
The url is now: http://localhost:8080/app/page.seam?rowId=3&actionMethod=page.xhtml:selectedCar.setCar(selectedCar)&cid=3