Java Enhancer.setSuperclass方法代码示例

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包/类
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包/类
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包/类
/**
 * 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();
}
 

import org.springframework.cglib.proxy.Enhancer; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private static <T> T createProxy(final Class<?> classToMock, final MethodInterceptor interceptor) {
	final Enhancer enhancer = new Enhancer();
	enhancer.setSuperclass(classToMock);
	enhancer.setCallbackType(interceptor.getClass());
	final Class<?> proxyClass = enhancer.createClass();
	Enhancer.registerCallbacks(proxyClass, new Callback[] { interceptor });
	return (T) ObjenesisHelper.newInstance(proxyClass);
}
 

import org.springframework.cglib.proxy.Enhancer; //导入方法依赖的package包/类
public static NamedParameterJdbcOperations wrap(final NamedParameterJdbcOperations jdbcOperations) {
    final Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(NamedParameterJdbcOperations.class);
    enhancer.setCallback((MethodInterceptor) (obj, method, args, proxy) -> {
        final Stopwatch sw = Stopwatch.createStarted();

        try {
            final String methodName = method.getName();

            if (methodName.startsWith("query")
                    || methodName.startsWith("batchUpdate")
                    || methodName.startsWith("update")) {
                logSqlQuery(args);

                final Object result = method.invoke(jdbcOperations, args);

                if (sw.elapsed(TimeUnit.SECONDS) > 5) {
                    LOG.warn("SQL execution took too long {}", sw);
                }

                return result;
            }

            return method.invoke(jdbcOperations, args);

        } catch (InvocationTargetException e) {
            throw e.getTargetException();
        }
    });

    return (NamedParameterJdbcOperations) enhancer.create();
}
 

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

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);
	if (this.owner instanceof ConfigurableBeanFactory) {
		ClassLoader cl = ((ConfigurableBeanFactory) this.owner).getBeanClassLoader();
		enhancer.setStrategy(new ClassLoaderAwareGeneratorStrategy(cl));
	}
	enhancer.setCallbackFilter(new MethodOverrideCallbackFilter(beanDefinition));
	enhancer.setCallbackTypes(CALLBACK_TYPES);
	return enhancer.createClass();
}