• 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{
    @Override
    public 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)+"毫秒");
    }
    @Override
    public 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)+"毫秒");
    }
    @Override
    public 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. 代码没有得到复用

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

    1. package com.example.proxy.service;
    2.  
    3. /**
    4.  * @author hrui
    5.  * @date 2023/9/25 8:42
    6.  */
    7. public class OrderServiceImpl implements OrderService{
    8.     @Override
    9.     public void generate() {
    10.         //模拟生成订单耗时
    11.         try {
    12.             Thread.sleep(1234);
    13.             System.out.println("订单已生产");
    14.         } catch (InterruptedException e) {
    15.             e.printStackTrace();
    16.         }
    17.     }
    18.  
    19.     @Override
    20.     public void modify() {
    21.         try {
    22.             Thread.sleep(2222);
    23.             System.out.println("订单已修改");
    24.         } catch (InterruptedException e) {
    25.             e.printStackTrace();
    26.         }
    27.     }
    28.  
    29.     @Override
    30.     public void detail() {
    31.         try {
    32.             Thread.sleep(3333);
    33.             System.out.println("查看订单详情");
    34.         } catch (InterruptedException e) {
    35.             e.printStackTrace();
    36.         }
    37.     }
    38. }

    让子类继承重写方法

    1. package com.example.proxy.service;
    2.  
    3. /**
    4.  * @author hrui
    5.  * @date 2023/9/25 9:48
    6.  */
    7. public class OrderServiceImplSub extends OrderServiceImpl{
    8.  
    9.     @Override
    10.     public void generate() {
    11.         long start = System.currentTimeMillis();
    12.         super.generate();
    13.         long end = System.currentTimeMillis();
    14.         System.out.println("耗时"+(end-start)+"毫秒");
    15.     }
    16.  
    17.     @Override
    18.     public void modify() {
    19.         long start = System.currentTimeMillis();
    20.         super.modify();
    21.         long end = System.currentTimeMillis();
    22.         System.out.println("耗时"+(end-start)+"毫秒");
    23.     }
    24.  
    25.     @Override
    26.     public void detail() {
    27.         long start = System.currentTimeMillis();
    28.         super.detail();
    29.         long end = System.currentTimeMillis();
    30.         System.out.println("耗时"+(end-start)+"毫秒");
    31.     }
    32. }

    测试

    上面的解决方式解决了OCP

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

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

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

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

    1. package com.example.proxy.service;
    2.  
    3. import com.sun.org.apache.xpath.internal.operations.Or;
    4.  
    5. /**
    6.  * @author hrui
    7.  * @date 2023/9/25 10:24
    8.  */
    9. public class OrderServiceProxy implements OrderService{//和目标对象应有相同的行为动作,因此实现OrderService
    10.  
    11.  
    12.     OrderService target;
    13.  
    14.     public OrderServiceProxy(OrderService target) {
    15.         this.target = target;
    16.     }
    17.  
    18.     @Override
    19.     public void generate() {//代理方法
    20.         long start = System.currentTimeMillis();
    21.         target.generate();
    22.         long end = System.currentTimeMillis();
    23.         System.out.println("耗时"+(end-start)+"毫秒");
    24.     }
    25.  
    26.     @Override
    27.     public void modify() {
    28.         long start = System.currentTimeMillis();
    29.         target.modify();
    30.         long end = System.currentTimeMillis();
    31.         System.out.println("耗时"+(end-start)+"毫秒");
    32.     }
    33.  
    34.     @Override
    35.     public void detail() {
    36.         long start = System.currentTimeMillis();
    37.         target.detail();
    38.         long end = System.currentTimeMillis();
    39.         System.out.println("耗时"+(end-start)+"毫秒");
    40.     }
    41. }

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

    解决了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 目标方法上的实参

             */
            @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)+"毫秒");
                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;
    }

    @Override
    public 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() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Object retValue = method.invoke(target, args);
                return retValue;
            }
        });
    }
}

    1. package com.example.proxy.client;
    2.  
    3. import com.example.proxy.service.OrderService;
    4. import com.example.proxy.service.OrderServiceImpl;
    5. import com.example.proxy.util.JDKProxyUtil;
    6.  
    7. import java.lang.reflect.InvocationHandler;
    8. import java.lang.reflect.Method;
    9. import java.lang.reflect.Proxy;
    10.  
    11. /**
    12.  * @author hrui
    13.  * @date 2023/9/25 12:41
    14.  */
    15. public class Client {
    16.     public static void main(String[] args) {
    17.         //创建目标对象
    18.         OrderService target=new OrderServiceImpl();
    19.         //创建代理对象
    20.         /**
    21.          * 1.newProxyInstance 翻译为:新建代理对象
    22.          *      也就是说,通过调用这个方法可以创建代理对象
    23.          *      本质上newProxyInstance()方法的执行,做了两件事:
    24.          *          第一件事:在内存中动态的生成了一个代理类的字节码class
    25.          *          第二件事:new对象了.通过内存中生成的代理类.class,实例化了代理对象
    26.          * 2.关于newProxyInstance()方法的三个重要的参数,每一个含义,有什么用?
    27.          *  第一个参数:ClassLoader loader
    28.          *          类加载器 必须得和目标类得类加载器一样
    29.          *  第二个参数:Class<?>[] interfaces
    30.          *          代理类和目标类要实现同一个接口或同一些接口.
    31.          *  第三个参数:InvocationHandler h
    32.          *          InvocationHandler是一个接口,称为调用处理器,需要传一个InvocationHandler实现类
    33.          *          调用处理器不会导致类爆炸,这里就不做处理,以匿名内类方式
    34.          */
    35.         //Object proxyObj = Proxy.newProxyInstance("类加载器", "代理类要实现的接口", "调用处理器");
    36. //        OrderService proxyObj = (OrderService)Proxy.newProxyInstance(target.getClass().getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
    37. //
    38. //
    39. //
    40. //            /*
    41. //            1.invoke方法是JDK负责调用的
    42. //            2.当代理对象调用代理方法的时候,注册在InvocationHandler调用处理器当中的invoke()会被调用
    43. //            3.invoke方法内的三个参数:
    44. //                    invoke()是JDK负责调用的.参数是JDK传过来的.
    45. //                    第一个参数:Object proxy 代理对象的引用,这个参数使用较少
    46. //                    第二个参数:Method method 目标对象上的目标方法.(要执行的目标方法就是它)
    47. //                    第三个参数:Object[] args 目标方法上的实参
    48. //
    49. //             */
    50. //            @Override
    51. //            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    52. //                long start = System.currentTimeMillis();
    53. //                Object retValue = method.invoke(target, args);
    54. //                long end = System.currentTimeMillis();
    55. //                System.out.println("耗时"+(end-start)+"毫秒");
    56. //                //如果代理对象调用代理方法之后,需要返回结果的话,invoke方法必须将目标对象的目标方法的返回结果继续返回
    57. //                return retValue;
    58. //            }
    59. //        });
    60.  
    61.         OrderService proxyObj = (OrderService)JDKProxyUtil.newProxyInstance(target);
    62.         //调用代理对象的代理方法
    63.         //注意:调用代理对象的代理方法的时候,如果你要做增强的话,目标对象的目标方法得保证执行(在执行前后添加功能增强功能)
    64.         proxyObj.generate();
    65.         proxyObj.modify();
    66.         proxyObj.detail();
    67.         String name = proxyObj.getName();
    68.         System.out.println(name);
    69.     }
    70. }

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

    使用CGLIB需要引入依赖

    
    cglib
    cglib
    3.3.0

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

  • 相关阅读:
    刷题笔记 1
    VSCODE编译阿里云HaaS程序时遇到Win32file找不到错误怎么办？
    Springboot发送邮件
    【SpringBoot】静态资源导入探究
    基于SpringBoot+Vue+uniapp的OA办公系统(源码+lw+部署文档+讲解等)
    Mybatis学习笔记1 Mybatis入门
    Alibaba 架构师纯手工打造神仙级“2022 版 Java 面试手册”
    Python基于Excel数据加以反距离加权空间插值并掩膜图层
    Vue 源码解读（8）—— 编译器 之 解析（下）
    渲染引擎的资源加载优化
  • 原文地址：https://blog.csdn.net/tiantiantbtb/article/details/133265952