Spring学习笔记11 GoF代理模式

Spring学习笔记10 JdbcTemplate_biubiubiu0706的博客-CSDN博客

新建个maven模块  static-proxy

演示静态代理

订单接口

测试

需求:统计每个业务方法的耗时

package com.example.proxy.service;/*** @author hrui* @date 2023/9/25 8:42*/
public class OrderServiceImpl implements OrderService{@Overridepublic void generate() {long start = System.currentTimeMillis();//模拟生成订单耗时try {Thread.sleep(1234);System.out.println("订单已生产");} catch (InterruptedException e) {e.printStackTrace();}long end = System.currentTimeMillis();System.out.println("耗时"+(end-start)+"毫秒");}@Overridepublic void modify() {long start = System.currentTimeMillis();try {Thread.sleep(2222);System.out.println("订单已修改");} catch (InterruptedException e) {e.printStackTrace();}long end = System.currentTimeMillis();System.out.println("耗时"+(end-start)+"毫秒");}@Overridepublic void detail() {long start = System.currentTimeMillis();try {Thread.sleep(3333);System.out.println("查看订单详情");} catch (InterruptedException e) {e.printStackTrace();}long end = System.currentTimeMillis();System.out.println("耗时"+(end-start)+"毫秒");}
}

上面确实实现了功能

但是硬编码,在每个业务接口中的每一个业务方法中直接添加统计耗时的程序:

缺点:

1.违背了OCP开闭原则

2. 代码没有得到复用

--------------------------------------------------------------------------------------------------------------------

package com.example.proxy.service;/*** @author hrui* @date 2023/9/25 8:42*/
public class OrderServiceImpl implements OrderService{@Overridepublic void generate() {//模拟生成订单耗时try {Thread.sleep(1234);System.out.println("订单已生产");} catch (InterruptedException e) {e.printStackTrace();}}@Overridepublic void modify() {try {Thread.sleep(2222);System.out.println("订单已修改");} catch (InterruptedException e) {e.printStackTrace();}}@Overridepublic void detail() {try {Thread.sleep(3333);System.out.println("查看订单详情");} catch (InterruptedException e) {e.printStackTrace();}}
}

让子类继承重写方法

package com.example.proxy.service;/*** @author hrui* @date 2023/9/25 9:48*/
public class OrderServiceImplSub extends OrderServiceImpl{@Overridepublic void generate() {long start = System.currentTimeMillis();super.generate();long end = System.currentTimeMillis();System.out.println("耗时"+(end-start)+"毫秒");}@Overridepublic void modify() {long start = System.currentTimeMillis();super.modify();long end = System.currentTimeMillis();System.out.println("耗时"+(end-start)+"毫秒");}@Overridepublic void detail() {long start = System.currentTimeMillis();super.detail();long end = System.currentTimeMillis();System.out.println("耗时"+(end-start)+"毫秒");}
}

测试

上面的解决方式解决了OCP

但是这种方式会导致耦合度很高.因为采用了继承关系.继承关系是一种耦合度非常高的关系,不建议使用.

另外代码还是没有得到复用

再看下面的解决方式(静态代理)

OrderService是公共接口     OrderServiceImpl是目标对象

package com.example.proxy.service;import com.sun.org.apache.xpath.internal.operations.Or;/*** @author hrui* @date 2023/9/25 10:24*/
public class OrderServiceProxy implements OrderService{//和目标对象应有相同的行为动作,因此实现OrderServiceOrderService target;public OrderServiceProxy(OrderService target) {this.target = target;}@Overridepublic void generate() {//代理方法long start = System.currentTimeMillis();target.generate();long end = System.currentTimeMillis();System.out.println("耗时"+(end-start)+"毫秒");}@Overridepublic void modify() {long start = System.currentTimeMillis();target.modify();long end = System.currentTimeMillis();System.out.println("耗时"+(end-start)+"毫秒");}@Overridepublic void detail() {long start = System.currentTimeMillis();target.detail();long end = System.currentTimeMillis();System.out.println("耗时"+(end-start)+"毫秒");}
}

上面使用了静态代理,目标对象和代理对象都需要实现或者继承公共接口,因为需要相同的动作或行为.

解决了OCP原则问题,使用静态代理可以降低耦合度

缺点:如果程序中有多个这样业务类,那么都需要代理,类爆炸 不好维护

可以使用动态代理解决类爆炸问题

动态代理还是代理模式,只不过添加了字节码生成技术,可以在内存中动态的生成.class字节码,这个字节码就是代理类----->在内存中动态的生成字节码技术

SpringAOP底层用的不是JDK就是CGLIB

动态代理:

1.JDK代理:目标类必须实现接口(缺陷) 

2.CGLIB代理:无要求,且性能比JDK代理好.底层是通过继承实现的(因动态在内存中生成,无所谓耦合度了)----->底层还有一个小而快的字节码处理框架ASM

3.javassist:动态代理

java的反射包下有个Proxy        java.lang.reflect.Proxy(JDK内置的)--->帮我们在内存中动态生成字节码

新建模块  dynamic-proxy

还是同一个需求,统计每个业务方法的耗时

直接开始写

具体代码

package com.example.proxy.client;import com.example.proxy.service.OrderService;
import com.example.proxy.service.OrderServiceImpl;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;/*** @author hrui* @date 2023/9/25 12:41*/
public class Client {public static void main(String[] args) {//创建目标对象OrderService target=new OrderServiceImpl();//创建代理对象/*** 1.newProxyInstance 翻译为:新建代理对象*      也就是说,通过调用这个方法可以创建代理对象*      本质上newProxyInstance()方法的执行,做了两件事:*          第一件事:在内存中动态的生成了一个代理类的字节码class*          第二件事:new对象了.通过内存中生成的代理类.class,实例化了代理对象* 2.关于newProxyInstance()方法的三个重要的参数,每一个含义,有什么用?*  第一个参数:ClassLoader loader*          类加载器 必须得和目标类得类加载器一样*  第二个参数:Class<?>[] interfaces*          代理类和目标类要实现同一个接口或同一些接口.*  第三个参数:InvocationHandler h*          InvocationHandler是一个接口,称为调用处理器,需要传一个InvocationHandler实现类*          调用处理器不会导致类爆炸,这里就不做处理,以匿名内类方式*///Object proxyObj = Proxy.newProxyInstance("类加载器", "代理类要实现的接口", "调用处理器");OrderService proxyObj = (OrderService)Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {/*1.invoke方法是JDK负责调用的2.当代理对象调用代理方法的时候,注册在InvocationHandler调用处理器当中的invoke()会被调用3.invoke方法内的三个参数:invoke()是JDK负责调用的.参数是JDK传过来的.第一个参数:Object proxy 代理对象的引用,这个参数使用较少第二个参数:Method method 目标对象上的目标方法.(要执行的目标方法就是它)第三个参数:Object[] args 目标方法上的实参*/@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {long start = System.currentTimeMillis();Object retValue = method.invoke(target, args);long end = System.currentTimeMillis();System.out.println("耗时"+(end-start)+"毫秒");return null;}});//调用代理对象的代理方法//注意:调用代理对象的代理方法的时候,如果你要做增强的话,目标对象的目标方法得保证执行(在执行前后添加功能增强功能)proxyObj.generate();proxyObj.modify();proxyObj.detail();}
}

上面是匿名内部类写法

而且关于返回值  返回了是null

返回null,但程序依旧是可以跑的   但上面所有的方法是无返回值的,如果是有返回值的会如何

新增一个有返回值的

程序还是可以跑

但返回值能不能拿到

下面是用个实现类的写法

package com.example.proxy.client;import com.example.proxy.service.OrderService;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;/*** @author hrui* @date 2023/9/25 15:57*/
public class AInvocationHandler implements InvocationHandler {OrderService target;public AInvocationHandler(OrderService target) {this.target = target;}@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Object invoke = method.invoke(target, method);return invoke;}
}

JDK动态代理工具类封装

public class JDKProxyUtil {public static Object newProxyInstance(Object target){//底层还是调用JDK的动态代理return Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {@Overridepublic Object invoke(Object proxy, Method method, Object[] args) throws Throwable {Object retValue = method.invoke(target, args);return retValue;}});}
}

package com.example.proxy.client;import com.example.proxy.service.OrderService;
import com.example.proxy.service.OrderServiceImpl;
import com.example.proxy.util.JDKProxyUtil;import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;/*** @author hrui* @date 2023/9/25 12:41*/
public class Client {public static void main(String[] args) {//创建目标对象OrderService target=new OrderServiceImpl();//创建代理对象/*** 1.newProxyInstance 翻译为:新建代理对象*      也就是说,通过调用这个方法可以创建代理对象*      本质上newProxyInstance()方法的执行,做了两件事:*          第一件事:在内存中动态的生成了一个代理类的字节码class*          第二件事:new对象了.通过内存中生成的代理类.class,实例化了代理对象* 2.关于newProxyInstance()方法的三个重要的参数,每一个含义,有什么用?*  第一个参数:ClassLoader loader*          类加载器 必须得和目标类得类加载器一样*  第二个参数:Class<?>[] interfaces*          代理类和目标类要实现同一个接口或同一些接口.*  第三个参数:InvocationHandler h*          InvocationHandler是一个接口,称为调用处理器,需要传一个InvocationHandler实现类*          调用处理器不会导致类爆炸,这里就不做处理,以匿名内类方式*///Object proxyObj = Proxy.newProxyInstance("类加载器", "代理类要实现的接口", "调用处理器");
//        OrderService proxyObj = (OrderService)Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
//
//
//
//            /*
//            1.invoke方法是JDK负责调用的
//            2.当代理对象调用代理方法的时候,注册在InvocationHandler调用处理器当中的invoke()会被调用
//            3.invoke方法内的三个参数:
//                    invoke()是JDK负责调用的.参数是JDK传过来的.
//                    第一个参数:Object proxy 代理对象的引用,这个参数使用较少
//                    第二个参数:Method method 目标对象上的目标方法.(要执行的目标方法就是它)
//                    第三个参数:Object[] args 目标方法上的实参
//
//             */
//            @Override
//            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
//                long start = System.currentTimeMillis();
//                Object retValue = method.invoke(target, args);
//                long end = System.currentTimeMillis();
//                System.out.println("耗时"+(end-start)+"毫秒");
//                //如果代理对象调用代理方法之后,需要返回结果的话,invoke方法必须将目标对象的目标方法的返回结果继续返回
//                return retValue;
//            }
//        });OrderService proxyObj = (OrderService)JDKProxyUtil.newProxyInstance(target);//调用代理对象的代理方法//注意:调用代理对象的代理方法的时候,如果你要做增强的话,目标对象的目标方法得保证执行(在执行前后添加功能增强功能)proxyObj.generate();proxyObj.modify();proxyObj.detail();String name = proxyObj.getName();System.out.println(name);}
}

CGLIB既可以代理接口,又可以代理类.底层采用继承的方式实现,所以被代理的目标类不能使用final修饰

使用CGLIB需要引入依赖

<dependency><groupId>cglib</groupId><artifactId>cglib</artifactId><version>3.3.0</version>
</dependency>

 其实CGLIB和开头写的继承方式差不多,只不过一个是需要写的而CGLIB是制动内存中生成的