• (续)SSM整合之spring笔记(AOP 动态代理)(P094—P098)


    复习:

    把第三方的类库交给IOC来管理,这个时候就没办法用注解的方式 因为我们的jar里面发的都是callss文件,字节码文件  我们看到的结果也是idea反编译的结果  这个文件是只读  是无法进行修改的  所以只能用xml 没办法用到注解

    像我们自己创建的类 就可以用注解+扫描的方式来处理

    新课:

    AOP

    一 . 准备工作  

    1 .新建模块spring-proxy       com.atguigu.spring

    2 .导入依赖

    jar
    
    
        
        
            junit
            junit
            4.12
            test
        
    

    二 .场景模拟

    声明接口
     第一步   声明计算器接口 Calculator ,包含加减乘除的抽象方法
    com.atguigu.spring.proxy.Calculator
    
    1. package com.atguigu.spring.proxy;
    2. public interface Calculator {
    3. int add(int i, int j);
    4. int sub(int i, int j);
    5. int mul(int i, int j);
    6. int div(int i, int j);
    7. }
     
     

     第二步 创建实现类 CalculatorImpl      实现implements Calculator 并重写里面的方法

     

    1. package com.atguigu.spring.proxy;
    2. public class CalculatorImpl implements Calculator{
    3. @Override
    4. public int add(int i, int j) {
    5. System.out.println("[日志] add 方法开始了,参数是:" + i + "," + j);
    6. int result = i + j;
    7. System.out.println("方法内部 result = " + result);
    8. System.out.println("[日志] add 方法结束了,结果是:" + result);
    9. return result;
    10. }
    11. @Override
    12. public int sub(int i, int j) {
    13. System.out.println("[日志] sub 方法开始了,参数是:" + i + "," + j);
    14. int result = i - j;
    15. System.out.println("方法内部 result = " + result);
    16. System.out.println("[日志] sub 方法结束了,结果是:" + result);
    17. return result;
    18. }
    19. @Override
    20. public int mul(int i, int j) {
    21. System.out.println("[日志] mul 方法开始了,参数是:" + i + "," + j);
    22. int result = i * j;
    23. System.out.println("方法内部 result = " + result);
    24. System.out.println("[日志] mul 方法结束了,结果是:" + result);
    25. return result;
    26. }
    27. @Override
    28. public int div(int i, int j) {
    29. System.out.println("[日志] div 方法开始了,参数是:" + i + "," + j);
    30. int result = i / j;
    31. System.out.println("方法内部 result = " + result);
    32. System.out.println("[日志] div 方法结束了,结果是:" + result);
    33. return result;
    34. }
    35. }

     

     提出问题

    ①现有代码缺陷
    针对带日志功能的实现类,我们发现有如下缺陷:
    对核心业务功能有干扰,导致程序员在开发核心业务功能时分散了精力
    附加功能分散在各个业务功能方法中,不利于统一维护
    ②解决思路
    解决这两个问题,核心就是:解耦。我们需要把附加功能从业务功能代码中抽取出来。
    ③困难
    解决问题的困难:要抽取的代码在方法内部,靠以前把子类中的重复代码抽取到父类的方式没法解决。
    所以需要引入新的技术。

    三 .代理模式

    1 . 概念

    ①介绍

    二十三种设计模式中的一种,属于结构型模式。它的作用就是通过提供一个代理类,让我们在调用目标 方法的时候,不再是直接对目标方法进行调用,而是通过代理类间接 调用。让不属于目标方法核心逻辑的代码从目标方法中剥离出来—— 解耦 。调用目标方法时先调用代理对象的方法,减少对目标方法的调用和打扰,同时让附加功能能够集中在一起也有利于统一维护。
    以前  没用代理之前
    使用代理后:
    什么叫做代理模式:
    我们对于目标对象  然后创建一个他所对应的代理对象 每一次在访问目标对象的时候  现在有了代理模式 就不会直接访问目标对象   我们是通过代理对象  然后间接的访问目标对象   然后在代理对象中会直接调用目标对象实现功能的过程 ,然后这个时候 ,我闪就可以在代理对象中来控制目标对象方法的执行 我们就可以在目标方法执行的前后或是执行的过程中,去加入一些额外的代码,也就是额外的操作   
    在不改变目标方法(对象)的基础上  通过代理对象添加一些额外的操作  

    ②生活中的代理

    广告商找大明星拍广告需要经过经纪人
    合作伙伴找大老板谈合作要约见面时间需要经过秘书
    房产中介是买卖双方的代理

    ③相关术语

    代理:将非核心逻辑剥离出来以后,封装这些非核心逻辑的类、对象、方法。
    目标:被代理 套用 了非核心逻辑代码的类、对象、方法。

     2.  静态代理

     创建静态代理类: CalculatorStaticProxy

    1. package com.atguigu.spring.proxy;
    2. /**
    3. * Date:2022/7/4
    4. * Author:ybc
    5. * Description:
    6. */
    7. public class CalculatorStaticProxy implements Calculator {
    8. private CalculatorImpl target;
    9. public CalculatorStaticProxy(CalculatorImpl target) {
    10. this.target = target;
    11. }
    12. @Override
    13. public int add(int i, int j) {
    14. System.out.println("日志,方法:add,参数:"+i+","+j);
    15. int result = target.add(i, j);
    16. System.out.println("日志,方法:add,结果:"+result);
    17. return result;
    18. }
    19. @Override
    20. public int sub(int i, int j) {
    21. System.out.println("日志,方法:sub,参数:"+i+","+j);
    22. int result = target.sub(i, j);
    23. System.out.println("日志,方法:sub,结果:"+result);
    24. return result;
    25. }
    26. @Override
    27. public int mul(int i, int j) {
    28. System.out.println("日志,方法:mul,参数:"+i+","+j);
    29. int result = target.mul(i, j);
    30. System.out.println("日志,方法:mul,结果:"+result);
    31. return result;
    32. }
    33. @Override
    34. public int div(int i, int j) {
    35. System.out.println("日志,方法:div,参数:"+i+","+j);
    36. int result = target.div(i, j);
    37. System.out.println("日志,方法:div,结果:"+result);
    38. return result;
    39. }
    40. }

    核心业务类  内部方法  目标方法   目标对象   CalculatorImpl

    1. package com.atguigu.spring.proxy;
    2. /**
    3. * Date:2022/7/4
    4. * Author:ybc
    5. * Description:
    6. */
    7. public class CalculatorImpl implements Calculator {
    8. @Override
    9. public int add(int i, int j) {
    10. int result = i + j;
    11. System.out.println("方法内部,result:"+result);
    12. return result;
    13. }
    14. @Override
    15. public int sub(int i, int j) {
    16. int result = i - j;
    17. System.out.println("方法内部,result:"+result);
    18. return result;
    19. }
    20. @Override
    21. public int mul(int i, int j) {
    22. int result = i * j;
    23. System.out.println("方法内部,result:"+result);
    24. return result;
    25. }
    26. @Override
    27. public int div(int i, int j) {
    28. int result = i / j;
    29. System.out.println("方法内部,result:"+result);
    30. return result;
    31. }
    32. }
    测试: 
    
    1. public class ProxyTest {
    2. @Test
    3. public void testProxy(){
    4. CalculatorStaticProxy proxy = new CalculatorStaticProxy(new CalculatorImpl());
    5. proxy.add(1, 2);
    6. }
    7. }

     

    静态代理确实实现了解耦,但是由于代码都写死了,完全不具备任何的灵活性。就拿日志功能来
    说,将来其他地方也需要附加日志,那还得再声明更多个静态代理类,那就产生了大量重复的代
    码,日志功能还是分散的,没有统一管理。
    提出进一步的需求:将日志功能集中到一个代理类中,将来有任何日志需求,都通过这一个代理
    类来实现。这就需要使用动态代理技术了。

    3. 动态代理

    我们不需要手动去创建代理类  而是通过jdk中,给我们提供的一些方法 一些API  然后动态的为某一个目标类来创建他所对应的动态代理类   也就是说代理类  我们是提前没有的   我们需要JDK为我们提供的API在代码运行的过程中 动态的去帮我们去创建每天目标类所对应的动态代理类 

    所以我们的动态指的是 我们会动态的去生成目标类所对应的代理类

    生产代理对象的工厂类:
    这里听不懂的话 可以回去复习如下知识:
    这里面要复习一下内部类和反射 设计模式  jvm
    可以去看宋红康Javase 反射阶段的动态代理
    1. public class ProxyFactory {
    2. private Object target;
    3. public ProxyFactory(Object target) {
    4. this.target = target;
    5. }
    6. public Object getProxy(){
    7. /**
    8. * ClassLoader loader:指定加载动态生成的代理类的类加载器
    9. * Class[] interfaces:获取目标对象实现的所有接口的class对象的数组
    10. * InvocationHandler h:设置代理类中的抽象方法如何重写
    11. */
    12. ClassLoader classLoader = this.getClass().getClassLoader();
    13. Class[] interfaces = target.getClass().getInterfaces();
    14. InvocationHandler h = new InvocationHandler() {
    15. @Override
    16. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    17. Object result = null;
    18. try {
    19. System.out.println("日志,方法:"+method.getName()+",参数:"+ Arrays.toString(args));
    20. //proxy表示代理对象,method表示要执行的方法,args表示要执行的方法到的参数列表
    21. result = method.invoke(target, args);
    22. System.out.println("日志,方法:"+method.getName()+",结果:"+ result);
    23. } catch (Exception e) {
    24. e.printStackTrace();
    25. System.out.println("日志,方法:"+method.getName()+",异常:"+ e);
    26. } finally {
    27. System.out.println("日志,方法:"+method.getName()+",方法执行完毕");
    28. }
    29. return result;
    30. }
    31. };
    32. return Proxy.newProxyInstance(classLoader, interfaces, h);
    33. }
    34. }

     测试类

    1. public class ProxyTest {
    2. @Test
    3. public void testProxy(){
    4. /* CalculatorStaticProxy proxy = new CalculatorStaticProxy(new CalculatorImpl());
    5. proxy.add(1, 2);*/
    6. ProxyFactory proxyFactory = new ProxyFactory(new CalculatorImpl());
    7. Calculator proxy = (Calculator) proxyFactory.getProxy();
    8. proxy.add(1,2);
    9. //proxy.div(1,0);
    10. }
    11. }

    1. public class ProxyTest {
    2. @Test
    3. public void testProxy(){
    4. /* CalculatorStaticProxy proxy = new CalculatorStaticProxy(new CalculatorImpl());
    5. proxy.add(1, 2);*/
    6. ProxyFactory proxyFactory = new ProxyFactory(new CalculatorImpl());
    7. Calculator proxy = (Calculator) proxyFactory.getProxy();
    8. // proxy.add(1,2);
    9. proxy.div(1,0);
    10. }
    11. }

    总结:

    /**
     * 动态代理有两种:
     * 1、jdk动态代理,要求必须有接口,最终生成的代理类和目标类实现相同的接口
     * 在com.sun.proxy包下,类名为$proxy2
     * 2、cglib动态代理,最终生成的代理类会继承目标类,并且和目标类在相同的包下
     */

     

     
    

  • 相关阅读:
    探索Kimi智能助手:如何用超长文本解锁高效信息处理新境界
    MySQL主从复制与读写分离
    C++ 类和对象篇(四) 构造函数
    Date日期工具类(数据库日期区间问题)
    猴子也能学会的jQuery第十二期——jQuery遍历(上)
    【课外阅读】cpp并发编程实战
    Vue学习第22天——Vuex安装使用详解及案例练习(彻底搞懂vuex)
    6.【图的应用2】有向⽆环图DAG描述表达式、拓扑排序和逆拓扑排序(AOV网)、关键路径(AOE网)
    项目沟通难?信息传递不及时,甘特图来帮你
    三大电商平台(淘宝/京东/阿里巴巴)封装商品详情API接口附代码实例|参数解析
  • 原文地址:https://blog.csdn.net/m0_59281987/article/details/127680817