Java UnitOfWork类代码示例

import com.google.inject.persist.UnitOfWork; //导入依赖的package包/类
@Override
protected final void configure() {
	configurePersistence();

	requireBinding(PersistService.class);
	requireBinding(UnitOfWork.class);
/*if[AOP]*/
	// wrapping in an if[AOP] just to allow this to compile in NO_AOP -- it won't be used

	// class-level @Transacational
	bindInterceptor(annotatedWith(Transactional.class),
			new TransactionalClassMethodMatcher(),
			getTransactionInterceptor());
	// method-level @Transacational
	bindInterceptor(any(), new TransactionalMethodMatcher(), getTransactionInterceptor());
   /*end[AOP]*/
}
 

import com.google.inject.persist.UnitOfWork; //导入依赖的package包/类
protected void configurePersistence() {
	bind(String[].class).annotatedWith(Neo4j.class).toInstance(packages);

	if (null != properties) {
		bind(Properties.class).annotatedWith(Neo4j.class).toInstance(properties);
	} else {
		bind(Properties.class).annotatedWith(Neo4j.class).toProvider(Providers.of(null));
	}

	bind(Neo4jPersistService.class).in(Singleton.class);
	bind(PersistService.class).to(Neo4jPersistService.class);
	bind(UnitOfWork.class).to(Neo4jPersistService.class);
	bind(Session.class).toProvider(Neo4jPersistService.class);

	transactionInterceptor = new Neo4jLocalTxnInterceptor();
	requestInjection(transactionInterceptor);
}
 

import com.google.inject.persist.UnitOfWork; //导入依赖的package包/类
public void testCall() throws Exception {
    final String message = "TestMessage";
    final CallableInUnitOfWork<String> unitOfWork = new CallableInUnitOfWork<>(
            () -> new UnitOfWork() {

                @Override
                public void begin() {

                }

                @Override
                public void end() {

                }
            }, () -> message);

    assertEquals(message, unitOfWork.call());
}
 

import com.google.inject.persist.UnitOfWork; //导入依赖的package包/类
@Override
protected void configurePersistence() {
  bindConstant().annotatedWith(Jpa.class).to(jpaUnit);

  bind(JpaPersistService.class).in(Singleton.class);

  bind(PersistService.class).to(JpaPersistService.class);
  bind(UnitOfWork.class).to(JpaPersistService.class);
  bind(EntityManager.class).toProvider(JpaPersistService.class);
  bind(EntityManagerFactory.class)
      .toProvider(JpaPersistService.EntityManagerFactoryProvider.class);

  transactionInterceptor = new JpaLocalTxnInterceptor();
  requestInjection(transactionInterceptor);

  // Bind dynamic finders.
  for (Class<?> finder : dynamicFinders) {
    bindFinder(finder);
  }
}
 

import com.google.inject.persist.UnitOfWork; //导入依赖的package包/类
public void testSimpleTransaction() {
  injector
      .getInstance(JoiningLocalTransactionsTest.TransactionalObject.class)
      .runOperationInTxn();

  EntityManager em = injector.getInstance(EntityManager.class);
  assertFalse("txn was not closed by transactional service", em.getTransaction().isActive());

  //test that the data has been stored
  Object result =
      em.createQuery("from JpaTestEntity where text = :text")
          .setParameter("text", UNIQUE_TEXT)
          .getSingleResult();
  injector.getInstance(UnitOfWork.class).end();

  assertTrue("odd result returned fatal", result instanceof JpaTestEntity);

  assertEquals(
      "queried entity did not match--did automatic txn fail?",
      UNIQUE_TEXT,
      ((JpaTestEntity) result).getText());
}
 

import com.google.inject.persist.UnitOfWork; //导入依赖的package包/类
public void testSimpleTransactionRollbackOnUnchecked() {
  try {
    injector
        .getInstance(JoiningLocalTransactionsTest.TransactionalObject.class)
        .runOperationInTxnThrowingUnchecked();
  } catch (RuntimeException re) {
    //ignore
    injector.getInstance(UnitOfWork.class).end();
  }

  EntityManager em = injector.getInstance(EntityManager.class);
  assertFalse(
      "Session was not closed by transactional service (rollback didnt happen?)",
      em.getTransaction().isActive());

  try {
    Object result =
        em.createQuery("from JpaTestEntity where text = :text")
            .setParameter("text", TRANSIENT_UNIQUE_TEXT)
            .getSingleResult();
    injector.getInstance(UnitOfWork.class).end();
    fail("a result was returned! rollback sure didnt happen!!!");
  } catch (NoResultException e) {
  }
}
 

import com.google.inject.persist.UnitOfWork; //导入依赖的package包/类
public void testSimpleTransaction() {
  injector.getInstance(TransactionalObject.class).runOperationInTxn();

  EntityManager em = injector.getInstance(EntityManager.class);
  assertFalse("txn was not closed by transactional service", em.getTransaction().isActive());

  //test that the data has been stored
  Object result =
      em.createQuery("from JpaTestEntity where text = :text")
          .setParameter("text", UNIQUE_TEXT)
          .getSingleResult();
  injector.getInstance(UnitOfWork.class).end();

  assertTrue("odd result returned fatal", result instanceof JpaTestEntity);

  assertEquals(
      "queried entity did not match--did automatic txn fail?",
      UNIQUE_TEXT,
      ((JpaTestEntity) result).getText());
}
 

import com.google.inject.persist.UnitOfWork; //导入依赖的package包/类
public void testSimpleTransactionWithMerge() {
  JpaTestEntity entity =
      injector.getInstance(TransactionalObject.class).runOperationInTxnWithMerge();

  EntityManager em = injector.getInstance(EntityManager.class);
  assertFalse("txn was not closed by transactional service", em.getTransaction().isActive());

  //test that the data has been stored
  assertTrue("Em was closed after txn!", em.isOpen());

  Object result =
      em.createQuery("from JpaTestEntity where text = :text")
          .setParameter("text", UNIQUE_TEXT_MERGE)
          .getSingleResult();
  injector.getInstance(UnitOfWork.class).end();

  assertTrue(result instanceof JpaTestEntity);

  assertEquals(
      "queried entity did not match--did automatic txn fail?",
      UNIQUE_TEXT_MERGE,
      ((JpaTestEntity) result).getText());
}
 

import com.google.inject.persist.UnitOfWork; //导入依赖的package包/类
public void testSimpleTransactionRollbackOnUnchecked() {
  try {
    injector.getInstance(TransactionalObject.class).runOperationInTxnThrowingUnchecked();
  } catch (RuntimeException re) {
    //ignore
    injector.getInstance(UnitOfWork.class).end();
  }

  EntityManager em = injector.getInstance(EntityManager.class);
  assertFalse(
      "Session was not closed by transactional service (rollback didnt happen?)",
      em.getTransaction().isActive());

  try {
    Object result =
        em.createQuery("from JpaTestEntity where text = :text")
            .setParameter("text", TRANSIENT_UNIQUE_TEXT)
            .getSingleResult();
    injector.getInstance(UnitOfWork.class).end();
    fail("a result was returned! rollback sure didnt happen!!!");
  } catch (NoResultException e) {
  }
}
 

import com.google.inject.persist.UnitOfWork; //导入依赖的package包/类
public void testSimpleTransaction() {
  injector.getInstance(TransactionalObject.class).runOperationInTxn();

  EntityManager em = injector.getInstance(EntityManager.class);
  assertFalse(em.getTransaction().isActive());

  //test that the data has been stored
  Object result =
      em.createQuery("from JpaTestEntity where text = :text")
          .setParameter("text", UNIQUE_TEXT)
          .getSingleResult();
  injector.getInstance(UnitOfWork.class).end();

  assertTrue("odd result returned fatal", result instanceof JpaTestEntity);

  assertEquals(
      "queried entity did not match--did automatic txn fail?",
      UNIQUE_TEXT,
      ((JpaTestEntity) result).getText());
  injector.getInstance(UnitOfWork.class).end();
}
 

import com.google.inject.persist.UnitOfWork; //导入依赖的package包/类
public void disabled_testSimpleTransactionWithMergeAndDF() {
  EntityManager emOrig = injector.getInstance(EntityManager.class);
  JpaTestEntity entity =
      injector.getInstance(TransactionalObject.class).runOperationInTxnWithMergeForDf();

  EntityManager em = injector.getInstance(EntityManager.class);
  assertFalse("txn was not closed by transactional service", em.getTransaction().isActive());

  //test that the data has been stored
  assertTrue("Em was closed after txn!", em.isOpen());
  assertEquals("Em was not kept open across txns", emOrig, em);
  assertTrue("Merge did not store state or did not return persistent copy", em.contains(entity));

  Object result = injector.getInstance(TransactionalObject.class).find(UNIQUE_TEXT_MERGE_FORDF);
  injector.getInstance(UnitOfWork.class).end();

  assertNotNull(result);
  assertTrue(result instanceof JpaTestEntity);

  assertEquals(
      "queried entity did not match--did automatic txn fail?",
      UNIQUE_TEXT_MERGE_FORDF,
      ((JpaTestEntity) result).getText());
  injector.getInstance(UnitOfWork.class).end();
}
 

import com.google.inject.persist.UnitOfWork; //导入依赖的package包/类
public void testSimpleTransactionRollbackOnUnchecked() {
  try {
    injector.getInstance(TransactionalObject.class).runOperationInTxnThrowingUnchecked();
  } catch (RuntimeException re) {
    //ignore
    injector.getInstance(UnitOfWork.class).end();
  }

  EntityManager em = injector.getInstance(EntityManager.class);
  assertFalse(
      "Session was not closed by transactional service (rollback didnt happen?)",
      em.getTransaction().isActive());

  try {
    Object result =
        em.createQuery("from JpaTestEntity where text = :text")
            .setParameter("text", TRANSIENT_UNIQUE_TEXT)
            .getSingleResult();
    injector.getInstance(UnitOfWork.class).end();
    fail();
  } catch (NoResultException e) {
  }

  injector.getInstance(UnitOfWork.class).end();
}
 

import com.google.inject.persist.UnitOfWork; //导入依赖的package包/类
@Override protected void configurePersistence() {
  bindConstant().annotatedWith(Jpa.class).to(jpaUnit);

  if (null != properties) {
    bind(Properties.class).annotatedWith(Jpa.class).toInstance(properties);
  } else {
    bind(Properties.class).annotatedWith(Jpa.class)
        .toProvider(Providers.<Properties>of(null));
  }

  bind(JpaPersistService.class).in(Singleton.class);

  bind(PersistService.class).to(JpaPersistService.class);
  bind(UnitOfWork.class).to(JpaPersistService.class);
  bind(EntityManager.class).toProvider(JpaPersistService.class);
  bind(EntityManagerFactory.class)
      .toProvider(JpaPersistService.EntityManagerFactoryProvider.class);

  transactionInterceptor = new JpaLocalTxnInterceptor();
  requestInjection(transactionInterceptor);

  // Bind dynamic finders.
  for (Class<?> finder : dynamicFinders) {
    bindFinder(finder);
  }
}
 

import com.google.inject.persist.UnitOfWork; //导入依赖的package包/类
public void testSimpleCrossTxnWork() {
  //pretend that the request was started here
  EntityManager em = injector.getInstance(EntityManager.class);

  JpaTestEntity entity = injector
      .getInstance(ManualLocalTransactionsWithCustomMatcherTest.TransactionalObject.class)
      .runOperationInTxn();
  injector.getInstance(ManualLocalTransactionsWithCustomMatcherTest.TransactionalObject.class)
      .runOperationInTxn2();

  //persisted entity should remain in the same em (which should still be open)
  assertTrue("EntityManager  appears to have been closed across txns!",
      injector.getInstance(EntityManager.class).contains(entity));
  assertTrue("EntityManager  appears to have been closed across txns!", em.contains(entity));
  assertTrue("EntityManager appears to have been closed across txns!", em.isOpen());

  injector.getInstance(UnitOfWork.class).end();

  //try to query them back out
  em = injector.getInstance(EntityManager.class);
  assertNotNull(em.createQuery("from JpaTestEntity where text = :text")
      .setParameter("text", UNIQUE_TEXT).getSingleResult());
  assertNotNull(em.createQuery("from JpaTestEntity where text = :text")
      .setParameter("text", UNIQUE_TEXT_2).getSingleResult());
  em.close();
}
 

import com.google.inject.persist.UnitOfWork; //导入依赖的package包/类
public void testSimpleTransaction() {
  injector.getInstance(JoiningLocalTransactionsTest.TransactionalObject.class)
      .runOperationInTxn();

  EntityManager em = injector.getInstance(EntityManager.class);
  assertFalse("txn was not closed by transactional service",
      em.getTransaction().isActive());

  //test that the data has been stored
  Object result = em.createQuery("from JpaTestEntity where text = :text")
      .setParameter("text", UNIQUE_TEXT).getSingleResult();
  injector.getInstance(UnitOfWork.class).end();

  assertTrue("odd result returned fatal", result instanceof JpaTestEntity);

  assertEquals("queried entity did not match--did automatic txn fail?", UNIQUE_TEXT,
      ((JpaTestEntity) result).getText());
}