Java PostRemove类代码示例

import javax.persistence.PostRemove; //导入依赖的package包/类
@PostRemove
public void nullifyKey(Object object) {

    /*
     * We use reflection to locate the setId method since it's not defined in
     * any of the base interfaces of the VARS JPAEntities. This is deliberate
     * we don't normally want developers playing with the setId method.
     */
    if (object instanceof JPAEntity) {
        Class params[] = {Long.class};
        Object args[] = {null};
        try {
            Method method = object.getClass().getDeclaredMethod("setId", params);
            method.invoke(object, args);
        }
        catch (Exception e) {
            log.error("Failed to set primary key on " + object + " to null", e);
        }
    }
}
 

import javax.persistence.PostRemove; //导入依赖的package包/类
@PostRemove
public void removeImagesFromDisk(ImageResource image){
	
	if (image.getHiResImagePath() != null){
		delete(image.getHiResImagePath());
	}
	
	if (image.getLoResImagePath() != null){
		delete(image.getLoResImagePath());
	}
}
 

import javax.persistence.PostRemove; //导入依赖的package包/类
/**
 * Clear products and orders from cache post remove.
 */
@PostRemove
private void clearCaches() {
	CacheManager.MANAGER.clearCache(PersistenceProduct.class);
	CacheManager.MANAGER.clearCache(PersistenceOrder.class);
	CacheManager.MANAGER.clearRemoteCache(PersistenceOrderItem.class);
}
 

import javax.persistence.PostRemove; //导入依赖的package包/类
/**
 * Clear users and order items from cache post remove.
 */
@PostRemove
private void clearCaches() {
	CacheManager.MANAGER.clearCache(PersistenceUser.class);
	CacheManager.MANAGER.clearCache(PersistenceOrderItem.class);
	CacheManager.MANAGER.clearRemoteCache(PersistenceOrder.class);
}
 

import javax.persistence.PostRemove; //导入依赖的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.PostRemove; //导入依赖的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.PostRemove; //导入依赖的package包/类
@PostRemove
public void postRemoveLifecycleMethod() {
    postRemoveCount++;
    if (postRemoveCount != preRemoveCount) {
        throw new IllegalStateException("postRemoveCount(" + postRemoveCount + ") != preRemoveCount(" + preRemoveCount + ")");
    }
}
 

import javax.persistence.PostRemove; //导入依赖的package包/类
@Test
public void testRemove() throws Exception {
	User user = new User();
	user.name = "Michael";
	user.email = "[email protected]";
	warpdb.save(user);
	warpdb.remove(user);
	assertTrue(user.callbacks.contains(PreRemove.class));
	assertTrue(user.callbacks.contains(PostRemove.class));
	assertNull(warpdb.fetch(User.class, user.id));
}
 

import javax.persistence.PostRemove; //导入依赖的package包/类
@PostRemove
public void postRemove(E entity) {
    T delegate = getDelegate();
    if (delegate != null) {
        delegate.postRemove(entity);
    }
}
 

import javax.persistence.PostRemove; //导入依赖的package包/类
/**
 * Clear categories and order items from cache post remove.
 */
@PostRemove
private void clearCaches() {
	CacheManager.MANAGER.clearCache(PersistenceCategory.class);
	CacheManager.MANAGER.clearRemoteCache(PersistenceProduct.class);
}
 

import javax.persistence.PostRemove; //导入依赖的package包/类
/**
 * Clear users and order items from cache post remove.
 */
@PostRemove
private void clearCaches() {
	CacheManager.MANAGER.clearCache(PersistenceOrder.class);
	CacheManager.MANAGER.clearRemoteCache(PersistenceUser.class);
}
 

import javax.persistence.PostRemove; //导入依赖的package包/类
/**
 * Clear products from cache to update relationships.
 */
@PostRemove
private void clearCaches() {
	CacheManager.MANAGER.clearCache(PersistenceProduct.class);
	CacheManager.MANAGER.clearRemoteCache(PersistenceCategory.class);
}
 

import javax.persistence.PostRemove; //导入依赖的package包/类
@PostRemove
public void postRemove(Object entity) {
	notifyEntityPushers(EntityAction.REMOVED, entity);
}
 

import javax.persistence.PostRemove; //导入依赖的package包/类
@PostRemove
public void postRemove(Object object) {
    LOG.info("Listening to post remove for object:" + object);
}
 

import javax.persistence.PostRemove; //导入依赖的package包/类
@PostRemove
private void postRemove(Object object) {
	logger.debug("### DebugListener.postRemove({})", object);
}