Java设计模式之代理模式

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

几种常见的代理模式：

• 远程代理:类似于客户端、服务器这种模式，为不同地理的对象提供局域网代理对象
•  虚拟代理：根据需要将资源消耗很大的对象进行延迟，真正需要的时候进行创建，浏览帖子的时候会有文字和图片，可以采用虚拟代理，用一张虚拟的图片先代替真实的图片，等到真实的图片加载完成后，再显示真实的图片。
• 保护代理：控制对一个对象的访问权限。
• 智能引用代理：提供对目标对象额外的服务。

以下主要以智能代理为例：

1. 静态代理

代理和被代理对象在代理之前是确定的，他们都实现相同的接口或者继承相同的类。

实现方式：

•  继承：这种方式不推荐，会使类无线膨胀
• 聚合：一个类当中调用另一个对象

2. 动态代理

jdk的动态代理：

Java动态代理位于java.lang.reflect包下，一般主要设计一下两个类：

（1）Interface InvocationHandler：该接口仅定义了一个方法，public object invoke(Object obj,Method method,Object[] args)，在实际使用时，第一个参数指代理类，method是被代理的方法，args是该方法的参数组。这个方法在代理类中动态实现。

（2）Proxy：该类即为动态代理类：static newProxyInstance(ClassLoader,Class[]interfaces,InvocationHandler h):返回一个代理类实例，返回后的代理类可以当做被代理类使用。

下面的例子就是为car创建日志和时间的代理类：

new一个Moveable的接口

package com.dyl.test;

public interface Moveable {
    void move();

}

new一个car类实现moveable接口

package com.dyl.test;

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) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

}

为car创建一个时间的代理类

package com.dyl.jdkproxy;

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

public class TimeHandler implements InvocationHandler {
    
    
    private Object target;
    
    public TimeHandler(Object target) {
        // TODO Auto-generated constructor stub
        super();
        this.target = target;
    }

    /* (non-Javadoc)
     * @see java.lang.reflect.InvocationHandler#invoke(java.lang.Object, java.lang.reflect.Method, java.lang.Object[])
     * 参数：
     * proxy：被代理对象
     * method：被代理对象的方法
     * args：方法参数
     * 
     * 返回值：
     * Object方法的返回值
     */
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        // TODO Auto-generated method stub
        //开始时间
        long startTime = System.currentTimeMillis();
        System.out.println("汽车开始行驶");
        method.invoke(target);
        //结束时间
        long endTime = System.currentTimeMillis();
        System.out.println("汽车行驶结束...汽车行驶时间"+ (endTime-startTime)+" 毫秒");
        return null;
    }

}

为car创建一个日志的代理类

package com.dyl.jdkproxy;

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

public class LogHandler implements InvocationHandler {
    
    
    private Object target;
    
    public LogHandler(Object target) {
        // TODO Auto-generated constructor stub
        super();
        this.target = target;
    }

    /* 
     * 参数：
     * proxy：被代理对象
     * method：被代理对象的方法
     * args：方法参数
     * 
     * 返回值：
     * Object方法的返回值
     */
    public Object invoke(Object proxy, Method method, Object[] args)
            throws Throwable {
        System.out.println("日志开始");
        method.invoke(target);
        System.out.println("日志结束");
        return null;
    }

}

创建测试类

package com.dyl.jdkproxy;

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

import com.dyl.test.Car;
import com.dyl.test.Moveable;

public class TestJdkProxy {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        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);
        InvocationHandler h1 = new LogHandler(m);
        //在时间代理类的基础上创建日志的代理类
        Moveable m1 = (Moveable) Proxy.newProxyInstance(cls.getClassLoader(), cls.getInterfaces(), h1);
        m1.move();

    }

}

cglib的动态代理

针对类来实现代理，对指定目标类产生一个子类，通过方法拦截技术拦截所有的父类方法的调用

下面的例子对train代理：

new一个train类：

package com.dyl.cglibproxy;

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

}

引用cglib包，创建一个代理类实现MethodInterceptor接口:

package com.dyl.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();
        
    }
    
    /**
     * 拦截所有目标类方法调用
     * obj:目标类实例
     * m:目标方法的反射对象
     * args：方法的参数
     * proxy：代理类的实例
     * 
     */
    public Object intercept(Object obj, Method m, Object[] args,
            MethodProxy proxy) throws Throwable {
        //代理类调用父类的方法,来实现代理的方法
        System.out.println("日志开始");
        proxy.invokeSuper(obj, args);
        System.out.println("日志结束");
        return null;
    }

}

创建测试类：

package com.dyl.cglibproxy;

public class TestCgProxy {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        CglibProxy proxy = new CglibProxy();
        Train t = (Train) proxy.getProxy(Train.class);
        t.move();

    }

}