Java 使用Hibernate4'；s积分器模式和Spring'；s依赖注入

我习惯于使用Spring进行依赖项注入，如下所示：

<context:component-scan base-package="org.emmerich.myapp" />

然而，随着Hibernate 4.0的变化，我们现在建议使用新的

Integrator

接口进行服务发现。这包括为触发器添加事件侦听器，如

postpdate

，

postDelete

等

不幸的是，这并不能很好地通过带注释的依赖项进行依赖项注入。我有以下设置：

我定义了一个积分器，用于将我的侦听器添加到

ServiceFactory

。这在文件

META-INF/services/org.hibernate.integrator.spi.integrator

中引用

public class MyIntegrator implements Integrator {

    private MyListener listener;

    public MyIntegrator() {
        listener = new MyListener();
    }

    @Override
    public void integrate(Configuration configuration,
                          SessionFactoryImplementor sessionFactory,
                          SessionFactoryServiceRegistry serviceRegistry) {
    final EventListenerRegistry eventRegistry =
        serviceRegistry.getService(EventListenerRegistry.class);

    eventRegistry.prependListeners(EventType.POST_COMMIT_INSERT, listener);

}

我还定义了类

MyListener

，它看起来像典型的事件监听器

@Component
public class MyListener implements PostInsertEventListener {

    @Autowired
    private Dependent dependent;

    public void onPostInsert(PostInsertEvent event) {
         // dependent == null
    }

}

不幸的是，正如评论所示，这是行不通的。我想这是因为我在

MyIntegrator

内部实例化

MyListener

，它不会拾取组件，也不会自动连接组件。但是，如果我尝试这样做：

@Component
public class MyIntegrator {

     @Autowired
     private MyListener listener;

     ...
}

那么侦听器不是自动连接的

首先，使用Spring执行

新建MyListener（）

时感觉不对。我希望能够将其定义为一个自动连接的依赖项，并让Spring为我创建一个单例。我的问题是：

在新的Integrator接口中使用依赖项注入的最佳方法是什么？积分器用于构建SessionFactory，因此当要求它们自己进行集成时，我想没有可用的应用程序上下文。正因为如此，我在Integrator中需要的任何bean都需要以“老式”的方式创建，并且不会在它们上接收自动连线

我对春天的世界很陌生，你能说这是我应该期待看到的吗？我知道当我在SessionFactory中时，我在不同的应用程序范围内，但是即使我通过

new

创建bean，是否有办法获得对bean的引用并启用autowire

我提出的解决方案使用了

ApplicationContextAware

。这意味着每当上下文可用时，

MyListener

就会收到对

ApplicationContext

的引用，我在方法调用时从上下文引用bean，而不是在bean构造时。使用

new

创建bean并没有限制这一点，因此Spring仍然为我提供了应用程序上下文：

@Component
public class MyListener implements PostInsertEventListener, ApplicationContextAware {

    private static ApplicationContext context;

    public void onPostInsert(PostInsertEvent event) {
         // getDependent() == correct!
    }

    public void setApplicationContext(ApplicationContext context) throws BeanException {
        this.context = context;
    }

    public Dependent getDependent() {
        return context.getBean(Dependent.class);
    }

}

---

有更好的方法吗？

如评论中所述，我采用了另一种集成Spring管理的HibernateEventListeners的方法。代码如下：

Spring管理的Hibernate事件侦听器的标识符接口：

public interface HibernateEventListener { }

HibernateIntegrator：

@Service
public class HibernateSpringIntegrator {

    private static final Logger log = LoggerFactory.getLogger(HibernateSpringIntegrator.class);

    @Autowired
    private HibernateEntityManagerFactory entityManagerFactory;

    @Autowired
    private HibernateSpringIntegratorRegistry hibernateSpringIntegratorRegistry;

    @PostConstruct
    public void registerListeners() {
        log.debug("Registering Spring managed HibernateEventListeners");

        EventListenerRegistry listenerRegistry = ((SessionFactoryImpl) entityManagerFactory
                .getSessionFactory()).getServiceRegistry().getService(
                EventListenerRegistry.class);
        List<HibernateEventListener> eventListeners = hibernateSpringIntegratorRegistry
                .getHibernateEventListeners();
        for (HibernateEventListener hel : eventListeners) {
            log.debug("Registering: {}", hel.getClass());
            if (PreInsertEventListener.class.isAssignableFrom(hel.getClass())) {
                listenerRegistry.appendListeners(EventType.PRE_INSERT,
                        (PreInsertEventListener) hel);
            }
            if (PreUpdateEventListener.class.isAssignableFrom(hel.getClass())) {
                listenerRegistry.appendListeners(EventType.PRE_UPDATE,
                        (PreUpdateEventListener) hel);
            }
            if (PreDeleteEventListener.class.isAssignableFrom(hel.getClass())) {
                listenerRegistry.appendListeners(EventType.PRE_DELETE,
                        (PreDeleteEventListener) hel);
            }
            if (PostInsertEventListener.class.isAssignableFrom(hel.getClass())) {
                listenerRegistry.appendListeners(EventType.POST_INSERT,
                        (PostInsertEventListener) hel);
            }
            if (PostUpdateEventListener.class.isAssignableFrom(hel.getClass())) {
                listenerRegistry.appendListeners(EventType.POST_UPDATE,
                        (PostUpdateEventListener) hel);
            }
            if (PostDeleteEventListener.class.isAssignableFrom(hel.getClass())) {
                listenerRegistry.appendListeners(EventType.POST_DELETE,
                        (PostDeleteEventListener) hel);
            }
            // Currently we do not need other types of eventListeners. Else this method needs to be extended.
        }
    }
}

@服务
公共类HibernateStringIntegrator{
私有静态最终记录器log=LoggerFactory.getLogger（HibernateSpringIntegrator.class）；
@自动连线
私有HibernateEntityManager工厂；
@自动连线
私有HibernateStringIntegratorRegistry HibernateStringIntegratorRegistry；
@施工后
public void registerListeners（）{
debug（“注册Spring管理的HibernateEventListeners”）；
EventListenerRegistry listenerRegistry=（（SessionFactoryImpl）entityManagerFactory
.getSessionFactory（））.getServiceRegistry（）.getService(
EventListenerRegistry.class）；
List eventListeners=HibernateStringIntegratorRegistry
.getHibernateEventListeners（）；
for（HibernateeEventListener hel:eventListeners）{
debug（“注册：{}”，hel.getClass（））；
if（PreInsertEventListener.class.isAssignableFrom（hel.getClass（）））{
listenerRegistry.appendListeners（EventType.PRE_INSERT，
（预插入事件列表器）hel）；
}
if（PreUpdateEventListener.class.isAssignableFrom（hel.getClass（）））{
listenerRegistry.appendListeners（EventType.PRE_UPDATE，
（预更新事件列表）hel）；
}
if（PreDeleteEventListener.class.isAssignableFrom（hel.getClass（）））{
listenerRegistry.appendListeners（EventType.PRE_DELETE，
（PreDeleteEventListener）hel）；
}
if（PostInsertEventListener.class.isAssignableFrom（hel.getClass（）））{
listenerRegistry.appendListeners（EventType.POST_INSERT，
（PostInsertEventListener）hel）；
}
if（PostUpdateEventListener.class.isAssignableFrom（hel.getClass（）））{
listenerRegistry.appendListeners（EventType.POST\u更新，
（PositUpdateEventListener）hel）；
}
if（PostDeleteEventListener.class.isAssignableFrom（hel.getClass（）））{
listenerRegistry.appendListeners（EventType.POST_DELETE，
（PostDeleteEventListener）hel）；
}
//目前我们不需要其他类型的EventListener。否则此方法需要扩展。
}
}
}

“登记处”：

@组件
公共类HibernateStringIntegratorRegistry{
@自动连线（必需=错误）
私有列表hibernateEventListeners；
公共列表getHibernateEventListeners（）{
如果（hibernateEventListeners==null）{
返回集合。emptyList（）；
}
返回hibernateEventListeners；
}
}

下面是一个示例实现：

@Component
public class MailGenerationEventListener implements HibernateEventListener, 
    PostDeleteEventListener, PostInsertEventListener, PostUpdateEventListener {

    @Override
    public void onPostDelete(PostDeleteEvent event) {
        Class<?> entityClass = event.getEntity().getClass();
        ...
    }

    @Override
    public void onPostInsert(PostInsertEvent event) {
        Class<?> entityClass = event.getEntity().getClass();
        ...
    }

    @Override
    public void onPostUpdate(PostUpdateEvent event) {
        Class<?> entityClass = event.getEntity().getClass();
        ...
    }
}

@组件
公共类MailGenerationEventListener实现HibernateEventListener，
PostDeleteEventListener、PostInsertEventListener、PostUpdateEventListener{
@凌驾
PostDelete上的公共无效（PostDeleteEvent事件）{
类entityClass=event.getEntity（）.getClass（）；
...
}
@凌驾
公共无效onPostInsert（PostInsertEvent事件）{
类entityClass=event.getEntity（）.getClass（）；
...
}
@爱
@Component
public class HibernateSpringIntegratorRegistry {

    @Autowired(required = false)
    private List<HibernateEventListener> hibernateEventListeners;

    public List<HibernateEventListener> getHibernateEventListeners() {
        if (hibernateEventListeners == null) {
            return Collections.emptyList();
        }
        return hibernateEventListeners;
    }
}

@Component
public class MailGenerationEventListener implements HibernateEventListener, 
    PostDeleteEventListener, PostInsertEventListener, PostUpdateEventListener {

    @Override
    public void onPostDelete(PostDeleteEvent event) {
        Class<?> entityClass = event.getEntity().getClass();
        ...
    }

    @Override
    public void onPostInsert(PostInsertEvent event) {
        Class<?> entityClass = event.getEntity().getClass();
        ...
    }

    @Override
    public void onPostUpdate(PostUpdateEvent event) {
        Class<?> entityClass = event.getEntity().getClass();
        ...
    }
}

<!-- Make our validators use DI if necessary -->
<bean id="validator" class="org.springframework.validation.beanvalidation.LocalValidatorFactoryBean"/>

<bean id="sessionFactory" class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
    <!-- other props -->
    <property name="hibernateProperties">
            <map>
                <entry key="javax.persistence.validation.factory" value-ref="validator" />
            </map>
    </property>
</bean>