The Source for Java Technology Collaboration
User: Password:
Register | Login help    



Syndicate this blog (XML)
Carol McDonald

Carol McDonald's Blog

«Sample Store Catalog Application using Visual Web Pack and the Java Persistence APIs | Main | Sample Application using JSF, Seam, and Java Persistence APIs on Glassfish »

Sample Application using JSF, Spring 2.0, and Java Persistence APIs

Posted by caroljmcdonald on June 19, 2007 at 12:53 PM | Comments (30)

Pagination of Data Sets in a Sample Application using JSF, Spring 2.0, and Java Persistence APIs on Glassfish



This Sample Store Catalog app demonstrates the usage of JavaServer Faces, the new Java Persistence APIs, and Spring 2.0 to implement pagination. I took this example  Pagination of Data Sets in a Sample Application using JSF, Catalog Facade Stateless Session, and Java Persistence APIs  and modified it slightly to use a Spring Bean instead of a EJB 3.0 Stateless Session Bean.  If you compare the two, you will see that the code is almost the same, the main difference is the extra xml configuration for Spring, and for me it wasn't easy to get the .xml configuration right. It took looking at several articles, blogs, examples, and some trial and error to get it working.  (see the references at the end).
download the SpringJPA sample application code
Note: I updated the  Spring  JSF integration part of this application to use the org.springframework.web.jsf.DelegatingVariableResolver instead of a  JSF Managed Bean ServiceLocator in order to get a reference to the CatalogService Spring Bean from the Spring application context.

Explanation of the usage of JSF, Spring 2.0 , and Java Persistence APIs in a sample Store Catalog Application

The image below shows the Catalog Listing page, which allows a user to page through a list of items in a store.

listpage.jpg

The List.jsp page uses a JSF dataTable component to display a list of catalog items

The dataTable component is useful when you want to show a set of results in a table. In a JavaServer Faces application, the UIData component (the superclass of dataTable)  supports binding to a collection of data objects. It does the work of iterating over each record in the data source. The HTML dataTable renderer displays the data as an HTML table.

In the List.jsp web page the dataTable is defined as shown below:  (Note: Red colors are for Java EE tags, annotations code, Blue for Spring specific and Green for my code or variables)

Code Sample from:  List.jsp

<h:dataTable value='#{item.items}' var='dataTableItem' border="1"
      cellpadding="2" cellspacing="0">

The value attribute of a dataTable tag references the data to be included in the table. The var attribute specifies a name that is used by the components within the dataTable tag as an alias to the data referenced in the value attribute of dataTable.  In the dataTable tag from the List.jsp page, the value attribute points to a list of catalog items. The var attribute points to a single item in that list. As the UIData component iterates through the list, each reference to dataTableItem points to the current item in the list.

The dataTable's value is bound to the items property of the item controller class, ItemController, which is defined in the faces-config.xml file:

Code Sample from: faces-context.xml

 <managed-bean>
    <managed-bean-name>item</managed-bean-name>
      <managed-bean-class>
         sessionpagination.ItemController
      </managed-bean-class>
    <managed-bean-scope>session</managed-bean-scope>
     <managed-property>
          <property-name>catalogService</property-name>
          <value>#{catalogService}</value>
    </managed-property>
 </managed-bean>


This ItemController ManagedBean items property is defined as shown below:

Code Sample from: ItemController.java

    public DataModel getItems() {
        if (model==null  || index != firstItem){
            model=getNextItems();
        }
        return this.model;
    }
   
    public DataModel getNextItems() {      
        model = new ListDataModel(catalogService.getItems(firstItem,batchSize));
        index = firstItem;      
        return this.model;
    }


The getItems() method wraps a List of item objects, returned from the catalogService,  in a DataModel.
UIData, the superclass of dataTable, supports data binding to a collection of data objects represented by a DataModel instance.  The data collection underlying a DataModel instance is modeled as a collection of row objects that can be accessed by a row index.  The APIs provide mechanisms to position to a specified row index, and to retrieve an object that represents the data that corresponds to the current row index.   

The Item properties Name, Photo, and price  are displayed with the column component:

Code Sample from: List.jsp

  <h:column>
      <f:facet name="header">
          <h:outputText value="Price"/>
      </f:facet>
      <h:outputText value="#{dataTableItem.price}"/>
  </h:column>

The column tags represent columns of data in a UIData component. While the UIData component is iterating over the rows of data, it processes the UIColumn component associated with each column tag for each row in the table.

The UIData component  iterates through the list of items (item.items)  and displays the dataTableItem.price. Each time UIData iterates through the list of items, it renders one cell in each column.

The dataTable and column tags use facet to represent parts of the table that are not repeated or updated. These include headers, footers, and captions.

The  recommended way to integrate Spring with JSF is to configure the Spring DelegatingVariableResolver in the faces-context.xml.  The <application> <variable-resolver> elements in a faces-config.xml file allows a Faces-based application to register a custom replacement class for the implementation of the standard Faces VariableResolver implementation. The Spring DelegatingVariableResolver  first delegates to the original resolver of the underlying JSF implementation, then to the Spring root WebApplicationContext.   This allows you to configure Spring Beans as managed properties of your JSF Managed Beans. For example, below the  catalogService Spring Bean is configured as a managed property of the ItemController JSF ManagedBean:

Code Sample from: faces-context.xml

  <application>
    <variable-resolver>
      org.springframework.web.jsf.DelegatingVariableResolver
    </variable-resolver>
 </application>
 <managed-bean>
    <managed-bean-name>item</managed-bean-name>
      <managed-bean-class>
         sessionpagination.ItemController
      </managed-bean-class>
    <managed-bean-scope>session</managed-bean-scope>
     <managed-property>
          <property-name>catalogService</property-name>
          <value>#{catalogService}</value>
    </managed-property>
 </managed-bean>



The catalogService, and its implementation  CatalogDAO,  is defined as a Spring bean in the Spring configuration resource file /WEB-INF/applicationContext.xml :

Code Sample from: applicationContext.xml
  
    <bean id="catalogService" class="service.CatalogDAO"/>     
 
    <bean name="itemController" class="sessionpagination.ItemController">
        <property name="catalogService">
            <ref bean="catalogService"/>
        </property>
    </bean>
   
</beans>

<property name="catalogService"> refers to the ItemController setCatalogService method. The Spring root WebApplicationContext will inject the catalogService Spring Bean into the catalogService property of the ItemController JSF ManagedBean :

Code Sample from: ItemController.java

  public class ItemController {

  private CatalogService catalogService ;
   
  public void setCatalogService(CatalogService catalogService) {
        this.catalogService = catalogService; 
  }

For more information on using JSF with Spring, see Spring - Java/J2EE Application Framework Integrating with JavaServer Faces .

Using the Java Persistence API (JPA) with Spring 2.0

The Spring bean CatalogDAO uses the Java Persistence API EntityManager Query object to return a list of items. The CatalogDAO annotates the field private EntityManager em;  with @PersistenceContext , which causes an entity manager to be injected. (note that using the @PersistenceContext annotation is the same way an Entity Manager is injected for a EJB 3.0 Session Bean.)
 

Code Sample from: CatalogDAO.java

@Repository
@Transactional
public class CatalogDAO implements CatalogService {
   
    @PersistenceContext(unitName="PetCatalogPu")
    private EntityManager em;

    public List<Item>  getItems(int firstItem,int batchSize) {      
       Query q = em.createQuery("select object(o) from Item as o");
       q.setMaxResults(batchSize);
       q.setFirstResult(firstItem);
       List<Item> items= q.getResultList();
       return items;      
   }
   

The Java Persistence Query APIs are used to create and execute queries that can return a list of results.  The JPA Query interface provides support for pagination via the setFirstResult() and setMaxResults() methods: q.setMaxResults(int maxResult) sets the maximum number of results to retrieve. q.setFirstResult(int startPosition) sets the position of the first result to retrieve.

In the code below, we show the Item entity class which maps to the  ITEM table that stores the item instances. This is a typical Java Persistence entity object. There are two requirements for an entity:
  1. annotating the class with an @Entity annotation.
  2. annotating   the primary key identifier with @Id
Because the fields name, description.... are basic mappings from the object fields to columns of the same name in the database table, they don't have to be annotated.  The O/R  relationships with Address and Product are also annotated. For more information on defining JPA entities see Pro EJB 3: Java Persistence API book.

Code Sample from: Item.java

@Entity
public class Item implements java.io.Serializable {

    @Id  
    private String itemID;
    private String name;   
    private String description;   
    private String imageurl;   
    private String imagethumburl; 
    private BigDecimal price;
    @OneToOne(cascade={CascadeType.PERSIST})
    private Address address;
    @ManyToOne
    private Product product;
    
    public Item() { }
     
    public String getItemID() {
        return itemID;
    }
    public void setItemID(String itemID) {
        this.itemID = itemID;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }   
    public String getDescription() {
        return description;
    }
    public void setDescription(String description) {
        this.description = description;
    }
    public BigDecimal getPrice() {
       return price;
    } 
    public void setPrice(BigDecimal price) {
        this.price = price;
    }
    public void setAddress(Address address) {
        this.address = address;
    }
    public Product getProduct() {
        return product;
    }
    public void setProduct(Product product) {
        this.product = product;
    }

    ...
}   




The ItemController ManagedBean pages through the list of Items by maintaining the firstItem and batchSize attributes and passing these as parameters to the CatalogService getItems(firstItem, batchSize) method. The ItemController's <managed-bean-scope> is defined as session, a JSF Managedbean with session scope will be stored in the session meaning that the bean's properties will stay alive for the life of the Http Session.


The ItemController ItemCount  property is  used to get and display the number of Catolog items in the  data base on the List.jsp page:

Code Sample from: List.jsp

<h:outputText value="Item #{item.firstItem + 1}..#{item.lastItem} of
     #{item.itemCount}"/>

This ItemController ItemCount property is defined as shown below:

Code Sample from: ItemController.java

    public int getItemCount() {      
        int count = catalogService.getItemsCount();
        return count;     
    }

The ItemController getItemCount() method calls the CatalogService interface to get the count of the list of items. The CatalogDAO Spring bean  getItemCount() method uses the JPA Query interface to get the count of all items in the database item table:

Code Sample from: CatalogDAO.java
public class CatalogDAO implements CatalogService {
. . .
    public int  getItemCount() {
        Query q = entityManager.createQuery("select count(o) from Item as o");     
        int count = ((Long)q.getSingleResult()).intValue();     
        return count;
    }   
    


A JSF commandLink is  used to provide a link to click on to display the next page of items. The commandLink tag represents an HTML hyperlink and is rendered as an HTML <a> element. The commandLink tag is used to submit an action event to the application. 

Code Sample from: List.jsp

 <h:commandLink action="#{item.next}" value="Next #{item.batchSize}"
    rendered="#{item.lastItem + item.batchSize <= item.itemCount}"/>   

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="#{item.prev}" value="Previous #{item.batchSize}"        
        rendered="#{item.firstItem >=item.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="#{item.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="#{item.item.name}" title="Name" />
    <h:outputText value="#{item.item.description}" title="Description"/>
    <h:graphicImage url="#{item.item.imageurl}" title="Imageurl" />
    <h:outputText value="#{item.item.price}" title="Price" />
    <h:outputText value="#{item.item.address.city}" title="Address" />
    <h:outputText value="#{item.item.contactinfo.email}" title="Address"/>  


    detailpage.jpg



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.0.



Setting up the database tables for the sample application:
  • edit the properties in the SpringJPA\setup\javadb.properties file, then run the ant script in the directory SpringJPA\setup, or just run the sql in the directory SpringJPA\setup\sql\javadb with whatever tool you have.

Configuration of the Application for Spring 2.0, JSF, JPA, running on Glassfish

 To set up glassfish and the netbeans project for Spring, I modified the steps from  Spring and Hibernate in GlassFish  :     Setting Things Up:
  • download and extract  Spring  ( I downloaded 2.1).
  • Download and install NetBeans 5.5.1
  • Download and install GlassFish V1, following the instructions on the download page. Alternatively you can use Sun Java System Application Server PE 9, Sun's GlassFish distribution.
  • Add the Glassfish server to Netbeans:
  • Start NetBeans and switch to the Runtime window (Ctrl+5).
  • Right-click the Servers node and select Add Server.
  • select Sun Java System Application Server (Sun's binary distribution of GlassFish).
  • Browse to the location where you installed GlassFish and select Finish.
    Create the Spring Library in Netbeans:
  • Open the Netbeans Library Manager (Tools menu) and create a new library called Spring.
  • Add the following jars to the Classpath:
  • dist/spring.jar, dist/weaving/spring-aspects.jar, lib/jakarta-commons/commons-logging.jar, lib/log4j/log4j-1.2.9.jar .
  • Set the Sources to the Spring src directory.
  • Set the Javadoc to the Spring docs\api directory.
    This library is now available for use by any project.

Open and Run the SpringJPA Project

Download The SpringJPA application. Unzip the code. From Netbeans do Open Project and select the Netbeans project SpringJPA from the unzipped directory. The SpringJPA application is a NetBeans Enterprise Application Project, which is actually comprised of 2 projects: SpringJPA and SpringJPA-war. SpringJPA-war is a Java EE Module of the SpringJPA project.  SpringJPA-war generates the war file and SpringJPA generates the ear file which contains the war.

Open the SpringJPA project. You will see this dialog when you open the project, because the Enterprise Application Project stores the absolute location to its J2EE Modules, you need to configure the location for the SpringJPA-war.

reference_problems
  • Click Close. The SpringJPA project will be in bold red.
  • Right click the project and select Resolve Reference Problems from the context menu.
  • Use the Resolve Reference Problems dialog to map the SpringJPA-war module to its project, which you'll find is a subdirectory beneath the SpringJPA directory .
  • After the references are resolved, right-click the SpringJPA project and select Open Required Projects (now that the dependencies are correct, the SpringJPA-war project will always open with the SpringJPA project).
  • There are still additional references problems with the web module,  since it references the Spring jar files that are needed to build the project.
  • add the new Spring library to the SpringJPA-war...
    in the project window under  SpringJPA-war:
    right click on Librairies, Add Library
    Select the Spring Library (that you created above) from the list, then click Add Library . This will add the Spring jar files to your SpringJPA-war project.
  • All references should now be resolved.  Right-click the SpringJPA project and select clean and build project.
  • Press F6 to test run the project. NetBeans will build, package, deploy and launch the application.

     Creating your own Netbeans with Spring & Glassfish Project :

  • If you want to create your own application, Create a new Netbeans Enterprise Application:
  • In Netbeans  select File New Project, then select Enterprise ..Enterprise Application, on the New Enterprise Application Window, for Server select Sun Java System Applicaton server,  Java EE 5 Version, and Select the Create Web Application Module as shown below:
                      newentapp.jpg
  • change your Netbeans project properties to add the new Spring library...
    in the project window under  your application's war:
    right click on Librairies, Add Library
    Select Spring Library from the list, then click Add Library .
  • to Generate Entity classes from the database tables: In the project window, right click on the war, 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)
  • For Spring configuration add the applicationConfiguration.xml and modify the web.xml and faces-config.xml as described below.
    Configuration of the XML files for Spring 2.0, JSF, and JPA, running on Glassfish
  •  Add 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.0

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:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.0.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.0.xsd">
   
    <bean id="catalogService" class="service.CatalogDAO"/>     
    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="loadTimeWeaver">
            <bean class="org.springframework.instrument.classloading.glassfish.GlassFishLoadTimeWeaver"/>
        </property>
        <property name="jpaVendorAdapter">
            <bean
                class="org.springframework.orm.jpa.vendor.TopLinkJpaVendorAdapter">
                <property name="showSql" value="true" />
                <property name="generateDdl" value="false" />
                <property name="databasePlatform"
                          value="oracle.toplink.essentials.platform.database.DerbyPlatform" />
            </bean>
        </property>
    </bean>      
    <bean id="dataSource"
          class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="org.apache.derby.jdbc.ClientDriver" />
        <property name="url" value="jdbc:derby://localhost:1527/pet-catalog" />
        <property name="username" value="app" />
        <property name="password" value="app" />
    </bean>     
    <bean class="org.springframework.dao.annotation.PersistenceExceptionTranslationPostProcessor"/>   
    <bean class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor"/>      
    <bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">
        <property name="entityManagerFactory" ref="entityManagerFactory"/>
        <property name="dataSource" ref="dataSource"/>
    </bean>   
    <tx:annotation-driven />  
    <bean name="itemController" class="sessionpagination.ItemController" scope="session">
        <property name="catalogService">
            <ref bean="catalogService"/>
        </property>
    </bean>
   
</beans>


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>   
   

  • Add the DelegatingVariableResolver and any Spring beans (i.e. catalogService) referenced as JSF Managed Bean (i.e. ItemController) properties  to the faces-config.xml : 
Code Sample from: faces-config.xml

  <application>
    <variable-resolver>
    org.springframework.web.jsf.DelegatingVariableResolver 
    </variable-resolver>
 </application>
 <managed-bean>
    <managed-bean-name>item</managed-bean-name>
      <managed-bean-class>
         sessionpagination.ItemController
      </managed-bean-class>
    <managed-bean-scope>session</managed-bean-scope>
     <managed-property>
          <property-name>catalogService</property-name>
          <value>#{catalogService}</value>
    </managed-property>
 </managed-bean>



References




Bookmark blog post: del.icio.us del.icio.us Digg Digg DZone DZone Furl Furl Reddit Reddit
Comments
Comments are listed in date ascending order (oldest first)

  • I also wrote an example like this using Spring 2, a4j, richfaces, hibernate-based jpa (not toplink) with 1 more feature which is data can be sorted by columns. So my questions are not about the techniques:

    1. If we use Spring 2, JSF and JPA, why is Glassfish chosen but not something "lighter" like Tomcat or Jetty?

    2. This is an article about Spring, JSF, JPA, but I'd like to ask your opinion about something else (so this question must be off-topic). If you use Glassfish, are you going to use Spring, JSF, JPA and then Spring WebFlow (when you need conversation, flow scopes) and then Acegi (when you need authorization and authentication). There's is an intergration between acegi and jsf, but it's, in my opinion, not famous as acegi & jsp (so I don't know how well it performs). Thus, is it better if Seam is chosen to replace Spring, Spring WebFlow and Acegi (and we'll be "closer" to the standard")?

    Posted by: dxxvi on June 20, 2007 at 01:41 PM

  • hi, I wrote this to show a sample app using spring with glassfish, because sometimes I got the question why should I use Java EE/glassfish instead of Spring/Tomcat , so I wanted to show its not either or , you can use them together. Interface21 (the company behind the spring framework) is a glassfish partner.
    1) Why is Tomcat or Jetty "lighter" ? the application code is ~ the same for both, actually now Spring requires more xml files than Java EE. Glassfish has hot deploy and the startup time for V3 is supposed to be really fast. I don't really want to debate which is better because I'm not an expert on Tomcat, I think the choice depends on your requirements. Listening to Wotif.com talk at JavaOne they gave some good reasons why they chose Glassfish. Performance tests for Grizzly (the glassfish web container) are very good. With Glassfish you get Comet, HADB, OpenESB , BPEL...
    2) I haven't used WebFlow. I've implemented apps with j2ee web authentication ejb authorization ldap, jaas, servlet filter... I've only looked at Acegi, it looks interesting but I haven't looked at it with JSF. I think Seam is really neat, I plan on modifying my app for Seam next. Seam features are going into the Web Beans standard , see the JavaOne session Web Beans Update TS-4089. I don't think I can answer your questions completely, depends on the project, company....

    Posted by: caroljmcdonald on June 20, 2007 at 02:55 PM

  • Well the lighter is mostly regarding the startup times, most people especially in debugging mode (The Eclipse Hotplug often is the cause of this) have to start the app server lots of times every day for development, so getting good startup times is crucial, that is one of the reasons why many people develop under tomcat / jetty and then use another app server for deployment.

    Posted by: werpu on June 21, 2007 at 02:10 AM

  • right , yes right that does make testing your code faster. like I said there is hot deploy, and V3 is supposed to be lot faster startup.

    Posted by: caroljmcdonald on June 21, 2007 at 06:57 AM

  • Hi McDonald,
    After i create application follow your tutorial, I get the following error:
    2007-07-06 11:53:47,806 ERROR [org.apache.catalina.core.ContainerBase.[Catalina].[localhost].[/springpoc].[Faces Servlet]] - Servlet.service() for servlet Faces Servlet threw exception
    java.lang.IllegalArgumentException: Unknown entity bean class: class net.j2mm.springpoc.dao.domain.Item, please verify that this class has been marked with the @Entity annotation.
    at oracle.toplink.essentials.internal.ejb.cmp3.base.EntityManagerImpl.findInternal(EntityManagerImpl.java:291)
    at oracle.toplink.essentials.internal.ejb.cmp3.EntityManagerImpl.find(EntityManagerImpl.java:133)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
    at java.lang.reflect.Method.invoke(Method.java:585)
    at org.springframework.orm.jpa.SharedEntityManagerCreator$SharedEntityManagerInvocationHandler.invoke(SharedEntityManagerCreator.java:180)
    at $Proxy14.find(Unknown Source)
    at net.j2mm.springpoc.service.CatalogDAO.getItem(CatalogDAO.java:46)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
    at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:39)
    at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25)
    at java.lang.reflect.Method.invoke(Method.java:585)
    at org.springframework.aop.support.AopUtils.invokeJoinpointUsingReflection(AopUtils.java:296)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.invokeJoinpoint(ReflectiveMethodInvocation.java:177)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:144)
    at org.springframework.dao.support.PersistenceExceptionTranslationInterceptor.invoke(PersistenceExceptionTranslationInterceptor.java:138)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:166)
    at org.springframework.transaction.interceptor.TransactionInterceptor.invoke(TransactionInterceptor.java:107)
    at org.springframework.aop.framework.ReflectiveMethodInvocation.proceed(ReflectiveMethodInvocation.java:166)
    at org.springframework.aop.framework.JdkDynamicAopProxy.invoke(JdkDynamicAopProxy.java:204)
    at $Proxy17.getItem(Unknown Source)
    at net.j2mm.springpoc.web.action.ItemController.getTesting(ItemController.java:69)
    at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)

    IS there anyone have such problem?
    Thanks for your help

    Posted by: jyzhou817 on July 05, 2007 at 08:58 PM

  • Hi, I don't know what the problem is. With Netbeans you can generate the Entity Classes and the Persistence Unit from the DB tables. Did you try that? You can post glassfish questions here http://forums.java.net/jive/forum.jspa?forumID=56

    Posted by: caroljmcdonald on July 06, 2007 at 06:57 AM

  • I wrote FacesGoodies, to give a starting point, when using JSF+Spring+JPA

    FacesGoodies uses (check out the trunk):
    JSF 1.2 (Apache MyFaces 1.2.0-SNAPSHOT), Trinidad 1.2.1, Facelets, Shale, Spring 2.0, JPA (Java Persistence API) and Toplink Essentials

    FacesGoodies

    Posted by: mwessendorf on July 09, 2007 at 02:18 AM

  • Hi, br/
    Thanks for your reply.
    Actually, I can unit test the DAO by extends AbstractJpaTests. the result is correct. br/
    But, when I try to deploy it in tomcat, I get the error as what i posted.
    br/
    my environment is: tomcat 5.5.23, mysql 5.0
    I am struggling for this problem for quite few days. Is it because of JSF?

    Thanks

    Posted by: jyzhou817 on July 09, 2007 at 03:02 AM

  • Hi Jyzhou817

    I guess your issue is using



    Try:



    There is also a special module for Tomcat.
    Perhaps checking out FacesGoodies, does help as well

    Posted by: mwessendorf on July 09, 2007 at 03:15 AM


  • ok...

    try:
    org.springframework.instrument.classloading.SimpleLoadTimeWeaver

    instead of
    org.springframework.instrument.classloading.glassfish.GlassFishLoadTimeWeaver

    for the loadTimeWeaver

    Posted by: mwessendorf on July 09, 2007 at 03:15 AM

  • Hi, br/
    Thanks for your reply.
    Actually, I can unit test the DAO by extends AbstractJpaTests. the result is correct. br/
    But, when I try to deploy it in tomcat, I get the error as what i posted.
    br/
    my environment is: tomcat 5.5.23, mysql 5.0
    I am struggling for this problem for quite few days. Is it because of JSF?

    Thanks

    Posted by: jyzhou817 on July 09, 2007 at 03:34 AM

  • Hi,

    Thanks very much.

    I am using org.springframework.instrument.classloading.ReflectiveLoadTimeWeaver
    and I tries org.springframework.instrument.classloading.SimpleLoadTimeWeaver
    also. Still the same result.

    Thanks

    Posted by: jyzhou817 on July 09, 2007 at 03:36 AM

  • Hi,
    Could you please attach the jars you used when deploy to glassfish server?

    when i deploy it to glassfish, i get the following error:

    [#|2007-07-13T10:15:22.004+0800|WARNING|sun-appserver-pe9.0|javax.enterprise.resource.webcontainer.jsf.lifecycle|_ThreadID=19;_ThreadName=httpWorkerThread-8080-1;_RequestID=499f4b4c-4d0c-4191-bf99-c19e7ba6b1db;|executePhase(RENDER_RESPONSE 6,com.sun.faces.context.FacesContextImpl@11c5809) threw exception
    javax.faces.FacesException: org.apache.jasper.JasperException: jsp.error.beans.property.conversion
    at com.sun.faces.context.ExternalContextImpl.dispatch(ExternalContextImpl.java:418)
    at com.sun.faces.application.ViewHandlerImpl.executePageToBuildView(ViewHandlerImpl.java:480)
    at com.sun.faces.application.ViewHandlerImpl.renderView(ViewHandlerImpl.java:125)
    at com.sun.faces.lifecycle.RenderResponsePhase.execute(RenderResponsePhase.java:133)
    at com.sun.faces.lifecycle.LifecycleImpl.phase(LifecycleImpl.java:244)
    at com.sun.faces.lifecycle.LifecycleImpl.render(LifecycleImpl.java:140)
    at javax.faces.webapp.FacesServlet.service(FacesServlet.java:245)
    at org.apache.catalina.core.ApplicationFilterChain.servletService(ApplicationFilterChain.java:397)
    at org.apache.catalina.core.StandardWrapperValve.invoke(StandardWrapperValve.java:278)
    at org.apache.catalina.core.StandardPipeline.doInvoke(StandardPipeline.java:566)
    at org.apache.catalina.core.StandardPipeline.invoke(StandardPipeline.java:536)
    at org.apache.catalina.core.StandardContextValve.invokeInternal(StandardContextValve.java:240)
    at org.apache.catalina.core.StandardContextValve.invoke(StandardContextValve.java:179)
    at org.apache.catalina.core.StandardPipeline.doInvoke(StandardPipeline.java:566)
    at com.sun.enterprise.web.WebPipeline.invoke(WebPipeline.java:73)
    at org.apache.catalina.core.StandardHostValve.invoke(StandardHostValve.java:182)
    at org.apache.catalina.core.StandardPipeline.doInvoke(StandardPipeline.java:566)
    at com.sun.enterprise.web.VirtualServerPipeline.invoke(VirtualServerPipeline.java:120)
    at org.apache.catalina.core.ContainerBase.invoke(ContainerBase.java:939)
    at org.apache.catalina.core.StandardEngineValve.invoke(StandardEngineValve.java:137)
    at org.apache.catalina.core.StandardPipeline.doInvoke(StandardPipeline.java:566)
    at org.apache.catalina.core.StandardPipeline.invoke(StandardPipeline.java:536)
    at org.apache.catalina.core.ContainerBase.invoke(ContainerBase.java:939)
    at org.apache.coyote.tomcat5.CoyoteAdapter.service(CoyoteAdapter.java:239)
    at com.sun.enterprise.web.connector.grizzly.ProcessorTask.invokeAdapter(ProcessorTask.java:667)
    at com.sun.enterprise.web.connector.grizzly.ProcessorTask.processNonBlocked(ProcessorTask.java:574)
    at com.sun.enterprise.web.connector.grizzly.ProcessorTask.process(ProcessorTask.java:844)
    at com.sun.enterprise.web.connector.grizzly.ReadTask.executeProcessorTask(ReadTask.java:287)
    at com.sun.enterprise.web.connector.grizzly.ReadTask.doTask(ReadTask.java:212)
    at com.sun.enterprise.web.connector.grizzly.TaskBase.run(TaskBase.java:252)
    at com.sun.enterprise.web.connector.grizzly.WorkerThread.run(WorkerThread.java:75)
    Caused by: org.apache.jasper.JasperException: jsp.error.beans.property.conversion
    at org.apache.jasper.runtime.JspRuntimeLibrary.getValueFromPropertyEditorManager(JspRuntimeLibrary.java:900)
    at org.apache.jsp.item.List2_jsp._jspx_meth_h_messages_0(List2_jsp.java:150)
    at org.apache.jsp.item.List2_jsp._jspx_meth_f_view_0(List2_jsp.java:117)
    at org.apache.jsp.item.List2_jsp._jspService(List2_jsp.java:81)
    at org.apache.jasper.runtime.HttpJspBase.service(HttpJspBase.java:111)
    at javax.servlet.http.HttpServlet.service(HttpServlet.java:820)
    at org.apache.jasper.servlet.JspServletWrapper.service(JspServletWrapper.java:353)
    at org.apache.jasper.servlet.JspServlet.serviceJspFile(JspServlet.java:412)
    at org.apache.jasper.servlet.JspServlet.service(JspServlet.java:318)
    at javax.servlet.http.HttpServlet.service(HttpServlet.java:820)
    at org.apache.catalina.core.ApplicationFilterChain.servletService(ApplicationFilterChain.java:397)
    at org.apache.catalina.core.ApplicationDispatcher.doInvoke(ApplicationDispatcher.java:850)
    at org.apache.catalina.core.ApplicationDispatcher.invoke(ApplicationDispatcher.java:697)
    at org.apache.catalina.core.ApplicationDispatcher.processRequest(ApplicationDispatcher.java:532)
    at org.apache.catalina.core.ApplicationDispatcher.doForward(ApplicationDispatcher.java:465)
    at org.apache.catalina.core.ApplicationDispatcher.forward(ApplicationDispatcher.java:353)
    at com.sun.faces.context.ExternalContextImpl.dispatch(ExternalContextImpl.java:413)
    ... 30 more

    Thanks alot.

    Posted by: jyzhou817 on July 12, 2007 at 07:58 PM

  • HI, I uploaded the .ear file to
    https://techdayscode.dev.java.net/servlets/ProjectDocumentList?folderID=7555

    Posted by: caroljmcdonald on July 12, 2007 at 08:22 PM

  • Thanks alot.

    Posted by: jyzhou817 on July 12, 2007 at 08:35 PM


  • I follow your example
    and was able to get Spring beans injection into the
    JSF container. I am trying to use Seam annotation instead of managed-bean
    definition in the faces-context.xml. So instead of

     

    <managed-bean>
        <managed-bean-name>item</managed-bean-name>
          <managed-bean-class>
             sessionpagination.ItemController
          </managed-bean-class>
        <managed-bean-scope>session</managed-bean-scope>
         <managed-property>
              <property-name>catalogService</property-name>
              <value>#{catalogService}</value>
        </managed-property>
     </managed-bean>

     

    I tried to do something like this in the class:

     

    @Scope(ScopeType.SESSION)

    @Name(“item”)

    public class ItemController implements Serializable
    {
    @In(“#{catalogService }”)
      private CatalogService catalogService ;

      private String test;


      public void setCatalogService(CatalogService
    catalogService) {
            this.catalogService
    = catalogService; 
      }

     

    public String getTest() {

    return “testing”;

    }

    }

     

    But I was not able to
    use this bean on the jsf pages. Looks like its not instantiated in the JSF container. Is there any
    other settings or configuration I have to do to get it injected by Seam? Thank
    you.

     

    Posted by: paulkim on July 27, 2007 at 07:22 AM

  • I haven't tried seam & spring together. If you are going to use Seam on Glassfish you will need the Seam jars and configuration in your project (see my or brian leonard's blog on seam on glassfish).

    Posted by: caroljmcdonald on July 27, 2007 at 07:31 AM

  • Regarding the "the lighter is mostly regarding the startup times", check out this information from Raible's blog:
    http://raibledesigns.com/rd/category/Java


    Startup Time with no applications deployed:

    Tomcat 6: 3 seconds
    GlassFish 2: 8 seconds
    Startup Time with AppFuse 2.0 (Struts + Hibernate version) as a WAR

    Tomcat 6: 15 seconds
    GlassFish 2: 16 seconds

    comparison of how long it takes for both servers to pick up a new WAR (and start the application) when it's dropped into their autodeploy directories.

    Tomcat 6: 14-16 seconds
    GlassFish 2: 9 seconds

    Posted by: caroljmcdonald on September 24, 2007 at 07:11 AM

  • Hi Carol i am having problem saving data using JSF Spring JPA
    I tried writing all code here but it is comin all on one line


    I have raised the same question in Spring forum without help
    The link is as below

    http://forum.springframework.org/showthread.php?t=47355


    Can you please help

    Posted by: purnendu9 on December 12, 2007 at 11:43 PM

  • I haven't had a chance to try out Spring 2.5 with Glassfish yet. This question would be better answered by a spring forum

    Posted by: caroljmcdonald on December 13, 2007 at 07:18 PM

  • Comment

    Posted by: andreakendall on January 09, 2008 at 03:25 PM

  • I am having problems getting this to run. I get a java.lang.RuntimeException: java.lang.RuntimeException: javax.naming.NameNotFoundException

    I have set this up using Netbeans 6.0 and Spring 2.5.

    I also created the database in Netbeans 6.0 and can view jdbc:derby://localhost:1527/pet-catalog tables and there associated data.

    For reference here is the full expeption shown on the Glassfish debug tab

    naming.bind
    Null component com.sun.appserv:type=JspMonitor,name=jsp,WebModule=//server/SpringJPA,J2EEApplication=null,J2EEServer=server
    WEB0207: Error starting web context StandardEngine[com.sun.appserv].StandardHost[server].StandardContext[/SpringJPA] on virtual server server
    java.lang.RuntimeException: java.lang.RuntimeException: javax.naming.NameNotFoundException
    at com.sun.enterprise.web.WebModuleListener.loadPersistenceUnits(WebModuleListener.java:193)
    at com.sun.enterprise.web.WebModuleListener.lifecycleEvent(WebModuleListener.java:168)
    at org.apache.catalina.util.LifecycleSupport.fireLifecycleEvent(LifecycleSupport.java:143)
    at org.apache.catalina.core.StandardContext.start(StandardContext.java:5086)
    at com.sun.enterprise.web.WebModule.start(WebModule.java:327)
    at com.sun.enterprise.web.LifecycleStarter.doRun(LifecycleStarter.java:58)
    at com.sun.appserv.management.util.misc.RunnableBase.runSync(RunnableBase.java:296)
    at com.sun.appserv.management.util.misc.RunnableBase.run(RunnableBase.java:330)
    at java.util.concurrent.Executors$RunnableAdapter.call(Executors.java:441)
    at java.util.concurrent.FutureTask$Sync.innerRun(FutureTask.java:303)
    at java.util.concurrent.FutureTask.run(FutureTask.java:138)
    at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:885)
    at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:907)
    at java.lang.Thread.run(Thread.java:619)
    Caused by: java.lang.RuntimeException: javax.naming.NameNotFoundException
    at com.sun.enterprise.server.PersistenceUnitInfoImpl._getJtaDataSource(PersistenceUnitInfoImpl.java:283)
    at com.sun.enterprise.server.PersistenceUnitInfoImpl.(PersistenceUnitInfoImpl.java:116)
    at com.sun.enterprise.server.PersistenceUnitLoaderImpl.load(PersistenceUnitLoaderImpl.java:121)
    at com.sun.enterprise.server.PersistenceUnitLoaderImpl.load(PersistenceUnitLoaderImpl.java:84)
    at com.sun.enterprise.web.WebModuleListener.loadPersistenceUnits(WebModuleListener.java:190)
    ... 13 more
    Caused by: javax.naming.NameNotFoundException
    at com.sun.enterprise.naming.TransientContext.resolveContext(TransientContext.java:268)
    at com.sun.enterprise.naming.TransientContext.lookup(TransientContext.java:191)
    at com.sun.enterprise.naming.SerialContextProviderImpl.lookup(SerialContextProviderImpl.java:74)
    at com.sun.enterprise.naming.LocalSerialContextProviderImpl.lookup(LocalSerialContextProviderImpl.java:111)
    at com.sun.enterprise.naming.SerialContext.lookup(SerialContext.java:339)
    at javax.naming.InitialContext.lookup(InitialContext.java:392)
    at com.sun.enterprise.connectors.ConnectorResourceAdminServiceImpl.lookup(ConnectorResourceAdminServiceImpl.java:196)
    at com.sun.enterprise.connectors.ConnectorRuntime.lookupPMResource(ConnectorRuntime.java:1098)
    at com.sun.enterprise.server.PersistenceUnitInfoImpl.lookupPMDataSource(PersistenceUnitInfoImpl.java:294)
    at com.sun.enterprise.server.PersistenceUnitInfoImpl._getJtaDataSource(PersistenceUnitInfoImpl.java:281)
    ... 17 more

    Posted by: andreakendall on January 09, 2008 at 03:36 PM

  • A few more things.

    The setup.xml file does not build as shipped it references an unknown tools dependancy.

    I do not see any SpringJPA-war module. Should I download the Spring ear and get the .war from that?

    Posted by: andreakendall on January 09, 2008 at 03:45 PM

  • I replaced this ear version with a version that just has a .war for my blog on spring 2.5, jsf, and jpa. Please try again following the instructions on the newer blog entry. From your error looks like there is a problem with the persistence unit.

    Posted by: caroljmcdonald on January 09, 2008 at 04:04 PM

  • Great article - just what I was looking for - thx Carol

    Posted by: amoore_qualcomm_com on March 19, 2008 at 09:48 AM

  • Hi Carol
    When trying to setup the sample application I ran into the problem that has been mentioned earlier i.e. the setup.xml does not build as it cannot find the tools dependency.

    To fix this problem I have made changes to some files that are part of the setup directory. Download this jar and unjar it into the setup directory. Ensure that you have edited the setup/build.properties to have the value of javaee.home to point to the root of your GlassFish application server installation. Then you can run the command "ant -f setup.xml setup" or "ant -f setup.xml unsetup" from the setup directory successfully.

    Thanks
    Pramod Gopinath

    Posted by: pramodgo on April 16, 2008 at 04:49 PM

  • Hi Carol
    When I made the post somehow the href did not translate properly. The jar file can be found at : http://blogs.sun.com/pramodg/resource/spring/carol_SpringJPA.jar.

    Thanks
    Pramod

    Posted by: pramodgo on April 16, 2008 at 04:50 PM

  • Pramod, I added your setup fixes to the sample download zip

    Posted by: caroljmcdonald on April 19, 2008 at 11:30 AM

  • Nice article :-)

    One consideration -- I don't think the ItemController bean needs to be in your application.xml file. The ContextLoaderListener will create the catalogService bean and the DelegatingVariableResolver will automagically inject the ref to catalogService into your ItemController. (YMMV)

    Posted by: netminkey on June 04, 2008 at 06:51 AM

  • you are right, actually I already took the ItemController bean out of the application.xml file in the code, I need to update the blog text.

    Posted by: caroljmcdonald on June 04, 2008 at 07:02 AM




This work is licensed under a Creative Commons License.
Creative Commons License

Powered by
Movable Type 3.01D
 Feed java.net RSS Feeds
Feedback  | FAQ  | Press | Terms of Use
Privacy  |  Trademarks | Site Map
 
Your use of this web site or any of its content or software indicates your agreement to be bound by these Terms of Participation.
 
Copyright © 1995-2008 Sun Microsystems, Inc.
Oreilly LogoCollabnet Logo
Powered by Sun Microsystems, Inc.,
O'Reilly and CollabNet