笔触狂放9

这个屌丝很懒，什么也没留下！

热门标签

SpringAOP机制详解_spring框架的aop机制

作者：笔触狂放9 | 2024-02-15 20:47:59

踩

spring框架的aop机制

一、AOP概述

（一）什么是AOP

AOP为Aspect Oriented Programming的缩写，意思为面向切面编程，是通过预编译方式和运行期动态代理实现程序功能的统一维护的一种技术。

（二）AOP编程思想

AOP面向切面编程是一种编程思想，是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各个部分之间的耦合度降低，提高程序的可重用性，同时提高了开发的效率。

（三）Spring中的常用术语

Joinpoint（连接点）：所谓连接点是指那些被拦截到的点。在Spring中，这些点指的是方法，因为Spring只支持方法类型的连接点。
Pointcut（切入点）：所谓切入点是指我们要对哪些Joinpoint进行拦截的定义。
Advice（通知/增强）：通知是指拦截到Joinpoint之后所要做的事情就是通知。通知的类型：前置通知，后置通知，异常通知，最终通知，环绕通知。
Introduction（引介）：引介是一种特殊的通知在不修改类代码的前提下，Introduction可以在运行期为类动态地添加一些方法。
Target（目标对象）：代理的目标对象。
Proxy（代理）：一个类被AOP织入增强后，就产生一个结果代理类。
Weaving（织入）：是指把增强应用到目标对象来创建新的代理对象的过程。Spring采用动态代理织入，而Aspect采用编译期织入和类装载期织入。
Aspect（切面）：是切入点和通知（引介）的结合。

（四）AOP编程底层的实现机制

1、JDK动态代理

只提供接口的代理，不支持类的代理。JDK动态代理通过反射来接受被代理的类，并且要求被代理的类必须实现一个接口。JDK动态代理的核心是invocationHandler接口和Proxy类

2、CGLB动态代理

通过继承的方式来实现动态代理，因此如果某个类被标记为final，那么他是无法使用CGLB做动态代理。

（五）AOP的作用及优势

作用：在程序运行期间，在不修改源码的情况下对方法进行功能增强。

优势：减少重复代码，提高开发效率，并且便于维护。

二、Spring基于XML的AOP配置

（一）环境搭建

1、添加依赖


<properties>
    <spring.version>5.2.5.RELEASE</spring.version>
</properties>
 
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>
 
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.7</version>
    </dependency>
</dependencies>

2、添加代码

准备实体类


public class Account implements Serializable {
    private Integer id;
    private String name;
    private double money;
 
    public Integer getId() {
        return id;
    }
 
    public void setId(Integer id) {
        this.id = id;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    public double getMoney() {
        return money;
    }
 
    public void setMoney(double money) {
        this.money = money;
    }
 
    @Override
    public String toString() {
        return "Account{" +
            "id=" + id +
            ", name='" + name + '\'' +
            ", money=" + money +
            '}';
    }
}

创建AccountDao接口以及实现类


public interface AccountDao {
    public Account findByName(String name);
    public void update(Account account);
}


public class AccountDaoImpl implements AccountDao {
    private QueryRunner queryRunner = new QueryRunner(new ComboPooledDataSource());
 
    @Override
    public Account findByName(String name) {
        try {
            String sql ="select *from account where name =? ";
            Account account = queryRunner.query(sql, new BeanHandler<>(Account.class), name);
            return account;
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
        return null;
    }
 
    @Override
    public void update(Account account) {
        try {
            String sql ="update account set money =? where name =? ";
            queryRunner.update(sql, account.getMoney(), account.getName());
        } catch (SQLException throwables) {
            throwables.printStackTrace();
        }
    }
}

创建AccountService接口以及实现类


public interface AccountService {
/**
* 定义业务方法， 实现转账
* @param sourceAccountName 来源账户
* @param targetAccountName 目标账户
* @param money 转账金额
*/
public void transfer(String sourceAccountName,String targetAccountName,double money);
}


public class AccountServiceImpl implements AccountService {
 
    //依赖dao层
    private AccountDao accountDao = new AccountDaoImpl();
 
    @Override
    public void transfer(String sourceAccountName, String targetAccountName,double money) {
        //查询来源账户和目标账户
        Account sAccount = accountDao.findByName(sourceAccountName);
        Account tAccount = accountDao.findByName(targetAccountName);
       
        //来源账户减钱，目标账户加钱
        sAccount.setMoney(sAccount.getMoney()-money);
        tAccount.setMoney(tAccount.getMoney()+money);
 
        //持久化到数据库
        accountDao.update(sAccount);
        //模拟异常发生
        int i=1/0;
        accountDao.update(tAccount);
    }
}

3、创建配置文件并导入约束


<?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: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/aop
    http://www.springframework.org/schema/aop/spring-aop.xsd">
</beans>

4、配置Spring的IOC


<!-- 配置数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <!--连接数据库的必备信息-->
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test">
</property>
    <property name="user" value="root"></property>
    <property name="password" value="root"></property>
</bean>
 
<!-- 配置Connection的工具类 ConnectionUtils -->
<bean id="connectionUtils" class="com.offcn.utils.ConnectionUtils">
    <!-- 注入数据源-->
    <property name="dataSource" ref="dataSource"></property>
</bean>
 
<!--配置queryRunner-->
<bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner"></bean>
 
<!--配置accountDao-->
<bean id="accountDao" class="com.offcn.dao.impl.AccountDaoImpl">
    <property name="queryRunner" ref="queryRunner"></property>
    <property name="connectionUtils" ref="connectionUtils"></property>
</bean>
 
<!--配置accountService-->
<bean id="accountService" class="com.offcn.service.impl.AccountServiceImpl">
    <property name="accountDao" ref="accountDao"></property>
</bean>

5、抽取公共代码制作成通知


/**
* 和事务管理相关的工具类，它包含了，开启事务，提交事务，回滚事务和释放连接
*/
public class TransactionManager {
    private ConnectionUtils connectionUtils;
 
    public void setConnectionUtils(ConnectionUtils connectionUtils) {
        this.connectionUtils = connectionUtils;
    }
 
    /**
    * 开启事务
    */
    public void beginTransaction(){
        try {
            connectionUtils.getThreadConnection().setAutoCommit(false);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
 
    /**
    * 提交事务
    */
    public void commit(){
        try {
            connectionUtils.getThreadConnection().commit();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
 
    /**
    * 回滚事务
    */
    public void rollback(){
        try {
            connectionUtils.getThreadConnection().rollback();
        }catch (Exception e){
            e.printStackTrace();
        }
    }
 
    /**
    * 释放连接
    */
    public void release(){
        try {
            connectionUtils.removeConnection();
            connectionUtils.getThreadConnection().close();//还回连接池中
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

（二）AOP配置步骤

1、配置bean标签


<!--配置通知：txManager-->
<bean id="txManager" class="com.offcn.utils.TransactionManager">
    <property name="connectionUtils" ref="connectionUtils"></property>
</bean>

2、使用aop：config 声明AOP配置

aop:config:
作用：开始声明aop配置


<aop:config>
    <!-- 配置的代码都写在此处 -->
</aop:config>

3、使用aop：aspect 配置切面

aop：aspect
作用：用于配置切面
属性：id ：给切面提供一个唯一标识。
ref：引用配置好的通知类 bean 的 id。


<aop:aspect id="tdAdvice" ref="txManager">
    <!--配置通知的类型要写在此处-->
</aop:aspect>

4、使用aop：pointcut配置切入点表达式

aop:pointcut

作用：用于配置切入点表达式。就是指定对哪些类的哪些方法进行增强。

属性： expression：用于定义切入点表达式。

id：用于给切入点表达式提供一个唯一标识


<aop:pointcut id="point1" expression="execution( public void com.offcn.service.impl.AccountServiceImpl.transfer(java.lang.String,java.lang.St
ring,java.lang.Double))"/>

5、使用aop：xxx配置对应的通知类型

aop：before

作用：用于指定通知类中的增强方法名称

属性：method：用于指定通知类中的增强方法名称

ponitcut-ref：用于指定切入点的表达式的引用

poinitcut：用于指定切入点表达式

执行时间点：切入点方法执行之前执行

<aop:before method="beginTransaction" pointcut-ref="point1"></aop:before>

aop：after-returning

作用：用于配置后置通知

属性：method：指定通知中方法的名称

pointct：定义切入点表达式

pointcut-ref：指定切入点表达式的引用

执行时间点：切入点方法正常执行之后。它和异常通知只能有一个执行。

<aop:after-returning method="commit" pointcut-ref="point1"/>

aop：after-throwing

作用：用于配置异常通知

属性：method：指定通知中方法的名称

pointct：定义切入点表达式

pointcut-ref：指定切入点表达式的引用

执行时间点：切入点方法执行产生异常后执行。它和后置通知只能执行一个。

<aop:after-throwing method="rollback" pointcut-ref="point1"/>

aop：after

作用：用于配置最终通知

属性：method：指定通知中方法的名称

pointct：定义切入点表达式

pointcut-ref：指定切入点表达式的引用

执行时间点：无论切入点方法执行时是否有异常，它都会在其后面执行。

<aop:after method="release" pointcut-ref="point1"/>

（三）切入点表达式说明

切入点表达式的语法

execution([修饰符] 返回值类型包名.类名.方法名(参数))

访问修饰符可以省略
返回值类型、包名、类名、方法名可以使用*代表任意
包名与类名之间一个点。代表当前包下的类，两个点...表示当前包及其子包下的类
参数列表可以使用两个点...表示任意个数，任意类型的参数列表

（四）环绕通知配置事务管理

在TransactionManager类当中添加方法


/**
    * 环绕通知:
    * spring 框架为我们提供了一个接口：ProceedingJoinPoint，它可以作为环绕通知的方法参
数。
    * 在环绕通知执行时，spring 框架会为我们提供该接口的实现类对象，我们直接使用就行。
    * @param pjp
    * @return
*/
public Object transactionAround(ProceedingJoinPoint pjp) {
    //定义返回值
    Object returnValue = null;
    try {
        //获取方法执行所需的参数
        Object[] args = pjp.getArgs();
        //前置通知：开启事务
        beginTransaction();
        //执行方法
        returnValue = pjp.proceed(args);
        //后置通知：提交事务
        commit();
    }catch(Throwable e) {
        //异常通知：回滚事务
        rollback();
        e.printStackTrace();
    }finally {
        //最终通知：释放资源
        release();
    }
    return returnValue;
}

aop：around：

作用：用于配置环绕通知

属性：method：指定通知中方法的名称

pointct：定义切入点表达式

pointcut-ref：指定切入点表达式的引用

说明：它是 spring 框架为我们提供的一种可以在代码中手动控制增强代码什么时候执行的方式。

注意：通常情况下，环绕通知都是独立使用的。


<aop:config>
    <aop:aspect id="tdAdvice" ref="txManager">
        <aop:pointcut id="point1" expression="execution(*com.offcn.service.impl.*.*(..))"/>
        <!-- 配置环绕通知 -->
        <aop:around method="transactionAround" pointcut-ref="point1"/>
    </aop:aspect>
</aop:config>

三、Spring基于注解的AOP配置

（一）环境搭建

1、构建maven工程添加AOP注解的相关依赖


<properties>
    <spring.version>5.2.5.RELEASE</spring.version>
</properties>
 
<dependencies>
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>${spring.version}</version>
    </dependency>
 
    <dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.7</version>
    </dependency>
</dependencies>

2、导入代码

沿用上一章节资源

copy Account AccountDao AccountDaoImpl AccountService AccountServiceImpl

3、在配置文件中导入context的名称空间且配置


<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:aop="http://www.springframework.org/schema/aop"
    xmlns:context="http://www.springframework.org/schema/context"
    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
    http://www.springframework.org/schema/context
    http://www.springframework.org/schema/context/spring-context.xsd">
</beans>

4、资源使用注解配置


<!-- 配置数据源 -->
<bean id="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
    <!--连接数据库的必备信息-->
    <property name="driverClass" value="com.mysql.jdbc.Driver"></property>
    <property name="jdbcUrl" value="jdbc:mysql://localhost:3306/test">
</property>
    <property name="user" value="root"></property>
    <property name="password" value="root"></property>
</bean>
 
<!--配置queryRunner-->
    <bean id="queryRunner" class="org.apache.commons.dbutils.QueryRunner">
</bean>

5、在配置文件中指定spring要扫描的包


<!-- 告知 spring，在创建容器时要扫描的包 -->
<context:component-scan base-package="com.offcn"></context:component-scan>

（二）配置步骤

1、通知类使用注解配置


/**
* 和事务管理相关的工具类，它包含了，开启事务，提交事务，回滚事务和释放连接
*/
@Component("txManager")
public class TransactionManager {
    @Autowired
    private ConnectionUtils connectionUtils;
}

2、通知类使用@Aspect注解声明为切面


/**
* 和事务管理相关的工具类，它包含了，开启事务，提交事务，回滚事务和释放连接
*/
@Component("txManager")
@Aspect //表明当前类是一个切面类
public class TransactionManager {
    @Autowired
    private ConnectionUtils connectionUtils;
}

3、增强方法上使用注解配置通知

@Before

作用：把当前方法看成是前置通知

属性：value：用于指定切入点表达式，还可以指定切入点表达式的引用。


//开启事务
@Before("execution(* com.offcn.service.impl.*.*(..)))")
public void beginTransaction(){
    try {
        System.out.println("before..........................");
        connectionUtils.getThreadConnection().setAutoCommit(false);
    }catch (Exception e){
        e.printStackTrace();
    }
}

@AfterReturning

作用：把当前方法看成是后置通知。

属性：value：用于指定切入点表达式，还可以指定切入点表达式的引用


// 提交事务
@AfterReturning("execution(* com.offcn.service.impl.*.*(..)))")
public void commit(){
    try {
        connectionUtils.getThreadConnection().commit();
    }catch (Exception e){
        e.printStackTrace();
    }
}

@AfterThrowing

作用：把当前方法看成是异常通知。

属性：value：用于指定切入点表达式，还可以指定切入点表达式的引用


//回滚事务
@AfterThrowing("execution(* com.offcn.service.impl.*.*(..)))")
public void rollback(){
    try {
        connectionUtils.getThreadConnection().rollback();
    }catch (Exception e){
        e.printStackTrace();
    }
}

@After

作用：把当前方法看成是最终通知。

属性： value ：用于指定切入点表达式，还可以指定切入点表达式的引用。


//释放连接
@After("execution(* com.offcn.service.impl.*.*(..)))")
public void release(){
    try {
        connectionUtils.removeConnection();
        connectionUtils.getThreadConnection().close();//还回连接池中
    }catch (Exception e){
        e.printStackTrace();
    }
}

4、开启Spring对注解AOP的支持


<!-- 开启 spring 对注解 AOP 的支持 -->
<aop:aspectj-autoproxy/>

5、环绕通知注解配置

@Around

作用：把当前方法看成是环绕通知。

属性：value：用于指定切入点表达式，还可以指定切入点表达式的引用。


// 环绕通知:
@Around("execution(*com.offcn.service.impl.*.*(..))")
public Object transactionAround(ProceedingJoinPoint pjp) {
 
    //定义返回值
    Object returnValue = null;
    try {
        //获取方法执行所需的参数
        Object[] args = pjp.getArgs();
        //前置通知：开启事务
        beginTransaction();
        //执行方法
        returnValue = pjp.proceed(args);
        //后置通知：提交事务
        commit();
    }catch(Throwable e) {
        //异常通知：回滚事务
        rollback();
        e.printStackTrace();
    }finally {
        //最终通知：释放资源
        release();
    }
    return returnValue;
}

6、切入点表达式注解


@Pointcut("execution(* com.offcn.service.impl.*.*(..))")
private void point1() {}
 
// 环绕通知:
@Around("point1()")///注意：千万别忘了写括号
public Object transactionAround(ProceedingJoinPoint pjp) {
    //定义返回值
    Object returnValue = null;
    try {
        //获取方法执行所需的参数
        Object[] args = pjp.getArgs();
        //前置通知：开启事务
        beginTransaction();
        //执行方法
        returnValue = pjp.proceed(args);
        //后置通知：提交事务
        commit();
    }catch(Throwable e) {
        //异常通知：回滚事务
        rollback();
        e.printStackTrace();
    }finally {
        //最终通知：释放资源
        release();
    }
    return returnValue;
}

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/笔触狂放9/article/detail/86844

SpringAOP机制详解_spring框架的aop机制

一、AOP概述

（一）什么是AOP

（二）AOP编程思想

（三）Spring中的常用术语

（四）AOP编程底层的实现机制

1、JDK动态代理

2、CGLB动态代理

（五）AOP的作用及优势

二、Spring基于XML的AOP配置

（一）环境搭建

1、添加依赖

2、添加代码

准备实体类

创建AccountDao接口以及实现类

创建AccountService接口以及实现类

3、创建配置文件并导入约束

4、配置Spring的IOC

5、抽取公共代码制作成通知

（二）AOP配置步骤

1、配置bean标签

2、使用aop：config 声明AOP配置

3、使用aop：aspect 配置切面

4、使用aop：pointcut配置切入点表达式

5、使用aop：xxx配置对应的通知类型

aop：before

aop：after-returning

aop：after-throwing

aop：after

（三）切入点表达式说明

切入点表达式的语法

（四）环绕通知配置事务管理

三、Spring基于注解的AOP配置

（一）环境搭建

1、构建maven工程添加AOP注解的相关依赖

2、导入代码

3、在配置文件中导入context的名称空间且配置

4、资源使用注解配置

5、在配置文件中指定spring要扫描的包

（二）配置步骤

1、通知类使用注解配置

2、通知类使用@Aspect注解声明为切面

3、增强方法上使用注解配置通知

4、开启Spring对注解AOP的支持

5、环绕通知注解配置

6、切入点表达式注解