hibernate事件监听器，可用于修改前后日志记录，新增修改属性值默认值设置，

package ca.acentury.lamta.lm.advice;

import ca.acentury.lamta.framework.abstraction.session.LamtaCurrentUserInfoA;
import ca.acentury.lamta.framework.abstraction.session.LamtaHttpSession;
import ca.acentury.lamta.framework.data.LamtaIdentity;
import ca.acentury.lamta.spring.framework.session.LamtaSpringSessionFactory;
import ca.acentury.lamta.spring.jpa.support.entity.AbstractStandardPO;
import org.hibernate.HibernateException;
import org.hibernate.engine.spi.SessionFactoryImplementor;
import org.hibernate.event.service.spi.EventListenerRegistry;
import org.hibernate.event.spi.*;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import org.springframework.web.context.request.RequestAttributes;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;

import javax.persistence.EntityManagerFactory;
import java.util.Map;

@Component
public class GlobalEntityHandler implements PersistEventListener, MergeEventListener {
　　　
    @Autowired
    LamtaSpringSessionFactory sessionFactory;

    public GlobalEntityHandler(EntityManagerFactory entityManagerFactory) {
        SessionFactoryImplementor sessionFactory = entityManagerFactory.unwrap(SessionFactoryImplementor.class);
        EventListenerRegistry registry = sessionFactory
                .getServiceRegistry()
                .getService(EventListenerRegistry.class);
        registry.prependListeners(EventType.PERSIST, this);
        registry.prependListeners(EventType.MERGE, this);
    }

    @Override
    public void onPersist(PersistEvent event) throws HibernateException {
　　　　//新增事件监听，当实体类id为null时会执行
        Object entity = event.getObject();
        if (entity instanceof AbstractStandardPO abstractStandardPO) {
            abstractStandardPO.setId(LamtaIdentity.generate());
            updateStandard(abstractStandardPO);
        }
    }

    @Override
    public void onPersist(PersistEvent event, Map createdAlready) throws HibernateException {
        // ignore
    }

    @Override
    public void onMerge(MergeEvent event) throws HibernateException {
　　　　　//修改事件  
        Object entity = event.getOriginal();
        if (entity instanceof AbstractStandardPO abstractStandardPO) {
            updateStandard(abstractStandardPO);
        }
    }

    @Override
    public void onMerge(MergeEvent event, Map copiedAlready) throws HibernateException {
        // ignore
    }
　　
    private void updateStandard(AbstractStandardPO standardPO) {
        String account = null;
        try {
            RequestAttributes ra = RequestContextHolder.getRequestAttributes();
            ServletRequestAttributes sra = (ServletRequestAttributes) ra;
            String session = sra.getRequest().getHeader(LamtaHttpSession.Header);
            if (StringUtils.hasText(session)) {
                LamtaCurrentUserInfoA lamtaCurrentUserInfoA = sessionFactory.getSession(session)
                        .find(LamtaCurrentUserInfoA.class).block();
                account = lamtaCurrentUserInfoA != null ? lamtaCurrentUserInfoA.getAccount() : null;
            }
        } catch (Throwable e) {
            //
        }
        if (StringUtils.hasText(account)) {
            if (!StringUtils.hasText(standardPO.getCreatedById())) {
                standardPO.setCreatedById(account);
            }
            standardPO.setLastModifiedById(account);
        }
    }

}

实体类继承