为其他对象提供一种代理，以控制对这个对象的访问，代理对象在客户端和目标对象之间起到了中介的作用。
适用于：
保护目标对象；
增强目标对象。
优点：
将代理对象和真实被调用的目标对象分离；
降低耦合，拓展性好；
保护目标对象，增强目标对象。
缺点：
造成类的数目增加，增加复杂度；
客户端和目标对象增加代理对象，会造成处理速度变慢。
静态代理
通过在代码中显式地定义了一个代理类，在代理类中通过同名的方法对目标对象的方法进行包装，客户端通过调用代理类的方法来调用目标对象的方法。
举个静态代理的例子：
新建一个派的制作接口PieService：
public interface PieServcie {
void makePie();
}
创建其实现类PieServiceImpl：
public class PieServiceImpl implements PieServcie{
public void makePie() {
System.out.println("制作🥗派");
}
}
要对PieServiceImpl的makePie方法增强，我们需要创建一个代理对象PieServiceProxy：
public class PieServiceProxy {
private PieServcie pieServcie;
public void makePie() {
beforeMethod();
pieServcie = new PieServiceImpl();
pieServcie.makePie();
afterMethod();
}
private void beforeMethod() {
System.out.println("准备材料");
}
private void afterMethod() {
System.out.println("保鲜");
}
}
在PieServiceProxy中我们创建了一个和PieServcie一致的同名方法makePie，方法内部调用了PieServiceImpl的makePie方法，并且在方法调用前调用了代理类的beforeMethod方法，方法调用后调用了代理类的afterMethod方法。
创建客户端Application，测试：
public class Application {
public static void main(String[] args) {
PieServiceProxy proxy = new PieServiceProxy();
proxy.makePie();
}
}
输出：
准备材料
制作🥗派
保鲜
这个例子的UML图如下：
动态代理
JDK的动态代理只能代理接口，通过接口的方法名在动态生成的代理类中调用业务实现类的同名方法。
静态代理的缺点就是每需要代理一个类，就需要手写对应的代理类。这个问题可以用动态代理来解决。举个动态代理的例子：
新建冰淇淋制作接口IceCreamService：
public interface IceCreamService {
void makeIceCream(String fruit);
}
实现类IceCreamServiceImpl：
public class IceCreamServiceImpl implements IceCreamService {
public void makeIceCream(String fruit) {
System.out.println("制作" + fruit + "🍦");
}
}
现在需要对IceCreamServiceImpl进行代理增强，如果使用静态代理，我们需要编写一个IceCreamServiceImplProxy类，使用动态代理的话，我们可以动态生成对应的代理类。
创建DynamicProxy：
public class DynamicProxy implements InvocationHandler {
// 代理的目标对象
private Object object;
public DynamicProxy(Object object) {
this.object = object;
}
public Object proxy() {
Class<?> clazz = object.getClass();
// 生成代理对象
return Proxy.newProxyInstance(clazz.getClassLoader(),
clazz.getInterfaces(), this);
}
/**
* @param proxy 动态生成的代理对象
* @param method 代理方法
* @param args 代理方法的方法参数
* @return 结果
* @throws Throwable
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
return null;
}
}
动态代理类通过实现InvocationHandler的invoke方法实现，proxy用于生成代理对象。剩下的步骤和静态代理类似，完善DynamicProxy：
public class DynamicProxy implements InvocationHandler {
// 代理的目标对象
private Object object;
public DynamicProxy(Object object) {
this.object = object;
}
public Object proxy() {
Class<?> clazz = object.getClass();
// 生成代理对象
return Proxy.newProxyInstance(clazz.getClassLoader(),
clazz.getInterfaces(), this);
}
/**
* @param proxy 动态生成的代理对象
* @param method 代理方法
* @param args 代理方法的方法参数
* @return 结果
* @throws Throwable
*/
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
beforeMethod(object);
// 反射执行代理对象的目标方法
Object result = method.invoke(object, args);
afterMethod(object);
return result;
}
private void beforeMethod(Object object) {
if (object instanceof PieServcie) {
System.out.println("准备派的材料");
} else if (object instanceof IceCreamService) {
System.out.println("准备冰淇淋材料");
} else {
throw new RuntimeException("暂不支持代理" + object.getClass() + "类型");
}
}
private void afterMethod(Object object) {
if (object instanceof PieServcie) {
System.out.println("保鲜派");
} else if (object instanceof IceCreamService) {
System.out.println("保鲜冰淇淋");
} else {
throw new RuntimeException("暂不支持代理" + object.getClass() + "类型");
}
}
}
创建客户端Application测试：
public class Application {
public static void main(String[] args) {
PieServcie pieServiceDynamicProxy = (PieServcie) new DynamicProxy(new PieServiceImpl()).proxy();
pieServiceDynamicProxy.makePie();
System.out.println("-----------------");
IceCreamService iceCreamServiceDynamicProxy = (IceCreamService) new DynamicProxy(new IceCreamServiceImpl()).proxy();
iceCreamServiceDynamicProxy.makeIceCream("🍓");
}
}
结果：
准备派的材料
制作🥗派
保鲜派
-----------------
准备冰淇淋材料
制作🍓🍦
保鲜冰淇淋
可以看到，通过动态代理我们实现了目标方法增强，并且不需要手写目标类的代理对象。
CGLib代理
通过继承来实现，生成的代理类就是目标对象类的子类，通过重写业务方法来实现代理。
Spring对代理模式的拓展
当Bean有实现接口时，使用JDK动态代理；
当Bean没有实现接口时，使用CGLib代理。
可以通过以下配置强制使用CGLib代理：
spring:
aop:
proxy-target-class: true
