spring再学习之AOP事务

spring中的事务

spring怎么操作事务的：

事务的转播行为：

事务代码转账操作如下：

接口：

public interface AccountDao {

    //加钱

    void addMoney(Integer id,Double money);

    //减钱

    void decreaseMoney(Integer id,Double Money);

}

实现类：

import org.springframework.jdbc.core.support.JdbcDaoSupport;

public class AccountDaoImpl extends JdbcDaoSupport implements AccountDao {

    @Override

    public void addMoney(Integer id, Double money) {

        String sql="update t_account set money=money+? where id = ?";

        getJdbcTemplate().update(sql,money,id);

        // TODO Auto-generated method stub

    }

    @Override

    public void decreaseMoney(Integer id, Double money) {

        String sql="update t_account set money=money-? where id = ?";

        getJdbcTemplate().update(sql,money,id);

    }

}

service层接口

package cn.itcast.service;

public interface AccountService {

    //转账方法

    void transfer(Integer from,Integer to,Double money);

}

service实现类：

import org.springframework.transaction.TransactionStatus;

import org.springframework.transaction.annotation.Isolation;

import org.springframework.transaction.annotation.Propagation;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.transaction.support.TransactionCallback;

import org.springframework.transaction.support.TransactionCallbackWithoutResult;

import org.springframework.transaction.support.TransactionTemplate;

import cn.itcast.dao.AccountDao;

@Transactional(isolation=Isolation.REPEATABLE_READ,propagation=Propagation.REQUIRED,readOnly=false)

public class AccountServiceImpl implements AccountService {

    private AccountDao ad;

    private TransactionTemplate tt;

    @Override

    public void transfer(final Integer from, final Integer to,final  Double money) {

               //事务

                //减钱

                ad.decreaseMoney(from, money);

                //加钱

                ad.addMoney(to, money);

    }

    public AccountDao getAd() {

        return ad;

    }

    public void setAd(AccountDao ad) {

        this.ad = ad;

    }

    public TransactionTemplate getTt() {

        return tt;

    }

    public void setTt(TransactionTemplate tt) {

        this.tt = tt;

    }

/*    @Override
手动代码：

    public void transfer(final Integer from, final Integer to,final  Double money) {

        //事务

        tt.execute(new TransactionCallbackWithoutResult() {

            @Override

            protected void doInTransactionWithoutResult(TransactionStatus arg0) {

                // TODO Auto-generated method stub

                //减钱

                ad.decreaseMoney(from, money);

                int i=1/0;

                //加钱

                ad.addMoney(to, money);

            }

        });

    }

*/

}

分析：

XML配置式实现事务：

原理;

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
       xmlns="http://www.springframework.org/schema/beans" 
       xmlns:p="http://www.springframework.org/schema/p" 
       xmlns:context="http://www.springframework.org/schema/context" 
       xmlns:tx="http://www.springframework.org/schema/tx" 
       xmlns:aop="http://www.springframework.org/schema/aop" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans-4.2.xsd 
       http://www.springframework.org/schema/context 
       http://www.springframework.org/schema/context/spring-context-4.2.xsd 
       http://www.springframework.org/schema/tx 
       http://www.springframework.org/schema/tx/spring-tx-4.2.xsd 
       http://www.springframework.org/schema/aop 
       http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">      

   <!--指定Spring读取db.properties  -->

   <context:property-placeholder location="classpath:db.properties"  />

      <!-- 事物核心管理器，
           封装了所有事物操作，
           依赖于连接池 
       -->

      <bean name="dataSourceTransactionManager" 
           class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

           <property name="dataSource" ref="dataSource"></property>

      </bean>

      <!-- 事务模板对象 -->

      <bean name="transactionTemplate" 
            class="org.springframework.transaction.support.TransactionTemplate">

           <property name="transactionManager" ref="dataSourceTransactionManager"></property>

      </bean>

      <!-- 配置事务通知 
           isolation:隔离级别
           propagation:传播行为
           read-only：是否只读  
       -->

      <tx:advice id="txAdvice" transaction-manager="dataSourceTransactionManager">

            <tx:attributes>

                   <tx:method name="save*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>

                   <tx:method name="persist*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>

                   <tx:method name="update*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>

                   <tx:method name="modify*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>

                   <tx:method name="delete*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>

                   <tx:method name="remove*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>

                   <tx:method name="get*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true"/>

                   <tx:method name="find*" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="true"/>

                   <tx:method name="transfer" isolation="REPEATABLE_READ" propagation="REQUIRED" read-only="false"/>

            </tx:attributes>

      </tx:advice>

      <!-- 配置织入 -->

     <aop:config>

         <aop:pointcut expression="execution(* cn.itcast.service..*ServiceImpl.*(..))" id="txPc"/>

         <!-- 配置切面 -->

         <aop:advisor advice-ref="txAdvice" pointcut-ref="txPc"/>

     </aop:config>

   <!-- 1.将连接池交给Spring管理 -->

      <bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">

          <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>

          <property name="driverClass" value="${jdbc.driverClass}"></property>

          <property name="user" value="${jdbc.user}"></property>

          <property name="password" value="${jdbc.password}"></property>

      </bean>

    <!-- 2.将JDBCTemplate放入Spring容器

      <bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">

           <property name="dataSource" ref="dataSource"></property>

      </bean> -->

   <!-- 3.将accountDao放入spring容器 -->

   <bean name="accountDao" class="cn.itcast.dao.AccountDaoImpl">

        <property name="dataSource" ref="dataSource"></property>

   </bean>

    <!-- 3.将accountService放入spring容器 -->

   <bean name="accountService" class="cn.itcast.service.AccountServiceImpl">

        <property name="ad" ref="accountDao"></property>

        <property name="tt" ref="transactionTemplate"></property>

   </bean>

</beans>

xml配置式，中java写法：

1、打开事务

2、调用doInTransactionWithoutResult

3、提交事务

package cn.itcast.service;

import org.springframework.transaction.TransactionStatus;

import org.springframework.transaction.annotation.Isolation;

import org.springframework.transaction.annotation.Propagation;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.transaction.support.TransactionCallback;

import org.springframework.transaction.support.TransactionCallbackWithoutResult;

import org.springframework.transaction.support.TransactionTemplate;

import cn.itcast.dao.AccountDao;public class AccountServiceImpl implements AccountService {

    private AccountDao ad;

    private TransactionTemplate tt;

    @Override

    public void transfer(final Integer from, final Integer to,final  Double money) {

               //事务

                //减钱

                ad.decreaseMoney(from, money);

                //加钱

                ad.addMoney(to, money);

    }

    public AccountDao getAd() {

        return ad;

    }

    public void setAd(AccountDao ad) {

        this.ad = ad;

    }

    public TransactionTemplate getTt() {

        return tt;

    }

    public void setTt(TransactionTemplate tt) {

        this.tt = tt;

    }

}

测试：

package cn.itcast.tx;

import javax.annotation.Resource;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import cn.itcast.service.AccountService;

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:applicationContext1.xml")

public class Demo {

    @Resource(name="accountService")

    private AccountService ad;

    @Test

    public void fun1() {

        ad.transfer(1, 2, 1000.00);

    }

}

注解式配置事务：

<?xml version="1.0" encoding="UTF-8"?>

<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
       xmlns="http://www.springframework.org/schema/beans" 
       xmlns:p="http://www.springframework.org/schema/p" 
       xmlns:context="http://www.springframework.org/schema/context" 
       xmlns:tx="http://www.springframework.org/schema/tx" 
       xmlns:aop="http://www.springframework.org/schema/aop" 
       xsi:schemaLocation="http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans-4.2.xsd 
       http://www.springframework.org/schema/context 
       http://www.springframework.org/schema/context/spring-context-4.2.xsd 
       http://www.springframework.org/schema/tx 
       http://www.springframework.org/schema/tx/spring-tx-4.2.xsd 
       http://www.springframework.org/schema/aop 
       http://www.springframework.org/schema/aop/spring-aop-4.2.xsd ">      

   <!--指定Spring读取db.properties  -->

   <context:property-placeholder location="classpath:db.properties"  />

      <!-- 事物核心管理器，封装了所有事物操作，依赖于连接池 -->

      <bean name="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">

           <property name="dataSource" ref="dataSource"></property>

      </bean>

      <!-- 事务模板对象 -->

      <bean name="transactionTemplate" class="org.springframework.transaction.support.TransactionTemplate">

           <property name="transactionManager" ref="transactionManager"></property>

      </bean>

      <!--开启使用注解配置事务  -->

      <tx:annotation-driven />

   <!-- 1.将连接池交给Spring管理 -->

      <bean name="dataSource" class="com.mchange.v2.c3p0.ComboPooledDataSource">

          <property name="jdbcUrl" value="${jdbc.jdbcUrl}"></property>

          <property name="driverClass" value="${jdbc.driverClass}"></property>

          <property name="user" value="${jdbc.user}"></property>

          <property name="password" value="${jdbc.password}"></property>

      </bean>

    <!-- 2.将JDBCTemplate放入Spring容器

      <bean name="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">

           <property name="dataSource" ref="dataSource"></property>

      </bean> -->

   <!-- 3.将accountDao放入spring容器 -->

   <bean name="accountDao" class="cn.itcast.dao.AccountDaoImpl">

        <property name="dataSource" ref="dataSource"></property>

   </bean>

    <!-- 3.将accountService放入spring容器 -->

   <bean name="accountService" class="cn.itcast.service.AccountServiceImpl">

        <property name="ad" ref="accountDao"></property>

        <property name="tt" ref="transactionTemplate"></property>

   </bean>

</beans>

使用注解：

package cn.itcast.service;

import org.springframework.transaction.TransactionStatus;

import org.springframework.transaction.annotation.Isolation;

import org.springframework.transaction.annotation.Propagation;

import org.springframework.transaction.annotation.Transactional;

import org.springframework.transaction.support.TransactionCallback;

import org.springframework.transaction.support.TransactionCallbackWithoutResult;

import org.springframework.transaction.support.TransactionTemplate;

import cn.itcast.dao.AccountDao;public class AccountServiceImpl implements AccountService {


    private AccountDao ad;

    private TransactionTemplate tt;

    @Override

    @Transactional(isolation=Isolation.REPEATABLE_READ,propagation=Propagation.REQUIRED,readOnly=false)

    public void transfer(final Integer from, final Integer to,final  Double money) {

                //事务

                //减钱

                ad.decreaseMoney(from, money);

                //加钱

                ad.addMoney(to, money);

    }

    public AccountDao getAd() {

        return ad;

    }

    public void setAd(AccountDao ad) {

        this.ad = ad;

    }

    public TransactionTemplate getTt() {

        return tt;

    }

    public void setTt(TransactionTemplate tt) {

        this.tt = tt;

    }

}

测试：

package cn.itcast.tx;

import javax.annotation.Resource;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.springframework.test.context.ContextConfiguration;

import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import cn.itcast.service.AccountService;

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration("classpath:applicationContext2.xml")

public class Demo {

    @Resource(name="accountService")

    private AccountService ad;

    @Test

    public void fun1() {

        ad.transfer(1, 2, 1000.00);

    }

}

结果：

spring再学习之AOP事务的更多相关文章

spring再学习之AOP准备
一.aop思想: 横向重复,纵向抽取 1.乱码 2.事务管理 3,action 二.spring能够为容器中管理的对象生成代理对象 1.spring能帮我们生成代理对象 2.spring实现aop的原 ...
spring再学习之AOP实操
一.spring导包 2.目标对象 public class UserServiceImpl implements UserService { @Override public void save() ...
spring再学习之设计模式
今天我们来聊一聊,spring中常用到的设计模式,在spring中常用的设计模式达到九种. 第一种:简单工厂三种工厂模式:https://blog.csdn.net/xiaoddt/article/ ...
JAVAEE——spring03：spring整合JDBC和aop事务
一.spring整合JDBC 1.spring提供了很多模板整合Dao技术 2.spring中提供了一个可以操作数据库的对象.对象封装了jdbc技术. JDBCTemplate => JDBC模 ...
Spring基础学习(四)—AOP
一.AOP基础 1.基本需求需求: 日志功能,在程序执行期间记录发生的活动. ArithmeticCalculate.java public interface ArithmeticCal ...
Spring框架学习05——AOP相关术语详解
1.Spring AOP 的基本概述 AOP(Aspect Oriented Programing)面向切面编程,AOP采取横向抽取机制,取代了传统纵向继承体系重复性代码(性能监视.事务管理.安全检查 ...
spring框架学习(三)——AOP( 面向切面编程)
AOP 即 Aspect Oriented Program 面向切面编程首先,在面向切面编程的思想里面,把功能分为核心业务功能,和周边功能. 所谓的核心业务,比如登陆,增加数据,删除数据都叫核心业务 ...
Spring注解开发系列Ⅵ --- AOP&事务
注解开发 --- AOP AOP称为面向切面编程,在程序开发中主要用来解决一些系统层面上的问题,比如日志,事务,权限等待,Struts2的拦截器设计就是基于AOP的思想,横向重复,纵向抽取.详细的AO ...
Spring框架学习06——AOP底层实现原理
在Java中有多种动态代理技术,如JDK.CGLIB.Javassist.ASM,其中最常用的动态代理技术是JDK和CGLIB. 1.JDK的动态代理 JDK动态代理是java.lang.reflec ...

随机推荐

【对线面试官】Java多线程基础
// 请求直接交给线程池来处理 public void push(PushParam pushParam) { try { pushServiceThreadExecutor.submit(() -& ...
SAP中数据库表长度的界定
SAP中,如何查看表和关键字的长度?通过SE11菜单栏Extras->table width 可以看到.然而SAP在系统也会将表分类,特别是在可扩展的表维护视图中,分为如下几类 ult ...
容器编排系统K8s之包管理器helm基础使用（二）
前文我们介绍了helm的相关术语和使用helm安装和卸载应用,回顾请参考:https://www.cnblogs.com/qiuhom-1874/p/14305902.html:今天我们来介绍下自定义 ...
[Usaco2008 Nov]Buying Hay 购买干草
题目描述约翰的干草库存已经告罄,他打算为奶牛们采购H(1≤H≤50000)磅干草,他知道N(1≤N≤100)个干草公司,现在用1到N给它们编号.第i个公司卖的干草包重量为Pi(1≤Pi≤5000)磅 ...
USB限流芯片，4.8A最大，过压关闭6V
PW1503,PW1502是超低RDS(ON)开关,具有可编程的电流限制,以保护电源源于过电流和短路保护.它具有超温保护以及反向闭锁功能. PW1503,PW1502采用薄型(1毫米)5针薄型SOT2 ...
论super().__init__()的用法
当我们调用 super() 的时候,实际上是实例化了一个 super 类. super 是个类,既不是关键字也不是函数等其他数据结构,该对象就是专门用来访问父类中的属性的(严格按照继承的关系). -- ...
HTML5与CSS3知识点总结
好好学习,天天向上本文已收录至我的Github仓库DayDayUP:github.com/RobodLee/DayDayUP,欢迎Star 原文链接:https://blog.csdn.net/we ...
Property or method "previewUrl" is not defined on the instance but referenced during render. Make sure that this property is reactive, either in the data option, or for class-based components,
Property or method "previewUrl" is not defined on the instance but referenced during rende ...
Web自动化测试python环境中安装 --selenium安装、火狐和火狐驱动版本、谷歌和谷歌驱动版本、测试
一.安装selenium Windows命令行(cmd)输入pip install selenium(无须指定版本默认最新)或 pip install selenium==3.141.0(可指定版本) ...
改造xxl-job的客户端日志文件生成体系
为什么要改造XXL-JOB原有的日志文件生成体系 xxl-job原本自己的客户端日志文件生成策略是:一个日志记录就生成一个文件,也就是当数据库存在一条日志logId,对应的客户端就会生成一个文件, ...

spring再学习之AOP事务

spring再学习之AOP事务的更多相关文章

随机推荐

热门专题