View difference between Paste ID: 8cPB96bZ and kesM4XJJ

 @Target({
         ElementType.TYPE,
         ElementType.METHOD,
 })
 @Retention(RetentionPolicy.RUNTIME)
 public @interface PreCollectionChange {
 }
 
 
 
 public class IntegratorImpl implements Integrator {
 
     private final Map<Class<?>, List<Method>> preCollectionChangeMethods;
 
     public IntegratorImpl() {
         this.preCollectionChangeMethods = new ConcurrentHashMap<>();
     }
 
     @Override
     public void integrate(Configuration configuration, SessionFactoryImplementor sessionFactory, SessionFactoryServiceRegistry serviceRegistry) {
         EventListenerRegistry registry = sessionFactory.getServiceRegistry().getService(EventListenerRegistry.class);
         registry.getEventListenerGroup(EventType.FLUSH_ENTITY).appendListener(new PreCollectionChangeFlushEntityEventListener());
     }
 
     private class PreCollectionChangeFlushEntityEventListener implements FlushEntityEventListener {
 
         @Override
         public void onFlushEntity(FlushEntityEvent event) throws HibernateException {
             Object entity = event.getEntity();
             Class<?> entityClass = entity.getClass();
 
             if (!preCollectionChangeMethods.containsKey(entityClass)) {
                 Method[] uniqueDeclaredMethods = ReflectionUtils.getUniqueDeclaredMethods(entityClass);
                 List<Method> methods = Arrays.asList(uniqueDeclaredMethods).stream()
                         .filter(method -> AnnotationUtils.findAnnotation(method, PreCollectionChange.class) != null)
                         .map(method -> {
                             method.setAccessible(true);
                             return method;
                         })
                         .collect(Collectors.toList());
                 // Place leaf methods in the end to correspond to constructors order.
                 Collections.reverse(methods);
                 preCollectionChangeMethods.put(entityClass, methods);
             }
 
             List<Method> methods = preCollectionChangeMethods.get(entityClass);
             for (Method method : methods) {
                 try {
                     method.invoke(entity, (Object[]) null);
                 } catch (IllegalAccessException | InvocationTargetException e) {
                     throw new CallbackException(e);
                 }
             }
         }
     }
 }
 
 
 
 @Entity
 public abstract class Device {
 
     @ManyToMany
     @JoinTable(
             name = "device_application",
             joinColumns = {
                     @JoinColumn(name = "device_id"),
             },
             inverseJoinColumns = {
                     @JoinColumn(name = "application_id"),
             })
     private Set<Application> applications = new HashSet<>();
 
     public Set<Application> getApplications() {
         return applications;
     }
 
     public void setApplications(Set<Application> applications) {
         this.applications = applications;
     }
 
     @PrePersist
     private void prePersist() {
         checkApplications();
     }
 
     @PreUpdate
     private void preUpdate() {
         checkApplications();
     }
 
     @PreCollectionChange
     private void checkApplications() {
         Class<? extends Application> applicationClass = getApplicationClass();
         for (Application application : applications) {
             if (!applicationClass.isAssignableFrom(application.getClass())) {
                 throw new IllegalStateException("All applications must be of class " + applicationClass.getName());
             }
         }
     }
 
     @Transient
     protected abstract Class<? extends Application> getApplicationClass();
 }