（3）.mybatis编写工具类

编写工具类

复用与重构

复用：使用方法与函数，复用的类，构成JAR包。（工具类属于复用）

一。创建工具类（一般在src下创建util包，在util包下创建工具类）。

例如：MybatisUtilds为工具类：

二：本工具类，作用如下：

1.创建和初始化SqlSessionFactory封装成方法

2.能够创建在一定范围内（线程）有效的SqlSession

3.能够关闭在一定范围内（）有效的SqlSession

4.能够进行事务控制

5.一些额外的支持Dao层便捷开发的方法

实现：

ThreadLocal:线程本地存储（只能存储一个对象，但是可以保证这个线程一直有效，除非线程销毁）

ThreadGroup:线程组

ThreadPool：线程池

泛型方法：

public static <T> T getMapper(Class<T> tClass){
    return open().getMapper(tClass);
}

eg:

    public static void rollback(){
        SqlSession session = threadLocal.get();
        if(session!=null) session.rollback();
        UsersMapper dao=session.getMapper(UsersMapper.class);
        NewsMapper newDao=session.getMapper(NewsMapper.class);
    }
    public static <T> T getMapper(Class<T> tClass){
        return open().getMapper(tClass);
    }

可更改：

public static void rollback(){
        SqlSession session = threadLocal.get();
        if(session!=null) session.rollback();
        UsersMapper dao=getMapper(UsersMapper.class);
        NewsMapper newDao=getMapper(NewsMapper.class);
    }
    public static <T> T getMapper(Class<T> tClass){
        return open().getMapper(tClass);
    }

三：完整代码：

MybatisUtils类：

 package com.util;

 import com.dao.NewsMapper;
 import com.dao.UsersMapper;
 import org.apache.ibatis.io.Resources;
 import org.apache.ibatis.session.SqlSession;
 import org.apache.ibatis.session.SqlSessionFactory;
 import org.apache.ibatis.session.SqlSessionFactoryBuilder;

 import java.io.IOException;
 import java.io.InputStream;

 public class MybatisUtils {
     /**
      * 1.创建和初始化SqlSessionFactory
      * 2.能够创建在一定范围内（线程）有效的SqlSession
      * 3.能够关闭在一定范围内（）有效的SqlSession
      * 4.能够进行事务控制
      * 5.一些额外的支持Dao层便捷开发的方法
      *  * 场景1：重定向
      *  * me -> A(伊滨)      1request->response   1线程
      *  *    -> B(西工)      2request->response   2线程
      *  *    -> C(涧西)      3request->response   3线程
      *  *    -> A(伊滨)      4request->response   4线程
      *  * 场景2：转发         1request->response   1线程
      *  * me -> A(伊滨)
      *  *             -电话-> B(西工)
      *  *             -电话-> C(涧西)
      *  *     <-
      *  * 多线程环境下访问SqlSession是同一个么、需要是同一个么？  不是同一个
      *  * 单线程环境下访问SqlSession是同一个么、需要是同一个么？  是同一个
      */
     static final String CONFIG_FILE = "mybatis-config.xml";
     static SqlSessionFactory factory;
     static{
         initFactory(CONFIG_FILE);
     }
     public static void initFactory(String configName){
         SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
         try {
             InputStream resourceAsStream =
                     Resources.getResourceAsStream(configName);
             factory = builder.build(resourceAsStream);
         } catch (IOException e) {
             e.printStackTrace();
         }
     }
     static ThreadLocal<SqlSession> threadLocal = new ThreadLocal<>();
     public static SqlSession open(){
         SqlSession session = threadLocal.get();
         if(session==null){
             session = factory.openSession();
             threadLocal.set(session);//线程绑定session，保证每次调用的是同一个线程
         }
         return session;
     }
     public static void close(){
         SqlSession session = threadLocal.get();
         if(session!=null){
             session.close();
             threadLocal.set(null);
         }
     }
     public static void commit(){
         SqlSession session = threadLocal.get();
         if(session!=null) session.commit();
     }
     public static void rollback(){
         SqlSession session = threadLocal.get();
         if(session!=null) session.rollback();
         UsersMapper dao=getMapper(UsersMapper.class);
         NewsMapper newDao=getMapper(NewsMapper.class);
     }
     public static <T> T getMapper(Class<T> tClass){
         return open().getMapper(tClass);
     }

 }

测试类MybatisUtilsTest：

 package com.dao;

 import org.apache.ibatis.session.SqlSession;
 import org.junit.Test;

 import static com.util.MybatisUtils.open;

 public class MybatisUtilsTest {
     //单线程测试
     @Test
     public void openInUniqueThread() throws InterruptedException{
         SqlSession s1=open();
         Thread.sleep(2000);
         SqlSession s2=open();
         Thread.sleep((int)(Math.random()*10000)+1000);
         SqlSession s3=open();
         Thread.sleep((int)(Math.random()*10000)+1000);
         assert s1==s2&&s1==s3;
     }
     //多线程测试
     SqlSession s1 = null;//全局变量
     SqlSession s2 = null;
     SqlSession s3 = null;
     @Test
     public void openInMultiplyThread() throws InterruptedException {
         // 匿名类对象（匿名内部类）。1.创建匿名内部类（thread）2.重写run方法 3.创建对象
         new Thread(){//子线程
             public void run(){
                 s1 = open();
             }
         }.start();
         new Thread(){
             public void run(){
                 s2 = open();
             }
         }.start();
         new Thread(){
             public void run(){
                 s3 = open();
             }
         }.start();
         // 等待，轮训
         while(true){
             if(s1 != null && s2 != null && s3 != null){
                 System.out.println("结束了！");
                 break;
             }
             System.out.println("等待：s1=" + s1 +",s2=" + s2 + ",s3=" + s3);
             Thread.sleep(10);
         }
         assert s1 != s2 && s2 != s3 && s1 != s3;//主线程，s1,S2,S3为子线程。
     }

 }