Comment utiliser le Printemps géré Hibernate intercepteurs au Printemps de Démarrage?

Il n'est pas particulièrement facile d'ajouter de Hibernate intercepteur qui est aussi un Ressort Bean, mais vous pouvez facilement ajouter un intercepteur si c'est géré entièrement par Hibernate. Pour faire ajouter les éléments suivants à votre application.properties:

spring.jpa.properties.hibernate.ejb.interceptor=my.package.MyInterceptorClassName

Si vous avez besoin de l'Intercepteur à être également un haricot que vous pouvez créer votre propre LocalContainerEntityManagerFactoryBean. Le EntityManagerFactoryBuilder de Printemps de Démarrage 1.1.4 est un peu trop restrictive par le générique de l'propriétés de sorte que vous besoin de lancer pour (Map), nous allons nous intéresser à la fixation de 1,2.

@Bean
public LocalContainerEntityManagerFactoryBean entityManagerFactory(
        EntityManagerFactoryBuilder factory, DataSource dataSource,
        JpaProperties properties) {
    Map<String, Object> jpaProperties = new HashMap<String, Object>();
    jpaProperties.putAll(properties.getHibernateProperties(dataSource));
    jpaProperties.put("hibernate.ejb.interceptor", hibernateInterceptor());
    return factory.dataSource(dataSource).packages("sample.data.jpa")
            .properties((Map) jpaProperties).build();
}

@Bean
public EmptyInterceptor hibernateInterceptor() {
    return new EmptyInterceptor() {
        @Override
        public boolean onLoad(Object entity, Serializable id, Object[] state,
                String[] propertyNames, Type[] types) {
            System.out.println("Loaded " + id);
            return false;
        }
    };
}

Mon simple un exemple de fichier de hibernate auditeurs pour le printemps de démarrage (printemps-amorçage-starter 1.2.4.De presse)

import org.hibernate.event.service.spi.EventListenerRegistry;
import org.hibernate.event.spi.*;
import org.hibernate.internal.SessionFactoryImpl;
import org.hibernate.jpa.HibernateEntityManagerFactory;
import org.springframework.stereotype.Component;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import javax.annotation.PostConstruct;
import javax.inject.Inject;
import javax.persistence.EntityManagerFactory;
@Component
public class UiDateListener implements PostLoadEventListener, PreUpdateEventListener {
@Inject EntityManagerFactory entityManagerFactory;
@PostConstruct
private void init() {
HibernateEntityManagerFactory hibernateEntityManagerFactory = (HibernateEntityManagerFactory) this.entityManagerFactory;
SessionFactoryImpl sessionFactoryImpl = (SessionFactoryImpl) hibernateEntityManagerFactory.getSessionFactory();
EventListenerRegistry registry = sessionFactoryImpl.getServiceRegistry().getService(EventListenerRegistry.class);
registry.appendListeners(EventType.POST_LOAD, this);
registry.appendListeners(EventType.PRE_UPDATE, this);
}
@Override
public void onPostLoad(PostLoadEvent event) {
final Object entity = event.getEntity();
if (entity == null) return;
//some logic after entity loaded
}
@Override
public boolean onPreUpdate(PreUpdateEvent event) {
final Object entity = event.getEntity();
if (entity == null) return false;
//some logic before entity persist
return false;
}
}

J'ai trouvé une autre approche, après des recherches de deux jours sur la façon d'intégrer Hibernate Intercepteurs avec Spring Data JPA, ma solution est un hybride entre java et de configuration xml de configuration, mais cette post a été très utile. Ma dernière solution a été:

AuditLogInterceptor classe:

public class AuditLogInterceptor extends EmptyInterceptor{
private int updates;
//interceptor for updates
public boolean onFlushDirty(Object entity,
Serializable id,
Object[] currentState,
Object[] previousState,
String[] propertyNames,
Type[] types) {
if ( entity instanceof Auditable ) {
updates++;
for ( int i=0; i < propertyNames.length; i++ ) {
if ( "lastUpdateTimestamp".equals( propertyNames[i] ) ) {
currentState[i] = new Date();
return true;
}
}
}
return false;
}
}

Source De Données De Configuration Java:

@Bean
DataSource dataSource() {
//Use JDBC Datasource 
DataSource dataSource = new DriverManagerDataSource();
((DriverManagerDataSource)dataSource).setDriverClassName(jdbcDriver);
((DriverManagerDataSource)dataSource).setUrl(jdbcUrl);
((DriverManagerDataSource)dataSource).setUsername(jdbcUsername);
((DriverManagerDataSource)dataSource).setPassword(jdbcPassword);                    
return dataSource;
}

Entité et les Gestionnaires de Transaction de l'ajout de l'Intercepteur

<bean id="entityManagerFactory"
class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean"
p:persistenceUnitName="InterceptorPersistentUnit" p:persistenceXmlLocation="classpath:audit/persistence.xml"
p:dataSource-ref="dataSource" p:jpaVendorAdapter-ref="jpaAdapter">
<property name="loadTimeWeaver">
<bean class="org.springframework.instrument.classloading.InstrumentationLoadTimeWeaver"/>
</property>              
</bean>
<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager"
p:entityManagerFactory-ref="entityManagerFactory" />
<bean id="jpaAdapter"
class="org.springframework.orm.jpa.vendor.HibernateJpaVendorAdapter"
p:database="ORACLE" p:showSql="true" />

persistance fichier de configuration

     <persistence-unit name="InterceptorPersistentUnit">
<class>com.app.CLASSTOINTERCEPT</class>           
<shared-cache-mode>ENABLE_SELECTIVE</shared-cache-mode>
<properties>
<property name="hibernate.ejb.interceptor"
value="com.app.audit.AuditLogInterceptor" />
</properties>
</persistence-unit>

Bonjour,

Donner à cette lecture: https://github.com/spring-projects/spring-boot/commit/59d5ed58428d8cb6c6d9fb723d0e334fe3e7d9be (utilisation: HibernatePropertiesCustomizer interface)

OU

Pour de simples Intercepteur:

Afin de configurer cela dans votre application, il vous suffit d'ajouter: printemps.jpa.les propriétés.mise en veille prolongée.ejb.intercepteur = chemin d'accès.d'.intercepteur (en application.les propriétés). L'intercepteur doit lui-même être @Composante.

Aussi longtemps que l'intercepteur ne fait pas les utiliser tout de haricots. Sinon, c'est un peu plus compliqué mais je serais plus qu'heureux de vous offrir la solution.

N'oubliez pas d'ajouter dans l'application-test.propriétés, un EmptyInterceptor de ne pas utiliser le système de journalisation (ou ce que vous voulez l'utiliser pour) dans les tests (qui ne serait pas très utile).

Espère que c'était de l'utiliser pour vous.

Comme note finale: toujours mettre à jour votre Spring /Hibernate versions (utiliser le plus tard possible) et vous verrez que la plupart de code deviendront superflus comme les versions plus récentes tentent de réduire les configurations autant que possible.