代理设计模式知识概括

代理模式的基本介绍

代理模式的基本介绍&＃xff1a;

• 代理模式&＃xff1a;为一个对象提供一个替身&＃xff0c;以控制对这个对象的访问。 即通过代理对象访问目标对象。
• 代理对象的好处是&＃xff1a;可以在目标对象实现的基础上&＃xff0c;增强额外的功能操作&＃xff0c;即扩展目标对象的功能。
• 被代理的对象可以是远程对象、 创建开销大的对象或需要安全控制的对象
• 代理模式有不同的形式&＃xff0c;主要有三种&＃xff1a;静态代理、 动态代理 (JDK代理、接口代理)和 Cglib代理 (可以在内存动态的创建对象&＃xff0c;而不需要实现接口&＃xff0c; 他是属于动态代理的范畴) 。

静态代码模式

静态代码模式的基本介绍&＃xff1a;

• 静态代理在使用时&＃xff0c;需要定义接口或者父类&＃xff0c;被代理对象(即目标对象)与代理对象一起实现相同的接口或者是继承相同父类

静态代理应用实例&＃xff1a;

• 具体要求&＃xff1a;
  ①定义一个接口&＃xff1a;ITeacherDao
  ②目标对象TeacherDAO实现接口ITeacherDAO
  ③使用静态代理方式&＃xff0c;就需要在代理对象TeacherDAOProxy中也实现ITeacherDAO
  ④调用的时候通过调用代理对象的方法来调用目标对象
  ⑤特别提醒&＃xff1a;代理对象与目标对象要实现相同的接口&＃xff0c;然后通过调用相同的方法来调用目标对象的方法
• 类图&＃xff1a;
• 代码实现&＃xff1a;

ITeacherDao&＃xff1a;定义抽象的方法(授课)规范

//接口
public interface ITeacherDao {void teach(); // 授课的方法}


TeacherDao&＃xff1a;实现具体的业务功能

public class TeacherDao implements ITeacherDao {&＃64;Overridepublic void teach() {System.out.println(" 老师授课中 。。。。。");}}


TeacherDaoProxy&＃xff1a;代理类&＃xff0c;聚合了一个 ITeacherDao 具体实现类的对象&＃xff0c;在TeacherDaoProxy实现了 ITeacherDao 接口&＃xff0c;并在 teach() 方法中完成代理操作

//代理对象,静态代理
public class TeacherDaoProxy implements ITeacherDao {private ITeacherDao target; // 目标对象&＃xff0c;通过接口来聚合// 构造器public TeacherDaoProxy(ITeacherDao target) {this.target &＃61; target;}&＃64;Overridepublic void teach() {System.out.println("开始代理 完成某些操作。。。。。 ");// 方法target.teach();System.out.println("提交。。。。。");// 方法}}


Client&＃xff1a;客户端

public class Client {public static void main(String[] args) {// 创建目标对象(被代理对象)TeacherDao teacherDao &＃61; new TeacherDao();// 创建代理对象, 同时将被代理对象传递给代理对象TeacherDaoProxy teacherDaoProxy &＃61; new TeacherDaoProxy(teacherDao);// 通过代理对象&＃xff0c;调用到被代理对象的方法// 即&＃xff1a;执行的是代理对象的方法&＃xff0c;代理对象再去调用目标对象的方法teacherDaoProxy.teach();}}


静态代理优缺点&＃xff1a;

• 优点&＃xff1a;在不修改目标对象的功能前提下&＃xff0c;能通过代理对象对目标功能扩展
• 缺点&＃xff1a;因为代理对象需要与目标对象实现一样的接口&＃xff0c;所以会有很多代理类 一旦接口增加方法&＃xff0c;目标对象与代理对象都要维护
• 静态代理是在编译器编写类 &＃xff0c;而动态代理则是内存中生成类。

动态代理模式

动态代理模式的基本介绍:

• 代理对象不需要实现接口&＃xff0c; 但是目标对象要实现接口&＃xff0c; 否则不能用动态代理
• 代理对象的生成&＃xff0c; 是利用JDK的API&＃xff0c;动态的在内存中构建代理对象
• 动态代理也叫做&＃xff1a; JDK代理、 接口代理

JDK中生成代理对象的API:

• 代理类所在包&＃xff1a;java.lang.reflect.Proxy
• JDK实现代理只需要使用newProxyInstance方法&＃xff0c;但是该方法需要接收三个参数&＃xff0c;完整的写法是&＃xff1a;

static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)


动态代理应用实例:

• 应用实例要求:将前面的静态代理改进成动态代理模式(即&＃xff1a;JDK代理模式)
• 类图:
• 代码实现:

ITeacherDao

//接口
public interface ITeacherDao {void teach(); // 授课方法void sayHello(String name);}


TeacherDao&＃xff1a;

public class TeacherDao implements ITeacherDao {&＃64;Overridepublic void teach() {System.out.println(" 老师授课中.... ");}&＃64;Overridepublic void sayHello(String name) {System.out.println("hello " &＃43; name);}}


ProxyFactory&＃xff1a;通过构造器传入被代理对象&＃xff0c;通过 Proxy.newProxyInstance() 方法中的 new InvocationHandler() 匿名内部类实现具体的代理逻辑

public class ProxyFactory {// 维护一个目标对象 , Objectprivate Object target;// 构造器 &＃xff0c; 对target 进行初始化public ProxyFactory(Object target) {this.target &＃61; target;}// 给目标对象 生成一个代理对象public Object getProxyInstance() {// 说明/** public static Object newProxyInstance(ClassLoader loader, Class[] interfaces, InvocationHandler h)* * 1. ClassLoader loader &＃xff1a; 指定当前目标对象使用的类加载器, 获取加载器的方法固定 * 2. Class[] interfaces: 目标对象实现的接口类型&＃xff0c;使用泛型方法确认类型 * 3. InvocationHandler h : 事情处理&＃xff0c;执行目标对象的方法时&＃xff0c;会触发事情处理器方法, 会把当前执行的目标对象方法作为参数传入*/return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(),new InvocationHandler() {&＃64;Override/** proxy&＃xff1a;proxy the proxy instance that the method was invoked on* method&＃xff1a;待调用的目标方法&＃xff08;target 的方法&＃xff09;* args&＃xff1a;方法参数*/public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {System.out.println("JDK代理开始~~");// 反射机制调用目标对象的方法Object returnVal &＃61; method.invoke(target, args);System.out.println("JDK代理提交");return returnVal;}});}}


Client&＃xff1a;

public class Client {public static void main(String[] args) {// 创建目标对象ITeacherDao target &＃61; new TeacherDao();// 给目标对象&＃xff0c;创建代理对象, 可以转成 ITeacherDaoITeacherDao proxyInstance &＃61; (ITeacherDao) new ProxyFactory(target).getProxyInstance();// proxyInstance&＃61;class com.sun.proxy.$Proxy0 内存中动态生成了代理对象System.out.println("proxyInstance&＃61;" &＃43; proxyInstance.getClass());// 通过代理对象&＃xff0c;调用目标对象的方法proxyInstance.teach();proxyInstance.sayHello(" tom ");}}


代码追踪:

• Step into 进入 proxyInstance.sayHello(" tom ");

• 参数 proxy 为代理对象

• 参数 method 为被代理(target)对象中的方法

public final class Method extends Executable {private Class<?> clazz;private int slot;// This is guaranteed to be interned by the VM in the 1.4// reflection implementationprivate String name;private Class<?> returnType;private Class<?>[] parameterTypes;private Class<?>[] exceptionTypes;private int modifiers;// Generics and annotations supportprivate transient String signature;// generic info repository; lazily initializedprivate transient MethodRepository genericInfo;private byte[] annotations;private byte[] parameterAnnotations;private byte[] annotationDefault;private volatile MethodAccessor methodAccessor;


• 参数 args 为方法的形参

Cglib 代理模式

Cglib代理模式的基本介绍:

• 静态代理和JDK代理模式都要求目标对象是实现一个接口&＃xff0c;但是有时候目标对象只是一个单独的对象&＃xff0c;并没有实现任何的接口&＃xff0c;这个时候可使用目标对象子类来实现代理&＃xff0c;这就是Cglib代理
• Cglib代理也叫作子类代理&＃xff0c;它是在内存中构建一个子类对象从而实现对目标对象功能扩展&＃xff0c;有些书也将Cglib代理归属到动态代理
• Cglib是一个强大的高性能的代码生成包&＃xff0c;它可以在运行期扩展java类与实现java接口&＃xff0c;它广泛的被许多AOP的框架使用&＃xff0c;例如Spring
  AOP&＃xff0c;实现方法拦截
• 在AOP编程中如何选择代理模式&＃xff1a;
  ①目标对象需要实现接口&＃xff0c;用JDK代理
  ②目标对象不需要实现接口&＃xff0c;用Cglib代理
• Cglib包的底层是通过使用字节码处理框架ASM来转换字节码并生成新的类

Cglib代理模式实现步骤&＃xff1a;

• 需要引入cglib的jar文件

• 在内存中动态构建子类&＃xff0c; 注意代理的类不能为final&＃xff0c;否则报错java.lang.IllegalArgumentException
• 目标对象的方法如果为final 或 static,那么就不会被拦截&＃xff0c;即不会执行目标对象额外的业务方法

Cglib代理模式应用实例:

• 应用实例要求:将前面的案例用Cglib代理模式实现
• 类图&＃xff1a;
• 代码实现&＃xff1a;

TeacherDao&＃xff1a;被代理类

public class TeacherDao {public String teach() {System.out.println(" 老师授课中 &＃xff0c; 我是cglib代理&＃xff0c;不需要实现接口 ");return "hello";}}


ProxyFactory&＃xff1a;代理工厂类&＃xff0c;用于获取代理对象

public class ProxyFactory implements MethodInterceptor {// 维护一个目标对象private Object target;// 构造器&＃xff0c;传入一个被代理的对象public ProxyFactory(Object target) {this.target &＃61; target;}// 返回一个代理对象: 是 target 对象的代理对象public Object getProxyInstance() {// 1. 创建一个工具类Enhancer enhancer &＃61; new Enhancer();// 2. 设置父类enhancer.setSuperclass(target.getClass());// 3. 设置回调函数enhancer.setCallback(this);// 4. 创建子类对象&＃xff0c;即代理对象return enhancer.create();}// 重写 intercept 方法&＃xff0c;会调用目标对象的方法&＃64;Overridepublic Object intercept(Object arg0, Method method, Object[] args, MethodProxy arg3) throws Throwable {System.out.println("Cglib代理模式 ~~ 开始");Object returnVal &＃61; method.invoke(target, args);System.out.println("Cglib代理模式 ~~ 提交");return returnVal;}}


Client&＃xff1a;客户端

public class Client {public static void main(String[] args) {// 创建目标对象TeacherDao target &＃61; new TeacherDao();// 获取到代理对象&＃xff0c;并且将目标对象传递给代理对象TeacherDao proxyInstance &＃61; (TeacherDao) new ProxyFactory(target).getProxyInstance();// 执行代理对象的方法&＃xff0c;触发intecept 方法&＃xff0c;从而实现 对目标对象的调用String res &＃61; proxyInstance.teach();System.out.println("res&＃61;" &＃43; res);}}


代码追踪&＃xff1a;

• Step into 进入 String res &＃61; proxyInstance.teach();
• 形参 Method 为 public java.lang.String com.atguigu.proxy.cglib.TeacherDao.teach()

public final class Method extends Executable {private Class<?> clazz;private int slot;// This is guaranteed to be interned by the VM in the 1.4// reflection implementationprivate String name;private Class<?> returnType;private Class<?>[] parameterTypes;private Class<?>[] exceptionTypes;private int modifiers;// Generics and annotations supportprivate transient String signature;// generic info repository; lazily initializedprivate transient MethodRepository genericInfo;private byte[] annotations;private byte[] parameterAnnotations;private byte[] annotationDefault;private volatile MethodAccessor methodAccessor;

代理模式(Proxy)的变体

几种常见的代理模式介绍——几种变体&＃xff1a;

• 防火墙代理&＃xff1a;内网通过代理穿透防火墙&＃xff0c;实现对公网的访问
• 缓存代理&＃xff1a;比如&＃xff1a;当请求图片文件等资源时&＃xff0c;先到缓存代理去取&＃xff0c;如果取到资源则ok&＃xff0c;如果取不到资源&＃xff0c;再到公网或者数据库取&＃xff0c;然后缓存
• 远程代理远程对象的本地代表&＃xff0c;通过它可以把远程对象当本地对象来调用。远程代理通过网络和真正的远程对象沟通信息
  
• 同步代理&＃xff1a; 主要使用在多线程编程中&＃xff0c;完成多线程间同步工作