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 ...

随机推荐

Upload - Labs (上)
Pass - 01: 1.尝试上传一个php文件:aaa.php,发现只允许上传某些图片类型,用bp抓包,发现http请求都没通过burp就弹出了不允许上传的提示框,这表明验证点在前端,而不在服务端 ...
oracle新增ID主键列，如何补全旧数据的ID值
1.创建SEQUENCE CREATE SEQUENCE MONKEY.TEST_ADD_IDCOL_ID CACHE 100; 2.新增表栏位 ALTER TABLE MONKEY.TEST_ADD ...
inode占满导致No space left on device inode快速解决方法
暂未发现其他比我这个更快的方法. 因为其他方法会展示那个非常卡的目录,导致效率极低.而我这个方法不会去展示那个目录. 查找占用的目录 find / -type d -size +1M -maxdept ...
django url别名和反向解析命名空间
url别名和反向解析我们平时写的url名字都是死的,如果项目过大,需要项目中某个文件名改动一下,那么改动起来就不是一般的麻烦了,所以我们就在定义的时候给url起一个别名,以后不管哪个文件中运用都是用 ...
使用fdopen对python进程产生的文件进行权限最小化配置
需求背景用python进行文件的创建和读写操作时,我们很少关注所创建的文件的权限配置.对于一些安全性较高的系统,如果我们创建的文件权限其他用户或者同一用户组里的其他用户有可读权限的话,有可能导致不必 ...
使用git上传代码到github远程仓库
一.新建代码库注册好github登录后,首先先在网页上新建代码库. 点击右上角"+"→New repository 进入如下页面:按照要求填写完成后,点击按钮创建代码库创建成功. ...
C#高级编程第11版 - 第六章索引
[1]6.2 运算符 1.&符在C#里是逻辑与运算.管道符号|在C#里则是逻辑或运算.%运算符用来返回除法运算的余数,因此当x=7时,x%5的值将是2. [2]6.2.1 运算符的简写 1.下 ...
琐碎的想法（三）对Java的批评的看法
编写本文的目的在大环境下,Java是一个饱受争议的语言,一方面在工程上它的流行程度非常高:另一方面,越是资深的软件工程师就越容易对这个语言感到不满. 在这种情况下,博主希望每一个Java程序员能够耐 ...
Django runserver 默认多线程监听文件变动
django-admin and manage.py | Django documentation | Django https://docs.djangoproject.com/en/3.0/ref ...
阿里巴巴微服务与配置中心技术实践之道配置推送 ConfigurationManagement ConfigDrivenAnyting
阿里巴巴微服务与配置中心技术实践之道原创: 坤宇 InfoQ 2018-02-08 在面向分布式的微服务系统中,如何通过更高效的配置管理方式,帮助微服务系统架构持续"无痛"的演进 ...

spring再学习之AOP事务

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

随机推荐

热门专题