首页 / JAVA / java – Spring TestNG没有事务性回滚

java – Spring TestNG没有事务性回滚

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了java – Spring TestNG没有事务性回滚，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含13861字，纯文字阅读大概需要20分钟。

内容图文

我正在使用TestNG 6.9.9构建回归测试环境.但遇到一个我在使用JUnit时从未遇到过的问题.
在我看来,当完成每个测试用例时,如果测试方法在与他们调用的相同的事务上下文中运行,则每个数据的更改将默认自动回滚.但似乎这不是事实,我不知道我的代码中是否有任何错误.请帮帮我.
pom.xml中的属性,表示框架的版本

<properties>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <springframework.version>4.2.4.RELEASE</springframework.version>
    <hibernate.version>4.3.11.Final</hibernate.version>
<testng.version>6.9.9</testng.version>
</properties>

显然,它们都是最新的.

我的考试班：

package com.noahwm.hkapp.api;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.testng.AbstractTestNGSpringContextTests;
import org.springframework.test.context.transaction.TransactionConfiguration;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.testng.Assert;
import org.testng.annotations.Test;

import com.noahwm.hkapp.api.db.dao.AppUserDao;
import com.noahwm.hkapp.api.db.model.AppUser;
import com.noahwm.hkapp.api.service.AppUserService;

@ContextConfiguration(locations = { "classpath:applicationContext-test.xml" })
public class AppUserServiceTestNGTest extends AbstractTestNGSpringContextTests {

  @Autowired
  private AppUserService appUserService;

  @Test
  @Rollback
  @Transactional
  public void testApp() {
    AppUser appUser = new AppUser();
    appUser.setAge(10);
    appUser.setGender("F");
    appUser.setMobilePhone("13219201034");
    appUser.setName("HKAPP Test");
    appUserService.createUser(appUser);
    String appUserId = appUser.getId();
    Assert.assertNotNull(appUserId);
  }
}

创建实体实例,而不是调用createUser()将其保存到DB.根据我在JUnit中所做的,即使我没有将@Rollback注释放在测试方法的前面,数据也会自动回滚.

AppUser的结构是：

package com.noahwm.hkapp.api.db.model;

import javax.persistence.Column;
import javax.persistence.Entity;

@Entity(name = "APP_USERS")
public class AppUser extends BaseDataModel {

  @Column(name = "NAME")
  private String name;

  @Column(name = "GENDER")
  private String gender;

  @Column(name = "AGE")
  private Integer age;

  @Column(name = "MOBILE_PHONE")
  private String mobilePhone;

  public String getId() {
    return id;
  }

  public void setId(String id) {
    this.id = id;
  }

  public String getName() {
    return name;
  }

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

  public String getGender() {
    return gender;
  }

  public void setGender(String gender) {
    this.gender = gender;
  }

  public Integer getAge() {
    return age;
  }

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

  public String getMobilePhone() {
    return mobilePhone;
  }

  public void setMobilePhone(String mobilePhone) {
    this.mobilePhone = mobilePhone;
  }

}

BaseDataModel.java

package com.noahwm.hkapp.api.db.model;

import javax.persistence.Column;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.MappedSuperclass;
import javax.persistence.Version;

import org.hibernate.annotations.GenericGenerator;

@MappedSuperclass
public class BaseDataModel {

  @Id
  @GeneratedValue(generator = "uuid")
  @GenericGenerator(name = "uuid", strategy = "org.hibernate.id.UUIDGenerator")
  @Column(name = "ID", unique = true, length = 36, nullable = false)
  protected String id;

  @Version
  @Column(name = "version")
  protected Integer version;

  public String getId() {
    return id;
  }

  public void setId(String id) {
    this.id = id;
  }

  public Integer getVersion() {
    return version;
  }
}

ApplicationContext的-的test.xml

<?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:tx="http://www.springframework.org/schema/tx"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:jee="http://www.springframework.org/schema/jee"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:util="http://www.springframework.org/schema/util"
    xsi:schemaLocation="http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context-4.0.xsd
            http://www.springframework.org/schema/jee
            http://www.springframework.org/schema/jee/spring-jee-4.0.xsd
            http://www.springframework.org/schema/tx
            http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop-4.0.xsd
            http://www.springframework.org/schema/util
            http://www.springframework.org/schema/util/spring-util-4.0.xsd">

    <bean
        class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
        <property name="location">
            <value>classpath:jdbc.test.properties</value>
        </property>
    </bean>

    <context:annotation-config />
    <context:component-scan base-package="com.noahwm.hkapp.api" />

    <aop:aspectj-autoproxy />

    <bean id="lobHandler" class="org.springframework.jdbc.support.lob.DefaultLobHandler"
        lazy-init="true" />

    <bean id="dataSource" class="com.jolbox.bonecp.BoneCPDataSource"
        destroy-method="close">
        <property name="driverClass" value="${jdbc.driver}" />
        <property name="jdbcUrl" value="${jdbc.url}" />
        <property name="username" value="${jdbc.username}" />
        <property name="password" value="${jdbc.password}" />
        <property name="maxConnectionsPerPartition" value="${jdbc.maxConnectionsPerPartition}" />
        <property name="minConnectionsPerPartition" value="${jdbc.minConnectionsPerPartition}" />
        <property name="partitionCount" value="${jdbc.partitionCount}" />
        <property name="acquireIncrement" value="${jdbc.acquireIncrement}" />
    </bean>

    <bean id="sessionFactory"
        class="org.springframework.orm.hibernate4.LocalSessionFactoryBean">
        <property name="dataSource" ref="dataSource" />
        <property name="packagesToScan">
            <list>
                <value>com.noahwm.hkapp.api.db.model</value>
            </list>
        </property>
        <property name="hibernateProperties">
            <props>
                <prop key="hibernate.dialect">${hibernate.dialect}</prop>
                <prop key="hibernate.show_sql">${hibernate.show_sql}</prop>
                <prop key="hibernate.jdbc.batch_size">10</prop>
                <prop key="hibernate.jdbc.fetch_size">30</prop>
                <prop key="hibernate.default_batch_fetch_size">10</prop>
            </props>
        </property>
    </bean>

    <tx:annotation-driven transaction-manager="txManager"
        proxy-target-class="true" />
    <bean id="txManager"
        class="org.springframework.orm.hibernate4.HibernateTransactionManager">
        <property name="sessionFactory" ref="sessionFactory" />
    </bean>
</beans>

事务管理器名为“txManager”.
AppUserService.java

package com.noahwm.hkapp.api.service;

import java.util.List;
import java.util.Map;

import com.noahwm.hkapp.api.db.dao.AppUserDao;
import com.noahwm.hkapp.api.db.model.AppUser;

public interface AppUserService {
  void createUser(AppUser user);

}

AppUserServiceImpl.java

package com.noahwm.hkapp.api.service.impl;

import java.util.List;
import java.util.Map;

import org.hibernate.criterion.Order;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import com.noahwm.hkapp.api.db.dao.AppUserDao;
import com.noahwm.hkapp.api.db.model.AppUser;
import com.noahwm.hkapp.api.service.AppUserService;
import com.noahwm.hkapp.api.service.EntityService;
import com.noahwm.hkapp.utils.SimpleSearchCriteria;

@Service("AppUserService")
@Transactional(propagation=Propagation.REQUIRED)
public class AppUserServiceImpl extends EntityService implements AppUserService {

  private static final Logger logger = LoggerFactory.getLogger(AppUserServiceImpl.class);

  @Autowired
  private AppUserDao dao;
  @Override
  public void createUser(AppUser user) {
    logger.debug("Creating user with name {}", user.getName());
    dao.save(user);
  }
}

AppUserDao.java

package com.noahwm.hkapp.api.db.dao;

import org.springframework.stereotype.Repository;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;

import com.noahwm.hkapp.api.db.model.AppUser;

@Repository
@Transactional(propagation=Propagation.REQUIRED)
public class AppUserDao extends BaseDao<AppUser> {
  public void testsRollBack(AppUser appUser) throws Exception{
    save(appUser);
  }
}

BaseDao.java

package com.noahwm.hkapp.api.db.dao;

import java.io.Serializable;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;

import javax.annotation.Resource;

import org.hibernate.Criteria;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import org.springframework.transaction.annotation.Transactional;

import com.noahwm.hkapp.api.db.model.BaseDataModel;
import com.noahwm.hkapp.utils.SimpleSearchCriteria;

class BaseDao<T extends BaseDataModel> {

  private Class<T> domainClass;

  @Resource(name = "sessionFactory")
  protected SessionFactory sessionFactory;

  protected SessionFactory getSessionFactory() {
    return sessionFactory;
  }

  public void setSessionFactory(SessionFactory sessionFactory) {
    this.sessionFactory = sessionFactory;
  }

  @SuppressWarnings("unchecked")
  public Class<T> getDomainClass() {
    if (domainClass == null) {
      Type type = this.getClass().getGenericSuperclass();
      ParameterizedType parameterizedType = (ParameterizedType) type;
      domainClass = (Class<T>) parameterizedType.getActualTypeArguments()[0];
    }
    return domainClass;
  }

  protected Session getCurrentSession() {
    return getSessionFactory().getCurrentSession();
  }

  public Criteria createCriteria() {
    return getCurrentSession().createCriteria(getDomainClass());
  }

  public void save(T o) {
    getCurrentSession().save(o);
  }

  public void update(T o) {
    getCurrentSession().update(o);
  }

  public void saveOrUpdate(T o) {
    getCurrentSession().saveOrUpdate(o);
  }

  public Object merge(Object o) {
    return getCurrentSession().merge(o);
  }

  public void delete(T o) {
    getCurrentSession().delete(o);
  }

  public T deleteById(Serializable id) {
    T o = findById(id);
    getCurrentSession().delete(o);
    return o;
  }

  public void evict(Object o) {
    getCurrentSession().evict(o);
  }

  @SuppressWarnings("unchecked")
  public List<T> findAll() {
    return createCriteria().list();
  }

  @SuppressWarnings("unchecked")
  public T findById(Serializable o) {
    List<T> results = createCriteria().add(Restrictions.idEq(o)).list();
    if (results.isEmpty()) {
      return null;
    } else {
      return results.get(0);
    }
  }

  @SuppressWarnings("unchecked")
  public T load(Serializable o) {
    return (T) getCurrentSession().load(getDomainClass(), o);
  }

  @SuppressWarnings("unchecked")
  public List<T> findBy(Map<String, Object> propertyNameValues) {
    return createCriteria().add(Restrictions.allEq(propertyNameValues)).list();
  }

  @SuppressWarnings("unchecked")
  public List<T> findBy(String propertyName, Object value) {
    return createCriteria().add(Restrictions.eq(propertyName, value)).list();
  }

  @SuppressWarnings("unchecked")
  public List<T> find(SimpleSearchCriteria simpleSearchCriteria) {
    Criteria criteria = createCriteria();
    Iterator<Criterion> criterions = simpleSearchCriteria.iterator();
    while(criterions.hasNext()) {
      criteria.add(criterions.next());
    }
    for(Order o : simpleSearchCriteria.getOrders()) {
      criteria.addOrder(o);
    }
    if(simpleSearchCriteria.getFetchSize() != null) {
      criteria.setFetchSize(simpleSearchCriteria.getFetchSize());
    }
    if(simpleSearchCriteria.getFirstResult() != null) {
      criteria.setFirstResult(simpleSearchCriteria.getFirstResult());
    }
    if(simpleSearchCriteria.getMaxResults() != null) {
      criteria.setMaxResults(simpleSearchCriteria.getMaxResults());
    }
    if(simpleSearchCriteria.getTimeout() != null) {
      criteria.setTimeout(simpleSearchCriteria.getTimeout());
    }
    return criteria.list();
  }

  public T findFirst(SimpleSearchCriteria simpleSearchCriteria) {
    simpleSearchCriteria.setMaxResults(1);
    List<T> results = find(simpleSearchCriteria);
    if(results.isEmpty()) {
      return null;
    } else {
      return results.get(0);
    }
  }

  public Object callNamedQuery(String sql, Map<String, Object> parameter) {
    Query query = getCurrentSession().createSQLQuery(sql);
    for(Entry<String, Object> entry:parameter.entrySet()){
      query.setParameter(entry.getKey(), entry.getValue());
    }
    return query.executeUpdate();
  }
}

这是DB init脚本：

CREATE TABLE "APP_USERS" (
"ID" VARCHAR(36),
"NAME" VARCHAR(50),
"GENDER" VARCHAR(1),
"AGE" NUMERIC(3,0),
"MOBILE_PHONE" VARCHAR(20),
    VERSION INTEGER)

如您所见,这是一个非常常见的Spring TestNG集成测试.但是无法使用自动回滚功能,这与我的关系很多.

解决方法:

感谢M. Deinum.
为了解决我的问题,我只需用AbstractTransactionalTestNGSpringContextTests替换AbstractTestNGSpringContextTests类.

package com.noahwm.hkapp.api;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.annotation.Rollback;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.testng.AbstractTransactionalTestNGSpringContextTests;
import org.springframework.test.context.transaction.TransactionConfiguration;
import org.springframework.transaction.annotation.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.testng.Assert;
import org.testng.annotations.Test;

import com.noahwm.hkapp.api.db.dao.AppUserDao;
import com.noahwm.hkapp.api.db.model.AppUser;
import com.noahwm.hkapp.api.service.AppUserService;

@ContextConfiguration(locations = { "classpath:applicationContext-test.xml" })
public class AppUserServiceTestNGTest extends AbstractTransactionalTestNGSpringContextTests {

  @Autowired
  private AppUserService appUserService;

  @Test
  @Rollback
  @Transactional
  public void testApp() {
    AppUser appUser = new AppUser();
    appUser.setAge(10);
    appUser.setGender("F");
    appUser.setMobilePhone("13219201034");
    appUser.setName("HKAPP Test");
    appUserService.createUser(appUser);
    String appUserId = appUser.getId();
    Assert.assertNotNull(appUserId);
  }
}

内容总结

以上是互联网集市为您收集整理的java – Spring TestNG没有事务性回滚全部内容，希望文章能够帮你解决java – Spring TestNG没有事务性回滚所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/809087.html

来源：【匿名】

【上一篇】java – 随机种子之间的区别是否重要？【下一篇】JAVA/JSP学习系列之五

更多 ►

【java – Spring TestNG没有事务性回滚】教程文章相关的互联网学习教程文章

javaweb学习总结(三十八)——事务【代码】【图】

一、事务的概念事务指逻辑上的一组操作，组成这组操作的各个单元，要不全部成功，要不全部不成功。　　例如：A——B转帐，对应于如下两条sql语句　　update from account set money=money+100 where name=‘B‘; 　　 update from account set money=money-100 where name=‘A‘;二、MySQL数据库中操作事务命令　　1、编写测试SQL脚本，如下： 1/*创建账户表*/ 2createtable account(3 id intprimarykey auto_increment,4 ...

Java事务(三) - 使用ThreadLocal

一. 为什么使用ThreadLocal:在上一篇博文中, 我们通过传递Connection的方式来控制事务, 这种方法可以达到目的, 但让人看的不爽, 如果涉及到调用多个service, 那我是不是还得从controller层传递Connection?ThreadLocal的用法见上一篇博客, 该类保证一个类的实例变量在各个线程中都有一份单独的拷贝, 从而不会影响其他线程中的实例变量二. 如何使用ThreadLocal:1. 写一个TransactionManager类:/*** 管理事务*/ public class Transact...

Java EE 事务管理

Open Group组织定义的分布式事务处理模型包括：应用程序(AP)、事务管理器(TM)、资源管理器(RM)、通信资源管理器(CRM)。常见的事务管理器就是事务中间件（通常由应用服务器来实现）、常见的资源管理器就是数据库、常见的通信管理器就是消息中间件。XA规范：Open Group组织为分布式事务指定的事务中间件与数据库之间的接口规范。XA规范的理论基础是两阶段提交协议。JTA 分布式事务管理调用javax.transaction.UserTransacton接口的beg...

JAVA分布式事务小结

分布式事务处理（ Distributed Transaction Processing ， DTP ）涉及多个分布在不同地方的数据库，但对数据库的操作必须全部被提交或者回滚。只要任一数据库操作时失败，所有参与事务的数据库都需要回滚。　　举个例子，A服务部署在tomcat上，执行insert a并调用B和C接口， B服务部署在weblogic上，执行insert b， C服务部署在Nginx，执行insert c。现在要执行A，并且在执行到insert c时更新失败，分布式事务的要求是inse...

java事务（三）【代码】【图】

java事务（三）——自己实现分布式事务在上一篇《java事务（二）——本地事务》中已经提到了事务的类型，并对本地事务做了说明。而分布式事务是跨越多个数据源来对数据来进行访问和更新，在JAVA中是使用JTA(Java Transaction API)来实现分布式的事务管理的。但是在本篇中并不会说明如何使用JTA，而是在不依赖其他框架以及jar包的情况下自己来实现分布式事务，作为对分布式事务的一个理解。假设现在有两个数据库，可以是在...

Java事务处理全解析（二）——失败的案例【代码】【图】

在本系列的上一篇文章中，我们讲到了Java事务处理的基本问题，并且讲到了Service层和DAO层，在本篇文章中，我们将以BankService为例学习一个事务处理失败的案例。 BankService的功能为：某个用户有两个账户，分别为银行账户和保险账户，并且有各自的账户号，BankService的transfer方法从该用户的银行账户向保险账户转帐，两个DAO分别用于对两个账户表的存取操作。定义一个BankService接口如下：package davenkin;public interface ...

java单元测试juint中事务问题【代码】

java.lang.IllegalStateException: Failed to load ApplicationContextat org.springframework.test.context.CacheAwareContextLoaderDelegate.loadContext(CacheAwareContextLoaderDelegate.java:99)at org.springframework.test.context.TestContext.getApplicationContext(TestContext.java:122)at org.springframework.test.context.web.ServletTestExecutionListener.setUpRequestContextIfNecessary(ServletTestExecutionLis...

java基础第22天_mysql存储过程、事务隔离

断点续传、QQ等项目的数据保存在数据库中实现。本文出自 “作业” 博客，请务必保留此出处http://10718270.blog.51cto.com/10708270/1793274原文：http://10718270.blog.51cto.com/10708270/1793274

Java Spring 事务回滚详解【图】

这篇文章主要介绍java Spring事务回滚spring 事务回滚1、遇到的问题　　当我们一个方法里面有多个数据库保存操作的时候，中间的数据库操作发生的错误。伪代码如下：public method() { Dao1.save(Person1); Dao1.save(Person2); Dao1.save(Person2);//假如这句发生了错误，前面的两个对象会被保存到数据库中 Dao1.save(Person2);}　　期待的情况：发生错误之前的所有数据库保存操作都回滚，即不保存　　正常情况：前面的数据库操...

java中事务的管理

什么是事务:　　事务，就是一组操作数据库的动作集合。　　一组处理步骤或者全部发生或者一步也不执行，我们称该组处理步骤为一个事务。当所有的步骤像一个操作一样被完整地执行，我们称该事务被提交。由于其中的一部分或多步执行失败，导致没有步骤被提交，则事务必须回滚到最初的系统状态。　　事务必须满足ACID原则。ACID是原子性（atomicity）、一致性（consistency）、隔离性（isolation）和持久性（durability）的缩写。　　...

JAVA中事务的属性ACID;

原子性(ATOMICITY): 一个事务要被完全的无二义性的做完或撤消。在任何操作出现一个错误的情况下，构成事务的所有操作的效果必须被撤消，数据应被回滚到以前的状态。一致性(CONSISTENCY): 一个事务应该保护所有定义在数据上的不变的属性(例如完整性约束)。在完成了一个成功的事务时，数据应处于一致的状态。换句话说，一个事务应该把系统从一个一致-状态转换到另一个一致状态。举个例子，在关系数据库的情况下，一个一致的事务将保...

JavaEE事务【图】

一、什么是事务？事务(Transaction)是作为单个逻辑工作单元执行的一系列操作。这些操作作为一个整体向系统提交，要么都执行、要么都不执行。事务是一个不可分割的工作逻辑单元转账操作A—>B： begin transaction1.更新帐户A的余额2.记录帐户A的交易日志3.更新帐户B的余额4.记录帐户B的交易日志 end transaction二、事务的特征(ACID) 原子性Atomicity事务必须是原子工作单元。对于其数据修改，要么全执行，要么全都不执行。一致性...

java-mybaits-009-mybatis-spring-使用，SqlSessionFactoryBean、事务【代码】【图】

一、版本限制参看地址：http://www.mybatis.org/spring/ 二、使用入门2.1、pom<dependency><groupId>org.mybatis</groupId><artifactId>mybatis-spring</artifactId><version>x.x.x</version></dependency>2.2、SqlSessionFactoryBean创建在 Spring 的 XML 配置文件中:<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean"><property name="dataSource" ref="dataSource"/></bean>要注意 SqlSessionFac...

java基础之----分布式事务ttc【代码】

最近研究了一下分布式事务框架，ttc,总体感觉还可以，当然前提条件下是你要会使用这个框架。下面分层次讲，尽量让想学习的同学读了这篇文章能加以操作运用。我不想废话，直接上干货。一.什么是tcc?干什么用的？ ttc是分布式事务框架，用于分布式事务的。分布式事务就是针对两个以上的库操作数据事务管理的，比如操作A库B库，当B库失败，也要把A库哪一步操作也要回滚。 ttc其实是一个模板框架，是英文字母try,confi...

【JAVAEE学习笔记】hibernate02：实体规则、对象状态、缓存、事务、批量查询和实现客户列表显示【代码】【图】

一、hibernate中的实体规则实体类创建的注意事项　1.持久化类提供无参数构造　2.成员变量私有,提供共有get/set方法访问.需提供属性　3.持久化类中的属性,应尽量使用包装类型　4.持久化类需要提供oid.与数据库中的主键列对应　5.不要用final修饰class主键类型自然主键(少见)　　表的业务列中,有某业务列符合,必须有,并且不重复的特征时,该列可以作为主键使用.代理主键(常见)　　表的业务列中,没有某业务列符合,必须有,并且不重复的特...

JAVA - 技术教程分类

Java 教程 Java 简介 Java 开发环境配置 Java 基础语法 Java 对象和类 Java 基本数据类型 Java 变量类型 Java 修饰符 Java 运算符 Java 循环结构 Java 条件语句 Java switch case Java Number & Math 类 Java Character 类 Java String 类 Java StringBuffer Java 数组 Java 日期时间 Java 方法 Java Stream、File、IO Java Scanner 类 Java 异常处理 Java 继承 Java Override/Overload Java 多态 Java 抽象类 Java 封装 Java 接口 Java 枚举 Java 包(package) Java 数据结构 Java 集合框架 Java ArrayList Java LinkedList Java HashSet Java HashMap Java Iterator Java Object Java 泛型 Java 序列化 Java 网络编程 Java 多线程编程 Java Applet 基础 Java 文档注释 Java 实例 Java 8 新特性 Java MySQL 连接 Java 9 新特性 Java 测验 java 全部

JAVA - 最热教程

Java在运行项目时候，点击右键的弹框，...nacos配置中心超时问题：java.net.Conn...Java的设计模式（7）— 生产者-消费者模...基于DOM4j和POI实现的XML文件转换为XLS...如何在Java中创建一些变量类型别名使用java8的Stream统计字符串数组中每一...idea插件篇之java内存分析工具(JProfil...cannot cast 'java.lang.Integer' to '...java – Bootstrap.properties中Spring...Java8利用stream流实现数字排序和中文排...

首页 / JAVA / java – Spring TestNG没有事务性回滚

java – Spring TestNG没有事务性回滚

内容导读

内容图文

内容总结

内容备注

内容手机端

【java – Spring TestNG没有事务性回滚】教程文章相关的互联网学习教程文章

javaweb学习总结(三十八)——事务【代码】【图】

Java事务(三) - 使用ThreadLocal

Java EE 事务管理

JAVA分布式事务小结

java事务（三）【代码】【图】

Java事务处理全解析（二）——失败的案例【代码】【图】

java单元测试juint中事务问题【代码】

java基础第22天_mysql存储过程、事务隔离

Java Spring 事务回滚详解【图】

java中事务的管理

JAVA中事务的属性ACID;

JavaEE事务【图】

java-mybaits-009-mybatis-spring-使用，SqlSessionFactoryBean、事务【代码】【图】

java基础之----分布式事务ttc【代码】

【JAVAEE学习笔记】hibernate02：实体规则、对象状态、缓存、事务、批量查询和实现客户列表显示【代码】【图】

SPRING - 相关标签

JAVA - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程