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

本文链接：https://blog.csdn.net/m0_59281987/article/details/127680817

复习：

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

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

新课：

AOP

一 . 准备工作

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

2 .导入依赖

<packaging>jar</packaging>

<dependencies>
    <!-- junit测试 -->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.12</version>
        <scope>test</scope>
    </dependency>
</dependencies>

二 .场景模拟

声明接口

第一步声明计算器接口 Calculator ，包含加减乘除的抽象方法

com.atguigu.spring.proxy.Calculator

package com.atguigu.spring.proxy;

public interface Calculator {

    int add(int i, int j);
    int sub(int i, int j);
    int mul(int i, int j);
    int div(int i, int j);
    
}

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

package com.atguigu.spring.proxy;

public class CalculatorImpl implements Calculator{
    @Override
    public int add(int i, int j) {
        System.out.println("[日志] add 方法开始了，参数是：" + i + "," + j);
        int result = i + j;
        System.out.println("方法内部 result = " + result);
        System.out.println("[日志] add 方法结束了，结果是：" + result);
        return result;

    }

    @Override
    public int sub(int i, int j) {
        System.out.println("[日志] sub 方法开始了，参数是：" + i + "," + j);
        int result = i - j;
        System.out.println("方法内部 result = " + result);
        System.out.println("[日志] sub 方法结束了，结果是：" + result);
        return result;
    }

    @Override
    public int mul(int i, int j) {
        System.out.println("[日志] mul 方法开始了，参数是：" + i + "," + j);
        int result = i * j;
        System.out.println("方法内部 result = " + result);
        System.out.println("[日志] mul 方法结束了，结果是：" + result);
        return result;
    }

    @Override
    public int div(int i, int j) {
        System.out.println("[日志] div 方法开始了，参数是：" + i + "," + j);
        int result = i / j;
        System.out.println("方法内部 result = " + result);
        System.out.println("[日志] div 方法结束了，结果是：" + result);
        return result;
    }
}

提出问题

①现有代码缺陷

针对带日志功能的实现类，我们发现有如下缺陷：

对核心业务功能有干扰，导致程序员在开发核心业务功能时分散了精力

附加功能分散在各个业务功能方法中，不利于统一维护

②解决思路

解决这两个问题，核心就是：解耦。我们需要把附加功能从业务功能代码中抽取出来。

③困难

解决问题的困难：要抽取的代码在方法内部，靠以前把子类中的重复代码抽取到父类的方式没法解决。

所以需要引入新的技术。

三 .代理模式

1 . 概念

①介绍

二十三种设计模式中的一种，属于结构型模式。它的作用就是通过提供一个代理类，让我们在调用目标方法的时候，不再是直接对目标方法进行调用，而是通过代理类间接调用。让不属于目标方法核心逻辑的代码从目标方法中剥离出来—— 解耦。调用目标方法时先调用代理对象的方法，减少对目标方法的调用和打扰，同时让附加功能能够集中在一起也有利于统一维护。

以前没用代理之前

使用代理后：

什么叫做代理模式：

我们对于目标对象然后创建一个他所对应的代理对象每一次在访问目标对象的时候现在有了代理模式就不会直接访问目标对象我们是通过代理对象然后间接的访问目标对象然后在代理对象中会直接调用目标对象实现功能的过程，然后这个时候，我闪就可以在代理对象中来控制目标对象方法的执行我们就可以在目标方法执行的前后或是执行的过程中，去加入一些额外的代码，也就是额外的操作

在不改变目标方法（对象）的基础上通过代理对象添加一些额外的操作

②生活中的代理

广告商找大明星拍广告需要经过经纪人

合作伙伴找大老板谈合作要约见面时间需要经过秘书

房产中介是买卖双方的代理

③相关术语

代理：将非核心逻辑剥离出来以后，封装这些非核心逻辑的类、对象、方法。

目标：被代理 “ 套用 ” 了非核心逻辑代码的类、对象、方法。

2. 静态代理

创建静态代理类： CalculatorStaticProxy

package com.atguigu.spring.proxy;

/**
 * Date:2022/7/4
 * Author:ybc
 * Description:
 */
public class CalculatorStaticProxy implements Calculator {

    private CalculatorImpl target;

    public CalculatorStaticProxy(CalculatorImpl target) {
        this.target = target;
    }

    @Override
    public int add(int i, int j) {
        System.out.println("日志，方法：add，参数："+i+","+j);
        int result = target.add(i, j);
        System.out.println("日志，方法：add，结果："+result);
        return result;
    }

    @Override
    public int sub(int i, int j) {
        System.out.println("日志，方法：sub，参数："+i+","+j);
        int result = target.sub(i, j);
        System.out.println("日志，方法：sub，结果："+result);
        return result;
    }

    @Override
    public int mul(int i, int j) {
        System.out.println("日志，方法：mul，参数："+i+","+j);
        int result = target.mul(i, j);
        System.out.println("日志，方法：mul，结果："+result);
        return result;
    }

    @Override
    public int div(int i, int j) {
        System.out.println("日志，方法：div，参数："+i+","+j);
        int result = target.div(i, j);
        System.out.println("日志，方法：div，结果："+result);
        return result;
    }
}

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

package com.atguigu.spring.proxy;

/**
 * Date:2022/7/4
 * Author:ybc
 * Description:
 */
public class CalculatorImpl implements Calculator {
    @Override
    public int add(int i, int j) {
        int result = i + j;
        System.out.println("方法内部，result："+result);
        return result;
    }

    @Override
    public int sub(int i, int j) {
        int result = i - j;
        System.out.println("方法内部，result："+result);
        return result;
    }

    @Override
    public int mul(int i, int j) {
        int result = i * j;
        System.out.println("方法内部，result："+result);
        return result;
    }

    @Override
    public int div(int i, int j) {
        int result = i / j;
        System.out.println("方法内部，result："+result);
        return result;
    }
}

测试：

public class ProxyTest {

    @Test
    public void testProxy(){
        CalculatorStaticProxy proxy = new CalculatorStaticProxy(new CalculatorImpl());
        proxy.add(1, 2);
    }

}

静态代理确实实现了解耦，但是由于代码都写死了，完全不具备任何的灵活性。就拿日志功能来

说，将来其他地方也需要附加日志，那还得再声明更多个静态代理类，那就产生了大量重复的代

码，日志功能还是分散的，没有统一管理。

提出进一步的需求：将日志功能集中到一个代理类中，将来有任何日志需求，都通过这一个代理

类来实现。这就需要使用动态代理技术了。

3. 动态代理

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

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

生产代理对象的工厂类：

这里听不懂的话可以回去复习如下知识：

这里面要复习一下内部类和反射设计模式 jvm

可以去看宋红康Javase 反射阶段的动态代理

public class ProxyFactory {

    private Object target;

    public ProxyFactory(Object target) {
        this.target = target;
    }

    public Object getProxy(){
        /**
         * ClassLoader loader：指定加载动态生成的代理类的类加载器
         * Class[] interfaces：获取目标对象实现的所有接口的class对象的数组
         * InvocationHandler h：设置代理类中的抽象方法如何重写
         */
        ClassLoader classLoader = this.getClass().getClassLoader();
        Class<?>[] interfaces = target.getClass().getInterfaces();
        InvocationHandler h = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                Object result = null;
                try {
                    System.out.println("日志，方法："+method.getName()+"，参数："+ Arrays.toString(args));
                    //proxy表示代理对象，method表示要执行的方法，args表示要执行的方法到的参数列表
                    result = method.invoke(target, args);
                    System.out.println("日志，方法："+method.getName()+"，结果："+ result);
                } catch (Exception e) {
                    e.printStackTrace();
                    System.out.println("日志，方法："+method.getName()+"，异常："+ e);
                } finally {
                    System.out.println("日志，方法："+method.getName()+"，方法执行完毕");
                }
                return result;
            }
        };
        return Proxy.newProxyInstance(classLoader, interfaces, h);
    }
}

测试类

public class ProxyTest {

    @Test
    public void testProxy(){
   /*     CalculatorStaticProxy proxy = new CalculatorStaticProxy(new CalculatorImpl());
        proxy.add(1, 2);*/

        ProxyFactory proxyFactory = new ProxyFactory(new CalculatorImpl());
        Calculator proxy = (Calculator) proxyFactory.getProxy();
        proxy.add(1,2);
       //proxy.div(1,0);

    }

}

public class ProxyTest {

    @Test
    public void testProxy(){
   /*     CalculatorStaticProxy proxy = new CalculatorStaticProxy(new CalculatorImpl());
        proxy.add(1, 2);*/

        ProxyFactory proxyFactory = new ProxyFactory(new CalculatorImpl());
        Calculator proxy = (Calculator) proxyFactory.getProxy();
       // proxy.add(1,2);
       proxy.div(1,0);

    }

}

总结：

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