Java Code Examples for org.springframework.aop.support.AopUtils#isJdkDynamicProxy()

private MapTaskBatchDao getMapTaskBatchDao() throws Exception {
	Field taskExecutionDaoField = ReflectionUtils.findField(SimpleTaskExplorer.class,
			"taskExecutionDao");
	taskExecutionDaoField.setAccessible(true);

	MapTaskExecutionDao taskExecutionDao;

	if (AopUtils.isJdkDynamicProxy(this.taskExplorer)) {
		SimpleTaskExplorer dereferencedTaskRepository = (SimpleTaskExplorer) ((Advised) this.taskExplorer)
				.getTargetSource().getTarget();

		taskExecutionDao = (MapTaskExecutionDao) ReflectionUtils
				.getField(taskExecutionDaoField, dereferencedTaskRepository);
	}
	else {
		taskExecutionDao = (MapTaskExecutionDao) ReflectionUtils
				.getField(taskExecutionDaoField, this.taskExplorer);
	}

	return new MapTaskBatchDao(taskExecutionDao.getBatchJobAssociations());
}
 

/**
 * 是否代理了多次
 * see http://jinnianshilongnian.iteye.com/blog/1894465
 * @param proxy
 * @return
 */
public static boolean isMultipleProxy(Object proxy) {
    try {
        ProxyFactory proxyFactory = null;
        if(AopUtils.isJdkDynamicProxy(proxy)) {
            proxyFactory = findJdkDynamicProxyFactory(proxy);
        }
        if(AopUtils.isCglibProxy(proxy)) {
            proxyFactory = findCglibProxyFactory(proxy);
        }
        TargetSource targetSource = (TargetSource) ReflectionUtils.getField(ProxyFactory_targetSource_FIELD, proxyFactory);
        return AopUtils.isAopProxy(targetSource.getTarget());
    } catch (Exception e) {
        throw new IllegalArgumentException("proxy args maybe not proxy with cglib or jdk dynamic proxy. this method not support", e);
    }
}
 

/**
 * @param scope          the scope of the events that this event bus handles.
 * @param parentEventBus the parent event bus to use, may be {@code null};
 */
public ScopedEventBus(EventScope scope, EventBus parentEventBus) {
    eventScope = scope;
    this.parentEventBus = parentEventBus;
    if (parentEventBus != null) {
        if (AopUtils.isJdkDynamicProxy(parentEventBus)) {
            logger.debug("Parent event bus [{}] is proxied, trying to get the real EventBus instance",
                    parentEventBus);
            try {
                this.parentEventBus = (EventBus) ((Advised) parentEventBus).getTargetSource().getTarget();
            } catch (Exception e) {
                logger.error("Could not get target EventBus from proxy", e);
                throw new RuntimeException("Could not get parent event bus", e);
            }
        }
        logger.debug("Using parent event bus [{}]", this.parentEventBus);
        this.parentEventBus.subscribe(parentListener);
    }
}
 

/**
 * 是否代理了多次
 * see http://jinnianshilongnian.iteye.com/blog/1894465
 * @param proxy
 * @return
 */
public static boolean isMultipleProxy(Object proxy) {
    try {
        ProxyFactory proxyFactory = null;
        if(AopUtils.isJdkDynamicProxy(proxy)) {
            proxyFactory = findJdkDynamicProxyFactory(proxy);
        }
        if(AopUtils.isCglibProxy(proxy)) {
            proxyFactory = findCglibProxyFactory(proxy);
        }
        TargetSource targetSource = (TargetSource) ReflectionUtils.getField(ProxyFactory_targetSource_FIELD, proxyFactory);
        return AopUtils.isAopProxy(targetSource.getTarget());
    } catch (Exception e) {
        throw new IllegalArgumentException("proxy args maybe not proxy with cglib or jdk dynamic proxy. this method not support", e);
    }
}
 

protected <T> T getTargetObject(Object proxy, Class<T> targetClass) throws Exception {
    if (AopUtils.isJdkDynamicProxy(proxy)) {
        return (T) ((Advised) proxy).getTargetSource().getTarget();
    } else if (AopUtils.isCglibProxy(proxy)) {
        return (T) ((Advised) proxy).getTargetSource().getTarget();
    } else {
        return (T) proxy;
    }
}
 

/**
 * Throws an IllegalArgumentException if it encounters a JDK dynamic proxy.
 * Metadata can only be read from target classes and CGLIB proxies!
 */
@Override
protected void checkManagedBean(Object managedBean) throws IllegalArgumentException {
	if (AopUtils.isJdkDynamicProxy(managedBean)) {
		throw new IllegalArgumentException(
				"MetadataMBeanInfoAssembler does not support JDK dynamic proxies - " +
				"export the target beans directly or use CGLIB proxies instead");
	}
}
 

/**
 * 获取 目标对象
 * @param proxy 代理对象
 * @return
 * @throws Exception
 */
public static Object getTarget(Object proxy) throws Exception {
    if(!AopUtils.isAopProxy(proxy)) {
        return proxy;//不是代理对象
    }
    if(AopUtils.isJdkDynamicProxy(proxy)) {
        return getJdkDynamicProxyTargetObject(proxy);
    } else { //cglib
        return getCglibProxyTargetObject(proxy);
    }
}
 

@SuppressWarnings({"unchecked"})
public static <T> T getTargetObject(Object proxy) throws Exception {
    if (AopUtils.isJdkDynamicProxy(proxy)) {
        return (T) getTargetObject(((Advised)proxy).getTargetSource().getTarget());
    }
    return (T) proxy; // expected to be cglib proxy then, which is simply a specialized class
}
 

@SuppressWarnings({ "unchecked" })
protected <T> T getTargetObject(Object proxy, Class<T> targetClass) throws Exception {
	if (AopUtils.isJdkDynamicProxy(proxy)) {
		return (T) ((Advised) proxy).getTargetSource().getTarget();
	}
	else {
		return (T) proxy; // expected to be cglib proxy then, which is simply a
		// specialized class
	}
}
 

/**
 * 获取 目标对象
 *
 * @param proxy 代理对象
 * @return 目标对象
 */
public static Object getTarget(Object proxy) {
    if (!AopUtils.isAopProxy(proxy)) {
        return proxy;
    }
    try {
        Object target = AopUtils.isJdkDynamicProxy(proxy)
                ? getJdkDynamicProxyTargetObject(proxy)
                : getCglibProxyTargetObject(proxy);

        return getTarget(target);
    } catch (Exception ex) {
        return proxy;
    }
}
 

protected <T> T getTargetObject(Object proxy, Class<T> targetClass) throws Exception {
    if (AopUtils.isJdkDynamicProxy(proxy)) {
        return (T) ((Advised) proxy).getTargetSource().getTarget();
    } else if (AopUtils.isCglibProxy(proxy)) {
        return (T) ((Advised) proxy).getTargetSource().getTarget();
    } else {
        return (T) proxy;
    }
}
 

/**
 * 获取 目标对象
 * @param proxy 代理对象
 * @return
 * @throws Exception
 */
public static Object getTarget(Object proxy) throws Exception {
    if(!AopUtils.isAopProxy(proxy)) {
        return proxy;//不是代理对象
    }
    if(AopUtils.isJdkDynamicProxy(proxy)) {
        return getJdkDynamicProxyTargetObject(proxy);
    } else { //cglib
        return getCglibProxyTargetObject(proxy);
    }
}
 

/**
 * 获取目标对象.
 *
 * @param proxy 代理对象
 * @return 目标对象
 */
public static Object getTarget(final Object proxy) {
    if (!AopUtils.isAopProxy(proxy)) {
        return proxy;
    }
    if (AopUtils.isJdkDynamicProxy(proxy)) {
        return getProxyTargetObject(proxy, "h");
    } else {
        return getProxyTargetObject(proxy, "CGLIB$CALLBACK_0");
    }
}
 

/**
 * 获取 目标对象
 *
 * @param proxy 代理对象
 * @return
 * @throws Exception
 */
public static Object getTarget(Object proxy) throws Exception {

    if (!AopUtils.isAopProxy(proxy)) {
        return proxy;//不是代理对象
    }

    if (AopUtils.isJdkDynamicProxy(proxy)) {
        return getJdkDynamicProxyTargetObject(proxy);
    } else { //cglib
        return getCglibProxyTargetObject(proxy);
    }


}
 

private Object getTargetObject(Object proxy) throws BeansException {
    if (AopUtils.isJdkDynamicProxy(proxy)) {
        try {
            return ((Advised)proxy).getTargetSource().getTarget();
        } catch (Exception e) {
            throw new FatalBeanException("Error getting target of JDK proxy", e);
        }
    }
    return proxy;
}
 

/**
 * 获取 Model 所有的字段
 * @param modelClass
 * @return
 */
public static List<Field> getAllFields(Class<?> modelClass) {
    // 如果 modelClass 是代理对象，则需要获取原来的 modelClass
    if (AopUtils.isAopProxy(modelClass)
            || AopUtils.isJdkDynamicProxy(modelClass)
            || AopUtils.isCglibProxy(modelClass)) {
        modelClass = AopUtils.getTargetClass(modelClass);
    }
    List<Field> fieldList = getFieldList(modelClass);
    return fieldList;
}
 

/**
 * Throws an IllegalArgumentException if it encounters a JDK dynamic proxy.
 * Metadata can only be read from target classes and CGLIB proxies!
 */
@Override
protected void checkManagedBean(Object managedBean) throws IllegalArgumentException {
	if (AopUtils.isJdkDynamicProxy(managedBean)) {
		throw new IllegalArgumentException(
				"MetadataMBeanInfoAssembler does not support JDK dynamic proxies - " +
				"export the target beans directly or use CGLIB proxies instead");
	}
}
 

private AdvisedSupport getAdvisedSupport(Object proxy) throws Exception {
    Field h;
    if (AopUtils.isJdkDynamicProxy(proxy)) {
        h = proxy.getClass().getSuperclass().getDeclaredField("h");
    } else {
        h = proxy.getClass().getDeclaredField("CGLIB$CALLBACK_0");
    }
    h.setAccessible(true);
    Object dynamicAdvisedInterceptor = h.get(proxy);
    Field advised = dynamicAdvisedInterceptor.getClass().getDeclaredField("advised");
    advised.setAccessible(true);
    return (AdvisedSupport)advised.get(dynamicAdvisedInterceptor);
}
 

/**
 * Throws an IllegalArgumentException if it encounters a JDK dynamic proxy.
 * Metadata can only be read from target classes and CGLIB proxies!
 */
@Override
protected void checkManagedBean(Object managedBean) throws IllegalArgumentException {
	if (AopUtils.isJdkDynamicProxy(managedBean)) {
		throw new IllegalArgumentException(
				"MetadataMBeanInfoAssembler does not support JDK dynamic proxies - " +
				"export the target beans directly or use CGLIB proxies instead");
	}
}
 

/**
 * Return the class to be used for the JMX descriptor field "class".
 * Only applied when the "exposeClassDescriptor" property is "true".
 * <p>The default implementation returns the first implemented interface
 * for a JDK proxy, and the target class else.
 * @param managedBean the bean instance (might be an AOP proxy)
 * @return the class to expose in the descriptor field "class"
 * @see #setExposeClassDescriptor
 * @see #getClassToExpose(Class)
 * @see org.springframework.aop.framework.AopProxyUtils#proxiedUserInterfaces(Object)
 */
protected Class<?> getClassForDescriptor(Object managedBean) {
	if (AopUtils.isJdkDynamicProxy(managedBean)) {
		return AopProxyUtils.proxiedUserInterfaces(managedBean)[0];
	}
	return getClassToExpose(managedBean);
}