Java设计模式之代理模式（Proxy）

设计模式（Design Pattern）：

   是一套被反复使用、经过分类编目、代码设计经验的总结。

目的：

   为了可重用代码、让代码更容易被他人理解、保证代码的可靠性。

代理模式的定义：

   为其他对象提供一种代理，以控制对这个对象的访问。代理对象起到了一个中介的作用，可以去掉功能服务、增加额外服务。
比如：移动电信服务站、火车票代售处等等

常见的代理模式有：远程代理、虚拟代理、保护代理、智能代理

远程代理：（代理模式经典的一个运用。类似客户端与服务器，是远程通讯的一个缩影。）为一个不同地址空间的对象提供局域网代表对象。
例：总店通过网络远程监控各个分店销售情况。

虚拟代理：根据需要将一个资源消耗很大或比较复杂的对象进行延迟创建，在真正需要的时候进行创建。
例：浏览帖子时会有文字和图片，如果图片非常大会一直加载，影响文字的阅读，所以可以采用虚拟代理用一张虚拟的图片代替真实的图片进行显示，当真实图片加载完成之后再进行显示。

保护代理：控制对一个对象的访问权限。
例：在浏览一个网站时，注册与没有注册显示的界面、相关操作权限有所差别。

智能引用代理：提供对目标对象额外的服务。

※智能引用代理：

适用场景：日志处理、权限管理、事务处理等。

• 静态代理：代理和被代理对象在代理之前是确定的。他们都实现相同的接口或继承相同的抽象类。
  （代理类对被代理类进行功能的叠加，静态代理局限于对象都是确定的。比如汽车是一个被代理类，汽车1是汽车的一个代理类增加了对汽车记录行驶路径的动作，汽车2也是汽车的一个代理类增加了对汽车记录行驶时间的动作，它们都实现了Moveable接口或抽象类。扩展为记录火车、飞机行驶轨迹、时间等得重新这样去实现，过于繁琐。）
• 动态代理：
  • JDK动态代理
    
        Java动态代理类位于java.lang.reflect包下，一般主要涉及到以下两个类：
        1. Interface InvocationHandler：该接口中仅定义了一个方法
        public object invoke(Object obj,Method methdo,Object[] args)在实际使用时，第一个参数obj一般是指代理类，method是被代理的方法，args为该方法的参数数组。这个抽象方法在代理类中动态实现。
        2.Proxy：该类为动态代理类
        static Object newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h)：返回代理类的一个实例，返回后的代理类可以当作被代理类使用（可使用被代理类的在接口中声明过的方法）。
        测试代码：
        第一步：创建一个实现接口InvocationHandler的类，它必须实现invoke方法。
        第二步：创建被代理的类以及接口
        第三步：调用Proxy的静态方法，动态的创建一个代理类newProxyInstance(ClassLoader loader, Class[] interfaces,InvocationHandler h);
        第四步：通过代理调用方法。

		//目标类（被代理类）实现的接口
		public interface Moveable {
			void move();
		}
		
		//目标类
		public class Car implements Moveable {
		    public void move() {
		        System.out.println("汽车开始行驶！");
		    }
		}
		
		//创建handler，完善业务方法（invoke中）
		public class TimeHandler implements InvocationHandler {
		    private Object target;
		
		    public TimeHandler(Object target) {
		        super();
		        this.target = target;
		    }
		
		    /**
		     *
		     * @param proxy 被代理对象
		     * @param method 被代理对象的方法
		     * @param args 方法的参数
		     * @return Object
		     * @throws Throwable
		     */
		    @Override
		    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		
		        long startTime = System.currentTimeMillis();
		        System.out.println("汽车开始行驶---》");
		        method.invoke(target);
		        long endTime = System.currentTimeMillis();
		        System.out.println("汽车结束行驶。。。行驶时间：" + (endTime - startTime) + "ms!");
		        return null;
		    }
		}
		
		//测试类
		public class Test {
		    public static void main(String[] args) {
		        Car car = new Car();
		        InvocationHandler h = new TimeHandler(car);
		        Class<?> cls = car.getClass();
		
		        //参数：1.类加载器 2.实现接口 3.InvocationHandler
		        Moveable m = (Moveable) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), h);
		        m.move();
		    }
		}
		/*输出：汽车开始行驶---》
		汽车开始行驶！
		汽车结束行驶。。。行驶时间：1ms!*/

    总结：Dynamic Proxy是这样一种Class（被代理对象首先要实现某些接口）：
    它是在运行是生成的class
    该class需要实现一组interface
    使用动态代理时，必须实现InvocationHandler接口
    （代理类并不能做具体的事，声明一个Handler,由它接管实际的工作，具体业务在Handler中实现）
     ※ JDK动态代理
    1.只能代理实现了接口的类
    2.没有实现接口的类不能实现JDK的动态代理

• CGLIB动态代理
     ※ CGLIB动态代理
    1.针对类实现代理的
    2.对指定目标类产生一个子类，通过方法拦截技术拦截所有父类方法的调用

//创建目标类
public class Train {
    public void move(){
        System.out.println("火车行驶中。。。");
    }
}

//创建代理类实现方法拦截接口（需要导cglib的jar包）
public class CglibProxy implements MethodInterceptor {

    //创建代理类的属性
    private Enhancer enhancer = new Enhancer();

    //Object 代理类 clazz 被代理的类
    public Object getProxy(Class clazz){

        //设置创建子类的类（也就是为哪个类产生代理类）
        enhancer.setSuperclass(clazz);
        enhancer.setCallback(this);
        //创建子类的实例
        return enhancer.create();
    }

    /**
     * 拦截所有目标类方法的调用
     * @param obj 目标类的实例
     * @param method 目标方法的反射对象
     * @param args 方法的参数
     * @param methodProxy 代理类的实例
     * @return
     * @throws Throwable
     */
     @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy methodProxy) throws Throwable {
        System.out.println("日志开始。。。");
        //代理类调用父类的方法
        methodProxy.invokeSuper(obj, args);
        System.out.println("日志结束。。。");
        return null;
    }
}

//测试类
public class Test {
    public static void main(String[] args) {
        //创建返回代理类的对象
        CglibProxy proxy = new CglibProxy();
        Train t = (Train) proxy.getProxy(Train.class);
        t.move();
    }
    /*输出：
    日志开始。。。
    火车行驶中。。。
    日志结束。。。
     */
    //对运行的方法前后增加了额外的处理
}

总结

  调用某个jar包的某个类的某个方法，因为不能修改源码，所以就可以采用代理模式这种机制在代理方法前后增加一些额外的业务逻辑，这种方式也称为AOP 面向切面编程（Aspect-Oriented Programming），在不改变原有类方法的基础上增加额外功能。

AOP概念及优点

   AOP主要处理共通逻辑，例如日志记录、性能统计、安全控制、事务控制、异常处理等等，AOP可以将这些共通逻辑从普通业务逻辑代码中分离出来，这样在日后修改这些逻辑的时候就不会影响普通业务逻辑的代码。
利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。
OOP（面向对象编程）针对业务处理过程的实体及其属性和行为进行抽象封装，以获得更加清晰高效的逻辑单元划分。
AOP则是针对业务处理过程中的切面进行提取，它所面对的是处理过程中的某个步骤或阶段，一伙的逻辑过程中各部分之间低耦合性的隔离效果。
AOP需要以OOP为前提和基础。

什么是方面

指封装共同处理的组件，该组件被作用到其他目标组件方法上。

什么是目标

指被一个或多个方面所作用的对象。

什么是切入点

切入点是用于指定哪些组件和方法使用方面功能，在Spring中利用一个表达式指定切入目标。
Spring提供了以下常用的切入点表达式：
   -方法限定表达式
     execution（修饰符？ 返回类型 方法名（参数）throws 异常类型）
   -类型限定表达式
      within（包名.类型）
   -Bean名称限定表达式
      bean（”Bean的id或name属性值“）

什么是通知

通知是用于指定方面组件和目标组件作用的实际。例如方面功能在目标方法之前或之后执行等时机。
Spring框架提供以下几种类型的通知：
-前置通知：先执行方面功能再执行目标功能
-后置通知：先执行目标功能再执行方面功能（目标无异常才执行方面）
-最终通知：先执行目标功能再执行方面功能（目标有无异常都执行方面）
-异常通知：先执行目标，抛出后执行方面
-环绕通知：先执行方面前置部分，然后执行目标，最后再执行方面后置部分
例：

	try {
		//前置通知--执行方面
		//环绕通知前置部分
		//执行目标组件方法
		//环绕通知后置部分
		//后置通知--执行方面
	} catch {
		//异常通知--执行方面
	} finally {
		//最终通知--执行方面
	}

AOP实现原理

Spring AOP实现主要基于动态代理技术（Cglib和Jdk Proxy Api）。当Spring采用AOP配置后，Spring容器返回的目标对象，实质上是Spring利用动态代理技术生成的一个代理类型。代理类重写了源目标组件方法的功能，再代理类中调用方面对象对象功能和目标对象的功能。
使用的配置方式有xml和注解

模拟JDK动态代理的内部实现