Java PersistenceManagerFactory類代碼示例

import javax.jdo.PersistenceManagerFactory; //導入依賴的package包/類
@Test
public void testLocalPersistenceManagerFactoryBeanWithFile() throws IOException {
	LocalPersistenceManagerFactoryBean pmfb = new LocalPersistenceManagerFactoryBean() {
		@Override
		protected PersistenceManagerFactory newPersistenceManagerFactory(Map props) {
			throw new IllegalArgumentException((String) props.get("myKey"));
		}
	};
	pmfb.setConfigLocation(new ClassPathResource("test.properties", getClass()));
	try {
		pmfb.afterPropertiesSet();
		fail("Should have thrown IllegalArgumentException");
	}
	catch (IllegalArgumentException ex) {
		// expected
		assertTrue("Correct exception", "myValue".equals(ex.getMessage()));
	}
}
 

import javax.jdo.PersistenceManagerFactory; //導入依賴的package包/類
@Test
public void testLocalPersistenceManagerFactoryBeanWithName() throws IOException {
	LocalPersistenceManagerFactoryBean pmfb = new LocalPersistenceManagerFactoryBean() {
		@Override
		protected PersistenceManagerFactory newPersistenceManagerFactory(String name) {
			throw new IllegalArgumentException(name);
		}
	};
	pmfb.setPersistenceManagerFactoryName("myName");
	try {
		pmfb.afterPropertiesSet();
		fail("Should have thrown IllegalArgumentException");
	}
	catch (IllegalArgumentException ex) {
		// expected
		assertTrue("Correct exception", "myName".equals(ex.getMessage()));
	}
}
 

import javax.jdo.PersistenceManagerFactory; //導入依賴的package包/類
@Test
public void testLocalPersistenceManagerFactoryBeanWithNameAndProperties() throws IOException {
	LocalPersistenceManagerFactoryBean pmfb = new LocalPersistenceManagerFactoryBean() {
		@Override
		protected PersistenceManagerFactory newPersistenceManagerFactory(String name) {
			throw new IllegalArgumentException(name);
		}
	};
	pmfb.setPersistenceManagerFactoryName("myName");
	pmfb.getJdoPropertyMap().put("myKey", "myValue");
	try {
		pmfb.afterPropertiesSet();
		fail("Should have thrown IllegalStateException");
	}
	catch (IllegalStateException ex) {
		// expected
		assertTrue(ex.getMessage().indexOf("persistenceManagerFactoryName") != -1);
		assertTrue(ex.getMessage().indexOf("jdoProp") != -1);
	}
}
 

import javax.jdo.PersistenceManagerFactory; //導入依賴的package包/類
public void init(int doublesPerRow) {
	System.out.println("Storing to database");
	ZooHelper.getDataStoreManager().createDb(dbName);
	
	ZooJdoProperties prop = new ZooJdoProperties(dbName);
	PersistenceManagerFactory pmf = JDOHelper.getPersistenceManagerFactory(prop);
	pmf.setRetainValues(false);
	pm = pmf.getPersistenceManager();
	pm.currentTransaction().begin();
	
	list = new PersistentArrayDoubleParent(doublesPerRow);
	pm.makePersistent(list);
	
	pad = list.getNextForWrite2();
	data = pad.getData();
}
 

import javax.jdo.PersistenceManagerFactory; //導入依賴的package包/類
private PersistenceManager getPersistManager(MetadbConf metadbConf) {
  //TODO: get params from dbConf
  String driver = metadbConf.getJdbcDriverName();

  LOG.info("Connecting to Metastore with driver: " + driver);

  Properties properties = new Properties();
  properties.setProperty("javax.jdo.option.ConnectionURL",
          "jdbc:derby:metastore_db;create=true");

  properties.setProperty("javax.jdo.option.ConnectionDriverName",
          driver);

  properties.setProperty("javax.jdo.option.ConnectionUserName", "");
  properties.setProperty("javax.jdo.option.ConnectionPassword", "");
  properties.setProperty("datanucleus.schema.autoCreateSchema", "true");
  properties.setProperty("datanucleus.schema.autoCreateTables", "true");
  properties.setProperty("datanucleus.schema.validateTables", "false");
  properties.setProperty("datanucleus.schema.validateConstraints", "false");

  PersistenceManagerFactory pmf = JDOHelper.getPersistenceManagerFactory(properties);
  PersistenceManager pm = pmf.getPersistenceManager();

  return  pm;
}
 

import javax.jdo.PersistenceManagerFactory; //導入依賴的package包/類
public  Object getPersistenceManager(String client,PersistenceManagerFactory pmf) 
{
	Map<String,PersistenceManager> map = (Map<String,PersistenceManager>)super.get();
	PersistenceManager pm = null;
	if (map != null)
		pm = map.get(client);
	
    if(pm == null || pm.isClosed()) 
    {
        pm = pmf.getPersistenceManager( ); 
        pm.setUserObject(client);
        if (map == null)
        	map = new HashMap<>();
        map.put(client, pm);
        set(map);
    }

    return pm;
}
 

import javax.jdo.PersistenceManagerFactory; //導入依賴的package包/類
public PersistenceManager getPersistenceManager(String key)
 {
  PersistenceManagerFactory pmf = factories.get(key);
  if (pmf == null)
  {
throw new APIException(APIException.INTERNAL_DB_ERROR);
  }
  if (pmf != null)
  {
  	PersistenceManager pm = (PersistenceManager) pmRet.getPersistenceManager(key,pmf);
  	if (!pm.currentTransaction().isActive())
  		TransactionPeer.startReadOnlyTransaction(pm);
  	return pm;
  }
  else
  	return null;
 }
 

import javax.jdo.PersistenceManagerFactory; //導入依賴的package包/類
@Test
public void testJdoDaoSupportWithPersistenceManagerFactory() throws Exception {
	PersistenceManagerFactory pmf = mock(PersistenceManagerFactory.class);
	pmf.getConnectionFactory();
	final List test = new ArrayList();
	JdoDaoSupport dao = new JdoDaoSupport() {
		@Override
		protected void initDao() {
			test.add("test");
		}
	};
	dao.setPersistenceManagerFactory(pmf);
	dao.afterPropertiesSet();
	assertEquals("Correct PersistenceManagerFactory", pmf, dao.getPersistenceManagerFactory());
	assertEquals("Correct JdoTemplate", pmf, dao.getJdoTemplate().getPersistenceManagerFactory());
	assertEquals("initDao called", test.size(), 1);
}
 

import javax.jdo.PersistenceManagerFactory; //導入依賴的package包/類
@Test
public void testInterceptor() {
	PersistenceManagerFactory pmf = mock(PersistenceManagerFactory.class);
	PersistenceManager pm = mock(PersistenceManager.class);
	given(pmf.getPersistenceManager()).willReturn(pm);

	JdoInterceptor interceptor = new JdoInterceptor();
	interceptor.setPersistenceManagerFactory(pmf);
	try {
		interceptor.invoke(new TestInvocation(pmf));
	}
	catch (Throwable t) {
		fail("Should not have thrown Throwable: " + t.getMessage());
	}

	verify(pm).close();
}
 

import javax.jdo.PersistenceManagerFactory; //導入依賴的package包/類
@Test
public void testInterceptorWithPrebound() {
	PersistenceManagerFactory pmf = mock(PersistenceManagerFactory.class);
	PersistenceManager pm = mock(PersistenceManager.class);

	TransactionSynchronizationManager.bindResource(pmf, new PersistenceManagerHolder(pm));
	JdoInterceptor interceptor = new JdoInterceptor();
	interceptor.setPersistenceManagerFactory(pmf);
	try {
		interceptor.invoke(new TestInvocation(pmf));
	}
	catch (Throwable t) {
		fail("Should not have thrown Throwable: " + t.getMessage());
	}
	finally {
		TransactionSynchronizationManager.unbindResource(pmf);
	}
}
 

import javax.jdo.PersistenceManagerFactory; //導入依賴的package包/類
public void initializeDatastore(PersistenceManagerFactory pmf) {
    /*
    PersistenceManager pm = pmf.getPersistenceManager();
    Transaction tx = pm.currentTransaction();

    try {
        tx.begin();

        // TODO: Initialize datastore

        tx.commit();
    } catch (Exception ex) {
        LOG.error("Unable to initialize repository", ex);
    } finally {
        if (tx.isActive()) {
            tx.rollback();
        }
        pm.close();
    }
    */
}
 

import javax.jdo.PersistenceManagerFactory; //導入依賴的package包/類
/**
 * Obtain a JDO PersistenceManager via the given factory. Is aware of a
 * corresponding PersistenceManager bound to the current thread,
 * for example when using JdoTransactionManager. Will create a new
 * PersistenceManager else, if "allowCreate" is {@code true}.
 * <p>Same as {@code getPersistenceManager}, but throwing the original JDOException.
 * @param pmf PersistenceManagerFactory to create the PersistenceManager with
 * @param allowCreate if a non-transactional PersistenceManager should be created
 * when no transactional PersistenceManager can be found for the current thread
 * @return the PersistenceManager
 * @throws JDOException if the PersistenceManager couldn't be created
 * @throws IllegalStateException if no thread-bound PersistenceManager found and
 * "allowCreate" is {@code false}
 * @see #getPersistenceManager(javax.jdo.PersistenceManagerFactory, boolean)
 * @see JdoTransactionManager
 */
public static PersistenceManager doGetPersistenceManager(PersistenceManagerFactory pmf, boolean allowCreate)
	throws JDOException, IllegalStateException {

	Assert.notNull(pmf, "No PersistenceManagerFactory specified");

	PersistenceManagerHolder pmHolder =
			(PersistenceManagerHolder) TransactionSynchronizationManager.getResource(pmf);
	if (pmHolder != null) {
		if (!pmHolder.isSynchronizedWithTransaction() &&
				TransactionSynchronizationManager.isSynchronizationActive()) {
			pmHolder.setSynchronizedWithTransaction(true);
			TransactionSynchronizationManager.registerSynchronization(
					new PersistenceManagerSynchronization(pmHolder, pmf, false));
		}
		return pmHolder.getPersistenceManager();
	}

	if (!allowCreate && !TransactionSynchronizationManager.isSynchronizationActive()) {
		throw new IllegalStateException("No JDO PersistenceManager bound to thread, " +
				"and configuration does not allow creation of non-transactional one here");
	}

	logger.debug("Opening JDO PersistenceManager");
	PersistenceManager pm = pmf.getPersistenceManager();

	if (TransactionSynchronizationManager.isSynchronizationActive()) {
		logger.debug("Registering transaction synchronization for JDO PersistenceManager");
		// Use same PersistenceManager for further JDO actions within the transaction.
		// Thread object will get removed by synchronization at transaction completion.
		pmHolder = new PersistenceManagerHolder(pm);
		pmHolder.setSynchronizedWithTransaction(true);
		TransactionSynchronizationManager.registerSynchronization(
				new PersistenceManagerSynchronization(pmHolder, pmf, true));
		TransactionSynchronizationManager.bindResource(pmf, pmHolder);
	}

	return pm;
}
 

import javax.jdo.PersistenceManagerFactory; //導入依賴的package包/類
/**
 * Return whether the given JDO PersistenceManager is transactional, that is,
 * bound to the current thread by Spring's transaction facilities.
 * @param pm the JDO PersistenceManager to check
 * @param pmf JDO PersistenceManagerFactory that the PersistenceManager
 * was created with (can be {@code null})
 * @return whether the PersistenceManager is transactional
 */
public static boolean isPersistenceManagerTransactional(
		PersistenceManager pm, PersistenceManagerFactory pmf) {

	if (pmf == null) {
		return false;
	}
	PersistenceManagerHolder pmHolder =
			(PersistenceManagerHolder) TransactionSynchronizationManager.getResource(pmf);
	return (pmHolder != null && pm == pmHolder.getPersistenceManager());
}
 

import javax.jdo.PersistenceManagerFactory; //導入依賴的package包/類
/**
 * Apply the current transaction timeout, if any, to the given JDO Query object.
 * @param query the JDO Query object
 * @param pmf JDO PersistenceManagerFactory that the Query was created for
 * @throws JDOException if thrown by JDO methods
 */
public static void applyTransactionTimeout(Query query, PersistenceManagerFactory pmf) throws JDOException {
	Assert.notNull(query, "No Query object specified");
	PersistenceManagerHolder pmHolder =
			(PersistenceManagerHolder) TransactionSynchronizationManager.getResource(pmf);
	if (pmHolder != null && pmHolder.hasTimeout() &&
			pmf.supportedOptions().contains("javax.jdo.option.DatastoreTimeout")) {
		int timeout = (int) pmHolder.getTimeToLiveInMillis();
		query.setDatastoreReadTimeoutMillis(timeout);
		query.setDatastoreWriteTimeoutMillis(timeout);
	}
}
 

import javax.jdo.PersistenceManagerFactory; //導入依賴的package包/類
/**
 * Actually release a PersistenceManager for the given factory.
 * Same as {@code releasePersistenceManager}, but throwing the original JDOException.
 * @param pm PersistenceManager to close
 * @param pmf PersistenceManagerFactory that the PersistenceManager was created with
 * (can be {@code null})
 * @throws JDOException if thrown by JDO methods
 */
public static void doReleasePersistenceManager(PersistenceManager pm, PersistenceManagerFactory pmf)
		throws JDOException {

	if (pm == null) {
		return;
	}
	// Only release non-transactional PersistenceManagers.
	if (!isPersistenceManagerTransactional(pm, pmf)) {
		logger.debug("Closing JDO PersistenceManager");
		pm.close();
	}
}