在Java的java.lang.reflect包下提供一个Proxy类和一个InvocationHandler接口,通过使用这个类和接口可以生成jdk动态代理类或动态代理对象。
Proxy是所有动态代理类的父类,它提供了两个静态方法来创建动态代理类和动态代理对象,如下:
Ø
static
Class<?>
getProxyClass(
ClassLoader loader,
Class<?>... interfaces)
Ø
static
Object
newProxyInstance(
ClassLoader loader,
Class<?>[] interfaces,
InvocationHandler h)
getProxyClass返回代理类的 java.lang.Class 对象,并向其提供类加载器和接口数组。newProxyInstance返回一个指定接口的代理类实例,该接口可以将方法调用转发到指定的调用处理程序,执行代理对象的每个方法时都会被替换执行InvocationHandler对象的Invoke方法。实际上,即使采用第一种方式获取了一个动态代理类之后,当程序需要通过该代理类来创建对象时一样需要传入一个InvocationHandler对象。也就是说,系统生成的每个代理对象都有一个与之关联的InvocationHandler对象。
从上面的两个方法的参数可以看出,只有给我一个(或多个)接口,我们就可以生成实现了这个(或多个)接口的代理类和代理对象。
2. 两种方式生成代理对象
下面我们就用上面提到两种方式,分别来生成一个接口(Person)的代理对象。
2.1 接口Person
- package com.tgb.reflect;
- /**
- * 目标接口
- *
- * @author wangzhipeng
- *
- */
- public interface Person {
- public void walk();
- public void sayHello();
- }
2.2 构造一个InvocationHandler类
- package com.tgb.reflect;
- import java.lang.reflect.InvocationHandler;
- import java.lang.reflect.Method;
- public class MyInvocationHandler implements InvocationHandler {
- /**
- * 执行代理对象的所有方法时都会被替换成执行如下的invoke方法
- *
- * proxy :代表动态代理对象; method:代表正在执行的方法 ;args :代表执行代理对象方法时传入的实参
- */
- @Override
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- // TODO Auto-generated method stub
- System.out.println("正在执行方法:" + method.getName());
- if (args != null) {
- System.out.println("下面是执行方法时传入的实参:");
- for (Object object : args) {
- System.out.println(object);
- }
- } else {
- System.out.println("该方法调用无实参!");
- }
- return null;
- }
- }
2.3 方式一:利用getProxyClass生成代理对象
- package com.tgb.reflect;
- import java.lang.reflect.Constructor;
- import java.lang.reflect.InvocationHandler;
- import java.lang.reflect.Proxy;
- /**
- * 利用getProxyClass生成代理对象
- *
- * @author wangzhipeng
- *
- */
- public class TestReflectProxy {
- @SuppressWarnings("unchecked")
- public static void main(String[] args) throws Exception {
- // 1、创建一个InvocationHandler对象
- InvocationHandler myInvocationHandler = new MyInvocationHandler();
- // 2、创建Person接口的一个代理类(获取代理类的字节码)
- Class proxyClass = Proxy.getProxyClass(Person.class.getClassLoader(), new Class[] { Person.class });
- // 3、根据代理类的字节码拿到它的参数为InvocationHandler类型的构造器
- Constructor constructor = proxyClass.getConstructor(new Class[] { InvocationHandler.class });
- // 4、根据构造器创建代理对象
- Person person = (Person) constructor.newInstance(myInvocationHandler);
- // 5、调用代理对象的方法
- person.walk();
- person.sayHello();
- /**
- * 输出结果如下:
- *
- * 正在执行方法:walk 该方法调用无实参!
- *
- * 正在执行方法:sayHello 该方法调用无实参!
- */
- }
- }
2.4 方式二:利用newProxyInstance生成代理对象
- package com.tgb.reflect;
- import java.lang.reflect.InvocationHandler;
- import java.lang.reflect.Proxy;
- /**
- * 利用newProxyInstance生成代理对象
- *
- * @author wangzhipeng
- *
- */
- public class TestReflectProxy2 {
- public static void main(String[] args) {
- // 1、创建一个InvocationHandler对象
- InvocationHandler myInvocationHandler = new MyInvocationHandler();
- // 2、利用Proxy类的静态方法newProxyInstance直接生成Person接口的代理对象
- Person person = (Person) Proxy.newProxyInstance(Person.class.getClassLoader(), new Class[] { Person.class }, myInvocationHandler);
- // 3、调用代理对象的方法
- person.walk();
- person.sayHello();
- /**
- * 输出结果如下:
- *
- * 正在执行方法:walk 该方法调用无实参!
- *
- * 正在执行方法:sayHello 该方法调用无实参!
- */
- }
- }
3. 动态代理与aop
下面我们在上面例子的基础上再扩展一小步,模拟以下aop思想原理。其实,非常简单,上面已经提到了,执行代理对象的每个方法时都被替换执行InvocationHandler对象的Invoke方法。所以我们只需要在Invoke方法中的“反射执行目标方法(method.invoke(target,args))“的前后加入我们增强的方法即可。实例代码如下:
3.1 目标接口Person
- package com.tgb.reflect.aop;
- /**
- * 目标接口
- *
- * @author wangzhipeng
- *
- */
- public interface Person {
- public void walk();
- public void sayHello();
- }
3.2 目标类ZhanSan
- package com.tgb.reflect.aop;
- /**
- * 目标类(实现了Person接口)
- *
- * @author wangzhipeng
- *
- */
- public class ZhanSan implements Person {
- @Override
- public void sayHello() {
- System.out.println("我是张三---->sayHello");
- }
- @Override
- public void walk() {
- System.out.println("我是张三---->walk");
- }
- }
3.3 增强类Extend
- package com.tgb.reflect.aop;
- /**
- * 增强类
- *
- * @author wangzhipeng
- *
- */
- public class Extend {
- /**
- * 增强方法1
- */
- public void ExtendMethod1() {
- System.out.println("我是增强方法一");
- }
- /**
- * 增强方法2
- */
- public void ExtendMethod2() {
- System.out.println("我是增强方法二");
- }
- }
3.4 InvocationHandler类MyInvocationHandler
- package com.tgb.reflect.aop;
- import java.lang.reflect.InvocationHandler;
- import java.lang.reflect.Method;
- public class MyInvocationHandler implements InvocationHandler {
- // 目标对象(需要被代理的对象)
- private Object target;
- public void setTarget(Object target) {
- this.target = target;
- }
- /**
- * 执行代理对象的所有方法时都会被替换成执行如下的invoke方法
- */
- @Override
- public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
- // 实例化一个增强类
- Extend extend = new Extend();
- // 执行增强方法1(模拟spring前置增强)
- extend.ExtendMethod1();
- Object result = method.invoke(target, args);// 【执行目标方法】
- // 执行增强方法2(模拟spring后置增强)
- extend.ExtendMethod2();
- return result;
- }
- }
3.5 代理生成工厂MyProxyFactory
- package com.tgb.reflect.aop;
- import java.lang.reflect.Proxy;
- /**
- * 生成代理的工厂
- *
- * @author wangzhipeng
- *
- */
- public class MyProxyFactory {
- /*
- * 获取一个目标对象(目标类必须实现接口)的代理对象
- */
- public static Object getProxy(Object target) {
- // 实例化一个InvocationHandler类,并传入目标对象
- MyInvocationHandler myInvocationHandler = new MyInvocationHandler();
- myInvocationHandler.setTarget(target);
- // 生成代理对象
- Object proxyObject = Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), myInvocationHandler);
- return proxyObject;
- }
- }
3.6 测试类Test
- package com.tgb.reflect.aop;
- /**
- * 测试类
- *
- * @author wangzhipeng
- *
- */
- public class Test {
- public static void main(String[] args) {
- // 创建一个原始的ZhanSan(实现了Person接口)对象作为Target
- Person zhanSan = new ZhanSan();
- // 利用代理工厂生成zhansan对象(Target)的代理对象
- Person proxyZhanSan = (Person) MyProxyFactory.getProxy(zhanSan);
- // 执行代理对象的方法(会执行织入的增强类(Extend)的两个增强方法)
- proxyZhanSan.walk();
- proxyZhanSan.sayHello();
- }
- }
3.7 结果如下
4. 总结
Proxy类主要方法有四个(如下图),jdk动态代理主要是利用Proxy类的getProxyClass和newProxyInstance方法生成接口的动态代理对象,并将执行代理对象的每个方法时都被替换执行InvocationHandler对象的Invoke方法。这为spring的aop打好了基础。此外,实际应用中,我们一般不会单纯直接生成一个(或多个)接口的代理对象,而是生成某个接口实现类(目标类)的代理对象。
实际上普通的java编程中我们很少用到动态代理,它最大的魅力在于编写框架或底层基础代码。最后,代理的架构图如下: