Java代理的三种实现详解

代理模式是一种常用的结构型设计模式，其目的就是为其他对象提供一个代理以控制对该对象的访问，对该对象解耦，同时在不更改该对象的情况下，扩展该对象的功能。代理类负责为委托类预处理消息，过滤消息并转发消息，以及进行消息被委托类执行后的后续处理，可以在不更改目标对象（委托类）的情况下，扩展功能。代理分为静态代理和动态代理。

1、静态代理

静态代理：由程序员手动创建代理类，在程序运行前代理类的.class文件就已经存在了。静态代理在使用时，需要定义接口或者父类，委托类（目标对象）和代理类需要一起实现同一接口或者继承同一父类。

接口类：

定义一只程序猿，有一个通用功能需要实现

public interface ICoder {
    public void commonFunc();
}

目标对象：

实现通用功能

public class CoderImpl implements ICoder {

    @Override
    public void commonFunc() {
        System.out.println("----commonFunc-----");
    }

}

代理对象：

产品经理来了一个新需求，在原有功能上，增加新功能，通用功能有其他地方在用不能更改。因此可以新建一个类将原先的代理复制过来，但是这样会导致以后维护困难；这时代理出现了，代理目标对象，并赋予新功能。

public class CoderImplProxy implements ICoder {
    // 目标对象接口
    private ICoder iCoder;
    public CoderImplProxy(ICoder iCoder) {
        super();
        this.iCoder = iCoder;
    }

    @Override
    public void commonFunc() {
        iCoder.commonFunc();
        System.out.println("-----specificFunc-----");
    }
}

测试类：

public class CoderTest {
    
    public static void main(String[] args) {
        ICoder coderImpl = new CoderImpl();
        ICoder codeImplProxy = new CoderImplProxy(coderImpl);
        
        codeImplProxy.commonFunc();
    }
}

测试结果

----commonFunc-----
-----specificFunc-----

2、动态代理

上面的代理，使客户端可以不需要知道目标对象的具体实现，只要知道代理对象即可（解耦），但是因为需要同目标对象实现相同的接口，当要求对不同的对象代理时，就需要对不同的对象分别进行代理，系统大时无法处理；同时目标对象增加了新的方法，代理对象也要增加方法，增加了维护难度。动态代理很好的解决了这些问题。
动态代理：代理类在程序运行时创建的代理方式。动态代理通过反射机制实现动态代理，能代理各种不同的对象。

2.1 jdk动态代理

接口类：

跟静态代理一样，定义一只程序猿，有一个通用功能需要实现

public interface ICoder {
    public void commonFunc(String funcName, int index);
}

目标对象：

通用方法的实现

public class CoderImpl implements ICoder {
    @Override
    public void commonFunc(String funcName, int index) {
        System.out.println("第"+index+"个方法，名为"+funcName);
    }
}

代理类：

Java的动态代理，需要java.lang.reflect.InvocationHandler接口和 java.lang.reflect.Proxy类的支持，实现InvocationHandler接口。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

public class CoderProxyFactory implements InvocationHandler {
    // 目标对象接口，此处用Object，可以代理所有的目标对象
    private Object target;

    /**
     * 绑定关系，也就是关联到哪个接口（与具体的实现类绑定）的哪些方法将被调用时，执行invoke方法。  
     * @param target
     * @return
     */
    public Object newProxyInstance(Object target){  
        this.target=target;  
        //该方法用于为指定类装载器、一组接口及调用处理器生成动态代理类实例    
        //第一个参数指定产生代理对象的类加载器，需要将其指定为和目标对象同一个类加载器  
        //第二个参数要实现和目标对象一样的接口，所以只需要拿到目标对象的实现接口  
        //第三个参数表明这些被拦截的方法在被拦截时需要执行哪个InvocationHandler的invoke方法  
        //根据传入的目标返回一个代理对象  
        return Proxy.newProxyInstance(
                target.getClass().getClassLoader(), // 类加载器 
                target.getClass().getInterfaces(),  // 
                this
            );  
    }  
    
    //关联的这个实现类的方法被调用时将被执行  
    // InvocationHandler接口的方法，proxy表示代理，method表示原对象被调用的方法，args表示方法的参数
    @Override  
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {  
        for(int i=0;i<args.length;i++){  
            System.out.println(args[i]);  
        }  
        Object result=null;  
        try{  
            //调用目标方法  
            result = method.invoke(target, args);  
            
            // 扩展
            System.out.println("-----specificFunc-----");  
        }catch(Exception e){  
            e.printStackTrace();  
            throw e;  
        }  
        return result;  
    }  
}

测试类

public class CoderTest {
    public static void main(String[] args) {
        CoderProxyFactory coderProxyFactory = new CoderProxyFactory();
        ICoder coderImpl = (ICoder) coderProxyFactory.newProxyInstance(new CoderImpl());  
        coderImpl.commonFunc("sayHello", 2);
    }
}

2.2 cglib代理

虽然动态代理不需要对每个目标对象做代理，但是我们发现，无论是静态代理还是jdk动态代理，所代理的对象都是实现一个或多个接口，也即是针对接口做代理。如果需要针对类做代理，可以通过cglib代理实现。

目标对象

public class Coder {
    public Integer commonFunc(String funcName, int index) {
        System.out.println("第"+index+"个方法，名为"+funcName);
        return 1;
    }
}

代理类

import java.lang.reflect.Method;
import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class ProxyFactory implements MethodInterceptor {
    private Object target;

    public ProxyFactory(Object target) {
        super();
        this.target = target;
    }

    //给目标对象创建一个代理对象
    public Object getProxyInstance(){
        //1.工具类
        Enhancer enhancer = new Enhancer();
        //2.设置父类
        enhancer.setSuperclass(target.getClass());
        //3.设置回调函数
        enhancer.setCallback(this);
        //4.创建子类(代理对象)
        return enhancer.create();
    }

    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        
        for(int i=0;i<args.length;i++){  
            System.out.println(args[i]);  
        }  
        Object result=null;  
        try{  
            //调用目标方法  
            result = method.invoke(target, args);  
            
            // 扩展
            System.out.println("-----specificFunc-----");  
        }catch(Exception e){  
            e.printStackTrace();  
            throw e;  
        }  
        return result;  
    }
}

测试类

public class CglibTest {
    public static void main(String[] args) {
        Coder target = new Coder();
        Coder proxy = (Coder) new ProxyFactory(target).getProxyInstance();
        Integer res = proxy.commonFunc("sayHello", 2);
        System.out.println(res);
    }
}

至此，java的三种代理实现就介绍完了。
cglib动态代理也可以针对接口做代理，跟jdk动态代理一样都是在运行期生成字节码，但是cglib动态代理的实现原理更复杂，效率也比jdk动态更低，这个以后再详细讨论。