Using Spring to develop EJB 3.1

When developping EJB applications, you need to bootstrap an EJB container to run your EJBs. Before Java EE 6, EJB containers usually come bundled in full-blown JEE application servers, making the test and development of EJBs difficult and counter-productive. As of Java EE 6, the EJB specification comes with a new feature : an embedded API for EJB containers. This is a great step, but I found some limitations to this API (more on that later). That’s why I decided to code an stateless EJB (arguably the most commonly kind of EJB), test it with Spring and run it under Glasshfish.

Roadmap

The EJB will be at the heart of a very simple web application. It will allow to add and select contact entities. We’ll be using JPA and Derby for the persistence. We’ll also leverage the new web profile of Java EE, as the EJB will be distributed directly in the web application, along with the JPA persistence unit and a servlet (to display contacts).

The entity

Here is the code of the entity :

1. package com.zenika.contact.domain;
3. import javax.persistence.Entity;
4. import javax.persistence.GeneratedValue;
5. import javax.persistence.GenerationType;
6. import javax.persistence.Id;
8. @Entity
9. public class Contact {
11. @Id
12. @GeneratedValue(strategy=GenerationType.IDENTITY)
13. private Long id;
15. private String firstName,lastName;
17. public Contact() { }
19. public Contact(String firstName, String lastName) {
20. this();
21. this.firstName = firstName;
22. this.lastName = lastName;
23. }
25. // getters and setters…
26. }

The EJB

Here is the interface of the EJB :

1. package com.zenika.contact.service;
3. import java.util.List;
4. import com.zenika.contact.domain.Contact;
6. public interface ContactService {
8. /**
9.   * Contact creation.
10.   * @param contact
11.   * @return
12.   */
13. Contact create(Contact contact);
15. /**
16.   * Contact selection.
17.   * @return
18.   */
19. List<Contact> select();
21. }

Note this is a plain interface (not remote nor locale), because I’m used to coding against interface, but we could also use the corresponding EJB annotations if we needed to.
And now, the code of the EJB itself :

1. package com.zenika.contact.service.impl;
3. import java.util.List;
4. import javax.ejb.Stateless;
5. import javax.persistence.EntityManager;
6. import javax.persistence.PersistenceContext;
7. import com.zenika.contact.domain.Contact;
8. import com.zenika.contact.service.ContactService;
10. @Stateless
11. public class ContactServiceImpl implements ContactService {
13. @PersistenceContext(name=“contact”)
14. private EntityManager entityManager;
16. @Override
17. public Contact create(Contact contact) {
18. entityManager.persist(contact);
19. return contact;
20. }
22. @Override
23. public List<Contact> select() {
24. return entityManager.createQuery(“select c from Contact c”).getResultList();
25. }
26. }

The JPA configuration

The JPA configuration lies in the standard location, META-INF/persistence.xml:

1. <?xml version=“1.0” encoding=“UTF-8”?>
2. <persistence xmlns=“http://java.sun.com/xml/ns/persistence&#8221; version=“1.0”>
3. <persistence-unit name=“contact” transaction-type=“JTA”>
4. <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
5. <jta-data-source>jdbc/contactDS</jta-data-source>
6. <class>com.zenika.contact.domain.Contact</class>
7. <exclude-unlisted-classes />
8. <properties>
9. <property name=“eclipselink.ddl-generation” value=“drop-and-create-tables”/>
10. <property name=“eclipselink.logging.level” value=“INFO”/>
11. </properties>
12. </persistence-unit>
13. </persistence>

Note the persistence unit uses JTA transaction, EclipseLink (JPA 2.0 Reference Implementation, which ships with Glassfish 3.0) and a JNDI datasource.

The servlet

The servlet is only there to check that everything goes fine once the application has been deployed :

1. package com.zenika.contact.web;
3. import java.io.IOException;
4. import java.util.List;
6. import javax.ejb.EJB;
7. import javax.servlet.ServletException;
8. import javax.servlet.http.HttpServlet;
9. import javax.servlet.http.HttpServletRequest;
10. import javax.servlet.http.HttpServletResponse;
12. import com.zenika.contact.domain.Contact;
13. import com.zenika.contact.service.ContactService;
15. public class ContactServlet extends HttpServlet {
17. @EJB
18. private ContactService contactService;
20. @Override
21. protected void doGet(HttpServletRequest req, HttpServletResponse resp)
22. throws ServletException, IOException {
23. List<Contact> contacts = contactService.select();
24. if(contacts.isEmpty()) {
25. resp.getWriter().append(“<p>No contact.</p>”);
26. 
    25; else {
27. for(Contact contact : contacts) {
28. resp.getWriter().append(“<p>”)
29. .append(contact.getFirstName())
30. .append(” “)
31. .append(contact.getLastName())
32. .append(“</p>”);
33. }
34. }
35. }
36. }

There’s also a servlet listener, to populate the database :

1. package com.zenika.contact.web;
3. import javax.ejb.EJB;
4. import javax.servlet.ServletContextEvent;
5. import javax.servlet.ServletContextListener;
6. import com.zenika.contact.domain.Contact;
7. import com.zenika.contact.service.ContactService;
9. public class PopulateDataBaseListener implements ServletContextListener {
11. @EJB
12. private ContactService contactService;
14. @Override
15. public void contextInitialized(ServletContextEvent sce) {
16. if(contactService.select().isEmpty()) {
17. contactService.create(< span style=”color: #7F0055; font-weight: bold;”>new Contact(“Arnaud”,“Cogoluegnes”));
18. contactService.create(new Contact(“Carl”,“Azoury”));
19. contactService.create(new Contact(“Olivier”,“Croisier”));
20. }
21. }
23. @Override
24. public void contextDestroyed(ServletContextEvent sce) { }
26. }

The web.xml of the application :

1. <web-app xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance&#8221;
2. xmlns=“http://java.sun.com/xml/ns/javaee&#8221; xmlns:web=“http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd&#8221;
3. xsi:schemaLocation=“http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd&#8221;
4. id=“rest” version=“2.5”>
6. <display-name>Zen Contact JEE</display-name>
8. <listener>
9. <description>Add some rows in the database if necessary.</description>
10. <listener-class>com.zenika.contact.web.PopulateDataBaseListener</listener-class>
11. </listener>
13. <servlet>
14. <servlet-name>contact</servlet-name>
15. <servlet-class>com.zenika.contact.web.ContactServlet</servlet-class>
16. </servlet>
18. <servlet-mapping>
19. <servlet-name>contact</servlet-name>
20. <url-pattern>/contact.do</url-pattern>
21. </servlet-mapping>
23. </web-app>

By now, you should have something like the following :

Setting up the database

We’ll be using Derby, which ships with the JDK (as of version 1.6). Go to JAVA_HOME/db/bin and start the server with the startNetworkServer script.

Testing the EJB with Spring

Let’s say our EJB is much more complicated, with complex queries and business algorithms. Thus we need to test it against the database. The embedded EJB container API works but I found the one from Glassfish quite long to start and it remains difficult to switch from a test database to the server database, as the container picks up by default the META-INF/persistence.xml, which points to a JNDI datasource. Moreover, what we need in our test are transaction management and dependency injection (for the PersistenceContext). Spring offers a lightweight yet powerful solution to do that.

Configuring JPA with Spring

We can start by declaring the EJB in the Spring application context :

1. <?xml version=“1.0” encoding=“UTF-8”?>
2. <beans xmlns=“http://www.springframework.org/schema/beans&#8221;
3. xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance&#8221; xmlns:aop=“http://www.springframework.org/schema/aop&#8221;
4. xmlns:context=“http://www.springframework.org/schema/context&#8221; xmlns:tx=“http://www.springframework.org/schema/tx&#8221;
5. xsi:schemaLocation=“http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
6. http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
7. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd
8. http://www.springframework.org /schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd&#8221;>
10. <bean class=“com.zenika.contact.service.impl.ContactServiceImpl” />
12. <context:annotation-config />
14. </beans>

Note the use of the context:annotation-config element, which tells Spring to automatically inject PersistenceContexts.
Thanks to Spring JPA support, we can use a specific persistence file, let’s call it persistence-test.xml :

1. <?xml version=“1.0” encoding=“UTF-8”?>
2. <persistence xmlns=“http://java.sun.com/xml/ns/persistence&#8221;
3. xmlns:xsi=“http://www.w3.org/2001/XMLSchema-instance&#8221;
4. xsi:schemaLocation=“http://java.sun.com/xml/ns/persistence
5. http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd&#8221;
6. version=“1.0”>
8. <persistence-unit name=“contact” transaction-type=“RESOURCE_LOCAL”>
9. <provider>org.hibernate.ejb.HibernatePersistence</provider>
10. <class>com.zenika.contact.domain.Contact</class>
11. <exclude-unlisted-classes />
12. </persistence-unit>
14. </persistence>

Why do we use Hibernate for our test? Mainly because it enhances classes at runtime and does not need specific feature like load-time weaving through a JVM agent.
Let’s see now how to complement the Spring configuration :

1. <bean (…)>
2. (…)
3. <bean id=“dataSource”
4. class=“org.springframework.jdbc.datasource.SingleConnectionDataSource”>
5. <property name=“driverClassName” value=“org.apache.derby.jdbc.ClientDriver” />
6. <property name=“url”
7. value=“jdbc:derby://localhost:1527/contact_test;create=true” />
8. <property name=“username” value=“APP” />
9. <property name=“password” value=“APP” />
10. <property name=“suppressClose” value=“true” />
11. </bean>
13. <bean id=“contactEntityManagerFactory”
14. class=“org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean”>
15. <property name=“persistenceXmlLocation” value=“/com/zenika/contact/service/impl/persistence-test.xml” />
16. <property name=“dataSource” ref=“dataSource” />
17. <property name=“jpaProperties”>
18. <props>
19. <prop key=“hibernate.dialect”>org.hibernate.dialect.DerbyDialect</prop>
20. <prop key=“hibernate.hbm2ddl.auto”>create</prop>
21. <prop key=“hibernate.show_sql”>false</prop>
22. </props>
23. </property>
24. <property name=“jpaDialect”>
25. <bean class=“org.springframework.orm.jpa.vendor.HibernateJpaDialect” />
26. </property>
27. </bean>
28. </beans>

What about transaction management? We can add it declaratively, with the Spring JPA transaction manager and by decorating Spring beans that hold the @Stateless annotation :

1. <bean (…)>
2. (…)
3. <bean id=“transactionManager” class=“org.springframework.orm.jpa.JpaTransactionManager”>
4. <property name=“entityManagerFactory” ref=“contactEntityManagerFactory” />
5. </bean>
7. <aop:config>
8. <aop:pointcut expression=“within(@javax.ejb.Stateless *)” id=“ejbPointcut”/>
9. <aop:advisor advice-ref=“transactionInterceptor” pointcut-ref=“ejbPointcut” />
10. </aop:config>
12. <tx:advice id=“transactionInterceptor”>
13. <tx:attributes>
14. <tx:method name=“*” />
15. </tx:attributes>
16. </tx:advice>
17. </beans>

Writing the test

We’re ready now to test the EJB. The Spring TestContext Framework can handle the Spring application context lifecycle and would even cache it if other tests were using it, making the test suite faster. Here is the test :

1. package com.zenika.contact.service.impl;
3. import javax.sql.DataSource;
5. import org.junit.Assert;
6. import org.junit.Test;
7. import org.junit.runner.RunWith;
8. import org.springframework.beans.factory.annotation.Autowired;
9. import org.springframework.jdbc.core.JdbcTemplate;
10. import org.springframework.test.context.ContextConfiguration;
11. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
13. import com.zenika.contact.domain.Contact;
14. import com.zenika.contact.service.ContactService;
16. @RunWith(SpringJUnit4ClassRunner.class)
17. @ContextConfiguration
18. public class ContactServiceSpringTest {
20. @Autowired
21. ContactService contactService;
23. @Autowired
24. DataSource dataSource;
26. @Test public void create() {
27. JdbcTemplate template = new JdbcTemplate(dataSource);
28. int count = template.queryForInt(“select count(1) from contact”);
29. Contact contact = new Contact();
30. contact.setFirstName(“Arnaud”);
31. contact.setLastName(“Cogoluegnes”);
32. contactService.create(contact);
33. Assert.assertEquals(count+1,template.queryForInt(“select count(1) from contact”));
34. }
36. @Test public void select() {
37. JdbcTemplate template = new JdbcTemplate(dataSource);
38. template.update(“delete from contact”);
39. template.update(“insert into contact (id, firstName, lastName) values (default,?,?)”, “Arnaud”,“Cogoluegnes”);
40. Assert.assertEquals(1,contactService.select().size());
41. }
43. }

You can now run the test with Eclipse for instance.

Running the application on Glassfish

Before deploying the application, you need to install Glassfish and configure the JNDI datasource.

Setting up Glassfish

You can download Glassfish from its web page. We use here Glassfish 3.0. Once you have the archive, unzip it in a directory, go to the bin directory and start the server :

 ./asadmin start-domain

You can then access the admin console from the following URL: http://localhost:4848/

Setting up the datasource

The set up of the datasource is made of two steps: the pool and then the JDBC resource. Create first a pool for Derby, which uses the contact database (and creates it if necessary) :
And then, create the JDBC resources that uses this connection pool :

Deploying the application

Once packaged (see source code enclosed to this post), the application can be deployed on Glassfish. All the components we wrote have been detected :
You can check the application at http://localhost:8080/jeecontact-1.0.0/contact.do

Conclusion

Spring is not only able to power applications from the data access layer to the UI layer, it can also help you developping transactional components like EJBs. This is especially valuable when queries become complex and you want to clearly separate the test environment from the server environment, in a highly configurable and simple way.