Home » openejb-3.1.2-src » org.apache » openejb » persistence » [javadoc | source]

    1   /**
    2    *
    3    * Licensed to the Apache Software Foundation (ASF) under one or more
    4    * contributor license agreements.  See the NOTICE file distributed with
    5    * this work for additional information regarding copyright ownership.
    6    * The ASF licenses this file to You under the Apache License, Version 2.0
    7    * (the "License"); you may not use this file except in compliance with
    8    * the License.  You may obtain a copy of the License at
    9    *
   10    *     http://www.apache.org/licenses/LICENSE-2.0
   11    *
   12    *  Unless required by applicable law or agreed to in writing, software
   13    *  distributed under the License is distributed on an "AS IS" BASIS,
   14    *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   15    *  See the License for the specific language governing permissions and
   16    *  limitations under the License.
   17    */
   18   package org.apache.openejb.persistence;
   19   
   20   import java.util.Map;
   21   import javax.persistence.FlushModeType;
   22   import javax.persistence.LockModeType;
   23   import javax.persistence.Query;
   24   import javax.persistence.EntityTransaction;
   25   import javax.persistence.EntityManager;
   26   import javax.persistence.EntityManagerFactory;
   27   import javax.persistence.TransactionRequiredException;
   28   
   29   /**
   30    * The JtaEntityManager is a wrapper around an entity manager that automatically creates and closes entity managers
   31    * for each transaction in which it is accessed.  This implementation supports both transaction and extended scoped
   32    * JTA entity managers.
   33    * </p>
   34    * It is important that extended scoped entity managers add entity managers to the JtaEntityManagerRegistry when the
   35    * component is entered and remove them when exited.  If this registration is not preformed, an IllegalStateException
   36    * will be thrown when entity manger is used.
   37    * It is important that a component adds extended scoped entity managers to the JtaEntityManagerRegistry when the
   38    * component is entered and removes them when exited.  If this registration is not preformed, an IllegalStateException will
   39    * be thrown when entity manger is accessed.
   40    */
   41   public class JtaEntityManager implements EntityManager {
   42       private final JtaEntityManagerRegistry registry;
   43       private final EntityManagerFactory entityManagerFactory;
   44       private final Map properties;
   45       private final boolean extended;
   46   
   47       public JtaEntityManager(JtaEntityManagerRegistry registry, EntityManagerFactory entityManagerFactory, Map properties) {
   48           this(registry, entityManagerFactory, properties, false);
   49   
   50       }
   51       public JtaEntityManager(JtaEntityManagerRegistry registry, EntityManagerFactory entityManagerFactory, Map properties, boolean extended) {
   52           if (registry == null) throw new NullPointerException("registry is null");
   53           if (entityManagerFactory == null) throw new NullPointerException("entityManagerFactory is null");
   54           this.registry = registry;
   55           this.entityManagerFactory = entityManagerFactory;
   56           this.properties = properties;
   57           this.extended = extended;
   58       }
   59   
   60       private EntityManager getEntityManager() {
   61           return registry.getEntityManager(entityManagerFactory, properties, extended);
   62       }
   63   
   64       private boolean isTransactionActive() {
   65           return registry.isTransactionActive();
   66       }
   67   
   68       /**
   69        * This method assures that a non-extended entity managers has an acive transaction.  This is
   70        * required for some operations on the entity manager.
   71        * @throws TransactionRequiredException if non-extended and a transaction is not active
   72        */
   73       private void assertTransactionActive() throws TransactionRequiredException {
   74           if (!extended && !isTransactionActive()) {
   75               throw new TransactionRequiredException();
   76           }
   77       }
   78   
   79       /**
   80        * Closes a non-extended entity manager if no transaction is active.  For methods on an
   81        * entity manager that do not require an active transaction, a temp entity manager is created
   82        * for the operation and then closed.
   83        * @param entityManager the entity manager to close if non-extended and a transaction is not active
   84        */
   85       private void closeIfNoTx(EntityManager entityManager) {
   86           if (!extended && !isTransactionActive()) {
   87               entityManager.close();
   88           }
   89       }
   90   
   91       public EntityManager getDelegate() {
   92           return getEntityManager();
   93       }
   94   
   95       public void persist(Object entity) {
   96           assertTransactionActive();
   97           getEntityManager().persist(entity);
   98       }
   99   
  100       public <T>T merge(T entity) {
  101           assertTransactionActive();
  102           return getEntityManager().merge(entity);
  103       }
  104   
  105       public void remove(Object entity) {
  106           assertTransactionActive();
  107           getEntityManager().remove(entity);
  108       }
  109   
  110       public <T>T find(Class<T> entityClass, Object primaryKey) {
  111           EntityManager entityManager = getEntityManager();
  112           try {
  113               return entityManager.find(entityClass, primaryKey);
  114           } finally {
  115               closeIfNoTx(entityManager);
  116           }
  117       }
  118   
  119       public <T>T getReference(Class<T> entityClass, Object primaryKey) {
  120           EntityManager entityManager = getEntityManager();
  121           try {
  122               return entityManager.getReference(entityClass, primaryKey);
  123           } finally {
  124               closeIfNoTx(entityManager);
  125           }
  126       }
  127   
  128       public void flush() {
  129           assertTransactionActive();
  130           getEntityManager().flush();
  131       }
  132   
  133       public void setFlushMode(FlushModeType flushMode) {
  134           EntityManager entityManager = getEntityManager();
  135           try {
  136               entityManager.setFlushMode(flushMode);
  137           } finally {
  138               closeIfNoTx(entityManager);
  139           }
  140       }
  141   
  142       public FlushModeType getFlushMode() {
  143           EntityManager entityManager = getEntityManager();
  144           try {
  145               return entityManager.getFlushMode();
  146           } finally {
  147               closeIfNoTx(entityManager);
  148           }
  149       }
  150   
  151       public void lock(Object entity, LockModeType lockMode) {
  152           assertTransactionActive();
  153           getEntityManager().lock(entity, lockMode);
  154       }
  155   
  156       public void refresh(Object entity) {
  157           assertTransactionActive();
  158           getEntityManager().refresh(entity);
  159       }
  160   
  161       public void clear() {
  162           if (!extended && !isTransactionActive()) {
  163               return;
  164           }
  165           getEntityManager().clear();
  166       }
  167   
  168       public boolean contains(Object entity) {
  169           return isTransactionActive() && getEntityManager().contains(entity);
  170       }
  171   
  172       public Query createQuery(String qlString) {
  173           EntityManager entityManager = getEntityManager();
  174           Query query = entityManager.createQuery(qlString);
  175           return proxyIfNoTx(entityManager, query);
  176       }
  177   
  178       public Query createNamedQuery(String name) {
  179           EntityManager entityManager = getEntityManager();
  180           Query query = entityManager.createNamedQuery(name);
  181           return proxyIfNoTx(entityManager, query);
  182       }
  183   
  184       public Query createNativeQuery(String sqlString) {
  185           EntityManager entityManager = getEntityManager();
  186           Query query = entityManager.createNativeQuery(sqlString);
  187           return proxyIfNoTx(entityManager, query);
  188       }
  189   
  190       public Query createNativeQuery(String sqlString, Class resultClass) {
  191           EntityManager entityManager = getEntityManager();
  192           Query query = entityManager.createNativeQuery(sqlString, resultClass);
  193           return proxyIfNoTx(entityManager, query);
  194       }
  195   
  196       public Query createNativeQuery(String sqlString, String resultSetMapping) {
  197           EntityManager entityManager = getEntityManager();
  198           Query query = entityManager.createNativeQuery(sqlString, resultSetMapping);
  199           return proxyIfNoTx(entityManager, query);
  200       }
  201   
  202       private Query proxyIfNoTx(EntityManager entityManager, Query query) {
  203           if (!extended && !isTransactionActive()) {
  204               return new JtaQuery(entityManager, query);
  205           }
  206           return query;
  207       }
  208   
  209       public void joinTransaction() {
  210       }
  211   
  212       public void close() {
  213       }
  214   
  215       public boolean isOpen() {
  216           return true;
  217       }
  218   
  219       public EntityTransaction getTransaction() {
  220           throw new IllegalStateException("A JTA EntityManager can not use the EntityTransaction API.  See JPA 1.0 section 5.5");
  221       }
  222   }

Home » openejb-3.1.2-src » org.apache » openejb » persistence » [javadoc | source]