【源码】Spring Data JPA原理解析之Hibernate EventListener使用及原理

package com.jingai.jpa.dao.entity;
 
@EntityListeners({AuditingEntityListener.class, UserAuditListener.class})
@Table(name = "tb_user")
public class UserEntity {
     // 省略其他
 
}

public enum CallbackType {
	PRE_UPDATE( PreUpdate.class ),
	POST_UPDATE( PostUpdate.class ),
	PRE_PERSIST( PrePersist.class ),
	POST_PERSIST( PostPersist.class ),
	PRE_REMOVE( PreRemove.class ),
	POST_REMOVE( PostRemove.class ),
	POST_LOAD( PostLoad.class )
	;
 
	private Class<? extends Annotation> callbackAnnotation;
 
	CallbackType(Class<? extends Annotation> callbackAnnotation) {
		this.callbackAnnotation = callbackAnnotation;
	}
 
	public Class<? extends Annotation> getCallbackAnnotation() {
		return callbackAnnotation;
	}
}

package org.hibernate.jpa.event.internal;
 
public final class CallbacksFactory {
	private static final Logger log = Logger.getLogger( CallbacksFactory.class );
 
	/**
	 * @param entityBindings：持久化类信息集合
	 */
	public static CallbackRegistryImplementor buildCallbackRegistry(SessionFactoryOptions options,
			ServiceRegistry serviceRegistry, Collection<PersistentClass> entityBindings) {
		if ( !jpaCallBacksEnabled( options ) ) {
			return new EmptyCallbackRegistryImpl();
		}
		ManagedBeanRegistry beanRegistry = serviceRegistry.getService( ManagedBeanRegistry.class );
		CallbackRegistryImplementor registry = new CallbackRegistryImpl();
		Set<Class<?>> entityClasses = new HashSet<>();
		// 遍历持久化类
		for ( PersistentClass persistentClass : entityBindings ) {
			if ( persistentClass.getClassName() == null ) {
				// we can have dynamic (non-java class) mapping
				continue;
			}
 
			Class<?> entityClass = persistentClass.getMappedClass();
 
			if ( !entityClasses.add( entityClass ) ) {
				if ( log.isDebugEnabled() ) {
					log.debugf(
							"Class [%s] already has callbacks registered; " +
									"assuming this means the class was mapped twice " +
									"(using hbm.xml entity-name support) - skipping subsequent registrations" +
									"to avoid duplicates",
							entityClass.getName()
					);
				}
				continue;
			}
			// persistentClass.getCallbackDefinitions()：获取解析的监听器信息
			// 将监听器信息封装成Callback对象，添加到registry对象中
			registry.registerCallbacks( persistentClass.getMappedClass(),
					buildCallbacks( persistentClass.getCallbackDefinitions(), beanRegistry ) );
			// 持久化类中的方法添加的监听器封装成Callback对象，添加到registry对象中
			for ( @SuppressWarnings("unchecked") Iterator<Property> propertyIterator = persistentClass.getDeclaredPropertyIterator();
					propertyIterator.hasNext(); ) {
				final Property property = propertyIterator.next();
				registry.registerCallbacks( persistentClass.getMappedClass(),
						buildCallbacks( property.getCallbackDefinitions(), beanRegistry ) );
			}
		}
 
		return registry;
	}
 
	/**
	 * 通过CallbackDefinition定义信息，转化为Callback数组
	 */
	private static Callback[] buildCallbacks(List<CallbackDefinition> callbackDefinitions,
			ManagedBeanRegistry beanRegistry) {
		if ( callbackDefinitions == null || callbackDefinitions.isEmpty() ) {
			return null;
		}
		List<Callback> callbacks = new ArrayList<>();
		for ( CallbackDefinition definition : callbackDefinitions ) {
			callbacks.add( definition.createCallback( beanRegistry ) );
		}
		return callbacks.toArray( new Callback[0] );
	}
 
	private static boolean jpaCallBacksEnabled(SessionFactoryOptions options) {
		return options.areJPACallbacksEnabled();
	}
 
}

package org.hibernate.jpa.event.internal;
 
@SuppressWarnings({"unchecked", "serial"})
final class CallbackRegistryImpl implements CallbackRegistryImplementor {
	private HashMap<Class, Callback[]> preCreates = new HashMap<Class, Callback[]>();
	private HashMap<Class, Callback[]> postCreates = new HashMap<Class, Callback[]>();
	private HashMap<Class, Callback[]> preRemoves = new HashMap<Class, Callback[]>();
	private HashMap<Class, Callback[]> postRemoves = new HashMap<Class, Callback[]>();
	private HashMap<Class, Callback[]> preUpdates = new HashMap<Class, Callback[]>();
	private HashMap<Class, Callback[]> postUpdates = new HashMap<Class, Callback[]>();
	private HashMap<Class, Callback[]> postLoads = new HashMap<Class, Callback[]>();
 
	@Override
	public boolean hasRegisteredCallbacks(Class entityClass, CallbackType callbackType) {
		final HashMap<Class, Callback[]> map = determineAppropriateCallbackMap( callbackType );
		return notEmpty( map.get( entityClass ) );
	}
 
	@Override
	public void registerCallbacks(Class entityClass, Callback[] callbacks) {
		if ( callbacks == null || callbacks.length == 0 ) {
			return;
		}
		// 遍历回调
		for ( Callback callback : callbacks ) {
			// 返回对应类型的回调Map对象，key为对应实体类，value为对应类型的监听器的Callback数组，对于监听器，是ListenerCallback对象
			final HashMap<Class, Callback[]> map = determineAppropriateCallbackMap( callback.getCallbackType() );
			Callback[] entityCallbacks = map.get( entityClass );
			if ( entityCallbacks == null ) {
				entityCallbacks = new Callback[0];
			}
			entityCallbacks = ArrayHelper.join( entityCallbacks, callback );
			map.put( entityClass, entityCallbacks );
		}
	}
 
	/**
	 * 根据类型，返回对应类型的Map对象
	 */
	private HashMap<Class, Callback[]> determineAppropriateCallbackMap(CallbackType callbackType) {
		if ( callbackType == CallbackType.PRE_PERSIST ) {
			return preCreates;
		}
 
		if ( callbackType == CallbackType.POST_PERSIST ) {
			return postCreates;
		}
 
		if ( callbackType == CallbackType.PRE_REMOVE ) {
			return preRemoves;
		}
 
		if ( callbackType == CallbackType.POST_REMOVE ) {
			return postRemoves;
		}
 
		if ( callbackType == CallbackType.PRE_UPDATE ) {
			return preUpdates;
		}
 
		if ( callbackType == CallbackType.POST_UPDATE ) {
			return postUpdates;
		}
 
		if ( callbackType == CallbackType.POST_LOAD ) {
			return postLoads;
		}
 
		throw new PersistenceException( "Unrecognized JPA callback type [" + callbackType + "]" );
	}
 
	// 省略其他
}

public class EventListenerRegistryImpl implements EventListenerRegistry, Stoppable {
	public static class Builder {
		private final CallbackRegistryImplementor callbackRegistry;
		private final boolean jpaBootstrap;
 
		private final Map<EventType<?>,EventListenerGroup<?>> listenerGroupMap = new TreeMap<>(
				Comparator.comparing( EventType::ordinal )
		);
 
		/*
		 * 保存信息，执行applyStandardListeners()
		 */
		public Builder(CallbackRegistryImplementor callbackRegistry, boolean jpaBootstrap) {
			this.callbackRegistry = callbackRegistry;
			this.jpaBootstrap = jpaBootstrap;
 
			applyStandardListeners();
		}
 
		/*
		 * 对不同的事件类型，添加默认的监听器
		 */
		private void applyStandardListeners() {
			
			// 创建的默认监听器
			prepareListeners( PERSIST, new DefaultPersistEventListener() );
 
			// 创建刷新的默认监听器
			prepareListeners( PERSIST_ONFLUSH, new DefaultPersistOnFlushEventListener() );
 
			// 删除的默认监听器
			prepareListeners( DELETE, new DefaultDeleteEventListener() );
 
            // 修改后的监听器
			prepareListeners( POST_UPDATE, new PostUpdateEventListenerStandardImpl() );			
 
            // 省略其他
		}
 
		public <T> void prepareListeners(EventType<T> eventType) {
			prepareListeners( eventType, null );
		}
 
		public <T> void prepareListeners(EventType<T> type, T defaultListener) {
			prepareListeners(
					type,
					defaultListener,
					t -> { // 不同类型监听器，创建监听组。即同一个类型，可以有多个监听器
						if ( type == EventType.POST_COMMIT_DELETE
								|| type == EventType.POST_COMMIT_INSERT
								|| type == EventType.POST_COMMIT_UPDATE ) {
							return new PostCommitEventListenerGroupImpl<>( type, callbackRegistry, jpaBootstrap );
						}
						else {
							return new EventListenerGroupImpl<>( type, callbackRegistry, jpaBootstrap );
						}
					}
			);
		}
 
		/*
		 * 按类型、监听组分类，保存到Map中
		 */
		@SuppressWarnings({"rawtypes", "unchecked"})
		public <T> void prepareListeners(
				EventType<T> type,
				T defaultListener,
				Function<EventType<T>,EventListenerGroupImpl<T>> groupCreator) {
			final EventListenerGroupImpl listenerGroup = groupCreator.apply( type );
 
			if ( defaultListener != null ) {
				listenerGroup.appendListener( defaultListener );
			}
 
			listenerGroupMap.put( type, listenerGroup );
		}
 
		// 省略其他
	}
}

package com.jingai.jpa.listener;
 
@Component
@Slf4j
public class UserEventListener implements PersistEventListener, CallbackRegistryConsumer, InitializingBean {
 
    @Resource
    private SessionFactory sessionFactory;
 
    @Override
    public void onPersist(PersistEvent event) throws HibernateException {
        log.info("UserEventListener onPersist ....");
    }
 
    @Override
    public void onPersist(PersistEvent event, Map createdAlready) throws HibernateException {
        log.info("UserEventListener onPersist222 ....");
    }
 
    @Override
    public void injectCallbackRegistry(CallbackRegistry callbackRegistry) {
        log.info("UserEventListener callbackRegistry ....");
    }
 
    @Override
    public void afterPropertiesSet() throws Exception {
        log.info("init  SessionFactoryImplementor {}", sessionFactory);
        // 将监听器添加到SessionFactory中
        if(sessionFactory != null) {
            sessionFactory.getSessionFactory().getServiceRegistry()
                    .getService(EventListenerRegistry.class)
                    .prependListeners(EventType.PERSIST, UserEventListener.class);
        }
    }
}

package org.hibernate.internal;
 
public final class FastSessionServices {
 
	public final EventListenerGroup<AutoFlushEventListener> eventListenerGroup_AUTO_FLUSH;
	public final EventListenerGroup<ClearEventListener> eventListenerGroup_CLEAR;
	public final EventListenerGroup<DeleteEventListener> eventListenerGroup_DELETE;
	public final EventListenerGroup<PersistEventListener> eventListenerGroup_PERSIST;
	public final EventListenerGroup<PersistEventListener> eventListenerGroup_PERSIST_ONFLUSH;
 
 
	FastSessionServices(SessionFactoryImpl sf) {
		Objects.requireNonNull( sf );
		final ServiceRegistryImplementor sr = sf.getServiceRegistry();
		final JdbcServices jdbcServices = sf.getJdbcServices();
		final SessionFactoryOptions sessionFactoryOptions = sf.getSessionFactoryOptions();
 
		// 获取EventListenerRegistry，在EventListenerRegistry中保存归类的监听器
		final EventListenerRegistry eventListenerRegistry = sr.getService( EventListenerRegistry.class );
		this.eventListenerGroup_AUTO_FLUSH = listeners( eventListenerRegistry, EventType.AUTO_FLUSH );
		this.eventListenerGroup_CLEAR = listeners( eventListenerRegistry, EventType.CLEAR );
		this.eventListenerGroup_DELETE = listeners( eventListenerRegistry, EventType.DELETE );
		this.eventListenerGroup_DIRTY_CHECK = listeners( eventListenerRegistry, EventType.DIRTY_CHECK );
 
		// 省略其他
	}
	
	// 省略其他
 
}