Using JPA with Spring in Java

Generation ECC200 in Java Using JPA with Spring

bid on an item, and it uses the EAOs to manipulate the entities. You can use the EAOs in your service classes, and the EAOs can be injected into the POJOs with Spring s setter injection as follows:

public class BidServiceBean implements BidService protected ItemEAO itemEAO; protected BidEAO bidEAO ; public BidServiceBean() { } //Inject Instances of Item and BidEAO public void setItemEAO(ItemEAO itemEAO) { this.itemEAO = itemEAO; } public void setBidEAO(BidEAO ) { this.bidEAO = bidEAO; } public Long addBid(String userId, Long itemId, Double bidPrice) { ... } } {

The BidServiceBean class looks similar to the PlaceBidBean class the only remarkable difference is that it is a POJO with no annotations, JNDI lookup, or use of EAO factory code of any kind. If you are new to Spring, you must be wondering, If all classes are POJOs, then how does the framework know about the EntityManager, and how does it inject instances of EntityManager It s all based on a little Spring configuration magic, which we dive into next.

The real power of Spring comes from how it configures services via dependency injection. For our example this means you need to configure the EntityManagerFactory. To coax ActionBazaar to work with Spring, you ll need the configuration shown in listing 16.2.

Listing 16.2 Spring configuration to use JPA Configures EntityManager <bean id = "entityManager" class = "org.springframework.jndi.JndiObjectFactoryBean"> <property name = "jndiName" value = "java:comp/env/actionBazaar"/>

Defines Spring EAO <bean id = "bidEAO" class = "actionbazaar.persistence.eao.BidSpringEAO" autowire = "byType"> <property name = "entityManager" ref = "entityManager"/> </bean>

<bean id = "bidService" class = "actionbazaar.buslogic.BidServiceBean"> <property name = "bidEAO"> <ref bean = "bidEAO"/> </property> </bean>

Even if you re not familiar with Spring, you can probably figure out what s going on in this configuration file (actionBazaar-service.xml). The first bean instance, entityManager, injects an instance of the EntityManager by retrieving it from the JNDI namespace when it is referenced from another bean instance. The next bean, bidEAO, asks Spring to automatically wire it to use the previous entityManager. The final bean, bidService, requests that Spring inject the bidEAO bean as the implementation for it to use at runtime. Configuring Spring to use the EntityManager Because Spring is a lightweight container, it can work either inside a Java EE container or independently. Spring can use a container- or an application-managed EntityManager either inside or outside the container. While you re using Spring within a Java EE container, it acts as a proxy between the container and the application and injects an EntityManager or EntityManagerFactory when your application needs it. That way, you don t have to worry about including extra JPA code. In this chapter we primarily focus on Spring as a framework within the Java EE container. This means you have to configure Spring so it can retrieve an EntityManager from the Java EE container and inject an instance of an EntityManager whenever you use a JpaTemplate. If you re using Spring within a Java EE 5 container, you must use either the JndiObjectFactoryBean or Spring 2.0 s new jee:jndi-lookup mechanism to wire an instance of EntityManager (as we did in listing 16.2). If you want the new Spring 2.0 configuration instead of JndiObjectFactoryBean, then use this configuration:

Remember, this notation works only if you ve upgraded to version 2 of Spring. Using Spring outside Java EE container with JPA As we discussed earlier, Spring 2.0 acts as a container and supports the container-managed EntityManager with JPA. The Spring container manages the persistence unit. You have to use LocalContainerEntityManagerFactoryBean to wire an entityManagerFactory. The LocalContainerEntityManagerFactoryBean reads the persistence.xml packaged in the application to configure the persistence unit by using the data source supplied. It can also perform load-time weaving to search for annotated entity classes. Here is an example configuration of the container-managed EntityManager:

<beans> <bean id = "entityManagerFactory" class = "org.springframework.orm.jpa. LocalContainerEntityManagerFactoryBean"> ... <property name = "loadTimeWeaver"> <bean class = "org.springframework.instrument.classloading. SimpleLoadTimeWeaver"/> </property> </bean> <bean id = "bidEAO" class = "actionbazaar.persistence.eao.BidSpringEAO" autowire = "byType"> <property name = "entityManagerFactory" ref = "entityManagerFactory"/> </bean> </beans>

For more information, refer to the Spring documentation. If you re using Spring outside a Java EE container, you can use a LocalEntityManagerFactory and your configuration will look like this:

<bean id = "entityManagerFactory" class = "org.springframework.orm.jpa.LocalEntityManagerFactoryBean"> ... </bean>