Java Enhancer.setCallbackTypes方法代码示例

import net.sf.cglib.proxy.Enhancer; //导入方法依赖的package包/类
public ConstructionProxy<T> create() throws ErrorsException {
  if (interceptors.isEmpty()) {
    return new DefaultConstructionProxyFactory<T>(injectionPoint).create();
  }

  @SuppressWarnings("unchecked")
  Class<? extends Callback>[] callbackTypes = new Class[callbacks.length];
  for (int i = 0; i < callbacks.length; i++) {
    if (callbacks[i] == net.sf.cglib.proxy.NoOp.INSTANCE) {
      callbackTypes[i] = net.sf.cglib.proxy.NoOp.class;
    } else {
      callbackTypes[i] = net.sf.cglib.proxy.MethodInterceptor.class;
    }
  }

  // Create the proxied class. We're careful to ensure that all enhancer state is not-specific
  // to this injector. Otherwise, the proxies for each injector will waste PermGen memory
  try {
  Enhancer enhancer = BytecodeGen.newEnhancer(declaringClass, visibility);
  enhancer.setCallbackFilter(new IndicesCallbackFilter(methods));
  enhancer.setCallbackTypes(callbackTypes);
  return new ProxyConstructor<T>(enhancer, injectionPoint, callbacks, interceptors);
  } catch (Throwable e) {
    throw new Errors().errorEnhancingClass(declaringClass, e).toException();
  }
}
 

import net.sf.cglib.proxy.Enhancer; //导入方法依赖的package包/类
public BasicProxyFactoryImpl(Class superClass, Class[] interfaces) {
	if ( superClass == null && ( interfaces == null || interfaces.length < 1 ) ) {
		throw new AssertionFailure( "attempting to build proxy without any superclass or interfaces" );
	}

	Enhancer en = new Enhancer();
	en.setUseCache( false );
	en.setInterceptDuringConstruction( false );
	en.setUseFactory( true );
	en.setCallbackTypes( CALLBACK_TYPES );
	en.setCallbackFilter( FINALIZE_FILTER );
	if ( superClass != null ) {
		en.setSuperclass( superClass );
	}
	if ( interfaces != null && interfaces.length > 0 ) {
		en.setInterfaces( interfaces );
	}
	proxyClass = en.createClass();
	try {
		factory = ( Factory ) proxyClass.newInstance();
	}
	catch ( Throwable t ) {
		throw new HibernateException( "Unable to build CGLIB Factory instance" );
	}
}
 

import net.sf.cglib.proxy.Enhancer; //导入方法依赖的package包/类
public T getProxy() {
    Class proxyClass = getProxy(delegateClass.getName());
    if (proxyClass == null) {
        Enhancer enhancer = new Enhancer();
        if (delegateClass.isInterface()) { // 判断是否为接口，优先进行接口代理可以解决service为final
            enhancer.setInterfaces(new Class[] { delegateClass });
        } else {
            enhancer.setSuperclass(delegateClass);
        }
        enhancer.setCallbackTypes(new Class[] { ProxyDirect.class, ProxyInterceptor.class });
        enhancer.setCallbackFilter(new ProxyRoute());
        proxyClass = enhancer.createClass();
        // 注册proxyClass
        registerProxy(delegateClass.getName(), proxyClass);
    }

    Enhancer.registerCallbacks(proxyClass, new Callback[] { new ProxyDirect(), new ProxyInterceptor() });
    try {
        Object[] _constructorArgs = new Object[0];
        Constructor _constructor = proxyClass.getConstructor(new Class[] {});// 先尝试默认的空构造函数
        return (T) _constructor.newInstance(_constructorArgs);
    } catch (Throwable e) {
        throw new OptimizerException(e);
    } finally {
        // clear thread callbacks to allow them to be gc'd
        Enhancer.registerStaticCallbacks(proxyClass, null);
    }
}
 

import net.sf.cglib.proxy.Enhancer; //导入方法依赖的package包/类
public static Class<?> getProxyClass(Class<?> clazz) {
    Enhancer e = new Enhancer();
    if (clazz.isInterface()) {
     e.setSuperclass(clazz);
    } else {
     e.setSuperclass(clazz);
     e.setInterfaces(clazz.getInterfaces());
    }
    e.setCallbackTypes(new Class[]{
        InvocationHandler.class,
        NoOp.class,
    });
    e.setCallbackFilter(BAD_OBJECT_METHOD_FILTER);
    e.setUseFactory(true);
    e.setNamingPolicy(new LithiumTestProxyNamingPolicy());
    return e.createClass();
}
 

import net.sf.cglib.proxy.Enhancer; //导入方法依赖的package包/类
private static Object newProxyByCglib(Typing typing, Handler handler) {
  Enhancer enhancer = new Enhancer() {
    /** includes all constructors */
    protected void filterConstructors(Class sc, List constructors) {}
  };
  enhancer.setClassLoader(Thread.currentThread().getContextClassLoader());
  enhancer.setUseFactory(true);
  enhancer.setSuperclass(typing.superclass);
  enhancer.setInterfaces(typing.interfaces.toArray(new Class[0]));
  enhancer.setCallbackTypes(new Class[] { MethodInterceptor.class, NoOp.class });
  enhancer.setCallbackFilter(new CallbackFilter() {
    /** ignores bridge methods */
    public int accept(Method method) {
      return method.isBridge() ? 1 : 0;
    }
  });
  Class<?> proxyClass = enhancer.createClass();
  Factory proxy = (Factory) new ObjenesisStd().newInstance(proxyClass);
  proxy.setCallbacks(new Callback[] { asMethodInterceptor(handler), new SerializableNoOp() });
  return proxy;
}
 

import net.sf.cglib.proxy.Enhancer; //导入方法依赖的package包/类
private Factory createFactory(Class<?> classToProxify) throws IllegalAccessException, InstantiationException {
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(classToProxify);
    enhancer.setCallbackFilter(new ImmutabilityCallbackFilter(this, classToProxify));
    enhancer.setCallbackTypes(new Class[]{
            EqualsMethodInterceptor.class,
            ExceptionMethodInterceptor.class,
            DelegatingMethodInterceptor.class,
            FreezingMethodInterceptor.class
    });
    Class proxyClass = enhancer.createClass();
    return (Factory) proxyClass.newInstance();
}
 

import net.sf.cglib.proxy.Enhancer; //导入方法依赖的package包/类
public static Class getProxyFactory(Class persistentClass, Class[] interfaces)
		throws HibernateException {
	Enhancer e = new Enhancer();
	e.setSuperclass( interfaces.length == 1 ? persistentClass : null );
	e.setInterfaces(interfaces);
	e.setCallbackTypes(new Class[]{
		InvocationHandler.class,
		NoOp.class,
  		});
 		e.setCallbackFilter(FINALIZE_FILTER);
 		e.setUseFactory(false);
	e.setInterceptDuringConstruction( false );
	return e.createClass();
}
 

import net.sf.cglib.proxy.Enhancer; //导入方法依赖的package包/类
@Override
public ConstructionProxy<T> create() throws ErrorsException {
  if (interceptors.isEmpty()) {
    return new DefaultConstructionProxyFactory<T>(injectionPoint).create();
  }

  @SuppressWarnings("unchecked")
  Class<? extends Callback>[] callbackTypes = new Class[callbacks.length];
  for (int i = 0; i < callbacks.length; i++) {
    if (callbacks[i] == net.sf.cglib.proxy.NoOp.INSTANCE) {
      callbackTypes[i] = net.sf.cglib.proxy.NoOp.class;
    } else {
      callbackTypes[i] = net.sf.cglib.proxy.MethodInterceptor.class;
    }
  }

  // Create the proxied class. We're careful to ensure that all enhancer state is not-specific
  // to this injector. Otherwise, the proxies for each injector will waste PermGen memory
  try {
    Enhancer enhancer = BytecodeGen.newEnhancer(declaringClass, visibility);
    enhancer.setCallbackFilter(new IndicesCallbackFilter(methods));
    enhancer.setCallbackTypes(callbackTypes);
    return new ProxyConstructor<T>(enhancer, injectionPoint, callbacks, interceptors);
  } catch (Throwable e) {
    throw new Errors().errorEnhancingClass(declaringClass, e).toException();
  }
}
 

import net.sf.cglib.proxy.Enhancer; //导入方法依赖的package包/类
public void shouldDeProxyCGLibProxy() throws Exception {
  Enhancer enhancer = new Enhancer();
  enhancer.setSuperclass(ArrayList.class);
  enhancer.setCallbackTypes(new Class[] { NoOp.class });
  Class<?> proxy = enhancer.createClass();

  assertEquals(Types.deProxy(proxy), ArrayList.class);
}
 

import net.sf.cglib.proxy.Enhancer; //导入方法依赖的package包/类
private Class enhanceServiceEndpointInterface(Class serviceEndpointInterface, ClassLoader classLoader) {
    Enhancer enhancer = new Enhancer();
    enhancer.setClassLoader(classLoader);
    enhancer.setSuperclass(GenericServiceEndpointWrapper.class);
    enhancer.setInterfaces(new Class[]{serviceEndpointInterface});
    enhancer.setCallbackFilter(new NoOverrideCallbackFilter(GenericServiceEndpointWrapper.class));
    enhancer.setCallbackTypes(new Class[]{NoOp.class, MethodInterceptor.class});
    enhancer.setUseFactory(false);
    enhancer.setUseCache(false);

    return enhancer.createClass();
}
 

import net.sf.cglib.proxy.Enhancer; //导入方法依赖的package包/类
@Override
protected Class<?> createProxyClass() {
	Enhancer en = new Enhancer();
    en.setInterceptDuringConstruction(false);
    en.setUseFactory(true);
    
    en.setSuperclass(unproxiedClass);
    if (isDistinguishable(unproxiedClass)) {
        isDistinguishable = true;
        en.setInterfaces(new Class[] { Persistent.class, Distinguishable.class });
        en.setCallbackTypes(new Class[] { MethodInterceptor.class, NoOp.class });
        en.setCallbackFilter(FINALIZE_AND_DISTINGUISHABLE_INTEFERCE_FILTER);
    } else {
        en.setInterfaces(new Class[] { Persistent.class });
        en.setCallbackType(SetterInterceptor.class);
    }
    
    // Add an additional track field.
    en.setStrategy(new DefaultGeneratorStrategy() {
        protected ClassGenerator transform(ClassGenerator cg) throws Exception {
            return new TransformingClassGenerator(cg, new AddPropertyTransformer(
                    new String[] { MODIFIED_PROP_NAMES },
                    new Type[] { Type.getType(Set.class) }
                ));
        }
    });
    
    return en.createClass();
}
 

import net.sf.cglib.proxy.Enhancer; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private Class<Connection> createProxyConnectionClass() {
    Set<Class<?>> interfaces = ClassLoaderUtils.getAllInterfaces(Connection.class);
    interfaces.add(PooledConnectionProxy.class);

    Enhancer enhancer = new Enhancer();
    enhancer.setInterfaces(interfaces.toArray(new Class<?>[0]));
    enhancer.setCallbackTypes(new Class[] {FastDispatcher.class, Interceptor.class} );
    enhancer.setCallbackFilter(new InterceptorFilter(new ConnectionJavaProxy()));
    return enhancer.createClass();
}
 

import net.sf.cglib.proxy.Enhancer; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private Class<PreparedStatement> createProxyPreparedStatementClass() {
    Set<Class<?>> interfaces = ClassLoaderUtils.getAllInterfaces(PreparedStatement.class);

    Enhancer enhancer = new Enhancer();
    enhancer.setInterfaces(interfaces.toArray(new Class<?>[0]));
    enhancer.setCallbackTypes(new Class[] {FastDispatcher.class, Interceptor.class} );
    enhancer.setCallbackFilter(new InterceptorFilter(new PreparedStatementJavaProxy()));
    return enhancer.createClass();
}
 

import net.sf.cglib.proxy.Enhancer; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private Class<Statement> createProxyStatementClass() {
    Set<Class<?>> interfaces = ClassLoaderUtils.getAllInterfaces(Statement.class);

    Enhancer enhancer = new Enhancer();
    enhancer.setInterfaces(interfaces.toArray(new Class<?>[0]));
    enhancer.setCallbackTypes(new Class[] {FastDispatcher.class, Interceptor.class} );
    enhancer.setCallbackFilter(new InterceptorFilter(new StatementJavaProxy()));
    return enhancer.createClass();
}
 

import net.sf.cglib.proxy.Enhancer; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
private Class<CallableStatement> createProxyCallableStatementClass() {
    Set<Class<?>> interfaces = ClassLoaderUtils.getAllInterfaces(CallableStatement.class);

    Enhancer enhancer = new Enhancer();
    enhancer.setInterfaces(interfaces.toArray(new Class<?>[0]));
    enhancer.setCallbackTypes(new Class[] {FastDispatcher.class, Interceptor.class} );
    enhancer.setCallbackFilter(new InterceptorFilter(new CallableStatementJavaProxy()));
    return enhancer.createClass();
}