标签：int 切面 System 面向 AOP println out public result

面向切面AOP

1. 场景模拟

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

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

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;
    }
}

创建带日志功能的实现类CalculatorLogImpl

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

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

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

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

提出问题

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

对核心业务有干扰，导致程序员在开发核心功能时分散了注意力
附加功能分散在各个业务功能的方法中，不利于维护统一

解决思路：解耦合，让核心代码与日志分离

目的就是为了减少非业务代码对业务代码的干扰！有利于统一维护。

2. 代理模式

开始->调用代理对象->调用目标方法->目标方法把结果返回代理对象->代理对象把返回值返回给最初的调用者。

生活中的代理：

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

2.1 静态代理

静态代理能够实现代码的解耦，但是由于代码写死了，完全不具备灵活性，因此这并不是一个很好的方案。

创建静态代理

public class CalculatorStaticProxy implements Calculator{
    //被代理的目标对象要穿递过来
    private Calculator calculator;
    public CalculatorStaticProxy(Calculator calculator){
        this.calculator = calculator;
    }

    @Override
    public int add(int i, int j) {
        //输出日志
        System.out.println("[日志] add方法开始了，参数是 " + i + "," + j);
        //调用核心业务
        int result = calculator.add(i,j);
        //输出日志
        System.out.println("[日志] add方法结束了，结果是 " + result);
        return result;
    }

    @Override
    public int sub(int i, int j) {
        return 0;
    }

    @Override
    public int mul(int i, int j) {
        return 0;
    }

    @Override
    public int div(int i, int j) {
        return 0;
    }
}

提出进一步的需求：将日志功能集中到一个代理类中，将来有任何日志需求，都通过一个代理类来实现。这就是需要使用动态代理技术。

2.2 动态代理

调用流程：调用代理类->操作前->调用核心代码->调用后->结束

生产代理工厂ProxyFactory：

package com.lily;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.util.Arrays;

public class ProxyFactory {
    //创建一个目标对象
    private Object target;

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

    //创建一个方法，返回一个代理对象
    public Object getProxy() {
        /**
         * Proxy.newProxyInstance(ClassLoader loader, Class<?>[] interfaces, InvocationHandler handler);
         *
         * ClassLoader loader:加载动态生成代理类的类加载器
         * interfaces:目标对象实现的所有接口class类型的数组
         * handler:设置代理对象它实现目标对象方法的过程
         */
        ClassLoader classLoader = this.target.getClass().getClassLoader();
        Class<?>[] interfaces = target.getClass().getInterfaces();
        var invocationHandler = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                /**
                 * proxy:代理对象
                 * method:代理对象要实现的方法
                 * args:method方法当中的参数
                 */
                //调用方法前输出
                System.out.println("[动态代理][日志]" + method.getName() + ", 参数:" + Arrays.toString(args));
                Object result = method.invoke(target, args);
                //调用方法后输出
                System.out.println("[动态代理][日志]" + method.getName() + ", 结果:" + result);
                return result;
            }
        };
        return Proxy.newProxyInstance(classLoader, interfaces, invocationHandler);
    }
}

创建测试类测试：

public class Main {
    public static void main(String[] args) {
        //创建代理对象
        ProxyFactory proxyFactory = new ProxyFactory(new CalculatorImpl());
        //调用方法
        Calculator proxy = (Calculator)proxyFactory.getProxy();
        proxy.add(1,2);
    }
}

结果如下：

[动态代理][日志]add, 参数:[1, 2]
方法内部 result =3
[动态代理][日志]add, 结果:3

Process finished with exit code 0

3 AOP概念以及相关术语

AOP(Aspect Oriented Programming)是一种设计思想，面向横切面编程。它以通过预编译的方法和运行期动态代理方式实现，在不修改源代码的情况下，给程序动态统一添加额外功能的一种技术。利用AOP可以对各个部分进行隔离，进一步降低耦合度。

每一个横切关注点要做的事情都需要写一个方法来实现，这样的方法称之为通知方法。

前置通知：在被代理的目标方法前执行
返回通知：在被代理的目标方法成功结束后执行
异常通知：在被代理的目标方法异常结束后执行
后置通知：在被代理的目标方法最终结束执行
环绕通知：使用tay...catch...finally结构围绕整个被代理的目标方法，包括上面四种通知对应的位置。

4. 基于注解的AOP

AOP底层使用的就是动态代理，其中分为两类：

JDK动态代理->适用于有接口的情况->生成接口实现类的代理对象。
cglib动态代理->适用于没有接口的情况->通过继承被代理的目标类，生成子类代理对象。

AspectJ->是AOP框架，Spring只是借用了AspectJ当中的注解实现了AOP功能。

引入如下依赖：

<!-- https://mvnrepository.com/artifact/org.springframework/spring-aop -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>6.0.2</version>
        </dependency>

        <!-- https://mvnrepository.com/artifact/org.springframework/spring-aspects -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>6.0.2</version>
        </dependency>

创建切面类LogAspect并配置

package com.lily;

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;

@Component
@Aspect //  表示这是一个切面类
public class LogAspect {
    //设置切入点和通知类型
    /**
     * 通知类型：前置@Before(value="切入点表达式")
     * 返回@AfterReturning  异常@AfterThrowing  后置@After  环绕@Around
     */
    /**
     * 切入点表达式：
     * execution(方法权限修饰符 方法返回值 方法所在类的全类名(实现类).方法名(参数列表) )
     */
    @Before(value = "execution(public int com.lily.CalculatorImpl.add(..))")
    public void beforeMethod(JoinPoint joinPoint) {
        System.out.println("前置通知，参数名称:" + joinPoint.getArgs().toString());
    }

    @After(value = "execution(public int com.lily.CalculatorImpl.*(..))")
    public void afterMethod(JoinPoint joinPoint) {
        System.out.println("后置通知,方法名称:" + joinPoint.getSignature().getName());
    }


    @AfterReturning(value = "execution(public int com.lily.CalculatorImpl.*(..))", returning = "result")
    public void afterReturing(JoinPoint joinPoint, Object result) {
        System.out.println("返回通知,结果为:" + result);
    }

    @AfterThrowing(value = "execution(* com.lily.CalculatorImpl.*(..))", throwing = "exceptionMessage")
    public void afterThrowing(JoinPoint joinPoint, Throwable exceptionMessage) {
        System.out.println("异常通知,异常信息" + exceptionMessage);
    }

    @Around(value = "execution(* com.lily.CalculatorImpl.*(..))")
    public void around(JoinPoint joinPoint) {
        System.out.println("环绕信息");
    }
}

开启启AspectJ自动代理，为目标对象生成代理：

@ComponentScan("com.lily")
@EnableAspectJAutoProxy //开启AspectJ自动代理，为目标对象生成代理
public class Main {
    public static void main(String[] args) {

    }
}

package com.lily;

import org.springframework.stereotype.Component;

@Component
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;
    }
}

重用切入点表达式

由于程序中出现了大量重复的表达式，因此我们可以重用切入点表达式：

声明

@Pointcut(value = "execution(* com.lily.CalculatorImpl.*(..))")
    public void pointCut(){}

使用

//如果在同一个切面（同一个文件下）：
@After(value = "pointCut()")
public void afterMethod(JoinPoint joinPoint) {
    System.out.println("后置通知,方法名称:" + joinPoint.getSignature().getName());
}

//如果不在同一个切面（同一个文件下）：
@After(value = "com.lily.LogAspectpointCut()")
public void afterMethod(JoinPoint joinPoint) {
    System.out.println("后置通知,方法名称:" + joinPoint.getSignature().getName());
}

切面的优先级：

外面的优先级高于里面
@Order(较小的数)：优先级高；@Order(较大的数)：优先级低

5. 基于XML的AOP

实现

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:content="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">


    <!-- 开启组件扫描 -->
    <content:component-scan base-package="com.lily"></content:component-scan>
    <!--配置AOP五种通知-->
    <aop:config>
        <!-- 配置切面类 -->
        <aop:aspect ref="logAspect">
            <!-- 配置切入点 -->
            <aop:pointcut id="pointCut" expression="execution(* com.lily.CalculatorImpl.*(..))"/>
            <!-- 配置5种通知类型 -->
            <aop:before method="beforeMethod" pointcut-ref="pointCut"></aop:before>
            <aop:after method="afterMethod" pointcut-ref="pointCut"></aop:after>
            <aop:after-returning method="afterReturing" returning="result" pointcut-ref="pointCut"></aop:after-returning>
            <aop:after-throwing method="afterThrowing" throwing="exceptionMessage" pointcut-ref="pointCut"></aop:after-throwing>
            <aop:before method="around" pointcut-ref="pointCut"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>

标签：int,切面,System,面向,AOP,println,out,public,result
From： https://www.cnblogs.com/lilyflower/p/18056317

4_面向切面AOP