设计模式--代理模式

  代理模式的核心作用是通过代理，控制对对象的访问，可以详细控制访问某个对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理。从而实现将统一流程代码放到代理类中处理。

代理模式的核心角色：

• 抽象角色：定义代理角色和真实角色的公共对外方法。
• 真实角色：实现抽象角色，定义真实角色所要实现的业务逻辑，供代理角色调用。关注真正的业务逻辑。
• 代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作。

应用场景：

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

分类：

• 静态代理（静态定义代理类）
• 动态代理（动态生成代理类）

静态代理模式实现(静态定义代理类)

/**
 * 明星接口
 */
public interface Star {
	/**
	 * 面谈
	 */
	void confer();
	/**
	 * 签合同
	 */
	void signContract();
	/**
	 * 订票
	 */
	void bookTicket();
	/**
	 * 唱歌
	 */
	void sing();
	/**
	 * 收款
	 */
	void collectMoney();
}

/**
 * 真实明星
 */
public class RealStar implements Star{

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

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

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

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

	public void sing() {
		System.out.println("RealStar(刘德华).sing(爱你一万年)");
	}

}

/**
 * 明星经济人
 */
public class ProxyStar implements Star{
	private Star star;//所代理的明星
	
	public ProxyStar() {
	}
	public ProxyStar(Star star) {
		this.star = star;
	}

	public void bookTicket() {
		System.out.println("ProxyStar.bookTicket");
	}

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

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

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

	public void sing() {
		star.sing();//调用所代理的明星进行唱歌
	}

}

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

静态代理模式的类图：

动态代理模式实现（动态生成代理类）：

优点：抽象角色(接口)中声明的所有方法都被转移到调用处理器一个集中的方法中处理，这样，我们可以更加灵活和统一的处理众多的方法。

实现方式：

              1. JDK自带的动态代理

     - java.lang.reflect.Proxy动态生成代理类和对象。

     - java.lang.reflect.InvocationHandler(处理器接口) 可以通过invoke方法实现对真实角色的代理访问；每次通过Proxy生成代理类对象时都要指定对应的处理器对象。

      2. javaassist字节码操作库实现

              3. CGLIB

             4. ASM(底层使用指令，可维护性较差)

/**
 * 明星接口
 */
public interface Star {
	/**
	 * 面谈
	 */
	void confer();
	/**
	 * 签合同
	 */
	void signContract();
	/**
	 * 订票
	 */
	void bookTicket();
	/**
	 * 唱歌
	 */
	void sing();
	/**
	 * 收款
	 */
	void collectMoney();
}
/**
 * 真实明星
 */
public class RealStar implements Star{

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

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

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

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

	public void sing() {
		System.out.println("RealStar(刘德华).sing(爱你一万年)");
	}

}

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class StarHandler implements InvocationHandler{

	Star realStar;
	public StarHandler(Star star){
		this.realStar = star;
	}
	public Object invoke(Object proxy, Method method, Object[] args)
			throws Throwable {
		Object obj = null;
		System.out.println("面谈");
		System.out.println("签合同");
		System.out.println("订机票");
		if (method.getName().equals("sing")){
			obj = method.invoke(realStar, args);
		}
		System.out.println("收款");
		return obj;
	}

}

import java.lang.reflect.Proxy;
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.sing();
	}
}