Structure webapp using JSF and Eclipslink

[Andrew Dambrosio]

I've be asked to create a new website and I have to use JSF (Primefaces) and Eclipselink JPA. I haven't created an application from scratch for a couple of years and I've forgotten the best way to structure the application.
Is the following tutorial a go example of setting everything up?
http://wiki.eclipse.org/EclipseLink/Examples/JPA/JSF_Tutorial

I can't figure out if I need to use Spring. Personally I can't get my head around Spring and don't see how it can benefit my app. If I am wrong, let me know.

I'm also trying to get my head around bean injection. I don't see the point of it. The current website that I've been maintaining doesn't use it. I've personally used it in the past but can't remember it's purpose.

I've searched for these answers but can't find anything.

Can someone help

[Tim Holloway]

It's not a good idea to specifically warp your project to fit a specific IDE. IDEs are notoriously subject to change. For my projects, it's a requirement that I be able to do a full build on a machine without any IDE at all, so I typically use Maven. Which, alas, also warps projects, but is less subject to being wrecked by new versions. Eclipse can adapt pretty much any project to be Maven-friendly while still getting the benefits of the IDE.

I'm going to reverse your questions, since it may make more sense that way.

JSF is built using principles of the Inversion of Control (IoC) paradigm. Using IoC, instead of program components going out and looking for other program components (for example, Service Locators), the IoC framework delivers those components to the seeking components. The advantage to this is that you don't have to explicitly code the seeking logic into components. That means that JSF components can often be implemented as POJOs, which makes them more re-usable, easier to test in isolation, and more independent of the internals of the subsystems that they are working with.

JSF itself, however, only provides IoC for Managed Beans. It doesn't really support non-JSF beans. The Spring Framework, however, does, and by means of the appropriate JSF plugin, you can integrate the Spring IoC system and the JSF IoC system seamlessly, thus providing "one-stop-shopping" for bean injection.

My primary use for Spring in most JSF webapps is to manage the ORM. I'm using JPA, and Spring provides services such that the grunt work of managing transactions, handling exceptions and other tedious and repetitive jobs is done by Spring itself. I also leverage it to make systems more testable, though. For example, it's not uncommon for my webapp to create and send emails. By implementing the email service as a Spring-injected component, I can use a dummy mailer for testing and switch to the live mailer for production. Since Spring is handling the wiring-together of my beans, it's a minor change to the Spring config file to do this instead of a Java source code change.

[Andrew Dambrosio]

Thanks,
I think I'm starting to understand.
I came across this example which uses hibernate.
http://technology-for-human.blogspot.com.au/2011/04/jsf-2-spring-3-jpa-hibernate-3.html

I can't figure out how the EntityManager is set though.

Any links to a tutorial that uses JSF, JPA and Spring would be much approciated. I can't find anything.

[Tim Holloway]

Pretty much if you know Spring JPA, you can easily adapt it to work with JSF. JSF makes no unusual demands of Spring JPA.

Spring itself constructs and injects the EntityManagers into the DAO objects of your ORM layer. I actually maintain 2 separate ORM layers myself (3, if you count the Object Model as a layer).

The DAO layer handles single-table operations. Brute-force mechanics such as "find", "save", "delete". DAO objects have EntityManagers injected into them.

The Service layer handles business-aware operations. These operations typically retrieve and save "working sets" of related objects. I have, for example, a Bus Route webapp where there's a service for editing routes. The Route object contains a collection of Bus Stop objects. They're all fetched and stored as a unit in a single database transaction. My webapps maintain their transactional boundaries at the external methods of the service components.

There are 2 ways to manage transactions and object model attachment in a webapp. It is very common for developers to configure in a component that keeps ORM objects attached for the life of an HTTP request/response cycle. I don't do that myself, however, I do it the other way, which is to make the service objects return detached objects.

The reason I prefer detached objects for the higher levels of the webapp have to do with the fact that if they're detached, I don't have to worry about some apparently-unrelated function at the rendering phase of the request/response cycle accidentally nuking data. Since the data is detached, any damage done won't leak back to the database. Plus, this keeps persistence code - both explicit and implied (lazy-fetch) out of the rendering phase. I pay a price for that, since it means I must precisely determine my working sets instead of simply being able to go grab stuff at will, but I sleep better at night.

Beyond that, there's a simple faces-config.xml option that joins the EL resolver for Spring to the EL resolved for JSF. It looks like this:

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

With this component wired into JSF, EL references to Spring JPA beans can be made in the same way as EL references to JSF managed objects. So you can use ManagedProperty to inject the ORM services components into the JSF backing beans for their use in persistence.

JPA, Spring and JSF are all fairly complex (and often quirky) systems to learn, but they make industrial-grade webapps a lot easier to create and maintain.

[Andrew Dambrosio]

Thanks for you help.
I came across the following tutorial which I found gave me a good visual of how everything works.

http://www.javacodegeeks.com/2012/04/jsf-2-primefaces-3-spring-3-hibernate-4.html

[john lazeraski]

Tim, been years since I used Spring, never used Hibernate. But given that JEE 6 seems to have stemmed from Spring and Hibernate, does Spring still require all the xml-from-hell configuration stuff? Or is it more annotation friendly like JEE6/7 is for configuring things.. like injecting resources, beans, etc?

[Tim Holloway]

You've missed a lot. Spring is definitely well-supplied with annotations these days and wiring JPA resources into JSF is a dream. And not only Spring, since Hibernate JPA is also annotatable without resorting to XML.

My current webapps have very small Spring config files that mostly handle the EntitityManager tie-ins to the webapp's container-supplied DataSources (via JNDI). Everything else is annotated, and often autowired as well.

You can still use XML, and you can use XML to override annotations so that you can re-use or customize components without touching source code, but for general purposes, you can annotate and keep everything simple and in one place.

[john lazeraski]

Nice! I figured they must have gone that direction. I am still torn though.. which is better JEE6 (and now 7) or using Spring/Hibernate. Most shops I've interviewed with seem to lean heavily towards Spring and Hibernate, but JEE 6/7 is so nice and at least for me GlassFish 4 is rock solid and easy to work with. Unzip, create a domain, start it, ready to deploy into it with all the JEE services ready to go. I went back to using @ManagedBean because I wanted to make sure my app could run in Tomcat if need be, but then all my @EJB stuff would no longer work, hence why I want to start looking back at Spring/Hibernate to understand them as well so that I can deploy my app in Tomcat (or Jetty) and not need the EJB layer or have to deploy a separate EJB tier into a JBoss or Glassfish container and work with remote calls and such. Seems like Tomcat + Servlet/JSF + Spring/Hibernate offer a pretty solid solution if you don't want the full JEE stack.

[Tim Holloway]

"JEE" isn't particularly well-loved these days. Although I think that depends on how you define "JEE". JSF is part of JEE and I like it. I also like JPA, which is a subset of EJB3.

The main difference between Spring JPA and EJB3 is how the entityManager gets injected. In JEE/EJB, the EntityManager is injected directly by the container - which rules out Tomcat. In Spring/JPA, Spring itself handles the injection. So the amount of change required to go from one to the other is fairly slight.

[Andrew Dambrosio]

Tim,
I've started creating the business logic and DAO classes in my application.
I'm trying to set up me applicationContext.xml.
I need to set it up so it uses Glassfish connection pooling and connects to a MSSQL 2008 database using Eclipselink JPA.
I can't find an example anywhere of such a configuration. Do you have any examples?
thanks

[Tim Holloway]

I don't have anything specifically like what you are using, but here's a sample from one of my apps running under Tomcat:

    <!-- -->
    <bean id="myDataSource"
        class="org.springframework.jndi.JndiObjectFactoryBean"
    >
        <property name="jndiName" value="java:comp/env/jdbc/localDB" />
    </bean>

    <!-- Persistence Definitions -->
    <bean id="entityManagerFactory"
        class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
    >
        <property name="dataSource" ref="myDataSource" />
        <property name="loadTimeWeaver">
            <bean
                class="org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver" />
        </property>
        <property name="packagesToScan"
            value="com.mousetech.app32.persistence.model" />
        <property name="jpaPropertyMap" ref="jpaPropertyMap" />
        <property name="jpaVendorAdapter">
            <bean
                class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"
            >
                <property name="showSql" value="false" />
                <property name="generateDdl" value="true" />
                <property name="databasePlatform"
                    value="org.hibernate.dialect.DB2Dialect" />
            </bean>
        </property>
    </bean>

    <util:map id="jpaPropertyMap">
        <entry key="hibernate.hbm2ddl.auto" value="update" />
        <entry key="hibernate.dialect" value="org.hibernate.dialect.DB2Dialect" />
    </util:map>

    <bean
        class="org.springframework.orm.jpa.support.PersistenceAnnotationBeanPostProcessor" />
    <bean id="transactionManager"
        class="org.springframework.orm.jpa.JpaTransactionManager"
    >
        <property name="entityManagerFactory" ref="entityManagerFactory" />
    </bean>
    <tx:annotation-driven />

This is for Tomcat, so it's not using EJB-injected entity management. If you need that, the Spring docs should cover it. I've also included some of the support beans that make life more pleasant by automatically scanning and wiring persistence components together.

This probably isn't totally clean - I think the persistence manager is looking in places it doesn't need to, but it has mutated over time and I'm too cowardly to go in and meddle with it when I have bigger problems to address. It works, that's all I can say.

[Andrew Dambrosio]

I've had a look at this spring JPA tutorial
http://spring.io/guides/gs/accessing-data-jpa/

Why does this tutorial not require an applicationContext.xml file?
The last time I did a spring project (2010), you had to specify all the beans in the applicationContext.xml file. This does not seem to be required anymore by using the @AutoWired annotation?

[Andrew Dambrosio]

See my code below. I've set up a test. All I'm trying to do at the moment is make sure I can retrieve data from the database (I haven't included the interfaces). Can you provide any tips?
I'm using spring 3.1.
There is something wrong with the configuration. I'm getting the following error:
Exception in thread "main" org.springframework.beans.factory.BeanDefinitionStoreException: Failed to read candidate component class: URL [jar:file:/C:/Workspace/test.jar!/com/mb/AAATestBean.class]; nested exception is java.lang.ArrayStoreException: sun.reflect.annotation.TypeNotPresentExceptionProxy

My test bean to output the brands in the database:

package com.mb;

import com.DAO.BrandDAO;
import com.model.Brand;
import java.util.ArrayList;
import java.util.List;
import org.apache.log4j.Logger;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@EnableTransactionManagement
@EnableAutoConfiguration
public class AAATestBean {
    private static final String SVN_ID = "$id$";
    private static final Logger log = Logger.getLogger (AAATestBean.class);

    public AAATestBean() {
    }
    
    @Bean
    BrandDAO brandDAO() {
        return new BrandDAO();
    }
            
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("WEB-INF/applicationContext.xml");

        
        
        BrandDAO brandDAO = ctx.getBean(BrandDAO.class);
        try {
            List<Brand> brandList = new ArrayList<Brand>();
            brandList = brandDAO.findBrandEntities();
            
            System.out.println("brandList size: " + brandList.size());
            
            for (Brand b : brandList) {
                System.out.println("BRAND: " + b.getBrandName());
            }
            
            
        } catch (Exception ex) {
            log.error("REVISIT e", ex);
        }
        
    }
}

Brand.java

package com.model;

import java.io.Serializable;
import java.util.List;
import javax.persistence.Basic;
import javax.persistence.Cacheable;
import javax.persistence.CascadeType;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.FetchType;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.NamedQueries;
import javax.persistence.NamedQuery;
import javax.persistence.OneToMany;
import javax.persistence.Table;

/**
 *
 * @author qt82701
 */
@Entity
@Table(name = "brand")
@Cacheable(true)
@NamedQueries({
    @NamedQuery(name = "Brand.findAll", query = "SELECT b FROM Brand b"),
    @NamedQuery(name = "Brand.findByBrandId", query = "SELECT b FROM Brand b WHERE b.brandId = :brandId"),
    @NamedQuery(name = "Brand.findByBrandName", query = "SELECT b FROM Brand b WHERE b.brandName = :brandName")})
public class Brand implements Serializable {
    private static final long serialVersionUID = 1L;
    @Id
    @Basic(optional = false)
    @GeneratedValue(strategy=GenerationType.IDENTITY)
    @Column(name = "brand_id")
    private Integer brandId;
    @Basic(optional = false)
    @Column(name = "brand_name")
    private String brandName;
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "brandId", fetch = FetchType.EAGER)
    private List<CmsPage> cmsPageList;
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "brandId", fetch = FetchType.EAGER)
    private List<EdmLink> edmLinkList;
    @OneToMany(cascade = CascadeType.ALL, mappedBy = "brandId", fetch = FetchType.EAGER)
    private List<Website> websiteList;

    public Brand() {
    }

    public Brand(Integer brandId) {
        this.brandId = brandId;
    }

    public Brand(Integer brandId, String brandName) {
        this.brandId = brandId;
        this.brandName = brandName;
    }

    public Integer getBrandId() {
        return brandId;
    }

    public void setBrandId(Integer brandId) {
        this.brandId = brandId;
    }

    public String getBrandName() {
        return brandName;
    }

    public void setBrandName(String brandName) {
        this.brandName = brandName;
    }

    public List<CmsPage> getCmsPageList() {
        return cmsPageList;
    }

    public void setCmsPageList(List<CmsPage> cmsPageList) {
        this.cmsPageList = cmsPageList;
    }

    public List<EdmLink> getEdmLinkList() {
        return edmLinkList;
    }

    public void setEdmLinkList(List<EdmLink> edmLinkList) {
        this.edmLinkList = edmLinkList;
    }

    public List<Website> getWebsiteList() {
        return websiteList;
    }

    public void setWebsiteList(List<Website> websiteList) {
        this.websiteList = websiteList;
    }

    @Override
    public int hashCode() {
        int hash = 0;
        hash += (brandId != null ? brandId.hashCode() : 0);
        return hash;
    }

    @Override
    public boolean equals(Object object) {
        // TODO: Warning - this method won't work in the case the id fields are not set
        if (!(object instanceof Brand)) {
            return false;
        }
        Brand other = (Brand) object;
        if ((this.brandId == null && other.brandId != null) || (this.brandId != null && !this.brandId.equals(other.brandId))) {
            return false;
        }
        return true;
    }

    @Override
    public String toString() {
        return "com.model.Brand[ brandId=" + brandId + " ]";
    }
    
}

BrandDAO

package com.DAO;

import com.DAO.iface.IBrandDAO;
import com.model.Brand;
import javax.persistence.Query;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Root;
import java.util.List;
import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

public class BrandDAO implements IBrandDAO {

    @PersistenceContext
    private EntityManager em;
    
    @Override
    public List<Brand> findBrandEntities() {
        return findBrandEntities(true, -1, -1);
    }

    @Override
    public List<Brand> findBrandEntities(int maxResults, int firstResult) {
        return findBrandEntities(false, maxResults, firstResult);
    }

    @Override
    public List<Brand> findBrandEntities(boolean all, int maxResults, int firstResult) {
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            cq.select(cq.from(Brand.class));
            Query q = em.createQuery(cq);
            if (!all) {
                q.setMaxResults(maxResults);
                q.setFirstResult(firstResult);
            }
            return q.getResultList();
        } finally {
            em.close();
        }
    }

    @Override
    public Brand findBrand(Integer id) {
        try {
            return em.find(Brand.class, id);
        } finally {
            em.close();
        }
    }

    @Override
    public int getBrandCount() {
        try {
            CriteriaQuery cq = em.getCriteriaBuilder().createQuery();
            Root<Brand> rt = cq.from(Brand.class);
            cq.select(em.getCriteriaBuilder().count(rt));
            Query q = em.createQuery(cq);
            return ((Long) q.getSingleResult()).intValue();
        } finally {
            em.close();
        }
    }
    
}

BrandBL

package com.BL;

import com.BL.iface.IBrandBL;
import com.DAO.iface.IBrandDAO;
import com.model.Brand;
import java.util.List;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.transaction.annotation.Transactional;

@Transactional(readOnly = true)
public class BrandBL implements IBrandBL {
    private static final Logger log = Logger.getLogger (BrandBL.class);
    
    @Autowired
    IBrandDAO brandDAO;

    @Override
    public List<Brand> findBrandEntities() {
        return brandDAO.findBrandEntities();
    }

    @Override
    public List<Brand> findBrandEntities(int maxResults, int firstResult) {
        return brandDAO.findBrandEntities(maxResults, firstResult);
    }

    @Override
    public List<Brand> findBrandEntities(boolean all, int maxResults, int firstResult) {
        return brandDAO.findBrandEntities(all, maxResults, firstResult);
    }

    @Override
    public Brand findBrand(Integer id) {
        return brandDAO.findBrand(id);
    }

    @Override
    public int getBrandCount() {
        return brandDAO.getBrandCount();
    }
    
}

persistence.xml

<?xml version="1.0" encoding="UTF-8"?>
<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">
  <persistence-unit name="DAOPU" transaction-type="RESOURCE_LOCAL">
      <mapping-file>META-INF/orm.xml</mapping-file>

    <shared-cache-mode>ENABLE_SELECTIVE</shared-cache-mode>
    <properties>
      <property name="javax.persistence.jdbc.url" value="jdbc:sqlserver://SERVER;databaseName=DATABASE"/>
      <property name="javax.persistence.jdbc.password" value="PASSWORD"/>
      <property name="javax.persistence.jdbc.driver" value="com.microsoft.sqlserver.jdbc.SQLServerDriver"/>
      <property name="javax.persistence.jdbc.user" value="USER"/>
    </properties>
  </persistence-unit>
</persistence>

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:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
       http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.1.xsd
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd 
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd"    
       xmlns:context="http://www.springframework.org/schema/context">
    

    <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"> 
        <property name="persistenceXmlLocation" value="/META-INF/persistence.xml" />
        <property name="persistenceUnitName" value="DAOPU" /> 
        <property name="dataSource" ref="dataSource" /> 

        <property name="jpaDialect">
            <bean class="org.springframework.orm.jpa.vendor.EclipseLinkJpaDialect" />
        </property>
        <property name="jpaVendorAdapter"> 
            <bean class="org.springframework.orm.jpa.vendor.EclipseLinkJpaVendorAdapter"> 
                <property name="generateDdl" value="true"/> 
                <property name="showSql" value="true" />
                <property name="databasePlatform" value="org.eclipse.persistence.platform.database.SQLServerPlatform" /> 
            </bean> 
        </property> 
    </bean> 
    
    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="driverClassName" value="com.microsoft.sqlserver.jdbc.SQLServerDriver" />
        <property name="url" value="jdbc:sqlserver://SERVER:1433;databaseName=DATABASE" />
        <property name="username" value="USER" />
        <property name="password" value="PASSWORD" />
    </bean>
     
    <!-- Enable the configuration of transactional behavior based on annotations -->
    <tx:annotation-driven transaction-manager="txManager"/>

    <!-- Transaction Manager is defined -->
    <bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager">
       <property name="entityManagerFactory" ref="entityManagerFactory"/>
    </bean>


    <bean class="org.springframework.orm.jpa.vendor.EclipseLinkJpaDialect">
    </bean>
    
    <context:component-scan base-package="com.*"></context:component-scan>
    
    <context:annotation-config/>
</beans>

[Tim Holloway]

That's WAY too much for people to read off the screen! You need to reduce it down to something manageable.