Android设计模式——代理模式

• • 静态代理：

    • Subject: 抽象主题类（顶层接口）
    • 委托者（真实主题类）
    • 静态代理者：
    • 静态代理实现方式

  • 动态代理

    • 动态代理类
    • 动态代理实现方式

静态代理：

Subject: 抽象主题类（顶层接口）

/**
 * ①Subject: 抽象主题类，声明真是主体与代理主题的共同接口方法。
 * 这里建立一个起诉类的接口，用来让律师类和起诉者类共同实现
 */
public interface ILawsuit {
    void submit();//提交申请
    void burden();//进行举证
    void defend();//开始辩护
    void finish();//诉讼完成
}

委托者（真实主题类）

/**
 * ②起诉者类实现顶层接口，重写里边的方法
 * RealSubject: 真实主题类，定义了代理所表示的真实对象，
 * 执行具体的业务方法。客户端将会通过代理类（律师）来间接的调动这个真实主题中的方法。
 */
public class Civilian implements ILawsuit {
    private static final String TAG = "civlian";
    @Override
    public void submit() {
        Log.d(TAG, "submit: 起诉者");
    }

    @Override
    public void burden() {
        Log.d(TAG, "burden: 起诉者");
    }

    @Override
    public void defend() {
        Log.d(TAG, "defend: 起诉者");
    }

    @Override
    public void finish() {
        Log.d(TAG, "finish: 起诉者");
    }
}

静态代理者：

/**
 * @author ytf
 * ③代理类（律师）同样实现顶层接口，并且持有真实类对象的引用
 * 在接口方法中调用真实主题相应的方法，达到代理的作用。
 * 代理者的代码时先生成写好，然后再对其进行编译，在代码运行前，代理类的class编译文件就已经存在了。
 */
public class Lawyer implements ILawsuit {
    private Civilian civilian;

    public Lawyer(Civilian civilian) {
        this.civilian = civilian;
    }

    @Override
    public void submit() {
        civilian.submit();
    }

    @Override
    public void burden() {
        civilian.burden();

    }

    @Override
    public void defend() {
        civilian.defend();
    }

    @Override
    public void finish() {
        civilian.finish();
    }
}

静态代理实现方式

  /**
     * 静态代理
     */
    private void initProxy() {
        ILawsuit civilian=new Civilian();
        ILawsuit laywer=new Lawyer((Civilian) civilian);
        laywer.submit();
        laywer.burden();
        laywer.defend();
        laywer.finish();
    }

动态代理

动态代理类

/**
 * 动态代理类
 * Java提供了一个便捷的动态代理接口InvocationHandler，动态代理类只要实现这个接口就行
 * 通过反射动态的生成代理者对象，也就是说在写代码的时候根本不知道要代理谁，具体代理谁会在执行阶段决定。
 * @Object object 这里使用Object对象，而不确定要代理的具体的对象类型
 * a. 实现InvocationHandler接口创建自己的调用处理器
 */
public class DynamicProxy implements InvocationHandler {
    //代理类持有一个委托类的对象引用
    private Object object;
    public DynamicProxy(Object object) {
        this.object = object;
    }

    /**
     * 该方法负责集中处理动态代理类上的所有方法调用。
     * 调用处理器根据这三个参数进行预处理或分派到委托类实例上反射执行
     * @param proxy 代理类实例
     * @param method 被调用的方法对象
     * @param args 调用参数。
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long stime = System.currentTimeMillis();
        //这里可以对方法名进行判断过滤 if(method.getName().equals("***"))
        //利用反射机制将请求分派给委托类处理。Method的invoke返回Object对象作为方法执行结果。
        //因为示例程序没有返回值，所以这里忽略了返回值处理
        Object rusult=method.invoke(object,args);
        long ftime = System.currentTimeMillis();
        System.out.println("执行任务耗时"+(ftime - stime)+"毫秒");
        return rusult;
    }
}

动态代理实现方式

 /**
     * 动态代理
     */
    private void initDynamicProxy() {
        ILawsuit iLawsuit=new Civilian();
        DynamicProxy dynamicProxy=new DynamicProxy(iLawsuit);
        ClassLoader classLoader=iLawsuit.getClass().getClassLoader();
        //动态创建代理类，需要传入一个类加载器ClassLoader；一个你希望这个代理实现的接口列表(便于调用接口中的方法)，这里要代理ILawsuit接口；
        //和一个InvocationHandler的实现，也就是前面创建的dynamicProxy。利用反射得到动态代理的构造方法
        //b. 给Proxy类提供ClassLoader和代理接口类型数组创建动态代理类
        ILawsuit laywer= (ILawsuit) Proxy.newProxyInstance(classLoader,new Class[]{ILawsuit.class},dynamicProxy);
        laywer.submit();
        laywer.defend();
        laywer.burden();
        laywer.finish();

    }