Java PostPersist类代码示例

import javax.persistence.PostPersist; //导入依赖的package包/类
@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);
  }
}
 

import javax.persistence.PostPersist; //导入依赖的package包/类
@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];
    }
}
 

import javax.persistence.PostPersist; //导入依赖的package包/类
@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));
}
 

import javax.persistence.PostPersist; //导入依赖的package包/类
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 ) );
	}
}
 

import javax.persistence.PostPersist; //导入依赖的package包/类
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 ) );
		}
	}
 

import javax.persistence.PostPersist; //导入依赖的package包/类
/**
 * 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);
            }
        }
    }
}
 

import javax.persistence.PostPersist; //导入依赖的package包/类
@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);
}
 

import javax.persistence.PostPersist; //导入依赖的package包/类
@PostPersist
@PostUpdate
public void setChildIds() {
    super.setChildIds();
    if (this.identityProviderAttributes != null) {
        for (IdentityProviderAttribute attr : this.identityProviderAttributes) {
            attr.setOrganization(this);
        }
    }
}
 

import javax.persistence.PostPersist; //导入依赖的package包/类
@PostPersist
@PostUpdate
public void setChildIds() {
    super.setChildIds();
    if (this.attributes != null) {
        for (VesselAttribute attr : this.attributes) {
            attr.setVessel(this);
        }
    }
}
 

import javax.persistence.PostPersist; //导入依赖的package包/类
@PostPersist
@PostUpdate
public void setChildIds() {
    if (getCertificates() != null) {
        getCertificates().forEach(this::assignToCert);
    }
}
 

import javax.persistence.PostPersist; //导入依赖的package包/类
@PostPersist
public void postPersistLifecycleMethod() {
    postPersistCount++;
    if (postPersistCount != prePersistCount) {
        throw new IllegalStateException("postPersistCount(" + postPersistCount + ") != prePersistCount(" + prePersistCount + ")");
    }
}
 

import javax.persistence.PostPersist; //导入依赖的package包/类
@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);
}
 

import javax.persistence.PostPersist; //导入依赖的package包/类
@Test
public void testInsert() throws Exception {
	User user = new User();
	user.name = "Michael";
	user.email = "[email protected]";
	warpdb.save(user);
	assertTrue(user.callbacks.contains(PrePersist.class));
	assertTrue(user.callbacks.contains(PostPersist.class));
	assertEquals("0001", user.id);
	assertEquals(user.createdAt, user.updatedAt);
	assertEquals(System.currentTimeMillis(), user.createdAt, 500);
}
 

import javax.persistence.PostPersist; //导入依赖的package包/类
/**
 * 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));
            }
        });
    }
}
 

import javax.persistence.PostPersist; //导入依赖的package包/类
/**
 * 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));
            }
        });
    }
}