代理模式

核心作用

-通过代理，控制对对象的访问
可以详细控制访问某个（某类）对象的方法，在调用这个方法前做前置处理，调用这个方法后做后置处理。（即：AOP的微观实现！）

AOP(面向切面编程)

-它是可以通过预编译方式和运行期动态带来实现在不修改源代码的情况下给程序动态统一添加功能的一种技术。它是一种新的方法论，它是对传统OOP编程的一种补充。
-常用术语：
-切面( Aspect) :其实就是共有功能的实现。
-通知( Advice ) :是切面的具体实现。
-连接点( Joinpoint) :就是程序在运行过程中能够插入切面的地点。
-切入点( Pointcut) :用于定义通知应该切入到哪些连接点上。
-目标对象( Target) :就是那些即将切入切面的对象，也就是那些被通知的对象
-代理对象( Proxy) :将通知应用到目标对象之后被动态创建的对象。
-织入( Weaving ) : 将切面应用到目标对象从而创建一个新的代理对象的过程。

代理模式核心角色

-抽象角色：定义代理角色和真是觉得的公共对外方法
-真实角色：实现抽象角色，定义真是角色索要实现的业务逻辑，供代理角色调用(关注真正的业务逻辑)
-代理角色：实现抽象角色，是真实角色的代理，通过真是角色的业务逻辑方法来实现抽象方法，并可以附加自己的操作(将统一的流程控制放到代理角色中处理)

应用场景

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

分类

静态代理(静态定义代理类)

抽象角色：

public interface Star {
	
	void confer();//面谈
	void signConstract();//签合同
	void bookTicket();//订票
	void sing();//唱歌
	void collectMoney();//收尾款
	
}

真实角色：

public class RealStar implements Star{

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

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

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

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

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

代理角色：

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

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

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

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

客户类：

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

动态代理(动态生成代理类)

动态代理实现方式：
 JDK自带的动态代理
 javaassist字节那操作库实现
 CGLIB
 ASM(底层使用指令，可维护性较差)

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

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

抽象角色：

public interface Star {
	
	void confer();//面谈
	void signConstract();//签合同
	void bookTicket();//订票
	void sing();//唱歌
	void collectMoney();//收尾款
	
}

真实角色：

public class RealStar implements Star{

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

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

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

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

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

handler：

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

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

}

客户类：

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