代理模式

核心作用：通过代理，控制对对象的访问，可以详细控制访问某个（某类）对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理

核心角色:

        抽象角色：定义代理角色和真实角色的公共对外方法，实现相同的接口

        真实角色：实现抽象角色，定义真实角色所需要的业务逻辑，供代理角色调用

        代理角色：实现抽象角色，是真实角色的代理，通过真实角色的业务逻辑来实现抽象方法，并加以附加自己的操作   将统一的流程控制放到代理角色中处理（持有真实角色的引用）

分类：静态代理（程序员定义代理类）

Java代码：

package StaticProxy;

public interface Star {
	/**
	 * 面谈
	 */
	void confer();

	/**
	 * 签合同
	 */
	void signContract();

	/**
	 * 订票
	 */
	void bookTicket();

	/**
	 * 唱歌
	 */
	void sing();

	/**
	 * 收钱
	 */
	void CollectMoney();
}

package StaticProxy;

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 CollectMoney() {
		System.out.println("RealStar.CollectMoney()");

	}

	@Override
	public void sing() {
		System.out.println("RealStar(周杰伦本人).signContract()");

	}

}

package StaticProxy;

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 CollectMoney() {
		System.out.println("ProxyStar.CollectMoney()");

	}

	@Override
	public void sing() {
		star.sing();

	}

}

package StaticProxy;

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.InvocationHandle(处理器接口)

                                                                        可以通过invoke方法实现对真实角色的代理访问

                                                                         每次通过Proxy生成代理类对象式都要指定对应的处理器对象

Java代码：

package DynamicProxy;

public interface Star {
	/**
	 * 面谈
	 */
	void confer();

	/**
	 * 签合同
	 */
	void signContract();

	/**
	 * 订票
	 */
	void bookTicket();

	/**
	 * 唱歌
	 */
	void sing();

	/**
	 * 收钱
	 */
	void CollectMoney();
}

package DynamicProxy;

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 CollectMoney() {
		System.out.println("RealStar.CollectMoney()");

	}

	@Override
	public void sing() {
		System.out.println("RealStar(周杰伦本人).signContract()");

	}

}

package DynamicProxy;

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

public class StarHandler implements InvocationHandler {

	Star RealStar;

	public StarHandler(Star realStar) {
		super();
		RealStar = realStar;
	}

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

		System.out.println("真正的方法执行前！");
		System.out.println("面谈，订合同，预付款，订机票");

		if (method.getName().equals("sing")) {
			object = method.invoke(RealStar, args);
		}

		System.out.println("真正的方法启动后！");
		System.out.println("收尾款");
		return object;
	}

}

package DynamicProxy;

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

}