springMVC+redis+mybatis的javaWeb框架的搭建---套路实战（1）

最新推荐文章于 2022-12-17 14:12:22 发布

原创最新推荐文章于 2022-12-17 14:12:22 发布 · 1.7k 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#spring mvc #mybatis #redis

mybatis 同时被 2 个专栏收录

4 篇文章

订阅专栏

springMVC+

1 篇文章

订阅专栏

本文介绍了一个消息系统的DAO层测试实现，通过Dbunit进行数据准备，并使用Spring JUnit4ClassRunner进行单元测试。

1、项目树形结构图

这里写图片描述

这个项目的结构其实和秒杀系的基础上增加来的，我主要增加了测试类的正规写法，但是当时在赶进度的过程中，我只是对dao层做了dbunit的测试，对业务层的mock测试没来得及做，写测试的工作，个人感觉其实需要花费的时间比你些业务逻辑花的时间多的要多.

MessageDaoTest.java

package cmcc.msggate.dao;

import cmcc.msggate.entity.Message;
import cmcc.msggate.utils.AbstractDbUnitTestCase;
import cmcc.msggate.utils.EntitiesHelper;
import org.dbunit.DatabaseUnitException;
import org.dbunit.dataset.DataSetException;
import org.dbunit.dataset.IDataSet;
import org.dbunit.operation.DatabaseOperation;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.sql.SQLException;
import java.util.Date;
import java.util.List;
import java.util.UUID;

/**
 * 测试messageDao
 * Created by tianjun on 2016/10/18 0018.
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration({"classpath:spring/spring-dao.xml"})
public class MessageDaoTest extends AbstractDbUnitTestCase {

    @Autowired
    private MessageDao messageDao;

    private IDataSet ds;

    private Message expected = new Message("1", "aaa", "123456", "456132", "123", new Date(), new Date(), 1,null,null,"转短信","123", null);

    private Logger logger = LoggerFactory.getLogger(this.getClass());

    @Before
    public void setUp() throws DataSetException, IOException {
        //备份书库中已存在的表
        backupOneTable("message");
        //根据自己编写的测试xml读取数据
        ds = createDateSet("t_message");
    }

    private Message create() {
        Message message = new Message();
        message.setMsgId("1");
        message.setFromUser("123456");
        message.setToUser("456132");
        message.setMsgText("aaa");
        message.setMsgIdentify("123");
        message.setCreateTime(new Date());
        message.setReplyTime(new Date());
        message.setPaUuid("123");
        return message;
    }


    @Test
    public void testQueryBymsgId() throws DatabaseUnitException, SQLException {
        DatabaseOperation.CLEAN_INSERT.execute(dbunitCon, ds);
        Message msg = messageDao.queryBymsgId("1");
        EntitiesHelper.assertMessage(expected, msg);
    }

    @Test
    public void testCreateMsg(){

        Message message = create();
        int i = messageDao.createMsg(message);
        EntitiesHelper.assertResult(1, i);


    }

//    @Test
//    public void testUpdateBymsgId() throws DatabaseUnitException, SQLException {
//
//        Message message = create();
//        messageDao.createMsg(message);
//        message = messageDao.queryBymsgId(message.getMsgId());
//        EntitiesHelper.assertMessageWithoutIdAndResult(expected, message);
//
//    }

    @Test
    public void testUpdateBymsgIdentify() throws DatabaseUnitException, SQLException {

        Message message = create();
        messageDao.createMsg(message);
        messageDao.updateBymsgIdentify(message.getMsgIdentify(), new Date(), 1);
        message = messageDao.queryBymsgId(message.getMsgId());
        EntitiesHelper.assertMessageWithoutMsgId(expected,message);

    }

    @Test
    public void testQueryBymsgIdentify() throws DatabaseUnitException, SQLException {
        DatabaseOperation.CLEAN_INSERT.execute(dbunitCon, ds);
        Message msg = messageDao.queryBymsgIdentify("123");
        EntitiesHelper.assertMessage(expected, msg);
    }

    @Test
    public void testQueryAll() throws DatabaseUnitException, SQLException {
        DatabaseOperation.CLEAN_INSERT.execute(dbunitCon, ds);
        List<Message> msgs = messageDao.queryAll(0, 100,"1", null);
        EntitiesHelper.assertMessage(expected, msgs.get(0));
    }

    @Test
    public void testQueryKeyword() throws DatabaseUnitException, SQLException {
        DatabaseOperation.CLEAN_INSERT.execute(dbunitCon, ds);
        List<Message> msgs = messageDao.queryByKeyword("a", 0, 100,"1");
        EntitiesHelper.assertMessage(expected, msgs.get(0));
    }


    @Test
    public void countMessage() throws DatabaseUnitException, SQLException {
        DatabaseOperation.CLEAN_INSERT.execute(dbunitCon, ds);
        EntitiesHelper.assertResult(1,messageDao.countMessage("2", "1"));
    }

    @Test
    public void countKeyword() throws DatabaseUnitException, SQLException {
        DatabaseOperation.CLEAN_INSERT.execute(dbunitCon, ds);
        EntitiesHelper.assertResult(1,messageDao.countkeyword("a","1"));
    }


    @Test
    public void testUuid(){
        String id = UUID.randomUUID().toString();
        System.out.println(id);
    }


    @After
    public void tearDown() throws FileNotFoundException, DatabaseUnitException, SQLException {
        resumeTable();
    }


}

AbstractDbUnitTestCase.java

package cmcc.msggate.utils;

import org.dbunit.DatabaseUnitException;
import org.dbunit.database.DatabaseConnection;
import org.dbunit.database.IDatabaseConnection;
import org.dbunit.database.QueryDataSet;
import org.dbunit.dataset.DataSetException;
import org.dbunit.dataset.IDataSet;
import org.dbunit.dataset.xml.FlatXmlDataSet;
import org.dbunit.dataset.xml.FlatXmlProducer;
import org.dbunit.operation.DatabaseOperation;
import org.junit.AfterClass;
import org.junit.BeforeClass;
import org.xml.sax.InputSource;

import java.io.*;
import java.net.URL;
import java.sql.SQLException;

import static org.junit.Assert.assertNotNull;

/**
 *
 * Created by tianjun on 2016/10/18 0018.
 */
public class AbstractDbUnitTestCase {

    public static IDatabaseConnection dbunitCon;
    private File tempFile;

    @BeforeClass  //只执行一次（@before是每一个@test前都要执行）同理@afterClass
    public static void init() throws DatabaseUnitException, SQLException {
        dbunitCon = new DatabaseConnection(Dbutil.getConnection());
    }


    protected IDataSet createDateSet(String tname) throws DataSetException {

        InputStream is = AbstractDbUnitTestCase.class.getClassLoader().getResourceAsStream(tname + ".xml");
        assertNotNull("dbunit的基础数据不存在", is);
        /**
         * 1、FlatXmlDataSet用来获取基于属性存储的属性值
         * 2、XMLDataSet用来获取基于节点类型存储的属性值
         */
        return new FlatXmlDataSet(new FlatXmlProducer(new InputSource(is)));
    }

    /**
     * 备份数据库所有的表
     *
     * @throws IOException
     * @throws SQLException
     * @throws DataSetException
     */
    protected void backupAllTalbe() throws IOException, SQLException, DataSetException {
        IDataSet ds = dbunitCon.createDataSet();
        writeBackupFile(ds);
    }

    private void writeBackupFile(IDataSet ds) throws IOException, DataSetException {
        tempFile = File.createTempFile("back", "xml");
        FlatXmlDataSet.write(ds, new FileWriter(tempFile));
    }

    protected void backupCustomTable(String[] tname) throws DataSetException, IOException {
        QueryDataSet ds = new QueryDataSet(dbunitCon);
        for (String str : tname) {
            ds.addTable(str);
        }
        writeBackupFile(ds);
    }

    /**
     * 备份某张表
     *
     * @param tname
     * @throws DataSetException
     * @throws IOException
     */
    protected void backupOneTable(String tname) throws DataSetException, IOException {
        backupCustomTable(new String[]{tname});
    }

    /**
     * 还原数据库表
     *
     * @throws FileNotFoundException
     * @throws DatabaseUnitException
     * @throws SQLException
     */
    protected void resumeTable() throws FileNotFoundException, DatabaseUnitException, SQLException {
        IDataSet ds = new FlatXmlDataSet(new FlatXmlProducer(
                new InputSource(new FileInputStream(tempFile))));
        DatabaseOperation.CLEAN_INSERT.execute(dbunitCon, ds);
    }

    @AfterClass
    public static void destory() {
        if (dbunitCon != null) {
            try {
                dbunitCon.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

}

Dbutil.java

package cmcc.msggate.utils;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.io.support.PropertiesLoaderUtils;

import java.io.IOException;
import java.sql.*;
import java.util.Properties;

/**
 *
 * Created by tianjun on 2016/10/18 0018.
 */
public class Dbutil {
    private static Logger logger = LoggerFactory.getLogger(Dbutil.class);
    public static Connection getConnection() throws SQLException {
        Connection con = null;

        Properties props = null;
        try{
            props = PropertiesLoaderUtils.loadAllProperties("jdbc.properties");

        }catch (IOException e){
            logger.error(e.getMessage(),e);
        }
        String url = props.getProperty("jdbc.url");
        String username = props.getProperty("jdbc.username");
        String password = props.getProperty("jdbc.password");

        con = DriverManager.getConnection(url,username,password);
        return con;
    }

    public static void close(Connection con) {
        try {
            if(con!=null) con.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static void close(PreparedStatement ps) {
        try {
            if(ps!=null) ps.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    public static void close(ResultSet rs) {
        try {
            if(rs!=null) rs.close();
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

EntitiesHelper.java

package cmcc.msggate.utils;

import cmcc.msggate.entity.Message;
import org.junit.Assert;


/**
 * Created by tianjun on 2016/10/18 0018.
 */
public class EntitiesHelper {

    public static void assertMessage(Message expected, Message actual) {
        Assert.assertNotNull(expected);
        Assert.assertEquals(expected.getMsgId(), actual.getMsgId());
        Assert.assertEquals(expected.getFromUser(), actual.getFromUser());
        Assert.assertEquals(expected.getToUser(), actual.getToUser());
        Assert.assertEquals(expected.getMsgIdentify(), actual.getMsgIdentify());
        Assert.assertEquals(expected.getMsgText(), actual.getMsgText());
        Assert.assertEquals(expected.getSendResult(), actual.getSendResult());
    }

    public static void assertMessageWithoutIdAndResult(Message expected, Message actual) {
        Assert.assertNotNull(expected);
        Assert.assertEquals(expected.getFromUser(), actual.getFromUser());
        Assert.assertEquals(expected.getToUser(), actual.getToUser());
        Assert.assertEquals(expected.getMsgIdentify(), actual.getMsgIdentify());
        Assert.assertEquals(expected.getMsgText(), actual.getMsgText());
    }

    public static void assertMessageWithoutMsgId(Message expected, Message actual) {
        Assert.assertNotNull(expected);
        Assert.assertEquals(expected.getFromUser(), actual.getFromUser());
        Assert.assertEquals(expected.getToUser(), actual.getToUser());
        Assert.assertEquals(expected.getMsgIdentify(), actual.getMsgIdentify());
        Assert.assertEquals(expected.getMsgText(), actual.getMsgText());
        Assert.assertEquals(expected.getSendResult(), actual.getSendResult());
    }

    public static void assertResult(Integer expected, Integer actual) {
        Assert.assertEquals(expected, actual);
    }

}