Java代理的几种方式

什么是代理

什么是代理呢，其实很好理解，就是不直接访问目标，而是经过一个中间层来访问，就好像下面这样：

Java的静态代理

举个例子，若是咱们一些水果，好比：香蕉、苹果等，写成Java代码，大概是下面这个样子：

//Fruit.java
/**
 * 水果的接口
 */
public interface Fruit {
    /**
     * 获取水果的名字
     */
    public String getName();
}

//Apple.java
public class Apple implements Fruit {
    @Override
    public String getName() {
        return "苹果";
    }
}

//Banana.java
public class Banana implements Fruit {
    @Override
    public String getName() {
        return "香蕉";
    }
}

可是吃水果，你要削皮吧，你不能每一个水果都写一个子类，类处理削皮这个事情吧。所以，咱们能够作一个代理 ，吃苹果以前，先把它削皮。 就像下面这样，把原来的水果包一层：

//PeelFruitProxy.java
/**
 * 代理，让每一个水果去皮
 */
public class PeelFruitProxy implements Fruit {
    private Fruit mFruit;

    public PeelFruit(Fruit fruit) {
        this.mFruit = fruit;
    }
    @Override
    public String getName() {
        System.out.println("proxt:" + proxy.getClass().getName());
        return "去皮的" + mFruit.getName();
    }
}

添加了测试类，测试类以下：

//Main.java
public class Main {
    public static void main(String[] args) {
        Apple apple=new Apple();//原始的苹果
        Banana banana=new Banana();//原始的香蕉

        PeelFruitProxy peelApple=new PeelFruitProxy(apple);//代理,添加去皮功能
        PeelFruitProxy peelBanana=new PeelFruitProxy(banana);//代理,添加去皮功能
        System.out.println(peelApple.getName());
        System.out.println(peelBanana.getName());
    }
}

以上就是Java的静态代理，简单点说，就是把原来的目标对象包一层，加入新东西再去调用目标自己。 可是若是只是这样的静态代理，一个接口，就须要一个代理，实现起来是否是很繁琐。

Java的动态代理

在Java中，有一个干这个事情的类，叫作Proxy，能够直接使用反射方式，代理拦截。 先简单的介绍一下这个类，其实最经常使用的只有一个静态方法Proxt.newProxyInstance(),是这样的：

public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)

首先咱们要实现InvocationHandler，实现其中的invoke方法，在调用目标对象的时候，会先调用到invoke方法，须要实现者在这个方法中，在主动调用被调用者方法。

//FruitInvocationHandler.java
/**
 * 调用方法拦截器
 */
public class FruitInvocationHandler implements InvocationHandler {
    private Fruit mFruit;

    public FruitInvocationHandler(Fruit fruit) {
        this.mFruit = fruit;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String result = (String) method.invoke(mFruit, args);//须要在这个方法里面，主动调用被代理的对象。
        return "去皮的" + result;
    }
}

运行一下：

//Main.Java
public class Main {
    public static void main(String[] args) {
        Apple apple = new Apple();
        Fruit proxyApple = (Fruit) Proxy.newProxyInstance(Fruit.class.getClassLoader(), new Class[]{Fruit.class}, new FruitInvocationHandler(apple));
        System.out.println(proxyApple.getClass().getName());
        System.out.println(proxyApple.getName());

        Banana banana = new Banana();
        Fruit proxyBanana = (Fruit) Proxy.newProxyInstance(Fruit.class.getClassLoader(), new Class[]{Fruit.class}, new FruitInvocationHandler(banana));
        System.out.println(proxyApple.getClass().getName());
        System.out.println(proxyBanana.getName());
    }
}

这个方法，就是生成一个上文中的PeelFruitProxy（固然，咱们看到的他名字叫：com.sun.proxy.$Proxy0），动态的生成，避免每次都须要写，这个也是叫他动态代理的缘由，由于咱们能够在运行时代理任意类。 不少程序中的AOP就是这样实现的，可是咱们发现一些特色，newProxyInstance()的第二个参数，是一个interfaces的列表，为啥要有这个这个列表呢？

由于咱们动态生成的代理类，也须要实现接口，这样才方便向下转型，使用其中的方法，否则，生成的类，类名就是com.sun.proxy.$Proxy0这种，而且是在内存中，没法调用生成的方法。 ** 因此，这种动态代理的方法，有一个致命的缺点，那就是被代理的类，必需要实现接口。**

CGLib代理

cglib is a powerful, high performance and quality Code Generation Library, It is used to extend JAVA classes and implements interfaces at runtime.

另外一个大名鼎鼎的Java代理实现，就是CGLib(Code Generation Library),一个基于ASM的代码生成框架，能够用他来动态生成类，而后实现对方法的拦截，就能够避开JDK的动态代理， 必需要目标类实现接口的问题了。 也就是说，能够用CGLib来生成上文中的PeelFruitProxy。

简单介绍一下怎么用，首先这个CGLib是一个三方的库，咱们要把它依赖进来：

compile 'cglib:cglib:3.2.8'

最新版本能够在这里看(新版本)[https://github.com/cglib/cglib/releases] 而后咱们来试一试，咱们来实现一下上面的代理

//FruitMethodInterceptor.java
/**
 * CGLib代理的方法拦截器
 */
public class FruitMethodInterceptor implements MethodInterceptor{
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        String result = (String) proxy.invokeSuper(obj, args);//主要，这里调用的是父类，也就是说， 生成的类和原始类是继承关系
        return "去皮的"+result;
    }
}

//Main.java
public class Main {
    public static void main(String[] args) {
        Enhancer enhancer = new Enhancer();
        enhancer.setSuperclass(Apple.class);
        enhancer.setCallback(new FruitMethodInterceptor());
        Apple apple = (Apple) enhancer.create();
        System.out.println(apple.getClass().getName());
        System.out.println(apple.getName());
    }
}

运行效果以下：

咱们看到，实现了一样的功能，可是，Apple已经不是原来的Apple类了，变成了com.zjiecode.learn.java.proxy.Apple$$EnhancerByCGLIB$$44ade224，没错，咱们正真使用的是这个类，而不是原来的Apple了，这个类继承自Apple，最后实现了对Apple类的代理。 这种方式，由于使用的是继承，因此，无需被代理的类实现接口。固然，他也能够经过接口来实现代理。

总结

• 第一种代理，就不说了，只适合单一的一个接口的代理，在编译时就决定好了。
• 第2、三种代理，都是动态时代理 ，可是咱们看到也有差异：
  • JDK的动态代理 ，只能实现接口代理，而且是包装的被代理对象(类的实例),也就是说，在代理的过程当中，有2个对象，一个代理对象，一个目标对象，目标对象被包装在代理对象里面。
  • CGLib的代理，是继承目标对象，生成了一个新的类，而后来实现代理，这样，在内存中就是有代理对象，没有目标对象了，使用的是直接继承的方式
• 生成代理类是在运行时，有别于javapoet在编译时生成类。

学习源码

纸上谈来终觉浅，绝知此事要躬行。 文中提到的源代码，你均可以参考： https://github.com/zjiecode/learn-java/tree/feature/java-proxy

参考资料

https://blog.csdn.net/danchu/article/details/70238002 https://blog.csdn.net/lovejj1994/article/details/78080124 https://www.jianshu.com/p/9a61af393e41?from=timeline&isappinstalled=0 https://github.com/cglib/cglib/wiki

推荐

做为我的开发者，不少时候须要关注服务器报警，提醒等， 要直接把服务器消息推送到手机上，为此，咱们开发了微信消息推送服务[wxpusher]，能够用过API直接把消息实时push到微信上，点击查看介绍。

有木有用 ，关注一下呗，万一有须要的时候呢？