mybatis框架入门（一）

mybatis的入门

mybatis的环境搭建

• 创建maven工程并导入坐标

• 创建实体类和dao的接口（实体类的成员必须和数据库表格中的字段名称一样）

  

   

   

• 创建mybatis的主配置文件SqlMapConfig.xml

  

   

   

• 创建映射配置文件WordsDao.xml

  

   

   

注意事项：

• 创建WordsDao.xml和WordsDao.java时名称是为了和我们之前的知识保持一致，在mybatis中他把持久层的操作接口名称和映射文件也叫做Mapper，所以，WordsDao和WordsMapper也是一样的

• 在idea中创建目录的时候，目录和包是不一样的，创建bao时，com.dao是二级结构；若是目录，则是一级结构

• mybatis的映射配置文件位置必须和dao层接口的包结构一致

• 映射配置文件的mapper标签namespace的属性的取值必须和dao层接口的全限定类名一致

• 映射的配置文件的操作配置（select ）id属性的取值必须是dao层接口的方法名

• 如果后三步符合要求，我们在开发中无需再写dao的实现类

mybatis入门案例实现（在上述配置文件已经完整配置好）

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;
import java.util.List;

• 读取主配置文件：

  //读取配置文件时，①可以使用类加载器，他只能读取类路径的配置文件；②可以使用ServletContext对象的getRealPath();
  InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");

• 创建SqlSessionFactory工厂：

  //创建工厂mybatis使用了构建者模式，可以把对象的构建细节隐藏，使使用者直接调用方法即可拿到对象
  SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
  SqlSessionFactory factory = builder.build(in);

• 创建SqlSession对象

  //生产SqlSession使用了工厂模式，可以解耦类之间的关系
  SqlSession sqlSession = factory.openSession();

• 创建Dao接口的代理对象

  //创建dao接口实现类使用了代理模式，不修改源码的基础上对已有的方法功能增强
  WordsDao wordsDao = sqlSession.getMapper(WordsDao.class);

• 使用代理对象执行方法

  List words = wordsDao.findAll();
          for (Words word : words) {
              System.out.println(word);
          }

• 释放资源

  sqlSession.close();
  in.close();

  完成的代码：

  package com.test;
  ​
  ​
  import com.dao.WordsDao;
  import com.domain.Words;
  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;
  import java.util.List;
  ​
  /**
   * @author xusha
   *
   * mybatis入门案例
   */
  public class MybatisTest {
      public static void main(String[] args) throws Exception {
          //1、读取配置文件
          InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
          //2、创建SqlSessionFactory工厂
          SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
          SqlSessionFactory factory = builder.build(in);
          //3、使用工厂创建SqlSession对象
          SqlSession sqlSession = factory.openSession();
          //4、使用SqlSession对象创建Dao接口的代理对象
          WordsDao wordsDao = sqlSession.getMapper(WordsDao.class);
          //5、使用代理对象执行方法
          List words = wordsDao.findAll();
          for (Words word : words) {
              System.out.println(word);
          }
          //6、释放资源
          sqlSession.close();
          in.close();
      }
  }

• 注意事项：

  • 可以使用注解的方式优化一些必要的代码

  在我们的主配置文件，修改指定的映射配置文件，这样指定的映射配置文件就可以删除

  
      
      <mappers>
  
          <mapper class="com.dao.WordsDao" />
    mappers>

  • 或者我们使用接口实现类完成查询结果：我们需要在dao包下创建一个impl包，新建接口的实现类，重写接口的方法（findAll）

  public class WordsDaoImpl implements WordsDao{
      private SqlSessionFactory factory;
      public WordsDaoImpl(SqlSessionFactory factory){
          this.factory = factory;
      }
      
      @Override
      public List findAll(){
          //1、使用工厂创建SqlSession对象
          SqlSession session = factory.openSession();
          //2、使用session执行查询所有方法
          List words = session.selectList("com.dao.WordsDao.findAll");
          session.close();
          //3、返回查询结果
          return words;
      }
  }

  由于我们在上述测试类中的main函数中已经有了工厂对象，我们就可以直接传递对象参数，后执行实现类的方法，而且还没有session对象，也不用关闭，对比之后的代码

  package com.test;
  
  
  import com.dao.WordsDao;
  import com.domain.Words;
  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;
  import java.util.List;
  
  /**
   * @author xusha
   *
   * mybatis入门案例
   */
  public class MybatisTest {
      public static void main(String[] args) throws Exception {
          //1、读取配置文件
          InputStream in = Resources.getResourceAsStream("SqlMapConfig.xml");
          //2、创建SqlSessionFactory工厂
          SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
          SqlSessionFactory factory = builder.build(in);
          //3、创建实现类对象
          WordsDaoImpl wordsDaoImpl = new WordsDaoImpl(factory);
          //4、使用对象执行方法
          List words = wordsDaoImpl.findAll();
          for (Words word : words) {
              System.out.println(word);
          }
          //5、释放资源
          in.close();
      }
  }

  使用指定的映射配置文件实现mybatis的增删改查等功能

  CURD功能都是使用代理对象实现的（使用单元测试功能测试每一个功能，另外增加一个聚合函数的实现和一个模糊查询的功能）

  完成这些功能分为以下几个步骤：（主配置已配好）

• 实体类Words.java：成员变量尽量和数据库表的字段名一样，每个成员的setter和getter方法，另外增加一个toString()方法

package com.domain;

import java.io.Serializable;

/**
 * @author 小沙砾
 */
public class Words implements Serializable {
    private Integer id;
    private String word;
    private String translation;
    private String introduction;
    private String add_time;
    private Integer star;

    @Override
    public String toString() {
        return "com.domain.Words{" +
                "id=" + id +
                ", word='" + word + '\'' +
                ", translation='" + translation + '\'' +
                ", introduction='" + introduction + '\'' +
                ", add_time='" + add_time + '\'' +
                ", star=" + star +
                '}';
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getWord() {
        return word;
    }

    public void setWord(String word) {
        this.word = word;
    }

    public String getTranslation() {
        return translation;
    }

    public void setTranslation(String translation) {
        this.translation = translation;
    }

    public String getIntroduction() {
        return introduction;
    }

    public void setIntroduction(String introduction) {
        this.introduction = introduction;
    }

    public String getAdd_time() {
        return add_time;
    }

    public void setAdd_time(String add_time) {
        this.add_time = add_time;
    }

    public Integer getStar() {
        return star;
    }

    public void setStar(Integer star) {
        this.star = star;
    }
}

• dao层的接口类的抽象方法需要包含4个功能CRUD

package com.dao;

import com.domain.Words;

import java.util.List;

/**
 * @author 小沙砾
 *
 * 用户的持久层接口
 */
public interface WordsDao {
    /**
     * 查询所有信息
     * @return
     */
    List findAll();

    /**
     * 保存信息
     * @param words
     */
    void saveWords(Words words);

    /**
     * 更新信息
     * @param words
     */
    void updateWords(Words words);

    /**
     * 删除信息
     * @param id
     */
    void deleteWords(Integer id);
    
    /**
     * 根据id查询信息
     * @return
     */
    List findById(Integer id);

    /**
     * 根据word模糊查询信息
     * @return
     */
    List findByWord(String word);

    /**
     * 统计信息的记录数
     * @return
     */
    int countInfo();
}

• 主配置中需要指定的映射配置文件WordsDao.xml，如果使用到实体类的成员变量名，需要在标签上指定parameterType="全限类限定名"，成员变量使用#{成员变量名}

xml version="1.0" encoding="UTF-8" ?>
DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.dao.WordsDao">
    
    <select id="findAll" resultType="com.domain.Words">
        select * from words;
    select>

    
    <insert id="saveWords" parameterType="com.domain.Words">
        insert into words(id, word, translation, introduction, group_id, add_time, star)
        values(#{id}, #{word}, #{translation}, #{introduction}, 1, #{add_time}, #{star});
    insert>

    
    <update id="updateWords" parameterType="com.domain.Words">
        update words
        set star = #{star}
        where id = #{id};
    update>

    
    <delete id="deleteWords" parameterType="int">
        delete
        from words
        where id = #{wid}
    delete>
    
    
    <select id="findById" parameterType="int" resultType="com.domain.Words">
        select * from words where id = #{wid};
    select>

    
    <select id="findByWord" parameterType="String" resultType="com.domain.Words">
        select * from words where word like #{word};
    select>

    
    <select id="countInfo" resultType="int">
        select count(id) from words;
    select>
mapper>

 

• 测试类中包含各种测试，其中包含CURD功能测试，为了测试CURD功能，也可以优化一些代码，如各种对象的创建和销毁，使得我们测试的方法只包含主要测试的部分

package com.test;


import com.dao.WordsDao;
import com.domain.Words;
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.After;
import org.junit.Before;
import org.junit.Test;

import java.io.InputStream;
import java.util.List;

/**
 * @author 小沙砾
 *
 * mybatis入门案例
 */
public class MybatisTest {
    private InputStream in;
    private SqlSessionFactoryBuilder builder;
    private SqlSessionFactory factory;
    private SqlSession sqlSession;
    private WordsDao wordsDao;

    @Before   //用于在测试方法执行之前执行的
    public void init() throws Exception {
        //1、读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2、创建SqlSessionFactory工厂
        builder = new SqlSessionFactoryBuilder();
        factory = builder.build(in);
        //3、使用工厂创建SqlSession对象
        sqlSession = factory.openSession();
        //4、使用SqlSession对象创建Dao接口的代理对象
        wordsDao = sqlSession.getMapper(WordsDao.class);
    }

    @After   //用于在测试方法执行之后执行的
    public void destroy(){
        //6、释放资源
        if(sqlSession != null){
            try{
                sqlSession.close();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
        if(in != null){
            try{
                in.close();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    @Test
    public void testFindAll() {
        //5、使用代理对象执行方法
        List words = wordsDao.findAll();
        for (Words word : words) {
            System.out.println(word);
        }
    }

    @Test
    public void testSaveWords() {
        Words words = new Words();
        words.setId(8);
        words.setWord("come on！");
        words.setTranslation("加油！");
        words.setIntroduction("语气词");
        words.setAdd_time("2020-03-20");
        words.setStar(1);

        //5、执行保存方法
        wordsDao.saveWords(words);

        //事务提交
        sqlSession.commit();
    }

    @Test
    public void testUpdateWords() {
        Words words = new Words();
        words.setId(8);
        words.setWord("come on！");
        words.setTranslation("加油！");
        words.setIntroduction("语气词");
        words.setAdd_time("2020-03-20");
        words.setStar(2);

        //5、执行更新方法
        wordsDao.updateWords(words);

        //事务提交
        sqlSession.commit();
    }

    @Test
    public void testDeleteWords() {
        //5、执行删除方法
        wordsDao.deleteWords(8);

        //事务提交
        sqlSession.commit();
    }
    
    @Test
    public void testFindById() {
        //5、执行根据id查询信息方法
        List words = wordsDao.findById(7);
        for (Words word : words) {
            System.out.println(word);
        }
    }

    @Test
    public void testFindByWord() {
        //5、执行根据word名称模糊查询信息
        List words = wordsDao.findByWord("%w%");
        for (Words word : words) {
            System.out.println(word);
        }
    }

    @Test
    public void testCountInfo(){
        //5、执行统计信息的记录数的方法
        Integer count = wordsDao.countInfo();
        System.out.println(count);
    }
}

在Dao层使用实现接口类实现mybatis的CURD功能

• 根据上述说明，可以知道在dao层可以创建执行数据库session对象，即可在dao层的接口实现类里执行重写的方法来执行数据库操作的语句，实体类和指定映射配置文件不需要改变。

• 接口实现类WordsDaoImpl：实现接口类的抽象方法，用成员变量session调用自己的实现方法

package com.dao.impl;

import com.dao.WordsDao;
import com.domain.Words;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

import java.util.List;

public class WordsDaoImpl implements WordsDao {
    private SqlSessionFactory factory;

    public WordsDaoImpl(SqlSessionFactory factory){
        this.factory = factory;
    }

    public List findAll() {
        //1、使用工厂创建SqlSession对象
        SqlSession session = factory.openSession();
        //2、使用session执行查询的所有方法
        List words = session.selectList("com.dao.WordsDao.findAll");
        session.close();
        //3、返回查询结果
        return words;
    }

    public void saveWords(Words words) {
        //1、使用工厂创建SqlSession对象
        SqlSession session = factory.openSession();
        //2、使用session对象执行保存方法
        session.insert("com.dao.WordsDao.saveWords", words);
        //3、事务提交
        session.commit();
        session.close();
    }

    public void updateWords(Words words) {
        //1、使用工厂创建SqlSession对象
        SqlSession session = factory.openSession();
        //2、使用session对象执行更新方法
        session.update("com.dao.WordsDao.updateWords", words);
        //3、事务提交
        session.commit();
        session.close();
    }

    public void deleteWords(Integer id) {
        //1、使用工厂创建SqlSession对象
        SqlSession session = factory.openSession();
        //2、使用session对象执行删除方法
        session.delete("com.dao.WordsDao.deleteWords", id);
        //3、事务提交
        session.commit();
        session.close();
    }

    public Words findById(Integer id) {
        //1、使用工厂创建SqlSession对象
        SqlSession session = factory.openSession();
        //2、使用session对象执行查询方法
        Words words = session.selectOne("com.dao.WordsDao.findById", id);
        session.close();
        return words;
    }

    public List findByWord(String word) {
        //1、使用工厂创建SqlSession对象
        SqlSession session = factory.openSession();
        //2、使用session对象执行模糊查询方法
        List words = session.selectList("com.dao.WordsDao.findByWord", word);
        session.close();
        return words;
    }

    public int countInfo() {
        //1、使用工厂创建SqlSession对象
        SqlSession session = factory.openSession();
        //2、使用session对象执行统计信息记录数方法
        Integer count = session.selectOne("com.dao.WordsDao.countInfo");
        session.close();
        return count;
    }
}

• 相应的测试类的单元测试方法可以减少不必要的代码

package com.test;


import com.dao.WordsDao;
import com.dao.impl.WordsDaoImpl;
import com.domain.Words;
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.After;
import org.junit.Before;
import org.junit.Test;

import java.io.InputStream;
import java.util.List;

/**
 * @author 小沙砾
 *
 * mybatis入门案例
 */
public class MybatisTest {
    private InputStream in;
    private SqlSessionFactoryBuilder builder;
    private SqlSessionFactory factory;
    //实现类对象
    private WordsDaoImpl wordsDaoImpl;

    @Before   //用于在测试方法执行之前执行的
    public void init() throws Exception {
        //1、读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2、创建SqlSessionFactory工厂
        builder = new SqlSessionFactoryBuilder();
        factory = builder.build(in);
        //3、创建实现类对象
        wordsDaoImpl = new WordsDaoImpl(factory);
    }

    @After   //用于在测试方法执行之后执行的
    public void destroy(){
        //6、释放资源
        if(in != null){
            try{
                in.close();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    @Test
    public void testFindAll() {
        //4、使用对象执行方法
        List words = wordsDaoImpl.findAll();
        for (Words word : words) {
            System.out.println(word);
        }
    }

    @Test
    public void testSaveWords() {
        Words words = new Words();
        words.setWord("smartphone");
        words.setTranslation("智能手机");
        words.setIntroduction("名词");
        words.setAdd_time("2020-03-20");
        words.setStar(1);
        System.out.println("保存之前的"+words);  //其中的id=null
        //5、执行保存方法
        wordsDaoImpl.saveWords(words);
        System.out.println("保存之后的"+words);   //其中的id有具体的值
    }

    @Test
    public void testUpdateWords() {
        Words words = new Words();
        words.setId(10);
        words.setStar(4);

        //5、执行更新方法
        wordsDaoImpl.updateWords(words);
    }

    @Test
    public void testDeleteWords() {
        //5、执行删除方法
        wordsDaoImpl.deleteWords(2);
    }

    @Test
    public void testFindById() {
        //5、执行根据id查询信息方法
        Words words = wordsDaoImpl.findById(7);
        System.out.println(words);
    }

    @Test
    public void testFindByWord() {
        //5、执行根据word名称模糊查询信息
        List words = wordsDaoImpl.findByWord("%w%");
        for (Words word : words) {
            System.out.println(word);
        }
    }

    @Test
    public void testCountInfo(){
        //5、执行统计信息的记录数的方法
        Integer count = wordsDaoImpl.countInfo();
        System.out.println(count);
    }
}

主配置文件的一些配置的要点

使用数据库连接为例

• 直接配置数据库环境然后在连接

• 使用properties配置，在标签内部给定数据库连接的信息

• 使用外部配置文件，然后在properties的resource属性或者是url属性指定外部配置文件的信息

注意事项：文件中有如何使用填写的信息

xml version="1.0" encoding="UTF-8" ?>
DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>

    
    
    <properties resource="jdbcConfig.properties">




    properties>

    
    <environments default="mysql">
        
        <environment id="mysql">
            
            <transactionManager type="JDBC">transactionManager>
            
            <dataSource type="POOLED">
                
                
                <property name="driver" value="${jdbc.driver}"/>
                <property name="url" value="${jdbc.url}"/>
                <property name="username" value="${jdbc.username}"/>
                <property name="password" value="${jdbc.password}"/>
            dataSource>
        environment>
    environments>

    
    
    <mappers>
        <mapper resource="com/dao/WordsDao.xml" />

    mappers>
configuration>

mybatis配置数据库连接池

mybatis提供了3种数据库连接池的配置方式

• 配置的位置

  • 主配置文件SqlMapConfig.xml中的dataSource标签，type属性就是表示采用何种连接池方式，type属性值如下

    • POOLED 采用传统的javax.sql.DataSource规范中的连接池，mybatis中有针对规范的实现

    • UNPOOLED 采用传统的获取连接的方式，虽然也实现了javax.sql.DataSource接口，但是并没有实现池的思想

    • JNDI 采用服务器提供的JDNI技术实现，来获取DataSource对象，不同的服务器所能拿到的DataSource是不一样的

      注意：如果不是web或者maven的war工程，是不能使用的

mybatis动态查询数据库表格信息

像一些有多重条件的或者是in集合的sql语句，我们可以采用一些特定的标签，以下只举例and条件和in集合（这里是使用dao层对象），这里还会使用封装

• 我们可以创建一个类来辅助我们的实体类，这里是创建一个QueryVo类

package com.domain;

import java.util.List;

public class QueryVo {
    private Words words;
    private List ids;

    public List getIds() {
        return ids;
    }

    public void setIds(List ids) {
        this.ids = ids;
    }

    public Words getWords() {
        return words;
    }

    public void setWords(Words words) {
        this.words = words;
    }
}

• 我们在dao层接口定义两个抽象方法：多重条件和集合查询

package com.dao;

import com.domain.QueryVo;
import com.domain.Words;

import java.util.List;

/**
 * @author 小沙砾
 *
 * 用户的持久层接口
 */
public interface WordsDao {
    /**
     * 查询所有信息
     * @return
     */
    List findAll();

    /**
     * 根据queryVo中的条件查询信息
     * @param vo
     * @return
     */
    List findWordsByVo(QueryVo vo);

    /**
     * 根据条件获取信息
     * @param words: 参数是可变的（参数个数不定）
     * @return
     */
    List findByConditions(Words words);

    /**
     * 根据queryVo中的id集合查询信息
     * @param vo
     * @return
     */
    List findWordsByInIds(QueryVo vo);
}

• 接口实现类

package com.dao.impl;

import com.dao.WordsDao;
import com.domain.QueryVo;
import com.domain.Words;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;

import java.util.List;

public class WordsDaoImpl implements WordsDao {
    private SqlSessionFactory factory;

    public WordsDaoImpl(SqlSessionFactory factory){
        this.factory = factory;
    }

    public List findAll() {
        //1、使用工厂创建SqlSession对象
        SqlSession session = factory.openSession();
        //2、使用session执行查询的所有方法
        List words = session.selectList("com.dao.WordsDao.findAll");
        session.close();
        //3、返回查询结果
        return words;
    }

    public List findWordsByVo(QueryVo vo) {
        //1、使用工厂创建SqlSession对象
        SqlSession session = factory.openSession();
        //2、使用session对象执行根据条件查询的方法
        List res = session.selectList("com.dao.WordsDao.findWordsByVo", vo);
        session.close();
        return res;
    }

    public List findByConditions(Words words){
        //1、使用工厂创建SqlSession对象
        SqlSession session = factory.openSession();
        //2、使用session对象执行根据条件查询的方法
        List res = session.selectList("com.dao.WordsDao.findByConditions", words);
        session.close();
        return res;
    }

    public List findWordsByInIds(QueryVo vo) {
        //1、使用工厂创建SqlSession对象
        SqlSession session = factory.openSession();
        //2、使用session对象执行根据条件查询的方法
        List res = session.selectList("com.dao.WordsDao.findWordsByInIds", vo);
        session.close();
        return res;
    }
}

• 指定映射配置文件里需要将words结果集封装成Map

xml version="1.0" encoding="UTF-8" ?>
DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.dao.WordsDao">
    
    <resultMap id="wordsMap" type="com.domain.Words">
        
        <id property="id" column="id">id>
        
        <result property="word" column="word">result>
        <result property="translation" column="translation">result>
        <result property="introduction" column="introduction">result>
        <result property="add_time" column="add_time">result>
        <result property="star" column="star">result>
    resultMap>

    
    <select id="findAll" resultMap="wordsMap">
        select * from words;
    select>

    
    <select id="findWordsByVo" parameterType="com.domain.QueryVo" resultType="com.domain.Words">
        select * from words where word like #{words.word};
    select>

    
    <select id="findByConditions" resultType="com.domain.Words" parameterType="com.domain.Words">
        select * from words where 1=1
        <if test="word != null">
            and word = #{word}
        if>
    select>

    
    <select id="findWordsByInIds" resultMap="wordsMap" parameterType="com.domain.QueryVo">
        select * from words
        <where>
            <if test="ids != null and ids.size()>0">
                <foreach collection="ids" open="and id in (" close=")" item="id" separator=",">
                    #{id}
                foreach>
            if>
        where>
    select>
mapper>

 

• 单元测试类

package com.test;


import com.dao.WordsDao;
import com.dao.impl.WordsDaoImpl;
import com.domain.QueryVo;
import com.domain.Words;
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.After;
import org.junit.Before;
import org.junit.Test;

import java.io.InputStream;
import java.util.ArrayList;
import java.util.List;

/**
 * @author 小沙砾
 *
 * mybatis入门案例
 */
public class MybatisTest {
    private InputStream in;
    private SqlSessionFactoryBuilder builder;
    private SqlSessionFactory factory;
    //实现类对象
    private WordsDaoImpl wordsDaoImpl;

    @Before   //用于在测试方法执行之前执行的
    public void init() throws Exception {
        //1、读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        //2、创建SqlSessionFactory工厂
        builder = new SqlSessionFactoryBuilder();
        factory = builder.build(in);
        //3、创建实现类对象
        wordsDaoImpl = new WordsDaoImpl(factory);
    }

    @After   //用于在测试方法执行之后执行的
    public void destroy(){
        //6、释放资源
        if(in != null){
            try{
                in.close();
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    @Test
    public void testFindAll() {
        //4、使用对象执行方法
        List words = wordsDaoImpl.findAll();
        for (Words word : words) {
            System.out.println(word);
        }
    }

    @Test
    public void testFindWordsByVo() {
        QueryVo vo = new QueryVo();
        Words words = new Words();
        words.setWord("%w%");
        vo.setWords(words);
        //5、执行根据word名称模糊查询信息
        List res = wordsDaoImpl.findWordsByVo(vo);
        for (Words re : res) {
            System.out.println(re);
        }
    }

    @Test
    public void testFindByCondition(){
        Words words = new Words();
        words.setWord("computer");
        //5、执行根据条件查询的方法
        List res = wordsDaoImpl.findByConditions(words);
        for (Words re : res) {
            System.out.println(re);
        }
    }

    @Test
    public void testFindWordsByInIds(){
        QueryVo vo = new QueryVo();
        ArrayList arr = new ArrayList();
        arr.add(1);
        arr.add(8);
        arr.add(7);
        arr.add(10);
        arr.add(9);
        vo.setIds(arr);
        List res = wordsDaoImpl.findWordsByInIds(vo);
        for (Words re : res) {
            System.out.println(re);
        }
    }
}

 

mybatis中多表之间的关系的实现

• mybatis中多表之间的一对一关系

  • 两个表的实体类可以像往常一样创建，但是在子表（从表）创建主表实体类对象的引用，以下显示子表实体类

  package com.domain;
  
  import java.io.Serializable;
  
  /**
   * @author 小沙砾
   */
  public class Words implements Serializable {
      private Integer id;
      private String word;
      private Integer group_id;
  
      //从表实体应该有一个主表实体的对象引用
      private Groups groups;
  
      public Groups getGroups() {
          return groups;
      }
  
      public void setGroups(Groups groups) {
          this.groups = groups;
      }
  
      public Integer getGroup_id() {
          return group_id;
      }
  
      public void setGroup_id(Integer group_id) {
          this.group_id = group_id;
      }
  
      @Override
      public String toString() {
          return "Words{" +
                  "id=" + id +
                  ", word='" + word + '\'' +
                  ", group_id='" + group_id + '\'' +
                  '}';
      }
  
      public Integer getId() {
          return id;
      }
  
      public void setId(Integer id) {
          this.id = id;
      }
  
      public String getWord() {
          return word;
      }
  
      public void setWord(String word) {
          this.word = word;
      }
  
     

  • 这一步需要在子表指定映射配置文件封装一个Map集合

  xml version="1.0" encoding="UTF-8" ?>
  DOCTYPE mapper
          PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
          "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  
  <mapper namespace="com.dao.WordsDao">
      
      <resultMap id="wordsMap" type="com.domain.Words">
          
          <id property="id" column="id">id>
          
          <result property="word" column="word">result>
          <result property="group_id" column="group_id">result>
      resultMap>
  
      
      <resultMap id="wordsGroupsMap" type="com.domain.Words">
          
          
          <id property="id" column="id">id>
          
          <result property="word" column="word">result>
          <result property="group_id" column="group_id">result>
          
          <association property="groups" column="gid" javaType="com.domain.Groups">
              
              <id property="id" column="gid">id>
              <result property="name" column="gname">result>
              <result property="add_time" column="gadd_time">result>
          association>
      resultMap>
  
      
      <select id="findAll" resultType="com.domain.Words">
          select * from words;
      select>
  
      
      <select id="findAllWordsGroups" resultType="com.domain.WordsGroups">
          select w.*, g.id as gid, g.name as gname
          from words as w, groups as g
          where w.group_id = g.id
      select>
  
      
      <select id="findAllByMap" resultMap="wordsGroupsMap">
          select w.*, g.id as gid, g.name as gname, g.add_time as gadd_time
          from words as w, groups as g
          where w.group_id = g.id
      select>
  mapper>

  • 接口类、接口实现类、测试类方法像往常一样实现，但是在一对一的抽象方法或者是其重写方法的返回值必须是子表实体类类型

• mybatis中多表之间的一对多关系

  • 两个表的实体类可以像往常一样创建，但是在主表创建子表实体类对象的引用集合，以下显示主表实体类

  package com.domain;
  
  import java.io.Serializable;
  import java.util.List;
  
  public class Groups implements Serializable {
      private Integer id;
      private String name;
      private String add_time;
  
      //一对多关系映射，主表实体应该包含从表实体的集合引用
      private List words;
  
      public List getWords() {
          return words;
      }
  
      public void setWords(List words) {
          this.words = words;
      }
  
      @Override
      public String toString() {
          return "Groups{" +
                  "id=" + id +
                  ", name='" + name + '\'' +
                  ", add_time='" + add_time + '\'' +
                  '}';
      }
  
      public Integer getId() {
          return id;
      }
  
      public void setId(Integer id) {
          this.id = id;
      }
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public String getAdd_time() {
          return add_time;
      }
  
      public void setAdd_time(String add_time) {
          this.add_time = add_time;
      }
  }

  • 这一步需要在主表指定映射配置文件封装一个Map集合

  xml version="1.0" encoding="UTF-8" ?>
  DOCTYPE mapper
          PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
          "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
  
  <mapper namespace="com.dao.GroupsDao">
      
      <resultMap id="groupsMap" type="com.domain.Groups">
          
          <id property="id" column="id">id>
          
          <result property="name" column="name">result>
          <result property="add_time" column="add_time">result>
      resultMap>
  
      
      <resultMap id="groupsWordsMap" type="com.domain.Groups">
          <id property="id" column="gid">id>
          <result property="name" column="gname">result>
          <result property="add_time" column="gadd_time">result>
          
          <collection property="words" ofType="com.domain.Words">
              <id property="id" column="id">id>
              <result property="word" column="word">result>
              <result property="group_id" column="group_id">result>
          collection>
      resultMap>
  
      
      <select id="findGroupsInWords" resultMap="groupsWordsMap">
          select w.*, g.id as gid, g.name as gname, g.add_time as gadd_time
          from groups g left outer join words w
          on g.id = w.group_id;
      select>
  
  mapper>

   

  • 接口类、接口实现类、测试类方法像往常一样实现，但是在一对一的抽象方法或者是其重写方法的返回值必须是主表实体类类型