org.eclipse.persistence.sessions.UnitOfWork Java Examples

@Override
@Nullable
public Object beginTransaction(EntityManager entityManager, TransactionDefinition definition)
		throws PersistenceException, SQLException, TransactionException {

	if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
		// Pass custom isolation level on to EclipseLink's DatabaseLogin configuration
		// (since Spring 4.1.2)
		UnitOfWork uow = entityManager.unwrap(UnitOfWork.class);
		uow.getLogin().setTransactionIsolation(definition.getIsolationLevel());
	}

	entityManager.getTransaction().begin();

	if (!definition.isReadOnly() && !this.lazyDatabaseTransaction) {
		// Begin an early transaction to force EclipseLink to get a JDBC Connection
		// so that Spring can manage transactions with JDBC as well as EclipseLink.
		entityManager.unwrap(UnitOfWork.class).beginEarlyTransaction();
	}

	return null;
}
 

@Override
@Nullable
public Object beginTransaction(EntityManager entityManager, TransactionDefinition definition)
		throws PersistenceException, SQLException, TransactionException {

	if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
		// Pass custom isolation level on to EclipseLink's DatabaseLogin configuration
		// (since Spring 4.1.2)
		UnitOfWork uow = entityManager.unwrap(UnitOfWork.class);
		uow.getLogin().setTransactionIsolation(definition.getIsolationLevel());
	}

	entityManager.getTransaction().begin();

	if (!definition.isReadOnly() && !this.lazyDatabaseTransaction) {
		// Begin an early transaction to force EclipseLink to get a JDBC Connection
		// so that Spring can manage transactions with JDBC as well as EclipseLink.
		entityManager.unwrap(UnitOfWork.class).beginEarlyTransaction();
	}

	return null;
}
 

@Override
public Object beginTransaction(EntityManager entityManager, TransactionDefinition definition)
		throws PersistenceException, SQLException, TransactionException {

	if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
		// Pass custom isolation level on to EclipseLink's DatabaseLogin configuration
		// (since Spring 4.1.2)
		UnitOfWork uow = entityManager.unwrap(UnitOfWork.class);
		uow.getLogin().setTransactionIsolation(definition.getIsolationLevel());
	}

	entityManager.getTransaction().begin();

	if (!definition.isReadOnly() && !this.lazyDatabaseTransaction) {
		// Begin an early transaction to force EclipseLink to get a JDBC Connection
		// so that Spring can manage transactions with JDBC as well as EclipseLink.
		entityManager.unwrap(UnitOfWork.class).beginEarlyTransaction();
	}

	return null;
}
 

@Override
public Object beginTransaction(EntityManager entityManager, TransactionDefinition definition)
		throws PersistenceException, SQLException, TransactionException {

	if (definition.getIsolationLevel() != TransactionDefinition.ISOLATION_DEFAULT) {
		// Pass custom isolation level on to EclipseLink's DatabaseLogin configuration
		// (since Spring 4.1.2)
		UnitOfWork uow = entityManager.unwrap(UnitOfWork.class);
		uow.getLogin().setTransactionIsolation(definition.getIsolationLevel());
	}

	entityManager.getTransaction().begin();

	if (!definition.isReadOnly() && !this.lazyDatabaseTransaction) {
		// Begin an early transaction to force EclipseLink to get a JDBC Connection
		// so that Spring can manage transactions with JDBC as well as EclipseLink.
		entityManager.unwrap(UnitOfWork.class).beginEarlyTransaction();
	}

	return null;
}
 

@Override
public <T extends Entity> T merge(T entity) {
    log.debug("merge {}", entity);

    if (entityStates.isManaged(entity))
        return entity;

    String storeName = support.getStorageName(delegate.unwrap(UnitOfWork.class));
    entityListenerMgr.fireListener(entity, EntityListenerType.BEFORE_ATTACH, storeName);

    if ((entityStates.isNew(entity) || !entityStates.isDetached(entity)) && entity.getId() != null) {
        // if a new instance is passed to merge(), we suppose it is persistent but "not detached"
        Entity destEntity = findOrCreate(entity.getClass(), entity.getId());
        deepCopyIgnoringNulls(entity, destEntity, Sets.newIdentityHashSet());
        if (entityStates.isNew(destEntity)) {
            entityPersistingEventMgr.publishEvent(entity);
        }
        //noinspection unchecked
        return (T) destEntity;
    }

    T merged = internalMerge(entity);
    support.registerInstance(merged, this);
    return merged;
}
 

protected void registerInstanceForUnitOfWork(Entity instance, UnitOfWork unitOfWork) {
    if (log.isTraceEnabled())
        log.trace("ContainerResourceHolder.registerInstanceForUnitOfWork: instance = " +
                instance + ", UnitOfWork = " + unitOfWork);

    if (instance instanceof BaseGenericIdEntity) {
        BaseEntityInternalAccess.setManaged((BaseGenericIdEntity) instance, true);
    }

    Set<Entity> instances = unitOfWorkMap.get(unitOfWork);
    if (instances == null) {
        instances = createEntitySet();
        unitOfWorkMap.put(unitOfWork, instances);
    }
    instances.add(instance);
}
 

public void detach(EntityManager entityManager, Entity entity) {
    UnitOfWork unitOfWork = entityManager.getDelegate().unwrap(UnitOfWork.class);
    String storeName = getStorageName(unitOfWork);

    if (entity instanceof BaseGenericIdEntity) {
        fireBeforeDetachEntityListener((BaseGenericIdEntity) entity, storeName);

        ContainerResourceHolder container = getInstanceContainerResourceHolder(storeName);
        container.unregisterInstance(entity, unitOfWork);
        if (BaseEntityInternalAccess.isNew((BaseGenericIdEntity) entity)) {
            container.getNewDetachedInstances().add(entity);
        }
    }

    makeDetached(entity);
}
 

/**
 * Return all active vertices.
 */
@SuppressWarnings("unchecked")
public synchronized List<Vertex> allActive() {
	UnitOfWork unitOfWork = this.entityManager.unwrap(JpaEntityManager.class).getUnitOfWork();
	try {
		return unitOfWork.getIdentityMapAccessor().getAllFromIdentityMap(null, BasicVertex.class, null, null);
	} catch (Exception exception) {
		return new ArrayList<Vertex>();
	}
}
 

protected Collection<Entity> getInstances(UnitOfWork unitOfWork) {
    HashSet<Entity> set = new HashSet<>();
    Set<Entity> entities = unitOfWorkMap.get(unitOfWork);
    if (entities != null)
        set.addAll(entities);
    return set;
}
 

public Collection<Entity> getInstances(EntityManager entityManager) {
    if (!TransactionSynchronizationManager.isActualTransactionActive())
        throw new RuntimeException("No transaction");

    UnitOfWork unitOfWork = entityManager.getDelegate().unwrap(UnitOfWork.class);
    return getInstanceContainerResourceHolder(getStorageName(unitOfWork)).getInstances(unitOfWork);
}
 

public void registerInstance(Entity entity, AbstractSession session) {
    // Can be called outside of a transaction when fetching lazy attributes
    if (!TransactionSynchronizationManager.isActualTransactionActive())
        return;

    if (!(session instanceof UnitOfWork))
        throw new RuntimeException("Session is not a UnitOfWork: " + session);

    getInstanceContainerResourceHolder(getStorageName(session)).registerInstanceForUnitOfWork(entity, (UnitOfWork) session);
}
 

public void registerInstance(Entity entity, EntityManager entityManager) {
    if (!TransactionSynchronizationManager.isActualTransactionActive())
        throw new RuntimeException("No transaction");

    UnitOfWork unitOfWork = entityManager.getDelegate().unwrap(UnitOfWork.class);
    getInstanceContainerResourceHolder(getStorageName(unitOfWork)).registerInstanceForUnitOfWork(entity, unitOfWork);

    if (entity instanceof BaseGenericIdEntity) {
        BaseEntityInternalAccess.setDetached((BaseGenericIdEntity) entity, false);
    }
}
 

public void processFlush(EntityManager entityManager, boolean warnAboutImplicitFlush) {
    UnitOfWork unitOfWork = entityManager.getDelegate().unwrap(UnitOfWork.class);
    String storeName = getStorageName(unitOfWork);
    traverseEntities(getInstanceContainerResourceHolder(storeName), new OnSaveEntityVisitor(storeName), warnAboutImplicitFlush);
}
 

protected void unregisterInstance(Entity instance, UnitOfWork unitOfWork) {
    Set<Entity> instances = unitOfWorkMap.get(unitOfWork);
    if (instances != null) {
        instances.remove(instance);
    }
}
 

public DatabaseNetwork(EntityManager entityManager, boolean isShortTerm) {
	super(isShortTerm);
	this.entityManager = entityManager;
	entityManager.unwrap(UnitOfWork.class).setProperty("network", this);
}
 

public synchronized void clear() {
	this.entityManager.clear();
	this.verticesByData.clear();
	resetSize();
	this.entityManager.unwrap(UnitOfWork.class).setProperty("network", this);
}
 

@Override
public Object beginTransaction(EntityManager entityManager, TransactionDefinition definition) throws PersistenceException, SQLException, TransactionException {
    Object result = super.beginTransaction(entityManager, definition);
    Preconditions.checkState(result == null, "Transactional data should be null for EclipseLink dialect");

    // Read default timeout every time - may be somebody wants to change it on the fly
    int defaultTimeout = 0;
    String defaultTimeoutProp = AppContext.getProperty("cuba.defaultQueryTimeoutSec");
    if (!"0".equals(defaultTimeoutProp) && !StringUtils.isBlank(defaultTimeoutProp)) {
        try {
            defaultTimeout = Integer.parseInt(defaultTimeoutProp);
        } catch (NumberFormatException e) {
            log.error("Invalid cuba.defaultQueryTimeoutSec value", e);
        }
    }

    int timeoutSec = 0;
    if (definition.getTimeout() != TransactionDefinition.TIMEOUT_DEFAULT)
        timeoutSec = definition.getTimeout();
    else if (defaultTimeout != 0)
        timeoutSec = defaultTimeout;

    if (timeoutSec != 0) {
        log.trace("Applying query timeout {} sec", timeoutSec);
        if (entityManager instanceof JpaEntityManager) {
            UnitOfWork unitOfWork = ((JpaEntityManager) entityManager).getUnitOfWork();
            if (unitOfWork != null) {
                //setup delay in seconds on unit of work
                unitOfWork.setQueryTimeoutDefault(timeoutSec);
            }
        }

        String s = DbmsSpecificFactory.getDbmsFeatures().getTransactionTimeoutStatement();
        if (s != null) {
            Connection connection = entityManager.unwrap(Connection.class);
            try (Statement statement = connection.createStatement()) {
                statement.execute(String.format(s, timeoutSec * 1000));
            }
        }
    }

    return new CubaEclipseLinkTransactionData(entityManager);
}