Spring事务管理与模板对象

已于 2024-03-05 09:34:47 修改
阅读量787 收藏 10
点赞数 7
分类专栏： Spring 文章标签： spring 数据库 java
于 2024-03-05 09:34:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_61611746/article/details/134516315
版权

1.事务管理

1.事务回顾

事务指数据库中多个操作合并在一起形成的操作序列

事务的作用

当数据库操作序列中个别操作失败时，提供一种方式使数据库状态恢复到正常状态（A），保障数据库即使在异常状态下仍能保持数据一致性（C）（要么操作前状态，要么操作后状态）。

当出现并发访问数据库时，在多个访问间进行相互隔离，防止并发访问操作结果互相干扰（I）

事务的特征（ACID）

原子性（Atomicity）指事务是一个不可分割的整体，其中的操作要么全执行或全不执行

一致性（Consistency）事务前后数据的完整性必须保持一致

隔离性（Isolation）事务的隔离性是多个用户并发访问数据库时，数据库为每一个用户开启的事务，不能被其他事务的操作数据所干扰，多个并发事务之间要相互隔离

持久性（Durability）持久性是指一个事务一旦被提交，它对数据库中数据的改变就是永久性的，接下来即使数据库发生故障也不应该对其有任何影响

事务的隔离级

脏读：允许读取未提交的信息

原因：Read uncommitted

解决方案： （表级读锁）

不可重复读：读取过程中单个数据发生了变化

解决方案： Repeatable read （行级写锁）

幻读：读取过程中数据条目发生了变化

解决方案： Serializable（表级写锁）

2.Spring事务核心对象

J2EE开发使用分层设计的思想进行，对于简单的业务层转调数据层的单一操作，事务开启在业务层或者数据层并无太大差别，当业务中包含多个数据层的调用时，需要在业务层开启事务，对数据层中多个操作进行组合并归属于同一个事务进行处理

Spring为业务层提供了整套的事务解决方案

        PlatformTransactionManager

        TransactionDefinition

        TransactionStatus

PlatformTransactionManager（平台事务管理器）

这是一个接口

平台事务管理器实现类：

DataSourceTransactionManager   适用于Spring JDBC或MyBatis

HibernateTransactionManager   适用于Hibernate3.0及以上版本

JpaTransactionManager   适用于JPA

JdoTransactionManager   适用于JDO

JtaTransactionManager   适用于JTA

JPA（Java Persistence API）Java EE 标准之一，为POJO提供持久化标准规范，并规范了持久化开发的统一API，符合JPA规范的开发可以在不同的JPA框架下运行

JDO(Java Data Object )是Java对象持久化规范，用于存取某种数据库中的对象，并提供标准化API。与JDBC相比，JDBC仅针对关系数据库进行操作，JDO可以扩展到关系数据库、文件、XML、对象数据库（ODBMS）等，可移植性更强

JTA（Java Transaction API）Java EE 标准之一，允许应用程序执行分布式事务处理。与JDBC相比，JDBC事务则被限定在一个单一的数据库连接，而一个JTA事务可以有多个参与者，比如JDBC连接、JDO 都可以参与到一个JTA事务中

此接口定义了事务的基本操作

获取事务

TransactionStatus getTransaction(TransactionDefinition definition)

提交事务 

void commit(TransactionStatus status)

回滚事务 

void rollback(TransactionStatus status)

TransactionDefinition（事务定义的接口）

此接口定义了事务的基本信息

获取事务定义名称

String getName()

获取事务的读写属性

boolean isReadOnly()

获取事务隔离级别

int getIsolationLevel()

获事务超时时间

int getTimeout()

获取事务传播行为特征

int getPropagationBehavior()

TransactionStatus（事务状态的接口）

此接口定义了事务在执行过程中某个时间点上的状态信息及对应的状态操作

获取事务是否处于新开启事务状态

boolean isNewTransaction()

获取事务是否处于已完成状态

boolean isCompleted()

获取事务是否处于回滚状态

boolean isRolbackOnly()

刷新事务状态

void flush()

获取事务是否具有回滚存储点

boolean hasSavepoint()

设置事务处于回滚状态

void setRollbackOnly()

3.事务控制方式

编程式

声明式（XML）

声明式（注解）

4.案例环境

银行转账业务说明

银行转账操作中，涉及从A账户到B账户的资金转移操作。数据层仅提供单条数据的基础操作，未设计多账户间的业务操作

package com.dao;

import org.apache.ibatis.annotations.Param;


public interface AccountDao {
    /*
    * 入账操作
    * name  入账用户名
    * money  入账金额
    */
    void inMoney(@Param("name") String name, @Param("money") Double money);

    /*
     * 入账操作
     * name  出账用户名
     * money  出账金额
     */
    void outMoney(@Param("name") String name, @Param("money") Double money);

}

package com.domain;

public class Account {
    private Integer id;
    private String name;
    private Double money;

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Double getMoney() {
        return money;
    }
    public void setMoney(Double money) {
        this.money = money;
    }
    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}
package com.service;

public interface AccountService {
    /*
    * 转账操作
    * outName  出账用户名
    * inName  入账用户名
    * money   转账金额
    */
    public void transfer(String outName, String inName, Double money);
}

package com.service.impl;

import com.dao.AccountDao;
import com.service.AccountService;

public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }

    @Override
    public void transfer(String outName, String inName, Double money) {
        accountDao.inMoney(outName,money);
        accountDao.outMoney(inName,money);
    }
}


<?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 https://www.springframework.org/schema/context/spring-context.xsd">
    <context:property-placeholder location="classpath:*.properties"/>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <bean id="accountService" class="com.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
    </bean>
    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="com.domain"/>
    </bean>
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.dao"/>
    </bean>
</beans>
<?xml version="1.0" encoding="UTF-8" ?>
<!--MyBatis的DTD约束-->
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.dao.AccountDao">
    <update id="inMoney">
        update account set money = money + #{money} where name = #{name}
    </update>

    <update id="outMoney">
        update account set money = money - #{money} where name = #{name}
    </update>
</mapper>
jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8&useSSL=false
jdbc.username=root
jdbc.password=123456

5.使用AOP控制事务 （XML）

将业务层的事务处理功能抽取出来制作成AOP通知，利用环绕通知运行期动态织入

范例

public Object tx(ProceedingJoinPoint pjp) throws Throwable {
    DataSourceTransactionManager dstm = new DataSourceTransactionManager();
    dstm.setDataSource(dataSource);
    TransactionDefinition td = new DefaultTransactionDefinition();
    TransactionStatus ts = dstm.getTransaction(td);
    Object ret = pjp.proceed(pjp.getArgs());
    dstm.commit(ts);
    
    return ret;
}

<bean id="txAdvice" class="com.aop.TxAdvice">
	<property name="dataSource" ref="dataSource"/>
</bean>

使用aop:advisor在AOP配置中引用事务专属通知类

<aop:config>
    <aop:pointcut id="pt" expression="execution(* *..transfer(..))"/>
    <aop:aspect ref="txAdvice">
        <aop:around method="tx" pointcut-ref="pt"/>
    </aop:aspect>
</aop:config>

样例

package com.service.impl;

import com.dao.AccountDao;
import com.service.AccountService;
import javafx.application.Platform;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

import javax.sql.DataSource;

public class AccountServiceImpl implements AccountService {
    private AccountDao accountDao;

    public void setAccountDao(AccountDao accountDao) {
        this.accountDao = accountDao;
    }
    /*private DataSource dataSource;

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }*/

    @Override
    public void transfer(String outName, String inName, Double money) {
       /* //开启事务
        PlatformTransactionManager ptm = new DataSourceTransactionManager(dataSource);
        //事务定义
        TransactionDefinition td = new DefaultTransactionDefinition();
        //事务状态
        TransactionStatus ts = ptm.getTransaction(td);*/
        accountDao.inMoney(outName,money);
        //int i = 1/0;
        accountDao.outMoney(inName,money);
        /*ptm.commit(ts);*/
    }
}


package com.aop;

import org.aspectj.lang.ProceedingJoinPoint;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;
import org.springframework.transaction.support.DefaultTransactionDefinition;

import javax.sql.DataSource;

public class TxAdvice {
    private DataSource dataSource;

    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }

    public Object transactionManager(ProceedingJoinPoint pjp) throws  Throwable{

        //开启事务
        PlatformTransactionManager ptm = new DataSourceTransactionManager(dataSource);
        //事务定义
        TransactionDefinition td = new DefaultTransactionDefinition();
        //事务状态
        TransactionStatus ts = ptm.getTransaction(td);
        Object ret = pjp.proceed(pjp.getArgs());
        ptm.commit(ts);
        return ret;
    }
}

 <bean id="txAdvice" class="com.aop.TxAdvice">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <aop:config>
        <aop:pointcut id="pt" expression="execution(* *..taransfer(..))"/>
        <aop:aspect ref="txAdvice">
            <aop:around method="transactionManager" pointcut-ref="pt"/>
        </aop:aspect>
    </aop:config>

6.声明式事务（XML）

tx配置----tx:advice

名称：tx:advice

类型：标签

归属：beans标签

作用：专用于声明事务通知

格式

<beans>
    <tx:advice id="txAdvice" transaction-manager="txManager">
    </tx:advice>
</beans>

基本属性：

id ：用于配置aop时指定通知器的id

transaction-manager ：指定事务管理器bean

tx配置----tx:attributes

名称：tx:attributes

类型：标签

归属：tx:advice标签

作用：定义通知属性

格式

<tx:advice id="txAdvice" transaction-manager="txManager">
    <tx:attributes>
    </tx:attributes>
</tx:advice>

基本属性：无

tx配置----tx:method

名称：tx:method

类型：标签

归属：tx:attribute标签

作用：设置具体的事务属性

格式

<tx:attributes>
    <tx:method name="*" read-only="false" />
    <tx:method name="get*" read-only="true" />
</tx:attributes>

说明：通常事务属性会配置多个，包含一个读写的全事务属性，一个只读的查询类事务属性 

样例

开启tx命名空间 

<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"
       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/context
       https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx
       https://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">
<bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <!--定义事务管理的通知类-->
    <tx:advice id="txAdvice" transaction-manager="txManager">
        <!--定义控制的事务-->
        <tx:attributes>
            <tx:method name="*" read-only="false"/>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="find" read-only="true"/>
            <tx:method name="transfer" read-only="false"/>
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <aop:pointcut id="pt" expression="execution(* com.service.*Service.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/>
    </aop:config>

 此时aop.TxAdvice就可以删除了

<!--<bean id="txAdvice" class="com.aop.TxAdvice">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <aop:config>
        <aop:pointcut id="pt" expression="execution(* *..transfer(..))"/>
        <aop:aspect ref="txAdvice">
            <aop:around method="transactionManager" pointcut-ref="pt"/>
        </aop:aspect>
    </aop:config>-->

此段也要删除

aop:advice与aop:advisor区别

aop:advice配置的通知类可以是普通java对象，不实现接口，也不使用继承关系

aop:advisor配置的通知类必须实现通知接口

        MethodBeforeAdvice

        AfterReturningAdvice

        ThrowsAdvice

        ……

7.tx:method属性

<tx:method
        name="*"			待添加事务的方法名表达式(支持*号通配符)
        read-only="false"	设置事务的读写属性，true为只读，false为读写
        timeout="-1"		设置事务超时时长，单位秒
        isolation="DEFAULT"	设置事务隔离级别，该隔离级别设定是基于Spring的设定，非数据库端
        no-rollback-for="java.lang.ArithmeticException"	设置事务中不回滚的异常，多个异常间使用,分割
        rollback-for=""			设置事务中必回滚的异常，多个异常间使用,分割
        propagation="REQUIRED"	设置事务的传播行为
        />

8.事务传播行为 

事务传播行为描述的是事务协调员对事务管理员所携带事务的处理态度

企业开发过程中，发现同属于同一个事务控制的各个业务中，如果某个业务与其他业务隔离度较高，拥有差异化的数据业务控制情况，通常使用事务传播行为对其进行控制

9.声明式事务（注解）

@Transactional

名称：@Transactional

类型：方法注解，类注解，接口注解

位置：方法定义上方，类定义上方，接口定义上方

作用：设置当前类/接口中所有方法或具体方法开启事务，并指定相关事务属性

范例

@Transactional(
    readOnly = false,
    timeout = -1,
    isolation = Isolation.DEFAULT,
    rollbackFor = {ArithmeticException.class, IOException.class},
    noRollbackFor = {},
    propagation = Propagation.REQUIRES_NEW
)

tx:annotation-driven

名称：tx:annotation-driven

类型：标签

归属：beans标签

作用：开启事务注解驱动，并指定对应的事务管理器

范例

<tx:annotation-driven transaction-manager="txManager"/>

样例

<?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"
       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/context
       https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/tx
       https://www.springframework.org/schema/tx/spring-tx.xsd
       http://www.springframework.org/schema/aop
       https://www.springframework.org/schema/aop/spring-aop.xsd">
    <context:property-placeholder location="classpath:*.properties"/>

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>
    <bean id="accountService" class="com.service.impl.AccountServiceImpl">
        <property name="accountDao" ref="accountDao"/>
        <!--<property name="dataSource" ref="dataSource"/>-->
    </bean>
    <bean class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dataSource"/>
        <property name="typeAliasesPackage" value="com.domain"/>
    </bean>
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <property name="basePackage" value="com.dao"/>
    </bean>

    <bean id="txManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource"/>
    </bean>
    <tx:annotation-driven transaction-manager="txManager"/>

   <!-- <tx:advice id="txAdvice" transaction-manager="txManager">
        <tx:attributes>
            <tx:method name="*" read-only="false"/>
            <tx:method name="get*" read-only="true"/>
            <tx:method name="find" read-only="true"/>
            <tx:method name="transfer" read-only="false"/>
        </tx:attributes>
    </tx:advice>
    <aop:config>
        <aop:pointcut id="pt" expression="execution(* com.service.*Service.*(..))"/>
        <aop:advisor advice-ref="txAdvice" pointcut-ref="pt"/>
    </aop:config>-->
</beans>

package com.service;

import org.springframework.transaction.annotation.Isolation;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
@Transactional(isolation = Isolation.DEFAULT)
public interface AccountService {
    /*
    * 转账操作
    * outName  出账用户名
    * inName  入账用户名
    * money   转账金额
    */
    @Transactional(
            readOnly = false,
            timeout = -1,
            isolation = Isolation.DEFAULT,
            rollbackFor = {},  //java.lang.ArithmeticException.class, IOException.class
            noRollbackFor = {},
            propagation = Propagation.REQUIRED
    )
    public void transfer(String outName, String inName, Double money);
}

10.声明式事务（纯注解驱动）

名称：@EnableTransactionManagement

类型：类注解

位置：Spring注解配置类上方

作用：开启注解驱动，等同XML格式中的注解驱动

范例

@Configuration
@ComponentScan("com.lichee")
@PropertySource("classpath:jdbc.properties")
@Import({JDBCConfig.class,MyBatisConfig.class,TransactionManagerConfig.class})
@EnableTransactionManagement
public class SpringConfig {
}

public class TransactionManagerConfig {
    @Bean
    public PlatformTransactionManager getTransactionManager(@Autowired DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }
}

样例

package com.domain;

public class Account {
    private Integer id;
    private String name;
    private Double money;

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Double getMoney() {
        return money;
    }
    public void setMoney(Double money) {
        this.money = money;
    }
    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", money=" + money +
                '}';
    }
}
package com.dao;

import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Update;


public interface AccountDao {
    @Update("update account set money = money + #{money} where name = #{name}")
    void inMoney(@Param("name") String name, @Param("money") Double money);


    @Update("update account set money = money - #{money} where name = #{name}")
    void outMoney(@Param("name") String name, @Param("money") Double money);

}

package com.service;

import org.springframework.transaction.annotation.Transactional;
@Transactional
public interface AccountService {
    public void transfer(String outName, String inName, Double money);
}

package com.service.impl;

import com.dao.AccountDao;
import com.service.AccountService;
import org.apache.ibatis.annotations.Arg;
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;

import java.io.IOException;
@Service("accountService")
public class AccountServiceImpl implements AccountService {
    @Autowired
    private AccountDao accountDao;

    public void transfer(String outName, String inName, Double money) {
        accountDao.inMoney(outName,money);
        //int i = 1/0;
        accountDao.outMoney(inName,money);
    }
}

package com.config;

import org.springframework.context.annotation.*;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@Configuration
@ComponentScan("com")
@PropertySource("classpath:jdbc.properties")
@Import({JDBCConfig.class,MyBatisConfig.class})
@EnableTransactionManagement
public class SpringConfig {
}

package com.config;

import com.alibaba.druid.pool.DruidDataSource;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.jdbc.datasource.DataSourceTransactionManager;
import org.springframework.transaction.PlatformTransactionManager;

import javax.sql.DataSource;

public class JDBCConfig {
    @Value("${jdbc.driver}")
    private String driver;
    @Value("${jdbc.url}")
    private String url;
    @Value("${jdbc.username}")
    private String userName;
    @Value("${jdbc.password}")
    private String password;
    @Bean("dataSource")
    public DataSource getDataSource(){
        DruidDataSource ds = new DruidDataSource();
        ds.setDriverClassName(driver);
        ds.setUrl(url);
        ds.setUsername(userName);
        ds.setPassword(password);
        return ds;
    }
    public PlatformTransactionManager gerTransactionManager(DataSource dataSource){
        return new DataSourceTransactionManager(dataSource);
    }
}

package com.config;

import org.mybatis.spring.SqlSessionFactoryBean;
import org.mybatis.spring.mapper.MapperScannerConfigurer;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;

import javax.sql.DataSource;

public class MyBatisConfig {
    @Bean
    public SqlSessionFactoryBean getSqlSessionFactoryBean(@Autowired DataSource dataSource){
        SqlSessionFactoryBean ssfb = new SqlSessionFactoryBean();
        ssfb.setTypeAliasesPackage("com.domain");
        ssfb.setDataSource(dataSource);
        return ssfb;
    }
    @Bean
    public MapperScannerConfigurer getMapperScannerConfigurer(){
        MapperScannerConfigurer msc = new MapperScannerConfigurer();
        msc.setBasePackage("com.dao");
        return msc;
    }
}

jdbc.properties 

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/spring_db?serverTimezone=UTC&useUnicode=true&characterEncoding=UTF-8&useSSL=false
jdbc.username=root
jdbc.password=123456
package com.service;

import com.config.SpringConfig;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;


//设定spring专用的类加载器
@RunWith(SpringJUnit4ClassRunner.class)
//设定加载的spring上下文对应的配置
@ContextConfiguration(classes = SpringConfig.class)
public class UserServiceTest {
    @Autowired
    private AccountService accountService;
    @Test
    public void testTransfer(){
       accountService.transfer("Jock1","Jock2",100D);
    }
}

2.模板对象

1.Spring模板对象

TransactionTemplate

JdbcTemplate

RedisTemplate

RabbitTemplate

JmsTemplate

HibernateTemplate

RestTemplate

2.JdbcTemplate

提供标准的sql语句提供API

public void save(Account account) {
    String sql = "insert into account(name,money)values(?,?)";
    jdbcTemplate.update(sql,account.getName(),account.getMoney());
}

3.NamedParameterJdbcTemplate 

提供标准的sql语句提供API

public void save(Account account) {
    String sql = "insert into account(name,money)values(:name,:money)";
    Map pm = new HashMap();
    pm.put("name",account.getName());
    pm.put("money",account.getMoney());
    jdbcTemplate.update(sql,pm);
}

4.RedisTemplate

RedisTemplate对象结构

public void changeMoney(Integer id, Double money) {
    redisTemplate.opsForValue().set("account:id:"+id,money);
}
public Double findMondyById(Integer id) {
    Object money = redisTemplate.opsForValue().get("account:id:" + id);
    return new Double(money.toString());
}

3.事务底层原理解析

策略模式（Strategy Pattern）使用不同策略的对象实现不同的行为方式，策略对象的变化导致行为的变化

天演L
关注
  • 7
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
事务模板接入(spring的编程式事务)
yjclsx的博客
07-31 42万+
事务模板接入 这里接入的是spring的编程式事务，代理一下spring的TransactionTemplate就可以了。 importorg.springframework.transaction.TransactionException; importorg.springframework.transaction.support.TransactionCallback; im...
Spring的事务管理小案例
09-11
在本文中，我们将深入探讨Spring框架中的事务管理。Spring是一个广泛应用的Java企业级应用开发框架，它提供...如果你想要深入了解，可以参考提供的博客链接或其他相关资料，进一步学习Spring事务管理的细节和最佳实践。
spring事务模板使用
weixin_34072458的博客
01-22 131
1.配置spring事务模板bean     &lt;!--spring 模板事务--&gt;    &lt;bean id="transactionProxy" abstract="true"        class="org.springframework.transaction.interceptor.TransactionProxyFactoryBean"&gt;        &lt...
Spring事务管理模板
oicq2008的专栏
05-28 2688
通常建议采用声明式事务管理。声明式事务管理的优势非常明显：代码中无需关于关注事务逻辑，让Spring声明式事务管理负责事务逻辑，声明式事务管理无需与具体的事务逻辑耦合，可以方便地在不同事务逻辑之间切换。声明式事务管理的配置方式，通常有如下三种：1.使用TransactionProxyFactoryBean为目标bean生成事务代理的配置。此方式是最传统，配置文件最臃肿、难以阅读的方式。2.采用be
014_Spring事务
aihiao的专栏
02-06 177
一. 事务 1. 什么事务? 1.1. 事务: 逻辑上的一组操作, 组成这组操作的各个单元, 要么全都成功, 要么全都失败。 2. 事务的特性 2.1. 原子性: 事务不可分割。 2.2. 一致性: 事务执行前后数据完整性保持一致。 2.3. 隔离性: 一个事务的执行不应该受到其他事务的干扰。 2.4. 持久性: 一旦事务结束, 数据就持久化到数据库。 3. 如果不考虑隔离性引发安全性问题 3.1. 读问题 3.1.1. 脏读: 一个事务读到另一个事务未提交的数据。 3.1.2. 不可
事务模板
10-25 108
为什么提供事务模板 截至到现在为止，除非你使用dao.execute(Sql ...)，一次执行多个 SQL，是事务安全的，其他的情况 均是事务不安全的，比如如下代码： Pet pet1 = dao.fetch(Pet.class,"XiaoBai"); Pet pet2 = dao.fetch(Pet.class,"XiaoHei"); pet1.setNickna...
spring事务管理
07-25
### Spring事务管理详解 #### 一、Spring事务管理概述 Spring 框架提供了一种强大的事务管理机制，能够帮助开发者轻松地管理应用程序中的事务。事务管理是企业级应用开发中不可或缺的一部分，它确保了数据操作的...
Wordpress Spring模板
08-23
1. **依赖注入（DI）**：Spring框架的核心特性之一，它允许开发者通过外部容器管理对象的依赖关系，而不是在代码中硬编码。在WordPress中，这可以帮助简化插件和主题的构建，减少代码之间的耦合度。 2. **面向切面...
Spring+SpringMvc+Mybatis学生管理系统
06-19
此外，Spring还提供了AOP（面向切面编程）功能，方便进行日志记录、事务管理等跨切面操作。 2. **SpringMVC**：SpringMVC是Spring框架的一个模块，专门处理Web层的请求和响应。它将MVC设计模式应用于Java Web开发，...
spring 整合JDBC和AOP事务的方法
08-27
现在，我们可以将 JDBC 模板和 AOP 事务整合到一起来实现事务的管理。我们可以在 UserDaoImpl 类中使用 JdbcTemplate 来实现数据库操作，并使用 @Transactional 注解来实现事务的管理。 例如，我们可以使用以下代码...
配制Spring事务和JdbcTemplate使用
10-08
配制Spring事务和JdbcTemplate使用 配制Spring事务和JdbcTemplate使用
java事务 - 模板设计模式
09-13
Template模板设计模式改造threadlocal控制事务
学习spring事务模板
qiuleng2002的专栏
12-28 823
通过学习spring事务模板：提供服务者可以要求客户端调用时实现第三方接口，该接口实现会在服务者提供服务时调用，完成服务方回调客户段代码。而在接口实现参数可以充当服务方提供给客户端额外的功能。例如：1：服务方为TransactionTemplate.execute，这个方法提供事务管理功能。2：而客户端会依照服务方实现TransactionCallback这个第三方接口，实现doInTra
【Spring4（三）】Spring的事务管理和JDBC模板的使用
风信子
11-16 212
Spring 的 AOP 的基于 AspectJ 注解开发 Spring 的基于AspectJ 的注解的 AOP 开发 创建项目，引入 jar 包 引入配置文件 applicationContext.xml &lt;?xml version="1.0" encoding="UTF-8"?&gt; &lt;beans xmlns="http://www.springframework.org/sc...
事务模板 VS 声明式事务
weixin_34249678的博客
09-26 175
事务模板 VS声明式事务 一、案例 我们首先看几个简单的案例。 1. 声明式事务示例一 @Transactional public voidaddData(long orderId,Object orderDetailDTO){ //查询操作 OrderDO orderDO = orderManage...
Spring框架-5(JDBC模板&Spring事务管理)
刘桂林
01-23 390
本文作者231-2018zho007博客：https://www.jianshu.com/u/e9cb5fd3aaa8声明：本文由作者 zho007 授权发布，未经原作者允许请勿转载 看到上面蓝色字了吗，点下吧系列文章：Spring框架-1(基础)Spring框架-2(IOC上)Spring框架-3(IOC下)Spring框架-4(AOP)Spring框架-5(JDBC模板&Spring事务管理)
【Spring】论对spring事务和数据库模板的理解和思路整理
weixin_48562055的博客
03-14 932
是什么 As we know ,spring不仅在创建对象的事情还有低耦合的设计上操心，还在对数据库的事务的支持也有帮助。 Spring JDBC 提供了多个实用的数据库访问工具，以简化 JDBC 的开发，其中使用最多就是 JdbcTemplate。 不过这个我们不常用 ，这里暂且不论 关键在于对事务的支持. 事务具有 4 个特性：原子性、一致性、隔离性和持久性，简称为 ACID 特性。 原子性（Atomicity）：一个事务是一个不可分割的工作单位，事务中包括的动作要么都做要么都不做。 一致性（Con.
Spring与Hibernate集成：声明式事务管理
本资源主要探讨了Spring框架与Hibernate ORM（对象关系映射）工具的集成，以及如何在两者之间实现声明式事务处理。声明式事务管理是Spring框架的一大特点，它简化了事务处理的复杂性，使得开发者无需显式编写事务...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值