设计模式之代理模式——静态代理及jdk、cglib动态代理

在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。

在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。将真实对象实例隐藏，将代理类暴露给客户调用。

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

通过代理记录car行驶时间

行驶接口

public interface MoveAble {
    void move();
}

car类实现moveAble接口
普通实现记录汽车行驶时间

public class Car implements MoveAble{
    @Override
    public void move() {
        long starttime =System.currentTimeMillis();
        System.out.println("汽车开始行驶");
        //实现开车的时间
        try {
            Thread.sleep(new Random().nextInt(1000));
            System.out.println("汽车行驶中");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long endtime =System.currentTimeMillis();
        System.out.println("汽车结束行驶，汽车行驶时间："+(endtime-starttime)+"毫秒！");
    }
}

继承的方式实现代理

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)+"毫秒！");
    }
}

聚合的方式实现代理

public class Car3 implements MoveAble{
    public Car3(Car car) {
        super();
        this.car =car;
    }
    private Car car;
    @Override
    public void move() {
        long starttime =System.currentTimeMillis();
        System.out.println("汽车开始行驶");
        car.move();
        long endtime =System.currentTimeMillis();
        System.out.println("汽车结束行驶，汽车行驶时间："+(endtime-starttime)+"毫秒！");

    }
}

测试类

public class Client {
    public static void main(String[] args) {
        //普通的方式
        Car car =new Car();
        car.move();
        //继承的方式
        MoveAble car2 =new Car2();
        car.move();
        //聚合的方式
        MoveAble car3 =new Car3(car);
        car3.move();
    }
}

聚合的方式比继承的方式更加灵活。

JDK动态代理

方式一

jdk动态代理代理的类是需要接口的
首先接口类：

public interface TestDynamicSubject {
    void doSameThing();
}

接口实现类

public class TestDynamicRealSubject implements TestDynamicSubject{

    public void doSameThing(){
        System.out.println("jdk动态代理，被代理类");
    }
}

代理对象的InvocationHandler接口实现类 代理对象所需的切面编程内容

public class TestDynamicJdkSubject implements InvocationHandler {
    private Object realSubject;

    public TestDynamicJdkSubject(Object realSubject) {
        this.realSubject = realSubject;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("jdk动态代理，切面对象，before");
        method.invoke(realSubject,args);
        System.out.println("jdk动态代理，切面对象，after");
        return null;
    }
}

客户端使用

可以对该接口下多个对象生产动态代理对象，不需要手动写静态代理对象。

public class TestDynamicProxy {

    public static void main(String[] args) {
        TestDynamicSubject subject = (TestDynamicSubject) Proxy.newProxyInstance(SessionState.Client.class.getClassLoader(),
                new Class[]{TestDynamicSubject.class}, new TestDynamicJdkSubject(new TestDynamicRealSubject()));
        subject.doSameThing();


    }
}

方式二

接口

//接口
public interface ITeacherDao {

	void teach(); // 授课方法
	void sayHello(String name);
}

被代理对象

public class TeacherDao implements ITeacherDao {

	@Override
	public void teach() {
		// TODO Auto-generated method stub
		System.out.println(" 老师授课中.... ");
	}

	@Override
	public void sayHello(String name) {
		// TODO Auto-generated method stub
		System.out.println("hello " + name);
	}
	
}

代理工厂

public class ProxyFactory {

	//维护一个目标对象 , Object
	private Object target;

	//构造器 ， 对target 进行初始化
	public ProxyFactory(Object target) {
		
		this.target = target;
	} 
	
	//给目标对象 生成一个代理对象
	public Object getProxyInstance() {
		
		//说明
		/*
		 *  public static Object newProxyInstance(ClassLoader loader,
                                          Class<?>[] interfaces,
                                          InvocationHandler h)
                                          
            //1. ClassLoader loader ： 指定当前目标对象使用的类加载器, 获取加载器的方法固定
            //2. Class<?>[] interfaces: 目标对象实现的接口类型，使用泛型方法确认类型
            //3. InvocationHandler h : 事情处理，执行目标对象的方法时，会触发事情处理器方法, 会把当前执行的目标对象方法作为参数传入
		 */
		return Proxy.newProxyInstance(target.getClass().getClassLoader(), 
				target.getClass().getInterfaces(), 
				new InvocationHandler() {
					
					@Override
					public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
						// TODO Auto-generated method stub
						System.out.println("JDK代理开始~~");
						//反射机制调用目标对象的方法
						Object returnVal = method.invoke(target, args);
						System.out.println("JDK代理提交");
						return returnVal;
					}
				}); 
	}
	
	
}

客户端

public class Client {

	public static void main(String[] args) {
		//创建目标对象
		ITeacherDao target = new TeacherDao();
		
		//给目标对象，创建代理对象, 可以转成 ITeacherDao
		ITeacherDao proxyInstance = (ITeacherDao)new ProxyFactory(target).getProxyInstance();
	
		// proxyInstance=class com.sun.proxy.$Proxy0 内存中动态生成了代理对象
		System.out.println("proxyInstance=" + proxyInstance.getClass());
		
		//通过代理对象，调用目标对象的方法
		//proxyInstance.teach();
		
		proxyInstance.sayHello(" tom ");
	}

}

CGLIB动态代理

在没有接口的对象无法使用jdk动态代理，我们可以使用cglib库来实现其动态代理。

方式一

被代理对象

public class TestDynamicObject {

    public void doSomething(){
        System.out.println("cglib动态代理,被代理对象");
    }
}

自定义MethodInterceptor 代理对象所需的切面编程内容

public class TestDynamicInterceptor implements MethodInterceptor {

    //创建代理对象
    public Object createProxy(Class clazz){
        //创建cglib的核心类
        Enhancer enhancer = new Enhancer();
        //为其设置父类
        enhancer.setSuperclass(clazz);
        //设置回调
        enhancer.setCallback(this);
        //创建代理
        return enhancer.create();
    }

    @Override
    public Object intercept(Object o, Method method, Object[] objects, MethodProxy methodProxy) throws Throwable {
        System.out.println("cglib动态代理，切面对象，before");
        Object object = methodProxy.invokeSuper(o, objects);
        System.out.println("cglib动态代理，切面对象，after");
        return object;
    }
}

客户端使用

public class TestDynamicProxy {

    public static void main(String[] args) {
//        // 通过CGLIB动态代理获取代理对象的过程
//        Enhancer enhancer = new Enhancer();
//        // 设置enhancer对象的父类
//        enhancer.setSuperclass(TestDynamicObject.class);
//        // 设置enhancer的回调对象
//        enhancer.setCallback(new TestDynamicInterceptor());
//        // 创建代理对象
//        TestDynamicObject proxy= (TestDynamicObject)enhancer.create();
//        // 通过代理对象调用目标方法
//        proxy.doSomething();
        TestDynamicInterceptor proxy = new TestDynamicInterceptor();
        TestDynamicObject proxyImp = (TestDynamicObject)proxy.createProxy(TestDynamicObject.class);
        proxyImp.doSomething();

    }
}

方式二

被代理对象

public class TeacherDao {

	public String teach() {
		System.out.println(" 老师授课中  ， 我是cglib代理，不需要实现接口 ");
		return "hello";
	}
}

代理工厂

public class ProxyFactory implements MethodInterceptor {

	//维护一个目标对象
	private Object target;
	
	//构造器，传入一个被代理的对象
	public ProxyFactory(Object target) {
		this.target = target;
	}

	//返回一个代理对象:  是 target 对象的代理对象
	public Object getProxyInstance() {
		//1. 创建一个工具类
		Enhancer enhancer = new Enhancer();
		//2. 设置父类
		enhancer.setSuperclass(target.getClass());
		//3. 设置回调函数
		enhancer.setCallback(this);
		//4. 创建子类对象，即代理对象
		return enhancer.create();
		
	}
	

	//重写  intercept 方法，会调用目标对象的方法
	@Override
	public Object intercept(Object arg0, Method method, Object[] args, MethodProxy arg3) throws Throwable {
		// TODO Auto-generated method stub
		System.out.println("Cglib代理模式 ~~ 开始");
		Object returnVal = method.invoke(target, args);
		System.out.println("Cglib代理模式 ~~ 提交");
		return returnVal;
	}

}

客户端

public class Client {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		//创建目标对象
		TeacherDao target = new TeacherDao();
		//获取到代理对象，并且将目标对象传递给代理对象
		TeacherDao proxyInstance = (TeacherDao)new ProxyFactory(target).getProxyInstance();

		//执行代理对象的方法，触发intecept 方法，从而实现 对目标对象的调用
		String res = proxyInstance.teach();
		System.out.println("res=" + res);
	}

}

要素

• jdk必须要有接口
• 被代理对象
• jdk动态代理和cglib动态代理所需要实现的切面编程接口