开发: C++知识库 Java知识库 JavaScript Python PHP知识库人工智能区块链大数据移动开发嵌入式开发工具数据结构与算法开发测试游戏开发网络协议系统运维
教程: HTML教程 CSS教程 JavaScript教程 Go语言教程 JQuery教程 VUE教程 VUE3教程 Bootstrap教程 SQL数据库教程 C语言教程 C++教程 Java教程 Python教程 Python3教程 C#教程
数码: 电脑笔记本显卡显示器固态硬盘硬盘耳机手机 iphone vivo oppo 小米华为单反装机图拉丁

-> Java知识库 -> 关于MyBatis的一些总结 -> 正文阅读

[Java知识库]关于MyBatis的一些总结

概述

MyBbatis它是一款半自动的ORM持久层框架，具有较高的SQL灵活性，支持高级映射(一对一，一对多)，动态SQL，延迟加载和缓存等特性，但它的数据库无关性较低。

ORM是什么？

Object Relation Mapping，对象关系映射。对象指的是Java对象，关系指的是数据库中的关系模型，对象关系映射，指的就是在Java对象和数据库的关系模型之间建立一种对应关系，比如用一个Java的User类，去对应数据库中的一张user表，类中的属性和表中的列一一对应。

mybatis为什么是半自动的ORM框架？

以为使用mybatis开发的时候，需要手写sql语句，而其他全自动的ORM框架，则不需要手写sql语句。更因为mybatis需要手写sql语句，拥有更好的灵活性。与传统的JDBC相比，mybatis提供了输入和输出映射，可以很方便地进行SQL设置，以及结果集的封装。并且还提供了关联查询和动态SQL等功能，极大地提升了开发的效率。

快速开发

步骤

编写全局配置文件
编写mapper映射文件
加载全局配置文件，生成SqlSessionFactory
创建SqlSession，调用mapper映射文件中的SQL语句来执行CRUD操作

具体操作

1. 在IDEA中新建一个maven的项目

2. 在项目的porn.xml配置中导入相关依赖，例：

<dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>5.1.46</version>
        </dependency>
        <dependency>
          <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.4.1</version>
        </dependency>
        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <!--log4j-->
            <dependency>
                <groupId>log4j</groupId>
                <artifactId>log4j</artifactId>
                <version>1.2.12</version>
            </dependency>
            <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.22</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>RELEASE</version>
            <scope>compile</scope>
        </dependency>
    </dependencies>

3. 创建mybatis-config.xml全局配置文件

<?xml version="1.0" encoding="UTF8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <properties resource="db.properties"/>
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <!--绑定接口-->
    <mappers>
    <!-- <mapper resource="com/weirdo/dao/AuthorMapper.xml"/>-->
      <mapper class="com.weirdo.dao.AuthorMapper"/>
    </mappers>
</configuration>

4. 配置数据库连接文件db.properties

driver = com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=false&userUnicode=true&acharacterEncoding=UTF-8
username=root
password=root

5. 编写Utils工具类

public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;
    static {
        try {
            //使用mybatis获取sqlsessionfactory对象
            String resource = "mybatis-config.xml";
            InputStream inputStream = Resources.getResourceAsStream(resource);
            sqlSessionFactory  = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
public static SqlSession getSqlSession() {
    return sqlSessionFactory.openSession(true);//此处true可以自动提交事务
}

}

7. 创建实体类

public class User {
    private int id;
    private String name;
    private String pwd;
}

8. 编写mapper映射文件（Mapper.xml）

<?xml version="1.0" encoding="UTF8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace=绑定一个对应的Dao/Mapper-->
              <!--此处必须是.不能是/-->
<mapper namespace="com.dao.UserMapper">
    <!--模糊查询-->
    <select id="getUserLike" resultType="com.pojo.User">
        select * from mybatis.user where name like #{value}
    </select>
    <!--查询语句-->
    <select id="getUserList" resultType="com.pojo.User">
        select * from mybatis.user
    </select>
    <select id="getUserById" parameterType="int" resultType="com.pojo.User">
        select * from mybatis.user where id = #{id}
    </select>
    <insert id="addUser" parameterType="com.pojo.User">
        insert  into mybatis.user (id,name,pwd) value (#{id},#{name},#{pwd})
    </insert>
    <update id="updateUser" parameterType="com.pojo.User">
        update mybatis.user set name=#{name},pwd=#{pwd} where id =#{id}
    </update>
    <delete id="deleteUser" parameterType="int">
        delete from mybatis.user where id=#{id}
    </delete>
</mapper>

9. 编写测试类

public class UserDaoTest {
//模糊查询
    @Test
    public void getUserLike(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = mapper.getUserLike("%李%");
        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }
    //查询全部用户
    @Test
    public void test(){
        //第一步，获得sqlsession对象
        SqlSession sqlSession= MybatisUtils.getSqlSession();
        //执行sql 方式一 getMapper
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = mapper.getUserList();
        //方式二
        //List<User> userList=sqlSession.selectList("com.dao.UserDao.getUserList");
        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }
    //根据id查询用户
    @Test
    public void getUserById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.getUserById(1);
        System.out.println(user);
        sqlSession.close();
    }
    //增删改需要提交事务
    @Test
    public void addUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int res = mapper.addUser(new User(9, "小李", "1233"));
        if(res>0){
            System.out.println("插入成功");
        }
        sqlSession.commit();//提交事务很重要
        sqlSession.close();
    }
    @Test
    public void updateUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.updateUser(new User(2,"小王","1115"));
       sqlSession.commit();
        sqlSession.close();
    }
    @Test
    public void deleteUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.deleteUser(5);
         sqlSession.commit()
        sqlSession.close();
    }
}

一些注意问题（和解决方法）

在项目中导入相关依赖后，仍然报错，则需要刷新maven仓库中的项目依赖
全局配置文件中的标签是有顺序的

<configuration>
	<!-- 配置顺序如下
     properties  

     settings

     typeAliases

     typeHandlers

     objectFactory

     plugins

     environments
        environment
            transactionManager
            dataSource
            
     mappers
     -->
</configuration>

mappers标签引入映射器的俩种方式（常用）

<!--通过resource属性引入classpath路径的相对资源-->
<mappers>
  <mapper resource="com/weirdo/dao/AuthorMapper.xml"/>
</mappers>

<!--通过class属性指定mapper接口名称，此时对应的映射文件必须与接口位于同一路径下，并且名称相同-->
<mappers>
  <mapper class="com.weirdo.dao.AuthorMapper"/>
</mappers>

mapper.xml中增删改需要提交事务，在测试类中添加

sqlSession.commit();

也可以在工具类中设置（默认为flase，改为true即为自动提交）

public static SqlSession getSqlSession() {
        return sqlSessionFactory.openSession(true);//此处true可以自动提交事务
    }

mapper.xml的SQL语句中的占位符 ${ } 和 #{ }

一般会采用#{}，#{}输入参数的占位符，相当于jdbc的？，防注入，自动添加了‘ ’ 引号！
而${}，一般会用在模糊查询的情景，比如

SELECT * FROM student WHERE name like '%${name}%';

关于resultType和parameterType区别

resultType：返回值类型，类型即为对象类型，返回结果字段与对象属性匹配映射，类型中的属性名要与查询条件保持一致，否则就会失败。
parameterType：接收参数类型，同为对象类型，单字段例如String类型可以使用全包名或者单名称。

基于XML代理开发

全局配置文件和mapper.xml文件是最基本的配置，在完成基本配置后，我们可以不需要创建dao类，而可以直接创建一个mapper接口，进行处理。

创建接口

public interface UserMapper {
    //查询全部用户
    List<User> getUserList();
    //根据id查询用户
    User getUserById(int id);
    //添加用户
    int addUser(User user);
    //修改用户
    int updateUser(User user);
    //删除用户
    int deleteUser(int id);
}

创建mapper.xml

<?xml version="1.0" encoding="UTF8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--namespace=绑定一个对应的Dao/Mapper-->
<!--此处必须是.不能是/-->
<mapper namespace="com.dao.UserMapper">
    <!--查询语句-->
    <select id="getUserList" resultType="User">
        select * from mybatis.user
    </select>
    <select id="getUserById" parameterType="int" resultType="com.pojo.User">
        select * from mybatis.user where id = #{id}
    </select>
    <insert id="addUser" parameterType="com.pojo.User">
        insert  into mybatis.user (id,name,pwd) value (#{id},#{name},#{pwd})
    </insert>
    <update id="updateUser" parameterType="com.pojo.User">
        update mybatis.user set name=#{name},pwd=#{pwd} where id =#{id}
    </update>
    <delete id="deleteUser" parameterType="int">
        delete from mybatis.user where id=#{id}
    </delete>
</mapper>

测试类

public class UserDaoTest { 
    @Test
    public void test(){
        SqlSession sqlSession= MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        List<User> userList = mapper.getUserList();
        //方式二 List<User> userList=sqlSession.selectList("com.dao.UserDao.getUserList");
        for (User user : userList) {
            System.out.println(user);
        }
        sqlSession.close();
    }
    @Test
    public void getUserById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.getUserById(1);
        System.out.println(user);
        sqlSession.close();
    }
    //增删改需要提交事务
    @Test
    public void addUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int res = mapper.addUser(new User(9, "小李", "1233"));
        if(res>0){
            System.out.println("插入成功");
        }
        sqlSession.commit();
        sqlSession.close();
    }
    @Test
    public void updateUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.updateUser(new User(2,"小王","1115"));
        sqlSession.commit();
        sqlSession.close();
    }
    @Test
    public void deleteUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.deleteUser(5);
        sqlSession.commit();
        sqlSession.close();
    }
}

基于xml代理开发的注意事项

mapper接口和mapper.xml之间需要遵循一定规则，才能成功的让mybatis将mapper接口和mapper.xml绑定起来

mapper接口的全限定名，要和mapper.xml的namespace属性一致
mapper接口中的方法名要和mapper.xml中的SQL标签的id一致
mapper接口中的方法入参类型，要和mapper.xml中SQL语句的入参类型一致
mapper接口中的方法出参类型，要和mapper.xml中SQL语句的返回值类型一致

基于注解代理开发

如果对xml配置文件感到麻烦，则可以考虑使用注解的开发方式，不过注解的开发方式，会将SQL语句写到代码文件中，后续的维护性和扩展性不是很好（如果想修改SQL语句，就得改代码，得重新打包部署，而如果用xml方式，则只需要修改xml，用新的xml取替换旧的xml即可）。

使用注解的开发方式，也还是得有一个全局配置的xml文件，不过mapper.xml就可以省掉了，具体操作只用2步，如下

创建一个mapper接口

public interface UserMapper {
   @Select("select * from user")
   List<User> getUsers();
   //方法存在多个参数，所有参数前面必须加上@Param("id")注解
   @Select("select * from user where id = #{id}")
   User getUserById(@Param("id") int id);
   @Insert("insert into user(id,name,pwd) values (#{id},#{name},#{password})")
   int addUser(User user);
   @Update("update user set name=#{name},pwd=#{password} where id = #{id}")
   int updateUser(User user);
   @Delete("delete from user where id=#{id} ")
   int deleteUser(@Param("id") int id);
}

在全局配置文件中修改mappers标签，指定到mapper接口处

    <mappers>
        <mapper class="com.weirdo.dao.UserMapper"/>
    </mappers>

测试类

public class UserMapperTest {
    @Test
    public void test(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        //底层主要应用反射
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
//        List<User> users = mapper.getUsers();
//        for (User user : users) {
//            System.out.println(user);
//        }

//        User userById = mapper.getUserById(1);
//        System.out.println(userById);

//        mapper.addUser(new User(10,"张德胜","123432"));

//        mapper.updateUser(new User(6,"李佳怡","0988"));

        mapper.deleteUser(5);
        sqlSession.close();
    }
}

基于注解代理开发的注意事项

当使用注解开发时，若需要传入多个参数，可以结合@Param注解
@Param标签会被mybatis处理并封装成一个Map对象，比如上面的示例中，实际传入的参数是一个Map对象，@Param标签帮忙向Map中设置了值
在文章的上面，介绍了俩种mappers标签映入映射器的方式，在此处做一个细致的探讨补充

<!--在mapper接口中使用注解开发-->
<mappers>
  <mapper resource="com/weirdo/dao/AuthorMapper.xml"/>
</mappers>
<!-- 普通加载xml -->
<mappers>
  <mapper class="com.weirdo.dao.AuthorMapper"/>
</mappers>

而在实际工作中，一般我们会将一张表的SQL操作封装在一个mapper.xml中，可能有许多张表需要操作，那么我们是不是要在<mappers>标签下写多个<mapper>标签呢？其实不用，还有第三种加载mapper的方法，使用<package> 标签

<mappers>
    <package name="com.weirdo.mapper"/>
</mappers>

这样就会自动加载com.weirdo.mapper包下的所有mapper，这种方式需要将mapper接口文件和mapper.xml文件都放在com.weirdo.mapper包下，且接口文件和xml文件的文件名要一致。

关于target工程目录下需要添加以下配置

<build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>

mappers标签里映射的时候会出现找不到mapper的情况。这是因为src/main/java源码目录下的文件，maven打包时只会将该目录下的java文件打包，而其他类型的文件都不会被打包进去。需要在porn.xml的添加相关配置才可以。

动态SQL

可以根据具体的参数条件，来对SQL语句进行动态拼接。

比如在开发中，由于不确定查询参数是否存在，会使用类似于where 1 = 1来作为前缀，然后后面用AND 拼接要查询的参数，这样，就算要查询的参数为空，也能够正确执行查询，如果不加1 = 1，则如果查询参数为空，SQL语句就会变成SELECT * FROM student where，SQL不合法。

mybatis里的动态标签主要有

if

<select id="queryBlogIF" parameterType="map" resultType="blog">
       select * from mybatis.blog where 1=1
        <if test="title != null">
            and title = #{title}
        </if>
        <if test="author != null">
            and author=#{author}
        </if>
    </select>

choose,when,oherwise

<!-- choose 和 when , otherwise 是配套标签 
类似于java中的switch，只会选中满足条件的一个
-->
 <select id="queryBlogChoose" parameterType="map" resultType="blog">
        select * from mybatis.blog
        <where>
           <choose>
               <when test="title != null">
                   title = #{title}
               </when>
               <when test="author != null">
                  and author = #{author}
               </when>
               <otherwise>
                   and views=#{views}
               </otherwise>
           </choose>
        </where>
    </select>

trim、where、set

<update id="updateBlog" parameterType="map">
    update mybatis.blog
    <set>
        <if test="title != null">
            title = #{title},
        </if>
        <if test="author != null">
            author = #{author}
        </if>
    </set>
    where id = #{id}
</update>

SQL片段

有些时候可以用sql便签抽取公共部分，在使用的地方使用include标签

要注意：

最好是单表
sql里不要有where标签

<sql id="if-title-author">
    <if test="title != null">
        title = #{title}
    </if>
    <if test="author != null">
        and author = #{author}
    </if>
</sql>
<select id="queryBlogIF" parameterType="map" resultType="Blog">
    select * from mybatis.blog
    <where>
        <include refid="if-title-author"></include>
    </where>
</select>

foreach

<!--ids是传的，#{id}是遍历的-->
<select id="queryBlogForeach" parameterType="map" resultType="Blog">
    select * from mybatis.blog
    <where>
        <foreach collection="ids" item="id" open="and ("
                 close=")" separator="or">
            id=#{id}
        </foreach>
    </where>
</select>

测试类

@Test
public void queryBlogForeach(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    BlogMapper blogMapper = sqlSession.getMapper(BlogMapper.class);
    Map map = new HashMap();

    ArrayList<Integer> ids = new ArrayList<Integer>();
    ids.add(1);
    ids.add(3);
    map.put("ids",ids);

    List<Blog> list = blogMapper.queryBlogForeach(map);

    for (Blog blog : list) {
        System.out.println(blog);
    }

    sqlSession.close();
}

关于缓存

一级缓存

默认开启状态，同一个SqlSession级别共享的缓存，在一个SqlSession的生命周期内，执行俩次SQL查询，当然第二次查询会直接查询缓存，而不是数据库。
但如果，第一次和第二次相同的SQL查询之间，执行了INSERT/UPDATE/DELETE这种DML操作，一级缓存会被清空，第二次会查询数据库

缓存失效

同一个SqlSession下执行增删改操作，不用提交，会清空一级缓存
SqlSession提交或关闭的时候，会清除一级缓存
在全局配置文件中设置<setting name="localCacheScope" value="STATEMENT"/> 这样会使一级缓存失效，二级缓存并不受影响
对mapper.xml中的某个CRUD标签，设置属性flushCache=true，这样会导致该MappedStatement的一级缓存，二级缓存都失效（一个CRUD标签在mybatis中会被封装成一个MappedStatement

二级缓存

二级缓存是基于namespace和mapper的作用域起作用的，不是依赖于SQL session，默认关闭，在mybatis-config.xml文件中的标签配置开启缓存<settings name="cacheEnabled" value="true"/>开启二级缓存总开关，然后在某个具体的mapper.xml中增加<cache />，即开启了该mapper.xml的二级缓存。二级缓存是mapper级别的缓存，粒度比一级缓存大，多个SqlSession可以共享同一个mapper的二级缓存。注意开启二级缓存后，SqlSession需要提交，查询的数据才会被刷新到二级缓存当中