什么是代理模式

发表于 | 分类于 | 评论数： | 热度： ℃
本文字数： 14k | 阅读时长 ≈ 13 分钟

定义

  代理模式，即控制对象的直接访问权限。通过使用代理模式可以详细控制某个（某类）对象的方法，在调用这个方法之前做前置处理，调用这个方法之后做后置处理（这也就是Spring的AOP的微观实现）。

核心角色

  • 抽象角色：定义代理角色和真实角色的公共对外方法。
  • 真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。主要是关注真正的业务逻辑！
  • 代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以添加自己的操作，即将统一的流程控制放到代理角色中处理。

应用场景

  • 安全代理：屏蔽对真实角色的直接访问
  • 远程代理：通过代理类处理远程方法调用（RMI）
  • 延迟加载：先加载轻量级的代理对象，真正需要再加载真实对象

分类

  • 静态代理

  • 动态代理：
    ​ （1）JDK自带的字节码操作库实现

    （2）javaassist字节码操作库的实现

    （3）CGLIB第三方代理库

    （4）ASM（底层使用指令，可维护性较差）

静态代理模式

  举一个简单的例子，比如明星和经纪人的关系，明星的面谈、签合同、唱歌、订票以及收钱等行为（方法），其中面谈、签合同、订票以及收钱等方法都可以由经纪人代理，但是唱歌需要由明星本人执行，这种显式代理的方式就是静态代理模式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//抽象明星角色
public interface Star {
	/**
	 * 面谈
	 */
	void confer();
	/**
	 * 签合同
	 */
	void signContract();
	/**
	 * 订票
	 */
	void bookTicket();
	/**
	 * 唱歌
	 */
	void sing();
	/**
	 * 收钱
	 */
	void collectMoney();
}
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
//真实明星
public class RealStar implements Star{

	@Override
	public void confer() {
		System.out.println("realStar面谈");
	}

	@Override
	public void signContract() {
		System.out.println("realStar签合同");
	}

	@Override
	public void bookTicket() {
		System.out.println("realStar订票");
	}

	@Override
	public void sing() {
		System.out.println("周杰伦本人唱歌");
	}

	@Override
	public void collectMoney() {
		System.out.println("realStar收钱");
	}
}
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
//明星经纪人
public class ProxyStar implements Star{
	
	private Star star;
	
	public ProxyStar(Star star){
		this.star = star;
	}
	
	@Override
	public void confer() {
		System.out.println("代理人面谈");
	}

	@Override
	public void signContract() {
		System.out.println("代理人签合同");
	}

	@Override
	public void bookTicket() {
		System.out.println("代理人订票");
	}

	@Override
	public void sing() {
		//唱歌需要真实的明星来唱，其它都可以代理
		star.sing();
	}

	@Override
	public void collectMoney() {
		System.out.println("代理人收钱");
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
//客户端测试类
public class Client {
	public static void main(String[] args) {
		Star real = new RealStar();
		Star proxy = new ProxyStar(real);
		
		proxy.confer();
		proxy.signContract();
		proxy.bookTicket();
		proxy.sing();   //周杰伦本人唱歌
		proxy.collectMoney();
	}
}

动态代理模式

  • JDK自带的动态代理

    • java.lang.reflect.Proxy：动态生成代理类和对象
    • java.lang.reflect.InvocationHandler：处理器接口，可以通过invoke方法实现对真实角色的访问，每次通过proxy生成代理类对象时都要指定对应的处理器对象。
1
2
3
4
Star realStar = new RealStar();
StarHandler handler = new StarHandler(realStar);
Star proxy = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader,new Class[]{Star.class},handler);
proxy.sing();
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
public class StarHandler implements InvocationHandler {

    Star realStar;

    public StarHandler(Star realStar) {
        super();
        this.realStar = realStar;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {

        Object o = null;

        System.out.println("真正的方法执行前");

        if(method.getName().equals("sing")){
        	//真正方法的调用
            o = method.invoke(realStar,args);
        }

        System.out.println("真正的方法调用后");

        return o;
    }
}

测试类：

1
2
3
4
5
6
7
8
9
10
public class Client {
	
	public static void main(String[] args) {
		Star realStar = new RealStar();
		StarHandler handler = new StarHandler(realStar);
		Star proxy  = (Star) Proxy.newProxyInstance(ClassLoader.getSystemClassLoader(), new Class[]{Star.class}, handler);
		proxy.bookTicket();
		proxy.sing();   //周杰伦本人唱歌
	}
}

----\(˙<>˙)/----赞赏一下吧～