项目管理与SSM框架 Spring5(四)

简介: 项目管理与SSM框架 Spring5(四)

6.5 多切面配置

我们可以为切点配置多个通知,形成多切面,比如希望dao层的每个方法结束后都可以打印日志并发送邮件:

1、编写发送邮件的通知:

public class MyAspectJAdvice2 {
  // 后置通知
  public void myAfterReturning(JoinPoint joinPoint) {
    System.out.println("发送邮件");
   }
}

2、配置切面

<!-- 通知对象 -->
<bean id="myAspectJAdvice" class="com.itbaizhan.advice.MyAspectAdvice"></bean>
<bean id="myAspectJAdvice2" class="com.itbaizhan.advice.MyAspectAdvice2"></bean>
<!-- 配置AOP -->
<aop:config>
  <!-- 配置切面 -->
  <aop:aspect ref="myAspectJAdvice">
    <!-- 配置切点 -->
    <aop:pointcut id="myPointcut" expression="execution(* *..*.*(..))"/>
    <!-- 后置通知 -->
    <aop:after-returning method="myAfterReturning" pointcut-ref="myPointcut"/>
  </aop:aspect>
  <aop:aspect ref="myAspectJAdvice2">
    <aop:pointcut id="myPointcut2" expression="execution(* com.itbaizhan.dao.UserDao.*(..))"/>
    <aop:after-returning method="myAfterReturning" pointcut-ref="myPointcut2"/>
  </aop:aspect>
</aop:config>

6.6 注解配置AOP

1、在applicationContext.xml文件中开启AOP注解支持

<aop:aspectj-autoproxy/>

2、在通知类上方加入注解@Aspect

3、在通知方法上方加入注解@Before/@AfterReturning/@AfterThrowing/@After/@Around

package com.zj.advice;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
@Aspect
public class MyAdviceAspect {
    //后置通知
    @AfterReturning("execution(* com.zj.dao.StudentDao.*(..))")
    public void AfterReturningMethod(JoinPoint joinPoint){
        System.out.println("切点方法名:"+joinPoint.getSignature().getName());
        System.out.println("哪个类执行的该方法:"+joinPoint.getTarget());
        System.out.println("打印日志……");
    }
    //前置通知
    @Before("execution(* com.zj.dao.StudentDao.*(..))")
    public void BeforeMethod(JoinPoint joinPoint){
        System.out.println("前置通知……");
    }
    //异常通知
    @AfterThrowing(value = "execution(* com.zj.dao.StudentDao.*(..))",throwing = "exception")
    public void AfterThrowingMethod(Exception exception){
        System.out.println("异常:"+exception.getMessage());
        System.out.println("异常通知……");
    }
    //最终通知
    @After("execution(* com.zj.dao.StudentDao.*(..))")
    public void AfterMethod(JoinPoint joinPoint){
        System.out.println("最终通知……");
    }
    //环绕通知
    @Around("execution(* com.zj.dao.StudentDao.*(..))")
    public Object RoundMethod(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕前……");
        Object proceed = proceedingJoinPoint.proceed();//执行原方法
        System.out.println("环绕后……");
        return proceed;
    }
}

或者直接将切点提出来

package com.zj.advice;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
@Aspect
public class MyAdviceAspect {
    //切点
    @Pointcut("execution(* com.zj.dao.StudentDao.*(..))")
    public void point(){
    }
    //后置通知
    @AfterReturning("point()")
    public void AfterReturningMethod(JoinPoint joinPoint){
        System.out.println("切点方法名:"+joinPoint.getSignature().getName());
        System.out.println("哪个类执行的该方法:"+joinPoint.getTarget());
        System.out.println("打印日志……");
    }
    //前置通知
    @Before("point()")
    public void BeforeMethod(JoinPoint joinPoint){
        System.out.println("前置通知……");
    }
    //异常通知
    @AfterThrowing(value = "point()",throwing = "exception")
    public void AfterThrowingMethod(Exception exception){
        System.out.println("异常:"+exception.getMessage());
        System.out.println("异常通知……");
    }
    //最终通知
    @After("point()")
    public void AfterMethod(JoinPoint joinPoint){
        System.out.println("最终通知……");
    }
    //环绕通知
    @Around("point()")
    public Object RoundMethod(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        System.out.println("环绕前……");
        Object proceed = proceedingJoinPoint.proceed();//执行原方法
        System.out.println("环绕后……");
        return proceed;
    }
}

配置类如何代替xml中AOP注解支持?

在配置类上方添加@EnableAspectJAutoProxy即可

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

七、Spring事务

事务:不可分割的原子操作。即一系列的操作要么同时成功,要么同时失败。

开发过程中,事务管理一般在service层,service层中可能会操作多次数据库,这些操作是不可分割的。否则当程序报错时,可能会造成数据异常

如:张三给李四转账时,需要两次操作数据库:张三存款减少、李四存款增加。如果这两次数据库操作间出现异常,则会造成数据错误。

1、创建数据库

2、创建实体类

package com.zj.pojo;
public class User {
    private int id;
    private String username;
    private String sex;
    private String address;
    private int account;
    //get/set/构造省略
}

3、创建maven项目(spring+mybatis),引入依赖

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>org.example</groupId>
    <artifactId>springandmybatis</artifactId>
    <version>1.0-SNAPSHOT</version>
    <dependencies>
        <!--Mybatis-->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>
        <!--JDBC驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.26</version>
        </dependency>
        <!--Druid连接池-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.16</version>
        </dependency>
        <!--Spring-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>5.3.13</version>
        </dependency>
        <!--事务-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>5.3.13</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>5.3.13</version>
        </dependency>
        <!-- MyBatis与Spring的整合包,该包可以让Spring创建MyBatis的对象 -->
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>2.0.6</version>
        </dependency>
        <!--AOP框架: AspectJ -->
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>1.8.7</version>
        </dependency>
        <!-- junit,如果Spring5整合junit,则junit版本至少在4.12以上 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <!-- spring整合测试模块 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.3.13</version>
        </dependency>
    </dependencies>
</project>

4、dao、service层

@Repository
public interface UserDao {
    //根据id查找用户
    @Select("select * from user where id = #{id}")
    User findUserById(int id);
    //修改用户余额
    @Update("update user set account = #{account} where id = #{id}")
    void updateUser(User user);
}
@Service
public class UserService {
    @Autowired
    private UserDao userDao;
    //转账业务
    public void updateUser(int id1, int id2,int money){
        /*转出人减少金额*/
        User user1 = userDao.findUserById(id1);
        System.out.println("未转账之前:"+user1.getUsername()+"有"+user1.getAccount()+"元。");
        user1.setAccount(user1.getAccount() - money);
        userDao.updateUser(user1);
        /*转入人增加金额*/
        User user2 = userDao.findUserById(id2);
        System.out.println("未转账之前:"+user2.getUsername()+"有"+user2.getAccount()+"元。");
        user2.setAccount(user2.getAccount() + money);
        userDao.updateUser(user2);
        User userById1 = userDao.findUserById(id1);
        System.out.println("转账之后:"+userById1.getUsername()+"有"+userById1.getAccount()+"元。");
        User userById2 = userDao.findUserById(id2);
        System.out.println("转账之后:"+userById2.getUsername()+"有"+userById2.getAccount()+"元。");
    }
}

5、配置文件

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:context="http://www.springframework.org/schema/context"
       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/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">
    <!--扫描包-->
    <context:component-scan base-package="com.zj"/>
    <!--读取数据源配置文件-->
    <context:property-placeholder location="classpath:db.properties"/>
    <!--配置数据源-->
    <bean id="datasource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driverClassName}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <!--创建Spring封装过的SqlSessionFactory对象-->
    <bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="datasource"/>
    </bean>
    <!--创建Spring封装的SqlSession-->
    <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
        <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactory"/>
    </bean>
    <!-- 该对象可以自动扫描持久层接口,并为接口创建代理对象 -->
    <bean id="mapperScanner" class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 配置扫描的接口包 -->
        <property name="basePackage" value="com.zj.dao"/>
    </bean>
    <!--开启AOP注解支持-->
    <aop:aspectj-autoproxy/>
</beans>

6、测试

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class TestUserService {
    @Autowired
    private UserService userService;
    @Test
    public void testUpdateUser(){
        userService.updateUser(5,6,500);
    }
}

这么看来似乎是没啥大问题但是如果在转账的时候出现错误的话会怎么样呢?下面我们就来模拟转账业务出现错误看看转账业务是否还能正常进行。

@Service
public class UserService {
    @Autowired
    private UserDao userDao;
    //转账业务
    public void updateUser(int id1, int id2,int money){
        /*转出人减少金额*/
        User user1 = userDao.findUserById(id1);
        System.out.println("未转账之前:"+user1.getUsername()+"有"+user1.getAccount()+"元。");
        user1.setAccount(user1.getAccount() - money);
        userDao.updateUser(user1);
        //模拟错误
        int a = 1/0;
        /*转入人增加金额*/
        User user2 = userDao.findUserById(id2);
        System.out.println("未转账之前:"+user2.getUsername()+"有"+user2.getAccount()+"元。");
        user2.setAccount(user2.getAccount() + money);
        userDao.updateUser(user2);
        User userById1 = userDao.findUserById(id1);
        System.out.println("转账之后:"+userById1.getUsername()+"有"+userById1.getAccount()+"元。");
        User userById2 = userDao.findUserById(id2);
        System.out.println("转账之后:"+userById2.getUsername()+"有"+userById2.getAccount()+"元。");
    }
}

测试后

发现翟玲娇把钱转给了张晓但是钱没有到张晓的手里,钱丢了。我们希望的是转账业务要么成功要么失败。所以要使用事务。

相关文章
|
2月前
|
XML 安全 Java
|
1天前
|
前端开发 Java 数据库连接
Spring框架初识
Spring 是一个分层的轻量级开源框架,核心功能包括控制反转(IOC)和面向切面编程(AOP)。主要模块有核心容器、Spring 上下文、AOP、DAO、ORM、Web 模块和 MVC 框架。它通过 IOC 将配置与代码分离,简化开发;AOP 提供了声明性事务管理等增强功能。
33 21
Spring框架初识
|
3月前
|
数据采集 监控 前端开发
二级公立医院绩效考核系统源码,B/S架构,前后端分别基于Spring Boot和Avue框架
医院绩效管理系统通过与HIS系统的无缝对接,实现数据网络化采集、评价结果透明化管理及奖金分配自动化生成。系统涵盖科室和个人绩效考核、医疗质量考核、数据采集、绩效工资核算、收支核算、工作量统计、单项奖惩等功能,提升绩效评估的全面性、准确性和公正性。技术栈采用B/S架构,前后端分别基于Spring Boot和Avue框架。
163 5
|
3月前
|
缓存 NoSQL Java
什么是缓存?如何在 Spring Boot 中使用缓存框架
什么是缓存?如何在 Spring Boot 中使用缓存框架
135 0
|
19天前
|
SQL Java 数据库连接
对Spring、SpringMVC、MyBatis框架的介绍与解释
Spring 框架提供了全面的基础设施支持,Spring MVC 专注于 Web 层的开发,而 MyBatis 则是一个高效的持久层框架。这三个框架结合使用,可以显著提升 Java 企业级应用的开发效率和质量。通过理解它们的核心特性和使用方法,开发者可以更好地构建和维护复杂的应用程序。
110 29
|
8天前
|
XML Java 开发者
通过springboot框架创建对象(一)
在Spring Boot中,对象创建依赖于Spring框架的核心特性——控制反转(IoC)和依赖注入(DI)。IoC将对象的创建和管理交由Spring应用上下文负责,开发者只需定义依赖关系。DI通过构造函数、setter方法或字段注入实现依赖对象的传递。Spring Boot的自动配置机制基于类路径和配置文件,自动为应用程序配置Spring容器,简化开发过程。Bean的生命周期包括定义扫描、实例化、依赖注入、初始化和销毁回调,均由Spring容器管理。这些特性提高了开发效率并简化了代码维护。
|
4月前
|
Java API 数据库
Spring Boot框架因其简洁的配置、快速的启动特性及丰富的功能集而备受开发者青睐
本文通过在线图书管理系统案例,详细介绍如何使用Spring Boot构建RESTful API。从项目基础环境搭建、实体类与数据访问层定义,到业务逻辑实现和控制器编写,逐步展示了Spring Boot的简洁配置和强大功能。最后,通过Postman测试API,并介绍了如何添加安全性和异常处理,确保API的稳定性和安全性。
86 0
|
1月前
|
开发框架 运维 监控
Spring Boot中的日志框架选择
在Spring Boot开发中,日志管理至关重要。常见的日志框架有Logback、Log4j2、Java Util Logging和Slf4j。选择合适的日志框架需考虑性能、灵活性、社区支持及集成配置。本文以Logback为例,演示了如何记录不同级别的日志消息,并强调合理配置日志框架对提升系统可靠性和开发效率的重要性。
|
2月前
|
设计模式 XML Java
【23种设计模式·全精解析 | 自定义Spring框架篇】Spring核心源码分析+自定义Spring的IOC功能,依赖注入功能
本文详细介绍了Spring框架的核心功能,并通过手写自定义Spring框架的方式,深入理解了Spring的IOC(控制反转)和DI(依赖注入)功能,并且学会实际运用设计模式到真实开发中。
【23种设计模式·全精解析 | 自定义Spring框架篇】Spring核心源码分析+自定义Spring的IOC功能,依赖注入功能
|
3月前
|
存储 Java 关系型数据库
在Spring Boot中整合Seata框架实现分布式事务
可以在 Spring Boot 中成功整合 Seata 框架,实现分布式事务的管理和处理。在实际应用中,还需要根据具体的业务需求和技术架构进行进一步的优化和调整。同时,要注意处理各种可能出现的问题,以保障分布式事务的顺利执行。
214 53