代理模式

什么是代理模式

定义：为对象提供一种代理，以控制对这个对象的访问。

生活案例:

1. 租房中介, 执行者：中介 被代理人：我 这房子必须找，但是自己找麻烦，所以委托中介

   需要将你将租房的要求告诉中介

2. 黄牛, 执行者：黄牛 被代理人：我 这票必须买，但是买不到，只有找黄牛 你需要什么票需要告诉黄牛

3. 媒人, 执行者：媒婆 被代理人：我 这媳妇必须找，但是自己找不到/没空找 你要找什么类型的妹子，你需要告诉媒婆

满足代理模式应用场景的三个必要条件：

1. 有两个主要角色：执行者、被代理人

2. 注重过程，对于被代理对象来说，这件事一定要做的，但是自己不想做或者没时间做，找代理

3. 代理对象需要获取被代理对象的个人资料（执行者持有被代理对象的引用）

应用场景

• 日志代理类： 原始类不想做打印日志的功能，因为这会污染业务代码。日志代理类最重要的功能是打印日志，注重日志打印这个过程。

• 性能计算代理类

分类

代理模式分为两种：

1. 静态代理

2. 动态代理

其中动态代理又分为， jdk动态代理 和 cglib动态代理

静态代理实现

file

简单点来说，就是RealSubject类想要为Client类提供一些功能，但是RealSubject类又不能暴露自己的存在， 所以，委托代理Proxy类，让Proxy类调用RealSubject类的功能，从而让Client类间接使用RealSubject类的功能。 这样，代理中介就会将客户端与委托类隔离，还可以增加一些其他的功能。

哈哈，设计模式之禅以及大话设计模式都举了一个有趣的例子，其中设计模式之禅中的例子记忆尤为深刻：

西门庆找潘金莲，那潘金莲不好意思答复呀，咋办，找那个王婆做代理

---

下面是代码示例：

被代理对象的功能接口：

public interface Subject {
    void save(String target);

    String findById(Long id);

    List<String> findAll();
}

被代理对象类：

public class RealSubject implements Subject {
    @Override
    public void save(String target) {
        System.out.println("save success: " + target);
    }

    @Override
    public String findById(Long id) {
        return "张三";
    }

    @Override
    public List<String> findAll() {
        return new ArrayList<String>() {{
            this.add("张三");
            this.add("李四");
            this.add("王五");
            this.add("赵六");
        }};
    }
}

代理对象持有被代理对象的引用，对方法功能扩展：

public class Proxy implements Subject {

    private Subject subject;

    public Proxy(Subject subject) {
        System.err.println("----初始化Dao");
        this.subject = subject;
    }

    @Override
    public void save(String target) {
        System.err.println("----save " + target);
        subject.save(target);
    }

    @Override
    public String findById(Long id) {
        System.err.println("----findById " + id);
        return subject.findById(id);
    }

    @Override
    public List<String> findAll() {
        System.err.println("---findAll ");
        return subject.findAll();
    }
}

使用代理类：

public class Client {

    public static void main(String[] args) {
        Subject subject = new RealSubject();
        Proxy daoProxy = new Proxy(subject);
        String byId = daoProxy.findById(1L);
        System.out.println(byId);
    }
}

动态代理实现

根本： 字节码重组

jdk动态代理： 生成java，通过compiler生成字节码

cglib：直接通过asm.jar 修改字节码

JDK动态代理

jdk动态代理主要涉及两个类：

1. java.lang.reflect.InvocationHandler

2. java.lang.reflect.Proxy。

使用参见代码： me.feathers.proxy.dynamic

jdk动态代理原理:

Proxy.newProxyInstance(被代理类, 被代理类的接口subject.getClass().getInterfaces(), 调用处理器handler);

1. 拿到被代理对象的引用，获取他的接口

2. jdk代理重新生成一个类，同时实现被代理对象实现的接口

3. 获取被代理对象的引用

4. 动态生成一个新的class

生成的新的class中，继承 Proxy 类（获取代理类的class文件方法请查看 me.feathers.proxy.dynamic.jdk.Test），并且持有 InvocationHandler 的引用：

// 代理类的request 方法，实际是调用h的request方法，这里的h就是InvocationHandler
// 从而实现对Subject对象的代理
// 需要被代理对象的接口是为了确认生成对象的功能，可以强转为目标接口实例

public final class $Proxy0 extends Proxy implements Subject {
   static {
       try {
         m3 = Class.forName("com.sun.proxy.$Proxy0").getMethod("request", new Class[0]);
         return;
       } catch(xxx){xxx}
   }

   public final void request() {
       try {
         this.h.invoke(this, m3, null);
         return;
       } catch (Error|RuntimeException localError) {
         throw localError;
       } catch (Throwable localThrowable) {
         throw new UndeclaredThrowableException(localThrowable);
       }
   }
}

---

代码示例如下：

创建调用处理器，调用处理器需要接收当前的代理对象：

public class SubjectHandler implements InvocationHandler {

    private final Subject subject;

    public SubjectHandler(Subject subject) {
        this.subject = subject;
    }

    // 委托处理方法， 在调用subject的每个方法之前后，打印一句话
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("----即将调用方法" + method.getName());
        Object invoke = method.invoke(subject, args);
        System.out.println("----调用方法" + method.getName() + "结束");
        return invoke;
    }
}

生成并使用代理类：

/*
    原理：
    1. 拿到被代理对象的引用，然后获取他的接口
    2. JDK代理重新生成一个类，同时实现我们给的代理对象所实现的接口
    3. 把被代理对象的引用也拿到了
    4. 重新生成一个class字节码
    5. 然后加载
*/
public class Client {

    public static void main(String[] args) {
        Subject subject = new RealSubject();
        // 创建`调用处理器`，代理对象需要`调用处理器`，调用委托对象的方法
        SubjectHandler handler = new SubjectHandler(subject);
        // 获取类加载器
        ClassLoader cl = subject.getClass().getClassLoader();
        // 生成代理对象，需要调用newProxyInstance方法传入类加载器、目标类实现的所有接口、InvocationHandler实例
        // 返回一个Object的代理实例
        Subject s = (Subject) Proxy.newProxyInstance(cl, subject.getClass().getInterfaces(), handler);
        List<String> all = s.findAll();
        System.out.println(all);

        // 查看代理类的类型
        Class proxyClass = s.getClass();
        System.out.println(proxyClass); // class com.sun.proxy.$Proxy0
        // 查看他的父类
        Class superclass = proxyClass.getSuperclass(); // class java.lang.reflect.Proxy
        System.out.println(superclass);
        // 查看他的所有接口，是个数组
        Class[] interfaces = proxyClass.getInterfaces(); // [interface com.yangsx95.proxy.dynamic.jdk.Subject]
        System.out.println(Arrays.toString(interfaces));
    }
}

cglib动态代理

code: me.feathers.proxy.dynamic.cglib

jdk动态代理必须实现一个接口，在灵活性上就可能有些损失，cglib动态代理不同于jdk动态代理，生成的代理对象继承被代理对象。

我们通过操作子类，间接操作父类，从而实现代理。

---

下面是代码示例：

添加cglib依赖：

<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.2.4</version>
</dependency>

定义被代理类类，此类是一个无接口类：

public class RealSubject {

    public void request() {
        System.out.println("我是realRequest方法");
    }

}

定义方法拦截器：

public class SubjectHandler implements MethodInterceptor {

    // 和jdk动态代理相同，同样是做了字节码重组的工作
    // 和jdk动态代理不同，cglib不需要实现任何接口就可以对目标类进行代理，与jdk代理相比，用户是无感知的
    // cglib代理通过继承被代理类，来创建代理类。 即代理类继承被代理类

    // jdk是交给兄弟处理
    // cglib是交给儿子处理

    /**
     * @param o 被代理实例
     * @param method 方法
     * @param objects 参数
     * @param methodProxy
     * @return 方法调用返回值
     * @throws Throwable
     */
    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("即将调用request方法--");
        // 调用代理类父类（被代理类的方法）
        Object invoke = methodProxy.invokeSuper(o, objects);
        System.out.println("调用request方法结束");
        return invoke;
    }

    /**
     * 获取代理实例对象
     * @return 实例对象
     */
    public RealSubject getInstance() throws Exception {
        Enhancer enhancer = new Enhancer();
        // 告诉cglib，生成的代理类，需要继承哪个类
        enhancer.setSuperclass(RealSubject.class);
        // 设置回调，这里需要回调 intercept 方法
        enhancer.setCallback(this);

        // create ----
        // 1. 生成源代码
        // 2. 编译为class
        // 3. 加载到jvm 并返回被代理对象
        return (RealSubject) enhancer.create();
    }
}

生成并使用代理类：

public class Client {

    /**
     * cglib动态代理默认会代理被代理类的所有方法
     */
    public static void main(String[] args) throws Exception {
        SubjectHandler sh = new SubjectHandler();
        RealSubject instance = sh.getInstance();
        instance.request();
    }
}

手动实现动态代理，生成源代码的方式

动态代理是通过对字节码的直接操作生成新的代理类字节码来完成代理的，这里通过生成源代码的方式，实现伪动态代理，大概过程为：找到对象源码类，修改源码，生成新的源码，将新的源码编译加载到内存中，即可生成新的代理类。

代码不再演示。

手动实现动态代理，通过javassist

Javaassist 就是一个用来 处理 Java 字节码的类库，我们可以通过javassist完成动态代理的功能。

JDK中的代理模式

• java.rmi.*