Spring面向AOP编程与Spring事务笔记

桂亭亭

已于 2022-11-14 19:33:10 修改

阅读量950

点赞数 1

分类专栏： java Spring 文章标签： spring java mybatis

于 2022-11-14 19:28:12 首次发布

本文链接：https://blog.csdn.net/qq_53679247/article/details/127842026

版权

java 同时被 2 个专栏收录

71 篇文章 2 订阅

订阅专栏

Spring

28 篇文章 0 订阅

订阅专栏

1 基础定义

2 简单使用

3 AOP流程

4 AOP 消息获取参数/获取返回值/获取异常

5 AOP总结

6 Spring事务

AOP编程使用mybatis操作数据库（包括测试）完整依赖

1 基础定义

连接点(JoinPoint)：程序执行过程中的任意位置，粒度为执行方法、抛出异常、设置变量等在SpringAOP中，理解为方法的执行

切入点(Pointcut):匹配连接点的式子在SpringAOP中，一个切入点可以描述一个具体方法，也可也匹配多个方法一个具体的方法:如com.itheima.dao包下的BookDao接口中的无形参无返回值的save方法匹配多个方法:所有的save方法，所有的get开头的方法，所有以Dao结尾的接口中的任意方法，所有带有一个参数的方法连接点范围要比切入点范围大，是切入点的方法也一定是连接点，但是是连接点的方法就不一定要被增强，所以可能不是切入点。

通知(Advice):在切入点处执行的操作，也就是共性功能在SpringAOP中，功能最终以方法的形式呈现

通知类：定义通知的类

切面(Aspect):描述通知与切入点的对应关系。

就像是把一个已经定义好的方法，再在外界加入一些东西，实现拼接，最后执行拼接后的方法

2 简单使用

1 依赖引入

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>RELEASE</version>
            <scope>test</scope>
        </dependency>
    </dependencies>

2 定义接口与实现类

public interface BookDao {public void save();
    public void update();

}

@Repository
public class BookDaoImpl implements BookDao {
    public void save() {
        System.out.println(System.currentTimeMillis());
        System.out.println("book dao save ...");
    }
    public void update(){
        System.out.println("book dao update ...");
    }
}

3 定义通知类和通知，并在通知类中定义切面与切点

package com.learn.device;

import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
//定义通知类
public class myDevice {
    //定义切入点
    @Pointcut("execution(void com.learn.dao.BookDao.update())")
    private void pt(){}

    //制作切面
    @Before("pt()")
    public void method(){
        System.out.println("我是切面呀！");
    }
}

4 将通知类配给容器并标识其为切面类

package com.learn.device;

import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

@Component
@Aspect
//定义通知类
public class myDevice {
    //定义切入点
    @Pointcut("execution(void com.learn.dao.BookDao.update())")
    private void pt(){}

    //制作切面
    @Before("pt()")
    public void method(){
        System.out.println("我是切面呀！");
    }
}

5 在Spring配置类中开启注解格式AOP功能

package com.learn.springFramework;

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan("com.learn")
@EnableAspectJAutoProxy
public class SpringConfig {
}

6 编写测试方法

    @Test
    public void update() {
        ApplicationContext ctx = new
                AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        bookDao.update();
    }

7 成功截图

3 AOP流程

1 Spring容器启动

2 读取所有切面配置中的切入点

3 初始化Bean

4 执行Bean方法

目标对象(Target)：原始功能去掉共性功能对应的类产生的对象，这种对象是无法直接完成最终工作的

代理(Proxy)：目标对象无法直接完成工作，需要对其进行功能回填，通过原始对象的代理对象实现

4 AOP配置管理

1 AOP切入点表达式

2 AOP通知类型

重点记一下我们的环绕通知

通知类

//定义切入点
@Pointcut("execution(String com.learn.dao.BookDao.save())")
private void sv(){}
//切入面
@Around("sv()")
public Object saveExtend(ProceedingJoinPoint pjp)
{
    System.out.println("我是使用Around所呈现的前置内容");
    Object result=null;
    try {
        result=pjp.proceed();
    } catch (Throwable e) {
        throw new RuntimeException(e);
    }
    System.out.println("我是使用Around所呈现的后置内容");
     return result;
}

测试类

    @Test
    public void save() {
        ApplicationContext ctx = new
                AnnotationConfigApplicationContext(SpringConfig.class);
        BookDao bookDao = ctx.getBean(BookDao.class);
        Object result= bookDao.save();
        System.out.println(result);
    }

4 AOP 消息获取参数/获取返回值/获取异常

消息获取参数

1非环绕通知获取方式

2 环绕通知获取方式

修改原来方法的参数值

获取返回值

1 环绕通知获取返回值

2 返回后通知获取返回值

获取异常

1 环绕通知获取异常

2 抛出异常后通知获取异常

5 AOP总结

5.1 AOP的核心概念
概念：AOP(Aspect Oriented Programming)面向切面编程，一种编程范式
作用：在不惊动原始设计的基础上为方法进行功能增强
核心概念
代理（Proxy）：SpringAOP的核心本质是采用代理模式实现的
连接点（JoinPoint）：在SpringAOP中，理解为任意方法的执行
切入点（Pointcut）：匹配连接点的式子，也是具有共性功能的方法描述
通知（Advice）：若干个方法的共性功能，在切入点处执行，最终体现为一个方法
切面（Aspect）：描述通知与切入点的对应关系
目标对象（Target）：被代理的原始对象成为目标对象
5.2 切入点表达式
切入点表达式标准格式：动作关键字(访问修饰符 返回值 包名.类/接口名.方法名（参数）异常
名)
切入点表达式描述通配符：
作用：用于快速描述，范围描述
*：匹配任意符号（常用）
.. ：匹配多个连续的任意符号（常用）
+：匹配子类类型
切入点表达式书写技巧
1.按标准规范开发 2.查询操作的返回值建议使用*匹配 3.减少使用..的形式描述包 4.对接口
进行描述，使用*表示模块名，例如UserService的匹配描述为*Service 5.方法名书写保留动
词，例如get，使用*表示名词，例如getById匹配描述为getBy* 6.参数根据实际情况灵活调整
5.3 五种通知类型
前置通知
后置通知
环绕通知（重点）
环绕通知依赖形参ProceedingJoinPoint才能实现对原始方法的调用
环绕通知可以隔离原始方法的调用执行
环绕通知返回值设置为Object类型
环绕通知中可以对原始方法调用过程中出现的异常进行处理
返回后通知
抛出异常后通知
1 execution(* com.itheima.service.*Service.*(..))
5.4 通知中获取参数
获取切入点方法的参数，所有的通知类型都可以获取参数
JoinPoint：适用于前置、后置、返回后、抛出异常后通知
ProceedingJoinPoint：适用于环绕通知
获取切入点方法返回值，前置和抛出异常后通知是没有返回值，后置通知可有可无，所以不做研究
返回后通知
环绕通知
获取切入点方法运行异常信息，前置和返回后通知是不会有，后置通知可有可无，所以不做研究
抛出异常后通知
环绕通知

6 Spring事务

简单使用

1 在需要被事务管理的方法上添加注解

@Transactional

@Transactional可以写在接口类上、接口方法上、实现类上和实现类方法上写在接口类上，该接口的所有实现类的所有方法都会有事务写在接口方法上，该接口的所有实现类的该方法都会有事务写在实现类上，该类中的所有方法都会有事务写在实现类方法上，该方法上有事务建议写在实现类或实现类的方法上

2 在JdbcConfig类中配置事务管理器

@Bean public PlatformTransactionManager transactionManager(DataSource dataSource){ DataSourceTransactionManager transactionManager = new DataSourceTransactionManager(); transactionManager.setDataSource(dataSource); return transactionManager;

}

3 在Spring中配置类开启开启事务注解

@EnableTransactionManagement

事务角色

事务管理员：发起事务方，在Spring中通常指代业务层开启事务的方法

事务协调员：加入事务方，在Spring中通常指代数据层方法，也可以是业务层方法

注意: 目前的事务管理是基于DataSourceTransactionManager和SqlSessionFactoryBean使用的是同一个数据源。

Spring事务属性

readOnly：true只读事务，false读写事务，增删改要设为false,查询设为true。

timeout:设置超时时间单位秒，在多长时间之内事务没有提交成功就自动回滚，-1表示不设置超时时间。

rollbackFor:当出现指定异常进行事务回滚 noRollbackFor:当出现指定异常不进行事务回滚思考:出现异常事务会自动回滚，这个是我们之前就已经知道的 noRollbackFor是设定对于指定的异常不回滚，这个好理解 rollbackFor是指定回滚异常，对于异常事务不应该都回滚么，为什么还要指定?

原因是：Spring的事务只会对Error异常和RuntimeException异常及其子类进行事务回滚，其他的异常类型是不会回滚的，比如OException不符合上述条件所以不回滚

rollbackForClassName等同于rollbackFor,只不过属性为异常的类全名字符串 noRollbackForClassName等同于noRollbackFor，只不过属性为异常的类全名字符串 isolation设置事务的隔离级别

DEFAULT :默认隔离级别, 会采用数据库的隔离级别

READ_UNCOMMITTED : 读未提交

READ_COMMITTED : 读已提交
REPEATABLE_READ : 重复读取

SERIALIZABLE: 串行化

事务的传播

事务传播行为：事务协调员对事务管理员所携带事务的处理态度。具体如何解决，就需要用到propagation属性。

例如

AOP编程使用mybatis操作数据库（包括测试）完整依赖

 <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.9.4</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.1.16</version>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.47</version>
        </dependency>

        <dependency>
            <!--Spring操作数据库需要该jar包-->
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.2.10.RELEASE</version>
        </dependency>
        <dependency>
            <!--
            Spring与Mybatis整合的jar包
            这个jar包mybatis在前面，是Mybatis提供的
            -->
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>

        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.83</version>
        </dependency>

        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.6</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>RELEASE</version>
            <scope>test</scope>
        </dependency>

桂亭亭

关注

1
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
0
评论
Spring面向AOP编程与Spring事务笔记

5.1 AOP的核心概念概念：AOP(Aspect Oriented Programming)面向切面编程，一种编程范式作用：在不惊动原始设计的基础上为方法进行功能增强核心概念代理（Proxy）：SpringAOP的核心本质是采用代理模式实现的连接点（JoinPoint）：在SpringAOP中，理解为任意方法的执行切入点（Pointcut）：匹配连接点的式子，也是具有共性功能的方法描述通知（Advice）：若干个方法的共性功能，在切入点处执行，最终体现为一个方法。
复制链接

扫一扫