Mybatis学习笔记

最新推荐文章于 2024-03-07 22:41:36 发布

suprefan

最新推荐文章于 2024-03-07 22:41:36 发布

阅读量86

点赞数

分类专栏： # 框架学习

本文链接：https://blog.csdn.net/waiter123321/article/details/117401315

版权

框架学习专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1.简介

1.1 什么是Mybatis

MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。

如何获得Mybatis?

maven仓库

<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis</artifactId>
    <version>3.5.7</version>
</dependency>

Github：Releases · mybatis/mybatis-3 (github.com)
中文文档：mybatis – MyBatis 3 | 简介

1.2 持久化

数据持久化

持久化就是将程序的数据在持久状态和瞬时状态转化的过程
内存：断电即失
数据库（jdbc），io文件持久化

为什么需要持久化？

有一些对象不能让他丢掉
内存太贵了

1.3 持久层

完成持久化工作的代码块
层界限十分明显

1.4 为什么需要mybatis

方便
传统的JDBC代码太复杂了
简化
帮助程序将数据存入到数据库中
不用mybatis也可以
优点：
- 简单易学
- 灵活
- sql和代码分离提高了可维护性
- 提供映射标签支持对象与数据库的orm字段关系映射
- 提供对象关系映射标签支持对象关系组建维护
- 提供xml标签支持编写动态sql

2. 第一个Mybatis程序

思路：搭建环境---->导入Mybatis---->编写代码---->测试

2.1 搭建环境

搭建数据库

CREATE TABLE `user` (
		`id` INT(20) NOT NULL PRIMARY KEY,
		`name` VARCHAR(30) DEFAULT NULL,
		`pwd` VARCHAR(30) DEFAULT NULL
)ENGINE = INNODB DEFAULT CHARSET = utf8;

INSERT INTO `user` (`id`, `name`, `pwd`) VALUES
(1,'狂神','123456'),
(2,'张三','123456'),
(3,'李四','123456')

新建项目

新建普通maven项目
删除src目录
导入maven依赖

		<dependencies>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.21</version>
        </dependency>
        <dependency>
            <groupId>org.mybatis</groupId>
            <artifactId>mybatis</artifactId>
            <version>3.5.7</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
    </dependencies>

2.2 创建一个模块

编写mybatis的核心配置文件

<?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="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&amp;useUnicode=true&amp;characterEncoding=UTF-8&amp;serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="123"/>
            </dataSource>
        </environment>
    </environments>
    <!--每一个Mapper.XML都需要在核心配置文件中注册-->
    <mappers>
        <mapper resource="com/fan/dao/UserMapper.xml"/>
    </mappers>
</configuration>

编写mybatis工具类

public class MybatisUtils {

    private static SqlSessionFactory sqlSessionFactory;

    static {
        try {
            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();
    }

}

2.3 编写代码

实体类

//实体类
public class User {
    private int id;
    private String name;
    private String pwd;

    public User() {
    }

    public User(int id, String name, String pwd) {
        this.id = id;
        this.name = name;
        this.pwd = pwd;
    }

    public int getId() {
        return id;
    }

    public String getName() {
        return name;
    }

    public String getPwd() {
        return pwd;
    }

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

    public void setName(String name) {
        this.name = name;
    }

    public void setPwd(String pwd) {
        this.pwd = pwd;
    }

    @Override
    public String toString() {
        return "User{" +
                "id = " + id +
                ", name = " + name + '\'' +
                ", pwd = " + pwd + '\'' +
                "}";
    }
}

Dao接口

public interface UserDao {
    List<User> getUserList();
}

接口实现类

<?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.fan.dao.UserDao">
    <select id="getUserList" resultType="com.fan.pojo.User">
    select * from mybatis.user
  </select>
</mapper>

2.4 测试

注意点：org.apache.ibatis.binding.BindingException: Type interface com.fan.dao.UserDao is not known to the MapperRegistry.

MapperRegistry是什么？

核心配置文件中注册Mappers

junit测试

public class UserDaoTest {
    public UserDaoTest() {
    }

    @Test
    public void test() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserDao userDao = (UserDao)sqlSession.getMapper(UserDao.class);
        List<User> userList = userDao.getUserList();
        Iterator var4 = userList.iterator();

        while(var4.hasNext()) {
            User user = (User)var4.next();
            System.out.println(user);
        }

        sqlSession.close();
    }
}

可能会遇到的问题
- 配置文件没有注册
- 绑定接口错误
- 方法名不对
- 返回类型不对
- mybatis配置文件中时区、编码格式设置问题
- Maven导出资源问题

3. CRUD

3.1 namespace

namespace中的包名要和mapper接口的包名一致

3.2 select

选择，查询语句；

id：就是对应的namespace中的方法名
resultType：sql语句执行的返回值
parameterType:参数

编写接口
编写对应的mapper中的sql语句
测试

3.3 insert

3.4 update

3.5 delete

public interface UserMapper {
    //查询全部用户
    List<User> getUserList();

    //根据id查询用户
    User getUserById(int id);

    //插入一个用户
    int addUser(User user);

    //修改用户信息
    int updateUser(User user);

    //删除用户
    int deleteUser(int id);
}

		<select id="getUserList" resultType="com.fan.pojo.User">
        select * from mybatis.user
    </select>
    <select id="getUserById" resultType="com.fan.pojo.User" parameterType="int">
        select * from mybatis.user where id = #{id}
    </select>
    <insert id="addUser" parameterType="com.fan.pojo.User">
        insert into mybatis.user (id, name, pwd) values (#{id} , #{name}, #{pwd});
    </insert>
    <update id="updateUser" parameterType="com.fan.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>

public class UserDaoTest {

    @Test
    public void test(){
        //第一步 获取sqlsession对象
        SqlSession sqlSession = MybatisUtils.getSqlSession();


        try {
            //方式一：getMapper
            UserMapper userDao = sqlSession.getMapper(UserMapper.class);
            List<User> userList = userDao.getUserList();
            for(User user : userList)
                System.out.println(user);
        } catch (Exception e) {

        } finally {
            //关闭sqlsession
            sqlSession.close();
        }

        //方式二：
        //List<User> userList = sqlSession.selectList("com.fan.dao.UserDao.getUserList");

    }

    @Test
    public void testgetUserByIdo(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        User user = mapper.getUserById(1);
        System.out.println(user);

        sqlSession.close();
    }
    //增删改需要提交事务
    @Test
    public void testaddUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        int res = mapper.addUser(new User(4, "哈哈", "123456"));
        if(res > 0)
            System.out.println("插入成功!");
        //提交事务
        sqlSession.commit();
        User user = mapper.getUserById(4);
        System.out.println(user);

        sqlSession.close();
    }

    @Test
    public void testupdateUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.updateUser(new User(4, "呵呵", "123"));
        //提交事务
        sqlSession.commit();
        User user = mapper.getUserById(4);
        System.out.println(user);

        sqlSession.close();
    }

    @Test
    public void testdeleteUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();

        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.deleteUser(4);
        //提交事务
        sqlSession.commit();


        sqlSession.close();
    }
}

3.6 万能map

假设，我们的实体类，或者数据库中的表，字段或者参数过多，我们应当考虑使用map。

3.7 模糊查询

模糊查询怎么写？

java代码执行的时候，传递通配符 % %

List<User> userList = mapper.getUserLike("%李%");
在sql拼接中使用通配符！

select * from mybatis.user where name like % #{value}%

4.配置解析

4.1 核心配置文件

mybatis-config.xml

configuration（配置）
properties（属性）
settings（设置）
typeAliases（类型别名）
typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
environments（环境配置）
environment（环境变量）
transactionManager（事务管理器）
dataSource（数据源）
databaseIdProvider（数据库厂商标识）
mappers（映射器）

4.2 配置环境

Mybatis可以配置成适应多种环境

不过要记住：尽管可以配置多个环境，但每个SqlSessionFactory实例只能选择一种环境

学会使用配置多套运行环境

Mybatis默认的事务管理器就是JDBC，连接池：POOLED

4.3 属性

这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置。【db.properties】

编写一个配置文件

driver = com.mysql.cj.jdbc.Driver
url = jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=UTF-8&serverTimezone=UTC
username = root
password = 123

在核心配置文件中引入

<properties resource="db.properties"/>

可以直接引入外部文件
可以在其中增加一些属性配置
如果两个文件有同一个字段，优先使用外部配置文件的

4.4 typeAliases（类型别名）

类型别名可为 Java 类型设置一个缩写名字。它仅用于 XML 配置，意在降低冗余的全限定类名书写

		<typeAliases>
        <typeAlias type="com.fan.pojo.User" alias="User"/>
    </typeAliases>

也可以指定一个包名，MyBatis 会在包名下面搜索需要的 Java Bean

扫描实体类的包，它的默认别名就为这个类的类名，首字母小写

		<typeAliases>
        <package name="com.fan.pojo"/>
    </typeAliases>

4.5 设置

4.6 其他配置

typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins
- mybatis-generator-core
- mybatis-plus
- 通用mapper

4.7 映射器mapper

MapperRegistry

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

4.8 生命周期和作用域

理解我们之前讨论过的不同作用域和生命周期类别是至关重要的，因为错误的使用会导致非常严重的并发问题。

SqlSessionFactoryBuilder

一旦创建了SqlSessionFactoryBuilder，就不再需要他了
局部变量

SqlSessionFactory

说白了就是可以想象为：数据库连接池
SqlSessionFactory一旦被创建就应该在应用运行期间一直存在，没有任何理由丢弃它或重新建立另一个实例
最佳作用域是应用作用域
最简单的就是使用单例模式或者静态单例模式

SqlSession

连接到连接池的一个请求
SqlSession的实例不是线程安全的，因此不能被共享，所以它的最佳作用域是请求或方法作用域
用完赶紧关闭

5. 解决属性名和字段名不一致的问题

起别名

select id, name, pwd as password from mybatis.user where id = #{id}

resultMap

		<resultMap id="UserMap" type="User">
        <!--column 数据库中的字段 property实体类中的属性 -->
        <result column="id" property="id"/>
        <result column="name" property="name"/>
        <result column="pwd" property="password"/>
    </resultMap>

resultMap 元素是 MyBatis 中最重要最强大的元素。

ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。

6.日志

6.1日志工厂

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-hE9EtUWs-1622368620503)(G:\vscode_files\blog\Mybatis.assets\image-20210527104516637.png)]

SLF4J
LOG4J（掌握）
LOG4J2
JDK_LOGGING
COMMONS_LOGGING
STDOUT_LOGGING（掌握）
NO_LOGGING

		<settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

Opening JDBC Connection
Created connection 773989906.
Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@2e222612]
==>  Preparing: select * from mybatis.user where id = ?
==> Parameters: 2(Integer)
<==    Columns: id, name, pwd
<==        Row: 2, 张三, 123456
<==      Total: 1
User{id = 2, name = 张三', password = 123456'}
Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@2e222612]
Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@2e222612]
Returned connection 773989906 to pool.

Process finished with exit code 0

6.2LOG4J

什么是LOG4J？

Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件
我们也可以控制每一条日志的输出格式
通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程
通过一个配置文件来灵活地进行配置

导包

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

log4j.properties

### set log levels ###
log4j.rootLogger = debug ,  console ,  file

### 控制台输出相关设置 ###
log4j.appender.console = org.apache.log4j.ConsoleAppender
log4j.appender.console.Target = System.out
log4j.appender.console.layout = org.apache.log4j.PatternLayout
log4j.appender.console.Threshold = DEBUG
log4j.appender.stdout.layout.ConversionPattern = [%c]-%m%n

### 文件输出相关设置 ###
log4j.appender.file = org.apache.log4j.RollingFileAppender
log4j.appender.file.File = ./logs/fan.log
log4j.appender.file.MaxFileSize = 10mb
log4j.appender.file.Threshold = DEBUG ## 输出DEBUG级别以上的日志
log4j.appender.file.layout = org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern = [%p][%d{yy-MM-dd}][%c]%m%n

### 日志输出级别 ###
log4j.logger.org.mybatis = DEBUG
log4j.logger.java.sql = DEBUG
log4j.logger.java.sql.Statement = DEBUG
log4j.logger.java.sql.ResultSet = DEBUG
log4j.logger.java.sql.PrepareStatement = DEBUG

配置Log4j为日志的实现

		<settings>
        <setting name="logImpl" value="LOG4J"/>
    </settings>

log4j的使用

[DEBUG][21-05-27][org.apache.ibatis.transaction.jdbc.JdbcTransaction]Opening JDBC Connection
[DEBUG][21-05-27][org.apache.ibatis.datasource.pooled.PooledDataSource]Created connection 777313177.
[DEBUG][21-05-27][org.apache.ibatis.transaction.jdbc.JdbcTransaction]Setting autocommit to false on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@2e54db99]
[DEBUG][21-05-27][com.fan.dao.UserMapper.getUserById]==>  Preparing: select * from mybatis.user where id = ?
[DEBUG][21-05-27][com.fan.dao.UserMapper.getUserById]==> Parameters: 2(Integer)
[DEBUG][21-05-27][com.fan.dao.UserMapper.getUserById]<==      Total: 1
[DEBUG][21-05-27][org.apache.ibatis.transaction.jdbc.JdbcTransaction]Resetting autocommit to true on JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@2e54db99]
[DEBUG][21-05-27][org.apache.ibatis.transaction.jdbc.JdbcTransaction]Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@2e54db99]
[DEBUG][21-05-27][org.apache.ibatis.datasource.pooled.PooledDataSource]Returned connection 777313177 to pool.

简单使用

在要使用Log4j的类中，导入包import org.apache.log4j.Logger;
日志对象参数为当前类的classLogger.getLogger(UserMapperTest.class);
日志级别

				logger.info("info:进入了testlog4j");
        logger.debug("debug:进入了testlog4j");
        logger.error("error:进入了testlog4j");

7. 分页

思考：为什么要分页

减少数据的处理量

使用Limit分页

SELECT * from user limit 3; #[0,n]

使用mybatis实现分页

接口

//分页
    List<User>getUserByLimit(Map<String, Object> map);

mapper

<select id="getUserByLimit" parameterType="map" resultMap="UserMap">
        select * from mybatis.user limit #{startindex},#{pagesize};
    </select>

测试

@Test
    public void testgetUserByLimit(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        HashMap<String, Object> map = new HashMap<String, Object>();
        map.put("startindex",0);
        map.put("pagesize",2);
        List<User> users = mapper.getUserByLimit(map);
        for(User user : users)
            System.out.println(user);

        sqlSession.close();
    }

8.使用注解开发

8.1 面向接口编程

根本原因：解耦，可拓展，提高复用，分层开发中，上层不用管具体的实现，大家都遵循共同的标准，使得开发变得容易，规范性更好

关于接口的理解

接口从更深层次的理解，应是定义（规范、约束）与实现（名实分离的原则）的分离
接口的本身反映了系统设计人员对系统的抽象理解
接口应有两类：
- 第一类是对一个个体的抽象，它可应对为一个抽象体
- 第二类是对一个个体某一方面的抽象，即形成一个抽象面

三个面向的区别

面向对象是指我们考虑问题时，以对象为单位，考虑它的属性及方法
面向过程是指我们考虑问题时，以一个具体的流程为单位，考虑它的实现
接口设计与非接口设计时针对复用技术而言的，与面向对象不是一个问题，更多的体现是对系统整体的架构

8.2 使用注解开发

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

8.3 CRUD

我们可以在工具类创建的时候实现自动提交事务

public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession(true);
    }

编写接口，增加注释

		//插入一个用户
    @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(int id);

    @Select("select id, name, pwd as password from user")
    List<User> getUsers();

测试

		@Test
    public void testupdateUser(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);
        mapper.deleteUser(5);
        mapper.updateUser(new User(2, "王五","000"));
        List<User> users = mapper.getUsers();
        for (User user : users) {
            System.out.println(user);
        }

        sqlSession.close();
    }

注意：必须把接口注册帮顶到核心配置文件中

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

8.4 关于param（）注解

基本类型的参数或者String类型需要加上
引用类型不需要加
如果只有一个基本类型的话，可以忽略，但是建议大家都加上
我们在SQL引用的就是我们这里的@param中设定的属性名

9.lombok

使用步骤：

在IDEA中安装lombok插件
在项目中导入lombok的jar包


				<dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
        </dependency>

@Getter and @Setter
@FieldNameConstants
@ToString
@EqualsAndHashCode
@AllArgsConstructor, @RequiredArgsConstructor and @NoArgsConstructor
@Log, @Log4j, @Log4j2, @Slf4j, @XSlf4j, @CommonsLog, @JBossLog, @Flogger, @CustomLog
@Data

@Data:无参构造、get、set、tostring、hashcode、equals

在实体类上加注解即可

10.多对一

SQL:

CREATE TABLE `teacher` (
	`id` INT(10) NOT NULL,
	`name` VARCHAR(30) DEFAULT NULL,
	PRIMARY KEY (`id`)
)ENGINE = INNODB DEFAULT CHARSET = UTF8

INSERT INTO teacher (`id`, `name`) VALUES (1, '秦老师');

CREATE TABLE `student` (
	`id` INT(10) NOT NULL,
	`name` VARCHAR(30) DEFAULT NULL,
	`tid` INT(10) DEFAULT NULL,
	PRIMARY KEY (`id`),
	KEY `fktid` (`tid`),
	CONSTRAINT `fktid` FOREIGN KEY (`tid`) REFERENCES `teacher` (`id`)
)ENGINE = INNODB DEFAULT CHARSET = UTF8

INSERT INTO `student` (`id`, `name`,`tid`) VALUES (1, '小明','1');
INSERT INTO `student` (`id`, `name`,`tid`) VALUES (2, '小红','1');
INSERT INTO `student` (`id`, `name`,`tid`) VALUES (3, '小张','1');
INSERT INTO `student` (`id`, `name`,`tid`) VALUES (4, '小李','1');
INSERT INTO `student` (`id`, `name`,`tid`) VALUES (5, '小王','1');

测试环境搭建

导入lombok
新建实体类teacher student
建立mapper接口
建立mapper.xml文件
在核心配置文件中绑定注册我们的mapper接口或者文件
测试查询能否成功

按照查询嵌套处理

			<!-- 
       思路：
       1. 查询所有的学生信息
       2. 根据查询出来的学生的tid，寻求对应的老师
       -->
    
    <select id="getStudent" resultMap="StudentTeacher">
        select * from mybatis.student
    </select>
    <resultMap id="StudentTeacher" type="Student">
            <!--复杂的属性，我们需要单独处理
                    对象：association
                    集合：collection
            -->
            <association property="teacher" column="tid" javaType="Teacher" select="getTeacher"/>
    </resultMap>
    <select id="getTeacher" resultType="Teacher">
        select * from teacher where id = #{id}
    </select>

按照结果嵌套处理

		<!-- 按照结果嵌套处理   -->

    <select id="getStudent2" resultMap="StudentTeacher2">
        select s.id sid, s.name sname, t.name tname
        from student s, teacher t
        where s.tid = t.id
    </select>
    <resultMap id="StudentTeacher2" type="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <association property="teacher" javaType="Teacher">
            <result property="name" column="tname"/>
        </association>
    </resultMap>

回顾Mysql多对一查询方式：

子查询
联表查询

11.一对多处理

比如：一个老师有多个学生

		<select id="getTeacher" resultMap="TeacherStudent">
        select s.id sid, s.name sname, t.name tname, t.id tid
        from mybatis.student s, mybatis.teacher t
        where s.tid = t.id and t.id = #{tid}
    </select>
    <resultMap id="TeacherStudent" type="Teacher">
        <result property="id" column="tid"/>
        <result property="name" column="tname"/>
        <collection property="students" ofType="Student">
            <result property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>

小结

关联 - association 【多对一】
集合 - collection【一对多】
javaType & ofType
1. javatype 用来指定实体类中属性的类型
2. oftype用来指定映射到List或者集合中的pojo类型泛型中的约束类型

注意点

保证SQL的可读性通俗易懂
注意一对多和多对一属性名和字段的问题
如果问题不好排查错误可以使用日志建议使用Log4j

面试高频

mysql引擎
InnoDB底层原理
索引
索引优化

12. 动态SQL

什么是动态SQL?动态SQL就是根据不同的条件生成不同的SQL语句

如果你之前用过 JSTL 或任何基于类 XML 语言的文本处理器，你对动态 SQL 元素可能会感觉似曾相识。在 MyBatis 之前的版本中，需要花时间了解大量的元素。借助功能强大的基于 OGNL 的表达式，MyBatis 3 替换了之前的大部分元素，大大精简了元素种类，现在要学习的元素种类比原来的一半还要少。

if
choose (when, otherwise)
trim (where, set)
foreach

搭建环境

CREATE TABLE `blog` (
	`id` VARCHAR(50) NOT NULL COMMENT '博客id',
	`title` VARCHAR(100) NOT NULL COMMENT '博客标题',
	`author` VARCHAR(30) NOT NULL COMMENT '博客作者',
	`create_time`  datetime NOT NULL COMMENT '创建时间',
	`views` int(30) NOT NULL COMMENT '浏览量'
) ENGINE = INNODB DEFAULT CHARSET = utf8

创建一个工程：

导包
编写配置文件
编写实体类

@Data
public class Blog {
    private int id;
    private String title;
    private String author;
    private Date create_time;
    private int views;
}

编写实体类对应mapper以及xml

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

<select id="queryBlogChoose" parameterType="map" resultType="Blog">
        select * from blog
        <where>
            <choose>
                <when test="title != null">
                    title = #{title}
                </when>
                <when test="author != null">
                    author = #{author}
                </when>
                <otherwise>
                    and views = #{views}
                </otherwise>
            </choose>
        </where>
    </select>

trim where set

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

		<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标签抽取公共的部分

		<sql id="if-title-author">
        <if test="title != null">
            title = #{title}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
    </sql>

在需要使用的地方使用include标签引用即可

		<select id="queryBlogIF" parameterType="map" resultType="blog">
        select * from mybatis.blog
        <where>
            <include refid="if-title-author"></include>
        </where>
    </select>

注意事项：

最好基于单表来定义SQL片段
不要存在where标签

Foreach

select * from user where 1=1 and (id = 1 or id =2 id =3)

		<select id="queryBlogForeach" parameterType="map" resultType="Blog">
        select * from blog
        <where>
            <foreach collection="ids" item="id" open="and (" close=")" separator="or">
                id = #{id}
            </foreach>
        </where>
    </select>

		@Test
    public void testqueryBlogForeach(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        BlogMapper mapper = sqlSession.getMapper(BlogMapper.class);

        HashMap hashMap = new HashMap();
        ArrayList<Integer> ids = new ArrayList<Integer>();
        ids.add(1);
        ids.add(2);
        hashMap.put("ids",ids);

        List<Blog> blogs = mapper.queryBlogForeach(hashMap);
        for (Blog blog : blogs) {
            System.out.println(blog);
        }


        sqlSession.close();
    }

动态SQL就是在拼接SQL语句，我们只要保证SQL的正确性，按照SQL的格式，去排列组合就可以了

建议

先在Mysql中写出完整的sql，再对应的去修改成为我们的动态SQL实现

13.缓存

13.1 简介

什么是缓存cache？
为什么使用缓存?
什么样的数据能使用缓存？

13.2 Mybatis缓存

Mybatis系统中默认定义了两级缓存：一级缓存和二级缓存
- 默认情况下，只有一级缓存开启（sqlsession级别，也称为本地缓存）
- 二级缓存需要手动开启和配置，基于namespace级别的缓存
- 为了提高扩展性，定义了缓存接口cache，我们可以通过cache接口来自定义二级缓存

13.3 一级缓存

一级缓存也叫本地缓存
- 与数据库同义词会话期间查询到的数据会放在本地缓存中
- 以后如果需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库

缓存失效的情况：

查询不同的东西
增删改操作
查询不同的mapper
手动清理缓存

13.4 二级缓存

二级缓存也叫全局缓存，一级缓存的作用域太低了
基于namespace级别的缓存，一个名称空间，对应一个二级缓存
工作机制
- 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中
- 如果当前会话关闭了，这个会话对应的一级缓存就没了，但是我们想要的是会话关闭了，一级缓存中的数据被保存到二级缓存中
- 新的会话查询信息，就可以从二级缓存中获取内容
- 不同的mapper查出的数据会放在自己对应的缓存中

步骤：

开启全局缓存<setting name="cacheEnabled" value="true"/>
在要使用二级缓存的Mapper中开启<cache/>

suprefan

关注

0
点赞
踩
0

收藏

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

1.简介1.1 什么是MybatisMyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。如何获得Mybatis?maven仓库<!-- https://mvnrepository.com/a
复制链接

扫一扫