前言

这里所说的多重代理，是指代理的代理，即Proxy外再包一层Proxy。

由于CGLIB本身的设计，无法实现在Proxy外面再包装一层Proxy(JDK Proxy可以)，通常会报如下错误：

......
Caused by: java.lang.ClassFormatError: Duplicate method name&signature in class file target/MyTarget$$EnhancerByCGLIB$$3060dbbf$$EnhancerByCGLIB$$e84d8e38
	at java.lang.ClassLoader.defineClass1(Native Method)
	at java.lang.ClassLoader.defineClass(ClassLoader.java:763)
	... 10 more

定位到出错代码：
net.sf.cglib.proxy.Enhancer.generateClass(…)

public void generateClass(ClassVisitor v) throws Exception {

    ......

    if (useFactory) {
        int[] keys = getCallbackKeys();
        
        //写入方法 public Object newInstance(Callback[])
        emitNewInstanceCallbacks(e);
        
        //写入方法 public Object newInstance(Callback)
        emitNewInstanceCallback(e);
        
        //写入方法 public Object newInstance(Class[], Object[], Callback[])
        emitNewInstanceMultiarg(e, constructorInfo);
        
        //写入方法 public Callback getCallback(int)
        emitGetCallback(e, keys);
        
        //写入方法 public void setCallback(int, Callback)
        emitSetCallback(e, keys);
        
        //写入方法 public Callback[] getCallbacks()
        emitGetCallbacks(e);
        
        //写入方法 public void setCallbacks(Callback[])
        emitSetCallbacks(e);
    }

    e.end_class();
}

根据以上代码，我们可以发现，每次代理类生成时，CGLIB都会将以上7个public方法插入。

反编译生成出来的代理类，我们可以看到：


就是CGLIB插入的这7个方法发生了重复，导致构造Class出错。

但是为什么会发生重复呢？
原因很简单，当第一次构造代理类时，CGLIB将以上7个public方法插入Class，这时构造代理类Class是正常的，但是将这个代理类当做目标类，第二次构造代理类时出问题了，我们知道，CGLIB会重写目标类非private和非final方法，因此在第二次构造的代理类中就已经重写了这7个方法，而CGLIB本身又会插入这7个方法，因此在Class中会有重复，导致构造代理类Class失败。

如何实现

CGLIB与JDK动态代理相结合

既然两次CGLIB不行，我们试一下第一次代理类依旧使用CGLIB，第二次代理类生成用JDK动态代理。

第一次CGLIB动态代理拦截器

public class CGLIBInterceptor implements MethodInterceptor {
    
    public Object getFirstProxy(Class<?> targetClass) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(targetClass);
        enhancer.setCallback(this);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object arg0, Method arg1, Object[] arg2, MethodProxy arg3) throws Throwable {
        System.out.println("before CGLIBInterceptor");
        Object result = arg3.invokeSuper(arg0, arg2);
        System.out.println("after CGLIBInterceptor");
        return result;
    }

}

第二次JDK动态代理拦截器

public class JDKInterceptor implements InvocationHandler {
    
    private Object target;
    
    public Object getProxy(ClassLoader loader, Class<?>[] interfaces, Object target) {
        this.target = target;
        return Proxy.newProxyInstance(loader, interfaces, this);
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("before JDKInterceptor");
        Object result = method.invoke(this.target, args);
        System.out.println("after JDKInterceptor");
        return result;
    }

}

目标类接口

public interface ITarget {
    
    void hello(String str);
    
    String parse(String str);
}

目标类实现

public class MyTarget implements ITarget{
    
    @Override
    public void hello(String str) {
        System.out.println("hello MyTarget, " + str);
    }
    
    @Override
    public String parse(String str) {
        return "MyTarget > " + str;
    }

}

测试

public class CompositeProxyTest {
    
    public static void main(String[] args) {
        CGLIBInterceptor cglibInterceptor = new CGLIBInterceptor();
        MyTarget cglibProxy = (MyTarget)cglibInterceptor.getFirstProxy(MyTarget.class);
        
        JDKInterceptor jdkInterceptor = new JDKInterceptor();
        ITarget jdkProxy = (ITarget)jdkInterceptor.getProxy(MyTarget.class.getClassLoader(), MyTarget.class.getInterfaces(), cglibProxy);
        jdkProxy.hello("张三");
        System.out.println();
        System.out.println(jdkProxy.parse("李四"));
    }

}

输出

before JDKInterceptor
before CGLIBInterceptor
hello MyTarget, 张三
after CGLIBInterceptor
after JDKInterceptor

before JDKInterceptor
before CGLIBInterceptor
after CGLIBInterceptor
after JDKInterceptor
MyTarget > 李四

没什么问题，但是一旦用到JDK动态代理，目标类就必须实现接口。因此这种实现并不能适应全部情况。

类Spring AOP方式

在拦截器里放一个过滤器链即可，用户在过滤器里拦截多重调用。这些拦截器，就像你加@Around注解的方法，只不过我们这里没有Spring那么方便而已。

示例UML图：

拦截器链

public class Chain {
    
    private List<Point> list;
    private int index = -1;
    private Object target;
    
    public Chain(Object target, List<Point> list) {
        this.target = target;
        this.list = list;
    }
    
    public Object proceed(Method method, Object[] args) {
        Object result = null;
        if(++index == list.size()) {
            try {
                result = method.invoke(target, args);
            } catch (Exception e) {
                e.printStackTrace();
            }
            System.out.println("Target Method invoke result :" + result);
        } else {
            result = list.get(index).proceed(this, method, args);
        }
        return result;
    }
    
    public void resetIndex() {
        this.index = -1;
    }
    
    public interface Point {
        public Object proceed(Chain chain, Method method, Object[] args);
    }

}

拦截器1

public class Point1 implements Point {

    @Override
    public Object proceed(Chain chain, Method method, Object[] args) {
        System.out.println("before Point1");
        Object result = chain.proceed(method, args);
        System.out.println("after Point1");
        return result;
    }

}

拦截器2

public class Point2 implements Point {

    @Override
    public Object proceed(Chain chain, Method method, Object[] args) {
        System.out.println("before Point2");
        Object result = chain.proceed(method, args);
        System.out.println("after Point2");
        return result;
    }


}

代理工厂，调度入口

public class ProxyFactory implements MethodInterceptor {
    
    private Chain chain;
    
    public static ProxyFactory create() {
        return new ProxyFactory();
    }
    
    public Object getProxy(Object target) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(target.getClass());
        enhancer.setCallback(this);
        
        List<Point> list = new ArrayList<Point>(2);
        list.add(new Point1());
        list.add(new Point2());
        chain = new Chain(target, list);
        return enhancer.create();
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        chain.resetIndex();
        return chain.proceed(method, args);
    }

}

测试

public class CompositeProxyTest {
    
    public static void main(String[] args) {
        ITarget iTarget = (ITarget)ProxyFactory.create().getProxy(new MyTarget());
        iTarget.hello("张三");
        
        System.out.println();
        System.out.println(iTarget.parse("李四"));
    }

}

输出

before Point1
before Point2
hello MyTarget, 张三
Target Method invoke result :null
after Point2
after Point1

before Point1
before Point2
Target Method invoke result :MyTarget > 李四
after Point2
after Point1
MyTarget > 李四

符合预期。

参考：

使用 Cglib 实现多重代理