Class ExclusiveConnectionMode

java.lang.Object
org.eclipse.persistence.config.ExclusiveConnectionMode

public class ExclusiveConnectionMode extends Object
This property could be specified while creating either EntityManagerFactory (createEntityManagerFactory or persistence.xml) or EntityManager (createEntityManager); the latter overrides the former. The "isolated case" mentioned below is the case of some (or all) entities requiring isolated cache. That could be achieved either by specifying the property for one or more entities: eclipselink.cache.shared.Employee -> "false" or for all entities: eclipselink.cache.shared.default -> "false" Note that this property(es) could be specified only on persistence unit level (cannot be passed to createEntityManager method).

JPA persistence property Usage:

properties.add(PersistenceUnitProperties.EXCLUSIVE_CONNECTION_MODE, ExclusiveConnectionMode.Isolated);

Values are case-insensitive. "" could be used instead of default value ExclusiveConnectionMode.DEFAULT.

See Also:
  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static final String
    The value causes creation of ExclusiveIsolatedClientSession in both isolated and non-isolated cases.
    static final String
     
    static final String
    The value causes creation of ExclusiveIsolatedClientSession in isolated case and throws exception otherwise.
    static final String
    The value causes creation of IsolatedClientSession in isolated case and ClientSession otherwise.
  • Constructor Summary

    Constructors
    Constructor
    Description
    Deprecated, for removal: This API element is subject to removal in a future version.
    This constructor will be marked private and the class final.
  • Method Summary

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
  • Field Details

    • Transactional

      public static final String Transactional
      The value causes creation of IsolatedClientSession in isolated case and ClientSession otherwise. Connection is kept exclusive for the duration of Eclipselink transaction. Inside Eclipselink transaction all writes and reads performed through the exclusive connection. Outside Eclipselink transaction a new connection is acquired from connection pool for each read and released back immediately after the query is executed. Note that Eclipselink transaction usually starts later then JTA transaction does, or entityManager.beginTransaction method is called: Eclipselink usually waits until it's about to perform a query that potentially alters data base's state to start Exclipselink transaction. That reflects in connection usage in Transactional mode. Example: // Eclipselink transaction is not started yet - readQuery1 acquires and immediately releases connection. readQuery1.getResultList(); entityManager.getTransaction().begin(); // Eclipselink transaction still not started yet - readQuery2 acquires and immediately releases connection. readQuery2.getResultList(); entityManager.persist(new Employee()); // Eclipselink transaction is not started yet - readQuery3 acquires and immediately releases connection. readQuery3.getResultList(); entityManager.flush(); // Before the flushing is performed Exclipselink transaction is started: // connection is acquired that will be kept until the end of transaction and used for all reads and writes. readQuery4.getResultList(); entityManager.commit(); // Eclipselink transaction is completed, the connection used by Eclipselink transaction is released; // readQuery5 acquires and immediately releases connection. readQuery5.getResultList(); There's a way to force beginning of Eclipselink transaction right before executing the first query after em.getTransaction().begin(): "eclipselink.transaction.join-existing" -> true. In the example that setting would force Exclipselink transaction top begin right before readQuery2 is executed and therefore cause execution of readQuery2 and readQuery3 through the exclusive connection (of course the same connection would be used by readQuery4 and flush, too). However this approach could hardly be recommended: none of the objects read after Eclipselink transaction begins get into the shared cache unless altered therefore seriously reducing benefits of Eclipselink shared cache.
      See Also:
    • Isolated

      public static final String Isolated
      The value causes creation of ExclusiveIsolatedClientSession in isolated case and throws exception otherwise. Connection is kept exclusive for the whole lifetime of the owning EntityManager. Inside Eclipselink transaction all writes and reads performed through the exclusive connection. Outside Eclipelink transaction only isolated entities are read through the exclusive connection; for non isolated entities a new connection is acquired from connection pool for each read and released back immediately after the query is executed. In the example presented above all five readQueries would read isolated entity through the exclusive connection, however non-isolated entity would be read the same as in Transactional mode.
      See Also:
    • Always

      public static final String Always
      The value causes creation of ExclusiveIsolatedClientSession in both isolated and non-isolated cases. Connection is kept exclusive for the whole lifetime of the owning EntityManager. All writes and reads performed through the exclusive connection. In the example presented above all five readQueries would read all entity through the exclusive connection. Note that though all entities use the exclusive connection only isolated entities use isolated cache; non-isolated entities use shared cache.
      See Also:
    • DEFAULT

      public static final String DEFAULT
      See Also:
  • Constructor Details

    • ExclusiveConnectionMode

      @Deprecated(since="4.0.3", forRemoval=true) public ExclusiveConnectionMode()
      Deprecated, for removal: This API element is subject to removal in a future version.
      This constructor will be marked private and the class final. It is not designed for extensibility.