（2）.mybatis单元测试（junit测试）

一、Junit使用步骤：
1、创建测试目录，（src、测试目录是test）
2、在测试目录test中创建与src中相同的包名
3、为需要测试的类创建测试类，例如：UsersMapper，测试类是UsersMapperTest
4、为被测试类（UsersMapper）中的需要测试的方法在测试类型创建相应的方法。比如，需要测试findById方法，那么则测试类中创建findById方法，测试方法的要求
  a、不能有返回值、不能有参数
  b、需要只用@Test注解对该方法进行注解。
5、在测试方法中，使用断言对结果进行判断，assert，判断

一。单元测试

1. 在项目下创建一个目录test,之后将test右键Mark Directory as(标记目录为)->测试源根
2. 在test下创建类，类的包名与被测试类的包名一致，在被测试类后面加上Test，例如：com.dao.UsersMapper与com.dao.UsersMapperTest。在测试方法前@Test,导入junit测试路径，点击确定即可，之后maven后台下载。
3. Mybatis的核心对象:SqlSessionFactoryBuilder , SqlSessionFactory , SqlSession。(SqlSessionFactoryBuilder创建工厂，一般只用一次。SqlSessionFactory是工厂，工厂长期存在。SqlSession例如是工厂造的汽车，有时间期限，即使用完工厂依旧存在。)                                              SqlSeessionFactoryBuilder用过即丢，可用来创建多个SqlSessionFactory实例，并提供多个build方法的重载来构建SqlSessionFactory.    SqlSession(一般瞬时、短链接，也可以长连接，用完关闭)

   build(InputStream inputStream,String environment,Properties properties)
   build(Reader reader,String environment,Properties properties)
   build(Configuration config)
   
   配置信息以三种形式提供给 SqlessionFactoryld 的build 方法：
   InputStream（字节流） Reader （字符流） Configuration （类）

   读取XML文件构造方式:

   String CONFIG_FILE = "mybatis-config.xml";
   InputStream resourceAsStream = Resources.getResourceAsStream(CONFIG_FILE);
   SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder().build(resourceAsStream);

   //非静态成员，实例成员，成员变量，通过构造方法初始化。  静态函数，成员通过静态代码块初始化

4. 实现测试方法，在每个测试方法之前加@Test，实例化Session(建议通过工厂获取，不建议通过new获取。）写测试方法，之后进行断言操作Assert。Assert.assertNotNull(user),断言成功就是=true,断言失败，后面的代码不会执行了。eg:

    package com.dao;
   
    import com.bean.Users;
    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 org.junit.Assert;
    import org.junit.Test;
   
    import java.io.IOException;
    import java.io.InputStream;
   
    public class UsersMapperTest {
        static final String CONFIG_FILE = "mybatis-config.xml";
        static SqlSessionFactory factory;
        //非静态成员，实例成员，成员变量，通过构造方法初始化。  静态函数，成员通过静态代码块初始化
        static{  // 静态代码块
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            try {
                InputStream resourceAsStream =
                        Resources.getResourceAsStream(CONFIG_FILE);
                factory = builder.build(resourceAsStream);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        @Test
        public void findById()
        {
            SqlSession session = factory.openSession();//一般通过工厂获取，不建议通过new获取。
            Users user = session.selectOne("com.dao.UsersMapper.findById", 1);
            session.close();
   
            Assert.assertNotNull(user);
            Assert.assertEquals("管理员",user.getNickname());
            Assert.assertEquals("123",user.getPwd());
   
        }
    }

   测试结果：

      org.apache.ibatis.logging.LogFactory     - Logging initialized using 'class org.apache.ibatis.logging.log4j.Log4jImpl' adapter.
    18   DEBUG [main] org.apache.ibatis.datasource.pooled.PooledDataSource     - PooledDataSource forcefully closed/removed all connections.
    19   DEBUG [main] org.apache.ibatis.datasource.pooled.PooledDataSource     - PooledDataSource forcefully closed/removed all connections.
    19   DEBUG [main] org.apache.ibatis.datasource.pooled.PooledDataSource     - PooledDataSource forcefully closed/removed all connections.
    19   DEBUG [main] org.apache.ibatis.datasource.pooled.PooledDataSource     - PooledDataSource forcefully closed/removed all connections.
    142  DEBUG [main] org.apache.ibatis.transaction.jdbc.JdbcTransaction     - Opening JDBC Connection
    531  DEBUG [main] org.apache.ibatis.datasource.pooled.PooledDataSource     - Created connection 558187323.
    534  DEBUG [main]          com.dao.UsersMapper.findById     - ooo Using Connection [com.mysql.cj.jdbc.ConnectionImpl@2145433b]
    535  DEBUG [main]          com.dao.UsersMapper.findById     - ==>  Preparing: select id,nickname,realname,pwd,phone,email,address,create_time createTime,type,realid from n_users where id = ?
    582  DEBUG [main]          com.dao.UsersMapper.findById     - ==> Parameters: 1(Integer)
    628  TRACE [main]          com.dao.UsersMapper.findById     - <==    Columns: id, nickname, realname, pwd, phone, email, address, createTime, type, realid
    628  TRACE [main]          com.dao.UsersMapper.findById     - <==        Row: 1, 管理员, null, 123, null, null, null, 2019-10-09 10:06:39, 0, null
    633  DEBUG [main] org.apache.ibatis.transaction.jdbc.JdbcTransaction     - Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@2145433b]
    633  DEBUG [main] org.apache.ibatis.transaction.jdbc.JdbcTransaction     - Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@2145433b]
    633  DEBUG [main] org.apache.ibatis.datasource.pooled.PooledDataSource     - Returned connection 558187323 to pool.
   
    进程完成，退出码 0

   到此单元测试就完成了，接下来是一个完整的代码。

5. 单元测试总结代码：

    package com.dao;
   
    import com.bean.Users;
    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 org.junit.Assert;
    import org.junit.Test;
   
    import java.io.IOException;
    import java.io.InputStream;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Calendar;
    import java.util.List;
    import java.util.Date;
    public class UsersMapperTest {
        static final String CONFIG_FILE = "mybatis-config.xml";
        static SqlSessionFactory factory;
        static{  // 静态代码块
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            try {
                InputStream resourceAsStream =
                        Resources.getResourceAsStream(CONFIG_FILE);
                factory = builder.build(resourceAsStream);
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        @Test   // Alt+enter
        public void findById(){
            SqlSession session = factory.openSession();
            Users user = session.selectOne("com.dao.UsersMapper.findById", 1);
            // 手工的、肉眼的、主观的、人品的方式判断程序的成熟度
            System.out.println();// TRACE/DEBUG/INFO/ERROR
            // 自动的、断言的、客观的、量化的方式判断程序的成熟度
            Assert.assertNotNull(user);
            Assert.assertEquals("管理员",user.getNickname());
            Assert.assertEquals("123",user.getPwd());
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String date = df.format(user.getCreateTime());
            Assert.assertEquals("2019-10-09 10:06:39",date);
        }
        @Test
        public void findAll(){
            SqlSession session = factory.openSession();
            List<Users> list = session.selectList("com.dao.UsersMapper.findAll");
            Assert.assertNotNull(list);
            Assert.assertEquals(3,list.size());<!--!验证表里记录条数-->
            Assert.assertEquals("管理员",list.get(0).getNickname());
        }
        @Test
        public void add(){
            Users user = new Users();
            user.setNickname("zhaoliu");
            user.setRealname("赵六");
            user.setPhone("11111");
            user.setEmail("11111@111.com");
            user.setAddress("111");
            user.setPwd("123");
            user.setCreateTime(new java.util.Date());
            SqlSession session = factory.openSession();
            session.insert("com.dao.UsersMapper.add",user);
            session.commit();                                                         <!--!提交事务-->
            Users userDb = session.selectOne("com.dao.UsersMapper.findById",6);      <!--!id以实际为准-->
            Assert.assertNotNull(userDb);
            Assert.assertEquals("赵六",userDb.getRealname());
            session.close();
        }
        @Test
        public void update() throws ParseException {
            SqlSession session = factory.openSession();
            Users dbUser = session.selectOne("com.dao.UsersMapper.findById",6);
            Assert.assertNotNull(dbUser);
            dbUser.setNickname("zhaoliu");
            // 2020-03-03 14:13:23 => 2019-10-09 10:11:42 : 2种
            /*Calendar cl = Calendar.getInstance(); // 当前时间
            cl.set(Calendar.YEAR,2019);
            cl.set(Calendar.MONTH,9);   // 0-11
            cl.set(Calendar.DAY_OF_MONTH,9);  // 1-31
            cl.set(Calendar.HOUR_OF_DAY,10);  // 0-23
            cl.set(Calendar.MINUTE,11);     // 1-60
            cl.set(Calendar.SECOND,42);     // 1-60
            cl.set(Calendar.MILLISECOND,0);  Date date=cl.getTime();*/
            SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            Date date = df.parse("2020-10-09 10:11:43");    //常用于判断从网络接受的时间
            dbUser.setCreateTime(date);
            session.update("com.dao.UsersMapper.update",dbUser);
            session.commit();
            Users user = session.selectOne("com.dao.UsersMapper.findById",6);
            Assert.assertNotNull(user);
            Assert.assertEquals("zhaoliu",user.getNickname());
            Assert.assertEquals(date,user.getCreateTime());
        }
        @Test
        public void delete(){
            // hibernate,mybatis
            // 主从表/父子表的概念？主表-主键所在的表，从表-外键所在的表
            // 1、添加数据：先为主表添加数据，后为从表添加数据
            // 2、删除数据：先删除从表数据，然后删除主表数据
            // n_users (主表) 的从表：n_news,n_replys,n_short_replys,n_access_logs
            // a主->b从->c从->d从，不创建外键（外键关系是存在的）
            SqlSession session = factory.openSession();
            session.delete("com.dao.AccessLogsMapper.deleteByUsersId",6);
            session.delete("com.dao.ShortReplysMapper.deleteByUsersId",6);
            session.delete("com.dao.ReplysMapper.deleteByUsersId",6);
            session.delete("com.dao.NewsMapper.deleteByUsersId",6);
            session.delete("com.dao.UsersMapper.delete",6);
            session.commit();
            Users user = session.selectOne("com.dao.UsersMapper.findById",6);
            Assert.assertNull(user);
        }
    }

   在执行删除操作时，记得删除外键里的记录，后删除主键内的记录。    // 主从表/父子表的概念？主表-主键所在的表，从表-外键所在的表
   101         // 1、添加数据：先为主表添加数据，后为从表添加数据
   102         // 2、删除数据：先删除从表数据，然后删除主表数据
   103         // n_users (主表) 的从表：n_news,n_replys,n_short_replys,n_access_logs
   104         // a主->b从->c从->d从，不创建外键（外键关系是存在的）

6. 之后依次把实体类，实现Mapper,并在主配置文件中配置,Mapper。
7. 学会审视自己的代码，=》审查（语法错误，逻辑错误）、优化、重构。