AOP的概述，术语，xml配置以及日志

AOP概述及术语详解

最新推荐文章于 2023-03-31 14:35:22 发布

原创最新推荐文章于 2023-03-31 14:35:22 发布 · 227 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#AOP

分享同时被 2 个专栏收录

28 篇文章

订阅专栏

java

24 篇文章

订阅专栏

文章目录

AOP的概述

AOP(Aspect-Oriented Programming，面向切面编程)：是一种新的方法论，是对传统 OOP(Object-Oriented Programming，面向对象编程)的补充。（OOP是纵向思想，那么AOP就是横向思想） AOP编程操作的主要对象是切面(aspect)，而切面模块化横切关注点。在应用AOP编程时，仍然需要定义公共功能，但可以明确的定义这个功能应用在哪里，以什么方式应用，并且不必修改受影响的类。这样一来横切关注点就被模块化到特殊的类里——这样的类我们通常称之为“切面”。
切面更像是对目标类的一些功能进行扩展，在xml中进行配置，可以做到无声无息的给目标类增加功能，不用的时候注释掉即可

AOP的术语

切面

我们将自己需要插入到目标业务逻辑中的代码模块化，通过AOP使之可以横切多个类的模块，称之为切面。

在Spring AOP配置中切面通常包含三部分：

切面模块本身x
通知
切入点

示例

<!--举个例子  板上钉钉-->
<!-- 目标业务逻辑代码（一块木板） -->
<bean id="calc" class="com.lanou3g.spring.simple.calc.CalcImpl"/>

<!-- 切面模块化对象(代表我们要附加到原始业务逻辑中的代码) （铁钉）-->
<bean id="calcAspect" class="com.lanou3g.spring.simple.calc.CalcAspect" />

<!-- 示例说明： 将切面calcAspect中的代码插入到calc原始业务代码中（把钉子钉进去的步骤） -->
<aop:config>
    <!-- 定义公用的切入点表达式，如果aspect中有多个通知，都可以通过pointcut-ref复用 -->
    <!--expression="execution(* com.lanou3g.spring.simple.calc.CalcImpl.*(..))包括了这个路径下的所有的方法-->
    <aop:pointcut id="all_calc_method" expression="execution(* com.lanou3g.spring.simple.calc.CalcImpl.*(..))" />
    <!--拿到那个铁钉-->
    <aop:aspect ref="calcAspect">
        <!-- 切面包含的通知（什么时间）（什么时候钉）、切入点(什么地点)（在哪儿钉） -->
        <aop:around method="computeTime" pointcut-ref="all_calc_method" />
    </aop:aspect>
</aop:config>

切入点

在 Spring AOP 中，需要使用 AspectJ 的切点表达式来定义切点。

AspectJ 指示器	描述
execution ()	用于匹配连接点的执行方法最常用
args ()	限制连接点的指定参数为指定类型的执行方法
@args ()	限制连接点匹配参数类型由指定注解标注的执行方法
this ()	限制连接点匹配 AOP 代理的 Bean 引用为指定类型的类
target ()	限制连接点匹配特定的执行对象，目标对象是指定的类型
@target ()	限制连接点匹配特定的执行对象，这些对象对应的类要具备指定类型注解
within()	限制连接点匹配指定类型，比如哪个包下，或哪个类里面
@within()	限制连接点匹配指定注释所标注的类型（当使用 Spring AOP 时，方法定义在由指定的注解所标注的类里）

@annotation	限制匹配带有指定注释的连接点

advice通知（要织入的代码）

前置通知（before）
在目标方法调用前通知切面，什么参数也无法获取。也不能终止目标方法执行（唯一的作用可能就是计数，记录通知的次数）

 <aop:before method="beforeM" pointcut-ref="all_calc_method" />

后置(最终)通知 (after)
在目标方法执行结束后通知切面，什么参数也无法获取。无论目标方法是正常执行结束还是抛出异常终止，都会被通知

 <aop:after method="afterFinallyM" pointcut-ref="all_calc_method" />

后置通知（带有返回值的那种）（after returning）
只有在目标方法 正常 执行结束后才会通知，在通知方法中可以获取到方法的返回值

 <aop:after-returning method="afterReturningM" pointcut-ref="all_calc_method" returning="retVal" />

异常通知(after throwing)
只有在目标方法出现异常才会通知，在通知方法中可以获取到抛出的异常信息

<aop:after-throwing method="afterThrowing" pointcut-ref="all_calc_method" throwing="throwable" />

环绕通知（around）
在目标方法执行前、后被通知，可以获取连接点对象(ProceedingJoinPoint这个对象可不得了，可以获得很多，所以最为常用)，该对象可以获取被拦截方法的签名、参数、返回值、包括调用与否)
该方法的返回值，即代表了真正业务逻辑代码的返回值
可以选择终止或正常执行目标方法

 <aop:around method="aroundM" pointcut-ref="all_calc_method" />

连接点

连接点有很多种，比如方法执行期间（开始执行、执行结束、抛出异常）、字段修饰符、字段值被更改…

在Spring AOP中只支持方法连接点(因为Spring AOP底层是通过动态代理实现的)。

连接点与切入点的关系可以简单理解为：切入点一定是连接点，连接点不一定是切入点。

织入

织入的过程其实就是Spring AOP帮我们把切面中的代码织入到目标代码中的过程，就是把铁钉钉进木板的过程

总体的过程（自己的理解）

首先定义一个接口

package com.lanou3g.spring.simple.calc;

public interface Calc {
    public int add(int num1, int num2);

    public int minus(int num1, int num2);

    public int multiply(int num1, int num2);
}

接着定义一个实现类（主业务也是目标业务）

package com.lanou3g.spring.simple.calc;

public class CalcImpl implements Calc {
    @Override
    public int add(int num1, int num2) {
        long start = System.currentTimeMillis();
        int result = num1 + num2;
        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        long timer = System.currentTimeMillis() - start;

        System.out.println("方法执行结束, 耗时：" + timer + "ms.");
        return result;
    }
    public int minus(int num1, int num2) {
        // 模拟方法执行报错，便于看到after-throwing通知
        //        int ret = 9 / 0;
        return num1 - num2;
    }

    public int multiply(int num1, int num2) {
        return num1 * num2;
    }
}

再接着我们在定义我们要切入的业务（切面）

package com.lanou3g.spring.simple.calc;


import lombok.extern.slf4j.Slf4j;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;

import java.util.Arrays;

@Slf4j
public class CalcAspect {
    /**
     * 计算方法耗时
     * 环绕通知
     * @param joinPoint 代表连接点对象，该对象可以获取被代理方法的所有信息
     */
    public Object aroundM(ProceedingJoinPoint joinPoint) throws Throwable {

        // 获取连接点代表的方法的签名
        Signature signature = joinPoint.getSignature();
        String methodName = signature.getName();
        Object[] args = joinPoint.getArgs();

        log.debug("[aroundM] ---- 目标方法"+methodName+"("+ Arrays.toString(args)+")开始执行");
        long start = System.currentTimeMillis();
        // 调用目标方法
        Object retVal = joinPoint.proceed();

        // 插入我们自己的逻辑代码
        long timer = System.currentTimeMillis() - start;

        log.debug("[aroundM] ---- 目标方法["+methodName+"("+ Arrays.toString(args)+")]执行结束，返回值： "+retVal+"， 耗时: " + timer + "ms.");

        // 正常返回目标方法的返回值
        return retVal;
    }

    public void beforeM() {
        log.debug("[beforeM] ---- 目标方法开始执行");
    }

    public void afterReturningM(Object retVal) {
        log.debug("[afterReturningM] ---- 目标方法执行结束，返回值: " + retVal);
    }

    public void afterFinallyM() {
        log.error("[afterFinallyM] ---- 方法执行结束");
    }

    public void afterThrowing(Throwable throwable) {
        log.error("[afterThrowing] ---- 方法执行出错", throwable);
    }
}

最后测试一下

package com.lanou3g.spring;

import com.lanou3g.spring.simple.calc.Calc;
import com.lanou3g.spring.simple.calc.CalcImpl;
import com.lanou3g.spring.simple.calc.MyCalcProxy;
import lombok.extern.slf4j.Slf4j;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * Hello world!
 */
@Slf4j
public class App {
    public static void main(String[] args) {
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        Calc calc = ctx.getBean(Calc.class);
        System.out.println(calc.minus(40000000, 90000000));
        log.info("控制台输出： " + calc.multiply(5, 89));
    }
}

也还可以通过静态代理实现

package com.lanou3g.spring.simple.calc;

/**
 * 通过静态代理实现将特定逻辑附加到原始业务代码上
 */
public class MyCalcProxy extends CalcImpl{
    @Override
    public int multiply(int num1, int num2) {
        System.out.println("multiply 方法开始执行");
        int result = super.multiply(num1, num2);
        System.out.println("multiply 方法执行结束");
       // System.out.println(result);
        return result;
        //只有返回值，没有输出语句，所以在调用时要有打印语句sout
        //向控制台输出结果的函数是System.out.println()。
        //普通函数的返回值是不会自动打印出来的，
    }
}

测试类

        CalcImpl mb=new MyCalcProxy();

        System.out.println(mb.add(2,3));
        System.out.println(mb.multiply(5,8));
        System.out.println(mb.minus(8,9));
        mb.multiply(2,78);

日志记录

<configuration>

    <property name="HOME_LOG" value="logs"/>

    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <layout class="ch.qos.logback.classic.PatternLayout">
            <Pattern>
                %d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n
            </Pattern>
        </layout>
    </appender>

    <appender name="RollingFile"
              class="ch.qos.logback.core.rolling.RollingFileAppender">
        <filter class="ch.qos.logback.classic.filter.ThresholdFilter">
            <level>TRACE</level>
        </filter>

        <!-- 测试部署时使用如下配置 -->
        <!-- 可让每天产生一个日志文件，最多 30 个，更早的删除 -->
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <fileNamePattern>${HOME_LOG}/log-%d{yyyy-MM-dd}.log
            </fileNamePattern>
            <maxHistory>10</maxHistory>
        </rollingPolicy>

        <!--
             RollingFileAppender 一般情况下需要配置两个参数：
             RollingPolicy，负责滚动。TriggeringPolicy，决定是否以及何时进行滚动
             TimeBasedRollingPolicy比较特殊，它同时继承了RollingPolicy和TriggerPolicy。

        -->
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger -
                %msg%n
            </pattern>
        </encoder>

        <!-- 正式部署时使用此配置 -->
        <!--
            <file>${app.home}/logs/log.log</file>
            <append>true</append>
            <rollingPolicy class="ch.qos.logback.core.rolling.FixedWindowRollingPolicy">
                <fileNamePattern>${app.home}/logs/log.%i.log.zip
                </fileNamePattern>
                <minIndex>1</minIndex>
                <maxIndex>7</maxIndex>
            </rollingPolicy>

            <encoder>
                <pattern>%d{yyyy-MM-dd HH:mm:ss.SSS} [%thread] %-5level %logger -
                    %msg%n
                </pattern>
            </encoder>

            <triggeringPolicy
                class="ch.qos.logback.core.rolling.SizeBasedTriggeringPolicy">
                <maxFileSize>50MB</maxFileSize>
            </triggeringPolicy>
         -->
    </appender>

控制台输出

21:54:57.771 [main] DEBUG c.l.spring.simple.calc.CalcAspect - [aroundM] ---- 目标方法minus([40000000, 90000000])开始执行
21:54:57.772 [main] DEBUG c.l.spring.simple.calc.CalcAspect - [beforeM] ---- 目标方法开始执行
21:54:57.773 [main] DEBUG c.l.spring.simple.calc.CalcAspect - [aroundM] ---- 目标方法[minus([40000000, 90000000])]执行结束，返回值： -50000000， 耗时: 1ms.
21:54:57.773 [main] DEBUG c.l.spring.simple.calc.CalcAspect - [afterReturningM] ---- 目标方法执行结束，返回值: -50000000
21:54:57.773 [main] ERROR c.l.spring.simple.calc.CalcAspect - [afterFinallyM] ---- 方法执行结束
-50000000
21:54:57.773 [main] DEBUG c.l.spring.simple.calc.CalcAspect - [aroundM] ---- 目标方法multiply([6, 9])开始执行
21:54:57.773 [main] DEBUG c.l.spring.simple.calc.CalcAspect - [beforeM] ---- 目标方法开始执行
21:54:57.773 [main] DEBUG c.l.spring.simple.calc.CalcAspect - [aroundM] ---- 目标方法[multiply([6, 9])]执行结束，返回值： 54， 耗时: 0ms.
21:54:57.774 [main] DEBUG c.l.spring.simple.calc.CalcAspect - [afterReturningM] ---- 目标方法执行结束，返回值: 54
21:54:57.774 [main] ERROR c.l.spring.simple.calc.CalcAspect - [afterFinallyM] ---- 方法执行结束
54
21:54:57.774 [main] DEBUG c.l.spring.simple.calc.CalcAspect - [aroundM] ---- 目标方法multiply([5, 89])开始执行
21:54:57.774 [main] DEBUG c.l.spring.simple.calc.CalcAspect - [beforeM] ---- 目标方法开始执行
21:54:57.774 [main] DEBUG c.l.spring.simple.calc.CalcAspect - [aroundM] ---- 目标方法[multiply([5, 89])]执行结束，返回值： 445， 耗时: 0ms.
21:54:57.774 [main] DEBUG c.l.spring.simple.calc.CalcAspect - [afterReturningM] ---- 目标方法执行结束，返回值: 445
21:54:57.774 [main] ERROR c.l.spring.simple.calc.CalcAspect - [afterFinallyM] ---- 方法执行结束
21:54:57.774 [main] INFO  com.lanou3g.spring.App - 控制台输出： 445

异常

<logger name="com.lanou3g.spring" level="DEBUG"/>
    <logger name="org.springframework" level="ERROR"/>

    <root level="debug">
        <appender-ref ref="STDOUT"/>
        <appender-ref ref="RollingFile" />
    </root>