java基础之静态代理和动态代理

在看一些源码过程中发现有很多都会用到代理。代理主要分为静态代理和动态代理。这里了解一下代理在java中的实现方式。
代码地址

静态代理

静态代理的实现方式主要是：目标类和代理类都实现同一个接口，然后通过代理类来调用被代理类中的方法，并且可以在调用方法的时候对方法实现功能的增强。实现起来相对比较简单,看代码

public interface SmsService { //接口定义
    void send(String phone,String content);
}

public class AliSmsService implements SmsService{ //需要被代理的类实现接口
    @Override
    public void send(String phone, String content) {//实现接口中的方法
        System.out.println("use ali sms service  send message to the phone ");
    }
}

public class SmsProxyService implements SmsService{ //代理类实现接口
    SmsService smsService; 
    public SmsProxyService(SmsService smsService) { //将需要被代理的类注入代理类中
        this.smsService = smsService;
    }
    @Override
    public void send(String phone, String content) {//实现接口中的方法
        beforeSend();  //功能增强
        smsService.send(phone,content); //实际执行被代理类中的方法
        afterSend(); //功能增强
    }
    private void afterSend() {
        //TODO
    }
    private void beforeSend() {
      	//TODO
    }

 public static void main(String[] args) { //调用的方法
        String phone = "";
        String content = "";
        AliSmsService aliSmsService = new AliSmsService();
        SmsProxyService proxyService = new SmsProxyService(aliSmsService);
        proxyService.send(phone,content);
    }

上边就是静态代理实现过程以及调用的方法。
优点：可以隐藏被代理类的具体实现过程，并且可以在不修改被代理类的前提下对方法扩展。
缺点：如果被代理类实现很多接口，那么代理类要么实现全部接口，要么就需要创建多个代理类，这样代理类就有两个问题，实现全部接口维护起来就比较复杂，如果创建多个代理类也不好维护。到这里就需要 动态代理来解决整个问题了。

动态代理

动态代理就是根据一定的条件在程序运行时动态的生成代理类。动态生成代理主要就是想办法根据被代理类或者接口来计算得出代理类的字节码，然后加载到jvm中，就可以使用了。
根据代理类和接口计算得出字节码这个具体实现有点复杂，先放一放吧
为什么可以加载到jvm中，
JVM类加载机制 加载>>验证>>准备>>解析>>初始化>>使用>>卸载 ，在加载的时候主要是3个步骤：1，通过类的全限定名获取对应的二进制字节码；2，将字节码流中静态存储结构转化为运行时数据结构；3，在内存中生成类的对象，作为方法区这个类的各种数据访问入口；
在第一步中通过类的全限定名获取对应的二进制字节码，这里有很多种方式，其中有一种方式就是运行时动态计算生成。加载到内存中就可以使用了。

动态代理实现方式：

JDK自带动态代理

主要用到两个类 java.lang.reflect.Proxy， java.lang.reflect.InvocationHandler。
这里可以这样理解，被代理类A，动态代理类B（动态生成，无需手动编写），代理操作类C（需要实现InvocationHandler），Proxy（用来生成动态代理类B）。

public interface CallService {
    void call(String phone);
}

public interface SmsService {
    void send(String phone);
}

public class AliSmsService implements SmsService , CallService{ //被代理类A
    @Override
    public void send(String phone) {
        System.out.println("send the message to the phone :" +phone);
    }
    @Override
    public void call(String phone) {
        System.out.println(" call the phone :" + phone);
    }
}

public class SmsProxyHandler implements InvocationHandler { //代理操作类C
    Object target; //被代理类A
    public SmsProxyHandler(Object target) {
        this.target = target;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println(proxy.getClass());//com.sun.proxy.$Proxy0
        beforeMethod();
        Object invoke = method.invoke(target, args);
        afterMethod();
        return  invoke;
    }
    private void afterMethod() {
        System.out.println("we can do something after the method ");
    }
    private void beforeMethod() {
        System.out.println("we can do something before the method ");
    }
}

    /**
     * JDK动态代理只能代理实现了接口的类，并且只能代理接口中的方法。生成的代理类时继承自Proxy又因java是单继承。
     * 所以只能代理接口的实现类。
     */
    private static void testJDKDynamicProxy(){
        //定义需要代理的类对象
        CallService smsService = new AliSmsService();
        Class<? extends CallService> clazz = smsService.getClass();
        System.out.println(clazz); //com.mao.proxy.dynamicproxy.AliSmsService
       // 代理操作类，可以实现代理类方法的增强 例如 在执行方法前后插入操作
        SmsProxyHandler smsProxyHandler = new SmsProxyHandler(smsService);
        // 通过Proxy.newProxyInstance 方法获得代理类
        CallService service = (CallService)Proxy.newProxyInstance(smsService.getClass().getClassLoader(), smsService.getClass().getInterfaces(), smsProxyHandler);
        System.out.println(service.getClass()); //com.sun.proxy.$Proxy0 理类默认类名
//        service.send("123456");
        service.call("456789"); //通过代理类调用目标类中的方法
    }

下面看一下生成的代理类长什么样

public final class $proxy0 extends Proxy implements CallService {
    private static Method m1;
    private static Method m3;
    private static Method m2;
    private static Method m4;
    private static Method m0;

    public $proxy1(InvocationHandler var1) throws  {
        super(var1);
    }

    public final boolean equals(Object var1) throws  {
        try {
            return (Boolean)super.h.invoke(this, m1, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final String setPhone(String var1, int var2) throws  {
        try {
            return (String)super.h.invoke(this, m3, new Object[]{var1, var2});
        } catch (RuntimeException | Error var4) {
            throw var4;
        } catch (Throwable var5) {
            throw new UndeclaredThrowableException(var5);
        }
    }

    public final String toString() throws  {
        try {
            return (String)super.h.invoke(this, m2, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    public final void call(String var1) throws  {
        try {
            super.h.invoke(this, m4, new Object[]{var1});
        } catch (RuntimeException | Error var3) {
            throw var3;
        } catch (Throwable var4) {
            throw new UndeclaredThrowableException(var4);
        }
    }

    public final int hashCode() throws  {
        try {
            return (Integer)super.h.invoke(this, m0, (Object[])null);
        } catch (RuntimeException | Error var2) {
            throw var2;
        } catch (Throwable var3) {
            throw new UndeclaredThrowableException(var3);
        }
    }

    static {
        try {
            m1 = Class.forName("java.lang.Object").getMethod("equals", Class.forName("java.lang.Object"));
            m3 = Class.forName("com.company.dynamicproxy.CallService").getMethod("setPhone", Class.forName("java.lang.String"), Integer.TYPE);
            m2 = Class.forName("java.lang.Object").getMethod("toString");
            m4 = Class.forName("com.company.dynamicproxy.CallService").getMethod("call", Class.forName("java.lang.String"));
            m0 = Class.forName("java.lang.Object").getMethod("hashCode");
        } catch (NoSuchMethodException var2) {
            throw new NoSuchMethodError(var2.getMessage());
        } catch (ClassNotFoundException var3) {
            throw new NoClassDefFoundError(var3.getMessage());
        }
    }
}

和静态代理的理解还是有点像的，不过在动态代理这里多了一个代理操作类，

*****这里还有一个问题要注意一下：
在jdk中代理类生成方法是调用 ProxyGenerator.generateProxyClass(
proxyName, interfaces, accessFlags);

在android sdk中代理类生成方法修改成了本地方法

到这里JDK动态代理就简单实现了一下。这里还有一个问题就是通过这种方式生成的代理类只能代理实现了接口的类。因为java是单继承的，生成的类已经继承自Proxy了。

CGLIB动态代理

public class AliSmsClass { //被代理类（没有实现接口）
    public  void sendMessage(String phone){
        System.out.println("send the message");
    }
}

public class SmsInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        before();
        Object result = proxy.invokeSuper(obj, args);
        return result;
    }
    private void before() {
        System.out.println("before the method ");
    }

}

public class DynamicProxyCglib {
    public static void main(String[] args) {
        AliSmsClass aliSmsClass = new AliSmsClass(); //被代理类
        Enhancer enhancer = new Enhancer(); //生成动态代理工具
        enhancer.setSuperclass(aliSmsClass.getClass()); //设置Super class
        enhancer.setCallback(new SmsInterceptor()); // 设置方法拦截器
        AliSmsClass o = (AliSmsClass) enhancer.create(); //创建动态代理类
        System.out.println(o.getClass()); //com.mao.proxy.cglibproxy.AliSmsClass$$EnhancerByCGLIB$$12a8d09   
        o.sendMessage("123456"); //通过代理类调用被代理类方法
    }
}

感觉实现起来更简单了，但是这里需要注意的是CGLIB是字节码操作类库，在android 虚拟机是执行dex格式的文件，所以android中不能用CGLIB。