Android 静态代理与动态代理详解

时间  2021-08-13
标签 java git github 数组 markdown ide oop 学习 测试 this 栏目 Android 繁體版
原文   原文链接

学习代理前，咱们先了解代理的含义

  1. 定义：给目标对象提供一个代理对象，并由代理对象控制目标对象的引用
  2. 目的：经过引入代理的方式来间接访问目标对象，防止直接访问目标对象给系统带来不肯定的复杂性

为何会有代理出现？

在传统的面向对象思想中，若是想要实现功能复用，要么继承，要么引用，不管哪一种方式，对代码都有必定的侵入性，耦合无可避免java

侵入性含义：

若是你想用它加强你程序的功能，你必须改动你的程序代码，那它就具备侵入性！ 若是只有一两点须要加强还好说，但若是大量功能点须要被加强，那么工做量就会很大，代码也不优雅！ 想象一下，若是你对外公开了一系列接口，忽然领导说了，接口要加权限控制。在哪加？ 最笨的固然是写个程序验证逻辑，而后每一个接口都拿来调用一遍。 这也是面向对象的思想短板，在要为程序新增一些通用功能时，只能经过耦合的方式才能进行。 而代理（动态代理）就能很好的解决该问题！git

静态代理与动态代理

根据加载被代理类的时机不一样，将代理分为静态代理和动态代理。

  • 静态代理：编译时就肯定了被代理的类是哪个
  • 动态代理：运行时才肯定被代理的类是哪一个

静态代理使用

一、静态代理需实现的方法

public interface Subject {

    void sayGoodBye();

    void sayHello(String str);

    boolean isProxy();
}

复制代码

二、定义被代理类（原来功能类）并实现被代理类的功能逻辑（打死都不改的那种）

public class RealSubject implements Subject {
    @Override
    public void sayGoodBye() {
        System.out.println("RealSubject 我是原封不动的代码 sayGoodBye ");
    }
    @Override
    public void sayHello(String str) {
        System.out.println("RealSubject 我是原封不动的代码 sayHello " + str);
    }

    @Override
    public boolean isProxy() {
        System.out.println("RealSubject 我是原封不动的代码 isProxy ");
        return false;
    }
}

复制代码

三、定义静态代理类（功能增长类），这个代理类也必需要实现和被代理类相同的Subject接口，便于对原有功能的加强

public class ProxySubject implements Subject {
    private Subject subject;

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

    @Override
    public void sayGoodBye() {
        //代理类，功能的加强 调用前 sayGoodBye 可作操做（好比是否能调用的权限认证）
        System.out.println("ProxySubject sayGoodBye begin " +
                "代理类，功能的加强 调用前 sayGoodBye 可作操做（好比是否能调用的权限认证）");
        //在代理类的方法中 间接访问被代理对象的方法
        subject.sayGoodBye();
        System.out.println("ProxySubject sayGoodBye end " +
                "这里可处理原方法调用后的逻辑处理");
    }

    @Override
    public void sayHello(String str) {
        //代理类，功能的加强 调用前 sayHello 可作操做（好比是否能调用的权限认证） 并测试带参数的方法
        System.out.println("ProxySubject sayHello begin " +
                "代理类，功能的加强 调用前 sayHello 可作操做（好比是否能调用的权限认证）");
        //在代理类的方法中 间接访问被代理对象的方法
        subject.sayHello(str);
        System.out.println("ProxySubject sayHello end " +
                "这里可处理原方法调用后的逻辑处理");
    }

    @Override
    public boolean isProxy() {
        //代理类，功能的加强 调用前 isProxy 可作操做（好比是否能调用的权限认证） 并测试带返回的方法
        System.out.println("ProxySubject isProxy begin " +
                "代理类，功能的加强 调用前 isProxy 可作操做（好比是否能调用的权限认证）");
        boolean boolReturn = subject.isProxy();
        System.out.println("ProxySubject isProxy end " +
                "这里可处理原方法调用后的逻辑处理");
        return boolReturn;
    }
}
复制代码

四、静态代理使用

public class ProxyMain {

    public static void main(String[] args) {
        //被代理的对象，某些状况下 咱们不但愿修改已有的代码，咱们采用代理来间接访问
        RealSubject realSubject = new RealSubject();
        //代理类对象，将原有代码不想修改的对象传入代理类对象
        ProxySubject proxySubject = new ProxySubject(realSubject);
        //调用代理类对象的方法
        proxySubject.sayGoodBye();
        System.out.println("******");
        proxySubject.sayHello("Test");
        System.out.println("******");
        proxySubject.isProxy();
    }

}
复制代码

五、最终打印

ProxySubject sayGoodBye begin  代理类，功能的加强 调用前 sayGoodBye 可作操做（好比是否能调用的权限认证）

RealSubject 我是原封不动的代码 sayGoodBye 

ProxySubject sayGoodBye end 这里可处理原方法调用后的逻辑处理

******

ProxySubject sayHello begin  代理类，功能的加强 调用前 sayHello 可作操做（好比是否能调用的权限认证）

RealSubject 我是原封不动的代码 sayHello  Test

ProxySubject sayHello end 这里可处理原方法调用后的逻辑处理

******

ProxySubject isProxy begin  代理类，功能的加强 调用前 isProxy 可作操做（好比是否能调用的权限认证）

RealSubject  我是原封不动的代码    isProxy  

ProxySubject isProxy end 这里可处理原方法调用后的逻辑处理   
复制代码

六、总结：

静态代理（传统代理模）的实现方式比较暴力直接，须要将全部被代理类的全部方法都写一遍，而且一个个的手动转发过去，麻烦并繁琐。因此咱们要学习并使用动态代理。github

动态代理核心原理

一、在java的动态代理机制中，有两个重要的类或接口

  • 一个是 InvocationHandler(Interface) 须要代码里须要实现该接口
  • 一个则是Proxy(Class)

二、InvocationHandler (Interface) 详解

public interface InvocationHandler {

    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable;
}
复制代码
  • proxy：指代生成的代理对象；
  • method：指代的是咱们所要调用真实对象的某个方法的Method对象；
  • args：指代的是调用真实对象某个方法时接受的参数；
  • 返回值 Object ：指的是须要原封不动的返回，被代理所调用的方法的返回

三、Proxy (Class) 核心原理

  • 编译时，代理对象的class并不存在，当须要调用 Proxy.newProxyInstance 方法时，会构建一个Proxy0的class字节码，而且加载到内存

四、Proxy.newProxyInstance方法详解

@CallerSensitive
    public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler h) throws IllegalArgumentException {....}
复制代码
  • loader：一个ClassLoader对象，定义了由哪一个ClassLoader对象来对生成的代理对象进行加载
  • interfaces：一个Interface对象的数组，表示的是我将要给我须要代理的对象提供一组什么接口，若是我提供了一组接口给它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了
  • 一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪个InvocationHandler对象上。

动态代理使用

第一步：定义一个接口 （待实现的逻辑）

public interface Subject {

    void sayGoodBye();

    void sayHello(String str);

    boolean isProxy();
}

复制代码

第二步：定义真实对象（被代理类，打死都不改的那种）：

public class RealSubject implements Subject {
    @Override
    public void sayGoodBye() {
        System.out.println("RealSubject 我是原封不动的代码 sayGoodBye ");
    }
    @Override
    public void sayHello(String str) {
        System.out.println("RealSubject 我是原封不动的代码 sayHello " + str);
    }

    @Override
    public boolean isProxy() {
        System.out.println("RealSubject 我是原封不动的代码 isProxy ");
        return false;
    }
}

复制代码

第三步：定义一个InvocationHandler， 至关于一个代理处理器

public class SubjectInvocationHandler implements InvocationHandler {
    //这个就是咱们要代理的真实对象
    private Object subject;

    //构造方法，给咱们要代理的真实对象赋初值
    public SubjectInvocationHandler(Object subject) {
        this.subject = subject;
    }

    @Override
    public Object invoke(Object object, Method method, Object[] args) throws Throwable {
        //在代理真实对象前咱们能够添加一些本身的操做
        System.out.println("before Method invoke 代理类，功能的加强 调用前 "+method+" 可作操做（好比是否能调用的权限认证）");
        System.out.println("Method:" + method);
        //当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用，获得对应的返回值，最后将对应返回值返回
        Object obj = method.invoke(subject, args);
        //在代理真实对象后咱们也能够添加一些本身的操做
        System.out.println("after Method invoke 这里可处理原方法调用后的逻辑处理 ");
        return obj;
    }
}
复制代码

第四步：调用

public class ProxyMain {

    public static void main(String[] args) {


        //被代理类
        Subject realSubject = new RealSubject();
        //咱们要代理哪一个类，就将该对象传进去，最后是经过该被代理对象来调用其方法的
        SubjectInvocationHandler handler = new SubjectInvocationHandler(realSubject);
        //生成代理类
        Subject subject = (Subject) Proxy.newProxyInstance(handler.getClass().getClassLoader(),
                realSubject.getClass().getInterfaces(), handler);
        //输出代理类对象
        System.out.println("Proxy : " + subject.getClass().getName());
        System.out.println("Proxy super : " + subject.getClass().getSuperclass().getName());
        System.out.println("Proxy interfaces : " + subject.getClass().getInterfaces()[0].getName());
        //调用代理类sayGoodBye方法
        subject.sayGoodBye();
        System.out.println("--------");
        //调用代理类sayHello方法
        subject.sayHello("Test");
        System.out.println("--------");
        System.out.println("---subject.isProxy()-----" + subject.isProxy());
    }

}
复制代码

最终打印：

Proxy : com.sun.proxy.$Proxy0
Proxy super : java.lang.reflect.Proxy
Proxy interfaces : staticproxy.Subject
before Method invoke  代理类，功能的加强 调用前 public abstract void staticproxy.Subject.sayGoodBye() 可作操做（好比是否能调用的权限认证）
Method:public abstract void staticproxy.Subject.sayGoodBye()
RealSubject 我是原封不动的代码 sayGoodBye 
after Method invoke  这里可处理原方法调用后的逻辑处理 
--------
before Method invoke  代理类，功能的加强 调用前 public abstract void staticproxy.Subject.sayHello(java.lang.String) 可作操做（好比是否能调用的权限认证）
Method:public abstract void staticproxy.Subject.sayHello(java.lang.String)
RealSubject 我是原封不动的代码 sayHello  Test
after Method invoke  这里可处理原方法调用后的逻辑处理 
--------
before Method invoke  代理类，功能的加强 调用前 public abstract boolean staticproxy.Subject.isProxy() 可作操做（好比是否能调用的权限认证）
Method:public abstract boolean staticproxy.Subject.isProxy()
RealSubject  我是原封不动的代码    isProxy     
after Method invoke  这里可处理原方法调用后的逻辑处理 
---subject.isProxy()-----false
---subject.isProxy()-----false
复制代码

动态代理总结

  • 动态代理可以增长程序的灵活度，好比调用方法先后的逻辑处理
  • 完美解决解耦问题，动态代理能够将调用层和实现层分离
  • 动态代理不须要接口实现类
  • 动态代理能够解决程序执行流程（下期讲解事件转到activity执行）

项目地址：点击下载

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程