Java设计模式(05-- 代理模式模式 )

学习代理模式之前需要了解的内容
1）面向对象的设计思想 2）了解多态概念 3）了解反射原理

本课程包括代理模式的概念及其分类、了解代理模式开发中的应用场景、掌握代理模式的实现方式、
理解JDK动态代理的实现。

代理模式的定义：
为其他对象提供一种代理以控制对这个对象的访问，代理对象起到中介作用，可去掉功能服务或者增加
额外的服务。

分类：
1）远程代理：为不同地理的对象提供局域网代表对象，类似客户端和服务器这种模式。
2）虚拟代理：根据需求将资源消耗很大的对象进行延迟处理，真正需要的时候再进行创建。（如一篇文章
的图片很大，我们可以用代替让图片进行延迟加载）
3）保护代理：如论坛的访问权限，我们就可以通过保护代理来实现。
4）智能引用代理：最常用的代理，一般都是需要在代理的服务之前增添某些功能。

以智能引用代理为例其实现方式有静态代理和动态代理两种方式。

静态代理：代理和被代理对象在代理之前都是确定的，他们都是实现了相同的接口或者继承了相同的抽象类。
实现静态方法可以通过继承的方式和聚合的方式来实现
实例：对行驶的汽车进行计时服务。

目标接口（被代理类和代理类都需要实现的接口类）：Moveable

package com.imooc.pattern.proxy;

public interface Moveable {
    void move();
}

被代理类（提供汽车行驶功能）Car

package com.imooc.pattern.proxy;

import java.util.Random;

public class Car implements Moveable {

    public void move() {
        try {
            Thread.sleep(new Random().nextInt(1000));
            System.out.println("汽车行驶中······");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

}

使用继承方式实现静态代理的代理类 CarExtends

package com.imooc.pattern.proxy;

/**
 * 通过继承的方式实现静态代理
 * CarExtends通过重写move方法，调用super.move()方法实现了对父类Car的代理,
 * 同时在super.move()方法前后加入了自己提供的额外服务
 * @author zplogo
 *
 */
public class CarExtends extends Car {

    public void move() {
        long startTime = System.currentTimeMillis();
        System.out.println("汽车开始行驶······");
        super.move();
        long endTime = System.currentTimeMillis();
        System.out.println("汽车终止行驶····本次行程共花费时间："+(endTime-startTime)+"毫秒");
    }
    
}

使用聚合方式实现静态代理的代理类 Car3

package com.imooc.pattern.proxy;

/**
 * 使用聚合的方式实现静态代理
 * 聚合就是在一个类中需要调用另一个对象，通过构造方法进行注入，然后在实现接口的方法中调用被代理对象的方法
 * 在该方法前后加入自己的逻辑功能
 * @author zplogo
 *
 */
public class Car3 implements Moveable {
    
    private Car car;
    
    public Car3(Car car) {
        super();
        this.car = car;
    }

    public void move() {
        long startTime = System.currentTimeMillis();
        System.out.println("汽车开始行驶····计时开始··");
        car.move();
        long endTime = System.currentTimeMillis();
        System.out.println("汽车终止行驶····本次行程共花费时间："+(endTime-startTime)+"毫秒");
    }

}

继承方式和聚合方式哪种更好？？
现实情况我们需要在代理服务前后做很多功能的叠加，如在move()方法前后不仅需要做计时功能还需要权限功能，日志记录服务。
而Java是单继承的，继承的方式实现静态代理来达到功能的叠加，继承将会无限膨胀下去，因此并不可取。
聚合的方式需要代理类和被代理类都实现相同的接口。

现在我们用聚合的方式完成汽车行驶计时和日志功能的叠加

时间代理类 CarTimeProxy

package com.imooc.pattern.proxy;

/**
 * 使用聚合的方式实现静态代理   
 * 功能：在代理汽车行驶功能的同时加入了计时功能
 * 聚合就是在一个类中需要调用另一个对象，通过构造方法进行注入，然后在实现接口的方法中调用被代理对象的方法
 * 在该方法前后加入自己的逻辑功能
 * @author zplogo
 *
 */
public class CarTimeProxy implements Moveable {
    
    private Moveable m;
    
    //这里由于代理类和被代理类都实现了相同的接口，所以我们可以传入Moveable对象
    public CarTimeProxy(Moveable m) {
        super();
        this.m = m;
    }

    public void move() {
        long startTime = System.currentTimeMillis();
        System.out.println("汽车开始行驶····计时开始··");
        m.move();
        long endTime = System.currentTimeMillis();
        System.out.println("汽车终止行驶····本次行程共花费时间："+(endTime-startTime)+"毫秒");
    }

}

日志记录代理类 CarLogProxy

package com.imooc.pattern.proxy;

/**
 * 使用聚合的方式实现静态代理   
 * 功能：在代理汽车行驶功能的同时加入了日志记录的功能
 * 聚合就是在一个类中需要调用另一个对象，通过构造方法进行注入，然后在实现接口的方法中调用被代理对象的方法
 * 在该方法前后加入自己的逻辑功能
 * @author zplogo
 *
 */
public class CarLogProxy implements Moveable {
    
    private Moveable m;
    
    //这里由于代理类和被代理类都实现了相同的接口，所以我们可以传入Moveable对象
    public CarLogProxy(Moveable m) {
        super();
        this.m = m;
    }

    public void move() {
        System.out.println("日志记录开始········");
        m.move();
        System.out.println("日志记录结束········");
    }

}

客户端测试类 ClientTest

package com.imooc.pattern.proxy;

import com.imooc.pattern.cglibproxy.CglibProxy;
import com.imooc.pattern.cglibproxy.Train;

public class ClientTest {

    public static void main(String[] args) {
//        Car car = new Car();
//        car.move();
        //通过继承的方式实现代理父类的功能，同时增加额外的功能
//         Moveable m = new CarExtends();
//         m.move();
        //使用聚合的方式实现静态代理，把被代理对象注入代理类构造方法，代理类实现接口方法中实现代理同时加入自己的功能
//        Car car = new Car();
//        Moveable m = new Car3(car);
//        m.move();
        
        //用聚合的方式实现静态代理比继承灵活，完成计时功能和日志功能的叠加【这种设计模式我们发现做功能的叠加非常好，代码清晰便于维护】
        //先完成计时功能，然后叠加日志记录功能
        /*Car car = new Car();
        CarTimeProxy ctp = new CarTimeProxy(car);
        CarLogProxy clp = new CarLogProxy(ctp);
        clp.move();*/
        //先完成日志记录功能，然后叠加计时功能
    /*    Car car = new Car();
        CarLogProxy clp = new CarLogProxy(car);
        CarTimeProxy ctp = new CarTimeProxy(clp);
        ctp.move();*/
        
        //测试Cglib产生代理类,好像cglib使用的继承方式完成动态代理
        CglibProxy cglibProxy = new CglibProxy();
        Train t = (Train)cglibProxy.getProxy(Train.class);//在getProxy()方法中已经设置了代理类的父类为Train.class
        t.move();
    }

}

JDK动态代理
首先被代理对象需要实现某些接口，运行时产生代理类的class对象，我们需要定义一个Hander实现InvocationHandler接口，让它接管业务，具体业务在Handler中实现。

JDK动态代理的实现步骤
1.创建实现InvocationHandler接口的类，它必须实现invoke方法。
2.创建被代理类及接口。
3.调用Proxy的静态方法创建一个代理类，newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h)
4.通过代理类调用方法

实例

汽车计时处理类 TimeHandler

package com.imooc.pattern.jdkproxy;

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

public class TimeHandler implements InvocationHandler {
    
    private Object target;
    
    public TimeHandler(Object target) {
        super();
        this.target = target;
    }
    
    /*
     * 参数：
     * proxy 被代理对象
     * method 被代理对象的方法
     * args 方法的参数
     * 
     * 返回值：
     * Object 该方法的返回对象
     */
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        long startTime = System.currentTimeMillis();
        System.out.println("汽车开始行驶····计时开始··");
        method.invoke(target, null);//通过传入被代理的对象，调用被代理对象的方法完成代理，（在该行上下加入额外的功能）
        long endTime = System.currentTimeMillis();
        System.out.println("汽车终止行驶····本次行程共花费时间："+(endTime-startTime)+"毫秒");
        return null;
    }

}

JDK动态代理测试类 JdkProxyTest

package com.imooc.pattern.jdkproxy;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;

import com.imooc.pattern.proxy.Car;
import com.imooc.pattern.proxy.Moveable;

public class JdkProxyTest {

    public static void main(String[] args) {
        Car car = new Car();
        InvocationHandler h = new TimeHandler(car);
        Class<?> cls=car.getClass();
        /*
         * loader 被代理类的类加载器
         * interfaces 实现接口
         * h  InvocationHandler
         */
        Moveable m = (Moveable) Proxy.newProxyInstance(cls.getClassLoader(),cls.getInterfaces() , h);
        m.move();
    }

}

思考作业：
我们用JDK完成了对Car运行时间的记录，另外我们需要在进行叠加记录日志的功能。

CgLib实现动态代理

首先需要引入Cglib的jar包 cglib-nodep-2.2.jar

实例代码：

被代理类 Train

package com.imooc.pattern.cglibproxy;

public class Train {
    public void move(){
        System.out.println("火车行驶中········");
    }
}

Cglib代理类  CglibProxy

package com.imooc.pattern.cglibproxy;

import java.lang.reflect.Method;

import net.sf.cglib.proxy.Enhancer;
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

public class CglibProxy implements MethodInterceptor {
    
    private Enhancer enhancer = new Enhancer();//创建代理类的属性
    
    public Object getProxy(Class clazz){
        enhancer.setSuperclass(clazz);//设置创建子类的类（被代理类）
        enhancer.setCallback(this);
        return enhancer.create();
    }
    
    /*
     * 拦截所有目标类的方法的调用
     * object 目标类的实例
     * m 目标方法反射的对象
     * args 方法的参数
     * proxy 代理类的实例
     */
    @Override
    public Object intercept(Object object, Method m, Object[] args,
            MethodProxy proxy) throws Throwable {
        System.out.println("开始记录日志·······");
        //代理类调用父类的方法
        proxy.invokeSuper(object, args);
        System.out.println("结束记录日志·······");
        return null;
    }

}

测试代码见上面的客户端测试类 。

智能引用代理在实际开发中应用最广泛，可以进行日志处理，权限管理，事务管理。

动态代理在面向切面编程（AOP）非常有用。

模拟JDK动态代理实现原理（未完待续················）