原文: https://blog.csdn.net/yangliuhbhd/article/details/80982254

结论: 在测试中使用simple模式提交10000条数据，时间为18248 毫秒，batch模式为5023 ，性能提高70%；

一、在mybatis中ExecutorType的使用

1.Mybatis内置的ExecutorType有3种，默认的是simple，该模式下它为每个语句的执行创建一个新的预处理语句，单条提交sql；而batch模式重复使用已经预处理的语句，

并且批量执行所有更新语句，显然batch性能将更优；

2.但batch模式也有自己的问题，比如在Insert操作时，在事务没有提交之前，是没有办法获取到自增的id，这在某型情形下是不符合业务要求的；

  1. 在测试中使用simple模式提交10000条数据，时间为18248 毫秒，batch模式为5023 ，性能提高70%；
  2. @Test
  3. public void mybatisBatch() {
  4.     SqlSession session = getSqlSessionFactory().openSession();
  5.     try {
  6.         DeptMapper deptMapper = (DeptMapper) session.getMapper(DeptMapper.class);
  7.         long start =System.currentTimeMillis();
  8.         for (int i = 0; i <10000 ; i++) {
  9.             SysDept dept=new SysDept(UUID.randomUUID().toString().substring(1,6), 1, new Date(),  new Date(), 1);
  10.             deptMapper.saveSysDept(dept);
  11.         }
  12.         long end =System.currentTimeMillis();
  13.         System.out.println("耗时:"+(end-start));
  14.         //ExecutorType.BATCH 批量耗时耗时:2134
  15.         //单条操作耗时 耗时:8584
  16.     } catch (Exception e) {
  17.         e.printStackTrace();
  18.     } finally {
  19.         session.commit();
  20.         session.close();
  21.     }
  22. }
  24. @Test
  25. public void saveDeptBatchOne() {
  26.     SqlSession session = getSqlSessionFactory().openSession();
  27.     try {
  28.         DeptMapper deptMapper = (DeptMapper) session.getMapper(DeptMapper.class);
  29.         long start =System.currentTimeMillis();
  30.         List<SysDept> deptList=new ArrayList<SysDept>();
  31.         for (int i = 0; i <100000 ; i++) {
  32.             SysDept dept=new SysDept(UUID.randomUUID().toString().substring(1,6), 1, new Date(),  new Date(), 1);
  33.             deptList.add(dept);
  34.             if(i%500==0){
  35.                 deptMapper.saveDeptBatch(deptList);
  36.                 deptList.clear();
  37.             }
  38.         }
  39.         deptMapper.saveDeptBatch(deptList);
  40.         long end =System.currentTimeMillis();
  41.         System.out.println("耗时:"+(end-start));
  42.         //非BATCH批量耗时 耗时:938
  43.     } catch (Exception e) {
  44.         e.printStackTrace();
  45.     } finally {
  46.         session.commit();
  47.         session.close();
  48.     }
  49. }
  51. @Test
  52. public void saveDeptBatchTwo() {
  53.     //设置ExecutorType.BATCH原理：把SQL语句发个数据库，数据库预编译好，数据库等待需要运行的参数，接收到参数后一次运行，ExecutorType.BATCH只打印一次SQL语句，多次设置参数步骤，
  54.     SqlSession session = getSqlSessionFactory().openSession(ExecutorType.BATCH);
  55.     try {
  56.         DeptMapper deptMapper = (DeptMapper) session.getMapper(DeptMapper.class);
  57.         long start =System.currentTimeMillis();
  58.         List<SysDept> deptList=new ArrayList<SysDept>();
  59.         for (int i = 0; i <100000; i++) {
  60.             SysDept dept=new SysDept(UUID.randomUUID().toString().substring(1,6), 1, new Date(),  new Date(), 1);
  61.             deptList.add(dept);
  62.             if(i%500==0){
  63.                 deptMapper.saveDeptBatch(deptList);
  64.                 deptList.clear();
  65.             }
  66.         }
  67.         deptMapper.saveDeptBatch(deptList);
  68.         long end =System.currentTimeMillis();
  69.         System.out.println("耗时:"+(end-start));
  70.         //BATCH批量耗时 耗时:822
  71.     } catch (Exception e) {
  72.         e.printStackTrace();
  73.     } finally {
  74.         session.commit();
  75.         session.close();
  76.     }
  77. }

二、在mybatis+spring中ExecutorType的使用

1、在spring配置文件中添加批量执行的SqlSessionTemplate

  1. <!--配置一个可以进行批量执行的sqlSession  -->
  2. <bean id="sqlSession" class="org.mybatis.spring.SqlSessionTemplate">
  3.   <constructor-arg name="sqlSessionFactory" ref="sqlSessionFactoryBean"></constructor-arg>
  4.   <constructor-arg name="executorType" value="BATCH"></constructor-arg>
  5. </bean>

2、service中获取批量添加的SqlSession

  1. @Service
  2. public class DeptService {
  3.         @Autowired
  4.         private DeptMapper deptMapper;
  5.         @Autowired
  6.         private SqlSession sqlSession;
  7.         public List<Dept> addDept(){
  8.         //executorType=BATCH 添加操作
  9.         DeptMapper mapper = sqlSession.getMapper(DeptMapper.class);
  10.         return mapper.saveDept(Dept);
  11.     }
  12.     }

三、$和#的区别

{}：可以获取map中的值或者pojo对象属性的值；

${}：可以获取map中的值或者pojo对象属性的值；

select from tbl_employee where id=${id} and last_name=#{lastName}
Preparing: select from tbl_employee where id=2 and last_name=?
区别：
#{}:是以预编译的形式，将参数设置到sql语句中；PreparedStatement；防止sql注入
${}:取出的值直接拼装在sql语句中；会有安全问题；