android

代理模式

编程好帮手-代理模式

定义

为其他对象提供一种代理以控制对这个对象的访问

使用场景

当无法或者不想直接访问某个对象或访问某个对象存在困难时可以通过一个代理对象来间接访问，为了保证客户端使用的透明性，委托对象与代理对象需要实现相同的接口

简单实现

诉讼接口类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

package ProxyPattern;
 
public interface ILawsuit {
    //提交申请
    void submit();
    //进行举证
    void burden();
    //开始辩护
    void defend();
    //诉讼完成
    void finish();
}

具体诉讼人

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

package ProxyPattern;
 
public class XiaoMin implements ILawsuit {
    public void submit() {
        System.out.println("老板拖欠工资，特此申请仲裁");
    }
 
    public void burden() {
        System.out.println("这是合同书和过去一年的银行工资流水");
    }
 
    public void defend() {
        System.out.println("证据确凿，不需要在说什么了");
    }
 
    public void finish() {
        System.out.println("诉讼成功，判决老板即日起七天内结算工资");
    }
}

代理律师

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

package ProxyPattern;
 
public class Lawyer implements ILawsuit {
    private ILawsuit lawsuit;
 
    public Lawyer(ILawsuit lawsuit) {
        this.lawsuit = lawsuit;
    }
 
    public void submit() {
        lawsuit.submit();
    }
 
    public void burden() {
        lawsuit.burden();
    }
 
    public void defend() {
        lawsuit.defend();
    }
 
    public void finish() {
        lawsuit.finish();
    }
}

动态代理类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package ProxyPattern;
 
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
 
public class DynamicProxy implements InvocationHandler {
    private Object object;
 
    public DynamicProxy(Object object) {
        this.object = object;
    }
 
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        //调用被代理类对象的方法
        Object result=method.invoke(object,args);
        return result;
    }
}

测试类

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

package ProxyPattern;
 
import java.lang.reflect.Proxy;
 
public class Client {
    public static void main(String[] args) {
        /* 静态代理
        //构造一个小民————
        ILawsuit xiaomin=new XiaoMin();
        //构造一个代理律师并将小民作为构造参数传递进去
        ILawsuit lawyer=new Lawyer(xiaomin);
        //律师提交诉讼申请
        lawyer.submit();
        //律师进行举证
        lawyer.burden();
        //律师代替小民进行辩护
        lawyer.defend();
        //完成诉讼
        lawyer.finish();*/
 
        //----动态代理
        //构造一个小民
        ILawsuit xiaomin=new XiaoMin();
        //构造一个动态代理
        DynamicProxy proxy=new DynamicProxy(xiaomin);
        //获取被代理类小民的classloader
        ClassLoader loader=xiaomin.getClass().getClassLoader();
        //动态构造一个代理者律师
        ILawsuit lawyer= (ILawsuit) Proxy.newProxyInstance(loader,new Class[]{ILawsuit.class},proxy);
        //律师提交诉讼申请
        lawyer.submit();
        //律师进行指证
        lawyer.burden();
        //律师代替小民进行辩护
        lawyer.defend();
        //完成诉讼
        lawyer.finish();
    }
}

输出结果

show.png