MyBatis使用总结

末蓝、 2023-07-06 06:28 13阅读 0赞

### 文章目录 ###

*   *  案例源码和sql文件
     *  MyBatis环境搭建和入门案例
     *   *   *  使用XML的方式
             *  使用注解的方式
     *  CRUD操作
     *   *   *  基本的CRUD操作
             *  传递pojo包装对象作为查询条件
             *  结果类型的封装
     *  sqlMapConfig.xml相关配置
     *   *   *  properties标签的resource、url属性用法
             *  typeAliases标签
             *  mappers标签
             *  sqlMapConfig.xml的最终配置
     *  MyBatis中的连接池
     *  MyBatis中的事务控制
     *  动态SQL
     *   *   *  if标签
             *  where标签
             *  foreach和sql标签
             *  抽取重复的sql语句
     *  MyBatis中的多表查询
     *   *   *  一对一
             *  一对多
             *  多对多
     *  MyBatis立即加载和延迟加载
     *  MyBatis缓存
     *   *   *  一级缓存
             *  二级缓存

## 案例源码和sql文件 ##

> 链接：https://pan.baidu.com/s/1JMiiW0sOFfzUXuNBgR-b4Q  
> 提取码：lpqb  
> mybatis-init文件中是CRUD操作章节的源码  
> mybatis-dynamicSql文件中是动态SQL章节的源码  
> mybatis-noe2many文件中是MyBatis中的多表查询一对一和一对多章节的源码

## MyBatis环境搭建和入门案例 ##

#### 使用XML的方式 ####

导入jar包坐标：

<dependency>
        <groupId>org.mybatis</groupId>
        <artifactId>mybatis</artifactId>
        <version>3.4.5</version>
    </dependency>
    
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.6</version>
    </dependency>

sqlMapConfig.xml配置文件：

<?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>
        <environments default="mysql">
            
            <environment id="mysql">
                
                <transactionManager type="JDBC"></transactionManager>
                <dataSource type="POOLED">
                    <property name="driver" value="com.mysql.jdbc.Driver"/>
                    <property name="url" value="jdbc:mysql://localhost:3306/mybatis"/>
                    <property name="username" value="root"/>
                    <property name="password" value="13456"/>
                </dataSource>
            </environment>
        </environments>
    
        
        <mappers>
            <mapper resource="cn/example/dao/IUserDao.xml"></mapper>
        </mappers>
    </configuration>

User :

public class User implements Serializable { 
        private Integer id;
        private String username;
        private Date birthday;
        private String sex;
        private String address;
        //getter和setter……
    }

IUserDao：

public interface IUserDao { 
        List<User> findAll();
    }

IUserDao.xml：

测试：

public class MyBatisTest { 
        public static void main(String[] args) throws IOException { 
            //1. 读取配置文件
            InputStream inputStream = Resources.getResourceAsStream("sqlMapConfig.xml");
            //2. 创建SqlSessionFactory工厂
            SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
            SqlSessionFactory factory = builder.build(inputStream);
            //3. 使用工厂生产SqlSession对象
            SqlSession  sqlSession = factory.openSession();
            //4. 使用SqlSession对象创建Dao接口的代理对象
            IUserDao userDao = sqlSession.getMapper(IUserDao.class);
            //5. 通过代理对象执行方法
            List<User> userList = userDao.findAll();
            userList.stream().forEach(System.out::println);
            //6. 释放资源
            sqlSession.close();
            inputStream.close();
        }
    }

#### 使用注解的方式 ####

使用注解的方式只需做如下两点修改  
IUserDao ：

public interface IUserDao { 
        @Select("select * from user")
        List<User> findAll();
    }

sqlMapConfig.xml配置文件：  
只需将resource属性改为class属性指定dao接口所在包位置

## CRUD操作 ##

#### 基本的CRUD操作 ####

IUserDao 接口：

public interface IUserDao { 
        //查询所有用户
        List<User> findAll();
    
        //保存用户
        void saveUser(User user);
    
        //更新
        void updateUser(User user);
    
        //根据id删除
        void deleteUser(Integer id);
    
        //根据id查找
        User findOneByid(Integer id);
    
        //根据姓名模糊查询
        List<User> findByName(String name);
    
        //查询总记录数
        Integer findTotal();
    }

IUserDao.xml文件：

<?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="cn.example.dao.IUserDao">
        <select id="findAll" resultType="cn.example.domain.User">
            select * from user
        </select>
    
        <insert id="saveUser" parameterType="cn.example.domain.User">
            
            <selectKey keyProperty="id" keyColumn="id" resultType="Integer" order="AFTER">
                select last_insert_id();
            </selectKey>
            insert into user(username, birthday, sex, address) values(#{username}, #{birthday}, #{sex}, #{address})
        </insert>
    
        <update id="updateUser" parameterType="cn.example.domain.User">
            update user set username=#{username}, birthday=#{birthday}, sex=#{sex}, address=#{address} where id = #{id}
        </update>
    
        
        <delete id="deleteUser" parameterType="java.lang.Integer">
            delete from user where id = #{id}
        </delete>
    
        <select id="findOneByid" parameterType="java.lang.Integer" resultType="cn.example.domain.User">
            select * from user where id = #{id}
        </select>
    
        <select id="findByName" parameterType="String" resultType="cn.example.domain.User">
            
            
            select * from user where username like #{name}
            
            select * from user where username like #{name}"%"
        </select>
    
        <select id="findTotal" resultType="Integer">
            select count(*) from user
        </select>
    </mapper>

#### 传递pojo包装对象作为查询条件 ####

MyBatis使用`OGNL`表达式解析对象字段的值，\#\{\}或者$\{\}括号中的值为pojo属性名称

> OGNL表达式全称Object Graphic Navigation Language，对象图导航语言，它是通过对象的取值方法来获取数据，在写法上省略了getXXX()。比如User中提供了getUsername()方法获取username属性值，使用OGNL表达式写法就是user.username获取属性值。  
> 而在MyBatis中，直接写username，而不是user.username，因为在parameterType属性中已经提供了属性所属的类，所以此时不需要写对象名称，如`<insert id="saveUser" parameterType="cn.example.domain.User"> insert into user(username, birthday, sex, address) values(#{username}, #{birthday}, #{sex}, #{address}) </insert>`

IUserDao接口中增加方法：

//根据QueryVo查询用户
    List<User> findUserByVo(QueryVo queryVo);

QueryVo：

public class QueryVo { 
        private User user;
    
        public User getUser() { 
            return user;
        }
    
        public void setUser(User user) { 
            this.user = user;
        }
    }

IUserDao.xml中增加mapper配置：

<select id="findUserByVo" parameterType="cn.example.domain.QueryVo" resultType="cn.example.domain.User">
        select * from user where username like #{user.username}
    </select>

#### 结果类型的封装 ####

OGNL表达式能够根据传递过来的User对象，将user.username替换到\#\{username\}上的前提是User对象的username属性和\#\{username\}中的名称相同，如果将User对象中的username属性改为`name`，那么就需要在sql语句中写成`#{name}`，但是对于返回值类型，因为数据库中的字段还是`username`，这还能将`name`值封装到User对象的`username`属性中吗？答案是不行。

> 在Windows系统上，MySQL数据库不区分大小写，即username和userName是同一个字段，因此User对象中的属性是userName，数据库中的字段可以是username，当从数据库查询到结果的时候，username字段和userName属性能够匹配上从而封装到User对象中。

解决数据库字段和对于的实体属性名称不同的办法有两种：

1.  写sql的时候给结果字段起别名，即`select user as username ...`  
    执行效率高
2.  MyBatis提供的配置项`resultMap`  
    开发效率高

**使用resultMap**

修改User类：

public class User implements Serializable { 
        private Integer userId;
        private String userName;
        private Date userBirthday;
        private String userSex;
        private String userAddress;
        //getter和setter方法省略... 
    }

IUserDao.xml：

<resultMap id="userMap" type="cn.example.domain.User">
        
        <id property="userId" column="id"></id>
        
        <result property="userName" column="username"></result>
        <result property="userBirthday" column="birthday"></result>
        <result property="userSex" column="sex"></result>
        <result property="userAddress" column="address"></result>
    </resultMap>
    
    <select id="findAll" resultMap="userMap">
        select * from user
    </select>
    
    <insert id="saveUser" parameterType="cn.example.domain.User">
        
        <selectKey keyProperty="userId" keyColumn="id" resultType="Integer" order="AFTER">
            select last_insert_id();
        </selectKey>
        insert into user(username, birthday, sex, address) values(#{userName}, #{userBirthday}, #{userSex}, #{userAddress})
    </insert>

## sqlMapConfig.xml相关配置 ##

#### properties标签的resource、url属性用法 ####

使用properties标签的resource属性和url属性可以指定数据库的配置文件  
resources路径下 jdbcConfig.properties：

jdbc.driver=com.mysql.jdbc.Driver
    jdbc.url=jdbc:mysql://localhost:3306/eesy_mybatis
    jdbc.username=root
    jdbc.password=123456

sqlMapConfig.xml：

<?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>
                    <property name="url" value="${jdbc.url}"></property>
                    <property name="username" value="${jdbc.username}"></property>
                    <property name="password" value="${jdbc.password}"></property>
                </dataSource>
            </environment>
        </environments>
        
    	
        <mappers>
            <mapper resource="cn/example/dao/IUserDao.xml"></mapper>
        </mappers>
    </configuration>

#### typeAliases标签 ####

使用typeAliases可以给实体类起别名

在IUserDao.xml中指定parameterType的时候使用user即可，无需指定全限定类名

<update id="updateUser" parameterType="user">
        update user set username=#{username}, birthday=#{birthday}, sex=#{sex}, address=#{address} where id = #{id}
    </update>

#### mappers标签 ####

<mappers>
        <mapper resource="cn/example/dao/IUserDao.xml"></mapper>
    </mappers>

<mappers>
        <mapper class="cn.example.dao.IUserDao"></mapper>
    </mappers>

<mappers>
        <package name="cn.example.dao"></package >
    </mappers>

#### sqlMapConfig.xml的最终配置 ####

<?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>
        <typeAliases>
            <package name="cn.example.domain"></package>
        </typeAliases>
        <environments default="mysql">
            
            <environment id="mysql">
                
                <transactionManager type="JDBC"></transactionManager>
                <dataSource type="POOLED">
                    <property name="driver" value="${jdbc.driver}"></property>
                    <property name="url" value="${jdbc.url}"></property>
                    <property name="username" value="${jdbc.username}"></property>
                    <property name="password" value="${jdbc.password}"></property>
                </dataSource>
            </environment>
        </environments>
    
        
        <mappers>
            <package name="cn.example.dao"></package >
        </mappers>
    </configuration>

## MyBatis中的连接池 ##

dataSource的type属性指定了连接池类型，可以取值：

*  POOLED  
    采用传统的`javax.sql.DataSource`规范中的连接池，mybatis中针对规范的实现实现了一套自己的连接池技术
 *  UNPOOLED  
    采用传统的获取连接的方式，虽然也实现了`javax.sql.DataSource`接口，但是并没有采用池的概念，即每次需要连接的时候建立连接，用完释放连接，而不是归还到池中
 *  JNDI  
    采用服务器提供的JNDI技术实现，来获取`DataSource`对象，不同的服务器所能拿到的`DataSource`不同，tomcat服务器采用的是dbcp连接池。如果不是web或者maven的war工程，不能使用JNDI

## MyBatis中的事务控制 ##

在`openSession()`方法中传入参数`true`，可以设置事务提交方式为手动提交，不传参数则为自动提交

//1. 读取配置文件
     InputStream inputStream = Resources.getResourceAsStream("sqlMapConfig.xml");
     //2. 创建SqlSessionFactory工厂
     SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
     SqlSessionFactory factory = builder.build(inputStream);
     //3. 使用工厂生产SqlSession对象
     SqlSession  sqlSession = factory.openSession(true);
     //4. 使用SqlSession对象创建Dao接口的代理对象...
     //5. 通过代理对象执行方法...
     //6. 释放资源...

## 动态SQL ##

User：

QueryVo ：

public class QueryVo { 
        private User user;
    	//getter和setter方法省略
    }

IUserDao：

public interface IUserDao { 
    
    }

IUserDao.xml：

<?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="cn.example.dao.IUserDao">
        
        <resultMap id="userMap" type="user">
            
            <id property="userId" column="id"></id>
            
            <result property="userName" column="username"></result>
            <result property="userBirthday" column="birthday"></result>
            <result property="userSex" column="sex"></result>
            <result property="userAddress" column="address"></result>
        </resultMap>
        
    </mapper>

#### if标签 ####

IUserDao接口中增加方法：

//根据传入的条件查询
    List<User> findUserByCondition(User user);

IUserDao.xml中增加配置：

<select id="findUserByCondition" parameterType="user" resultMap="userMap">
        select * from user where 1=1
        <if test="userName != null">
            and username = #{userName}
        </if>
    	<if test="userSex != null">
    		and usersex = #{userSex}
    	</if>
    </select>

#### where标签 ####

<select id="findUserByCondition" parameterType="user" resultMap="userMap">
        select * from user
        <where>
            <if test="userName != null">
                and username = #{userName}
            </if>
            <if test="userSex != null">
                and usersex = #{userSex}
            </if>
        </where>
    </select>

#### foreach和sql标签 ####

`select * from user where id in(1,2);`

QueryVo中增加属性并生成getter和setter方法：

private List<Integer> ids;

IUserDao接口中增加方法：

//根据QueryVO中提供的ids集合查询用户
    List<User> findUserInIds(QueryVo queryVo);

IUserDao.xml中增加配置：

<select id="findUserInIds" parameterType="queryVo" resultMap="userMap">
        select * from user
        <where>
            <if test="ids != null and ids.size()>0">
            	
                <foreach collection="ids" open="and id in(" close=")" item="uid" separator=",">
                    #{uid}
                </foreach>
            </if>
        </where>
    </select>

#### 抽取重复的sql语句 ####

<select id="findAll" resultMap="userMap">
        select * from user
    </select>

可以改写为如下，以后用到`select * from user`的地方都可以用`<include refid="defaultUser"></include>`代替：

<sql id="defaultUser">
       select * from user
    </sql>

## MyBatis中的多表查询 ##

User：

Account ：

public class Account implements Serializable { 
        private Integer id;
        private Integer uid;
        private Double money;
        //getter和setter、toString方法省略
    }

IUserDao ：

public interface IUserDao { 
        //查询所有用户以及用户下所有的账户信息（一对多）
        List<User> findAll();
    }

IAccountDao：

public interface IAccountDao { 
    	//查询所有账户以及账户对应的用户（一对一）
        List<Account> findAll();
    }

#### 一对一 ####

> 关键标签：`association`

Account类中增加属性，并设置getter和setter方法：

private User user;

IAccountDao.xml：

<?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="cn.example.dao.IAccountDao">
    
        
        <resultMap id="accountUserMap" type="account">
            <id property="id" column="aid"></id>
            <result property="uid" column="uid"></result>
            <result property="money" column="money"></result>
            
            <association property="user" column="uid" javaType="user">
                <id property="id" column="id"></id>
                <result column="username" property="username"></result>
                <result column="address" property="address"></result>
                <result column="sex" property="sex"></result>
                <result column="birthday" property="birthday"></result>
            </association>
        </resultMap>
    
        
        <select id="findAll" resultMap="accountUserMap">
            select u.*,a.id as aid,a.uid,a.money from account a , user u where u.id = a.uid;
        </select>
    </mapper>

#### 一对多 ####

> 关键标签：`collection`

User类添加属性：

private List<Account> accounts;

<?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="cn.example.dao.IUserDao">
    
        
        <resultMap id="userAccountMap" type="user">
            <id property="id" column="id"></id>
            <result column="username" property="username"></result>
            <result column="address" property="address"></result>
            <result column="sex" property="sex"></result>
            <result column="birthday" property="birthday"></result>
            
            <collection property="accounts" ofType="account">
                <id property="id" column="aid"></id>
                <result property="uid" column="uid"></result>
                <result property="money" column="money"></result>
            </collection>
        </resultMap>
    
        <select id="findAll" resultMap="userAccountMap">
            select * from user u left join account a on u.id=a.uid
        </select>
    </mapper>

#### 多对多 ####

多对多可以看成是一对多，在表结构上是多对多的关系，比如用户和角色，一个用户可以有多个角色，一个角色可以有多个用户，但是在sql层面，它们就是一对多的关系，一个用户可以有多个角色。因此写法和一对多的类似，只是slq语句上有变化。

## MyBatis立即加载和延迟加载 ##

[《MyBatis立即加载和延迟加载》][MyBatis]

## MyBatis缓存 ##

MyBatis使用数据缓存减少和数据库的交互次数，从而提高程序执行效率

适用于缓存的情况：

*  经常查询并且不经常改变的数据
 *  能容忍缓存和数据库数据的不一致

#### 一级缓存 ####

一级缓存指的是MyBatis中SqlSession对象的缓存，当我们执行查询之后，查询的结果会同时存入到SqlSession提供的一块区域中，该区域的结构是一个Map。当我们再次查询同样的数据时，MyBatis会先去SqlSession查询是否有该数据，如果有则直接拿来用。当SqlSession对象消失时，MyBatis的一级缓存消失。

public void testFindOneByid() { 
        User user1 = userDao.findOneByid(41);
        User user2 = userDao.findOneByid(41);
        System.out.println(user1 == user2); //true
    }

执行了一次sql：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lUXzEw_size_16_color_FFFFFF_t_70]

public void testFindOneByid() { 
        User user1 = userDao.findOneByid(41);
        //关闭SqlSession，缓存清空
        sqlSession.close();
        sqlSession = factory.openSession();
        userDao = sqlSession.getMapper(IUserDao.class);
        User user2 = userDao.findOneByid(41);
        System.out.println(user1 == user2); //false
    }

执行了两次sql：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lUXzEw_size_16_color_FFFFFF_t_70 1]  
一级缓存清空时机：  
一级缓存是SqlSession范围的缓存，当调用SqlSession的修改，添加，删除，commit()，close()等方法时，就会清空一级缓存。因此查询-修改-查询，第二次查询走的是查数据库而不是查缓存。

#### 二级缓存 ####

二级缓存指的是MyBatis中SqlSessionFactory对象的缓存，由同一个SqlSessionFactory对象创建的SqlSession共享同一个缓存。  
使用二级缓存：  
sqlMapConfig.xml中添加配置：

IUserDao.xml中开启支持二级缓存：

<mapper namespace="cn.example.dao.IUserDao">
        
        <cache/>
        <select id="findOneByid" parameterType="java.lang.Integer"  resultType="user" useCache="true">
            select * from user where id = #{ id}
        </select>
    </mapper>

使用：

public class SecondLevelCacheTest { 
    
        private InputStream in;
        private  SqlSessionFactory factory;
    
        @Before//用于在测试方法执行之前执行
        public void init()throws Exception{ 
            //1.读取配置文件，生成字节输入流
            in = Resources.getResourceAsStream("SqlMapConfig.xml");
            //2.获取SqlSessionFactory
            factory = new SqlSessionFactoryBuilder().build(in);
    
        }
    
        @After//用于在测试方法执行之后执行
        public void destroy()throws Exception{ 
            in.close();
        }
    
        @Test
        public void testFirstLevelCache(){ 
            SqlSession sqlSession1 = factory.openSession();
            IUserDao dao1 = sqlSession1.getMapper(IUserDao.class);
            User user1 = dao1.findOneByid(41);
            System.out.println(user1);
            sqlSession1.close();
    
            SqlSession sqlSession2 = factory.openSession();
            IUserDao dao2 = sqlSession2.getMapper(IUserDao.class);
            User user2 = dao2.findOneByid(41);
            System.out.println(user2);
            sqlSession2.close();
    
            System.out.println(user1 == user2); //false
        }
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lUXzEw_size_16_color_FFFFFF_t_70 2]  
user1和user2值不相等，但是第二次查询的确查的是缓存，这是为什么？因为MyBatis中的二级缓存保存的是数据而不是地址，当程序缓存中有的内存时，将该内容复制一份给新的变量，因此user1和user2的地址值不同。

[MyBatis]: https://blog.csdn.net/IT_10/article/details/103785394
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lUXzEw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/202002172307502.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lUXzEw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lUXzEw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200217230630641.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lUXzEw,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lUXzEw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200217235628653.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0lUXzEw,size_16,color_FFFFFF,t_70