JAVA动态代理案例

墨蓝 2022-05-13 06:36 220阅读 0赞

一.概述

在java的动态代理机制中，有两个重要的类或接口，一个是 InvocationHandler(Interface)、另一个则是 Proxy(Class)，这一个类和接口是实现我们动态代理所必须用到的。

1）.nvocationHandler：

每一个动态代理类都必须要实现InvocationHandler这个接口，并且每个代理类的实例都关联到了一个handler，当我们通过代理对象调用一个方法的时候，这个方法的调用就会被转发为由InvocationHandler这个接口的 invoke 方法来进行调用。

2）.invoke方法：

Object invoke(Object proxy, Method method, Object[] args) throws Throwable

proxy:　　指代我们所代理的那个真实对象。  
    method:　　指代的是我们所要调用真实对象的某个方法的Method对象。  
    args:　　指代的是调用真实对象某个方法时接受的参数。

3）.Proxy类的newProxyInstance方法：

public static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,  InvocationHandler h)  throws IllegalArgumentException

loader:　　一个ClassLoader对象，定义了由哪个ClassLoader对象来对生成的代理对象进行加载。  
    interfaces:　　一个Interface对象的数组，表示的是我将要给我需要代理的对象提供一组什么接口，如果我提供了一组接口给    它，那么这个代理对象就宣称实现了该接口(多态)，这样我就能调用这组接口中的方法了。  
    h:　　一个InvocationHandler对象，表示的是当我这个动态代理对象在调用方法的时候，会关联到哪一个InvocationHandler对    象上。

二.实现动态代理的方法

1）.具体有如下四步骤：

1. 通过实现 InvocationHandler 接口创建自己的调用处理器；   
2. 通过为 Proxy 类指定 ClassLoader 对象和一组 interface 来创建动态代理类；   
3. 通过反射机制获得动态代理类的构造函数，其唯一参数类型是调用处理器接口类型；   
4. 通过构造函数创建动态代理类实例，构造时调用处理器对象作为参数被传入。

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
    // 其内部通常包含指向委托类实例的引用，用于真正执行分派转发过来的方法调用
    InvocationHandler handler = new InvocationHandlerImpl(..); 
    
    // 通过 Proxy 为包括 Interface 接口在内的一组接口动态创建代理类的类对象
    Class clazz = Proxy.getProxyClass(classLoader, new Class[] { Interface.class, ... }); 
    
    // 通过反射从生成的类对象获得构造函数对象
    Constructor constructor = clazz.getConstructor(new Class[] { InvocationHandler.class }); 
    
    // 通过构造函数对象创建动态代理类实例
    Interface Proxy = (Interface)constructor.newInstance(new Object[] { handler });

实际使用过程更加简单，因为 Proxy 的静态方法 newProxyInstance 已经为我们封装了步骤 2 到步骤 4 的过程，所以简化后的过程如下

// InvocationHandlerImpl 实现了 InvocationHandler 接口，并能实现方法调用从代理类到委托类的分派转发
    InvocationHandler handler = new InvocationHandlerImpl(..); 
    
    // 通过 Proxy 直接创建动态代理类实例
    Interface proxy = (Interface)Proxy.newProxyInstance( classLoader, 
         new Class[] { Interface.class }, 
         handler );

三.实现案例

1）.定义了一个Subject类型的接口，为其声明了两个方法

package org.zhq.proxy;
    /**
     * @author 作者 hq.zheng:
     * @version 创建时间：2018-9-11 上午9:24:42
     * 类说明
     */
    public interface Subject {
    	public void rent();
    	public void hello(String str);
    }

2）.接着，定义了一个类来实现这个接口

package org.zhq.proxy;
    /**
     * @author 作者 hq.zheng:
     * @version 创建时间：2018-9-11 上午9:27:13
     * 类说明
     */
    public class RealSubject implements Subject {
    
    	@Override
    	public void rent() {
    		System.out.println("I want to rent my house");
    	}
    
    	@Override
    	public void hello(String str) {
    		System.out.println("hello:"+str);
    	}
    
    }

3）.定义一个动态代理类

package org.zhq.proxy;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    
    /**
     * @author 作者 hq.zheng:
     * @version 创建时间：2018-9-11 上午9:29:40
     * 类说明
     */
    public class DynamicProxy implements InvocationHandler {
    	//这个就是我们要代理的真实对象
    	private Object subject;
    	//构造方法，给我们要代理的真实对象赋初值
    	public DynamicProxy(Object subject){
    		this.subject=subject;
    	}
    	@Override
    	public Object invoke(Object proxy, Method method, Object[] args)
    			throws Throwable {
    		//在代理真实对象前我们可以添加一些自己的操作
    		System.out.println("before rent house");
    		System.out.println("Method:"+method);
    		//当代理对象调用真实对象的方法时，其会自动的跳转到代理对象关联的handler对象的invoke方法来进行调用
    		method.invoke(subject, args);
    		//在代理真实对象后我们也可以添加一些自己的操作
    		System.out.println("after rent house");
    		return null;
    	}
    
    }

4）.最后定义Client类

package org.zhq.proxy;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Proxy;
    
    
    /**
     * @author 作者 hq.zheng:
     * @version 创建时间：2018-9-11 上午9:39:54
     * 类说明
     */
    public class Client {
    	public static void main(String[] args) {
    		//我们要代理的真实对象
    		Subject realSubject=new RealSubject();
    		//我们要代理哪个真实对象，就将该对象传进去，最后通过该真实对象来调用其方法的
    		InvocationHandler handler=new DynamicProxy(realSubject);
    		/*
             * 通过Proxy的newProxyInstance方法来创建我们的代理对象，我们来看看其三个参数
             * 第一个参数 handler.getClass().getClassLoader() ，我们这里使用handler这个类的ClassLoader对象来加载我们的代理对象
             * 第二个参数realSubject.getClass().getInterfaces()，我们这里为代理对象提供的接口是真实对象所实行的接口，表示我要代理的是该真实对象，这样我就能调用这组接口中的方法了
             * 第三个参数handler， 我们这里将这个代理对象关联到了上方的 InvocationHandler 这个对象上
             */
    		Subject subject=(Subject) Proxy.newProxyInstance(handler.getClass().getClassLoader(), realSubject.getClass().getInterfaces(), handler);
    		System.out.println(subject.getClass().getName());
    		subject.rent();
    		subject.hello("world");
    	}
    
    }

5）.运行结果

![70][]

6）.分析结果

1.我们首先来看看 $Proxy0 这东西，我们看到，这个东西是由 System.out.println(subject.getClass().getName()); 这条语句打印出来的，那么为什么我们返回的这个代理对象的类名是这样的呢？

通过 Proxy.newProxyInstance 创建的代理对象是在jvm运行时动态生成的一个对象，它并不是我们的InvocationHandler类型，也不是我们定义的那组接口的类型，而是在运行是动态生成的一个对象，并且命名方式都是这样的形式，以$开头，proxy为中，最后一个数字表示对象的标号。

2.为什么我们这里可以将其转化为Subject类型的对象？

在newProxyInstance这个方法的第二个参数上，我们给这个代理对象提供了一组什么接口，那么我这个代理对象就会实现了这组接口，这个时候我们当然可以将这个代理对象强制类型转化为这组接口中的任意一个，因为这里的接口是Subject类型，所以就可以将其转化为Subject类型了。

3.为什么执行了invoke？

通过代理对象来调用实现的那种接口中的方法，这个时候程序就会跳转到由这个代理对象关联到的 handler 中的invoke方法去执行，而我们的这个 handler 对象又接受了一个 RealSubject类型的参数，表示我要代理的就是这个真实对象，所以此时就会调用 handler 中的invoke方法去执行

[70]: /images/20220513/de2d5accb27645c4bac6ec115f47d2da.png