一、概述

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

使用情况
●调试
●远程方法调用
相比静态代理优点：
抽象角色中（接口）声明的所有方法都被转移到调用处理器一个集中的方法中处理

🔥相关API

Proxy ：专门完成代理的操作类，是所有动态代理类的父类
通过此类为一个或多个接口动态地生成实现类
提供用于创建动态代理类和动态代理对象的静态方法
●static Class<?> getProxyClass(ClassLoader loader, Class<?>… interfaces)
创建一个动态代理类所对应的Class对象
●static Object newProxyInstance(ClassLoader loader, Class<?>[] interfaces,InvocationHandler h)
直接创建一个动态代理对象

二、原理

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

🔥动态代理步骤

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

public Object invoke(Object theProxy, Method method, Object[] params) throws Throwable{
try{
	Object retval = method.invoke(targetObj, params);
		// Print out the result
		System.out.println(retval);
		return retval;
	}catch (Exception exc){}
}

在这里插入图片描述

创建被代理的类以及接口

在这里插入图片描述

通过Proxy的静态方法
newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)
创建一个Subject接口代理

RealSubject target = new RealSubject();
// Create a proxy to wrap the original implementation
DebugProxy proxy = new DebugProxy(target);
// Get a reference to the proxy through the Subject interface
Subject sub = (Subject) Proxy.newProxyInstance(
Subject.class.getClassLoader(),new Class[] { Subject.class }, proxy);

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

String info = sub.say(“Peter", 24);
System.out.println(info);

三、动态代理与AOP

AOP代理可代替目标对象，AOP代理包含了目标对象的全部方法

AOP代理中的方法与目标对象的方法存在差异：
AOP代理内的方法可以在执行目标方法之前、之后插入一些通用处理

下面介绍一种更实用的动态代理机制：
在这里插入图片描述

改进为
在这里插入图片描述
改进后：代码段1、代码段2、代码段3和深色代码段分离开了，但代码段1、2、3又和一个特定的方法A耦合了！最理想的效果是：代码块1、2、3既可以执行方法A，又无须在程序中以硬编码的方式直接调用深色代码的方法

public class DogUtil{
	public void method1(){
		System.out.println("===== 模拟通用方法一 =====");
	}
	public void method2(){
		System.out.println("===== 模拟通用方法二 =====");
	}
}

public class MyInvocationHandler implements InvocationHandler{
		// 需要被代理的对象
		private Object target;
		public void setTarget(Object target){
				this.target = target;}
// 执行动态代理对象的所有方法时，都会被替换成执行如下的invoke方法
		public Object invoke(Object proxy, Method method, Object[] args)
				throws Exception{
				DogUtil du = new DogUtil();
				// 执行DogUtil对象中的method1。
				du.method1();
				// 以target作为主调来执行method方法
				Object result = method.invoke(target , args);
				// 执行DogUtil对象中的method2。
				du.method2();
				return result;}}

public class MyProxyFactory{
		// 为指定target生成动态代理对象
		public static Object getProxy(Object target)
				throws Exception{
				// 创建一个MyInvokationHandler对象
				MyInvokationHandler handler =
				new MyInvokationHandler();
				// 为MyInvokationHandler设置target对象
				handler.setTarget(target);
				// 创建、并返回一个动态代理对象
				return
Proxy.newProxyInstance(target.getClass().getClassLoader()
		, target.getClass().getInterfaces() , handler);
		}
}

public class Test{
	public static void main(String[] args)
			throws Exception{
			// 创建一个原始的HuntingDog对象，作为target
			Dog target = new HuntingDog();
			// 以指定的target来创建动态代理
			Dog dog = (Dog)MyProxyFactory.getProxy(target);
			dog.info();
			dog.run();
	}
}