设计模式之代理模式

设计模式之代理模式

代理模式的概念：

    为其他对象提供一种代理以控制对这个对象的访问。在某些情况下，一个对象不适合或者不能直接引用另一个对象，而代理对象可以在客户端和目标对象之间起到中介的作用

什么时候用代理模式：

• 远程代理（为不同地理的对象提供局域网代表对象）
• 虚拟代理（根据需要将一个资源消耗很大的对象进行延迟，真正需要的时候进行创建）
• 保护代理（控制对一个对象的权限）
• 智能引用代理（提供对目标对象额外的服务）

怎么用代理模式：

静态代理：

    代理和被代理对象在代理之前是确定的，他们都是先相同的接口或者相同的抽象类

public interface Moveable {
    public void move();
}

//定义一个Car类，实现Moveable接口

import java.util.Random;

public class Car implements Moveable{
    @Override
    public void move() {
        long starttime = System.currentTimeMillis();
        System.out.println("汽车开始移动");
        try {

            System.out.println("汽车移动中。。。。。");
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        System.out.println("汽车停止移动");
        long endtime = System.currentTimeMillis();
        System.out.println("移动："+(endtime-starttime)+"毫秒");

    }

}

测试：

public class Test {
    public static void main(String[] args) {
        Car car = new Car();
        car.move();
       }
}

//汽车开始移动
//汽车移动中。。。。。
//汽车停止移动
//移动：561毫秒

使用代理（集成的方式）：

//将car修改为
public class Car implements Moveable{
    @Override
    public void move() {
        try {
            long starttime = System.currentTimeMillis();
            System.out.println("汽车开始移动");
            System.out.println("汽车移动中。。。。。");
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }


    }

}

package Proxy;

/**
 * 继承的方式
 */
public class Car2 extends Car{
    //继承Car实现move方法，调用car的move方法相当于代理car
    @Override
    public void move() {
        long starttime = System.currentTimeMillis();
        System.out.println("汽车开始移动");
        super.move();
        System.out.println("汽车停止移动");
        long endtime = System.currentTimeMillis();
        System.out.println("移动："+(endtime-starttime)+"毫秒");
    }
}

使用代理（聚合的方式）：

/**
 * 使用聚合的方式，通过传入参数调用方法
 */
public class Car3 implements Moveable{
    private Car car;

    public Car3(Car car) {
        super();
        this.car = car;
    }
    @Override
    public void move() {
        long starttime = System.currentTimeMillis();
        System.out.println("汽车开始移动");
        car.move();
        System.out.println("汽车停止移动");
        long endtime = System.currentTimeMillis();
        System.out.println("移动："+(endtime-starttime)+"毫秒");
    }

}

使用聚合的方式比继承更适合：
如果我们需要增加功能并且实现先后顺序有变化，使用继承的方式我们需要不断的增加类，使用聚合的方式更方便。

动态代理：

JDK的动态代理
Java动态代理类位于Java.lang.reflect包下，一般主要涉及到以下两个类：
1. Interface InvocationHandler：该接口中仅定义了一个方法Object：invoke(Object obj,Method method,Object[] args）。
2. Proxy：该类即为动态代理类，其中主要包含以下内容：Protected Proxy(InvocationHandler h）：构造函数，用于给内部的h赋值。

动态代理实现的步骤：

1. 创建一个实现接口InvocationHandler的类，它必须实现invoke方法；
2. 创建被代理的类以及接口
3. 调用Proxy的静态方法，创建一个代理类：
4. 通过代理调用方法

动态代理：

• 所谓Dynamic Proxy是这样一种class：它是在运行时生成的class，在生成它时你必须提供一组interface给它，然后该class就宣称它实现了这些 interface。你当然可以把该class的实例当作这些interface中的任何一个来用。当然啦，这个Dynamic Proxy其实就是一个Proxy，它不会替你作实质性的工作，在生成它的实例时你必须提供一个handler，由它接管实际的工作。

code：

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

/**
 * 事务处理器
 */
public class TimeHandler implements InvocationHandler{
    private Object object;
    public TimeHandler(Object object) {
        super();
        this.object = object;
    }
    /*   第一个参数proxy一般是指代理类，
     *   method是被代理的方法，
     *   args为该方法的参数数组。
     *   这个抽象方法在代理类中动态实现
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        long starttime = System.currentTimeMillis();
        System.out.println("汽车开始移动");
        method.invoke(object);
        System.out.println("汽车停止移动");
        long endtime = System.currentTimeMillis();
        System.out.println("移动："+(endtime-starttime)+"毫秒");
        return null;
    }

}

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

/**
 * 测试
 *  */
public class Test {
    public static void main(String[] args) {
        Car car = new Car();
        InvocationHandler h = new TimeHandler(car);
        Class<?> cls = car.getClass();
        Moveable m = (Moveable) 
        //Static Object newProxyInstance(ClassLoader loader,Class[] interfaces,InvocationHandler h）：返回代理类的一个实例，返回后的代理类可以当作被代理类使用（可使用被代理类的在Subject接口中声明过的方法）。
        Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), h);
        m.move();
    }
}

使用cglib产生动态代理：
JDK动态代理：1、只能代理实现了接口的类 2、没有实现接口的类不能实JDK的动态代理。
CGLIB：1、针对类来实现代理。2、对指定目标类产生一个子类，通过方法拦截技术拦截所有父类方法的调用。

public class Car {
    public void move() {
        try {
            System.out.println("汽车移动中。。。。。");
            Thread.sleep(new Random().nextInt(1000));
        } catch (InterruptedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

import java.lang.reflect.Method;

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

/**
 * cglib代理
 *
 */
public class CglibProxy implements MethodInterceptor{
    //代理类的属性Enhancer
    Enhancer enhancer = new Enhancer();
    public Object getintance(Class clasz){
        //设置创建子类的类
        enhancer.setSuperclass(clasz);
        enhancer.setCallback(this);
        return enhancer.create();
    }

    /* 
     * 拦截所有目标方法的调用
     * obj  目标类的实例
     * m   目标方法的反射对象
     * agrs 方法的参数
     * proxy   代理方法的实例
     */
    @Override
    public Object intercept(Object obj, Method m, Object[] args, MethodProxy proxy) throws Throwable {
        //代理类调用父类的方法
        //增加业务逻辑
        long starttime = System.currentTimeMillis();
        System.out.println("汽车开始移动");
        proxy.invokeSuper(obj, args);
        System.out.println("汽车停止移动");
        long endtime = System.currentTimeMillis();
        System.out.println("移动："+(endtime-starttime)+"毫秒");
        return null;
    }

}

public class Test {
    public static void main(String[] args) {
        CglibProxy cg = new CglibProxy();
        Car car = (Car) cg.getintance(Car.class);
        car.move();
    }
}

总结：
Jdk动态代理：只能代理实现了接口的类 ，没有实现接口的类不能实JDK的动态代理。但是CGLIB可以弥补一些不足、针对类来实现代理，不需要实现接口，对指定目标类产生一个子类，通过方法拦截技术拦截所有父类方法的调用。AOP编程中就是在不改变源码的情况下，使用代理添加逻辑。