代理模式
定义：为其他对象提供一种代理以控制对这个对象的访问
角色：
Subject抽象主题角色：抽象主题类可以是抽象类也可以是接口，是一个最普通的业务类型定义，无特殊要求。
RealSubject具体主题角色：也叫做被委托角色、被代理角色。它才是冤大头，是业务逻辑的具体执行者。
Proxy代理主题角色：也叫做委托类、代理类。它负责对真实角色的应用，把所有抽象主题类定义的方法限制委托给真实主题角色实现，并且在真实主题角色处理完毕前后做预处理和善后处理工作。
//抽象主题类
public interface Subject {
//定义一个方法
public void request();
}
public class RealSubject implements Subject {
//实现方法
public void request() {
//业务逻辑处理
}
}
public class Proxy implements Subject {
//要代理哪个实现类
private Subject subject = null;
//默认被代理者
public Proxy(){
this.subject = new Proxy();
}
//代理的构造函数
public Proxy(Subject _subject){
this.subject = _subject;
}
//实现接口中定义的方法
public void request() {
this.before();
this.subject.request();
this.after();
}
//预处理
private void before(){
//do something
}
//善后处理
private void after(){
//do something
}
}
关于代理模式和装饰模式：
装饰模式就是代理模式的一个特殊应用，两者的共同点是都具有相同的接口，不同点则是代理模式着重对代理过程的控制，而装饰模式则是对类的功能进行加强或减弱，它着重类的功能变化。
例：
代理模式：一个著名的短跑运动员有自己的代理人。如果你很仰慕他，你找运动员说“你跑个我看看”，运动员肯定不搭理你，不过你找到他的代理人就不一样了，你可能和代理人比较熟，可以称兄道弟，这个忙代理人还是可以帮的，于是代理人同意让你欣赏运动员的练习赛
public interface IRunner {
//运动员的主要工作就是跑步
public void run();
}
public class Runner implements IRunner {
public void run() {
System.out.println("运动员跑步：动作很潇洒");
}
}
//代理人
public class RunnerAgent implements IRunner {
private IRunner runner;
public RunnerAgent(IRunner _runner){
this.runner = _runner;
}
//代理人是不会跑的
public void run() {
Random rand = new Random();
if(rand.nextBoolean()){
System.out.println("代理人同意安排运动员跑步");
runner.run();
}else{
System.out.println("代理人心情不好，不安排运动员跑步");
}
}
}
public class Client {
public static void main(String[] args) {
//定义一个短跑运动员
IRunner liu = new Runner();
//定义liu的代理人
IRunner agent = new RunnerAgent(liu);
//要求运动员跑步
System.out.println("====客人找到运动员的代理要求其去跑步===");
agent.run();
}
}
装饰模式：装饰模式是对类功能的加强，怎么加强呢？增强跑步速度！在屁股后面安装一个喷气动力装置
public class RunnerWithJet implements IRunner {
private IRunner runner;
public RunnerWithJet(IRunner _runner){
this.runner = _runner;
}
public void run() {
System.out.println("加快运动员的速度：为运动员增加喷气装置");
runner.run();
}
}
代理模式是把当前的行为或功能委托给其他对象执行，代理类负责接口限定：是否可以调用真实角色，以及是否对发送到真实角色的消息进行变形处理，它不对被主题角色（也就是被代理类）的功能做任何处理
装饰模式是在要保证接口不变的情况下加强类的功能，它保证的是被修饰的对象功能比原始对象丰富（当然，也可以减弱），但不做准入条件判断和准入参数过滤，如是否可以执行类的功能，过滤输入参数是否合规等，这不是装饰模式关心的。
动态代理：
public interface Buy {
void buyHouse(long money);
}
public class User implements Buy {
@Override
public void buyHouse(long money) {
System.out.println("买房了，用了"+money+" 钱 ");
}
}
public class DynamiclProxy implements InvocationHandler {
//真正要买房的对象
private Buy mObject;
public DynamiclProxy(Buy mObject) {
this.mObject = mObject;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
if (method.getName().equals("buyHouse")){
//如果方法是买房的话，那么先坑点钱
long money= (long) args[0];//取出第一个参数，因为我们是知道参数的
long newMoney= (long) (money*0.99);
System.out.println("坑了我们:"+(money-newMoney)+"钱");
args[0]=newMoney;//坑完再赋值给原来的参数
/**
* 调用真实对象去操作
*/
return method.invoke(mObject,args);
}
//如果有其他方法，也可以跟上面这样判断
return null;
}
}
public class ProxyClient {
public static void main(String[] args){
Buy buy=new User();
UserProxy proxy=new UserProxy(buy);
proxy.buyHouse(1000000);
System.out.println("动态代理测试");
Buy dynamicProxy= (Buy) Proxy.newProxyInstance(buy.getClass().getClassLoader(),
buy.getClass().getInterfaces(),new DynamiclProxy(buy));
dynamicProxy.buyHouse(1000000);
}
}
//相当于
public class UserProxy implements Buy {
private Buy mBuy;
public UserProxy(Buy mBuy) {
this.mBuy = mBuy;
}
@Override
public void buyHouse(long money) {
long newMoney= (long) (money*0.99);
System.out.println("这里坑点血汗钱，坑了我们:"+(money-newMoney)+"钱");
mBuy.buyHouse(newMoney);
}
}
动态代理，顾名思义是动态的，Java中的动态一般指的是在运行时的状态，是相对编译时的静态来区分，就是在运行时生成一个代理对象帮我们干活；
