Java设计模式——动态代理dynamicProxy

一、动态代理设计图

二、动态代理概述

动态代理是JDK5 提供的一种新特性。其特点在于在程序的运行时刻动态的创建出代理类及其对象，而不像我们使用静态代理时必须在编译之前定义好代理类。在运行时刻，框架帮我们动态的创建出一个实现了多个接口的代理类，每个代理类的对象都会和一个InvocationHandler接口的实现类相关联。当我们调用了代理对象所代理的接口中的方法的时候，这个调用的信息会被传递给InvocationHandler的invoke方法。在 invoke方法的参数中可以获取到代理对象、方法对应的Method对象和调用的实际参数（内部是通过反射来实现的）。 invoke方法的返回值被返回给使用者，至于返回什么值可以由自己来定义，这种做法实际上相当于对方法调用进行了AOP拦截。

三、创建动态代理的步骤

（1）、创建被代理类以及接口。

（2）、创建一个实现接口InvocationHandler的类，它必须实现invoke方法。

（3）、通过Proxy的静态方法newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)创建一个代理。

（4）、通过代理来调用方法（此代理实现了被代理类的接口）。

四、实例分析

在userService 中，调用getName()前后加上一句话，如果直接在userService的方法中添加，会破坏源文件，此时可以写个代理对象，当执行getName()方法时，在其前后添加相应的行为。

（1）、创建接口和被代理类。

接口：

package org.wangkeqing.proxy;
public interface UserService {
    public String getName(int id);
    public Integer getAge(int id);
}

被代理类：

package org.wangkeqing.proxy;
public class UserServiceImpl implements UserService {
	@Override
	public Integer getAge(int id) {
		System.out.println("------getAge------");
        	return 10;
	}
	@Override
	public String getName(int id) {
		System.out.println("------getName------");
        	return "Tom";
	}
}

（2）、创建一个实现接口InvocationHandler的类，它必须实现invoke方法。

package org.wangkeqing.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
/**
 * 代理类 <br>
 * @author wkq
 */
public class MyInvocationHandler implements InvocationHandler {
	private Object target;
    	MyInvocationHandler() {
        	super();
    	}
    /**
     * 代理类的构造方法 <br>
     * @param target 被代理的类 <br>
     */
    MyInvocationHandler(Object target) {
        super();
        this.target = target;
    }
	@Override
	public Object invoke(Object proxy, Method method, Object[] args)throws Throwable {
	//在执行getName（）方法前后做些事情
	if("getName".equals(method.getName())){
            System.out.println("method  before " + method.getName() + "-----------");
            Object result = method.invoke(target, args);
            System.out.println("method  after " + method.getName() + "-------------");
            return result;
        }else{
            System.out.println("-------------------------分割线-------------------------------");
            Object result = method.invoke(target, args);
            return result;
        }
	}
}

（3）、通过Proxy的静态方法newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)创建一个代理。通过代理类来调用方法（此代理实现了被代理类的接口）

package org.wangkeqing.proxy;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Proxy;
public class Main1 {
	public static void main(String[] args) {
	    //获取UserService的实现类实例
	    UserService userService = new UserServiceImpl();
	    //获取代理对象
            InvocationHandler invocationHandler = new MyInvocationHandler(userService);
        //第一个参数为被代理类的类加载器，第二个参数为被代理类的接口，第三个参数为代理对象
        UserService userServiceProxy =
            (UserService)Proxy.newProxyInstance(userService.getClass().getClassLoader(),userService.getClass().getInterfaces(), invocationHandler);
        //通过代理对象调用方法
        System.out.println(userServiceProxy.getName(1));
        System.out.println(userServiceProxy.getAge(1));
	}
}

执行结果如下：

method  before getName-----------
------getName------
method  after getName-------------
Tom
-------------------------分割线-------------------------------
------getAge------
10

可以看出，在执行getName()方法前后都添加了一句话。

五、注意一下两个方法参数

（1）Object  invoke(Object proxy, Method method, Object[] args)    :在代理实例上处理方法调用并返回结果。

invoke方法其实是反射里边的一个方法,在这个方法中有三个参数:

　　　　Ojbect proxy:表示需要代理的对象

　　　 Method method:表示要操作的方法

　　　 Object[] args:method方法所需要传入的参数(可能没有为,null.也可能有多个)

（2）public static ObjectnewProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)

     该方法返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序.方法中有三个参数:

参数：
　　　　 loader - 定义代理类的类加载器
　　　　 interfaces - 代理类要实现的接口列表
　　　　 h - 指派方法调用的调用处理程序
　 　返回：
　　　　一个带有代理类的指定调用处理程序的代理实例，它由指定的类加载器定义，并实现指定的接口。