[jboss-cvs] jboss-seam/src/main/org/jboss/seam/contexts ...

[Gavin King]

  User: gavin   
  Date: 07/06/18 01:57:35

  Modified:    src/main/org/jboss/seam/contexts  PassivatedEntity.java
  Log:
  JBSEAM-942, optimistic locking for passivated entities
  
  Revision  Changes    Path
  1.11      +52 -9     jboss-seam/src/main/org/jboss/seam/contexts/PassivatedEntity.java
  
  (In the diff below, changes in quantity of whitespace are not shown.)
  
  Index: PassivatedEntity.java
  ===================================================================
  RCS file: /cvsroot/jboss/jboss-seam/src/main/org/jboss/seam/contexts/PassivatedEntity.java,v
  retrieving revision 1.10
  retrieving revision 1.11
  diff -u -b -r1.10 -r1.11
  --- PassivatedEntity.java	16 Jun 2007 16:30:13 -0000	1.10
  +++ PassivatedEntity.java	18 Jun 2007 05:57:35 -0000	1.11
  @@ -3,8 +3,11 @@
   import java.io.Serializable;
   
   import javax.persistence.EntityManager;
  +import javax.persistence.OptimisticLockException;
   
  +import org.hibernate.EntityMode;
   import org.hibernate.Session;
  +import org.hibernate.metadata.ClassMetadata;
   import org.jboss.seam.Component;
   import org.jboss.seam.Seam;
   import org.jboss.seam.core.PersistenceContexts;
  @@ -26,14 +29,16 @@
      private static final long serialVersionUID = 6565440294007267788L;
      
      private Object id;
  +   private Object version;
      private String persistenceContext;
      private Class<?> entityClass; //TODO: make this transient, and serialize only the class name..
      
  -   private PassivatedEntity(Object id, Class<?> entityClass, String persistenceContext)
  +   private PassivatedEntity(Object id, Object version, Class<?> entityClass, String persistenceContext)
      {
         this.id = id;
         this.persistenceContext = persistenceContext;
         this.entityClass = entityClass;
  +      this.version = version;
      }
      
      public String getPersistenceContext()
  @@ -60,18 +65,38 @@
         }
         else
         {
  +         Object result = null;
  +         Object version = null;
            if (persistenceContext instanceof EntityManager)
            {
               EntityManager em = (EntityManager) persistenceContext;
  -            return em.isOpen() ? 
  -                     em.getReference( getEntityClass(), getId() ) : null;
  +            if ( em.isOpen() )
  +            {
  +               result = em.getReference( getEntityClass(), getId() );
  +               if (result!=null)
  +               {
  +                  version = PersistenceProvider.instance().getVersion(result, em);
  +               }
  +            }
            }
            else
            {
  +            //TODO: split this out to somewhere to isolate the Hibernate dependency!!
               Session session = (Session) persistenceContext;
  -            return session.isOpen() ? 
  -                     session.load( getEntityClass(), (Serializable) getId() ) : null;
  +            if ( session.isOpen() )
  +            {
  +               result = session.load( getEntityClass(), (Serializable) getId() );
  +               if (result!=null)
  +               {
  +                  version = getVersion(result, session);
  +               }
  +            }
  +         }
  +         if ( result!=null && this.version!=null && !this.version.equals(version) )
  +         {
  +            throw new OptimisticLockException("current database version number does not match passivated version number");
            }
  +         return result;
         }
      }
   
  @@ -84,7 +109,8 @@
            {
               Object persistenceContext = Component.getInstance(persistenceContextName);
               boolean managed;
  -            Object id;
  +            Object id = null;
  +            Object version = null;
               if (persistenceContext instanceof EntityManager)
               {
                  EntityManager em = (EntityManager) persistenceContext;
  @@ -97,10 +123,15 @@
                     //workaround for bug in HEM! //TODO; deleteme
                     managed = false;
                  }
  -               id = managed ? PersistenceProvider.instance().getId(value, em) : null;
  +               if (managed)
  +               {
  +                  id = PersistenceProvider.instance().getId(value, em);
  +                  version = PersistenceProvider.instance().getVersion(value, em);
  +               }
               }
               else
               {
  +               //TODO: split this out to somewhere to isolate the Hibernate dependency!!
                  Session session = (Session) persistenceContext;
                  try
                  {
  @@ -111,7 +142,11 @@
                     //just in case! //TODO; deleteme
                     managed = false;
                  }
  -               id = managed ? session.getIdentifier(value) : null;
  +               if (managed)
  +               {
  +                  id = session.getIdentifier(value);
  +                  version = getVersion(value, session);
  +               }
               }
               if (managed)
               {
  @@ -122,7 +157,7 @@
                  }
                  else
                  {
  -                  return new PassivatedEntity(id, entityClass, persistenceContextName);
  +                  return new PassivatedEntity(id, version, entityClass, persistenceContextName);
                  }
               }
            }
  @@ -130,6 +165,14 @@
         return null;
      }
      
  +   private static Object getVersion(Object value, Session session)
  +   {
  +      ClassMetadata classMetadata = session.getSessionFactory()
  +                  .getClassMetadata( value.getClass() );
  +      return classMetadata.isVersioned() ? 
  +               classMetadata.getVersion(value, EntityMode.POJO) : null;
  +   }
  +   
      public static boolean isTransactionRolledBackOrMarkedRollback()
      {
         try