Now setting connection autocommit to false before
[utils] / test / enterprise / src / main / java / org / wamblee / support / persistence / JpaBuilder.java
1 /*
2  * Copyright 2005-2010 the original author or authors.
3  * 
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  * 
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  * 
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 package org.wamblee.support.persistence;
17
18 import java.util.Map;
19 import java.util.TreeMap;
20 import java.util.logging.Level;
21 import java.util.logging.Logger;
22
23 import javax.naming.InitialContext;
24 import javax.naming.NamingException;
25 import javax.persistence.EntityManager;
26 import javax.persistence.EntityManagerFactory;
27 import javax.persistence.EntityTransaction;
28 import javax.persistence.Persistence;
29 import javax.persistence.PersistenceException;
30 import javax.sql.DataSource;
31
32 import org.wamblee.support.jndi.StubInitialContextFactory;
33
34 /**
35  * Utility for building an appropriately configured EntityManagerFactory. The
36  * idea is that a persistence.xml is used unchanged from the production version.
37  * This utility will then add the additional properties required for execution
38  * in a standalone environment.
39  * 
40  * The other purpose is to to shield dependencies of the test code on a
41  * particular JPA provider.
42  */
43 public class JpaBuilder {
44
45     private static final Logger LOGGER = Logger.getLogger(JpaBuilder.class
46         .getName());
47
48     /**
49      * Callback interface to execute some JPA code within a transaction with the
50      * entitymanager to use provided as input.
51      */
52     public static interface JpaUnitOfWork<T> {
53         /**
54          * Executes the unit of work. A transaction has been started.
55          * 
56          * @param aEm
57          *            Entity manager.
58          * @return Result of the execute method. If you don't want to return
59          *         anything use <code>Void</code> for the return type and return
60          *         null from the implementation.
61          */
62         T execute(EntityManager aEm) throws Exception;
63     }
64
65     private PersistenceUnitDescription persistenceUnit;
66     private DataSource dataSource;
67     private EntityManagerFactory factory;
68
69     /**
70      * Constructs the builder.
71      * 
72      * @param aDataSource
73      *            Datasource of database.
74      * @param aPersistenceUnit
75      *            Persistence unit.
76      */
77     public JpaBuilder(DataSource aDataSource,
78         PersistenceUnitDescription aPersistenceUnit) {
79         persistenceUnit = aPersistenceUnit;
80         dataSource = aDataSource;
81         StubInitialContextFactory.register();
82     }
83
84     /**
85      * Starts the builder, which in particular, mocks JNDI, binds the datasource
86      * the JNDI where the persistence unit expects it, creates the entity
87      * manager factory, and forces creation of the database schema.
88      */
89     public void start() throws Exception {
90         try {
91             InitialContext ctx = new InitialContext();
92             ctx.bind(persistenceUnit.getJndiName(), dataSource);
93         } catch (NamingException e) {
94             throw new RuntimeException("JNDI problem", e);
95         }
96         factory = createFactory();
97         try {
98             execute(new JpaUnitOfWork<Void>() {
99                 public Void execute(EntityManager aEm) {
100                     // Empty, just to trigger database schema creation.
101                     return null;
102                 }
103             });
104         } catch (PersistenceException e) {
105             factory.close();
106             throw e;
107         }
108     }
109
110     /**
111      * Stops the entity manager factory and disables JNDI mocking.
112      */
113     public void stop() {
114         StubInitialContextFactory.unregister();
115         factory.close();
116     }
117
118     /**
119      * Creates a new entity manager factory. Typically not used by test code.
120      * 
121      * @return Entity manager factory.
122      */
123     public EntityManagerFactory createFactory() {
124         Map<String, String> jpaProps = new TreeMap<String, String>();
125
126         JpaCustomizerBuilder.getCustomizer().customize(persistenceUnit,
127             jpaProps);
128
129         // jpaProps.put("javax.persistence.provider",
130         // HibernatePersistence.class.getName());
131         EntityManagerFactory factory = Persistence.createEntityManagerFactory(
132             persistenceUnit.getUnitName(), jpaProps);
133
134         LOGGER.info("Using " + factory.getClass());
135         return factory;
136     }
137
138     /**
139      * Executes a unit of work. This creates an entitymanager and runs the
140      * {@link JpaUnitOfWork#execute(EntityManager)} within a transaction,
141      * passing it the entity manager. Use of this method saves a lot of typing
142      * for applications.
143      * 
144      * @param aWork
145      *            Work to execute.
146      * @return The return value of the execute method of the unit of work.
147      */
148     public <T> T execute(JpaUnitOfWork<T> aWork) throws Exception {
149         EntityManager em = factory.createEntityManager();
150         EntityTransaction transaction = em.getTransaction();
151         transaction.begin();
152         try {
153             T value = aWork.execute(em);
154             transaction.commit();
155             return value;
156         } catch (Exception e) {
157             LOGGER.log(Level.WARNING, "Exception occured", e);
158             transaction.rollback();
159             throw e;
160         } finally {
161             em.close();
162         }
163     }
164 }