AOP(面向切面编程) 及Mybatis简介

本文详细介绍了AOP(面向切面编程)的核心概念,包括AOP与OOP的区别、AspectJ、切入点、通知类型以及Spring AOP的XML和注解配置方式。同时,文章还阐述了Spring声明式事务的配置,并给出了基于XML和注解的示例。此外,文章还简要探讨了Mybatis的基本依赖和两种方式(XML与注解)的映射SQL,包括数据库配置、Mapper接口和配置文件等内容。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

文章目录

AOP(面向切面编程)

AOP和OOP的比较

OOP语言提供了类与类之间纵向的关系(继承、接口),而AOP补充了横向的关系(比如在不改变目标类中源代码的情况下给com.john.demo.dao包下所有类中以insert和update开头的方法添加事务管理)

AspectJ(切面)

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

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

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

示例:

<!-- 在beans标签中配置命名空间aop -->
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop.xsd">

   
<!-- 目标业务逻辑代码 -->
<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复用 -->
    <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>

</beans>

在pom.xml文件中添加依赖

<dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>

切入点 (Pointcut)

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

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

通知(Advice)

配置applicationContext.xml

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

    <bean id="calc" class="com.lanou3g.spring.simple.calc.CalcImpl"/>

    <bean id="calcAspect" class="com.lanou3g.spring.simple.calc.CalcAspect" />

    <aop:config>
        <aop:pointcut id="all_calc_method" expression="execution(* com.lanou3g.spring.simple.calc.CalcImpl.*(..))" />
        <aop:aspect ref="calcAspect">
            <aop:around method="aroundM" pointcut-ref="all_calc_method" />
            <aop:before method="beforeM" pointcut-ref="all_calc_method" />
            <aop:after-returning method="afterReturningM" pointcut-ref="all_calc_method" returning="retVal" />
            <aop:after-throwing method="afterThrowing" pointcut-ref="all_calc_method" throwing="throwable" />
            <aop:after method="afterFinallyM" pointcut-ref="all_calc_method" />
        </aop:aspect>
    </aop:config>

</beans>

配置logback.xml

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

    <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>
</configuration>

环绕通知(around)

  • 在目标方法执行前、后被通知, 可以获取连接点对象(ProceedingJoinPoint, 该对象可以获取被拦截方法的签名、参数、返回值、包括调用与否)
  • 该方法的返回值,即代表了真正业务逻辑代码的返回值
  • 可以选择终止或正常执行目标方法

前置通知(before)

在目标方法调用前通知切面, 什么参数也无法获取。也不能终止目标方法执行

后置(返回值)通知(after returning)

只有在目标方法 正常 执行结束后才会通知, 在通知方法中可以获取到方法的返回值

后置(最终)通知 (after)

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

异常通知(after throwing)

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

连接点(JoinPoint)

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

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

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

织入(Weaver)

织入的过程其实就是Spring AOP帮我们把切面中的代码织入到目标代码中的过程。

用XML方式启用Spring AOP

添加依赖

首先我们需要先将aspectJ的依赖导入maven项目中

<dependency>           
 <groupId>org.aspectj</groupId>
 <artifactId>aspectjweaver</artifactId>
 <version>1.9.4</version>
</dependency>

使用示例

这里给出一个需要被织入的Java类的示例

public class CalcImpl implements Calc {
   
    /**
    * 加法
    */
    @Override
    public int add(int num1, int num2) {
   
        return num1 + num2;
    }
	/**
    * 减法
    */
    @Override
    public int subtract(int minuend, int subtrahend) {
   
        return minuend - subtrahend;
    }
    /**
    * 乘法
    */
    @Override
    public int multiply(int num1, int num2) {
   
        return num1 * num2;
    }
    /**
    * 除法
    */
    @Override
    public int divide(int dividend, int divisor) {
   
        return dividend / divisor;
    }
}

以及切面类

@Slf4j//该注解用于下面使用log输出(不想使用log的换成控制台输出语句即可)
public class CalcAspect {
   

    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) + ")]开始执行");
        
<think>好的,我现在需要帮用户检查一下他们提供的这句话有没有问题。首先,用户提到自己具备Spring Boot、Spring MVC和MyBatis的实战经验,接着是深入理解Spring Bean的生命周期机制,掌握自动配置原理和AOP面向切面编程。 首先,我要逐个检查技术术语的准确性。Spring Boot、Spring MVC和MyBatis都是正确的框架名称,没有问题。接下来是Spring Bean的生命周期机制,这里应该用“生命周期”而不是“生命周期机制”,不过可能用户是想强调机制,但通常我们会说“生命周期”。不过这里可能不算错误,但可以优化。 然后,自动配置原理,这里没问题,Spring Boot的自动配置是其核心特性之一。AOP面向切面编程,这里有点重复,因为AOP本身就是面向切面编程的缩写,所以正确的说法应该是“AOP面向切面编程)”或者直接说“面向切面编程AOP)”。用户这里用了“AOP面向切面编程”,虽然不算错误,但有点冗余,可以建议调整结构。 接下来,句子的结构问题。原句中的“深入理解Spring Bean生命周期机制,掌握自动配置原理与AOP面向切面编程”这部分,动词的使用是否恰当?“深入理解”和“掌握”都是合适的动词,但可能需要统一结构,比如都用“深入理解”或者“掌握”,不过分开使用也可以接受。 另外,标点符号方面,各部分之间用句号分隔是正确的,但可以考虑使用分号来连接相关的内容,使句子更流畅。例如,把“具备...实战经验。深入理解...”改为分号,但句号也是可以的,看用户偏好。 然后,是否存在技术表述不准确的地方?比如,Spring Bean的生命周期确实是Spring框架的核心内容,自动配置是Spring Boot的特性,AOP是Spring的一个模块,这些都是正确的。 总结问题点:主要是术语的准确性和表达的冗余。比如“AOP面向切面编程”可以优化,以及“生命周期机制”可能调整为“生命周期”。另外,句子结构可以稍微调整,使其更流畅。 可能的修改建议:将“AOP面向切面编程”改为“AOP面向切面编程)”,或者调整顺序。同时,检查是否有更合适的动词搭配,确保各部分表达清晰准确。 最后,确认用户的需求是检查简历或技术描述中的语句,所以需要确保专业性和准确性,同时避免冗余,使内容更精炼。可能需要建议用户将部分术语用括号补充说明,或者调整结构,使阅读更顺畅。</think>您提供的句子整体表述清晰,但在技术细节和表达方式上有以下可优化之处: ### 一、技术表述优化建议 1. **术语规范性问题** `AOP面向切面编程` 存在冗余,建议改为: `AOP面向切面编程)` *理由*:AOP 是 Aspect-Oriented Programming 的缩写,括号补充中文全称更符合技术文档规范。 2. **技术归属区分** `自动配置原理` 需要明确技术来源,建议改为: `Spring Boot 自动配置原理` *理由*:自动配置是 Spring Boot 的核心特性,与 Spring Framework 的 Bean 生命周期属于不同层级的技术点。 3. **生命周期表述** `Spring Bean生命周期机制` 建议调整为: `Spring Bean 生命周期及其管理机制` *理由*:生命周期本身包含阶段定义,而「机制」更强调 Spring 容器的具体实现逻辑。 ### 二、句式结构调整建议 ```markdown 具备 Spring Boot、Spring MVC 及 MyBatis 等框架的实战经验。深入理解 Spring Bean 生命周期及其管理机制,掌握 Spring Boot 自动配置原理与 AOP面向切面编程)的实现与应用。 ``` ### 三、改进后优势 1. 技术归属更清晰(明确区分 Spring Framework 与 Spring Boot 的不同技术点) 2. 术语表达更专业(通过括号补充英文缩写全称) 3. 逻辑层次更分明(「机制-原理-实现」的递进关系) ### 四、扩展建议 若面向技术面试场景,可补充具体量化指标: `例如:通过自定义 BeanPostProcessor 实现 Bean 初始化耗时监控(具体应用场景),基于 @EnableAutoConfiguration 实现自定义 Starter(实践案例)` 这样的调整既保持了专业性,又通过技术细节增强了说服力。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值