Java Enhancer类代码示例

import org.springframework.cglib.proxy.Enhancer; //导入依赖的package包/类
static public <T> T recorder(Object object, Class<T> as) {
    if (as.isInterface()) {
        // If it's just an interface, use standard java reflect proxying
        return as.cast(Proxy.newProxyInstance(as.getClassLoader(), new Class<?>[] { as }, new RecordingInvocationHandler(object)));
    }

    // If it's a class then use gclib to implement a subclass to implement proxying
    RecordingInvocationHandler ih = new RecordingInvocationHandler(object);
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(as);
    enhancer.setInterfaces(new Class<?>[]{RecordingProxy.class});
    enhancer.setCallback(new org.springframework.cglib.proxy.InvocationHandler() {
        @Override
        public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
            return ih.invoke(o, method, objects);
        }
    });
    return as.cast(enhancer.create());
}
 

import org.springframework.cglib.proxy.Enhancer; //导入依赖的package包/类
/**
 * Create a subclass proxy that intercepts calls to getObject(), delegating to the current BeanFactory
 * instead of creating a new instance. These proxies are created only when calling a FactoryBean from
 * within a Bean method, allowing for proper scoping semantics even when working against the FactoryBean
 * instance directly. If a FactoryBean instance is fetched through the container via &-dereferencing,
 * it will not be proxied. This too is aligned with the way XML configuration works.
 */
private Object enhanceFactoryBean(Class<?> fbClass, final ConfigurableBeanFactory beanFactory,
		final String beanName) throws InstantiationException, IllegalAccessException {

	Enhancer enhancer = new Enhancer();
	enhancer.setSuperclass(fbClass);
	enhancer.setUseFactory(false);
	enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
	enhancer.setCallback(new MethodInterceptor() {
		@Override
		public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
			if (method.getName().equals("getObject") && args.length == 0) {
				return beanFactory.getBean(beanName);
			}
			return proxy.invokeSuper(obj, args);
		}
	});
	return enhancer.create();
}
 

import org.springframework.cglib.proxy.Enhancer; //导入依赖的package包/类
@Override
@SuppressWarnings("unchecked")
protected Object createProxyClassAndInstance(Enhancer enhancer, Callback[] callbacks) {
	try {
		Factory factory = (Factory) this.objenesis.newInstance(enhancer.createClass());
		factory.setCallbacks(callbacks);
		return factory;
	}
	catch (ObjenesisException ex) {
		// Fallback to regular proxy construction on unsupported JVMs
		if (logger.isDebugEnabled()) {
			logger.debug("Unable to instantiate proxy using Objenesis, falling back to regular proxy construction", ex);
		}
		return super.createProxyClassAndInstance(enhancer, callbacks);
	}
}
 

import org.springframework.cglib.proxy.Enhancer; //导入依赖的package包/类
static public <T> T recorder(Object object, Class<T> as) {
    if (as.isInterface()) {
        // If it's just an interface, use standard java reflect proxying
        return as.cast(Proxy.newProxyInstance(as.getClassLoader(), new Class[]{as}, new RecordingInvocationHandler(object)));
    }

    // If it's a class then use gclib to implement a subclass to implement proxying
    RecordingInvocationHandler ih = new RecordingInvocationHandler(object);
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(as);
    enhancer.setInterfaces(new Class[]{RecordingProxy.class});
    enhancer.setCallback(new org.springframework.cglib.proxy.InvocationHandler() {
        @Override
        public Object invoke(Object o, Method method, Object[] objects) throws Throwable {
            return ih.invoke(o, method, objects);
        }
    });
    return as.cast(enhancer.create());
}
 

import org.springframework.cglib.proxy.Enhancer; //导入依赖的package包/类
/**
 * Create a subclass proxy that intercepts calls to getObject(), delegating to the current BeanFactory
 * instead of creating a new instance. These proxies are created only when calling a FactoryBean from
 * within a Bean method, allowing for proper scoping semantics even when working against the FactoryBean
 * instance directly. If a FactoryBean instance is fetched through the container via &-dereferencing,
 * it will not be proxied. This too is aligned with the way XML configuration works.
 */
private Object enhanceFactoryBean(Class<?> fbClass, String beanName) throws InstantiationException, IllegalAccessException {
	Enhancer enhancer = new Enhancer();
	enhancer.setSuperclass(fbClass);
	enhancer.setUseFactory(false);
	enhancer.setCallbackFilter(CALLBACK_FILTER);
	// Callback instances must be ordered in the same way as CALLBACK_TYPES and CALLBACK_FILTER
	Callback[] callbackInstances = new Callback[] {
			new GetObjectMethodInterceptor(this.beanFactory, beanName),
			NoOp.INSTANCE
	};
	enhancer.setCallbackTypes(CALLBACK_TYPES);
	Class<?> fbSubclass = enhancer.createClass();
	Enhancer.registerStaticCallbacks(fbSubclass, callbackInstances);
	return fbSubclass.newInstance();
}
 

import org.springframework.cglib.proxy.Enhancer; //导入依赖的package包/类
@SuppressWarnings("unchecked")
static <T> T wrapWithIfaceImplementation(final Class<T> iface, final Specification<Object> targetSpec) {
   	Enhancer enhancer = new Enhancer();
	enhancer.setInterfaces(new Class[] { iface });
	enhancer.setCallback(new MethodInterceptor() {
           @Override
           public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
           	if ("toString".equals(method.getName())) {
           		return iface.getSimpleName() + "[" + proxy.invoke(targetSpec, args) + "]";
           	}
           	return proxy.invoke(targetSpec, args);
           }
       });
	
	return (T) enhancer.create();
   }
 

import org.springframework.cglib.proxy.Enhancer; //导入依赖的package包/类
private Object createUnderlyingObjectProxy(InvocationReporter invocationReporter) {
	// use Cglib Enhancer inlined in spring3.2
	// spring3.2's ProxyFactory cannot creates a proxy with constructor arguments.
	// CglibAopProxy is package scoped and cannot call "setConstructorArguments" operationMethod.
	// This is fixed in spring4 with ObjenesisCglibAopProxy: https://jira.springsource.org/browse/SPR-3150
	// for now simulate what spring4 does with cglib and objenesis.
	final Enhancer enhancer = new Enhancer();
	enhancer.setSuperclass(implClass);
	enhancer.setInterfaces(implClass.getInterfaces());

	Objenesis objenesis = new ObjenesisStd();
	Callback[] callbacks = new Callback[]{invocationReporter};
	Class<?>[] types = new Class[callbacks.length];
	for (int x = 0; x < types.length; x++) {
		types[x] = callbacks[x].getClass();
	}
	enhancer.setCallbackTypes(types);

	Object client = objenesis.newInstance(enhancer.createClass());
	((Factory) client).setCallbacks(callbacks);
	return client;
}
 

import org.springframework.cglib.proxy.Enhancer; //导入依赖的package包/类
public Object createStudent(Object obj){
    this.object=obj;
    //创建一个Enhancer对象，来实例化obj
    Enhancer enhancer=new Enhancer();
    //将obj设置为Enhancer的父类，则Enhancer实现了obj的功能
    enhancer.setSuperclass(obj.getClass());
    //调用回调函数intercept
    enhancer.setCallback(this);
    return enhancer.create();
}
 

import org.springframework.cglib.proxy.Enhancer; //导入依赖的package包/类
public static void main(String[] args) {
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(UserServiceImpl.class);
    enhancer.setCallback(new MyMethodInterceptor());
    UserServiceImpl userService = (UserServiceImpl)enhancer.create();
    userService.add();//一个是重写的add方法，一个是CGLIB$add$0方法
    userService.delete(2233);
    userService.update(2333);//委托类的final方法不能被代理
}
 

import org.springframework.cglib.proxy.Enhancer; //导入依赖的package包/类
private <T extends EntityService> T createProxyService(T entityService, EntityServiceProxy entityServiceProxy) {
	Enhancer enhancer = new Enhancer();
	// 设置需要创建子类的类
	enhancer.setSuperclass(entityService.getClass());
	enhancer.setCallback(entityServiceProxy);
	// 通过字节码技术动态创建子类实例
	return (T) enhancer.create();
}
 

import org.springframework.cglib.proxy.Enhancer; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private <T extends IEntity> T createProxyEntity(EntityProxy entityProxy) {
	if (entityProxy != null) {
		Enhancer enhancer = new Enhancer();
		if (enhancer != null) {
			// 设置需要创建子类的类
			enhancer.setSuperclass(entityProxy.getEntity().getClass());
			enhancer.setCallback(entityProxy);
			// 通过字节码技术动态创建子类实例
			return (T) enhancer.create();
		}
	}
	return null;
}
 

import org.springframework.cglib.proxy.Enhancer; //导入依赖的package包/类
/**
 * Creates a new CGLIB {@link Enhancer} instance.
 */
private Enhancer newEnhancer(Class<?> superclass) {
	Enhancer enhancer = new Enhancer();
	enhancer.setSuperclass(superclass);
	enhancer.setInterfaces(new Class<?>[] {EnhancedConfiguration.class});
	enhancer.setUseFactory(false);
	enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
	enhancer.setStrategy(GENERATOR_STRATEGY);
	enhancer.setCallbackFilter(CALLBACK_FILTER);
	enhancer.setCallbackTypes(CALLBACK_FILTER.getCallbackTypes());
	return enhancer;
}
 

import org.springframework.cglib.proxy.Enhancer; //导入依赖的package包/类
/**
 * Uses enhancer to generate a subclass of superclass,
 * ensuring that callbacks are registered for the new subclass.
 */
private Class<?> createClass(Enhancer enhancer) {
	Class<?> subclass = enhancer.createClass();
	// Registering callbacks statically (as opposed to thread-local)
	// is critical for usage in an OSGi environment (SPR-5932)...
	Enhancer.registerStaticCallbacks(subclass, CALLBACKS);
	return subclass;
}
 

import org.springframework.cglib.proxy.Enhancer; //导入依赖的package包/类
@Override
public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
	Enhancer.registerStaticCallbacks(obj.getClass(), null);
	// Does the actual (non-CGLIB) superclass actually implement DisposableBean?
	// If so, call its dispose() method. If not, just exit.
	if (DisposableBean.class.isAssignableFrom(obj.getClass().getSuperclass())) {
		return proxy.invokeSuper(obj, args);
	}
	return null;
}
 

import org.springframework.cglib.proxy.Enhancer; //导入依赖的package包/类
/**
 * Create an enhanced subclass of the bean class for the provided bean
 * definition, using CGLIB.
 */
private Class<?> createEnhancedSubclass(RootBeanDefinition beanDefinition) {
	Enhancer enhancer = new Enhancer();
	enhancer.setSuperclass(beanDefinition.getBeanClass());
	enhancer.setNamingPolicy(SpringNamingPolicy.INSTANCE);
	enhancer.setCallbackFilter(new MethodOverrideCallbackFilter(beanDefinition));
	enhancer.setCallbackTypes(CALLBACK_TYPES);
	return enhancer.createClass();
}