事物的用法

最新推荐文章于 2023-03-12 11:48:08 发布
最新推荐文章于 2023-03-12 11:48:08 发布
阅读量250 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangwenfu123/article/details/78615292
版权

首先建立一个mavne项目

在pom文件导入依赖

<?xml version="1.0" encoding="UTF-8"?>
<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.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.spring3</groupId>
    <artifactId>spring3</artifactId>
    <version>1.0-SNAPSHOT</version>
    <properties>
        <spring-context.version>3.2.8.RELEASE</spring-context.version>
        <spring-aspects.version>3.1.4.RELEASE</spring-aspects.version>
        <spring-core.version>3.2.8.RELEASE</spring-core.version>
        <spring-aop.version>3.2.8.RELEASE</spring-aop.version>
        <aspectjrt.version>1.8.1</aspectjrt.version>
        <aspectjweaver.version>1.5.4</aspectjweaver.version>
        <spring-beans.version>3.2.8.RELEASE</spring-beans.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring-context.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring-aspects.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring-core.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aop</artifactId>
            <version>${spring-aop.version}</version>
        </dependency>
        <dependency>
            <groupId>org.aspectj</groupId>
            <artifactId>aspectjrt</artifactId>
            <version>${aspectjrt.version}</version>
        </dependency>
        <dependency>
            <groupId>aspectj</groupId>
            <artifactId>aspectjweaver</artifactId>
            <version>${aspectjweaver.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring-beans.version}</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>3.1.2.RELEASE</version>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-expression</artifactId>
            <version>4.3.12.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.43</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.1</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis-spring</artifactId>
            <version>1.3.0</version>
        </dependency>
        <dependency>
            <groupId>commons-dbcp</groupId>
            <artifactId>commons-dbcp</artifactId>
            <version>1.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>4.3.10.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-tx</artifactId>
            <version>3.1.1.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>javax.persistence</groupId>
            <artifactId>persistence-api</artifactId>
            <version>1.0</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.25</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
        </dependency>
    </dependencies>


</project>
最好添加上
<dependency>
    <groupId>commons-logging</groupId>
    <artifactId>commons-logging</artifactId>
    <version>1.2</version>
</dependency>
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>
这样控制台就可以输出运行的信息
commons-logging是Apache commons类库中的一员。Apache commons类库是一个通用的类库，提供了基础的功能，比如说commons-fileupload，commons-httpclient，commons-io，commons-codes等。
commons-logging能够选择使用Log4j还是JDK Logging，但是他不依赖Log4j，JDK Logging的API。如果项目的classpath中包含了log4j的类库，就会使用log4j，否则就使用JDK Logging。使用commons-logging能够灵活的选择使用那些日志方式，而且不需要修改源代码

如果有Log4j，commons-logging会把输出原封不动的交给log4j。如果没有log4j，commons-logging会将相应的输出转化成JDK Logging的输出

但是JDK自带的Logging其实是一个鸡肋，竟然没有debug的日志级别 所以还是让log4j管理比较好
但是要在classpath下添加log4j.properties配置文件如下:
log4j.rootLogger=DEBUG,console

# 以下是rootLogger的配置，子类默认继承，但是子类重写下面配置=rootLogger+自己配置，我晕
#输出到控制台
log4j.appender.console=org.apache.log4j.ConsoleAppender
#设置输出样式
log4j.appender.console.layout=org.apache.log4j.PatternLayout
#日志输出信息格式为
log4j.appender.console.layout.ConversionPattern=[%-d{yyyy-MM-dd HH:mm:ss}]-[%t-%5p]-[%C-%M(%L)]： %m%n


#默认的，common-logging会自动检查是否使用log4j，也可以使用配置文件显示的启用log4j。
#配置文件为commons-logging.properties，放在程序的classpath下即可。
#commons-logging已经支持自动扫描了，我们就不需要人为的添加这些无聊的配置文件了。
#org.apache.commons.logging.Log=org.apache.commons.logging.impl.Log4J-Logger
#org.apache.commons.logging.LogFactory=org.apache.commons.logging.impl.LogFactoryImpl

这样控制台就会输出 好方便我们学习事物
首先我们添加两个实体类 
package transactional.bean;

import com.sun.istack.internal.NotNull;

import javax.persistence.*;



/**
 * 创建一个实体类 如何持久化呢
 * @Entity标注这个类为JPA的一个实体
 *@Table来指定在数据库中的表名
 * 1.使用@Entity进行类的持久化操作,当JPA检测到我们的实体类当中有
 * @Entity 注解的时候会在数据库生成对应的表结构信息
 * 如何指定主键以及主键的生成策略
 * 2.使用@Id指定主键
 * Created by 340092 on 2017/11/17.
 */

@Entity
@Table(name = "cat")
public class Cat {
    /**
     * 使用@Id指定主键
     * @GeneratedValue(strategy = GenerationType.AUTO)指定主键的生成策略 (mysql默认自增长)
     */
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String name;
    private int catAge;
    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getCatAge() {
        return catAge;
    }

    public void setCatAge(int catAge) {
        this.catAge = catAge;
    }
}



package transactional.bean;

import javax.persistence.*;

/**
 * Created by 340092 on 2017/11/22.
 */
@Entity
@Table(name = "user")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;
    private String name;
    private int age;

    public Long getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
建立两个dao(这个使用spring+mybatis管理数据库)
CatDao :
package transactional.dao;

import org.apache.ibatis.annotations.Mapper;
import transactional.bean.Cat;

/**
 * Created by 340092 on 2017/11/22.
 */
public interface CatDao {
    void saveCat(Cat cat);
}

UserDao :
package transactional.dao;

import transactional.bean.User;

/**
 * Created by 340092 on 2017/11/22.
 */
public interface UserDao {
    void saveUser(User user);
}
spring配置文件
<?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: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
       http://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-3.1.xsd
       ">

    <context:property-placeholder location="classpath:mybatis.properties"/>
    <context:component-scan base-package="transactional"/>
    <context:annotation-config />

    <bean id="dataSource"
          class="org.apache.commons.dbcp.BasicDataSource">
        <property name="driverClassName"
                  value="com.mysql.jdbc.Driver"    />
        <property name="url"
                  value="jdbc:mysql://localhost:3306/test3"/>
        <property name="username"
                  value="root"/>
        <property name="password"
                  value="root"/>
    </bean>
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">

    <property name="basePackage"
              value="transactional.dao"/>
</bean>

    <bean id="sqlSessionFactory"
          class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource"
                  ref="dataSource"/>
        <property name="mapperLocations"
                  value="classpath:mapper/*.xml"/>
    </bean>


    <!-- 使用annotation定义事务 -->
    <tx:annotation-driven transaction-manager="transactionManager"
                          proxy-target-class="true" />
    <!-- 事务管理器配置, 使用jdbc事务 -->
    <bean id="transactionManager"
          class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
</beans>
两个mapper文件
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="transactional.dao.CatDao">
    <insert id="saveCat" parameterType="transactional.bean.Cat">
        INSERT INTO  cat(cat_age,name)VALUES (#{catAge},#{name})
    </insert>
</mapper>


<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="transactional.dao.UserDao">
    <insert id="saveUser" parameterType="transactional.bean.User">
        INSERT INTO  user(age,name)VALUES (#{age},#{name})
    </insert>
</mapper>


这样数据库就可以访问了:现在开始测试事物的用法
事务传播性：
1、PROPAGATION_REQUIRED：如果当前没有事务，就创建一个新事务，如果当前存在事务，就加入该事务，该设置是最常用的设置。
2、PROPAGATION_SUPPORTS：自身不会开启事务，在事务范围内则使用相同事务，否则不使用事务。‘
3、PROPAGATION_MANDATORY：支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就抛出异常。
4、PROPAGATION_REQUIRES_NEW：创建新事务，无论当前存不存在事务，都创建新事务。
5、PROPAGATION_NOT_SUPPORTED：以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。
6、PROPAGATION_NEVER：以非事务方式执行，如果当前存在事务，则抛出异常。
7、PROPAGATION_NESTED：如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则执行与PROPAGATION_REQUIRED类似的操作。

     
     

      
      

     
     


首先测试默认的事物传递级别
建立一个service类:如下
package transactional.service;

import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import transactional.bean.Cat;
import transactional.bean.User;
import transactional.dao.CatDao;
import transactional.dao.UserDao;

import javax.annotation.Resource;

/**
 * Created by 340092 on 2017/11/23.
 */
@Component
public class TransactionalTest {
    @Resource
    CatDao catDao;
    @Resource
    UserDao userDao;
    @Resource
    TransactionalTest1 transactionalTest1;

    //这里采用默认传递级别
    @Transactional(propagation= Propagation.REQUIRES_NEW)
    public void saveCatAndUser(){
        //一些逻辑操作 这里略过
        System.out.println("开始保存Cat");

        saveUser();

        Cat cat = new Cat();
        cat.setCatAge(12);
        cat.setName("Tom");
        catDao.saveCat(cat);

        //之后一些操作  这里省略
    }



    @Transactional(propagation= Propagation.REQUIRES_NEW)
    public void saveUser(){
        //一些逻辑操作 等等 略
        System.out.println("开始保存User");
        User user = new User();
        user.setAge(25);
        user.setName("Jack");
        userDao.saveUser(user);
        try {
            sendMessage();
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    public void sendMessage(){
        //这里只是模拟抛出异常
        throw new RuntimeException("发送消息失败");
    }
}

}
建一个测试类:
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;
import transactional.Impl.UserDaoImpl;
import transactional.bean.Cat;
import transactional.bean.User;
import transactional.service.CatService;
import transactional.service.TransactionalTest;
import transactional.service.UserService;

/**
 * Created by 340092 on 2017/11/22.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = {"classpath:springTransactional.xml"})
public class MybatisAndTransactional {
    TransactionalTest transactionalTest;
    @Test
    public void sakljd(){
        transactionalTest.saveCatAndUser();
    }
}
执行测试类会发现:
这种情况下(两个方法在一个类里面)不管是什么级别只会创建一个事物 有异常回滚 如果捕获异常则正常commit

(事物底层的做法是捕获到异常走回滚操作  并把异常抛出)
控制台:
准备测试事物
[2017-11-23 16:11:18]-[main-DEBUG]-[org.springframework.beans.factory.support.AbstractBeanFactory-doGetBean(246)]： Returning cached instance of singleton bean 'transactionManager'
[2017-11-23 16:11:18]-[main-DEBUG]-[org.springframework.transaction.support.AbstractPlatformTransactionManager-getTransaction(365)]： Creating new transaction with name [transactional.service.TransactionalTest.saveCatAndUser]: PROPAGATION_REQUIRES_NEW,ISOLATION_DEFAULT; ''
Thu Nov 23 16:11:18 CST 2017 WARN: Establishing SSL connection without server's identity verification is not recommended. According to MySQL 5.5.45+, 5.6.26+ and 5.7.6+ requirements SSL connection must be established by default if explicit option isn't set. For compliance with existing applications not using SSL the verifyServerCertificate property is set to 'false'. You need either to explicitly disable SSL by setting useSSL=false, or set useSSL=true and provide truststore for server certificate verification.
Thu Nov 23 16:11:18 CST 2017 WARN: Establishing SSL connection without server's identity verification is not recommended. According to MySQL 5.5.45+, 5.6.26+ and 5.7.6+ requirements SSL connection must be established by default if explicit option isn't set. For compliance with existing applications not using SSL the verifyServerCertificate property is set to 'false'. You need either to explicitly disable SSL by setting useSSL=false, or set useSSL=true and provide truststore for server certificate verification.
[2017-11-23 16:11:18]-[main-DEBUG]-[org.springframework.jdbc.datasource.DataSourceTransactionManager-doBegin(248)]： Acquired Connection [jdbc:mysql://localhost:3306/test3, UserName=root@localhost, MySQL Connector Java] for JDBC transaction
[2017-11-23 16:11:18]-[main-DEBUG]-[org.springframework.jdbc.datasource.DataSourceTransactionManager-doBegin(265)]： Switching JDBC Connection [jdbc:mysql://localhost:3306/test3, UserName=root@localhost, MySQL Connector Java] to manual commit
开始保存Cat
开始保存User
[2017-11-23 16:11:18]-[main-DEBUG]-[org.springframework.transaction.support.AbstractPlatformTransactionManager-processRollback(843)]： Initiating transaction rollback
[2017-11-23 16:11:18]-[main-DEBUG]-[org.springframework.jdbc.datasource.DataSourceTransactionManager-doRollback(325)]： Rolling back JDBC transaction on Connection [jdbc:mysql://localhost:3306/test3, UserName=root@localhost, MySQL Connector Java]
[2017-11-23 16:11:18]-[main-DEBUG]-[org.springframework.jdbc.datasource.DataSourceTransactionManager-doCleanupAfterCompletion(368)]： Releasing JDBC Connection [jdbc:mysql://localhost:3306/test3, UserName=root@localhost, MySQL Connector Java] after transaction
[2017-11-23 16:11:18]-[main-DEBUG]-[org.springframework.jdbc.datasource.DataSourceUtils-doReleaseConnection(327)]： Returning JDBC Connection to DataSource
[2017-11-23 16:11:18]-[main-DEBUG]-[org.springframework.test.context.support.DirtiesContextTestExecutionListener-afterTestMethod(86)]： After test method: context [[TestContext@783e6358 testClass = MybatisAndTransactional, testInstance = MybatisAndTransactional@17550481, testMethod = sakljd@MybatisAndTransactional, testException = java.lang.RuntimeException: 发送消息失败, mergedContextConfiguration = [MergedContextConfiguration@735f7ae5 testClass = MybatisAndTransactional, locations = '{classpath:springTransactional.xml}', classes = '{}', activeProfiles = '{}', contextLoader = 'org.springframework.test.context.support.DelegatingSmartContextLoader']]], class dirties context [false], class mode [null], method dirties context [false].


java.lang.RuntimeException: 发送消息失败


      
      

       
       

      
      

      
      

       
       

      
      

      
      

       
       现在用这个级别 
       
       REQUIRED 即默认级别:分成两个类:如下
      
      

      
      

       
       

      
      
package transactional.service;

import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import transactional.bean.Cat;
import transactional.dao.CatDao;
import javax.annotation.Resource;
/**
 * Created by 340092 on 2017/11/23.
 */
@Component
public class TransactionalTest {
    @Resource
    CatDao catDao;
    @Resource
    TransactionalTest12 transactionalTest12;

    //这里采用默认传递级别
    @Transactional
    public void saveCatAndUser(){
        //一些逻辑操作 这里略过
        System.out.println("开始保存Cat");

        transactionalTest12. saveUser();

        Cat cat = new Cat();
        cat.setCatAge(12);
        cat.setName("Tom");
        catDao.saveCat(cat);

        //之后一些操作  这里省略
    }

}和
package transactional.service;

import org.springframework.stereotype.Component;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import transactional.bean.User;
import transactional.dao.UserDao;
import javax.annotation.Resource;
/**
 * Created by 340092 on 2017/11/23.
 */
@Component
public class TransactionalTest12 {
    @Resource
    UserDao userDao;
    //这里采用默认传递级别
    @Transactional    public void saveUser(){        //一些逻辑操作 等等 略        System.out.println("开始保存User");        User user = new User();        user.setAge(25);        user.setName("Jack");        userDao.saveUser(user);    }    public void sendMessage(){        //这里只是模拟抛出异常        throw new RuntimeException("发送消息失败");    }}
测试结果:
准备测试事物
[2017-11-23 18:18:11]-[main-DEBUG]-[org.springframework.beans.factory.support.AbstractBeanFactory-doGetBean(246)]： Returning cached instance of singleton bean 'transactionManager'
[2017-11-23 18:18:19]-[main-DEBUG]-[org.springframework.transaction.support.AbstractPlatformTransactionManager-getTransaction(365)]： Creating new transaction with name [transactional.service.TransactionalTest.saveCatAndUser]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT; ''
Thu Nov 23 18:18:21 CST 2017 WARN: Establishing SSL connection without server's identity verification is not recommended. According to MySQL 5.5.45+, 5.6.26+ and 5.7.6+ requirements SSL connection must be established by default if explicit option isn't set. For compliance with existing applications not using SSL the verifyServerCertificate property is set to 'false'. You need either to explicitly disable SSL by setting useSSL=false, or set useSSL=true and provide truststore for server certificate verification.
Thu Nov 23 18:18:21 CST 2017 WARN: Establishing SSL connection without server's identity verification is not recommended. According to MySQL 5.5.45+, 5.6.26+ and 5.7.6+ requirements SSL connection must be established by default if explicit option isn't set. For compliance with existing applications not using SSL the verifyServerCertificate property is set to 'false'. You need either to explicitly disable SSL by setting useSSL=false, or set useSSL=true and provide truststore for server certificate verification.
[2017-11-23 18:18:21]-[main-DEBUG]-[org.springframework.jdbc.datasource.DataSourceTransactionManager-doBegin(248)]： Acquired Connection [jdbc:mysql://localhost:3306/test3, UserName=root@localhost, MySQL Connector Java] for JDBC transaction
[2017-11-23 18:18:21]-[main-DEBUG]-[org.springframework.jdbc.datasource.DataSourceTransactionManager-doBegin(265)]： Switching JDBC Connection [jdbc:mysql://localhost:3306/test3, UserName=root@localhost, MySQL Connector Java] to manual commit
开始保存Cat
[2017-11-23 18:18:43]-[main-DEBUG]-[org.springframework.beans.factory.support.AbstractBeanFactory-doGetBean(246)]： Returning cached instance of singleton bean 'transactionManager'
[2017-11-23 18:18:52]-[main-DEBUG]-[org.springframework.transaction.support.AbstractPlatformTransactionManager-handleExistingTransaction(470)]： Participating in existing transaction
开始保存User
[2017-11-23 18:20:15]-[main-DEBUG]-[org.springframework.transaction.support.AbstractPlatformTransactionManager-processCommit(752)]： Initiating transaction commit
[2017-11-23 18:20:15]-[main-DEBUG]-[org.springframework.jdbc.datasource.DataSourceTransactionManager-doCommit(310)]： Committing JDBC transaction on Connection [jdbc:mysql://localhost:3306/test3, UserName=root@localhost, MySQL Connector Java]
[2017-11-23 18:20:15]-[main-DEBUG]-[org.springframework.jdbc.datasource.DataSourceTransactionManager-doCleanupAfterCompletion(368)]： Releasing JDBC Connection [jdbc:mysql://localhost:3306/test3, UserName=root@localhost, MySQL Connector Java] after transaction
[2017-11-23 18:20:15]-[main-DEBUG]-[org.springframework.jdbc.datasource.DataSourceUtils-doReleaseConnection(327)]： Returning JDBC Connection to DataSource

先是创建一个事物 碰到下个方法(也是默认级别) 则参与到现有事物中不会开启新的事物,碰到异常都会回滚,无异常都会提交
 
下面开启:
@Transactional(propagation=Propagation.REQUIRES_NEW)
public void saveUser(){
准备测试事物
[2017-11-23 18:30:53]-[main-DEBUG]-[org.springframework.beans.factory.support.AbstractBeanFactory-doGetBean(246)]： Returning cached instance of singleton bean 'transactionManager'
[2017-11-23 18:30:53]-[main-DEBUG]-[org.springframework.transaction.support.AbstractPlatformTransactionManager-getTransaction(365)]： Creating new transaction with name [transactional.service.TransactionalTest.saveCatAndUser]: PROPAGATION_REQUIRED,ISOLATION_DEFAULT; ''
Thu Nov 23 18:30:53 CST 2017 WARN: Establishing SSL connection without server's identity verification is not recommended. According to MySQL 5.5.45+, 5.6.26+ and 5.7.6+ requirements SSL connection must be established by default if explicit option isn't set. For compliance with existing applications not using SSL the verifyServerCertificate property is set to 'false'. You need either to explicitly disable SSL by setting useSSL=false, or set useSSL=true and provide truststore for server certificate verification.
Thu Nov 23 18:30:53 CST 2017 WARN: Establishing SSL connection without server's identity verification is not recommended. According to MySQL 5.5.45+, 5.6.26+ and 5.7.6+ requirements SSL connection must be established by default if explicit option isn't set. For compliance with existing applications not using SSL the verifyServerCertificate property is set to 'false'. You need either to explicitly disable SSL by setting useSSL=false, or set useSSL=true and provide truststore for server certificate verification.
[2017-11-23 18:30:53]-[main-DEBUG]-[org.springframework.jdbc.datasource.DataSourceTransactionManager-doBegin(248)]： Acquired Connection [jdbc:mysql://localhost:3306/test3, UserName=root@localhost, MySQL Connector Java] for JDBC transaction
[2017-11-23 18:30:53]-[main-DEBUG]-[org.springframework.jdbc.datasource.DataSourceTransactionManager-doBegin(265)]： Switching JDBC Connection [jdbc:mysql://localhost:3306/test3, UserName=root@localhost, MySQL Connector Java] to manual commit
开始保存Cat
[2017-11-23 18:30:53]-[main-DEBUG]-[org.springframework.beans.factory.support.AbstractBeanFactory-doGetBean(246)]： Returning cached instance of singleton bean 'transactionManager'
[2017-11-23 18:30:53]-[main-DEBUG]-[org.springframework.transaction.support.AbstractPlatformTransactionManager-handleExistingTransaction(415)]： Suspending current transaction, creating new transaction with name [transactional.service.TransactionalTest12.saveUser]
Thu Nov 23 18:30:53 CST 2017 WARN: Establishing SSL connection without server's identity verification is not recommended. According to MySQL 5.5.45+, 5.6.26+ and 5.7.6+ requirements SSL connection must be established by default if explicit option isn't set. For compliance with existing applications not using SSL the verifyServerCertificate property is set to 'false'. You need either to explicitly disable SSL by setting useSSL=false, or set useSSL=true and provide truststore for server certificate verification.
[2017-11-23 18:30:53]-[main-DEBUG]-[org.springframework.jdbc.datasource.DataSourceTransactionManager-doBegin(248)]： Acquired Connection [jdbc:mysql://localhost:3306/test3, UserName=root@localhost, MySQL Connector Java] for JDBC transaction
[2017-11-23 18:30:53]-[main-DEBUG]-[org.springframework.jdbc.datasource.DataSourceTransactionManager-doBegin(265)]： Switching JDBC Connection [jdbc:mysql://localhost:3306/test3, UserName=root@localhost, MySQL Connector Java] to manual commit
开始保存User
[2017-11-23 18:30:53]-[main-DEBUG]-[org.springframework.transaction.support.AbstractPlatformTransactionManager-processCommit(752)]： Initiating transaction commit
[2017-11-23 18:30:53]-[main-DEBUG]-[org.springframework.jdbc.datasource.DataSourceTransactionManager-doCommit(310)]： Committing JDBC transaction on Connection [jdbc:mysql://localhost:3306/test3, UserName=root@localhost, MySQL Connector Java]
[2017-11-23 18:30:53]-[main-DEBUG]-[org.springframework.jdbc.datasource.DataSourceTransactionManager-doCleanupAfterCompletion(368)]： Releasing JDBC Connection [jdbc:mysql://localhost:3306/test3, UserName=root@localhost, MySQL Connector Java] after transaction
[2017-11-23 18:30:53]-[main-DEBUG]-[org.springframework.jdbc.datasource.DataSourceUtils-doReleaseConnection(327)]： Returning JDBC Connection to DataSource
[2017-11-23 18:30:53]-[main-DEBUG]-[org.springframework.transaction.support.AbstractPlatformTransactionManager-cleanupAfterCompletion(1012)]： Resuming suspended transaction after completion of inner transaction
[2017-11-23 18:30:53]-[main-DEBUG]-[org.springframework.transaction.support.AbstractPlatformTransactionManager-processCommit(752)]： Initiating transaction commit

 

 

 

这个首先开启一个事物  碰到
 

@Transactional(propagation=Propagation.REQUIRES_NEW)
public void saveUser(){ 会把当前事物挂起  开启一个新的事物 如果没有异常则两个事物做提交操作 如果saveUser()
 

有异常则第二个事物做回滚操作并把异常抛出,然后第一个事物捕获到异常 也做回滚操作并把异常抛出,
 

如果saveCatAndUser()抛出异常 则第二个提交  第一个回滚.在两个方法内捕获异常 不让异常抛出 则都提交
 

回滚操作主要是看有没有异常抛出. 这两个事物可以看成是独立的;
 

 


 
 

 

@Transactional(propagation=Propagation.NESTED)
 

 

 

这个传递级别 之前有事物()是先创建第一个事物 碰到这个级别 会把 创建一个嵌套事物 之后执行完成会释放这个节点  然后提交事物 ,如果第一个方法有异常则全部回滚,第二个异常也会全部回滚(是嵌套在一起的)
 

其他的几个级别都非常简单 可以自己试一下.

                

        

        

    




    

      

        

            

              
                
                  一个人世界
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
事务的使用方法

				
			

			

				

					05-12
				

			

		

		

			
				
介绍了ssm中的事务的使用，
若有不足或错误，还请指出

			
		

	



                

              
                



	

		

			

				
					
DB事物案例

				
			

			

				

					02-21
				

			

		

		

			
				
本案例"DB事物案例"旨在帮助新人理解并掌握如何在编程中实现数据库事务，特别是提交和回滚操作。下面我们将深入探讨相关知识点。  1. **事务的四大特性**：  - **原子性（Atomicity）**：事务中的所有操作要么全部...

			
		

	



                


  
              

                


	

		

			

				
					
事务的用法

				
			

			

				

					北国有鱼的博客
				

				

					05-08
					
					341
					
				

			

		

		

			
				
事务的概念：


1. 原子性（A）：

对于数据修改，要么全部都执行，要么全都不执行。 



2. 隔离性（C）：

在所有的操作没有执行完毕之前，其他会话不能够看到中间改变的过程。 



3. 一致性（I）：

事务发生前和发生后，根据数据的规则，总额应该匹配。 



4. 持久性（D）：

事务一旦被提交，其结果就是永久性的，系统崩溃也不会影响






laravel中使...

			
		

	





	

		

			

				
					
事物注解用法

				
			

			

				

					飞天神猪ll的博客
				

				

					01-03
					
					772
					
				

			

		

		

			
				
1、项目中我们可以使用基于配置的事物控制：
这样指定类中指定方法会有事物(切面控制)


2、我们也可以使用事物注解来控制事物：
在类(或者方法)上声明@Transactional表明类中的所有方法均受事物的控制，但是默认只是受非受检异常(RunTimeException)的控制
 让checked受检异常也回滚：在整个方法前加上@Transactional(rollbackFor=E

			
		

	



		

			
		



	

		

			

				
					
使用springboot aop来实现读写分离和事物配置

				
			

			

				

					08-19
				

			

		

		

			
				
本文将详细介绍使用SpringBoot AOP来实现读写分离和事务配置的原理、实现步骤和配置方法。  一、读写分离的原理  读写分离是指将数据库读取操作和写入操作分离到不同的数据库服务器上，以提高数据库的读取性能和可...

			
		

	





	

		

			

				
					
事物

				
			

			

				

					02-16
				

			

		

		

			
				
 - 在Java中，JDBC提供了管理事务的API，如Connection对象的commit()和rollback()方法。  - 在Spring框架中，可以使用@Transactional注解来自动管理事务，简化开发过程。  6. NoSQL数据库中的事务处理：  传统的...

			
		

	





	

		

			

				
					
注释事物控制

				
			

			

				

					09-01
				

			

		

		

			
				
在全注解的配置方式下，我们可以在Spring配置类上使用@Configuration标记，然后在需要事务管理的类或方法上使用@Transactional注解。此外，还可以通过@EnableTransactionManagement注解启用事务管理支持，并通过@...

			
		

	





	

		

			

				
					
spring事物传播propagation类别含义详解

				
			

			

				

					08-25
				

			

		

		

			
				
4. requires_new：如果当前有事务，则挂起该事物，并且自己创建一个新的事务给自己使用；如果当前没有事务，则跟required一样。例如，铃铛有饭吃，我看不上，不要，我自己买着自己吃。  5. not_supported：如果当前...

			
		

	





	

		

			

				
					
.net中关于事物的几种简单用法

				
			

			

				

					千里之行，始于足下
				

				

					07-20
					
					2238
					
				

			

		

		

			
				
用法一：



代码中使用事务前提：务必保证一个功能（或用例）在同一个打开的数据连接上，放到同一个事务里面操作。




首先是在D层添加一个类为了保存当前操作的这一个连接放到一个事务中执行，并事务执行打开同一个连接、事务完成关闭同一个连接的一个共有类



[csharp] view
 plaincopyprint?






"font-size:1

			
		

	





	

		

			

				
					
什么是事务

				
			

			

				

					
				

				

					08-01
					
					4564
					
				

			

		

		

			
				
 q            事务(TRANSACTION)是作为单个逻辑工作单元执行的一系列操作q            这些操作作为一个整体一起向系统提交，要么都执行、要么都不执行q            事务是一个不可分割的工作逻辑单元 转帐过程就是一个事务。它需要两条UPDATE语句来完成，这两条语句是一个整体，如果其中任一条出现错误，则整个转帐业务也应取消，两个帐户

			
		

	





	

		

			

				
					
事务的应用

				
			

			

				

					sunny_LI
				

				

					01-22
					
					780
					
				

			

		

		

			
				
事务一直是个很重要的概念，这次在项目中使用，学习一下，总结一下。
当遇到多个表的增删改操作时，如果想让它们做到要执行就都执行，要么就都不执行，就用到了事务。这是事务的原子性。

			
		

	





	

		

			

				
					
如何使用事务

				
			

			

				

					一个菜鸡的博客
				

				

					10-05
					
					1589
					
				

			

		

		

			
				
使用事务有两种方式，分别为 显式事务 和 隐式事务 。

			
		

	





	

		

			

				
					
事务的3种使用方法

				
			

			

				

					weixin_30877227的博客
				

				

					01-29
					
					906
					
				

			

		

		

			
				
三种事务的方法：1.sql语句，在sqlServer中执行的事务。2.SqlTransaction，代码程序中执行事务。3.TransactionScope 类似SqlTransaction区别在这个常用于using中。
一。sql语句：Sql Server2005/2008提供了begin tran，commit tran和rollback tran三个语句来显示的使用事务。begin tra...

			
		

	





	

		

			

				
					
数据库中事务用法举例

				
			

			

				

					开发软件
				

				

					03-21
					
					714
					
				

			

		

		

			
				
SET ANSI_NULLS ON
GO
SET QUOTED_IDENTIFIER ON
GO
-- =============================================
-- Author:		爱因光
-- Create date: 2012年3月21日14:37:10
-- Description:	事务基本用法
-- =========================

			
		

	





	

		

			

				
					
Spring 事务 - 基本使用、传播机制、失效场景、嵌套事务多回滚解决

				
			

			

				

					CYK_byte的博客
				

				

					03-12
					
					3397
					
				

			

		

		

			
				
带你一次学懂：编程式事务、声明式事务、事务的传播机制！

			
		

	





	

		

			

				
					
事务如何使用

				
			

			

				

					chao0508的博客
				

				

					05-21
					
					3368
					
				

			

		

		

			
				
事务是一个很神奇的东西  什么叫做事务呢  就是同时可以执行多个语句  一旦有一个错误 就不能运行下去 例如我们需要做一些批量的操作并且同时执行 如果我们用其他方法 例如判断的话 那么就回一直判断 如果数据多的话 那么就有可能出错 所以我们要用一种简单的方式  开启事务  并且使用使用简单的思路就是 开启事务  然后把要执行语句放在一起 如果一个出错那么任何都会不会往下走 并且锁定代码如下4.PD...

			
		

	





	

		

			

				
					
mybatisplus @Transactional事物详细用法

					
最新发布

				
			

			

				

					05-12
				

			

		

		

			
				
具体的使用方法如下：  1. 在 Service 层的方法上添加 @Transactional 注解，声明该方法需要进行事务管理。 2. 在方法内部调用 Mybatis-plus 提供的 CRUD 操作方法，并确保所有操作都在同一个事务内完成。 3. 如果...

			
		

	



              



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

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值