4.9MybatisUtils

自定义工具类MybatisUtils

package hsy.cool.util;

import hsy.cool.dao.NewsMapper;
import hsy.cool.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.InputStream;

/*
  代码复用(方法、函数、类、jar/开源第三方包)
  /重构(代码进行重写一遍，优化代码)

  1.创建和初始化SqlSessionFactory
  2.能够创建在一定范围内（线程的生命周期）有效session
                 范围---》时间范围
                    ---》空间范围
  3.能够关闭一定范围内(线程的生命周期)有效的session
  4.能够进行简单的事务控制
  5.会使用Mybatis提供一下便捷开发的方法
 ==============================================================================
 情况一：(用跑)
   自己     A---------                                    (客户端)重定向     request->response  单个线程
                     ---------->B------------             重定向     request->response  单个线程
                                             ---------->C 重定向     request->response  单个线程
            A--------   ---------- ----------<----------  重定向     request->response  单个线程
            4个线程。4个响应。4个请求  多线程

 情况二：(用电话)
           A---->B----C                                  (服务器端) 请求转发   .forword(req,resp)
             <---------
             单线程

问题：
1.我们这里是单线程还是多线程？   多
2.单线程环境下多次请求到的sqlsession是否是同一个？  是同一个
3.多线程环境下多次请求到的sqlsession是否是同一个？  不是
=======================================================================
         ThreadLocal线程本地存储类
                    只能存一个对象，但是可以保证这个对象对这个线程来说是一直有效的。
         ThreadPool线程池
         ThreadGroup线程组
 */
public class MybatisUtils {
    static ThreadLocal<SqlSession>THREAD_LOCAL=new ThreadLocal<>();//存取对象
    //需求：如果别人不想用static代码块来初始化，优化
    static final String CONFIG_FILE="mybatis-config.xml";
    //只要程序存在，工厂就在，所以定义成static
    static SqlSessionFactory factory;
    static {
        initFactory(CONFIG_FILE);
    }
    //初始化
    public static void initFactory(String configFile){
        SqlSessionFactoryBuilder builder=new SqlSessionFactoryBuilder();
        try {
            InputStream inputStream= Resources.getResourceAsStream(configFile);
            factory=builder.build(inputStream);
        }catch (Exception e){
            e.printStackTrace();
        }
    }
    //创建
    public static SqlSession open(){
        SqlSession session=THREAD_LOCAL.get();//获取对象
        if(session==null){
            session=factory.openSession();
            THREAD_LOCAL.set(session);
        }
        return session;
    }
    //关闭
    public static void close(){
        SqlSession session=THREAD_LOCAL.get();//获取对象
        if(session!=null){
            session.close();
            THREAD_LOCAL.set(null);
        }
    }
    //事务提交
    public static void commit(){
        SqlSession session=THREAD_LOCAL.get();//获取对象
        if(session!=null){
            session.commit();
        }
    }
    //事务回滚
    public static void rollback(){
        SqlSession session=THREAD_LOCAL.get();//获取对象
        if(session!=null){
          session.rollback();
        }
        //  Class类的类型
        //  class类
        /*UsersMapper dao=session.getMapper(UsersMapper.class);
        NewsMapper daonew=session.getMapper(NewsMapper.class);*/
       /* UsersMapper dao=getMapper(UsersMapper.class);
        NewsMapper daonew=getMapper(NewsMapper.class);*/
    }
    //泛型类/泛型方法
    public static <T> T getMapper(Class<T> tClass){
        return open().getMapper(tClass);
    }



}

测试

package hsy.cool.dao;

import hsy.cool.bean.Users;
import hsy.cool.util.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Assert;
import org.junit.Test;

import java.text.SimpleDateFormat;

public class MybatisUtilsTest {
    @Test
    public void openUniqueThread(){
        //测试是否单线程单session
        SqlSession s1= MybatisUtils.open();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        SqlSession s2= MybatisUtils.open();
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        SqlSession s3= MybatisUtils.open();
        assert s1==s2 && s1==s3;

    }
    SqlSession s1=null;
    SqlSession s2=null;
    SqlSession s3=null;
    @Test
    public void openInMultiplyThread() throws InterruptedException {
        //测试多个线程是否是多个会话
        new Thread(){
            @Override
            public void run() {
                s1=MybatisUtils.open();
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                s2=MybatisUtils.open();
            }
        }.start();
        new Thread(){
            @Override
            public void run() {
                s3=MybatisUtils.open();
            }
        }.start();
        while (true){
            if(s1==null||s2==null||s3==null){
                System.out.println("等待,s1="+s1+"  s2="+s2+"  s3="+s3);
                Thread.sleep(10);
            }else {
                System.out.println("对象都创建了");
                break;
            }
        }
        assert s1==s2 && s1==s3;

    }
    @Test
    public void findById(){
        /*SqlSession session=factory.openSession();
        Users user=session.selectOne("hsy.cool.dao.UsersMapper.findById",2);*/
    //UsersMapper dao=getMapper(UsersMapper.class);
        Users user=MybatisUtils.getMapper(UsersMapper.class).findById(2);
        //session.close();
        MybatisUtils.close();
        Assert.assertNotNull(user);
        Assert.assertEquals("杜哈哈",user.getNickname());
    }
    @Test
    public void findByName(){
        Users user=MybatisUtils.getMapper(UsersMapper.class).findByName("匿名啊啊啊");
        MybatisUtils.close();
        Assert.assertNotNull(user);
    }
}

xml

 <select id="findByName" resultType="hsy.cool.bean.Users" parameterType="string">
        select
            id,
            nickname,
            realname,
            pwd,
            phone,
            email,
            address,
            create_time createTime,
            type,
            realid
            from n_users where nickname=#{name}
    </select>