Example usage for org.hibernate.event.spi EventType POST_COMMIT_INSERT

List of usage examples for org.hibernate.event.spi EventType POST_COMMIT_INSERT

  1. HOME
  2. Java
  3. org.hibernate
  4. org.hibernate.event.spi.*
  5. EventType
  6. POST_COMMIT_INSERT

Introduction

In this page you can find the example usage for org.hibernate.event.spi EventType POST_COMMIT_INSERT.

Prototype

EventType POST_COMMIT_INSERT

To view the source code for org.hibernate.event.spi EventType POST_COMMIT_INSERT.

Click Source Link

Usage

From source file:at.molindo.esi4j.module.hibernate.DefaultHibernateLifecycleInjector.java

License:Apache License

@Override
public synchronized void injectLifecycle(SessionFactory sessionFactory,
        Esi4JBatchedEventProcessor batchedEventProcessor) {
    if (_listener != null) {
        throw new IllegalStateException("already injected");
    }/* www  .jav a2s . c o  m*/

    SessionFactoryImpl sessionFactoryImpl = (SessionFactoryImpl) sessionFactory;

    EventListenerRegistry registry = sessionFactoryImpl.getServiceRegistry()
            .getService(EventListenerRegistry.class);

    _listener = doCreateListener(sessionFactoryImpl, batchedEventProcessor);

    if (_listener instanceof PostInsertEventListener) {
        if (registerPostCommitListeneres) {
            registry.appendListeners(EventType.POST_COMMIT_INSERT, (PostInsertEventListener) _listener);
        } else {
            registry.appendListeners(EventType.POST_INSERT, (PostInsertEventListener) _listener);
        }
    }

    if (_listener instanceof PostUpdateEventListener) {
        if (registerPostCommitListeneres) {
            registry.appendListeners(EventType.POST_COMMIT_UPDATE, (PostUpdateEventListener) _listener);
        } else {
            registry.appendListeners(EventType.POST_UPDATE, (PostUpdateEventListener) _listener);
        }
    }

    if (_listener instanceof PostDeleteEventListener) {
        if (registerPostCommitListeneres) {
            registry.appendListeners(EventType.POST_COMMIT_DELETE, (PostDeleteEventListener) _listener);
        } else {
            registry.appendListeners(EventType.POST_DELETE, (PostDeleteEventListener) _listener);
        }
    }

    // collections
    if (!registerPostCommitListeneres) {
        if (_listener instanceof PostCollectionRecreateEventListener) {
            registry.appendListeners(EventType.POST_COLLECTION_RECREATE,
                    (PostCollectionRecreateEventListener) _listener);
        }

        if (_listener instanceof PostCollectionRemoveEventListener) {
            registry.appendListeners(EventType.POST_COLLECTION_REMOVE,
                    (PostCollectionRemoveEventListener) _listener);
        }

        if (_listener instanceof PostCollectionUpdateEventListener) {
            registry.appendListeners(EventType.POST_COLLECTION_UPDATE,
                    (PostCollectionUpdateEventListener) _listener);
        }
    }
}

From source file:com.invariantproperties.sandbox.springentitylistener.listener.HibernateEntityListenersConfigurer.java

License:Apache License

@PostConstruct
public void registerListeners() {
    HibernateEntityManagerFactory hemf = (HibernateEntityManagerFactory) emf;
    SessionFactory sf = hemf.getSessionFactory();
    EventListenerRegistry registry = ((SessionFactoryImpl) sf).getServiceRegistry()
            .getService(EventListenerRegistry.class);

    registry.getEventListenerGroup(EventType.PRE_INSERT).appendListener(listener);
    registry.getEventListenerGroup(EventType.POST_COMMIT_INSERT).appendListener(listener);
    registry.getEventListenerGroup(EventType.PRE_UPDATE).appendListener(listener);
    registry.getEventListenerGroup(EventType.POST_COMMIT_UPDATE).appendListener(listener);
    registry.getEventListenerGroup(EventType.PRE_DELETE).appendListener(listener);
    registry.getEventListenerGroup(EventType.POST_COMMIT_DELETE).appendListener(listener);
    registry.getEventListenerGroup(EventType.POST_LOAD).appendListener(listener);
}

From source file:com.invariantproperties.sandbox.springentitylistener.listener.SpringEntityListenersConfigurer.java

License:Apache License

@PostConstruct
public void registerListeners() {
    // get registry so we can add listeners.
    HibernateEntityManagerFactory hemf = (HibernateEntityManagerFactory) entityManagerFactory;
    SessionFactory sf = hemf.getSessionFactory();
    EventListenerRegistry registry = ((SessionFactoryImpl) sf).getServiceRegistry()
            .getService(EventListenerRegistry.class);

    final Set<Object> listeners = new HashSet<Object>();

    EntityManager entityManager = null;/*from  w w w . j  av  a2s  . c o  m*/
    try {
        entityManager = hemf.createEntityManager();
        // for every entity known to the system...
        for (EntityType<?> entity : entityManager.getMetamodel().getEntities()) {

            // ... register event listeners for it.
            if (entity.getJavaType().isAnnotationPresent(SpringEntityListeners.class)) {
                SpringEntityListeners annotation = (SpringEntityListeners) entity.getJavaType()
                        .getAnnotation(SpringEntityListeners.class);
                for (Class<?> beanClass : annotation.value()) {
                    Map<String, ?> map = context.getBeansOfType(beanClass);
                    listeners.addAll(map.values());
                }
            }
        }
    } finally {
        if (entityManager != null) {
            entityManager.close();
        }
    }

    // register adapter and listeners.
    HibernateEntityListenersAdapter adapter = new HibernateEntityListenersAdapter(
            new ArrayList<Object>(listeners), entityManagerFactory);
    registry.getEventListenerGroup(EventType.PRE_INSERT).appendListener(adapter);
    registry.getEventListenerGroup(EventType.POST_COMMIT_INSERT).appendListener(adapter);
    registry.getEventListenerGroup(EventType.PRE_UPDATE).appendListener(adapter);
    registry.getEventListenerGroup(EventType.POST_COMMIT_UPDATE).appendListener(adapter);
    registry.getEventListenerGroup(EventType.PRE_DELETE).appendListener(adapter);
    registry.getEventListenerGroup(EventType.POST_COMMIT_DELETE).appendListener(adapter);
    registry.getEventListenerGroup(EventType.POST_LOAD).appendListener(adapter);
}

From source file:edu.nps.moves.mmowgli.hibernate.AbstractVHib.java

License:Open Source License

protected void _installDataBaseListeners()// AppMaster apMas)
{
    DatabaseListeners dlis = new DatabaseListeners(sr);
    MSysOut.println(HIBERNATE_LOGS, "Installing db listeners");
    EventListenerRegistry registry = ((SessionFactoryImpl) sf).getServiceRegistry()
            .getService(EventListenerRegistry.class);
    registry.addDuplicationStrategy(new DuplicationStrategy() {
        @Override/*from   www .ja va 2  s.  com*/
        public boolean areMatch(Object listener, Object original) {
            return false;
        }

        @Override
        public Action getAction() {
            return null;
        }
    });

    if (dlis.getSaveListener() != null)
        registry.getEventListenerGroup(EventType.SAVE).appendListener(dlis.getSaveListener());
    if (dlis.getUpdateListener() != null)
        registry.getEventListenerGroup(EventType.UPDATE).appendListener(dlis.getUpdateListener());
    if (dlis.getSaveOrUpdateListener() != null)
        registry.getEventListenerGroup(EventType.SAVE_UPDATE).appendListener(dlis.getSaveOrUpdateListener());
    if (dlis.getDeleteListener() != null)
        registry.getEventListenerGroup(EventType.DELETE).appendListener(dlis.getDeleteListener());
    if (dlis.getPostInsertListener() != null)
        registry.getEventListenerGroup(EventType.POST_COMMIT_INSERT)
                .appendListener(dlis.getPostInsertListener());
    if (dlis.getPostUpdateListener() != null)
        registry.getEventListenerGroup(EventType.POST_COMMIT_UPDATE)
                .appendListener(dlis.getPostUpdateListener());

    MSysOut.println(HIBERNATE_LOGS, "db listeners installed");

    dlis.enableListeners(true); // may have to be moved later
}

From source file:net.krotscheck.jersey2.hibernate.factory.HibernateSessionFactoryFactory.java

License:Apache License

/**
 * This method automatically adds discovered hibernate event listeners into
 * the hibernate service registry.// w w w  .j  a v  a 2s.  com
 *
 * @param registry The service registry.
 */
private void injectEventListeners(final ServiceRegistry registry) {

    EventListenerRegistry eventRegistry = registry.getService(EventListenerRegistry.class);

    List<PostInsertEventListener> postInsertEvents = locator.getAllServices(PostInsertEventListener.class);
    for (PostInsertEventListener piEventListener : postInsertEvents) {
        logger.trace("Registering PostInsert: " + piEventListener.getClass().getCanonicalName());
        eventRegistry.appendListeners(EventType.POST_INSERT, piEventListener);
    }

    List<PostUpdateEventListener> postUpdateEvents = locator.getAllServices(PostUpdateEventListener.class);
    for (PostUpdateEventListener puEventListener : postUpdateEvents) {
        logger.trace("Registering PostUpdate: " + puEventListener.getClass().getCanonicalName());
        eventRegistry.appendListeners(EventType.POST_UPDATE, puEventListener);
    }

    List<PostDeleteEventListener> postDeleteEvents = locator.getAllServices(PostDeleteEventListener.class);
    for (PostDeleteEventListener pdEventListener : postDeleteEvents) {
        logger.trace("Registering PostDelete: " + pdEventListener.getClass().getCanonicalName());
        eventRegistry.appendListeners(EventType.POST_DELETE, pdEventListener);
    }

    List<PreInsertEventListener> preInsertEvents = locator.getAllServices(PreInsertEventListener.class);
    for (PreInsertEventListener piEventListener : preInsertEvents) {
        logger.trace("Registering PreInsert: " + piEventListener.getClass().getCanonicalName());
        eventRegistry.appendListeners(EventType.PRE_INSERT, piEventListener);
    }

    List<PreUpdateEventListener> preUpdateEvents = locator.getAllServices(PreUpdateEventListener.class);
    for (PreUpdateEventListener puEventListener : preUpdateEvents) {
        logger.trace("Registering PreUpdate: " + puEventListener.getClass().getCanonicalName());
        eventRegistry.appendListeners(EventType.PRE_UPDATE, puEventListener);
    }

    List<PreDeleteEventListener> preDeleteEvents = locator.getAllServices(PreDeleteEventListener.class);
    for (PreDeleteEventListener pdEventListener : preDeleteEvents) {
        logger.trace("Registering PreDelete: " + pdEventListener.getClass().getCanonicalName());
        eventRegistry.appendListeners(EventType.PRE_DELETE, pdEventListener);
    }

    List<PostCommitInsertEventListener> pciEvents = locator.getAllServices(PostCommitInsertEventListener.class);
    for (PostCommitInsertEventListener cpiEventListener : pciEvents) {
        logger.trace("Registering PostCommitInsert: " + cpiEventListener.getClass().getCanonicalName());
        eventRegistry.appendListeners(EventType.POST_COMMIT_INSERT, cpiEventListener);
    }

    List<PostCommitUpdateEventListener> pcuEvents = locator.getAllServices(PostCommitUpdateEventListener.class);
    for (PostCommitUpdateEventListener cpuEventListener : pcuEvents) {
        logger.trace("Registering PostCommitUpdate: " + cpuEventListener.getClass().getCanonicalName());
        eventRegistry.appendListeners(EventType.POST_COMMIT_UPDATE, cpuEventListener);
    }

    List<PostCommitDeleteEventListener> pcdEvents = locator.getAllServices(PostCommitDeleteEventListener.class);
    for (PostCommitDeleteEventListener cpdEventListener : pcdEvents) {
        logger.trace("Registering PostCommitDelete: " + cpdEventListener.getClass().getCanonicalName());
        eventRegistry.appendListeners(EventType.POST_COMMIT_DELETE, cpdEventListener);
    }
}

From source file:net.krotscheck.jersey2.hibernate.factory.HibernateSessionFactoryFactoryTest.java

License:Apache License

/**
 * Test the application event injectors.
 *//*from ww  w .ja v a 2  s .  c  o  m*/
@Test
public void testEventInjection() {

    // Create a fake application.
    SessionFactory factoryFactory = locator.getService(SessionFactory.class);
    Assert.assertNotNull(factoryFactory);

    ServiceRegistry serviceRegistry = ((SessionFactoryImpl) factoryFactory).getServiceRegistry();
    EventListenerRegistry eventRegistry = serviceRegistry.getService(EventListenerRegistry.class);

    EventListenerGroup<PreInsertEventListener> priGroup = eventRegistry
            .getEventListenerGroup(EventType.PRE_INSERT);
    assertContainsListener(priGroup);

    EventListenerGroup<PostInsertEventListener> poiGroup = eventRegistry
            .getEventListenerGroup(EventType.POST_INSERT);
    assertContainsListener(poiGroup);

    EventListenerGroup<PreUpdateEventListener> pruGroup = eventRegistry
            .getEventListenerGroup(EventType.PRE_UPDATE);
    assertContainsListener(pruGroup);

    EventListenerGroup<PostUpdateEventListener> pouGroup = eventRegistry
            .getEventListenerGroup(EventType.POST_UPDATE);
    assertContainsListener(pouGroup);

    EventListenerGroup<PreDeleteEventListener> prdGroup = eventRegistry
            .getEventListenerGroup(EventType.PRE_DELETE);
    assertContainsListener(prdGroup);

    EventListenerGroup<PostDeleteEventListener> podGroup = eventRegistry
            .getEventListenerGroup(EventType.POST_DELETE);
    assertContainsListener(podGroup);

    EventListenerGroup<PostInsertEventListener> pciGroup = eventRegistry
            .getEventListenerGroup(EventType.POST_COMMIT_INSERT);
    assertContainsListener(pciGroup);

    EventListenerGroup<PostUpdateEventListener> pcuGroup = eventRegistry
            .getEventListenerGroup(EventType.POST_COMMIT_UPDATE);
    assertContainsListener(pcuGroup);

    EventListenerGroup<PostDeleteEventListener> pcdGroup = eventRegistry
            .getEventListenerGroup(EventType.POST_COMMIT_DELETE);
    assertContainsListener(pcdGroup);
}