【Mybatis】Mybatis 学习笔记

最新推荐文章于 2023-04-08 16:33:44 发布

AldarLin

最新推荐文章于 2023-04-08 16:33:44 发布

阅读量388

点赞数

分类专栏：数据库文章标签： mybatis

本文链接：https://blog.csdn.net/qq_34416331/article/details/105573572

版权

数据库专栏收录该内容

13 篇文章 0 订阅

订阅专栏

1.5 MyBatis 和 Hibernate 对比

2.4 配置类型别名，减少不断写类路径的麻烦

三、MyBatis 连接池和事务

3.1 MyBatis 连接池提供的三种方式：

3.2 MyBatis 事务

3.3 MyBatis 一对一关系和多对多关系

一、MyBatis 基本知识

1.1 什么是 MyBatis

MyBatis 是一个基于 java 的持久层框架，它内部封装了 jdbc，使开发者只需要关注 sql 语句本身，而不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程
MyBatis 通过 xml 或者注解的方式将要执行的各种 statement 配置起来，并通过 java 对象和 statement 中 sql 的动态参数进行映射生成最终执行的 sql 语句，最后由 MyBatis 框架执行 sql 并将结果映射为 java 对象并返回
采用了 ORM 思想解决了实体和数据库的映射关系，对 jdbc 做了封装，屏蔽了 jdbc api 底层访问细节，使我们不用跟 jdbc api 打交道，就可以完成对数据库的持久化操作

1.2 MyBatis 的优点

耦合性低：不会对应用程序或数据库的现有设计造成任何影响，可以选择将 SQL 写在 XML 中或是程序代码中，实现统一管理。提供 XML 标签，支持编写动态 SQL 语句，并可重用
专注于sql：与传统的 jdbc 框架相比，消除了 JDBC 的大量冗余代码，使开发人员专注于 sql 语句的编写，而不用将精力花在 jdbc api的使用好管理上。
兼容性好：由于 MyBatis 使用 JDBC 来连接数据库，所以只要 JDBC 支持的数据库 MyBatis 都支持
集成：能与 Spring 很好的集成

1.3 MyBatis 的缺点

SQL 编写工作量较大，尤其当字段多、关联表多时，多 SQK 技能要求高
SQL 语句依赖数据库，导致数据库移植性差，不能随意更换数据库

1.4 MyBatis 适用场合

MyBatis 专注于 SQL 本身，是一个灵活高效的持久层解决方案，适用于快速开发的项目
MyBatis 适用于性能要求高，且需求变化多的项目

1.5 MyBatis 和 Hibernate 对比

	MyBatis	Hibernate
学习成本
开发速度
工作量
SQL 优化
对象管理
缓存

二、MyBatis 基本使用

POJO OGNL

2.1 基本使用

2.1.1 导入相关依赖

pom.xml

<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.4.4</version>
</dependency>

<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>8.0.11</version>
</dependency>

<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.14</version>
</dependency>

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.10</version>
</dependency>

2.1.2 增加配置文件

/resources/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">

<!-- mybatis的主配置文件 -->
<configuration>
    <!--  指定配置文件内容  -->
    <properties resource="jdbcConfig.properties">
    </properties>
    <!--    <properties url="file:///E:\lincya\study\java3\mybatis\mybatis_day02_01\jdbcConfig.properties">-->
    <!--    </properties>-->

    <!--  使用typeAliases配置别名，但只能配置domain中类的别名，使用指定的别名不区分大小写  -->
    <typeAliases>
        <!--        <typeAlias type="xyz.tom.www.domain.User" alias="user"></typeAlias>-->
        <!-- 用于指定要配置别名的包，当指定后，该包下的实体类都会注册别名，且类名就是别名，不区分大小写 -->
        <package name="xyz.tom.www.domain"/>
    </typeAliases>

    <!--  配置环境  -->
    <environments default="mysql">
        <!--    配置mysql的环境    -->
        <environment id="mysql">
            <!--    配置事务的类型   -->
            <transactionManager type="JDBC"></transactionManager>
            <!--    配置数据源（连接池）   -->
            <dataSource type="POOLED">
                <!--       配置连接数据库的4个基本信息         -->
                <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>

    <!--  指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件  -->
    <mappers>
        <!--    package是用于指定dao接口所在的包，当指定之后，就不需要再写mapper以及resource或者class了    -->
        <package name="xyz/tom/www/dao"/>
    </mappers>
</configuration>

/resources/jdbcConfig.properties

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=jdbc:mysql://www.xxxxxxx.xyz:3306/testdb?useSSL=false&useUnicode=true&characterEncoding=utf8
jdbc.username=root
jdbc.password=root

/resources/log4j.properties

#log4j.rootLogger=DEBUG, CONSOLE, LOGFILE
#
#log4j.logger.org.apache.axis.enterprise=FATAL, CONSOLE
#
##Console
#log4j.appender.CONSOLE=org.apache.log4j.DailyRollingFileAppender
#log4j.appender.Console.layout=org.apache.log4j.PatternLayout
#log4j.appender.Console.layout.ConversionPattern=%d[ISO8601] %-6r [%15.15t] %-5p %30.30c %x -%m\n
#
#log4j.appender.LOGFILE=org.apache.log4j.FileAppender
#log4j.appender.LOGFILE.File=e:/axis.log
#log4j.appender.LOGFILE.Append=true
#log4j.appender.LOGFILE.layout=org.apache.log4j.PatternLayout
#log4j.appender.LOGFILE.layout.ConversionPattern=%d[ISO8601] %-6r [%15.15t] %-5p %30.30c %x -%m\n


log4j.rootLogger=ERROR,A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss,SSS} [%c]-[%p] %m%n

#log4j.appender.BROWSE=org.apache.log4j.DailyRollingFileAppender
#log4j.appender.BROWSE.DatePattern='.'yyyy-MM-dd
#log4j.appender.BROWSE.file=${catalina.home}/logs/browse.log
#log4j.appender.BROWSE.layout=org.apache.log4j.PatternLayout
#log4j.appender.BROWSE.layout.ConversionPattern=[%-5p] %d{yyyy-MM-dd HH\:mm\:ss,SSS} method\:%l%n%m%n

#log4j.logger.com.telin.develop.displaytag=DEBUG


log4j.appender.Spring=org.apache.log4j.ConsoleAppender
log4j.appender.Spring.layout=org.apache.log4j.PatternLayout
log4j.appender.Spring.layout.ConversionPattern=[Spring]\: %-5p %d{yyyy-MM-dd HH\:mm\:ss,SSS} %C{1}\:%M - %m%n

#log4j.appender.Hibernate=org.apache.log4j.ConsoleAppender
#log4j.appender.Hibernate.layout=org.apache.log4j.PatternLayout
#log4j.appender.Hibernate.layout.ConversionPattern=[Hibernate]: %-5p %d{yyyy-MM-dd HH:mm:ss,SSS} %C{1}:%M - %m%n

log4j.appender.Ehcache=org.apache.log4j.ConsoleAppender
log4j.appender.Ehcache.layout=org.apache.log4j.PatternLayout
log4j.appender.Ehcache.layout.ConversionPattern=[Ehcache]: %-5p %d{yyyy-MM-dd HH:mm:ss,SSS} %C{1}:%M - %m%n

log4j.logger.com.ibatis=DEBUG
#log4j.logger.com.ibatis.common.jdbc.SimpleDataSource=DEBUG
#log4j.logger.com.ibatis.common.jdbc.ScriptRunner=DEBUG
#log4j.logger.com.ibatis.sqlmap.engine.impl.SqlMapClientDelegate=DEBUG
log4j.logger.java.sql.Connection=DEBUG
log4j.logger.java.sql.Statement=DEBUG
log4j.logger.java.sql.PreparedStatement=DEBUG
log4j.logger.java.sql.ResultSet=DEBUG

2.1.3 使用

/dao/UserDao.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="xyz.tom.www.dao.IUserDao">
    <!-- 配置 查询结果的列名和实体类的属性名的对应关系 -->
<!--    <resultMap id="userMap" type="xyz.tom.www.domain.User">-->
<!--        &lt;!&ndash;    主键字段的对应    &ndash;&gt;-->
<!--        <id property="userId" column="id"></id>-->
<!--        &lt;!&ndash;    非主键字段的对应    &ndash;&gt;-->
<!--        <result property="userName" column="usern   ame"></result>-->
<!--        ....-->
<!--    </resultMap>-->

    <!--  配置查询所有  -->
<!--    <select id="findAll" resultMap="userMap">-->
    <select id="findAll" resultType="User">
        select * from user
    </select>

    <!--  保存用户  -->
    <insert id="saveUser" parameterType="User">
        --     <!--  配置插入操作后，获取插入数据的id  -->
        <selectKey keyProperty="id" keyColumn="id" resultType="int" order="AFTER">
            select last_insert_id();
        </selectKey>
        insert into user(username, address, birthday, sex) values(#{username},#{address},#{birthday},#{sex})
    </insert>

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

    <delete id="deleteUser" parameterType="Integer">
        delete from
            user
        where
            id=#{uid}
    </delete>

    <select id="findById" parameterType="Integer" resultType="User">
        select
            *
        from
            user
        where
            id=#{uid}
    </select>

    <select id="findByName" parameterType="string" resultType="User">
        select
            *
        from
            user
        where
            username like concat('%',#{name},'%')
    </select>

    <select id="findTotal" resultType="int">
        select
            count(id)
        from
            user
    </select>

    <select id="findUserByVo" parameterType="QueryVo" resultType="User">
        select
            *
        from
            user
        where
            username like concat('%',#{user.username},'%')
    </select>
</mapper>

测试文件: mybatistest.java

public class mybatisTest {

    private InputStream in;
    private SqlSession session;
    private IUserDao userDao;

    @Before
    public void init() throws Exception{
        // 1. 读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        // 2. 创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        // 3. 使用工厂生产SqlSession对象
        session = factory.openSession();
        // 4. 使用SqlSession创建Dao接口的代理对象
        userDao = session.getMapper(IUserDao.class);
    }

    @After
    public void destroy() throws IOException {
        // 6. 释放资源
        session.close();
        in.close();
    }

    @Test
    public void testFindAll() throws Exception {
        // 5. 使用代理对象执行方法
        List<User> users = userDao.findAll();
        for (User user: users) {
            System.out.println(user);
        }
    }

    @Test
    public void testSave() throws IOException {
        User user = new User();
        user.setUsername("秋色");
        user.setAddress("小胡路365");
        user.setSex("女");
        user.setBirthday(new Date());
        System.out.println(user);

        // 5. 使用代理对象执行方法
        int count = userDao.saveUser(user);
        System.out.println(count);
        System.out.println(user);

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

    @Test
    public void testUpdate() throws IOException {
        User user = new User();
        user.setId(1);
        user.setUsername("小胡");
        user.setAddress("小茗路980");
        user.setSex("女");
        user.setBirthday(new Date());

        // 5. 使用代理对象执行方法
        int count = userDao.updateUser(user);
        System.out.println(count);

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

    @Test
    public void testDelete() throws IOException {
        // 5. 使用代理对象执行方法
        int count = userDao.deleteUser(2);
        System.out.println(count);

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

    @Test
    public void testFindByID() throws IOException {
        // 5. 使用代理对象执行方法
        User user = userDao.findById(1);
        System.out.println(user);
    }

    @Test
    public void testFindByName() throws IOException {
        // 5. 使用代理对象执行方法
        List<User> lists = userDao.findByName("胡");
        for (User user : lists) {
            System.out.println(user);
        }
    }

    @Test
    public void testTotal(){
        // 5. 使用代理对象执行方法
        int count = userDao.findTotal();
        System.out.println(count);
    }

    @Test
    public void testFindByVo(){
        QueryVo vo = new QueryVo();
        User user = new User();
        user.setUsername("胡");
        vo.setUser(user);
        // 5. 使用代理对象执行方法
        List<User> users = userDao.findUserByVo(vo);
        for(User u: users) {
            System.out.println(u);
        }
    }
}

2.1.4 常用标签

判断是否存在：<if>、<where>

<select id="findAll" resultType="User">
    select * from user
    <where>
        <if test="username ！= null">
            and username=#{username}
        </if>
    </where>
</select>

动态批量处理： <foreach>

批量查询：

 <select id="findUserInIds" parameterType="QueryVo" resultType="User">
        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>

批量增加：

    <insert id="saveUserBatch" parameterType="QueryVo">
        insert into user(
            username,
            address,
            birthday,
            sex
        )
        values
        <if test="users != null and users.size()>0">
            <foreach collection="users" item="user" separator=",">
                (
                    #{user.username},
                    #{user.address},
                    #{user.birthday},
                    #{user.sex}
                )
            </foreach>
        </if>
    </insert>

批量删除：

<delete id="deleteUserBatch" parameterType="QueryVo">
        delete from
            user
        <where>
            <if test="ids != null and ids.size()>0">
                <foreach collection="ids" item="uid" separator="," open="and id in(" close=")">
                    #{uid}
                </foreach>
            </if>
        </where>
</delete>

批量更新：

<update id="updateUserBatch" parameterType="QueryVo">
        <if test="users != null and users.size()>0">
            <foreach collection="users" item="user" separator=",">
                update
                    user
                set
                    username=#{user.username},
                    sex=#{user.sex},
                    birthday=#{user.birthday},
                    address=#{user.address}
                where
                    id=#{user.id}
            </foreach>
        </if>
   </update>

2.2 POJO

开发中可以通过 pojo 传递查询条件，实现多个对象共同查询。可以使用包装对象传递输入参数。


/**
 * 通过封装多个对象，实现多个对象共同查询
 */
public class QueryVo implements Serializable {
    public static final long serivalVersionUID=1L;

    private User user;

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }
}

<select id="findUserByVo" parameterType="QueryVo" resultType="xyz.tom.www.domain.User">
        select
            *
        from
            user
        where
            username like concat('%',#{user.username},'%')
</select>

    @Test
    public void testFindByVo(){
        QueryVo vo = new QueryVo();
        User user = new User();
        user.setUsername("胡");
        vo.setUser(user);
        // 5. 使用代理对象执行方法
        List<User> users = userDao.findUserByVo(vo);
        for(User u: users) {
            System.out.println(u);
        }
    }

2.3 配置指定dao包地址

2.3.1 先在配置文件中使用 packge 标签指定位置

<?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">

<!-- mybatis的主配置文件 -->
<configuration>
    ...

    <!--  指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件  -->
    <mappers>
        <!--    package是用于指定dao接口所在的包，当指定之后，就不需要再写mapper以及resource或者class了    -->
        <package name="xyz/tom/www/dao"/>
    </mappers>
</configuration>

2.3.2 修改 pom.xml 文件

由于 idea 下的 maven 默认不会主动把 src 下除 java 文件夹外的文件打包到 classes 文件夹下，故需要在 pom.xml 中修改配置

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

2.4 配置类型别名，减少不断写类路径的麻烦

通过 typeAliases 可以指定访问哪个包下的类文件，作为查询的入参和出参。

配置后的类名就是别名，且使用别名时不区分大小写

<!-- mybatis的主配置文件 -->
<configuration>
    <!--  使用typeAliases配置别名，但只能配置domain中类的别名，使用指定的别名不区分大小写  -->
    <typeAliases>
        <!--        <typeAlias type="xyz.tom.www.domain.User" alias="user"></typeAlias>-->
        <!-- 用于指定要配置别名的包，当指定后，该包下的实体类都会注册别名，且类名就是别名，不区分大小写 -->
        <package name="xyz.tom.www.domain"/>
    </typeAliases>
   
    .....
</configuration>

使用前后对比：

配置前：
<mapper namespace="xyz.tom.www.dao.IUserDao">
    <select id="findAll" resultType="xyz.tom.www.domain.User">
        ...
    </select>

    <insert id="saveUser" parameterType="xyz.tom.www.domain.User">
        ...
    </insert>

    <update id="updateUser" parameterType="xyz.tom.www.domain.User">
        ...
    </update>

    ......
</mapper>

配置后：
<mapper namespace="xyz.tom.www.dao.IUserDao">
    <select id="findAll" resultType="User">
        ...
    </select>

    <insert id="saveUser" parameterType="User">
        ...
    </insert>

    <update id="updateUser" parameterType="User">
        ...
    </update>

    ......
</mapper>

三、MyBatis 连接池和事务

3.1 MyBatis 连接池提供的三种方式：

3.1.1 配置的位置

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

    <!--  配置环境  -->
    <environments default="mysql">
        <!--    配置mysql的环境    -->
        <environment id="mysql">
            <!--    配置事务的类型   -->
            <transactionManager type="JDBC"></transactionManager>
            <!--    配置数据源（连接池）   -->
            <dataSource type="POOLED">
                <!--       配置连接数据库的4个基本信息         -->
                <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>

3.1.2 type 属性取值

取值	描述
POOLED	采用传统的 javax.sql.DataSource 中的连接池，mybatis 中有针对规范的实现
UNPOLLED	采用传统的获取连接的方式，虽然也实现 javax.sql.DataSrouce 接口，但是并没有使用池的思想
JNDI	采用服务器提供的 JNDI 技术实现，来获取 DataSource 对象，不同的服务器所能拿到的 DataSource 是不一样的。注意：如果不是 web 或者 maven 的 war 工程，是不能使用的。

3.2 MyBatis 事务

3.2.1 什么是事务

3.2.2 事务的四大特性ACID

3.2.3 不考虑隔离性会产生的3个问题

3.2.4 解决办法：四种隔离级别

3.3 MyBatis 一对一关系和多对多关系

3.3.1 一对一关系

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="xyz.tom.www.dao.IAccountDao">
    <!-- 配置 查询结果的列名和实体类的属性名的对应关系 -->
    <resultMap id="accountUserMap" type="account">
        <!--    主键字段的对应    -->
        <id property="id" column="id"></id>
        <!--    非主键字段的对应    -->
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
        <!--   一对一的关系映射，配合封装user的内容     -->
        <association property="user" column="uid" javaType="user">
            <id property="id" column="id"></id>
            <result property="username" column="username"></result>
            <result property="address" column="address"></result>
            <result property="sex" column="sex"></result>
            <result property="birthday" column="birthday"></result>
        </association>
    </resultMap>

    <!--  配置查询所有  -->
        <select id="findAll" resultMap="accountUserMap">
<!--    <select id="findAll" resultType="Account">-->
--         select * from account
        select a.*, u.username, u.address from account a, user u where u.id = a.uid;
    </select>
</mapper>

修改实体类：Account.java


public class Account implements Serializable {

    private static final long serivalVersionUID = 1L;

    private Integer id;
    private Integer uid;
    private Double money;

    private User user;

    public User getUser() {
        return user;
    }

    public void setUser(User user) {
        this.user = user;
    }

    public Integer getId() {
        return id;
    }

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

    public Integer getUid() {
        return uid;
    }

    public void setUid(Integer uid) {
        this.uid = uid;
    }

    public Double getMoney() {
        return money;
    }

    public void setMoney(Double money) {
        this.money = money;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", uid=" + uid +
                ", money=" + money +
                '}';
    }
}

测试代码：


public class AccountTest {

    private InputStream in;
    private SqlSession session;
    private IUserDao userDao;

    @Before
    public void init() throws Exception{
        // 1. 读取配置文件
        in = Resources.getResourceAsStream("SqlMapConfig.xml");
        // 2. 创建SqlSessionFactory工厂
        SqlSessionFactoryBuilder builder = new SqlSessionFactoryBuilder();
        SqlSessionFactory factory = builder.build(in);
        // 3. 使用工厂生产SqlSession对象
        session = factory.openSession();
        // 4. 使用SqlSession创建Dao接口的代理对象
        userDao = session.getMapper(IUserDao.class);
    }

    @After
    public void destroy() throws IOException {
        // 6. 释放资源
        session.close();
        in.close();
    }

    @Test
    public void testFindAll() throws Exception {
        List<User> accs = userDao.findAll();
        for (User acc: accs) {
            System.out.println(acc);
            System.out.println(acc.getAccounts());
        }
    }
}

3.3.2 多对多关系

<?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="xyz.tom.www.dao.IRoleDao">
    <!-- 配置 查询结果的列名和实体类的属性名的对应关系 -->
    <resultMap id="roleMap" type="role">
        <!--    主键字段的对应   findAll -->
        <id property="roleId" column="rId"></id>
        <!--    非主键字段的对应    -->
        <result property="roleName" column="role_name"></result>
        <result property="roleDesc" column="role_desc"></result>
        <collection property="users" ofType="user">
            <id column="id" property="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>
    </resultMap>

    <!--  配置查询所有  -->
    <select id="findAll" resultMap="roleMap">
        select u.*,r.id as rId, r.role_name, r.role_desc from
            role r
        left outer join user_role ur on r.id=ur.rid
        left outer join user u on u.id=ur.uid
    </select>
</mapper>

四、MyBatis 加载和缓存

4.1 延迟加载和立即加载

4.1.1 需求场景

查询一批笔记本电脑的进货明细，而不直接展示每列明细对应电脑配置或者价格等的详细信息，等到用户需要取出某笔记本相关的详细信息的时候，再进行单表查询

4.1.2 什么是延迟加载和立即加载

延迟加载：在真正使用数据的时候才发起查询，不用的时候不查询关联的数据，延迟加载又叫按需查询（懒加载）

立即加载：只要一调用方法，马上发起查询。

4.1.3 实现方式

开启配置：

<!--  开启mybatis支持延迟加载  -->
<settings>
    <setting name="lazyLoadingEnabled" value="true"/>
    <setting name="aggressiveLazyLoading" value="false"/>
</settings>

一对一：

<!-- 配置 查询结果的列名和实体类的属性名的对应关系 -->
    <resultMap id="accountUserMap" type="account">
        <!--    主键字段的对应    -->
        <id property="id" column="id"></id>
        <!--    非主键字段的对应    -->
        <result property="uid" column="uid"></result>
        <result property="money" column="money"></result>
        <!--   一对一的关系映射，配合封装user的内容
                select 属性指定的内容，查询用户的唯一标识
                column 属性指定的内容，用户根据id查询时，所需要的的参数的值-->
        <association property="user" column="uid" javaType="user" select="xyz.tom.www.dao.IUserDao.findById"></association>
    </resultMap>

一对多：

<!-- 配置 查询结果的列名和实体类的属性名的对应关系 -->
    <resultMap id="userMap" type="user">
        <!--    主键字段的对应    -->
        <id property="id" column="id"></id>
        <!--    非主键字段的对应    -->
        <result property="username" column="username"></result>
        <result property="address" column="address"></result>
        <result property="sex" column="sex"></result>
        <result property="birthday" column="birthday"></result>
        <!--   配置user对象中，roles集合的映射    -->
        <collection property="accounts" ofType="account" select="xyz.tom.www.dao.IAccountDao.findAccountById" column="id"></collection>
    </resultMap>

4.2 缓存

4.2.1 什么是缓存

缓存即存在于内存中的临时数据

4.2.2 为什么使用缓存

有效减少和数据库的交互次数，提高执行效率

4.2.3 适用范围

适用于缓存

经常查询且不常改变的
数据的正确与否对最终结果影响不大的

不适用于缓存

经常改变的数据
数据的正确与否对最终结果影响很大的
例如：商品的库存，银行的汇率，股市的牌价

4.2.4 一级缓存和二级缓存

	一级缓存	二级缓存
概念	指的是 MyBatis 中 SqlSession 对象的缓存	指的是 MyBatis 中 SqlSessionFactory 对象的缓存，由同一个 SqlSessionFactory 对象创建的 SqlSession 共享其缓存
存储方式	存储对象	仅存储数据
创建时间	当执行查询后，查询的结果会同时存入到 SqlSession 提供的一块区域中	开启配置后，查询时自动存入扫 SqlSessionFactory 中
销毁时间	当调用 SqlSession 的修改、添加、删除、commit()、close() 等方法时，就会清空一级缓存	任何的增删改都将刷新二级缓存
使用原则	默认开启	① 只能在同一个命名空间下使用二级缓存，若多个命名空间下都存在对同一个表的操作，那么这些命名空间内的数据可能会不一致 ② 在单表上使用二级缓存。若一个表与其他表有关联，那么可能存在多个命名空间对同一数据的操作 ③ 在查询多于修改时使用。由于任何的增删改操作都将刷新二级缓存，对二级缓存的频繁刷新会降低系统性能

4.2.5 二级缓存的打开方式

SqlMapConfig.xml

<!-- mybatis的主配置文件 -->
<configuration>
    ...

    <settings>
        <setting name="cacheEnabled" value="true"/>
    </settings>
</configuration>

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="xyz.tom.www.dao.IUserDao">
    <!--  开启user支持二级缓存 -->
    <cache/>


    <!--  使用 useCache 配置开启二级缓存 -->
    <select id="findById" parameterType="Integer" resultType="user" useCache="true">
        select
            *
        from
            user
        where
            id=#{uid}
    </select>

</mapper>

五、MyBatis 的注解用法

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">

<!-- mybatis的主配置文件 -->
<configuration>
    ....

    <!--  指定映射配置文件的位置，映射配置文件指的是每个dao独立的配置文件  -->
    <mappers>
        <package name="xyz.tom.www.dao"/>
    </mappers>
</configuration>

IUserDao.java

package xyz.tom.www.dao;

import org.apache.ibatis.annotations.*;
import xyz.tom.www.domain.AliasUser;
import xyz.tom.www.domain.User;

import java.util.List;

public interface IUserDao {

    @Select("select * from user")
    List<User> findAll();

    @Select("select * from user")
    @Results(id="userMap", value = {
            @Result(id = true, column = "id", property = "uId"),
            @Result(column = "username", property = "userN"),
            @Result(column = "address", property = "userA"),
            @Result(column = "sex", property = "userS"),
            @Result(column = "birthday", property = "userB"),

    })
    List<AliasUser> findAliasAll();

    @Select("select * from user")
    @ResultMap(value = {"userMap"})
    List<AliasUser> findAliasAll2();

    @Insert("insert into user(username, birthday, sex, address) values(#{username},#{birthday},#{sex},#{address})")
    int saveUser(User user);

    @Update("update user set username=#{username}, birthday=#{birthday}, sex=#{sex}, address=#{address} where id=#{id}")
    int updateUser(User user);

    @Delete("delete from user where id=#{id} ")
    int deleteUser(int id);
}

AldarLin

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【Mybatis】Mybatis 学习笔记

一、MyBatis 基本知识1.1 什么是 MyBatisMyBatis 是一个基于 java 的持久层框架，它内部封装了 jdbc，使开发者只需要关注 sql 语句本身，而不需要花费精力去处理加载驱动、创建连接、创建 statement 等繁杂的过程 MyBatis 通过 xml 或者注解的方式将要执行的各种 statement 配置起来，并通过 java 对象和 statement ...
复制链接

扫一扫