一、基础概念

二、UML类图

1、静态代理类图

2、动态代理类图

三、角色设计

四、案例分析

1、静态代理

2、JDK动态代理

3、Cglib动态代理

五、总结

一、基础概念

代理模式是一种结构型设计模式，它用一个代理对象来封装一个目标对象，通常是为了对目标对象的访问进行增强或控制。主要作用是扩展目标对象的功能，比如延迟加载、访问控制、远程访问和日志记录等。

二、UML类图

1、静态代理类图

2、动态代理类图

三、角色设计

角色	描述
抽象主题角色	定义了实际主题和代理对象必须实现的接口
实际主题角色	实现了抽象主题中的业务逻辑，是代理对象所代表的实际对象
代理角色	内部含有对实际主题的引用，从而可以操作实际主题对象；代理对象提供与实际主题相同的接口，其接口的实现方式可以在执行前后做一些额外的操作
客户端角色	通过抽象主题角色访问实际主题角色，这样可以在任何时刻都用代理对象替换实际主题对象

四、案例分析

1、静态代理

静态代理在程序编译期间就已经存在代理类的情况下产生代理关系，这种代理关系在运行前就已经确定。

其具体实现方式如下：

1、定义一个接口及其实现类，作为被代理对象。

2、创建一个代理类，实现与原对象相同的接口。

3、在代理类中维护一个被代理对象的引用。

4、代理类中的方法实现，会调用被代理对象中的对应方法，并在前后添加其他处理。

5、客户端通过代理类访问被代理对象。

静态代理的特点：

1、代理类和被代理类实现相同的接口。

2、代理关系在程序运行前就确定了。

3、编译时生成代理类，执行效率高。

4、但不易维护，如果接口增加方法、代理类和被代理类都要修改。

5、灵活性较差，代理类只能为一个被代理类服务。

静态代理模式可以解决一些简单的代码封装、容错、访问控制等问题,但灵活性和复用性较差。

我们通过一个简单的的Demo来实现静态代理，代码如下：

定义一个图片接口（抽象主题角色），默认包含一个显示图片的方法：

interface Image {void display();}

定义具体的图片实体（实体角色）去实现这个接口：

public class RealImage implements Image {@Override public void display() {System.out.println("显示图片");}}

定义一个图片代理类（代理角色）：

public class ProxyImage implements Image{private RealImage image;public ProxyImage() {image = new RealImage();}@Overridepublic void display() {System.out.println("代理开始...");image.display();System.out.println("代理结束...");}}

客户端：

public class Client {public static void main(String[] args) {ProxyImage proxyImage = new ProxyImage();proxyImage.display();}
}

运行结果如下：

2、JDK动态代理

JDK动态代理是在程序运行期间通过反射机制动态创建代理类及其对象，从而实现对目标对象的代理。动态代理的实现步骤：

1、定义一个接口及其实现类，作为被代理对象。

2、创建一个代理类，该类实现InvocationHandler接口。

3、实现invoke方法，调用被代理对象的方法，并在前后添加其他处理。

4、使用Proxy类的newProxyInstance方法生成被代理对象的代理类。

5、客户端通过代理类访问被代理对象的方法。

动态代理的特点：

1、代理类的生成时机是在程序运行期间，不需要实现接口。

2、动态代理类可以服务任何接口实现类，灵活性强。

3、使用反射机制，执行效率较低。

4、可以动态改变代理的逻辑实现。

动态代理通过在运行时动态创建代理,更加灵活,可以按需实现代理类，避免了代理类膨胀问题，但执行效率相对较低。

下面我们提供一个Demo案例来实现，代码如下：

定义一个Hello接口，并提供默认的sayHello方法：

public interface IHello {void sayHello();}

定义一个具体的Hello实体去实现接口并重写sayHello方法：

public class Hello implements IHello {@Overridepublic void sayHello() {System.out.println("Hello World!");}}

创建动态代理类：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;// 动态代理类
public class DynamicProxy {// 维护目标对象private Object target;// 构造方法,传入目标对象public DynamicProxy(Object target) {this.target = target;}//给目标对象动态生成一个代理对象public Object getProxyInstance() {//利用反射里面一个类Proxy调用newProxyInstance方法/** 这个方法三个参数* 1.ClassLoader loader:当前目标对象的类加载器* 2.Class<?>[] interface:目标对象实现的接口，使用泛型方法确认类型* 3.InvocationHandler h:事情处理，执行目标对象方法时，会触发* 事情处理器方法* */return Proxy.newProxyInstance(target.getClass().getClassLoader(),target.getClass().getInterfaces(),new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("代理开始...");Object res = method.invoke(target, args);System.out.println("代理结束...");return res;}});}}

客户端：

public class Client {public static void main(String[] args) {IHello target = new Hello();IHello proxyInstance = (IHello)new DynamicProxy(target).getProxyInstance();proxyInstance.sayHello();}
}

运行结果如下：

3、Cglib动态代理

Cglib代理和JDK动态代理的区别如下：

1、JDK动态代理只能代理实现了接口的类，而Cglib可以代理未实现任何接口的类。

2、JDK动态代理是通过反射机制生成一个实现了代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。而Cglib动态代理是通过生成目标类的子类来实现的。

3、JDK动态代理效率略低于Cglib动态代理，因为Cglib是通过修改字节码生成子类来避免反射调用。

4、JDK动态代理只需实现InvocationHandler接口，Cglib需要实现MethodInterceptor接口。

5、Cglib需要依赖cglib库，JDK动态代理是Java自带的。

6、JDK动态代理可直接代理标识了接口的类，Cglib可代理未标识接口的类。

如果要代理的类实现了接口可以直接用JDK动态代理，如果要代理的类没有接口则需要用Cglib。Cglib通过生成子类提高了效率,但也更复杂。在非必要时建议使用JDK动态代理。二者思想都是一样的，都是在运行时动态生成代理类。

这里我搭建了个SpringBoot项目，Spring里面集成了对应Jar包，主要代理类这边进行了变动，代码如下：

package com.example.api;import org.springframework.cglib.proxy.Enhancer;
import org.springframework.cglib.proxy.MethodInterceptor;
import org.springframework.cglib.proxy.MethodProxy;import java.lang.reflect.Method;//代理对象，Cglib代理（和jdk动态代理不同的是目标对象不需要实现接口）
public class DynamicProxy implements MethodInterceptor {//维护一个目标对象private Object target;//构造器，传入一个被代理的对象public DynamicProxy(Object target) {this.target = target;}//返回一个代理对象:是 target 对象的代理对象public Object getProxyInstance() {//1. 创建一个工具类Enhancer enhancer = new Enhancer();//2. 设置父类enhancer.setSuperclass(target.getClass());//3. 设置回调函数enhancer.setCallback(this);//4. 创建子类对象，即代理对象return enhancer.create();}//重写intercept方法，会调用目标对象的方法@Overridepublic Object intercept(Object arg0, Method method, Object[] args, MethodProxy arg3) throws Throwable {System.out.println("Cglib代理模式开始...");Object returnVal = method.invoke(target, args);System.out.println("Cglib代理模式结束...");return returnVal;}
}

客户端：

@SpringBootTest
class ApiApplicationTests {@Testvoid contextLoads() {//创建目标对象IHello target = new Hello();//获取到代理对象，并且将目标对象传递给代理对象Hello proxyInstance = (Hello) new DynamicProxy(target).getProxyInstance();//执行代理对象的方法，触发intecept 方法，从而实现对目标对象的调用proxyInstance.sayHello();}}

运行结果如图：