This commandLink action attribute references the ItemController backing bean next() method which calculates the next page's first row number  and returns a logical outcome String, which causes the List.jsp page to display the next page's list . The ItemController next method is defined as shown below:

Code Sample from: ItemController.java

public String next() {        if (firstItem + batchSize < getItemCount()) {            firstItem += batchSize;        }        return "item_list";    }

The JavaServer Faces NavigationHandler matches the logical outcome,  item_list against the navigation rules in the application configuration resource file faces-config.xml to determine which page to access next. In this case, the JavaServer Faces implementation loads the List.jsp page after this method returns.

Code Sample from: faces-config.xml

<navigation-rule>       <navigation-case>           <from-outcome>item_list</from-outcome>           <to-view-id>/item/List.jsp</to-view-id>       </navigation-case>   </navigation-rule>

A JSF commandLink is  used to provide a link to click on to display the previous page of items. This commandLink action attribute  references the  ItemController  prev() method that calculates the previous page's first row number  and returns a logical outcome String, which causes the List page to display the previous page of items :

Code Sample from: List.jsp

<h:commandLink action="#{itemController.prev}" value="Previous #{itemController.batchSize}"                 rendered="#{itemController.firstItem >=itemController.batchSize}"/>

 This ItemController  prev() method  is defined as shown below: 
 

Code Sample from: ItemController.java

public String prev() {         firstItem -= batchSize;         if (firstItem < 0) {             firstItem = 0;         }         return "item_list";     }

A JSF ommandLink is  used to provide a link to click on to display a page with the item details. This commandLink action attribute  references The ItemController detailSetup() method:

Code Sample from: List.jsp

<h:column>        <f:facet name="header">           <h:outputText value="Name"/>        </f:facet>        <h:commandLink action="#{itemController.detailSetup}" value="#{dataTableItem.name}"/>       </h:column>

The ItemController detailSetup() method  gets the item data from the current row of the dataModel, and returns a string which causes the Detail.jsp page to display the item details :

Code Sample from: ItemController.java

public String detailSetup() {         item = (Item) model.getRowData();         return "item_detail";     }

The JavaServer Faces NavigationHandler matches the logical outcome,  item_detail against the navigation rules in the application configuration resource file to determine which page to access next. In this case, the JavaServer Faces implementation loads the Detail.jsp page after this method returns.

Code Sample from: faces-config.xml

<navigation-rule>         <navigation-case>             <from-outcome>item_detail</from-outcome>             <to-view-id>/item/Detail.jsp</to-view-id>           </navigation-case>     </navigation-rule>

The Detail.jsp uses the outputText component to display the ItemController ManagedBean's item properties:

Code Sample from: detail.jsp

<h:outputText value="#{itemController.item.name}" title="Name" />     <h:outputText value="#{itemController.item.description}" title="Description"/>     <h:graphicImage url="#{itemController.item.imageurl}" title="Imageurl" />     <h:outputText value="#{itemController.item.price}" title="Price" />     <h:outputText value="#{itemController.item.address.city}" title="Address" />     <h:outputText value="#{itemController.item.contactinfo.email}" title="Address"/>

Conclusion
This concludes the sample application which demonstrates how to work with the JSF dataTable and  DataModel  to page through a list of  Item Entities which are retrieved using the Catalog methods which use  the Java Persistence APIs with Spring 2.5.

Running the Sample Code

The sample code for this tip is available as a NetBeans project. You can build and run the sample code using the NetBeans IDE.

Set up the Development Environment: (these directions are also here with screenshots)

1. Download and install NetBeans 6.0 . Get the full distribution with Java EE and Glassfish v2.
2. Install the Spring Framework Plug-in into the NetBeans IDE:
   • Select Tools from the NetBeans menu bar and select Plugins.
   • Select Available Plugins tab and then select Spring Framework Support and then click the Install button.
3. Open the Admin Console of the GlassFish V2 application server in order to create the JDBC Connection pool and JDBC resource:
   
   1. Select the NetBeans Services tab window.
   2. Expand Servers.
   3. Right click GlassFish V2 and select View Admin Console.
   4. Enter values to User Name and Password fields - the default is admin for User Name and adminadmin for the Password
4. Create a connection pool using the Admin Console:
   
   1. Expand Resources->JDBC.
   2. Click Connection Pools.
   3. Click New on the right of the page.
   4. For the Name field, enter PETCatalogPool.
   5. For Resource Type, select javax.sql.DataSource from the drop-down menu.
   6. For Database Vendor field, select JavaDB from the drop-down menu.
   7. Click Next.
   8. Scroll down to the end of the page to see the Additional Properties section.
   9. For Connection Attributes field, enter ;create=true.
   10. For DatabaseName field, enter pet-catalog.
   11. For Password field, enter app.
   12. For User field, enter app.
   13. Click Finish.
   14. Remove the SecurityMechanism property from the PETCatalogPool:.
       
       1. Select PetCatalogPool under Connection Pools node on the left.
       2. Select Additional Properties tab on the right and observe that the Edit Connection Pool Properties are displayed.
       3. Check Security Mechanism and click Delete Properties.Click Save.
5. Start the Java DB server using NetBeans:
   
   1. Select Tools from the NetBeans top-level menu bar and select Java DB Database->Start Server.
6. Make sure the PetCatalogPool is operational using the Admin Console:
   1. Start the Java DB server (if it is not started already)
      
   2. Select the Admin Console General tab window.
   3. Click Ping button.
   4. Make sure that the Ping Succeeded message is displayed on the top.
7. Create a JDBC resource using the Admin Console:
   1. Select JDBC Resources under JDBC on the left of the Admin Console .
   2. Click New button on the right.
   3. For JNDI Name field, enter jdbc/PETCatalogDB.
   4. For Pool Name field, select PETCatalogPool from the drop-down menu.
   5. Click OK.
8. Create a Database connection using NetBeans:
   
   1. Select the NetBeans Services tab window.
   2. Right click Database and select New Connection.
   3. Observe that the New Database Connection dialog box appears.
   4. For the Database URL field, enter jdbc:derby://localhost:1527/pet-catalog.
   5. For User Name field, enter app.
   6. For Password field, enter app.
   7. Click OK.
9. Create a database using NetBeans:
   Select Tools from the NetBeans top-level menu bar and select Java DB Database->Create Database.
   1. Observe that the Create Java DB Database dialog appears.
   2. For the Database Name field, enter pet-catalog.
   3. For User Name field, enter app.
   4. For Password field, enter app.
   5. Click OK.
10. Populate the database tables  in the pet-catalog database as follows:
    1. Under Databases, select the connection pet-catalog that you just created.
    2. Right mouse click on pet-catalog and select Excecute Command.
       
    3. In the SQL command window copy paste all the sql text from the file <sample_install_dir>/SpringJPA/setup/sql/javadb/catalog.sql,
       
    4. At the top of the window click on the icon for Run SQL. This will create all of the tables and data for the application.

Open and Run the Sample code:

1. Download the sample code and extract its contents. You should now see the newly extracted directory as <sample_install_dir>/SpringJPA, where <sample_install_dir> is the directory where you installed the sample package. For example, if you extracted the contents to C:\ on a Windows machine, then your newly created directory should be at C:\SpringJPA.
   
   
2. Start the NetBeans IDE. Click Open Project in the File menu and select the SpringJPA directory you just unzipped.
   
   
3. Build the project as follows:
   
   
   • Right click the SpringJPA node in the Projects window.
     
   • Select Clean and Build Project.
     
     
4. Run the project as follows:
   
   
   • Right click the SpringJPA node in the Projects window.
     
   • Select Run Project.
     

When you run the project, your browser should display the opening page of the JSF, Java Persistence API, and Spring 2.5 Sample Application (at http://localhost:8080/SpringJPA/).

Creating your own Netbeans Project with Spring 2.5 & Glassfish  :

1. If you want to create your own application, Create a new Netbeans Web Application:
   
   1. In Netbeans  select File New Project, then select Web ..Web Application, on the New Web Application Window, for Server select Sun Java System Applicaton server,  Java EE 5 Version,  set a project name and context path  and click Next .
   2. on the frameworks window select Spring Framework 2.5, click Finish.
      
2. To Generate Entity classes from database tables: In the project window, right click on the project, select new File..Persistence Entity classes from database.  Click next, then select your datasource, tables and create your persistence unit. For more info on how to do this try out the following Hands On Lab: Java EE 5, EJB 3.0, Java Persistence API (JPA)
3. Configuration of the XML files for Spring 2.5, JSF, and JPA, running on Glassfish. For Spring configuration modify the applicationConfiguration.xml and modify the web.xml and faces-config.xml as described below.
   1.  modify the file /WEB-INF/applicationContext.xml to the war WEB-INF directory.  This file is where you define your Spring service beans, and resources. Below is the applicationContext.xml for the sample app.  For more information about configuring the Spring applicationContext.xml for JPA see this article: Using the Java Persistence API (JPA) with Spring 2.5

      Code Sample from: applicationContext.xml

      <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans"        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"        xmlns:p="http://www.springframework.org/schema/p"        xmlns:aop="http://www.springframework.org/schema/aop"        xmlns:context="http://www.springframework.org/schema/context"        xmlns:jee="http://www.springframework.org/schema/jee"        xmlns:tx="http://www.springframework.org/schema/tx"        xsi:schemaLocation="        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd        http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans-2.5.xsd        http://www.springframework.org/schema/context        http://www.springframework.org/schema/context/spring-context-2.5.xsd        http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-2.5.xsd        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd">         <bean id="propertyConfigurer"           class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"           p:location="/WEB-INF/jdbc.properties" />                  <!-- JPA EntityManagerFactory -->     <bean id="entityManagerFactory"           class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"           p:dataSource-ref="dataSource">         <property name="jpaVendorAdapter">             <bean class="org.springframework.orm.jpa.vendor.TopLinkJpaVendorAdapter"                   p:databasePlatform="${jpa.databasePlatform}"                   p:showSql="${jpa.showSql}"/>                   </property>         <property name="loadTimeWeaver">             <bean class="org.springframework.instrument.classloading.glassfish.GlassFishLoadTimeWeaver"/>         </property>     </bean>             <bean id="dataSource"           class="org.springframework.jdbc.datasource.DriverManagerDataSource"           p:driverClassName="${jdbc.driverClassName}"           p:url="${jdbc.url}"           p:username="${jdbc.username}"           p:password="${jdbc.password}" />       <!--         PostProcessors to perform exception translation on @Repository classes     -->     <bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"/>        <bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor"/>     <!-- Transaction manager for  JTA  -->     <bean id="transactionManager" class="org.springframework.transaction.jta.JtaTransactionManager" />     <!--      Instruct Spring to perform declarative transaction management      automatically on annotated classes.     -->     <tx:annotation-driven />     <!--      Activates various annotations to be detected in bean classes: Spring's      @Required and @Autowired, as well as JSR 250's @PostConstruct,      @PreDestroy and @Resource (if available) and JPA's @PersistenceContext      and @PersistenceUnit (if available).     -->     <context:annotation-config/>     <context:component-scan base-package="sessionpagination" />     <!--      Instruct Spring to retrieve and apply @AspectJ aspects which are defined      as beans in this context (such as the UsageLogAspect below).     -->     <aop:aspectj-autoproxy/>     <!--      CatalogDAO Will automatically be transactional due to @Transactional.      EntityManager will be auto-injected due to @PersistenceContext.      PersistenceExceptions will be auto-translated due to @Repository.     -->     <bean id="catalogService" class="service.CatalogDAO"/>     </beans>

   2. Add the spring framework ContextLoaderListener and context parameter to your application's web.xml as shown below. For more information on configuring Spring see these references: Using Spring 2 with JSF , Spring - Java/J2EE Application Framework Integrating with JavaServer Faces,  Advanced Configuration of the Spring MVC Framework
      

      Code Sample from: web.xml

      <context-param>         <param-name>contextConfigLocation</param-name>         <param-value>/WEB-INF/applicationContext.xml</param-value>     </context-param>     <listener>         <listener-class>             org.springframework.web.context.ContextLoaderListener         </listener-class>     </listener>     <listener>         <listener-class>               org.springframework.web.context.request.RequestContextListener              </listener-class>     </listener>

   3. Add the SpringBeanFacesELResolver to the faces-config.xml : 

      Code Sample from: faces-config.xml

      <application>     <el-resolver>    org.springframework.web.jsf.el.SpringBeanFacesELResolver     </el-resolver>  </application>

      
      
      

For additional information see:

• What's New in Spring 2.5
• Intro to Spring 2.5
• Spring 2.5 framework samples (in download zip)
  
• Using the Java Persistence API (JPA) with Spring 2.0
• Data Access with Spring and JPA on Glassfish
• Using JPA in Spring without referencing Spring
• Spring - Java/J2EE Application Framework Integrating with JavaServer Faces
• Using Spring 2 with JSF
  
• Building JavaServer Faces Applications with Spring and Hibernate
• Spring and Hibernate in GlassFish
• Harnessing the Power of Java Platform, Enterprise Edition (Java EE) Technology With Spring
• Java EE tutorial (includes great tutorial for JSF and JPA)
• Pro EJB 3: Java Persistence API book
• Java BluePrints Solutions Catalog for the Java Persistence APIs contains a collection of topics and example applications.
• Java Persistence reference page on GlassFish Project 
• Build a real-world Web application with JavaServer Faces, the Spring Framework, and Hibernate