Customer

package com.shpun.entity;
public class Customer {
    private String id;
    private String name;
    private String gender;
    private String birthday;
    private String tel;
    private String email;
    private String introduction;
    /*getter  setter*/
}

CustomerMapper

package com.shpun.mapper;

@Repository
public interface CustomerMapper {
    int insertCustomer(Customer customer);
    int deleteCustomer(String id);
    int updateCustomer(Customer customer);
    Customer selectCustomer(String id);
    List<Customer> selectAllCustomers();
}

CustomerMapper.xml

<?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="com.shpun.mapper.CustomerMapper">

    <insert id="insertCustomer" useGeneratedKeys="true" keyProperty="id" parameterType="customer">
        insert into customers (name,gender,birthday,tel,email,introduction) value (#{name},#{gender},#{birthday},#{tel},#{email},#{introduction})
    </insert>

    <delete id="deleteCustomer" parameterType="string">
        delete from customers where id=#{id}
    </delete>

    <update id="updateCustomer" parameterType="customer">
        update customers set name=#{name},gender=#{gender},birthday=#{birthday},tel=#{tel},email=#{email},introduction=#{introduction} where id=#{id}
    </update>

    <select id="selectCustomer" parameterType="string" resultType="customer">
        select * from customers where id=#{id}
    </select>

    <select id="selectAllCustomers" resultType="customer">
        select * from customers
    </select>

</mapper>

Mybatis-config.xml

<?xml version="1.0" encoding="utf-8" ?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>

    <settings>
        <!-- 全局映射器启用缓存 -->
        <setting name="cacheEnabled" value="true"/>
        <!-- 允许JDBC支持生成的键 -->
        <setting name="useGeneratedKeys" value="true"/>
        <!-- 配置默认执行器 Reuse 重用预处理语句 -->
        <setting name="defaultExecutorType" value="REUSE"/>
        <!-- 全局启用延迟加载 -->
        <setting name="lazyLoadingEnabled" value="true"/>
        <!-- 设置超时时间，决定驱动等待一个数据库相应的时间 -->
        <setting name="defaultStatementTimeout" value="2500"/>
    </settings>

    <!-- 别名 -->
    <typeAliases>
        <typeAlias alias="customer" type="com.shpun.entity.Customer"/>
    </typeAliases>

    <!-- 映射器路径 -->
    <mappers>
        <mapper resource="com/shpun/mapper/CustomerMapper.xml"/>
    </mappers>

</configuration>

spring-config.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: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.xsd">

    <!-- 启用扫描 -->
    <context:annotation-config></context:annotation-config>
    <context:component-scan base-package="com.shpun.*"/>

    <!-- 引入外部properties文件 -->
    <context:property-placeholder location="mysql.properties"/>

    <!-- 设置数据库信息等 -->
    <bean id="dateSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url" value="${jdbc.url}"/>
    </bean>

    <!-- 集成Mybatis  SqlSessionFactoryBean 去支持 SqlSessionFactory 配置 -->
    <bean  id="SqlSessionFactory"  class="org.mybatis.spring.SqlSessionFactoryBean">
        <property name="dataSource" ref="dateSource"/>
        <property name="configLocation" value="mybatis-config.xml"/>
    </bean>

    <!-- 事务管理器配置数据源事务 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dateSource"/>
    </bean>

    <!-- 使用注解定义事务 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>

    <!-- 自动扫描配置Mapper的类 -->
    <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
        <!-- 指定Spring扫描的包 -->
        <property name="basePackage" value="com.shpun.mapper"/>
        <!-- 指定Spring中SqlSessionFactory的Bean的名称 -->
        <property name="SqlSessionFactoryBeanName" value="SqlSessionFactory"/>
        <!-- 指定类被注解标识才扫描 @Repository -->
        <property name="annotationClass" value="org.springframework.stereotype.Repository"/>
    </bean>

</beans>

CustomerService接口及其实现类

package com.shpun.service;
public interface CustomerService {
    int insertCustomer(Customer customer);
    int deleteCustomer(String id);
    int updateCustomer(Customer customer);
    Customer selectCustomer(String id);
    List<Customer> selectAllCustomer();
}

CustomerServiceImpl

package com.shpun.service;

@Service
public class CustomerServiceImpl implements CustomerService {

    @Autowired
    private CustomerMapper customerMapper = null;

    /**
     * @Transactional(propagation = Propagation.REQUIRES_NEW,isolation = Isolation.READ_COMMITTED)
     * propagation = Propagation.REQUIRES_NEW 传播行为，每次都开启一个新事务
     * isolation = Isolation.READ_COMMITTED 隔离级别，读/写提交  大部分情况下的选择
     * @param customer
     * @return
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW,isolation = Isolation.READ_COMMITTED)
    public int insertCustomer(Customer customer) {
        return customerMapper.insertCustomer(customer);
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW,isolation = Isolation.READ_COMMITTED)
    public int deleteCustomer(String id) {
        return customerMapper.deleteCustomer(id);
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW,isolation = Isolation.READ_COMMITTED)
    public int updateCustomer(Customer customer) {
        return customerMapper.updateCustomer(customer);
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW,isolation = Isolation.READ_COMMITTED)
    public Customer selectCustomer(String id) {
        return customerMapper.selectCustomer(id);
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRES_NEW,isolation = Isolation.READ_COMMITTED)
    public List<Customer> selectAllCustomer() {
        return customerMapper.selectAllCustomers();
    }
}

CustomerListService接口及其实现类

package com.shpun.service;

public interface CustomerListService {
    int insertCustomerList(List<Customer> customerList);
    int deleteCustomerList(List<Customer> customerList);
    int updateCustomerList(List<Customer> customerList);
    List<Customer> selectCustomerList(List<Customer> customerList);
}

CustomerListServiceImpl

package com.shpun.service;

@Service
public class CustomerListServiceImpl implements CustomerListService {

    @Autowired
    private CustomerService customerService;

    /**
     * @Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.READ_COMMITTED)
     * propagation = Propagation.REQUIRED Spring默认传播方式，存在当前事务则沿用；否则创建新事务
     * isolation = Isolation.READ_COMMITTED 隔离级别，读/写提交  大部分情况下的选择
     *
     * @param customerList
     * @return
     */
    @Override
    @Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.READ_COMMITTED)
    public int insertCustomerList(List<Customer> customerList) {
        int count = 0;
        for(Customer customer : customerList){
            try{
                customerService.insertCustomer(customer);
            }catch(Exception e){
                e.printStackTrace();
            }
        }
        return count;
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.READ_COMMITTED)
    public int deleteCustomerList(List<Customer> customerList) {
        int count = 0;
        for(Customer customer : customerList){
            try{
                customerService.deleteCustomer(customer.getId());
            }catch(Exception e){
                e.printStackTrace();
            }
        }
        return count;
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.READ_COMMITTED)
    public int updateCustomerList(List<Customer> customerList) {
        int count = 0;
        for(Customer customer : customerList){
            try{
                customerService.updateCustomer(customer);
            }catch(Exception e){
                e.printStackTrace();
            }
        }
        return count;
    }

    @Override
    @Transactional(propagation = Propagation.REQUIRED,isolation = Isolation.READ_COMMITTED)
    public List<Customer> selectCustomerList(List<Customer> customerList) {
        List<Customer> customers = new ArrayList<>();
        for(Customer customer : customerList){
            try{
                customers.add(customerService.selectCustomer(customer.getId()));
            }catch(Exception e){
                e.printStackTrace();
            }
        }
        return customers;
    }
}

测试

package com.shpun.main;

public class Test {

    public static void main(String[] args){

        ApplicationContext context = new ClassPathXmlApplicationContext("spring-config.xml");
        CustomerService cutomerService = context.getBean(CustomerService.class);
        CustomerListService customerListService = context.getBean(CustomerListService.class);

        List<Customer> customerList = new ArrayList<>();

          // insert
        for(int i=0;i<3;i++){
            Customer customer = new Customer();
            customer.setName("tx"+i);
            customer.setIntroduction("spring mybatis transaction "+i);
            customerList.add(customer);
        }
        System.out.println("insert");
        customerListService.insertCustomerList(customerList);

        // delete
        customerList.clear();
        for(int i=1;i<=3;i++){
            Customer customer = new Customer();
            customer.setId("101"+i);
            customerList.add(customer);
        }
        System.out.println("delete");
        customerListService.deleteCustomerList(customerList);

        // update
        customerList.clear();
        for(int i=1;i<=3;i++){
            Customer customer = new Customer();
            customer.setId("102"+i);
            customer.setName("修改");
            customer.setIntroduction("我被修改了TX"+i);
            customerList.add(customer);
        }
        System.out.println("update");
        customerListService.updateCustomerList(customerList);

        // select singal
        System.out.println(cutomerService.selectCustomer("1001"));

        // select list
        customerList.clear();
        for(int i=5;i<=7;i++){
            Customer customer = new Customer();
            customer.setId("104"+i);
            customerList.add(customer);
        }
        System.out.println(customerListService.selectCustomerList(customerList));

        // select all
        customerList.clear();
        System.out.println("select all");
        customerList = cutomerService.selectAllCustomer();
        for(Customer customer : customerList){
            System.out.println(customer);
        }

    }
}

ps:

Spring + Mybatis 启用事务，并使用注解的方式@Transactional记得在spring配置文件中添加

    <!-- 事务管理器配置数据源事务 -->
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dateSource"/>
    </bean>

    <!-- 使用注解定义事务 -->
    <tx:annotation-driven transaction-manager="transactionManager"/>