Как слушатели событий Hibernate ведут себя, используя HQL (именованные запросы)? - PullRequest
Новая
       11

Как слушатели событий Hibernate ведут себя, используя HQL (именованные запросы)?

3 голосов
/ 22 ноября 2010

Я создаю много прослушивателей событий hibernate, чтобы перехватывать все события базы данных, такие как загрузка, сохранение, обновление, удаление и т. Д. Все события будут перехвачены, но именованные запросы не будут перехватываться моим прослушивателем событий загрузки, и я хотел быспросите, что мне нужно реализовать, чтобы отлавливать запрос имен?

1 Ответ

3 голосов
/ 05 марта 2017

Как правило, участие событий определяется типом события (слушателя) и способом извлечения данных. Хотя вы правы и на самом деле, очевидно, есть разница между работой с запросами сущностей (EntityManager.find ..., Session.load ...) и работой с запросами HQL. Но не имеет значения, используются ли HQL-запросы как именованный запрос или как обычный запрос в случае HQL.

Чтобы показать это, я создал небольшой пример с использованием Spring Boot, Spring Data JPA и Hibernate, потому что с этой комбинацией легко работать. Эффекты аналогичны другим архитектурам приложений, использующим Hibernate.

Если мы используем, например, события загрузки, то непосредственно загруженные сущности распространяют только события типа LoadEvent, если вы используете EntityManager.find / Session.load для получения сущности. При использовании HQL (либо с Spring Data JPA, либо с обычным Hibernate) существуют события только этого определенного типа, если подозрительные объекты выбираются косвенно как ассоциация. В отличие от этого, PostLoadEvents запускаются в каждом случае.

Вот несколько простых классов, чтобы попробовать это.

InterceptionByEventCandidate (эти объекты, которые мы хотим перехватить): 

package com.example.model;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;

@Entity
public class InterceptionByEventCandidate {

    public static final String FETCH_ALL_QUERY = "SELECT c FROM InterceptionByEventCandidate c";
    public static final String FETCH_ALL_NAMED_QUERY = "selectAll";

    @Id
    @GeneratedValue
    private long id;

    private boolean interceptedOnLoad;

    private boolean interceptedOnPostLoad;

    public long getId() {
        return id;
    }

    public boolean isInterceptedOnLoad() {
        return interceptedOnLoad;
    }

    public void setInterceptedOnLoad(boolean interceptedOnLoad) {
        this.interceptedOnLoad = interceptedOnLoad;
    }

    public boolean isInterceptedOnPostLoad() {
        return interceptedOnPostLoad;
    }

    public void setInterceptedOnPostLoad(boolean interceptedOnPostLoad) {
        this.interceptedOnPostLoad = interceptedOnPostLoad;
    }

}

CandidateHost (необходим хост для демонстрации извлечения ассоциации): 

package com.example.model;

import javax.persistence.CascadeType;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.OneToOne;

@Entity
public class CandidateHost {

    public static final String FETCH_ALL_QUERY = "SELECT h FROM CandidateHost h JOIN h.candidate c";
    public static final String FETCH_ALL_NAMED_QUERY = "selectAllHosts";

    @Id
    @GeneratedValue
    private long id;

    @OneToOne(cascade = CascadeType.PERSIST)
    private InterceptionByEventCandidate candidate;

    public InterceptionByEventCandidate getCandidate() {
        return candidate;
    }

    public void setCandidate(InterceptionByEventCandidate candidate) {
        this.candidate = candidate;
    }

}

Теперь нам нужен подходящий слушатель, для удобства мы объединяем оба упомянутых типа событий в одном HqlEventListener: 

package com.example.event;

import org.hibernate.HibernateException;
import org.hibernate.event.spi.LoadEvent;
import org.hibernate.event.spi.LoadEventListener;
import org.hibernate.event.spi.PostLoadEvent;
import org.hibernate.event.spi.PostLoadEventListener;
import org.springframework.stereotype.Component;

import com.example.model.InterceptionByEventCandidate;

@Component
public class HqlEventListener implements LoadEventListener, PostLoadEventListener {

    private static final long serialVersionUID = -7248393324424903264L;

    @Override
    public void onLoad(LoadEvent event, LoadType loadType) throws HibernateException {
        final Object object = event.getResult();
        if (object instanceof InterceptionByEventCandidate) {
            ((InterceptionByEventCandidate) object).setInterceptedOnLoad(true);
        }
    }

    @Override
    public void onPostLoad(PostLoadEvent event) {
        final Object object = event.getEntity();
        if (object instanceof InterceptionByEventCandidate) {
            ((InterceptionByEventCandidate) object).setInterceptedOnPostLoad(true);
        }
    }

}

Чтобы сообщить Hibernate, какие события мы хотим обработать, нам нужна некоторая конфигурация: 

package com.example.event;

import javax.annotation.PostConstruct;
import javax.persistence.EntityManagerFactory;
import javax.persistence.PersistenceUnit;

import org.hibernate.event.service.spi.EventListenerRegistry;
import org.hibernate.event.spi.EventType;
import org.hibernate.internal.SessionFactoryImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;

@Configuration
public class EntityListenerConfiguration {

    @PersistenceUnit
    private EntityManagerFactory entityManagerFactory;

    @Autowired
    private HqlEventListener hqlEventListener;

    @PostConstruct
    protected void init() {
        final SessionFactoryImpl sessionFactory = entityManagerFactory.unwrap(SessionFactoryImpl.class);
        final EventListenerRegistry eventListenerRegistry = sessionFactory.getServiceRegistry()
                .getService(EventListenerRegistry.class);

        eventListenerRegistry.getEventListenerGroup(EventType.LOAD).appendListener(hqlEventListener);
        eventListenerRegistry.getEventListenerGroup(EventType.POST_LOAD).appendListener(hqlEventListener);

    }
}

Для предоставления и повторного использования именованных запросов мы храним их в файле информации о пакете: 

@NamedQueries({
        @NamedQuery(name = InterceptionByEventCandidate.FETCH_ALL_NAMED_QUERY, query = InterceptionByEventCandidate.FETCH_ALL_QUERY),
        @NamedQuery(name = CandidateHost.FETCH_ALL_NAMED_QUERY, query = CandidateHost.FETCH_ALL_QUERY) })

package com.example.event;

import org.hibernate.annotations.NamedQueries;
import org.hibernate.annotations.NamedQuery;

import com.example.model.CandidateHost;
import com.example.model.InterceptionByEventCandidate;

И, конечно, некоторые репозитории Spring Data JPA необходимы, чтобы проверить, показывают ли они то же поведение.

InterceptionByEventCandidateRepository: 

package com.example.repository;

import java.util.Set;

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import com.example.model.InterceptionByEventCandidate;

@Repository
public interface InterceptionByEventCandidateRepository extends CrudRepository<InterceptionByEventCandidate, Long> {

    @Query(InterceptionByEventCandidate.FETCH_ALL_QUERY)
    @Transactional(readOnly = true)
    Set<InterceptionByEventCandidate> findByHQL();

    @Query(name = InterceptionByEventCandidate.FETCH_ALL_NAMED_QUERY)
    @Transactional(readOnly = true)
    Set<InterceptionByEventCandidate> findByNamedHQL();
}

CandidateHostRepository: 

package com.example.repository;

import java.util.Set;

import org.springframework.data.jpa.repository.Query;
import org.springframework.data.repository.CrudRepository;
import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Transactional;

import com.example.model.CandidateHost;

@Repository
public interface CandidateHostRepository extends CrudRepository<CandidateHost, Long> {

    @Query(CandidateHost.FETCH_ALL_QUERY)
    @Transactional(readOnly = true)
    Set<CandidateHost> findByHQL();

    @Query(name = CandidateHost.FETCH_ALL_NAMED_QUERY)
    @Transactional(readOnly = true)
    Set<CandidateHost> findByNamedHQL();

}

Это было много примеров кода, и вот (я должен признать, что также огромный) тест, чтобы проверить, как события отличаются между стратегиями: 

package com.example.repository;

import static org.hamcrest.CoreMatchers.is;
import static org.junit.Assert.assertThat;

import java.util.Set;

import javax.persistence.EntityManager;
import javax.persistence.PersistenceContext;

import org.hibernate.Query;
import org.hibernate.Session;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.transaction.annotation.Transactional;

import com.example.model.CandidateHost;
import com.example.model.InterceptionByEventCandidate;

@RunWith(SpringRunner.class)
@Transactional
@SpringBootTest
public class HqlEventTests {

    @Autowired
    private CandidateHostRepository candidateHostRepository;

    @Autowired
    private InterceptionByEventCandidateRepository interceptionByEventCandidateRepository;

    @PersistenceContext
    private EntityManager entityManager;

    @Before
    public void setUp() {
        final CandidateHost host = new CandidateHost();
        final InterceptionByEventCandidate interceptionByEventCandidate = new InterceptionByEventCandidate();
        host.setCandidate(interceptionByEventCandidate);
        candidateHostRepository.save(host);
        entityManager.flush();
        entityManager.clear();
    }

    @Test
    public void interceptCandidateAtFindingHostBySpringDataJpaHql() {
        final Set<CandidateHost> result = candidateHostRepository.findByHQL();
        verifyInterceptions(result.stream().findFirst().get().getCandidate(), true, true);
    }

    @Test
    public void interceptCandidateAtFindingHostBySpringDataJpaNamedHql() {
        final Set<CandidateHost> result = candidateHostRepository.findByNamedHQL();
        verifyInterceptions(result.stream().findFirst().get().getCandidate(), true, true);
    }

    @Test
    public void interceptCandidateAtFindingHostByHibernateHql() {
        final Session session = entityManager.unwrap(Session.class);
        final Query query = session.createQuery(CandidateHost.FETCH_ALL_QUERY);

        verifyInterceptions(((CandidateHost) query.list().stream().findFirst().get()).getCandidate(), true, true);
    }

    @Test
    public void interceptCandidateAtFindingHostByHibernateNamedHql() {
        final Session session = entityManager.unwrap(Session.class);
        final Query query = session.getNamedQuery(CandidateHost.FETCH_ALL_NAMED_QUERY);

        verifyInterceptions(((CandidateHost) query.list().stream().findFirst().get()).getCandidate(), true, true);
    }

    @Test
    public void interceptCandidateBySpringDataJpaHql() {
        final Set<InterceptionByEventCandidate> result = interceptionByEventCandidateRepository.findByHQL();
        verifyInterceptions(result.stream().findFirst().get(), false, true);
    }

    @Test
    public void interceptCandidateBySpringDataJpaNamedHql() {
        final Set<InterceptionByEventCandidate> result = interceptionByEventCandidateRepository.findByNamedHQL();
        verifyInterceptions(result.stream().findFirst().get(), false, true);
    }

    @Test
    public void interceptCandidateByHibernateHql() {
        final Session session = entityManager.unwrap(Session.class);
        final Query query = session.createQuery(InterceptionByEventCandidate.FETCH_ALL_QUERY);

        verifyInterceptions((InterceptionByEventCandidate) query.list().stream().findFirst().get(), false, true);
    }

    @Test
    public void interceptCandidateByHibernateNamedHql() {
        final Session session = entityManager.unwrap(Session.class);
        final Query query = session.getNamedQuery(InterceptionByEventCandidate.FETCH_ALL_NAMED_QUERY);

        verifyInterceptions((InterceptionByEventCandidate) query.list().stream().findFirst().get(), false, true);
    }

    @Test
    public void interceptCandidateByHibernateFind() {
        long id = interceptionByEventCandidateRepository.findAll().iterator().next().getId();

        entityManager.flush();
        entityManager.clear();

        final Session session = entityManager.unwrap(Session.class);
        final InterceptionByEventCandidate candidate = session.load(InterceptionByEventCandidate.class, id);
        verifyInterceptions(candidate, true, true);
    }

    private void verifyInterceptions(final InterceptionByEventCandidate candidate, final boolean expectedLoadEventState,
            final boolean expectedPostLoadEventState) {
        assertThat("Expected load state did not match!", candidate.isInterceptedOnLoad(), is(expectedLoadEventState));
        assertThat("Expected postload state did not match!", candidate.isInterceptedOnPostLoad(),
                is(expectedPostLoadEventState));
    }
}

Глядя на эти тесты, мы видим, что нет разницы между именованными и обычными запросами. Если вы беспокоитесь о событиях другого типа, я думаю, это легко расширить.

...