代理简述：
代理是一个动词，动词之间会有产生关系两者。代理这个词产生关系的两者就是：realSubject(被代理者)，proxySubject（代理者）。举个例子：火车站，与火车站代售点。
火车站可以进行售票工作，而火车站代售点可以实现代售车票。但是代售点还有其他的功能，比如说支持预约。这个是火车站所不具有的功能。
简单理解代理模式就是：代理者代替被代理者去完成一些功能，在完成一些功能之前可以做一些预处理，完成之后可以做一些后置处理。
再看一个程序中的例子：AOP就是建立在代理的思想之上的，AOP面向切面编程，何为切面，就是你程序中的主要逻辑，在这些主要逻辑产生的地方设置切点，在切点的地方设置一个注入一些非主要功能，这个就是面向切面编程。面向切面编程是以动态代理为底层实现的
java代理模式应用
<1.静态代理--继承实现：
java中静态代理的实现方式有两种：一种基于继承思想，一种基于聚合。
首先描述基于继承思想的静态代理：（每段代码下方会有讲解，代码内会有注释）
代码如下：
1.定义一个接口：Moveable
package com.feixun.designerpattern.proxy.static_proxy;
public interface Moveable {
void move(); //定义抽象方法 move()，表示移动功能
}
2.定义一个被代理类Car类实现这个Moveable接口
package com.feixun.designerpattern.proxy.static_proxy;
import java.util.Random;
public class Car implements Moveable{
//实现move方法
@Override
public void move() {
try {
Thread.sleep(new Random().nextInt(1000));
System.out.println("汽车行驶中");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
3.在定义一个代理类Car2继承自Car
package com.feixun.designerpattern.proxy.static_proxy;
/**
* @author tao.liu
* 通过继承实现静态代理 丰富RealSubject的功能，Car2相当于ProxySubject
*
*/
public class Car2 extends Car{
@Override
public void move() {
long starttime = System.currentTimeMillis();
System.out.println("汽车开始行驶");
super.move();
long endtime = System.currentTimeMillis();
System.out.println("汽车行驶结束，行驶了"+(endtime-starttime)+" 毫秒");
}
}
解释：此程序在调用真实被代理类之前，对move花费的时间进行记录。
4.客户端调用
package com.feixun.designerpattern.proxy.static_proxy;
public class Client {
public static void main(String[] args) {
/*采用car2继承car 的方式实现代理
*随着功能的增加会出现更多的继承才能满足需求
*/
Moveable moveable = new Car2();
moveable.move();
}
}
程序输出结果：
汽车开始行驶
汽车行驶中
汽车行驶结束，行驶了287 毫秒
此种静态代理采用的是代理类（proxySubject）继承被代理类（realSubject）而实现的。
分析弊端：
1.假设现在我需要在汽车运行前后加上日志记录的功能，在这种方式（继承）下，我需要新建一个（Car3继承Car）的代理类完成这件事情。
2.再假设我现在还需要在运行前加上启动汽车的功能，我们需要再建立一个（Car4继承Car）的代理类来完成这个事情。
3.再假设，我需要在汽车运行之前先启动汽车，再进行日志记录，我们需要再建立一个Car5来继承Car3.
综上所述，随着功能的叠加，类的数量也会呈爆炸式增长。
解决这个问题就需要用聚合来实现类的代理
<2.静态代理--聚合实现：
代码如下：
建立move功能定义接口
package com.feixun.designerpattern.proxy.static_proxy;
public interface Moveable {
void move();
}
建立实现move功能的Car类
package com.feixun.designerpattern.proxy.static_proxy;
import java.util.Random;
public class Car implements Moveable{
@Override
public void move() {
try {
Thread.sleep(new Random().nextInt(1000));
System.out.println("汽车行驶中");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
建立日志代理类CarLogProxy
package com.feixun.designerpattern.proxy.static_proxy;
public class CarLogProxy implements Moveable {
private Moveable moveable;//将movable 类型的对象聚合进来，其实movable是一个接口，这里用到了多态的概念。
public CarLogProxy(Moveable moveable) {
super();
this.moveable = moveable;
}
@Override
public void move() {
System.out.println("日志开始...");
moveable.move();
System.out.println("日志结束...");
}
}
接着建立行驶时间CarTimeProxy代理类
package com.feixun.designerpattern.proxy.static_proxy;
//CarTimeProxy 为 属于Moveable 的类型对象的代理类
//基于聚合的方式
public class CarTimeProxy implements Moveable{
private Moveable moveable;//同上所示
public CarTimeProxy(Moveable moveable) {
super();
this.moveable = moveable;
}
@Override
public void move() {
long starttime = System.currentTimeMillis();
System.out.println("汽车开始行驶");
moveable.move();
long endtime = System.currentTimeMillis();
System.out.println("汽车行驶结束，行驶了"+(endtime-starttime)+" 毫秒");
}
}
测试类
package com.feixun.designerpattern.proxy.static_proxy;
public class Client {
public static void main(String[] args) {
Car car1 = new Car();
CarLogProxy carLogProxy = new CarLogProxy(car1);
CarTimeProxy carTimeProxy = new CarTimeProxy(carLogProxy);
carTimeProxy.move();
}
//引入问题:如果现在更多的realsubject 需要事件代理，那么现在需要新建多个代理类吗？类膨胀。
//动态产生代理，实现对不同类，不同方法的代理。
}
运行结果：
汽车开始行驶
日志开始...
汽车行驶中
日志结束...
汽车行驶结束，行驶了529 毫秒
现在我们这样测试：（请注意如下程序与上方程序的不同点：）
package com.feixun.designerpattern.proxy.static_proxy;
public class Client {
public static void main(String[] args) {
//采用聚合的方式实现的代理，代理之间也可以互相调用
Car car1 = new Car();
CarTimeProxy carTimeProxy = new CarTimeProxy(car1);
CarLogProxy carLogProxy = new CarLogProxy(carTimeProxy);
carLogProxy.move();
}
//引入问题，如果现在更多的不同类型的realsubject：比如或火车的，汽车的类 需要被代理，那么现在需要新建多个代理类吗？类膨胀。
//动态产生代理，实现对不同类，不同方法的代理。
}
运行结果：
日志开始...
汽车开始行驶
汽车行驶中
汽车行驶结束，行驶了649 毫秒
日志结束...
优点：这样的话就可以实现多个代理对象之间的相互调用相互聚合。从而比用继承方式实现的静态代理更优。减少了一个维度。
引入问题，如果现在更多的不同类型的realsubject：比如或火车的，汽车的类 需要被代理，那么现在需要新建多个代理类吗？类膨胀问题产生。
动态产生代理，实现对不同类，不同方法的代理。
动态代理
直接上代码：
首先建立定义接口的Moveable:
package com.feixun.designerpattern.proxy.dynamic_proxy;
public interface Moveable {
void move();
}
接着定义realsubject（被代理类）：泛指所有类型的被代理类。可以是Car,Subway，etc.
package com.feixun.designerpattern.proxy.dynamic_proxy;
import java.util.Random;
public class Car implements Moveable {
@Override
public void move() {
try {
Thread.sleep(new Random().nextInt(1000));
System.out.println("汽车行驶中");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
接着建立实现（implements）InvocationHandler接口的类：
InvocationHandler,中定义了Object invoke(Object proxy, Method method, Object[] args) 方法。参数解释如下图代码中注释
package com.feixun.designerpattern.proxy.dynamic_proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
public class MyHandler implements InvocationHandler {
private Object target;//被代理对象
public MyHandler(Object target) {
this.target = target;
}
/* (non-Javadoc)
* @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
* proxy--指被代理的对象（感觉java这个参数的名字并不是很好）
* method--被代理对象的方法
* args:被代理对象的方法参数
*/
@Override
public Object invoke(Object proxy, Method method, Object[] args)
throws Throwable {
System.out.println("汽车开始运行了...");
method.invoke(target, args);//运行被代理对象的方法，采用反射的机制。
System.out.println("汽车运行结束...");
return null;
}
}
这一步只是完成了被代理对象方法的扩充，还没有产生真实的代理对象。
再看测试类：
package com.feixun.designerpattern.proxy.dynamic_proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class TestDynamicProxy {
public static void main(String[] args) {
Car car = new Car();
InvocationHandler handler = new MyHandler(car);
Class<?> cs = car.getClass();
/*
* @param ： classloader 被代理对象的类加载器
* @param : interfaces 被代理对象实现的接口
* @param ： Invocationhandler handler /子类
*/
Moveable moveable=(Moveable)Proxy.newProxyInstance(cs.getClassLoader(),
cs.getInterfaces(), handler);//这一步动态生成代理对象 moveable
moveable.move();
}
}
运行结果：
汽车开始运行了...
汽车行驶中
汽车运行结束...
可以看出：动态代理解决了对不同委托类产生代理对象的问题，假设现在我有Subway类，我要实现被代理，我只需要Subway实现Moveable，然后在测试类中更改几行代码就好，所以解决了聚合静态代理产生的问题,又将问题复杂度减少了一个维度。
但是jdk动态代理也有问题：委托类想要实现自己的代理类，必须实现接口，如果有类没有实现接口，就不能使用JDK代理。
完
博客搬家：大坤的个人博客
欢迎评论哦~
