0

我正在尝试拦截Seam 3项目中的方法persist和updateof 。javax.persistence.EntityManager

在我尝试制作的微框架的先前版本（Seam 2）中，我org.hibernate.Interceptor使用persistence.xml.

但是现在我们处于 JEE6 环境中，我想要更多“类似 CDI”的东西。

我希望在进入EntityManager.persist通话之前，@BeforeTrackablePersist抛出一个事件。同样，我希望在进入呼叫@BeforeTrackableUpdate之前抛出一个事件。是我的一些人可以实现的接口，以便在持久或合并之前被拦截。EntityManager.mergeTrackableEntity

我正在使用 Seam 3 (3.1.0.Beta3) Extended Persistence Manager：

public class EntityManagerHandler {
    @SuppressWarnings("unused")
    @ExtensionManaged
    @Produces
    @PersistenceUnit
    private EntityManagerFactory entityManagerFactory;
}

所以我做了一个javax.enterprise.inject.spi.Extension，并尝试了很多方法来做到这一点：

public class TrackableExtension implements Extension {

    @Inject @BeforeTrackablePersisted
    private Event<Trackable> beforeTrackablePersistedEvent;

    @Inject @BeforeTrackableMerged
    private Event<Trackable> beforeTrackableMergedEvent;

    @SuppressWarnings("unchecked")
    public void processEntityManagerTarget(@Observes final ProcessInjectionTarget<EntityManager> event) {
        final InjectionTarget<EntityManager> injectionTarget = event.getInjectionTarget();
        final InjectionTarget<EntityManager> injectionTargetProxy = (InjectionTarget<EntityManager>) Proxy.newProxyInstance(event.getClass().getClassLoader(), new Class[] {InjectionTarget.class}, new InvocationHandler() {
            @Override
            public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
                if ("produce".equals(method.getName())) {
                    final CreationalContext<EntityManager> ctx = (CreationalContext<EntityManager>) args[0];
                    final EntityManager entityManager = decorateEntityManager(injectionTarget, ctx);
                    return entityManager;
                } else {
                    return method.invoke(injectionTarget, args);
                }
            }
        });
        event.setInjectionTarget(injectionTargetProxy);
    }

    public void processEntityManagerType(@Observes final ProcessAnnotatedType<EntityManager> event) {
        final AnnotatedType<EntityManager> type = event.getAnnotatedType();
        final AnnotatedTypeBuilder<EntityManager> builder = new AnnotatedTypeBuilder<EntityManager>().readFromType(type);

        for (final AnnotatedMethod<? super EntityManager> method : type.getMethods()) {
            final String name = method.getJavaMember().getName();
            if (StringUtils.equals(name, "persist") || StringUtils.equals(name, "merge")) {
                builder.addToMethod(method, TrackableInterceptorBindingLiteral.INSTANCE);
            }
        }

        event.setAnnotatedType(builder.create());
    }

    public void processEntityManagerBean(@Observes final ProcessBean<EntityManager> event) {
        final AnnotatedType<EntityManager> annotatedType = (AnnotatedType<EntityManager>)event.getAnnotated();
//      not even called
    }

    public void processEntityManager(@Observes final ProcessProducer<?, EntityManager> processProducer) {
        processProducer.setProducer(decorate(processProducer.getProducer()));
    }

    private Producer<EntityManager> decorate(final Producer<EntityManager> producer) {
        return new Producer<EntityManager>() {
            @Override
            public EntityManager produce(final CreationalContext<EntityManager> ctx) {
                return decorateEntityManager(producer, ctx);
            }
            @Override
            public Set<InjectionPoint> getInjectionPoints() {
                return producer.getInjectionPoints();
            }
            @Override
            public void dispose(final EntityManager instance) {
                producer.dispose(instance);
            }
        };
    }

    private EntityManager decorateEntityManager(final Producer<EntityManager> producer, final CreationalContext<EntityManager> ctx) {
        final EntityManager entityManager = producer.produce(ctx);
        return (EntityManager) Proxy.newProxyInstance(entityManager.getClass().getClassLoader(), new Class[] {EntityManager.class}, new InvocationHandler() {
            @Override
            public Object invoke(final Object proxy, final Method method, final Object[] args) throws Throwable {
                final String methodName = method.getName();
                if (StringUtils.equals(methodName, "persist")) {
                    fireEventIfTrackable(beforeTrackablePersistedEvent, args[0]);
                } else if (StringUtils.equals(methodName, "merge")) {
                    fireEventIfTrackable(beforeTrackableMergedEvent, args[0]);
                }
                return method.invoke(entityManager, args);
            }

            private void fireEventIfTrackable(final Event<Trackable> event, final Object entity) {
                if (entity instanceof Trackable) {
                    event.fire(Reflections.<Trackable>cast(entity));
                }
            }
        });
    }
}

在所有这些观察者方法中，只有第二个 ( processEntityManagerType(@Observes ProcessAnnotatedType<EntityManager>)) 被调用！即使对方法persist和进行了绑定merge，我的拦截器也永远不会被调用（我当然已经使用正确的行启用了它beans.xml，并使用文件启用了我的扩展名services/javax.enterprise.inject.spi.Extension）。

我认为 CDI 很简单的事情最后似乎真的很难......或者也许 Seam 3 做了一些事情，阻止了这段代码正确执行......

有人知道如何处理吗？

4

2 回答 2

1

我认为你让这比它需要的更难。首先，虽然 JPA 和 CDI 集成在 Java EE 6 中不是很好，但我们非常希望 Java EE 7 和 JPA 2.1 中的变化。

您要做的是为 EntityManager 创建自己的生产者，它将委托给 EntityManager 的实际实例，但在调用您感兴趣的方法时也会触发您自己的事件。看看 Seam Persistence来源查看可以做到这一点的一种方法。

于 2011-11-22T04:58:24.543 回答
0

由于最后我在SEAMPERSIST-75中应用了 Seam Persistence 的小补丁，理论上可以通过扩展org.jboss.seam.persistence.HibernatePersistenceProvider和覆盖该方法来做到这一点proxyEntityManager(EntityManager)。

于 2012-01-03T14:46:29.393 回答