Java Code Examples for net.sf.cglib.proxy.Enhancer#setCallback()

public static final <T> T createProxy(Class<T> clazz,MethodInterceptor interceptor) {
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(clazz);
    enhancer.setCallback(new NulsMethodInterceptor(interceptor));

    return (T) enhancer.create();
}
 

protected <T extends InteractionAwareFixture> T createFirst(Callback callback, Class<T> clazz, Class<?>[] constructorTypes, Object[] constructorArgs) {
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(clazz);
    enhancer.setCallback(callback);

    T result;
    if (constructorArgs != null && constructorArgs.length > 0) {
        result = (T) enhancer.create(constructorTypes, constructorArgs);
    } else {
        result = (T) enhancer.create();
    }
    return result;
}
 

private static void testCglibExecution() {
  MethodInterceptor methodInterceptor = new SubjectInterceptor();
  Enhancer enhancer = new Enhancer();
  enhancer.setSuperclass(ConcreteSubject.class);
  enhancer.setCallback(methodInterceptor);
  ISubject subject = (ISubject) enhancer.create();
  long start = System.currentTimeMillis();
  for (int i = 0; i < execution; i++) {
    subject.action();
  }
  long stop = System.currentTimeMillis();
  LOG.info("cglib execution time : {} ms", stop - start);
}
 

@Test
public void givenEnhancerProxy_whenExtendPersonService_thenInterceptMethod() throws Exception {
    // given
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(PersonService.class);
    enhancer.setCallback((FixedValue) () -> "Hello Tom!");
    PersonService proxy = (PersonService) enhancer.create();

    // when
    String res = proxy.sayHello(null);

    // then
    assertEquals("Hello Tom!", res);
}
 

public static <T> T getProxy(RpcClient rpcClient, Class clazz, NamingOptions namingOptions) {
    rpcClient.setServiceInterface(clazz, namingOptions);
    Enhancer en = new Enhancer();
    en.setSuperclass(clazz);
    en.setCallback(new BrpcProxy(rpcClient, clazz));
    return (T) en.create();
}
 

public static void main(String[] args) {
    while (true){
        Enhancer  enhancer = new Enhancer() ;
        enhancer.setSuperclass(HeapOOM.class);
        enhancer.setUseCache(false) ;
        enhancer.setCallback(new MethodInterceptor() {
            @Override
            public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
                return methodProxy.invoke(o,objects) ;
            }
        });
        enhancer.create() ;

    }
}
 

/**
 * 创建代理对象
 * @param target 被代理的对象
 * @return
 */
public Object getProxyInstance(Object target){
    this.target = target;
    // 声明增强类实例
    Enhancer enhancer = new Enhancer();
    // 设置被代理类字节码，CGLIB根据字节码生成被代理类的子类
    enhancer.setSuperclass(this.target.getClass());
    // 设置要代理的拦截器，回调函数，即一个方法拦截   new MethodInterceptor()
    enhancer.setCallback(this);
    // 创建代理对象 实例
    return enhancer.create();
}
 

@Override
protected Object getProxyInternal(ClassLoader loader, Class<?>[] interfaces,
                                  final java.lang.reflect.InvocationHandler h) {

    Class<?> superClass = null;
    List<Class<?>> theInterfaces = new ArrayList<>();

    for (Class<?> c : interfaces) {
        if (!c.isInterface()) {
            if (superClass != null) {
                throw new IllegalArgumentException("Only a single superclass is supported");
            }
            superClass = c;
        } else {
            theInterfaces.add(c);
        }
    }
    if (superClass != null) {
        Enhancer enhancer = new Enhancer();
        enhancer.setClassLoader(loader);
        enhancer.setSuperclass(superClass);
        enhancer.setInterfaces(theInterfaces.toArray(new Class<?>[0]));
        enhancer.setCallback(new MethodInterceptor() {

            public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy)
                throws Throwable {
                return h.invoke(obj, method, args);
            }

        });
        return enhancer.create();
    }
    return super.getProxyInternal(loader, interfaces, h);
}
 

/**
 * 使用动态代理的方式创建对象的实例
 * Create an instance of the object using a dynamic proxy.
 */
private static Object createProxy(Class clazz, MethodInterceptor interceptor) {
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(clazz);
    enhancer.setCallback(interceptor);
    return enhancer.create();
}
 

public static void main(String[] args) {
  MethodInterceptor methodInterceptor = new SubjectInterceptor();
  Enhancer enhancer = new Enhancer();
  enhancer.setSuperclass(ConcreteSubject.class);
  enhancer.setCallback(methodInterceptor);
  ISubject subject = (ISubject)enhancer.create();
  subject.action();
}
 

@Override
public Object proxy() {
    Enhancer enhancer = new Enhancer();
    //目标对象类
    enhancer.setSuperclass(target.getClass());
    enhancer.setCallback(this);
    //通过字节码技术创建目标对象类的子类实例作为代理
    return enhancer.create();
}
 

@SuppressWarnings("unchecked")
public static <T> T getProxyInstance(Object target, ProxyMethodInterceptor interceptor) {
	ProxyFactory pf = new ProxyFactory(target, interceptor);
	Enhancer en = new Enhancer();
	en.setSuperclass(target.getClass());
	en.setCallback(pf);
	return (T)en.create();
}
 

public Object createProxy() {
  Enhancer enhancer = new Enhancer();
  //设置代理类为目标类的子类
  enhancer.setSuperclass(this.target.getClass());
  //设置拦截器为回调函数
  enhancer.setCallback(this);
  return enhancer.create();
}
 

/**
 * 获取代理对象
 *
 * @param clazz bean的class
 * @return 对象
 */
public Object getProxy(Class<?> clazz) {
	enhancer = new Enhancer();
	// 设置需要创建子类的类
	enhancer.setSuperclass(clazz);
	enhancer.setCallback(this);
	// 通过字节码技术动态创建子类实例
	return enhancer.create();
}
 

/**
 * 获取代理类
 * @param clazz 类信息
 * @return 代理类结果
 */
public Object getProxy(Class clazz){
    Enhancer enhancer = new Enhancer();
    //目标对象类
    enhancer.setSuperclass(clazz);
    enhancer.setCallback(this);
    //通过字节码技术创建目标对象类的子类实例作为代理
    return enhancer.create();
}
 

private CoreContainer getZkAwareCoreContainer(final CoreContainer cc) {
  Enhancer e = new Enhancer();
  e.setClassLoader(cc.getClass().getClassLoader());
  e.setSuperclass(CoreContainer.class);
  e.setCallback(new MethodInterceptor() {
    public Object intercept(Object obj, Method method, Object [] args, MethodProxy proxy) throws Throwable {
      if (method.getName().equals("isZooKeeperAware")) {
        return Boolean.TRUE;
      }
      return method.invoke(cc, args);
    }
  });
  return (CoreContainer)e.create();
}
 

@Override
public Object getProxy() {
	Enhancer enhancer = new Enhancer();
	enhancer.setSuperclass(advised.getTargetSource().getTargetClass());
	enhancer.setInterfaces(advised.getTargetSource().getInterfaces());
	enhancer.setCallback(new DynamicAdvisedInterceptor(advised));
	Object enhanced = enhancer.create();
	return enhanced;
}
 

@SuppressWarnings("unchecked")
public RefreshableProxy(final T target) {
	super();
	this.target = target;
	final Enhancer enhancer = new Enhancer();
	enhancer.setSuperclass(this.target.getClass());
	enhancer.setCallback(this);
	proxy = (T) enhancer.create();
}
 

@Override
public JsonRender createJsonRender() {
	Enhancer enhancer = new Enhancer();
	enhancer.setSuperclass(JsonRender.class);
	enhancer.setCallback(new RenderMointorIntercetor());
	return (JsonRender)enhancer.create();
}
 

public static final <T> T createProxy(Class<T> clazz,Class[] paramsClass,Object[] params,MethodInterceptor interceptor) {
    Enhancer enhancer = new Enhancer();
    enhancer.setSuperclass(clazz);
    enhancer.setCallback(new NulsMethodInterceptor(interceptor));
    return (T) enhancer.create(paramsClass,params);
}