Java设计模式-代理模式详解

代理模式

一、静态代理

三类角色

1. 抽象角色：定义代理角色和公共角色的公共对外方法
2. 真实角色：实现抽象角色，定义真是角色所要实现的业务逻辑供代理角色调用，关注真正地业务逻辑
3. 代理角色：实现抽象角色，是真实角色的代理，通过真是角色的业务逻辑方法来实现抽象方法，并附加自己的操作。将统一的流程放到代理中处理

代码

1. 抽象角色

public interface Star {
	void confer();
	void signContract();
	void bookTicket();
	void sing();
	void collectMoney();
}

2. 真实角色（歌手）

public class RealStar implements Star{

	@Override
	public void confer() {
		System.out.println("RealStar.confer()");
		
	}

	@Override
	public void signContract() {
		System.out.println("RealStar.signContract()");
		
	}

	@Override
	public void bookTicket() {
		System.out.println("RealStar.bookTicket()");
		
	}

    /*
    * 可以继承所有的抽象方法，但主要是唱歌
    */
	@Override
	public void sing() {
		System.out.println("RealStar(Jay).sing()");
		
	}

	@Override
	public void collectMoney() {
		System.out.println("RealStar.collectMoney()");
		
	}

}

3. 代理角色（经纪人）：除了唱歌什么都干

public class ProxyStar implements Star{

	private Star star;
	
	
	
	public ProxyStar(Star star) {
		super();
		this.star = star;
	}

	@Override
	public void confer() {
		System.out.println("ProxyStar.confer()");
		
	}

	@Override
	public void signContract() {
		System.out.println("ProxyStar.signContract()");
		
	}

	@Override
	public void bookTicket() {
		System.out.println("ProxyStar.bookTicket()");
		
	}
	//唱歌交给，构造函数传进来的歌手对象去唱歌
	@Override
	public void sing() {
		star.sing();
		
	}

	@Override
	public void collectMoney() {
		System.out.println("ProxyStar.collectMoney()");
		
	}

}

4. 客户

public class Client {
	public static void main(String[] args) {
		Star star = new RealStar();
		Star proxy = new ProxyStar(star);
		proxy.confer();
		proxy.bookTicket();
		proxy.sing();
	}
}

结果：

ProxyStar.confer()
ProxyStar.bookTicket()
RealStar(Jay).sing()

优缺点

好处：

• 可以使真是角色的操作更加纯粹！不用去关注一些公共的业务
• 公共业务交给代理角色！实现业务分工
• 公共业务扩展时，方便集中管理

缺点：

• 一个真实角色就会产生一个代理角色；代码量会翻倍~开发效率低

二、动态代理

• 动态代理和静态代理角色一样

• 动态代理的代理类是动态生成的，不是直接写好的

• 动态代理分为两大类：基于接口的动态代理；基于类的动态代理

  • 基于接口–JDK动态代理
  • 基于类的–cglib；javassist

JDK动态代理

动态代理中变化的就是代理和客户端
动态代理的一大特点就是编译阶段没有代理类，在运行时才生成代理类。
代理类：

public class DynamicProxy implements InvocationHandler {

//　这个就是我们要代理的真实对象，即房东
private Object target;

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

//proxy:　　指代我们所代理的那个真实对象
//method:　　指代的是我们所要调用真实对象的某个方法的Method对象
//args:　　指代的是调用真实对象某个方法时接受的参数
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    //　　在代理真实对象前我们可以添加一些自己的操作
    System.out.println("before "+method.getName());

    System.out.println("Method:" + method.getName());

    //        如果方法是 sing则调用真实角色运行方法
    if (method.getName().equals("sing")) {

        Object result = method.invoke(target, args);

    } 

    //　　在代理真实对象后我们也可以添加一些自己的操作
    System.out.println("after "+method.getName());

    return result;
}

Client：

public class Client {
public static void main(String[] args)
{
    //    我们要代理的真实对象--歌手
    Star star= new RealStar();

    //    我们要代理哪个真实对象，就将该对象传进去，最后是通过该真实对象来调用其方法的
    InvocationHandler handler = new DynamicProxy(star);

    /*
     * 通过Proxy的newProxyInstance方法来创建我们的代理对象，我们来看看其三个参数
     * 第一个参数 handler.getClass().getClassLoader() ，我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象
     * 第二个参数realSubject.getClass().getInterfaces()，我们这里为代理对象提供的接口是真实对象所实行的接口，表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了
     * 第三个参数handler， 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上
     */
    Star proxy = (Star) Proxy.newProxyInstance(handler.getClass().getClassLoader(), star
            .getClass().getInterfaces(), handler);//一个动态代理类，中介

    proxy.sing();
}
}