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

随机推荐

python无法连接mysql，有个小坑，需要注意一下！
尝试用python链接mysql数据库,按照教程里链接了小半夜,就是没有链接上,找了各种文章,最后发现是版本的问题,我想使用的模块是MySQLdb,刚刚去他们的官网看了一下,最近一次更新是2014年, ...
小试牛刀ElasticSearch大数据聚合统计
ElasticSearch相信有不少朋友都了解,即使没有了解过它那相信对ELK也有所认识E即是ElasticSearch.ElasticSearch最开始更多用于检索,作为一搜索的集群产品简单易用绝对 ...
openshift 3.11安装部署
openshift 3.11 安装部署 openshift安装部署 1 环境准备(所有节点) openshift 版本 v3.11 1.1 机器环境 ip cpu mem hostname OSsys ...
websocket的应用---Django
websocket的应用---Django 1.长轮询轮询:在前端通过写js实现.缺点:有延迟.服务器压力大. 就是客户端通过一定的时间间隔以频繁请求的方式向服务器发送请求,来保持客户端和服务器端的 ...
采用Sharding-JDBC解决分库分表
源码:Sharding-JDBC(分库分表) 一.Sharding-JDBC介绍 1,介绍 Sharding-JDBC是当当网研发的开源分布式数据库中间件,从 3.0 开始Sharding-JDBC被 ...
大促密集，CDN如何保障电商体验如丝般顺滑？
简介: 前不久,阿里云技术天团空降CSDN在线峰会,对核心技术竞争力进行解读.其中,阿里云高级技术专家曾福华分享了<双11: CDN如何保障电商大促如丝般顺滑>的议题.俗话说:养兵千日,用 ...
MySQL 中的临时表
在使用 explain 解析一个 sql 时,有时我们会发现在 extra 列上显示 using temporary ,这表示这条语句用到了临时表,那么临时表究竟是什么?它又会对 sql 的性能产生什 ...
Win+R 快速启动程序
将某个程序的可执行C:\Program Files\Oracle\VirtualBox\VirtualBox.exe 或其快捷键放入某个自建的快捷键集合文件夹,可以自定义命名如 vb 将其添加到 ...
正则r的作用
>>> mm = "c:\\a\\b\\c" >>> mm 'c:\\a\\b\\c' >>> print(mm) c:\a\ ...
Python学习【第3篇】：列表魔法
##########################深灰魔法-list类中提供的方法###################list 类,列表list = [1,12,9,"age" ...

spring再学习之AOP事务

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

随机推荐

热门专题