下面列出了怎么用javax.persistence.spi.PersistenceUnitTransactionType的API类实例代码及写法，或者点击链接到github查看源代码。
public static EntityManagerFactory createEntityManagerFactory(KeycloakSession session, String unitName, Map<String, Object> properties, boolean jta) {
PersistenceUnitTransactionType txType = jta ? PersistenceUnitTransactionType.JTA : PersistenceUnitTransactionType.RESOURCE_LOCAL;
List<ParsedPersistenceXmlDescriptor> persistenceUnits = PersistenceXmlParser.locatePersistenceUnits(properties);
for (ParsedPersistenceXmlDescriptor persistenceUnit : persistenceUnits) {
if (persistenceUnit.getName().equals(unitName)) {
List<Class<?>> providedEntities = getProvidedEntities(session);
for (Class<?> entityClass : providedEntities) {
// Add all extra entity classes to the persistence unit.
persistenceUnit.addClasses(entityClass.getName());
}
// Now build the entity manager factory, supplying a proxy classloader, so Hibernate will be able
// to find and load the extra provided entities.
persistenceUnit.setTransactionType(txType);
return Bootstrap.getEntityManagerFactoryBuilder(persistenceUnit, properties,
new ProxyClassLoader(providedEntities)).build();
}
}
throw new RuntimeException("Persistence unit '" + unitName + "' not found");
}
private static void applyTransactionProperties(PersistenceUnitDescriptor persistenceUnit,
Map<String, Object> configurationValues) {
PersistenceUnitTransactionType transactionType = PersistenceUnitTransactionTypeHelper
.interpretTransactionType(configurationValues.get(JPA_TRANSACTION_TYPE));
if (transactionType == null) {
transactionType = persistenceUnit.getTransactionType();
}
if (transactionType == null) {
// is it more appropriate to have this be based on bootstrap entry point (EE vs SE)?
transactionType = PersistenceUnitTransactionType.RESOURCE_LOCAL;
}
boolean hasTransactionStrategy = configurationValues.containsKey(TRANSACTION_COORDINATOR_STRATEGY);
if (hasTransactionStrategy) {
LOG.overridingTransactionStrategyDangerous(TRANSACTION_COORDINATOR_STRATEGY);
} else {
if (transactionType == PersistenceUnitTransactionType.JTA) {
configurationValues.put(TRANSACTION_COORDINATOR_STRATEGY,
JtaTransactionCoordinatorBuilderImpl.class);
} else if (transactionType == PersistenceUnitTransactionType.RESOURCE_LOCAL) {
configurationValues.put(TRANSACTION_COORDINATOR_STRATEGY,
JdbcResourceLocalTransactionCoordinatorBuilderImpl.class);
}
}
}
public void testJta() throws Exception {
transactionType = PersistenceUnitTransactionType.JTA;
entityManagerFactory = createEntityManagerFactory();
final Object jpaTestObject = getClass().getClassLoader().loadClass("org.apache.openejb.core.cmp.jpa.JpaTestObject").newInstance();
set(jpaTestObject, "EntityManagerFactory", EntityManagerFactory.class, entityManagerFactory);
set(jpaTestObject, "TransactionManager", TransactionManager.class, transactionManager);
set(jpaTestObject, "NonJtaDs", DataSource.class, nonJtaDs);
Thread.currentThread().setContextClassLoader(getClass().getClassLoader());
invoke(jpaTestObject, "setUp");
try {
invoke(jpaTestObject, "jpaLifecycle");
} finally {
invoke(jpaTestObject, "tearDown");
}
}
private void applyTransactionProperties(StandardServiceRegistryBuilder ssrBuilder) {
PersistenceUnitTransactionType txnType = PersistenceUnitTransactionTypeHelper.interpretTransactionType(
configurationValues.get( JPA_TRANSACTION_TYPE )
);
if ( txnType == null ) {
txnType = persistenceUnit.getTransactionType();
}
if ( txnType == null ) {
// is it more appropriate to have this be based on bootstrap entry point (EE vs SE)?
txnType = PersistenceUnitTransactionType.RESOURCE_LOCAL;
}
boolean hasTxStrategy = configurationValues.containsKey( TRANSACTION_COORDINATOR_STRATEGY );
if ( hasTxStrategy ) {
LOG.overridingTransactionStrategyDangerous( TRANSACTION_COORDINATOR_STRATEGY );
}
else {
if ( txnType == PersistenceUnitTransactionType.JTA ) {
ssrBuilder.applySetting( TRANSACTION_COORDINATOR_STRATEGY, JtaTransactionCoordinatorBuilderImpl.class );
}
else if ( txnType == PersistenceUnitTransactionType.RESOURCE_LOCAL ) {
ssrBuilder.applySetting( TRANSACTION_COORDINATOR_STRATEGY, JdbcResourceLocalTransactionCoordinatorBuilderImpl.class );
}
}
}
/**
* Parse a specific {@code persistence.xml} and return the descriptor for the persistence-unit with matching name
*
* @param persistenceXmlUrl The {@code persistence.xml} URL
* @param name The PU name to match
* @param transactionType The specific PersistenceUnitTransactionType to incorporate into the persistence-unit descriptor
* @param integration The Map of integration settings
*
* @return The matching persistence-unit descriptor
*/
@SuppressWarnings("WeakerAccess")
public static ParsedPersistenceXmlDescriptor locateNamedPersistenceUnit(
URL persistenceXmlUrl,
String name,
PersistenceUnitTransactionType transactionType,
Map integration) {
assert StringHelper.isNotEmpty( name );
final PersistenceXmlParser parser = new PersistenceXmlParser(
ClassLoaderServiceImpl.fromConfigSettings( integration ),
transactionType
);
parser.parsePersistenceXml( persistenceXmlUrl, integration );
assert parser.persistenceUnits.containsKey( name );
return parser.persistenceUnits.get( name );
}
private void decodeTransactionType(ParsedPersistenceXmlDescriptor persistenceUnit) {
// if transaction type is set already
// use that value
// else
// if JTA DS
// use JTA
// else if NOT JTA DS
// use RESOURCE_LOCAL
// else
// use defaultTransactionType
if ( persistenceUnit.getTransactionType() != null ) {
return;
}
if ( persistenceUnit.getJtaDataSource() != null ) {
persistenceUnit.setTransactionType( PersistenceUnitTransactionType.JTA );
}
else if ( persistenceUnit.getNonJtaDataSource() != null ) {
persistenceUnit.setTransactionType( PersistenceUnitTransactionType.RESOURCE_LOCAL );
}
else {
persistenceUnit.setTransactionType( defaultTransactionType );
}
}
@ManagedOperation
@Description("change the current transaction type")
public void setTransactionType(final String type) {
try {
final PersistenceUnitTransactionType tt = PersistenceUnitTransactionType.valueOf(type.toUpperCase());
reloadableEntityManagerFactory.setTransactionType(tt);
} catch (final Exception iae) {
// ignored
}
}
@Override
public PersistenceUnitTransactionType getTransactionType() {
if (this.transactionType != null) {
return this.transactionType;
}
else {
return (this.jtaDataSource != null ?
PersistenceUnitTransactionType.JTA : PersistenceUnitTransactionType.RESOURCE_LOCAL);
}
}
@Test
public void testApplicationManagedEntityManagerWithJtaTransaction() throws Exception {
Object testEntity = new Object();
// This one's for the tx (shared)
EntityManager sharedEm = mock(EntityManager.class);
given(sharedEm.getTransaction()).willReturn(new NoOpEntityTransaction());
// This is the application-specific one
EntityManager mockEm = mock(EntityManager.class);
given(mockEmf.createEntityManager()).willReturn(sharedEm, mockEm);
LocalContainerEntityManagerFactoryBean cefb = parseValidPersistenceUnit();
MutablePersistenceUnitInfo pui = ((MutablePersistenceUnitInfo) cefb.getPersistenceUnitInfo());
pui.setTransactionType(PersistenceUnitTransactionType.JTA);
JpaTransactionManager jpatm = new JpaTransactionManager();
jpatm.setEntityManagerFactory(cefb.getObject());
TransactionStatus txStatus = jpatm.getTransaction(new DefaultTransactionAttribute());
EntityManagerFactory emf = cefb.getObject();
assertSame("EntityManagerFactory reference must be cached after init", emf, cefb.getObject());
assertNotSame("EMF must be proxied", mockEmf, emf);
EntityManager em = emf.createEntityManager();
em.joinTransaction();
assertFalse(em.contains(testEntity));
jpatm.commit(txStatus);
cefb.destroy();
verify(mockEm).joinTransaction();
verify(mockEm).contains(testEntity);
verify(mockEmf).close();
}
@Test
public void testExample4() throws Exception {
SimpleNamingContextBuilder builder = SimpleNamingContextBuilder.emptyActivatedContextBuilder();
DataSource ds = new DriverManagerDataSource();
builder.bind("java:comp/env/jdbc/MyDB", ds);
PersistenceUnitReader reader = new PersistenceUnitReader(
new PathMatchingResourcePatternResolver(), new JndiDataSourceLookup());
String resource = "/org/springframework/orm/jpa/persistence-example4.xml";
PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
assertNotNull(info);
assertEquals(1, info.length);
assertEquals("OrderManagement4", info[0].getPersistenceUnitName());
assertEquals(1, info[0].getMappingFileNames().size());
assertEquals("order-mappings.xml", info[0].getMappingFileNames().get(0));
assertEquals(3, info[0].getManagedClassNames().size());
assertEquals("com.acme.Order", info[0].getManagedClassNames().get(0));
assertEquals("com.acme.Customer", info[0].getManagedClassNames().get(1));
assertEquals("com.acme.Item", info[0].getManagedClassNames().get(2));
assertTrue("Exclude unlisted should be true when no value.", info[0].excludeUnlistedClasses());
assertSame(PersistenceUnitTransactionType.RESOURCE_LOCAL, info[0].getTransactionType());
assertEquals(0, info[0].getProperties().keySet().size());
builder.clear();
}
@Test
public void testApplicationManagedEntityManagerWithJtaTransaction() throws Exception {
Object testEntity = new Object();
// This one's for the tx (shared)
EntityManager sharedEm = mock(EntityManager.class);
given(sharedEm.getTransaction()).willReturn(new NoOpEntityTransaction());
// This is the application-specific one
EntityManager mockEm = mock(EntityManager.class);
given(mockEmf.createEntityManager()).willReturn(sharedEm, mockEm);
LocalContainerEntityManagerFactoryBean cefb = parseValidPersistenceUnit();
MutablePersistenceUnitInfo pui = ((MutablePersistenceUnitInfo) cefb.getPersistenceUnitInfo());
pui.setTransactionType(PersistenceUnitTransactionType.JTA);
JpaTransactionManager jpatm = new JpaTransactionManager();
jpatm.setEntityManagerFactory(cefb.getObject());
TransactionStatus txStatus = jpatm.getTransaction(new DefaultTransactionAttribute());
EntityManagerFactory emf = cefb.getObject();
assertSame("EntityManagerFactory reference must be cached after init", emf, cefb.getObject());
assertNotSame("EMF must be proxied", mockEmf, emf);
EntityManager em = emf.createEntityManager();
em.joinTransaction();
assertFalse(em.contains(testEntity));
jpatm.commit(txStatus);
cefb.destroy();
verify(mockEm).joinTransaction();
verify(mockEm).contains(testEntity);
verify(mockEmf).close();
}
public static PersistenceUnitInfoImpl newJTAPersistenceUnitInfo(
String persistenceUnitName, List<String> mappingFileNames, Properties properties, DataSource jtaDataSource) {
PersistenceUnitInfoImpl persistenceUnitInfo = new PersistenceUnitInfoImpl(
persistenceUnitName, mappingFileNames, properties
);
persistenceUnitInfo.jtaDataSource = jtaDataSource;
persistenceUnitInfo.nonJtaDataSource = null;
persistenceUnitInfo.transactionType = PersistenceUnitTransactionType.JTA;
return persistenceUnitInfo;
}
@Override
public PersistenceUnitTransactionType getTransactionType() {
if (this.transactionType != null) {
return this.transactionType;
}
else {
return (this.jtaDataSource != null ?
PersistenceUnitTransactionType.JTA : PersistenceUnitTransactionType.RESOURCE_LOCAL);
}
}
/**
* Intended for use in Hibernate tests
*
* @param persistenceXmlUrl The URL to a persistence.xml
* @param persistenceUnitName The name of the persistence-unit to parse
* @param integration setting overrides
*
* @return The EMFB
*/
public static EntityManagerFactoryBuilder getEntityManagerFactoryBuilder(
URL persistenceXmlUrl,
String persistenceUnitName,
PersistenceUnitTransactionType transactionType,
Map integration) {
;
return new EntityManagerFactoryBuilderImpl(
PersistenceXmlParser.parse( persistenceXmlUrl, transactionType, integration ).get( persistenceUnitName ),
integration
);
}
/**
* Find all persistence-units from all accessible {@code META-INF/persistence.xml} resources
*
* @param integration The Map of integration settings
*
* @return List of descriptors for all discovered persistence-units.
*/
public static List<ParsedPersistenceXmlDescriptor> locatePersistenceUnits(Map integration) {
final PersistenceXmlParser parser = new PersistenceXmlParser(
ClassLoaderServiceImpl.fromConfigSettings( integration ),
PersistenceUnitTransactionType.RESOURCE_LOCAL
);
parser.doResolve( integration );
return new ArrayList<>( parser.persistenceUnits.values() );
}
private static PersistenceUnitTransactionType parseTransactionType(String value) {
if ( StringHelper.isEmpty( value ) ) {
return null;
}
else if ( value.equalsIgnoreCase( "JTA" ) ) {
return PersistenceUnitTransactionType.JTA;
}
else if ( value.equalsIgnoreCase( "RESOURCE_LOCAL" ) ) {
return PersistenceUnitTransactionType.RESOURCE_LOCAL;
}
else {
throw new PersistenceException( "Unknown persistence unit transaction type : " + value );
}
}
@Override
public PersistenceUnitTransactionType getTransactionType() {
if (this.transactionType != null) {
return this.transactionType;
}
else {
return (this.jtaDataSource != null ?
PersistenceUnitTransactionType.JTA : PersistenceUnitTransactionType.RESOURCE_LOCAL);
}
}
@Test
public void testExample4() throws Exception {
SimpleNamingContextBuilder builder = SimpleNamingContextBuilder.emptyActivatedContextBuilder();
DataSource ds = new DriverManagerDataSource();
builder.bind("java:comp/env/jdbc/MyDB", ds);
PersistenceUnitReader reader = new PersistenceUnitReader(
new PathMatchingResourcePatternResolver(), new JndiDataSourceLookup());
String resource = "/org/springframework/orm/jpa/persistence-example4.xml";
PersistenceUnitInfo[] info = reader.readPersistenceUnitInfos(resource);
assertNotNull(info);
assertEquals(1, info.length);
assertEquals("OrderManagement4", info[0].getPersistenceUnitName());
assertEquals(1, info[0].getMappingFileNames().size());
assertEquals("order-mappings.xml", info[0].getMappingFileNames().get(0));
assertEquals(3, info[0].getManagedClassNames().size());
assertEquals("com.acme.Order", info[0].getManagedClassNames().get(0));
assertEquals("com.acme.Customer", info[0].getManagedClassNames().get(1));
assertEquals("com.acme.Item", info[0].getManagedClassNames().get(2));
assertTrue("Exclude unlisted should be true when no value.", info[0].excludeUnlistedClasses());
assertSame(PersistenceUnitTransactionType.RESOURCE_LOCAL, info[0].getTransactionType());
assertEquals(0, info[0].getProperties().keySet().size());
builder.clear();
}
public synchronized void setTransactionType(final PersistenceUnitTransactionType type) {
final PersistenceUnitInfoImpl info = entityManagerFactoryCallable.getUnitInfo();
info.setTransactionType(type);
final Properties properties = entityManagerFactoryCallable.getUnitInfo().getProperties();
if (properties.containsKey(JAVAX_PERSISTENCE_TRANSACTION_TYPE)) {
properties.setProperty(JAVAX_PERSISTENCE_TRANSACTION_TYPE, type.name());
}
}
public PersistenceUnitInfo build(final DataSource dataSource
, final Properties config
, final Class<?>... persistentClasses) {
return new PersistenceUnitInfo(){
@Override
public String getPersistenceUnitName() {
return "my pu";
}
@Override
public String getPersistenceProviderClassName() {
return "org.hibernate.jpa.HibernatePersistenceProvider";
}
@Override
public PersistenceUnitTransactionType getTransactionType() {
return PersistenceUnitTransactionType.RESOURCE_LOCAL;
}
@Override
public DataSource getJtaDataSource() {
return null;
}
@Override
public DataSource getNonJtaDataSource() {
return dataSource;
}
@Override
public List<String> getMappingFileNames() {
return emptyList();
}
@Override
public List<URL> getJarFileUrls() {
return emptyList();
}
@Override
public URL getPersistenceUnitRootUrl() {
return null;
}
@Override
public List<String> getManagedClassNames() {
return Arrays.stream(persistentClasses)
.map(c -> c.getName())
.collect(toList());
}
@Override
public boolean excludeUnlistedClasses() {
return false;
}
@Override
public SharedCacheMode getSharedCacheMode() {
return SharedCacheMode.NONE;
}
@Override
public ValidationMode getValidationMode() {
return ValidationMode.NONE;
}
@Override
public Properties getProperties() {
return config;
}
@Override
public String getPersistenceXMLSchemaVersion() {
return "2.1";
}
@Override
public ClassLoader getClassLoader() {
return this.getClass().getClassLoader();
}
@Override
public void addTransformer(ClassTransformer transformer) {
}
@Override
public ClassLoader getNewTempClassLoader() {
return null;
}
};
}
public void XtestUnenhancedGeneratedIdJta() throws Exception {
runTest("generatedId", PersistenceUnitTransactionType.JTA, false);
}
public DynamicEntityUnitInfo setNonJtaDataSource(DataSource nonJtaDataSource) {
this.nonjtaDataSource = nonJtaDataSource;
this.jtaDataSource = null;
transactionType = PersistenceUnitTransactionType.RESOURCE_LOCAL;
return this;
}
public void testEnhancedGeneratedIdResourceLocal() throws Exception {
runTest("generatedId", PersistenceUnitTransactionType.RESOURCE_LOCAL, true);
}
@Override
public Map<String, Object> getJpaPropertyMap(PersistenceUnitInfo pui) {
return buildJpaPropertyMap(this.jpaDialect.prepareConnection &&
pui.getTransactionType() != PersistenceUnitTransactionType.JTA);
}
public void setTransactionType(final PersistenceUnitTransactionType transactionType) {
this.transactionType = transactionType;
}
@Override
public PersistenceUnitTransactionType getTransactionType() {
return transactionType;
}
public PersistenceUnitInfoImpl setJtaDataSource(DataSource jtaDataSource) {
this.jtaDataSource = jtaDataSource;
this.nonJtaDataSource = null;
transactionType = PersistenceUnitTransactionType.JTA;
return this;
}
public PersistenceUnitInfoImpl setNonJtaDataSource(DataSource nonJtaDataSource) {
this.nonJtaDataSource = nonJtaDataSource;
this.jtaDataSource = null;
transactionType = PersistenceUnitTransactionType.RESOURCE_LOCAL;
return this;
}
@Override
public PersistenceUnitTransactionType getTransactionType() {
return null;
}
/**
* Parse the unit info DOM element.
*/
protected SpringPersistenceUnitInfo parsePersistenceUnitInfo(
Element persistenceUnit, String version, @Nullable URL rootUrl) throws IOException {
SpringPersistenceUnitInfo unitInfo = new SpringPersistenceUnitInfo();
// set JPA version (1.0 or 2.0)
unitInfo.setPersistenceXMLSchemaVersion(version);
// set persistence unit root URL
unitInfo.setPersistenceUnitRootUrl(rootUrl);
// set unit name
unitInfo.setPersistenceUnitName(persistenceUnit.getAttribute(UNIT_NAME).trim());
// set transaction type
String txType = persistenceUnit.getAttribute(TRANSACTION_TYPE).trim();
if (StringUtils.hasText(txType)) {
unitInfo.setTransactionType(PersistenceUnitTransactionType.valueOf(txType));
}
// evaluate data sources
String jtaDataSource = DomUtils.getChildElementValueByTagName(persistenceUnit, JTA_DATA_SOURCE);
if (StringUtils.hasText(jtaDataSource)) {
unitInfo.setJtaDataSource(this.dataSourceLookup.getDataSource(jtaDataSource.trim()));
}
String nonJtaDataSource = DomUtils.getChildElementValueByTagName(persistenceUnit, NON_JTA_DATA_SOURCE);
if (StringUtils.hasText(nonJtaDataSource)) {
unitInfo.setNonJtaDataSource(this.dataSourceLookup.getDataSource(nonJtaDataSource.trim()));
}
// provider
String provider = DomUtils.getChildElementValueByTagName(persistenceUnit, PROVIDER);
if (StringUtils.hasText(provider)) {
unitInfo.setPersistenceProviderClassName(provider.trim());
}
// exclude unlisted classes
Element excludeUnlistedClasses = DomUtils.getChildElementByTagName(persistenceUnit, EXCLUDE_UNLISTED_CLASSES);
if (excludeUnlistedClasses != null) {
String excludeText = DomUtils.getTextValue(excludeUnlistedClasses);
unitInfo.setExcludeUnlistedClasses(!StringUtils.hasText(excludeText) || Boolean.valueOf(excludeText));
}
// set JPA 2.0 shared cache mode
String cacheMode = DomUtils.getChildElementValueByTagName(persistenceUnit, SHARED_CACHE_MODE);
if (StringUtils.hasText(cacheMode)) {
unitInfo.setSharedCacheMode(SharedCacheMode.valueOf(cacheMode));
}
// set JPA 2.0 validation mode
String validationMode = DomUtils.getChildElementValueByTagName(persistenceUnit, VALIDATION_MODE);
if (StringUtils.hasText(validationMode)) {
unitInfo.setValidationMode(ValidationMode.valueOf(validationMode));
}
parseProperties(persistenceUnit, unitInfo);
parseManagedClasses(persistenceUnit, unitInfo);
parseMappingFiles(persistenceUnit, unitInfo);
parseJarFiles(persistenceUnit, unitInfo);
return unitInfo;
}