05.注解事务

最新推荐文章于 2023-08-17 23:38:40 发布
最新推荐文章于 2023-08-17 23:38:40 发布
阅读量227 收藏
点赞数
分类专栏： Spring学习 文章标签： spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ycjcson/article/details/112152720
版权

半注解、注解AOP、注解事务、全注解

一、半注解

use-default-filters:使用默认过滤规则，默认(true)引入所有的组件
<context:include-filter>:指定引入规则
type:规则判断依据
annotation
expression:被引入的内容的表达式
org.springframework.stereotype.Controller
<context:exclude-filter>:指定排除规则(有引入的内容)
type:规则判断依据
annotation
expression:被排除的内容的表达式
org.springframework.stereotype.Controller

案例：
配置文件
applicationContext.xml
<?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:context="http://www.springframework.org/schema/context"
       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">

    <!-- 测试半注解 开启注解扫描 -->
    <context:component-scan base-package="com.yl"/>
    
    <context:component-scan base-package="com.yl" use-default-filters="true">
        <!--<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>-->
        <!--<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>-->
    </context:component-scan>
    <!--
        @Primary:设置主要的继承类，当需要注入父类类型的时候，并且父类是抽象类的时候，则默认取其主要的子类作为注入的数据
        设置扫描德过滤规则
    -->
</beans>
UserInfo.java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
import java.util.Date;
/**
 * 用户的实体类
 */
@Component
public class UserInfo {
    private Integer userId;
    @Value("张胜男")
    private String userName;
    private Date createTime;
    private String userAddress;
    private String userEmail;
    public UserInfo(Integer userId, String userName, Date createTime, String userAddress, String userEmail) {
        this.userId = userId;
        this.userName = userName;
        this.createTime = createTime;
        this.userAddress = userAddress;
        this.userEmail = userEmail;
    }
    public Integer getUserId() {
        return userId;
    }
    public void setUserId(Integer userId) {
        this.userId = userId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public Date getCreateTime() {
        return createTime;
    }
    public void setCreateTime(Date createTime) {
        this.createTime = createTime;
    }
    public String getUserAddress() {
        return userAddress;
    }
    public void setUserAddress(String userAddress) {
        this.userAddress = userAddress;
    }
    public String getUserEmail() {
        return userEmail;
    }
    public void setUserEmail(String userEmail) {
        this.userEmail = userEmail;
    }
    @Override
    public String toString() {
        return "UserInfo{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", createTime=" + createTime +
                ", userAddress='" + userAddress + '\'' +
                ", userEmail='" + userEmail + '\'' +
                '}';
    }
}
测试
public void testUserInfo(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
        /*String[] beanNames = context.getBeanDefinitionNames();
        // getBeanDefinitionNames 获取所有的
        for(String beanName : beanNames){
            System.out.println(beanName);
        }
        */
        UserInfo userInfo = context.getBean("userInfo", UserInfo.class);

        System.out.println(userInfo);
        System.out.println(userInfo.getPet().getClass());
    }
抽象类注解案例（多个实现类）：
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;
@Component
public abstract class Pet {
    private Integer petId;
    @Value("旺财")
    private String petName;
    private String petSex;
    public Pet() {
    }
    public Pet(Integer petId, String petName, String petSex) {
        this.petId = petId;
        this.petName = petName;
        this.petSex = petSex;
    }
    @Override
    public String toString() {
        return "Pet{" +
                "petId=" + petId +
                ", petName='" + petName + '\'' +
                ", petSex='" + petSex + '\'' +
                '}';
    }
    public Integer getPetId() {
        return petId;
    }
    public void setPetId(Integer petId) {
        this.petId = petId;
    }
    public String getPetName() {
        return petName;
    }
    public void setPetName(String petName) {
        this.petName = petName;
    }
    public String getPetSex() {
        return petSex;
    }
    public void setPetSex(String petSex) {
        this.petSex = petSex;
    }
}
cat.java 实现类
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Component;
@Component
@Lazy // 是否懒加载
public class Cat extends Pet {
    private String catType;
    public String getCatType() {
        return catType;
    }
    public void setCatType(String catType) {
        this.catType = catType;
    }
    public void zhuaLaoShu(){
        System.out.println("抓老鼠！");
    }
}
dog.java 实现类
import org.springframework.context.annotation.Primary;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
@Component
@Primary // 当有多个实现类的时候，默认以该类为启动项
@Scope(value = "prototype") // 是否单列
public class Dog extends Pet {
    private Integer height;
    public void kanJia(){
        System.out.println("狗看门！");
    }
}
配置文件
<?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:context="http://www.springframework.org/schema/context"
       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">

    <!-- 测试半注解 开启注解扫描 -->
    <context:component-scan base-package="com.yl"/>

    <context:component-scan base-package="com.yl" use-default-filters="true">
        <!--<context:include-filter type="annotation" expression="org.springframework.stereotype.Controller"/>-->
        <!--<context:exclude-filter type="annotation" expression="org.springframework.stereotype.Controller"/>-->
    </context:component-scan>
    <!--
        @Primary:设置主要的继承类，当需要注入父类类型的时候，并且父类是抽象类的时候，则默认取其主要的子类作为注入的数据
        设置扫描德过滤规则
    -->
</beans>

二、注解AOP

案例：
calc.java
import org.springframework.stereotype.Component;
// 被通知类
@Component
public class Calc {
    public Integer cheng(int num1,int num2){
        return num1*num2;
    }
    public Integer chu(int num1,int num2){
        return num1/num2;
    }
}
MyAspect.java
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
import java.util.Arrays;
// 通知类
@Component
@Aspect
public class MyAspect {
    // 切点
    @Pointcut(value = "execution(* com.yl.entity.Calc.*(..))")
    public void pointdemo(){}
    // 前置通知
    @Before("pointdemo()")
    public void before(){
        System.out.println("前置通知");
    }
    @After("pointdemo()")
    public void after(JoinPoint jp){
        System.out.println("后置通知-->"+ Arrays.toString(jp.getArgs()));
    }
    @AfterReturning(value = "pointdemo()",returning = "rv")
    public void returning(Object rv){
        System.out.println("返回通知-->"+rv);
    }
    @AfterThrowing(value = "pointdemo()",throwing = "e")
    public void throwing(Exception e){
        System.out.println("异常通知-->"+e.getMessage());
    }
    @Around("execution(* com.yl.entity.Calc.*(..))")
    public Object around(ProceedingJoinPoint pjp){
        System.out.println("环绕前置通知");
        Object obj = null;
        try {
            obj = pjp.proceed();
            System.out.println("环绕返回通知！");
        } catch (Throwable throwable) {
            System.out.println("异常通知！已将结果设置为0");
            obj = 0;
        }finally {
            System.out.println("环绕后置通知！");
        }
        return obj;
    }
}
测试
// 测试Aop
    @Test
    public void testCalc(){
        ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext01.xml");
        Calc c = context.getBean( "calc",Calc.class);
        Integer cheng = c.cheng(2, 5);
        System.out.println(cheng);
    }
配置
<?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"
       xmlns:context="http://www.springframework.org/schema/context"
       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
       ">
    <!-- 开启注解扫描 -->
    <context:component-scan base-package="com.yl"/>
    <!-- 开启AOP的自动代理 -->
    <aop:aspectj-autoproxy/>
    <!--
        开启AOP的自动代理
            1、打开自动代理
            2、创建切面类，并交给SpringIOC容器管理，并注解@Aspect
            [3、]定义切点表示式，通过@Pointcut，注解在空方法上，根据方法名()进行调用
            4、定义通知方法
                @Before:前置通知
                @After:后置通知
                @AfterReturning:返回通知
                @AfterThrowing:异常通知
                @Around:环绕通知
    -->
</beans>

三、注解事务

开启事务的注解驱动
transaction-manager:指定当前事务驱动所使用的事务管理器
1、配置事务管理器
2、开事务的注解驱动
3、在需要使用事务的方法上打上@Transactional
propagation:传播行为
Propagation.REQUIRES_NEW:开启新事物
Propagation.REQUIRES:使用原来的事务
isolation:隔离级别
Isolation.READ_UNCOMMITTED:读未提交
Isolation.READ_COMMITTED:读已提交
Isolation.REPEATABLE_READ:可重复读
Isolation.SERIALIZABLE:序列化
timeout:事务的超时时间
read-only:事务是否只读
true:如果只读，则不会为该方法开启事务
false:会为该方法开启事务

案例
UserInfo.java
/**
 *用户信息实体类
 */
public class UserInfo {
    private Integer userId;
    private String userName;
    private String userPwd;
    private Integer userBalance;
    private Date userTime;
    public UserInfo(Integer userId, String userName, String userPwd, Integer userBalance, Date userTime) {
        this.userId = userId;
        this.userName = userName;
        this.userPwd = userPwd;
        this.userBalance = userBalance;
        this.userTime = userTime;
    }
    public UserInfo() {
    }
    public Integer getUserId() {
        return userId;
    }
    public void setUserId(Integer userId) {
        this.userId = userId;
    }
    public String getUserName() {
        return userName;
    }
    public void setUserName(String userName) {
        this.userName = userName;
    }
    public String getUserPwd() {
        return userPwd;
    }
    public void setUserPwd(String userPwd) {
        this.userPwd = userPwd;
    }
    public Integer getUserBalance() {
        return userBalance;
    }
    public void setUserBalance(Integer userBalance) {
        this.userBalance = userBalance;
    }
    public Date getUserTime() {
        return userTime;
    }
    public void setUserTime(Date userTime) {
        this.userTime = userTime;
    }
    @Override
    public String toString() {
        return "UserInfo{" +
                "userId=" + userId +
                ", userName='" + userName + '\'' +
                ", userPwd='" + userPwd + '\'' +
                ", userBalance=" + userBalance +
                ", userTime=" + userTime +
                '}';
    }
}
UserInfoDao.java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;
@Repository
public class UserInfoDao {
    @Autowired
    private JdbcTemplate jdbcTemplate;
    /**
     * 修改用户余额方法
     * @param userName 用户名
     * @param money 钱
     * @return 返回受影响行数
     */
    public int updateUserBalanceByUserName(String userName,Integer money){
        return jdbcTemplate.update(" UPDATE user_info SET user_balance = user_balance + ? WHERE user_name = ? ",money,userName);
    }
    /**
     *  根据用户名查询用户余额
     * @param userName  用户名
     * @return  返回金额
     */
    public Integer selectUserInfoBalanceByUserName(String userName){
        return jdbcTemplate.queryForObject(" SELECT user_balance FROM user_info WHERE user_name = ? ",Integer.class,userName);
    }
}
UserInfoService.java
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
@Service
public class UserInfoService {
    @Autowired
    private UserInfoDao userInfoDao;
    //事务需要具有一致性，要么都成功，要么都失败！
    /**
     * 转账功能
     * @param un1 转入的用户
     * @param un2 转出的用户
     * @param money 金额
     * @return 成功就返回 true
     */
    @Transactional(propagation = Propagation.REQUIRES_NEW,isolation = Isolation.SERIALIZABLE,readOnly = false)
    public boolean zhuanZhang(String un1,String un2,Integer money){
        //un1加钱
        userInfoDao.updateUserBalanceByUserName(un1,money);
        //判断余额
        if(getUserBalanceByUserName(un2)<money){
            //当余额不足，则抛出余额不足异常
            throw new BalanceBuZu();
        }else{
            //un2减钱
            userInfoDao.updateUserBalanceByUserName(un2,-money);
        }
        return true;
    }
    /**
     * 根据用户账号查询余额
     * @param userName 用户名
     * @return 返回该用户的金额
     */
    public Integer getUserBalanceByUserName(String userName){
        return userInfoDao.selectUserInfoBalanceByUserName(userName);
    }
}
/**
 * 自定义异常
 */
class BalanceBuZu extends RuntimeException{
    public BalanceBuZu() {
        super("余额不足");
    }
}
配置
<?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"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- 开启注解扫描 -->
    <context:component-scan base-package="com.yl"/>
    <!-- 开启AOP自动注解 -->
    <aop:aspectj-autoproxy/>
    <!--事务-->
    <bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <property name="dataSource" ref="dataSource">
        </property>
    </bean>
    <!-- 配置数据源 -->
    <bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">
        <property name="driverClass" value="com.mysql.jdbc.Driver"/>
        <property name="jdbcUrl" value="jdbc:mysql:///user_db?characterEncoding=UTF-8"/>
        <property name="user" value="root"/>
        <property name="password" value="123456"/>
    </bean>
    <bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    
    <tx:annotation-driven transaction-manager="transactionManager"/>
</beans>
测试
public void test2(){
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext02.xml");
        UserInfoService uis = ac.getBean(UserInfoService.class);
        //至少两段数据库操作，一个账户减钱，一个账户加钱
        boolean bl = uis.zhuanZhang("admin1","admin2",1500);
        System.out.println(bl?"转账成功":"转账失败");
    }

四、全注解

MySpringConfiguration.java
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
@Configuration // 让该类变成Spring的配置类
/*
* includeFilters = {
        @ComponentScan.Filter(type = FilterType.ANNOTATION,classes = {Controller.class, Service.class})
  )}
  * @ComponentScan(value = "com.zb.beisaomiao",useDefaultFilters = true,
        excludeFilters = @ComponentScan.Filter(
                type=FilterType.ANNOTATION,
                classes = {Controller.class, Repository.class})
)
* */

// 没有注解的方法(通过引入来注入)
@Import(value = {Test01.class, Test02.class})
public class MySpringConfiguration {

    /*
     *  1、注入Bean
     *      手动注入
     *          @Bean注解，注解在方法上，SpringIOC容器会自动调用该方法，将该方法返回的对象存入到SpringIOC容器中，默认beanName使用方法名
     *              value/name:指定其在SpringIOC容器中的name
     *              autowireCandidate:是否参与自动注入
     *              initMethod:初始化方法
     *              destroyMethod:销毁方法
     *      扫描注入
     *          @ComponentScan
     *      通过引入注入
     *          @Import
     *              value:要引入的类.class数组
     *      ... ...
     * */
    //<bean name="" class="" autowire="byType/byName" />
    @Bean(value ="userInfo", autowireCandidate = false,initMethod = "init",destroyMethod = "destory")
    public UserInfo getUserInfo(){
        UserInfo userInfo = new UserInfo();
        return userInfo;
    }
}
测试
import com.yl.cofiguration.MySpringConfiguration;
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
public class TestMain01 {
    public static void main(String[] args) {
        // 如果是通过Spring的配置类进行配置，则需要创建AnnotationConfigApplicationContext(配置类.class);
        ApplicationContext ac = new AnnotationConfigApplicationContext(MySpringConfiguration.class);
        String[] names = ac.getBeanDefinitionNames();
        for (String name : names){
            System.out.println(name);
        }
    }
}

五、作业

一、为工具类获取圆信息类通过SpringAOP完成代理增强

​ 描述：
​ 创建圆信息实现类，接口信息如下
​ public interface round｛
​ public double getPerimeter(Double radius);//根据传入的半径参数，获取圆的周长
​ public double getArea(Double radius);//根据传入的参数半径，获取圆的面积
​ }
​ 要求使用Spring的AOP功能，为该实现类添加环绕通知
​ 通知要求：在进行计算之前验证参数是否合理(大于0)
​ 计算之后，结果保留两位有效数(四舍五入)字并返回

Round.java
public interface Round {
    //根据传入的半径参数，获取圆的周长
    public double getPerimeter(Double radius);
    //根据传入的参数半径，获取圆的面积
    public double getArea(Double radius);
}
RoundImpl.java
import org.springframework.stereotype.Component;
// 被通知的类
@Component
public class RoundImpl implements Round{
    /**
     * 计算周长
     * @param radius 圆的半径
     * @return  返回圆的周长
     */
    @Override
    public double getPerimeter(Double radius) {
        return Math.PI*radius*2;
    }
    /**
     * 计算面积
     * @param radius 圆的半径
     * @return 返回圆的面积
     */
    @Override
    public double getArea(Double radius) {
        return Math.PI*radius*radius;
    }
}
MyAspectRound.java
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.Around;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
import java.math.BigDecimal;
// 通知类
@Component
@Aspect
public class MyAspectRound {
    // 切点
    @Pointcut(value = "execution(* com.yl.calculate.RoundImpl.*(..))")
    public void pointdemo(){}
    // 环绕通知
    @Around("pointdemo()")
    public Object around(ProceedingJoinPoint pjp){
        Object[] objnum = pjp.getArgs();
        Object obj = null;
        if((double)objnum[0]<0){
            throw new ling();
        }
        System.out.println("您输入的半径是："+objnum[0]+"大于 0" );
        try {
            obj = pjp.proceed();
        } catch (Throwable throwable) {
            System.out.println("异常通知！已将结果设置为0");
            obj = 0;
        }finally {
            // 保留两位小数
            BigDecimal bg = new BigDecimal((double)obj);
            obj  = bg.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
        }
        return obj;
    }
}
// 自定义异常
class ling extends RuntimeException{
    public ling() {
        super("半径小于零");
    }
}
测试
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class TestRound {
    public static void main(String[] args) {
        ApplicationContext ac = new ClassPathXmlApplicationContext("applicationContext.xml");
        Round round = ac.getBean( Round.class);
        System.out.println("圆的周长为："+round.getPerimeter(3.0));
        System.out.println("圆的面积为："+round.getArea(4.0));
    }
}
applicationContext.xml
<?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:context="http://www.springframework.org/schema/context"
       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/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.yl"/>
    <!-- 开启AOP自动注解 -->
    <aop:aspectj-autoproxy/>
</beans>
二、为服务层(BookInfoService)添加方法，并应用Spring声明式事务

​ public interface BookInfoService{
​ 购买图书方法
​ 判断图书数量是否大于等于购买数量
​ 等于：购买成功
​ 购买成功后，图书数量-1，用户积分+=图书单价*图书数量
​ 不等于：购买失败，抛出异常
​ public boolean buyBook(String userName,int quantity);
​ }

jv_xiaobai_yu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java事务 - 使用注解
09-13
使用注解控制java事务， 类似spring处理，代码干净简洁
spring boot注解事务+多线程
01-25
首先，让我们关注"注解事务"。在Spring框架中，我们主要依赖`@Transactional`注解来声明事务边界。当一个方法被这个注解标记时，Spring会自动管理事务的开始、提交或回滚。如果方法中发生任何未捕获的异常，事务将被...
事务 Transactional注解
liumeng0906的博客
07-26 1703
事务4种事务特性，5种隔离级别，7种传播行为事务逻辑上的一组操作，组成这组操作的各个逻辑单元，要么一起成功，要么一起失败。
Spring事务处理(注解版)
天蓬元帅的博客
08-08 2301
准备:jdbc.properties 第一步:连接数据库 &lt;context:property-placeholder location="jdbc.properties"/&gt;     &lt;bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"&gt;         &lt;property nam...
Spring 事务详解（注解方式）
shine的博客
08-05 2694
事务指逻辑上的一组操作，组成这组操作的各个单元，要么全部成功，要么全部不成功，只有这两种情况。@Transactional注解 可以作用于接口、接口方法、类以及类方法上。当作用于类上时，该类的所有 public 方法将都具有该类型的事务属性，同时，我们也可以在方法级别使用该标注来覆盖类级别的定义。虽然@Transactional 注解可以作用于接口、接口方法、类以及类方法上，但是 Spring 建议不要在接口或者接口方法上使用该注解，因为这只有在使用基于接口的代理时它才会生效。
Spring——事务注解@Transactional【建议收藏】
热门推荐
娜娜米的博客
07-18 3万+
在某些业务场景下，如果一个请求中，需要同时写入多张表的数据或者执行多条sql，为了保证操作的原子性（要么同时成功，要么同时失败），避免数据不一致的情况，我们一般都会用到事务；Spring框架下，我们经常会使用@Transactional注解来管理事务； 本篇介绍Spring的事务注解@Transactional相关的知识，包括事务简介、事务隔离级别、Spring声明式事务实现原理、事务的传播行为、@Transactional的用法及注意事项等，属于Spring的常用注解之一，需要掌握相关知识点；...
Spring注解开发,事务控制
01-15
除了`@Transactional`，Spring还提供了其他的事务管理注解，如`@Rollback`用来强制在测试结束后回滚事务，`@Propagation`用来设置事务的传播行为，`@Transactional(propagation = Propagation.REQUIRES_NEW)`表示...
spring 事务基于注解模式
12-12
Spring提供了多种事务管理方式，其中基于注解的事务管理是近年来常用的模式，因为它简化了代码并提高了可读性。本文将深入探讨Spring中的基于注解的事务管理及其工作原理。 ### 1. Spring事务管理概述 Spring事务...
SpringJDBC注解事务.zip
06-05
通过上述内容，我们可以看到Spring JDBC结合注解事务管理，极大地简化了事务控制，让开发更高效，同时也保持了代码的整洁性。在实际项目中，结合Spring的AOP（面向切面编程）和IoC（依赖注入）特性，事务管理变得...
使用注解版本声明事务
Leon_Jinhai_Sun的博客
05-26 202
<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...
spring中事务注解是啥？
舒一笑的博客
08-17 302
Transactional：这是最常用的事务注解，用于将方法标记为事务性操作。当方法被调用时，Spring将为其创建一个事务，并根据配置的事务传播规则进行管理。你可以通过传递不同的propagation参数来定义事务方法与已存在事务方法的交互方式。在Spring框架中，事务注解是一种方式，用于声明和管理事务的行为。通过使用事务注解，你可以轻松地将事务逻辑应用到Spring管理的Bean上。这些事务注解提供了灵活的方式来管理事务，并使得在Spring中使用事务变得更加简单和便捷。
Spring中注解事务@Transactional用法详解
qq_32512453的博客
04-14 809
1，常用参数说明 ： 参数名称 功能描述 readOnly 该属性用于设置当前事务是否为只读事务，设置为true表示只读，false则表示可读写，默认值为false。例如：@Transactional(readOnly=true) rollbackFor 该属性用于设置需要进行回滚的异常类数组，当方法中抛出指定异常数组中的异常时，则进行事务回滚。例如:指定单一异常类：@Transactional(rollbackFor=RuntimeException.class) ； 指定多个异
spring事务注解@Transactional
godkzz的博客
08-06 631
通过@Transactional注解方式，可以将事务放到响应的public方法中，实现事务管理。 一、属性 @Transactional的所有可选属性如下所示： 1.propagation 用于设置事务传播属性。该属性类型为Propagation枚举，默认值为Propagation.REQUIRED 2.isolation 用于设置事务的隔离级别。该属性类型为isolation枚举，默认值为Isolation.DEFAULT 3.readOnly 用于设置该方法对数据库的操作是否是只读的
关于声明式事务管理和注解事务
Rava722的博客
09-25 2183
在javaweb操作中，当涉及到数据库的持久化操作的时候就有一个大人物需要提起：事务 1，在原始的开发中事务可以通过在spring中配置进行操作，基本的原理就是，在spring中加入相应的sessionfactory（不同 的持久化框架不一样，mybatis为sqlsessionfactory，hibernate为sessionfactory）然后依赖各个持久化层的提供的事务管 理器
Spring中事务的使用、抽象机制及模拟Spring事务实现
十指波课堂的博客
08-14 293
前言本专题大纲如下：本文大纲如下：编程式事务Spring提供了两种编程式事务管理的方法使用 TransactionTemplate 或者TransactionalOperator.直接实现TransactionManager接口如果是使用的是命令式编程，Spring推荐使用TransactionTemplate来完成编程式事务管理，如果是响应式编程，那么使用TransactionalOperato...
@Transactional注解分析
52Pig的专栏
02-13 3615
事务具备ACID特性，即原子性、一致性、隔离性和持久性。 @Transactional注解是用来指定接口、类或方法必须拥有事务语义的元数据。 @Transactional注解就代表支持事务管理，如果这个注解在类上，那么表示该注解对于所有该类中的public方法都生效；如果注解出现在方法上，则代表该注解仅对该方法有效，会覆盖先前从类层次继承下来的注解。 一般情况下不要将这个注解加到接口和抽象类
Spring事务@Transactional注解原理
Minor的Java技术博客
07-12 977
这个注解的作用不言而喻，就是开启Spring对事务管理的支持。和其他的Enable注解类似，他的底层原理就是通过ImportSelector接口向IOC容器中放入了2个Bean： 1.1 AutoProxyRegistrar（AOP的支持） 这个Bean的作用就是向IOC容器中注册了一个的实现类，这个抽象类就是AOP的核心实现。所以这个Bean说白了也就是，在Spring Bean初始化后会进行对Advisor的寻找，然后判断当前Bean是否需要进行AOP并且是否有符合的切点，然后进行AOP的操作。这也是一
aspectj注解和事务注解
最新发布
08-30
AspectJ注解和事务注解是在Spring框架中用于声明式事务管理的两种方式。 AspectJ注解是一种通过注解方式来实现面向切面编程的技术。例如，@annotation(org.springframework.transaction.annotation.Transactional)...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值