反射之动态代理的概述和实现

朱雀 2022-06-15 01:50 137阅读 0赞

## 动态代理概述 ##

* 代理：本来应该自己做的事情，请了别人来做，被请的人就是代理对象。

* 动态代理：在程序运行过程中产生的这个对象,而程序运行过程中产生对象其实就是我们刚才反射讲解的内容，

所以，动态代理其实就是通过反射来生成一个代理
     * 在Java中java.lang.reflect包下提供了一个Proxy类和一个InvocationHandler接口，

通过使用这个类和接口就可以生成动态代理对象。

JDK提供的代理只能针对接口做代理。我们有更强大的代理cglib，Proxy类中的方法创建动态代理类对象

## 接口 InvocationHandler ##

所有已知实现类： 
    CompositeDataInvocationHandler, EventHandler,
    MBeanServerInvocationHandler, RemoteObjectInvocationHandler

public interface InvocationHandler 
    InvocationHandler 是代理实例的调用处理程序 实现的接口。 
    每个代理实例都具有一个关联的调用处理程序。
    对代理实例调用方法时，将对方法调用进行编码并将其指派到它的调用处理程序的 invoke 方法。

Object invoke(Object proxy, Method method,Object[] args) throws Throwable
     在代理实例上处理方法调用并返回结果。
     在与方法关联的代理实例上调用方法时，将在调用处理程序上调用此方法。 
     参数：
     proxy - 在其上调用方法的代理实例(被代理的对象)
     method - 对应于在代理实例上调用的接口方法的 Method 实例。(就是我们反射所获取的方法)
     args - 包含传入代理实例上方法调用的参数值的对象数组，如果接口方法不使用参数，则为 null。(我们方法的参数就是一个可变数组)
     返回：
     从代理实例的方法调用返回的值。

## 类 Proxy ##

java.lang.Object
    ——java.lang.reflect.Proxy
    所有已实现的接口：Serializable 
    public class Proxy extends Object implements SerializableProxy 
    提供用于创建动态代理类和实例的静态方法，它还是由这些方法创建的所有动态代理类的超类。

public static Object newProxyInstance( ClassLoader loader,  Class<?>[] interfaces, InvocationHandler h)  throws IllegalArgumentException
      返回一个指定接口的代理类实例，该接口可以将方法调用指派到指定的调用处理程序
      参数：
     loader - 定义代理类的类加载器(被代理类?的类加载器:?.getClass().getClassLoader())
     interfaces - 代理类要实现的接口列表(被代理类?实现的所有接口列表:?.getClass().getInterfaces())
     h - 指派方法调用的调用处理程序 (InvocationHandler的具体实例)
     返回：
     一个带有代理类的指定调用处理程序的代理实例，它由指定的类加载器定义，并实现指定的接口

案例

package 动态代理;
    
    public interface User {
    	
    	public void add();
    	
    	public void delete();
    }

package 动态代理;
    
    public class UserImp implements User{
    
    	@Override
    	public void add() {
    		//System.out.println("权限校验");
    		System.out.println("添加功能");
    		//System.out.println("日志记录");
    	}
    
    	@Override
    	public void delete() {
    		//System.out.println("权限校验");
    		System.out.println("删除功能");
    		//System.out.println("日志记录");
    	}
    }

**InvocationHandler的接口实例**

package 动态代理;
    
    import java.lang.reflect.InvocationHandler;
    import java.lang.reflect.Method;
    
    public class MyInvocationHandler implements InvocationHandler {
    	
    	//把被代理的对象传进来
    	private Object target;
    	
    	//为了接受被代理的对象
    	public MyInvocationHandler(Object target) {
    		this.target = target;
    	}
    	@Override
    	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    		
    		System.out.println("权限校验");
    		method.invoke(target, args);//执行被代理target对象的方法
    		System.out.println("日志记录");
    		return null;//
    	}
    
    }

测试

package 动态代理;
    import java.lang.reflect.Proxy;
    
    public class test {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		
    		UserImp ui = new UserImp();
    		ui.add();
    		ui.delete();
    		
    		System.out.println("-------------------------------");
    		
    		MyInvocationHandler m = new MyInvocationHandler(ui);
    		User u = (User)Proxy.newProxyInstance(ui.getClass().getClassLoader(), ui.getClass().getInterfaces(), m);
    		u.add();
    		u.delete();
    		
    	}
    
    }

在写一个案例

1.student接口

package 动态代理;
    
    public interface Student {
    	public void login();
    	
    	public void submit();
    }

2.实现student接口的实例StudentImp

package 动态代理;
    
    public class StudentImp implements Student {
    
    	@Override
    	public void login() {
    		System.out.println("登录");
    	}
    
    	@Override
    	public void submit() {
    		System.out.println("提交");
    	}
    
    }

3.写一个类实现InvocationHandler接口并补充这个类的构造方法以便传入被代理的对象,上面已经写好了

StudentImp si = new StudentImp();//创建被代理对象

MyInvocationHandler n = new MyInvocationHandler(si);//初始化被代理对象的处理方法

Student s = (Student)Proxy.newProxyInstance(si.getClass().getClassLoader(), si.getClass().getInterfaces(), n);//创建动态代理类

s.login();//调用动态代理类的方法
    s.submit()