java - 需要模式建议(Hibernate + Guice)

Question

我正在寻找有关如何将运行时依赖项注入(inject)从 Hibernate 检索的 JPA 实体的建议。我的问题本质上是这样的:

我有一个事务对象的多个不同子类。每个 Transaction 子类在执行时都有不同的行为，并且需要来自环境的一组不同的依赖项。这些 Transaction 对象由 Hibernate 作为 JPA 实体进行管理，因此我无法有效地使用 Guice 进行依赖项注入(inject)以使用它们的环境依赖项填充实例，就像我在应用程序的其余部分中所做的那样。

为了解决这个问题，我采用了一种有点类似于访问者模式的方法，如下所示:

public abstract class Transaction {
    // ...snip...
    public abstract void apply(Transactor transactor);
}

public class TransactionA extends Transaction {
    public void apply(Transactor transactor) {
        transactor.execute(this);
    }
}

public class TransactionB extends Transaction {
    public void apply(Transactor transactor) {
        transactor.execute(this);
    }
}
// other Transaction subclasses with the same boilerplate

public interface Transactor {
    public void execute(TransactionA trans);
    public void execute(TransactionB trans);
    // corresponding methods for other transaction types.
}

public class BeginTransactor {
     @Inject
     private Foo execAdep;
     public void execute(TransactionA trans) {
         execAdep.doSomething(...)    
     }

     @Inject
     private Bar execBdep;
     public void execute(TransactionB trans) {
         execBdep.doOther(...)    
     }
 }

我针对事务生命周期的不同部分有不同的 Transactor 实现。这些可以使用 Guice 依赖注入(inject)到我想要处理交易的上下文中，我只需调用:

 Transactor transactor = injector.getInstance(BeginTransactor.class); //Guice injection
 Transaction t = ... //get a transaction instance
 t.apply(transactor);

我不喜欢这种方法的地方是 (1) 并非每种类型的事务都应该在每个生命周期阶段都可执行，但是每个 Transactor 都必须为每个事务子类实现一个 execute() 方法，并且 (2) 基本上没有一个注入(inject)的依赖项用于处理不止一种交易类型。

本质上，我的 Transactor 接口(interface)和实现有很多不相关的杂物混杂在一起。理想情况下，我只需要对事务对象本身使用 execute() 方法，但我不希望调用代码必须知道事务的类型或它需要的依赖项。此外，这会使测试变得更加困难，因为如果 execute() 方法是 Transaction 对象上的具体方法，我将无法轻松模拟它。使用 Transactor 接口(interface)意味着我可以根据需要轻松模拟它。

谁能建议如何以一种类型安全的方式解决这个问题，这种方式不会导致在 Transactor 中出现一堆几乎不相关的行为，同时保持可测试性并允许依赖注入(inject)？

Answer 1

我使用 guice 进行交易，但我使用 AOP 来执行它们。我几乎没有样板，以牺牲一点“魔法”为代价。只要您拦截的类(class)“在俱乐部”，它就非常有效。

class BusinessLogic {
    @Inject public EntityManager em;

    @Transactional
    publc void doSomething() {
       //...
       em.persist(myObj);
    }

    @Transactional
    public void doSomethingElse() {
       //...
       em.delete(myObj);
    }
}

class TransactionalInterceptor implements MethodInterceptor {
    @Inject static Injector injector;
    public Object intercept(MethodInvocation invocation) {
        EntityManager em = injector.getInstance(EntityManager.class);
        em.getTransaction().begin();
        Object result = invocation.proceed();
        em.getTransaction().commit();
        return result;
    }
}
class TransactionalModule extends AbstractModule {
    public void configure() {
        requestStaticInjection(TransactionalInterceptor.class);
        bindInterceptor(Matchers.any(), Matchers.annotatedWith(Transactional.class),
                 new TransactionalInterceptor());
    }
}