import org.springframework.orm.jpa.SharedEntityManagerCreator; //导入依赖的package包/类
@Override
public final void afterPropertiesSet() {
	EntityManagerFactory emf = getEntityManagerFactory();
	if (emf == null) {
		throw new IllegalArgumentException("'entityManagerFactory' or 'persistenceUnitName' is required");
	}
	if (emf instanceof EntityManagerFactoryInfo) {
		EntityManagerFactoryInfo emfInfo = (EntityManagerFactoryInfo) emf;
		if (this.entityManagerInterface == null) {
			this.entityManagerInterface = emfInfo.getEntityManagerInterface();
			if (this.entityManagerInterface == null) {
				this.entityManagerInterface = EntityManager.class;
			}
		}
	}
	else {
		if (this.entityManagerInterface == null) {
			this.entityManagerInterface = EntityManager.class;
		}
	}
	this.shared = SharedEntityManagerCreator.createSharedEntityManager(
			emf, getJpaPropertyMap(), this.synchronizedWithTransaction, this.entityManagerInterface);
}
 

import org.springframework.orm.jpa.SharedEntityManagerCreator; //导入依赖的package包/类
private EntityManager resolveEntityManager(String requestingBeanName) {
	// Obtain EntityManager reference from JNDI?
	EntityManager em = getPersistenceContext(this.unitName, false);
	if (em == null) {
		// No pre-built EntityManager found -> build one based on factory.
		// Obtain EntityManagerFactory from JNDI?
		EntityManagerFactory emf = getPersistenceUnit(this.unitName);
		if (emf == null) {
			// Need to search for EntityManagerFactory beans.
			emf = findEntityManagerFactory(this.unitName, requestingBeanName);
		}
		// Inject a shared transactional EntityManager proxy.
		if (emf instanceof EntityManagerFactoryInfo &&
				((EntityManagerFactoryInfo) emf).getEntityManagerInterface() != null) {
			// Create EntityManager based on the info's vendor-specific type
			// (which might be more specific than the field's type).
			em = SharedEntityManagerCreator.createSharedEntityManager(emf, this.properties);
		}
		else {
			// Create EntityManager based on the field's type.
			em = SharedEntityManagerCreator.createSharedEntityManager(emf, this.properties, getResourceType());
		}
	}
	return em;
}
 

import org.springframework.orm.jpa.SharedEntityManagerCreator; //导入依赖的package包/类
private LockingStrategy newLockTxProxy(final String appId, final String uniqueId, final int ttl) {
    final JpaLockingStrategy lock = new JpaLockingStrategy();
    lock.entityManager = SharedEntityManagerCreator.createSharedEntityManager(factory);
    lock.setApplicationId(appId);
    lock.setUniqueId(uniqueId);
    lock.setLockTimeout(ttl);
    return (LockingStrategy) Proxy.newProxyInstance(
           JpaLockingStrategy.class.getClassLoader(),
           new Class[] {LockingStrategy.class},
           new TransactionalLockInvocationHandler(lock, this.txManager));
}
 

import org.springframework.orm.jpa.SharedEntityManagerCreator; //导入依赖的package包/类
private LockingStrategy newLockTxProxy(final String appId, final String uniqueId, final String ttl) {
    final JpaLockingStrategy lock = new JpaLockingStrategy(appId, uniqueId, Beans.newDuration(ttl).getSeconds());
    lock.entityManager = SharedEntityManagerCreator.createSharedEntityManager(factory);
    return (LockingStrategy) Proxy.newProxyInstance(
            JpaLockingStrategy.class.getClassLoader(),
            new Class[]{LockingStrategy.class},
            new TransactionalLockInvocationHandler(lock, this.txManager));
}
 

import org.springframework.orm.jpa.SharedEntityManagerCreator; //导入依赖的package包/类
@Bean
public JpaDatastore datastore(EntityManagerFactory emf) throws Exception {
	return JpaDatastore.builder().entityManagerFactory(emf)
			// use spring shared entitymanager to join spring transactions
			.entityManagerInitializer(f -> SharedEntityManagerCreator.createSharedEntityManager(f))
			.autoFlush(true).withExpressionResolver(KeyIs.RESOLVER)
			.withExpressionResolver(new UselessResolver()).traceEnabled(true).build();
}
 

import org.springframework.orm.jpa.SharedEntityManagerCreator; //导入依赖的package包/类
@Bean
public JpaDatastore datastore(EntityManagerFactory emf) throws Exception {
	return JpaDatastore.builder().entityManagerFactory(emf)
			// use spring shared entitymanager to join spring transactions
			.entityManagerInitializer(f -> SharedEntityManagerCreator.createSharedEntityManager(f))
			.autoFlush(true).withExpressionResolver(KeyIs.RESOLVER)
			.withExpressionResolver(new UselessResolver()).build();
}
 

import org.springframework.orm.jpa.SharedEntityManagerCreator; //导入依赖的package包/类
private LockingStrategy newLockTxProxy(final String appId, final String uniqueId, final int ttl) {
    final JpaLockingStrategy lock = new JpaLockingStrategy();
    lock.entityManager = SharedEntityManagerCreator.createSharedEntityManager(factory);
    lock.setApplicationId(appId);
    lock.setUniqueId(uniqueId);
    lock.setLockTimeout(ttl);
    return (LockingStrategy) Proxy.newProxyInstance(
           JpaLockingStrategy.class.getClassLoader(),
           new Class[] {LockingStrategy.class},
           new TransactionalLockInvocationHandler(lock));
}
 

import org.springframework.orm.jpa.SharedEntityManagerCreator; //导入依赖的package包/类
private EntityManager resolveEntityManager(String requestingBeanName) {
	// Obtain EntityManager reference from JNDI?
	EntityManager em = getPersistenceContext(this.unitName, false);
	if (em == null) {
		// No pre-built EntityManager found -> build one based on factory.
		// Obtain EntityManagerFactory from JNDI?
		EntityManagerFactory emf = getPersistenceUnit(this.unitName);
		if (emf == null) {
			// Need to search for EntityManagerFactory beans.
			emf = findEntityManagerFactory(this.unitName, requestingBeanName);
		}
		// Inject a shared transactional EntityManager proxy.
		if (emf instanceof EntityManagerFactoryInfo &&
				((EntityManagerFactoryInfo) emf).getEntityManagerInterface() != null) {
			// Create EntityManager based on the info's vendor-specific type
			// (which might be more specific than the field's type).
			em = SharedEntityManagerCreator.createSharedEntityManager(
					emf, this.properties, this.synchronizedWithTransaction);
		}
		else {
			// Create EntityManager based on the field's type.
			em = SharedEntityManagerCreator.createSharedEntityManager(
					emf, this.properties, this.synchronizedWithTransaction, getResourceType());
		}
	}
	return em;
}
 

import org.springframework.orm.jpa.SharedEntityManagerCreator; //导入依赖的package包/类
/**
 * Constructor.
 * <p>
 * Sets an {@link EntityManagerInitializer} which create a Spring shared {@link EntityManager}.
 * </p>
 */
public DefaultSpringJpaDatastore() {
	super(false);

	setEntityManagerInitializer((emf) -> SharedEntityManagerCreator.createSharedEntityManager(emf));
	setEntityManagerFinalizer((em) -> {
	});
}
 

import org.springframework.orm.jpa.SharedEntityManagerCreator; //导入依赖的package包/类
@Bean
public JpaDatastore datastore(EntityManagerFactory emf) throws Exception {
	return JpaDatastore.builder().entityManagerFactory(emf)
			// use spring shared entitymanager to join spring transactions
			.entityManagerInitializer(f -> SharedEntityManagerCreator.createSharedEntityManager(f))
			.autoFlush(true).traceEnabled(true).withExpressionResolver(KeyIs.RESOLVER).build();
}
 

import org.springframework.orm.jpa.SharedEntityManagerCreator; //导入依赖的package包/类
/**
 * @deprecated use {@link #getEntityManagerFactory()} to get hold of factory and create an entity manager using the factory.
 */
@Deprecated
protected EntityManager createEntityManager() {
    if (sharedEntityManager) {
        return SharedEntityManagerCreator.createSharedEntityManager(getEntityManagerFactory());
    } else {
        return getEntityManagerFactory().createEntityManager();
    }
}
 

import org.springframework.orm.jpa.SharedEntityManagerCreator; //导入依赖的package包/类
@Override
protected void doStart() throws Exception {
    // need to setup entity manager first
    if (getEndpoint().isSharedEntityManager()) {
        this.entityManager = SharedEntityManagerCreator.createSharedEntityManager(entityManagerFactory);
    } else {
        this.entityManager = entityManagerFactory.createEntityManager();
    }
    LOG.trace("Created EntityManager {} on {}", entityManager, this);

    super.doStart();
}
 

import org.springframework.orm.jpa.SharedEntityManagerCreator; //导入依赖的package包/类
public final void afterPropertiesSet() {
	EntityManagerFactory emf = getEntityManagerFactory();
	if (emf == null) {
		throw new IllegalArgumentException("'entityManagerFactory' or 'persistenceUnitName' is required");
	}
	Class[] ifcs = null;
	if (emf instanceof EntityManagerFactoryInfo) {
		EntityManagerFactoryInfo emfInfo = (EntityManagerFactoryInfo) emf;
		if (this.entityManagerInterface == null) {
			this.entityManagerInterface = emfInfo.getEntityManagerInterface();
			if (this.entityManagerInterface == null) {
				this.entityManagerInterface = EntityManager.class;
			}
		}
		JpaDialect jpaDialect = emfInfo.getJpaDialect();
		if (jpaDialect != null && jpaDialect.supportsEntityManagerPlusOperations()) {
			ifcs = new Class[] {this.entityManagerInterface, EntityManagerPlus.class};
		}
		else {
			ifcs = new Class[] {this.entityManagerInterface};
		}
	}
	else {
		if (this.entityManagerInterface == null) {
			this.entityManagerInterface = EntityManager.class;
		}
		ifcs = new Class[] {this.entityManagerInterface};
	}
	this.shared = SharedEntityManagerCreator.createSharedEntityManager(emf, getJpaPropertyMap(), ifcs);
}
 

import org.springframework.orm.jpa.SharedEntityManagerCreator; //导入依赖的package包/类
public void setEntityManagerFactory(EntityManagerFactory entityManagerFactory) {
	this.entityManagerFactory = entityManagerFactory;
	this.sharedEntityManager = SharedEntityManagerCreator.createSharedEntityManager(this.entityManagerFactory);
}
 

import org.springframework.orm.jpa.SharedEntityManagerCreator; //导入依赖的package包/类
public void testCanGetSharedOpenJpaEntityManagerProxy() {
	OpenJPAEntityManager openJPAEntityManager = (OpenJPAEntityManager) SharedEntityManagerCreator.createSharedEntityManager(
			entityManagerFactory, null, OpenJPAEntityManager.class);
	assertNotNull(openJPAEntityManager.getDelegate());
}
 

import org.springframework.orm.jpa.SharedEntityManagerCreator; //导入依赖的package包/类
public EntityManager getEntityManager() {
    return SharedEntityManagerCreator.createSharedEntityManager(getEntityManagerFactory());
}
 

import org.springframework.orm.jpa.SharedEntityManagerCreator; //导入依赖的package包/类
/**
 * Gets or creates an {@link javax.persistence.EntityManager} to use.
 *
 * @param exchange                 the current exchange, or <tt>null</tt> if no exchange
 * @param entityManagerFactory     the entity manager factory (mandatory)
 * @param usePassedInEntityManager whether to use an existing {@link javax.persistence.EntityManager} which has been stored
 *                                 on the exchange in the header with key {@link org.apache.camel.component.jpa.JpaConstants#ENTITY_MANAGER}
 * @param useSharedEntityManager   whether to use SharedEntityManagerCreator if not already passed in                             
 * @return the entity manager (is never null)
 */
public static EntityManager getTargetEntityManager(Exchange exchange, EntityManagerFactory entityManagerFactory,
                                                   boolean usePassedInEntityManager, boolean useSharedEntityManager, boolean allowRecreate) {
    EntityManager em = null;

    // favor using entity manager provided as a header from the end user
    if (exchange != null && usePassedInEntityManager) {
        em = exchange.getIn().getHeader(JpaConstants.ENTITY_MANAGER, EntityManager.class);
    }

    // then try reuse any entity manager which has been previously created and stored on the exchange
    if (em == null && exchange != null) {
        em = exchange.getProperty(JpaConstants.ENTITY_MANAGER, EntityManager.class);
    }

    if (em == null && useSharedEntityManager) {
        em = SharedEntityManagerCreator.createSharedEntityManager(entityManagerFactory);
    }
    
    if (em == null) {
        // create a new entity manager
        em = entityManagerFactory.createEntityManager();
        if (exchange != null) {
            // we want to reuse the EM so store as property and make sure we close it when done with the exchange
            exchange.setProperty(JpaConstants.ENTITY_MANAGER, em);
            exchange.addOnCompletion(new JpaCloseEntityManagerOnCompletion(em));
        }
    }

    if (allowRecreate && em == null || !em.isOpen()) {
        // create a new entity manager
        em = entityManagerFactory.createEntityManager();
        if (exchange != null) {
            // we want to reuse the EM so store as property and make sure we close it when done with the exchange
            exchange.setProperty(JpaConstants.ENTITY_MANAGER, em);
            exchange.addOnCompletion(new JpaCloseEntityManagerOnCompletion(em));
        }
    }

    return em;
}