Java学习笔记——设计模式：动态代理

引入

代理设计模式的原理：使用一个代理将对象包装起来，然后用该代理对象取代原始对象。任何对原始对象的调用都要通过代理。代理对象决定是否以及何时将方法调用转到原始对象上。

上一篇设计模式讲到的代理模式属于静态代理，特征是代理类和目标对象的类都是在编译期间确定下来，不利于程序的扩展。同时，每一个代理类只能为一个接口服务，这样一来程序开发中必然产生过多的代理。最好可以通过一个代理类完成全部的代理功能。

简介

动态代理是指客户通过代理类来调用其它对象的方法，并且是在程序运行时根据需要动态创建目标类的代理对象。

动态代理使用场合：

• 调试
• 远程方法调用

步骤

1. 创建一个实现接口InvocationHandler的类，它必须实现invoke方法，以完成代理的具体操作。

   class MyInvocationHandler implements InvocationHandler{
   
       Object obj; // 实现了接口的被代理类的对象的声明
   
       // (1)给被代理类的对象实例化；(2)返回一个代理类的对象
       public Object blind(Object obj) {
           this.obj = obj;
           return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), this);
       }
   
       // 当通过代理类的对象发起对被重写的方法的调用时，都会转换为对如下的invoke方法的调用
       @Override
       public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
           // method方法的返回值
           Object returnVal = method.invoke(obj, args);
           return returnVal;
       }
   
   }
   

2. 创建被代理的类以及接口

   interface Subject{
       void action();
   }
   
   // 被代理类
   class RealSubject implements Subject{
   
       @Override
       public void action() {
           System.out.println("我是被代理类，记得要执行我哦！");
       }
   
   }
   

3. 通过Proxy的静态方法newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h) 创建一个Subject接口代理（在步骤1的代码中体现）

4. 通过 Subject代理调用RealSubject实现类的方法

   // 1.创建被代理类的对象
   RealSubject real = new RealSubject();
   // 2.创建一个实现了InvacationHandler接口的类的对象
   MyInvocationHandler handler = new MyInvocationHandler();
   // 3.调用blind()方法，动态的返回一个同样实现了real所在类实现的接口Subject的代理类的对象。
   Subject subject = (Subject) handler.blind(real); // 此时subject就是代理类的对象
   subject.action(); // 转到对InvacationHandler接口的实现类的invoke方法的调用
   

AOP

Aspect Oriented Programming(AOP)，面向切面编程。

使用Proxy生成一个动态代理时，往往并不会凭空产生一个动态代理，这样没有太大的意义。通常都是为指定的目标对象生成动态代理。

这种动态代理在AOP中被称为AOP代理，AOP代理可代替目标对象，AOP代理包含了目标对象的全部方法。但AOP代理中的方法与目标对象的方法存在差异：AOP代理里的方法可以在执行目标方法之前、之后插入一些通用处理。

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 接口
interface StudentInfoService{
	void findInfo(String studentName);
	void showRole();
}

// 被代理类
class StudentInfoServiceImpl implements StudentInfoService{

	@Override
	public void findInfo(String studentName) {
		System.out.println("The name is " + studentName);
	}

	@Override
	public void showRole() {
		System.out.println("班干部");
	}
	
}

class MyHandler implements InvocationHandler {

	private Object obj;
	
	public void bind(Object obj) {
		this.obj = obj;
	}
	
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		System.out.println("======调用日志方法" + method.getName() + "======");
		Object returnVal = method.invoke(obj, args);
		System.out.println("======日志方法" + method.getName() + "调用结束======");
		return returnVal;
	}
	
}

class AOPFactory{
	// 动态创建创建一个代理类的对象
	public static Object getProxyInstance(Object obj) {
		MyHandler handler = new MyHandler();
		handler.bind(obj);
		return Proxy.newProxyInstance(obj.getClass().getClassLoader(), obj.getClass().getInterfaces(), handler);
	}
}

public class TestAOP {
	public static void main(String[] args) {
		// 创建一个被代理类的对象
		StudentInfoServiceImpl serviceImpl = new StudentInfoServiceImpl();
		// 动态获取一个代理类的对象
		StudentInfoService studentInfoService = (StudentInfoService) AOPFactory.getProxyInstance(serviceImpl);
		// 通过代理类的对象调用重写的抽象方法
		studentInfoService.findInfo("runner");
		studentInfoService.showRole();
	}
}

运行结果：
======调用日志方法findInfo======
The name is runner
======日志方法findInfo调用结束======
======调用日志方法showRole======
班干部
======日志方法showRole调用结束======

总结

核心在于实现InvocationHandler接口和Proxy类的静态方法newProxyInstance，前者负责与被代理类关联（重写的invoke方法是关键），后者负责动态生成一个代理类。这两者再通过newProxyInstance的第三个参数关联起来，从而实现了动态代理。

AOP是动态代理的一种应用，其核心在于实现InvocationHandler的invoke方法，method.invoke(obj, args)是动态的，其前后可能有其他的硬编码。

---

相关阅读：
Java学习笔记——Java反射机制