mybatis test 引用java mybatis的test

转载

编程梦想编织者 2024-01-30 01:40:05

文章标签 mybatis test 引用java apache Test java 文章分类 Java 后端开发

单元测试 junit测试单元测试流程

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

一。单元测试

在项目下创建一个目录test,之后将test右键Mark Directory as(标记目录为)->测试源根
在test下创建类，类的包名与被测试类的包名一致，在被测试类后面加上Test，例如：com.dao.UsersMapper与com.dao.UsersMapperTest。在测试方法前@Test,导入junit测试路径，点击确定即可，之后maven后台下载。
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);

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

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

1 package com.dao;
 2 
 3 import com.bean.Users;
 4 import org.apache.ibatis.io.Resources;
 5 import org.apache.ibatis.session.SqlSession;
 6 import org.apache.ibatis.session.SqlSessionFactory;
 7 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
 8 import org.junit.Assert;
 9 import org.junit.Test;
10 
11 import java.io.IOException;
12 import java.io.InputStream;
13 
14 public class UsersMapperTest {
15     static final String CONFIG_FILE = "mybatis-config.xml";
16     static SqlSessionFactory factory;
17     //非静态成员，实例成员，成员变量，通过构造方法初始化。  静态函数，成员通过静态代码块初始化
18     static{  // 静态代码块
19         SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
20         try {
21             InputStream resourceAsStream =
22                     Resources.getResourceAsStream(CONFIG_FILE);
23             factory = builder.build(resourceAsStream);
24         } catch (IOException e) {
25             e.printStackTrace();
26         }
27     }
28     @Test
29     public void findById()
30     {
31         SqlSession session = factory.openSession();//一般通过工厂获取，不建议通过new获取。
32         Users user = session.selectOne("com.dao.UsersMapper.findById", 1);
33         session.close();
34 
35         Assert.assertNotNull(user);
36         Assert.assertEquals("管理员",user.getNickname());
37         Assert.assertEquals("123",user.getPwd());
38 
39     }
40 }

测试结果：

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

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

单元测试总结代码：

1 package com.dao;
  2 
  3 import com.bean.Users;
  4 import org.apache.ibatis.io.Resources;
  5 import org.apache.ibatis.session.SqlSession;
  6 import org.apache.ibatis.session.SqlSessionFactory;
  7 import org.apache.ibatis.session.SqlSessionFactoryBuilder;
  8 import org.junit.Assert;
  9 import org.junit.Test;
 10 
 11 import java.io.IOException;
 12 import java.io.InputStream;
 13 import java.text.ParseException;
 14 import java.text.SimpleDateFormat;
 15 import java.util.Calendar;
 16 import java.util.List;
 17 import java.util.Date;
 18 public class UsersMapperTest {
 19     static final String CONFIG_FILE = "mybatis-config.xml";
 20     static SqlSessionFactory factory;
 21     static{  // 静态代码块
 22         SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
 23         try {
 24             InputStream resourceAsStream =
 25                     Resources.getResourceAsStream(CONFIG_FILE);
 26             factory = builder.build(resourceAsStream);
 27         } catch (IOException e) {
 28             e.printStackTrace();
 29         }
 30     }
 31     @Test   // Alt+enter
 32     public void findById(){
 33         SqlSession session = factory.openSession();
 34         Users user = session.selectOne("com.dao.UsersMapper.findById", 1);
 35         // 手工的、肉眼的、主观的、人品的方式判断程序的成熟度
 36         System.out.println();// TRACE/DEBUG/INFO/ERROR
 37         // 自动的、断言的、客观的、量化的方式判断程序的成熟度
 38         Assert.assertNotNull(user);
 39         Assert.assertEquals("管理员",user.getNickname());
 40         Assert.assertEquals("123",user.getPwd());
 41         SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 42         String date = df.format(user.getCreateTime());
 43         Assert.assertEquals("2019-10-09 10:06:39",date);
 44     }
 45     @Test
 46     public void findAll(){
 47         SqlSession session = factory.openSession();
 48         List<Users> list = session.selectList("com.dao.UsersMapper.findAll");
 49         Assert.assertNotNull(list);
 50         Assert.assertEquals(3,list.size());<!--!验证表里记录条数-->
 52         Assert.assertEquals("管理员",list.get(0).getNickname());
 53     }
 54     @Test
 55     public void add(){
 56         Users user = new Users();
 57         user.setNickname("zhaoliu");
 58         user.setRealname("赵六");
 59         user.setPhone("11111");
 60         user.setEmail("11111@111.com");
 61         user.setAddress("111");
 62         user.setPwd("123");
 63         user.setCreateTime(new java.util.Date());
 64         SqlSession session = factory.openSession();
 65         session.insert("com.dao.UsersMapper.add",user);
 66         session.commit();                                                         <!--!提交事务-->
 67         Users userDb = session.selectOne("com.dao.UsersMapper.findById",6);      <!--!id以实际为准-->
 68         Assert.assertNotNull(userDb);
 69         Assert.assertEquals("赵六",userDb.getRealname());
 70         session.close();
 71     }
 72     @Test
 73     public void update() throws ParseException {
 74         SqlSession session = factory.openSession();
 75         Users dbUser = session.selectOne("com.dao.UsersMapper.findById",6);
 76         Assert.assertNotNull(dbUser);
 77         dbUser.setNickname("zhaoliu");
 78         // 2020-03-03 14:13:23 => 2019-10-09 10:11:42 : 2种
 79         /*Calendar cl = Calendar.getInstance(); // 当前时间
 80         cl.set(Calendar.YEAR,2019);
 81         cl.set(Calendar.MONTH,9);   // 0-11
 82         cl.set(Calendar.DAY_OF_MONTH,9);  // 1-31
 83         cl.set(Calendar.HOUR_OF_DAY,10);  // 0-23
 84         cl.set(Calendar.MINUTE,11);     // 1-60
 85         cl.set(Calendar.SECOND,42);     // 1-60
 86         cl.set(Calendar.MILLISECOND,0);  Date date=cl.getTime();*/
 87         SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
 88         Date date = df.parse("2020-10-09 10:11:43");    //常用于判断从网络接受的时间
 89         dbUser.setCreateTime(date);
 90         session.update("com.dao.UsersMapper.update",dbUser);
 91         session.commit();
 92         Users user = session.selectOne("com.dao.UsersMapper.findById",6);
 93         Assert.assertNotNull(user);
 94         Assert.assertEquals("zhaoliu",user.getNickname());
 95         Assert.assertEquals(date,user.getCreateTime());
 96     }
 97     @Test
 98     public void delete(){
 99         // hibernate,mybatis
100         // 主从表/父子表的概念？主表-主键所在的表，从表-外键所在的表
101         // 1、添加数据：先为主表添加数据，后为从表添加数据
102         // 2、删除数据：先删除从表数据，然后删除主表数据
103         // n_users (主表) 的从表：n_news,n_replys,n_short_replys,n_access_logs
104         // a主->b从->c从->d从，不创建外键（外键关系是存在的）
105         SqlSession session = factory.openSession();
106         session.delete("com.dao.AccessLogsMapper.deleteByUsersId",6);
107         session.delete("com.dao.ShortReplysMapper.deleteByUsersId",6);
108         session.delete("com.dao.ReplysMapper.deleteByUsersId",6);
109         session.delete("com.dao.NewsMapper.deleteByUsersId",6);
110         session.delete("com.dao.UsersMapper.delete",6);
111         session.commit();
112         Users user = session.selectOne("com.dao.UsersMapper.findById",6);
113         Assert.assertNull(user);
114     }
115 }

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