Java 类javax.persistence.PostPersist 实例源码

@PostPersist
public void sendNotification(Notifiable<User> entity) {
  User from = entity.receiveFrom();
  Collection<User> tos = entity.sendTo();
  String summary = entity.getSummary();

  for (User to : tos) {
    Inbox inbox = to.getInbox();
    Notification notification = new Notification(inbox, from, summary);
    //ugly tentatively using this inject
    if (this.notificationRepository == null) {
      AutowireInjector.inject(this, this.notificationRepository);
    }
    notificationRepository.save(notification);
  }
}

@PostPersist
private final void packGuid() {

    if (this.guid == null) {
        return;
    }
    long tguid = this.guid;
    final byte[] packGUID = new byte[8 + 1];
    packGUID[0] = 0;
    int size = 1;
    for (byte i = 0; i < 8; ++i) {
        if ((tguid & 0xFF) > 0) {
            packGUID[0] |= (1 << i);
            packGUID[size] = (byte) (tguid & 0xFF);
            ++size;
        }

        tguid >>= 8;
    }
    this.packGuid = new byte[size];
    for (int i = 0; i < size; i++) {
        this.packGuid[i] = packGUID[i];
    }
}

@PostPersist
public void onPersist(ToDo todo) {
    //ToDoPersistenceMonitor is not a spring managed been, so we need to inject 
    //  publisher using this simple helper
    AutowireHelper.autowire(this, this.publisher);
    this.publisher.publish(new TodoCreatedEvent(todo));
}

private void processDefaultJpaCallbacks(String instanceCallbackClassName, List<JpaCallbackClass> jpaCallbackClassList) {
    ClassInfo callbackClassInfo = getLocalBindingContext().getClassInfo( instanceCallbackClassName );

    // Process superclass first if available and not excluded
    if ( JandexHelper.getSingleAnnotation( callbackClassInfo, JPADotNames.EXCLUDE_SUPERCLASS_LISTENERS ) != null ) {
        DotName superName = callbackClassInfo.superName();
        if ( superName != null ) {
            processDefaultJpaCallbacks( instanceCallbackClassName, jpaCallbackClassList );
        }
    }

    String callbackClassName = callbackClassInfo.name().toString();
    Map<Class<?>, String> callbacksByType = new HashMap<Class<?>, String>();
    createDefaultCallback(
            PrePersist.class, PseudoJpaDotNames.DEFAULT_PRE_PERSIST, callbackClassName, callbacksByType
    );
    createDefaultCallback(
            PreRemove.class, PseudoJpaDotNames.DEFAULT_PRE_REMOVE, callbackClassName, callbacksByType
    );
    createDefaultCallback(
            PreUpdate.class, PseudoJpaDotNames.DEFAULT_PRE_UPDATE, callbackClassName, callbacksByType
    );
    createDefaultCallback(
            PostLoad.class, PseudoJpaDotNames.DEFAULT_POST_LOAD, callbackClassName, callbacksByType
    );
    createDefaultCallback(
            PostPersist.class, PseudoJpaDotNames.DEFAULT_POST_PERSIST, callbackClassName, callbacksByType
    );
    createDefaultCallback(
            PostRemove.class, PseudoJpaDotNames.DEFAULT_POST_REMOVE, callbackClassName, callbacksByType
    );
    createDefaultCallback(
            PostUpdate.class, PseudoJpaDotNames.DEFAULT_POST_UPDATE, callbackClassName, callbacksByType
    );
    if ( !callbacksByType.isEmpty() ) {
        jpaCallbackClassList.add( new JpaCallbackClassImpl( instanceCallbackClassName, callbacksByType, true ) );
    }
}

private void processJpaCallbacks(String instanceCallbackClassName, boolean isListener, List<JpaCallbackClass> callbackClassList) {

        ClassInfo callbackClassInfo = getLocalBindingContext().getClassInfo( instanceCallbackClassName );

        // Process superclass first if available and not excluded
        if ( JandexHelper.getSingleAnnotation( callbackClassInfo, JPADotNames.EXCLUDE_SUPERCLASS_LISTENERS ) != null ) {
            DotName superName = callbackClassInfo.superName();
            if ( superName != null ) {
                processJpaCallbacks(
                        instanceCallbackClassName,
                        isListener,
                        callbackClassList
                );
            }
        }

        Map<Class<?>, String> callbacksByType = new HashMap<Class<?>, String>();
        createCallback( PrePersist.class, JPADotNames.PRE_PERSIST, callbacksByType, callbackClassInfo, isListener );
        createCallback( PreRemove.class, JPADotNames.PRE_REMOVE, callbacksByType, callbackClassInfo, isListener );
        createCallback( PreUpdate.class, JPADotNames.PRE_UPDATE, callbacksByType, callbackClassInfo, isListener );
        createCallback( PostLoad.class, JPADotNames.POST_LOAD, callbacksByType, callbackClassInfo, isListener );
        createCallback( PostPersist.class, JPADotNames.POST_PERSIST, callbacksByType, callbackClassInfo, isListener );
        createCallback( PostRemove.class, JPADotNames.POST_REMOVE, callbacksByType, callbackClassInfo, isListener );
        createCallback( PostUpdate.class, JPADotNames.POST_UPDATE, callbacksByType, callbackClassInfo, isListener );
        if ( !callbacksByType.isEmpty() ) {
            callbackClassList.add( new JpaCallbackClassImpl( instanceCallbackClassName, callbacksByType, isListener ) );
        }
    }

/**
 * Als dit een entiteit anders dan gegeven in onderzoek betreft dan moet de link naar gegegeven
 * in onderzoek worden hersteld.
 *
 * @param entity de opgeslagen entiteit
 */
@PostPersist
@PostUpdate
public void postSave(final Object entity) {
    if (entity instanceof Entiteit && !(entity instanceof GegevenInOnderzoek)) {
        final Entiteit entiteit = (Entiteit) entity;
        for (final GegevenInOnderzoek gegevenInOnderzoek : entiteit.getGegevenInOnderzoekPerElementMap().values()) {
            if (gegevenInOnderzoek.getEntiteitOfVoorkomen() != entity) {
                gegevenInOnderzoek.setEntiteitOfVoorkomen(entiteit);
            }
        }
    }
}

@PostLoad
@PostPersist
public void inject(Object object) {
    AutowireCapableBeanFactory beanFactory = get().getBeanFactory();
    if(beanFactory == null) {
        LOG.warn("Bean Factory not set! Depdendencies will not be injected into: '{}'", object);
        return;
    }
    LOG.debug("Injecting dependencies into entity: '{}'.", object);
    beanFactory.autowireBean(object);
}

@PostPersist
@PostUpdate
public void setChildIds() {
    super.setChildIds();
    if (this.identityProviderAttributes != null) {
        for (IdentityProviderAttribute attr : this.identityProviderAttributes) {
            attr.setOrganization(this);
        }
    }
}

@PostPersist
@PostUpdate
public void setChildIds() {
    super.setChildIds();
    if (this.attributes != null) {
        for (VesselAttribute attr : this.attributes) {
            attr.setVessel(this);
        }
    }
}

@PostPersist
@PostUpdate
public void setChildIds() {
    if (getCertificates() != null) {
        getCertificates().forEach(this::assignToCert);
    }
}

@PostPersist
public void postPersistLifecycleMethod() {
    postPersistCount++;
    if (postPersistCount != prePersistCount) {
        throw new IllegalStateException("postPersistCount(" + postPersistCount + ") != prePersistCount(" + prePersistCount + ")");
    }
}

@PreUpdate
@PostPersist
@PrePersist
public void setLastUpdate( Person p ) {
    if("addAction".equals(p.getFirstname())){
    p.setActive(true);}

    log.info("person after set active on true , before save action : {}",p);
}

/**
 * Invoked on both the PostPersist and PostUpdate. The default implementation is to simply publish a Spring event
 * to the ApplicationContext after the transaction has completed.
 * 
 * @param entity the newly-persisted Customer
 * @see CustomerPersistedEvent
 */
@PostPersist
@PostUpdate
public void customerUpdated(final Object entity) {
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
            @Override
            public void afterCommit() {
                ApplicationContextHolder.getApplicationContext().publishEvent(new CustomerPersistedEvent((Customer) entity));
            }
        });
    }
}

/**
 * Invoked on both the PostPersist and PostUpdate. The default implementation is to simply publish a Spring event
 * to the ApplicationContext to allow an event listener to respond appropriately (like resetting the current cart
 * in CartState)
 * 
 * @param entity the newly-persisted Order
 * @see OrderPersistedEvent
 */
@PostPersist
@PostUpdate
public void customerUpdated(final Object entity) {
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
            @Override
            public void afterCommit() {
                ApplicationContextHolder.getApplicationContext().publishEvent(new OrderPersistedEvent((Order) entity));
            }
        });
    }
}

/**
 * Invoked on both the PostPersist and PostUpdate. The default implementation is to simply publish a Spring event
 * to the ApplicationContext to allow an event listener to respond appropriately (like resetting the current cart
 * in CartState)
 * 
 * @param entity the newly-persisted Order
 * @see OrderPersistedEvent
 */
@PostPersist
@PostUpdate
public void customerUpdated(final Object entity) {
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
            @Override
            public void afterCommit() {
                ApplicationContextHolder.getApplicationContext().publishEvent(new OrderPersistedEvent((Order) entity));
            }
        });
    }
}

/**
 * Invoked on both the PostPersist and PostUpdate. The default implementation is to simply publish a Spring event
 * to the ApplicationContext after the transaction has completed.
 * 
 * @param entity the newly-persisted Customer
 * @see CustomerPersistedEvent
 */
@PostPersist
@PostUpdate
public void customerUpdated(final Object entity) {
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
            @Override
            public void afterCommit() {
                ApplicationContextHolder.getApplicationContext().publishEvent(new CustomerPersistedEvent((Customer) entity));
            }
        });
    }
}

/**
 * Invoked on both the PostPersist and PostUpdate. The default implementation is to simply publish a Spring event
 * to the ApplicationContext to allow an event listener to respond appropriately (like resetting the current cart
 * in CartState)
 * 
 * @param entity the newly-persisted Order
 * @see OrderPersistedEvent
 */
@PostPersist
@PostUpdate
public void customerUpdated(final Object entity) {
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
            @Override
            public void afterCommit() {
                ApplicationContextHolder.getApplicationContext().publishEvent(new OrderPersistedEvent((Order) entity));
            }
        });
    }
}

@PostLoad
@PostUpdate
@PostPersist
private void postLoadAttributes() {
  if (dbAttributes != null) {
    attributes =
        dbAttributes.values().stream().collect(toMap(attr -> attr.name, attr -> attr.values));
  }
}

@PostPersist
public void newCategoryNotification(Category category) {

   // Notification.sendEmailAlert(category.getCategoryId(), category
    //        .getCategoryName(), category.getUser().getFirstName(), category
  //          .getUser().getLastName());
}

/**
 * Invoked on both the PostPersist and PostUpdate. The default implementation is to simply publish a Spring event
 * to the ApplicationContext after the transaction has completed.
 * 
 * @param entity the newly-persisted Customer
 * @see CustomerPersistedEvent
 */
@PostPersist
@PostUpdate
public void customerUpdated(final Object entity) {
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
            @Override
            public void afterCommit() {
                ApplicationContextHolder.getApplicationContext().publishEvent(new CustomerPersistedEvent((Customer) entity));
            }
        });
    }
}

/**
 * Invoked on both the PostPersist and PostUpdate. The default implementation is to simply publish a Spring event
 * to the ApplicationContext to allow an event listener to respond appropriately (like resetting the current cart
 * in CartState)
 * 
 * @param entity the newly-persisted Order
 * @see OrderPersistedEvent
 */
@PostPersist
@PostUpdate
public void customerUpdated(final Object entity) {
    if (TransactionSynchronizationManager.isSynchronizationActive()) {
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronizationAdapter() {
            @Override
            public void afterCommit() {
                ApplicationContextHolder.getApplicationContext().publishEvent(new OrderPersistedEvent((Order) entity));
            }
        });
    }
}

@PostPersist
protected void newEntity(Object entity) {
    try {
        News news = new News(entity);
        EntityManager em = getEntityManager();
        if (em != null) {
            em.persist(news);
        }
    } catch (Exception e) {
        // Keine Nachrichten sind gute Nachrichten ;-)
    }
}

@PostPersist
public void postPersist() {
    Iterator<BillingItem> i = this.billingItems.iterator();
    BillingItem item;
    while(i.hasNext()) {
        item = i.next();
        item.setCh1_id(id);
    }
}

@PostPersist @PostUpdate @PostLoad
protected void decryptData() {
    // Decrypt the endpoint properties.
    EntityType entityType = EntityType.Api;
    if (type == PolicyType.Client) {
        entityType = EntityType.ClientApp;
    } else if (type == PolicyType.Plan) {
        entityType = EntityType.Plan;
    }
    DataEncryptionContext ctx = new DataEncryptionContext(organizationId, entityId, entityVersion, entityType);
    configuration = CurrentDataEncrypter.instance.decrypt(configuration, ctx);
}

@PostPersist
private void getLastEditAfterPost(){
    this.setLastEdit(this.getLastEdit());
    System.out.println("@PostPersist:"+this.lastEdit); 

}

@PostPersist
public void postPersist(Object entity) {
    notifyEntityPushers(EntityAction.PERSISTED, entity);
}

@PostPersist
public void updateNbCards() {
    int nbCards = 1 + this.getUser().getCards().size();
    this.getUser().setNbCards((long) nbCards);
}

@PostPersist
public void postPersist(Object object) {
    LOG.info("Listening to post persist for object:" + object);
}

@PostPersist
private void postPersist(Object object) {
    logger.debug("### DebugListener.postPersist({})", object);
}

@PostPersist
@PostUpdate
public void on_jpa_update() {
    AppointmentStatusMgrImpl.setCacheIsDirty(true);
}

@PostPersist
public void postPersist() {            
    for (BillingONItem b : this.billingItems) {
        b.setCh1Id(this.id);
    }                        
}

@PostPersist
void postPersist() {
    callbacks.add(PostPersist.class);
}

@PostRemove
@PostPersist
@PostUpdate
public void onPostModyfingOperation(final Object o) {
    markWrite();
}

@PostPersist
void postPersist(AuditableBaseEntity e) {
    createLog(DatabaseTransactionType.CREATE, e);
}

@PostPersist
@PostUpdate
private void updateVersion(Object entity)
{
    versionedThing.get().updateVersion(entity);
}

@PostPersist
public void defaultValues() {
  if (creationDate == null) {
    setCreationDate(creationDate);
  }
}

@PostPersist
public void postPersist(TwitterUser entity) {
    System.out.println("Spring PostPersist, key: " + key);
}

public void findMethodsForListener(Object listener) {
    Class<?> c = listener.getClass();
    for (Method m : c.getMethods()) {
        if (Void.TYPE.equals(m.getReturnType())) {
            Class<?>[] types = m.getParameterTypes();
            if (types.length == 1) {
                // check for all annotations now...
                if (m.getAnnotation(PrePersist.class) != null) {
                    if (!preInsert.containsKey(types[0])) {
                        preInsert.put(types[0], new LinkedHashMap<Method, Object>());
                    }
                    preInsert.get(types[0]).put(m, listener);
                }

                if (m.getAnnotation(PostPersist.class) != null) {
                    if (!postInsert.containsKey(types[0])) {
                        postInsert.put(types[0], new LinkedHashMap<Method, Object>());
                    }
                    postInsert.get(types[0]).put(m, listener);
                }

                if (m.getAnnotation(PreUpdate.class) != null) {
                    if (!preUpdate.containsKey(types[0])) {
                        preUpdate.put(types[0], new LinkedHashMap<Method, Object>());
                    }
                    preUpdate.get(types[0]).put(m, listener);
                }

                if (m.getAnnotation(PostUpdate.class) != null) {
                    if (!postUpdate.containsKey(types[0])) {
                        postUpdate.put(types[0], new LinkedHashMap<Method, Object>());
                    }
                    postUpdate.get(types[0]).put(m, listener);
                }

                if (m.getAnnotation(PreRemove.class) != null) {
                    if (!preRemove.containsKey(types[0])) {
                        preRemove.put(types[0], new LinkedHashMap<Method, Object>());
                    }
                    preRemove.get(types[0]).put(m, listener);
                }

                if (m.getAnnotation(PostRemove.class) != null) {
                    if (!postRemove.containsKey(types[0])) {
                        postRemove.put(types[0], new LinkedHashMap<Method, Object>());
                    }
                    postRemove.get(types[0]).put(m, listener);
                }

                if (m.getAnnotation(PostLoad.class) != null) {
                    if (!postLoad.containsKey(types[0])) {
                        postLoad.put(types[0], new LinkedHashMap<Method, Object>());
                    }
                    postLoad.get(types[0]).put(m, listener);
                }
            }
        }
    }
}

@PostPersist
public void postPersist(TwitterUser entity) {
    System.out.println("JPA PostPersist");
}