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

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

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

为什么会有代理出现？

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

侵入性含义：

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

静态代理与动态代理

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

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

静态代理使用

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

public interface Subject {
    
    

    void sayGoodBye();

    void sayHello(String str);

    boolean isProxy();
}

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

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;
    }
}

3、定义静态代理类（功能增加类），这个代理类也必须要实现和被代理类相同的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;
    }
}

4、静态代理使用

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();
    }

}

5、最终打印

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 这里可处理原方法调用后的逻辑处理   

6、总结：

静态代理（传统代理模）的实现方式比较暴力直接，需要将所有被代理类的所有方法都写一遍，并且一个个的手动转发过去，麻烦并繁琐。所以我们要学习并使用动态代理。

动态代理核心原理

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

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

2、InvocationHandler (Interface) 详解

public interface InvocationHandler {
    
    

    public Object invoke(Object proxy, Method method, Object[] args)
        throws Throwable;
}

• proxy：指代生成的代理对象；
• method：指代的是我们所要调用真实对象的某个方法的Method对象；
• args：指代的是调用真实对象某个方法时接受的参数；
• 返回值 Object ：指的是需要原封不动的返回，被代理所调用的方法的返回

3、Proxy (Class) 核心原理

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

4、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执行）

项目地址：点击下载