MyBatis学习

最新推荐文章于 2022-01-04 20:16:23 发布

Ghost-programmer

最新推荐文章于 2022-01-04 20:16:23 发布

阅读量215

点赞数

分类专栏： MyBatis

本文链接：https://blog.csdn.net/m0_38141537/article/details/111657958

版权

MyBatis 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1、什么是MyBatis

MyBatis是一款优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。
MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作
MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录
MyBatis 是一个半自动化的ORM框架 (Object Relationship Mapping) -->对象关系映射
MyBatis官方文档地址：https://mybatis.org/mybatis-3/zh/index.html
GitHub项目地址：https://github.com/mybatis/mybatis-3

1.1、什么是持久化

持久化（Persistence），即把数据（如内存中的对象）保存到可永久保存的存储设备中（如磁盘）。持久化的主要应用是将内存中的对象存储在数据库中，或者存储在磁盘文件中、XML数据文件中等等。

持久化是将程序数据在持久状态和瞬时状态间转换的机制。

通俗的讲，就是瞬时数据（比如内存中的数据，是不能永久保存的）持久化为持久数据（比如持久化至数据库中，能够长久保存）。

1.2、什么是持久层

持久层用来固化数据，如常说的DAO层，操作数据库将数据入库。

持久层，就是把持久的动作封装成一个独立的层，这是为了降低功能代码之间的关联。创建一个更清晰的抽象，提高代码的内聚力，降低代码的耦合度，从而增强代码的要劳动局生和可重用性。

MyBatis 是一款优秀的持久层框架。

2、MyBatis入门

创建maven项目

导入MyBatis的jar包

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

导入MySQL的jar包

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

导入JUnit测试包

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

创建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.IOException;
import java.io.InputStream;

public class MybatisUtil {

    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 getSession() {
        // 打开事务自动提交
        return sqlSessionFactory.openSession(true);
        // 事务不会自动提交
//        return sqlSessionFactory.openSession();
    }
}

创建MyBatis核心配置文件mybatis-config.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="properties/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>

    <!--设置映射器（mapper）-->
    <mappers>
        <mapper resource="mapper/UserMapper.xml"/>
    </mappers>
</configuration>

db.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://192.168.50.129:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
username=mybatis
password=123456

编写实体类

import java.util.Date;

public class User {
    private int id;

    private String user_name;

    private String password;

    private String sex;

    private Date create_time;

    private String birthday;

    public User() {
    }

    public User(int id, String user_name, String password, String sex, String birthday) {
        this.id = id;
        this.user_name = user_name;
        this.password = password;
        this.sex = sex;
        this.birthday = birthday;
    }

    public int getId() {
        return id;
    }

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

    public String getUser_name() {
        return user_name;
    }

    public void setUser_name(String user_name) {
        this.user_name = user_name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public Date getCreate_time() {
        return create_time;
    }

    public void setCreate_time(Date create_time) {
        this.create_time = create_time;
    }

    public String getBirthday() {
        return birthday;
    }

    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", user_name='" + user_name + '\'' +
                ", password='" + password + '\'' +
                ", sex='" + sex + '\'' +
                ", create_time=" + create_time +
                ", birthday='" + birthday + '\'' +
                '}';
    }
}

编写Mapper接口类

import com.ghost.mybatis.pojo.User;

import java.util.List;

public interface UserMapper {

    List<User> selectUser();

    User selectUserById(int id);

    int addUser(User user);

    int updateUser(User user);

    int deleteUser(int id);
}

编写Mapper.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="com.ghost.mybatis.mapper.UserMapper">
    <select id="selectUser" resultType="com.ghost.mybatis.pojo.User">
        select *
        from user
    </select>

    <select id="selectUserById" parameterType="int" resultType="user">
        select *
        from user
        where id = #{id};
    </select>

    <insert id="addUser" parameterType="com.ghost.mybatis.pojo.User">
        insert into user(id, user_name, password, sex, birthday)
        values (#{id}, #{user_name}, #{password}, #{sex}, #{birthday});
    </insert>

    <update id="updateUser" parameterType="com.ghost.mybatis.pojo.User">
        update user
        set user_name = #{user_name},
            password  = #{password},
            sex       = #{sex},
            birthday  = #{birthday}
        where id = #{id};
    </update>

    <delete id="deleteUser" parameterType="int">
        delete
        from user
        where id = #{id};
    </delete>
</mapper>

编写测试类

import com.ghost.mybatis.mapper.UserMapper;
import com.ghost.mybatis.pojo.User;
import com.ghost.mybatis.utils.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class MyTest {

    @Test
    public void selectUser() {
        // 获取SqlSession
        SqlSession session = MybatisUtil.getSession();
        //方法一:
        //List<User> users = session.selectList("com.ghost.mybatis.mapper.UserMapper.selectUser");
        //方法二:
        UserMapper mapper = session.getMapper(UserMapper.class);
        List<User> users = mapper.selectUser();

        for (User user: users){
            System.out.println(user);
        }
        session.close();
    }

    @Test
    public void selectUserById() {
        SqlSession session = MybatisUtil.getSession();
        UserMapper mapper = session.getMapper(UserMapper.class);
        User user = mapper.selectUserById(1);
        System.out.println(user);
        session.close();
    }

    @Test
    public void addUser() {
        SqlSession session = MybatisUtil.getSession();
        UserMapper mapper = session.getMapper(UserMapper.class);
        mapper.addUser(new User(6, "李四", "12334", "女", "2020-02"));
//        session.commit();
        session.close();
    }

    @Test
    public void updateUser() {
        SqlSession session = MybatisUtil.getSession();
        UserMapper mapper = session.getMapper(UserMapper.class);
        mapper.updateUser(new User(1, "张三", "8899993", "男", "1990-09"));
//        session.commit();
        session.close();
    }

    @Test
    public void deleteUser() {
        SqlSession session = MybatisUtil.getSession();
        UserMapper mapper = session.getMapper(UserMapper.class);
        mapper.deleteUser(3);
//        session.commit();
        session.close();
    }
}

运行测试查询，查询出结果，OK！！！

注意

如果将Mapper.xml文件写入src/main/java下，但是在运行时，target文件夹下没有该文件则，则需要在pom.xml 文件中加入如下配置（Maven静态资源过滤问题）

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

出现如下错误,则需要在MyBatis核心配置文件中设置映射器

org.apache.ibatis.binding.BindingException: Type interface com.ghost.mybatis.dao.UserMapper is not known to the MapperRegistry.

在这里插入图片描述

使用高版本MySQL时需要在URL中设置时区：serverTimezone=Asia/Shanghai
配置文件中namespace中的名称为对应Mapper接口或者Dao接口的完整包名,必须一致
标签不能对应错
resource绑定mapper需要使用路径
程序配置文件必须符合规范

3、作用域（Scope）和生命周期

不同作用域和生命周期类别是至关重要的，因为错误的使用会导致非常严重的并发问题。

创建顺序：SqlSessionFactoryBuilder --> SqlSessionFactory --> SqlSession

3.1 SqlSessionFactoryBuilder

这个类可以被实例化、使用和丢弃，一旦创建了 SqlSessionFactory，就不再需要它了
最佳作用域：局部变量

3.2 SqlSessionFactory

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

3.3 SqlSession

每个线程都应该有它自己的 SqlSession 实例
SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域
每次使用后确保执行关闭操作，否则资源被占用

3.4 从 SqlSessionFactory 中获取 SqlSession方式

方式一：(不推荐，类型不安全)

try (SqlSession session = sqlSessionFactory.openSession()) {
  Blog blog = (Blog) session.selectOne("org.mybatis.example.BlogMapper.selectBlog", 101);
}

方式二：

try (SqlSession session = sqlSessionFactory.openSession()) {
  BlogMapper mapper = session.getMapper(BlogMapper.class);
  Blog blog = mapper.selectBlog(101);
}

每个线程都应该有它自己的 SqlSession 实例。SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的最佳的作用域是请求或方法作用域。
确保每次都能执行关闭操作

3.5 映射器

映射器是一些绑定映射语句的接口（定义映射SQL语句文件）
既然 MyBatis 的行为已经由上述元素配置完了，我们现在就要来定义 SQL 映射语句了。但首先，我们需要告诉 MyBatis 到哪里去找到这些语句。在自动查找资源方面，Java 并没有提供一个很好的解决方案，所以最好的办法是直接告诉 MyBatis 到哪里去找映射文件。你可以使用相对于类路径的资源引用，或完全限定资源定位符（包括 file:/// 形式的 URL），或类名和包名等

<!-- 使用相对于类路径的资源引用 -->
<mappers>
  <mapper resource="org/mybatis/builder/AuthorMapper.xml"/>
  <mapper resource="org/mybatis/builder/BlogMapper.xml"/>
  <mapper resource="org/mybatis/builder/PostMapper.xml"/>
</mappers>

<!-- 使用完全限定资源定位符（URL） -->
<mappers>
  <mapper url="file:///var/mappers/AuthorMapper.xml"/>
  <mapper url="file:///var/mappers/BlogMapper.xml"/>
  <mapper url="file:///var/mappers/PostMapper.xml"/>
</mappers>

<!-- 使用映射器接口实现类的完全限定类名 -->
<mappers>
  <mapper class="org.mybatis.builder.AuthorMapper"/>
  <mapper class="org.mybatis.builder.BlogMapper"/>
  <mapper class="org.mybatis.builder.PostMapper"/>
</mappers>

<!-- 将包内的映射器接口实现全部注册为映射器 -->
<mappers>
  <package name="org.mybatis.builder"/>
</mappers>

MapperRegistry：注册绑定我们的Mapper文件
在使用“使用映射器接口实现类的完全限定类名”和“将包内的映射器接口实现全部注册为映射器”引入映射器接口时，需要注意如下问题：
- 接口和他的Mapper配置文件必须同名
- 接口和他的Mapper配置文件必须在同一个包下

3.6 映射器实例

映射器接口的实例是从 SqlSession 中获得的
方法作用域才是映射器实例的最合适的作用域，映射器实例应该在调用它们的方法中被获取，使用完毕之后即可丢弃
最好将映射器放在方法作用域内

try (SqlSession session = sqlSessionFactory.openSession()) {
  BlogMapper mapper = session.getMapper(BlogMapper.class);
  // 你的应用逻辑代码
}

4、XML配置

MyBatis 的配置文件包含了会深深影响 MyBatis 行为的设置和属性信息，核心配置文件一般为：mybatis-config.xml

4.1 属性（properties）

我们可以通过Properties属性来实现应用配置文件
这些属性可以在外部进行配置，并可以进行动态替换。你既可以在典型的 Java 属性文件中配置这些属性，也可以在 properties 元素的子元素中设置db.properties
在核心配置文件中引入外部配置文件

<!-- 可以直接引入外部文件 -->
<!-- 可以在其中增加一些属性配置 -->
<!-- 如果两个文件中有同一个字段，优先使用配置文件的 -->
<properties resource="properties/db.properties"/>

在XML中，所有的标签都可以规定其顺序

4.2 环境配置（environments）

<environments default="development">
  <environment id="development">
    <transactionManager type="JDBC">
      <property name="..." value="..."/>
    </transactionManager>
    <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>

MyBatis 可以配置成适应多种环境
尽管可以配置多个环境，但每个 SqlSessionFactory 实例只能选择一种环境
Mybatis默认的事务管理器是JDBC，连接池：POOLED

4.3 类型别名（typeAliases）

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

<typeAliases>
  <typeAlias alias="Author" type="domain.blog.Author"/>
  <typeAlias alias="Blog" type="domain.blog.Blog"/>
  <typeAlias alias="Comment" type="domain.blog.Comment"/>
  <typeAlias alias="Post" type="domain.blog.Post"/>
  <typeAlias alias="Section" type="domain.blog.Section"/>
  <typeAlias alias="Tag" type="domain.blog.Tag"/>
</typeAliases>

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

<!-- 在没有注解的情况下，会使用 Bean 的首字母小写的非限定类名来作为它的别名 -->
<!-- 若有注解，则别名为其注解值 -->
<typeAliases>
  <package name="domain.blog"/>
</typeAliases>

第一种可以使用DIY原则，第二种则不行，如果要使用则需要在实体类上增加注解
在实体类比较少的时候，可以使用第一种方式，如果实体类十分多，建议使用第二种

4.4 设置（settings）

cacheEnabled - 全局性地开启或关闭所有映射器配置文件中已配置的任何缓存
lazyLoadingEnabled - 延迟加载的全局开关。当开启时，所有关联对象都会延迟加载。特定关联关系中可通过设置 fetchType 属性来覆盖该项的开关状态
useGeneratedKeys - 允许 JDBC 支持自动生成主键，需要数据库驱动支持。如果设置为 true，将强制使用自动生成主键。尽管一些数据库驱动不支持此特性，但仍可正常工作（如 Derby）
mapUnderscoreToCamelCase - 是否开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn
logImpl - 指定 MyBatis 所用日志的具体实现，未指定时将自动查找(SLF4J | LOG4J | LOG4J2 | JDK_LOGGING | COMMONS_LOGGING | STDOUT_LOGGING(标准日志输出) | NO_LOGGING)

4.5 日志工厂

如果一个数据库操作出现了异常，我们需要排错。日志就是最好的助手。
在mybatis中具体使用那一个日志实现，在设置中设定。
配置信息

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

LOG4J

什么是log4j
- Log4j是Apache的一个开源项目，通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件、GUI组件
- 可以控制每一条日志的输出格式
- 通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程
- 可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码
maven项目中导入jar包
设置日志格式及其他配置信息

#将等级为DEBUG的日志信息输出到console和file这两个目的地，console和file的定义在下面的代码

log4j.rootLogger=DEBUG,console,file



#控制台输出的相关设置

log4j.appender.console = org.apache.log4j.ConsoleAppender

log4j.appender.console.Target = System.out

log4j.appender.console.Threshold=DEBUG

log4j.appender.console.layout = org.apache.log4j.PatternLayout

log4j.appender.console.layout.ConversionPattern=【%c】-%m%n



#文件输出的相关设置

log4j.appender.file = org.apache.log4j.RollingFileAppender

log4j.appender.file.File=./log/kuang.log

log4j.appender.file.MaxFileSize=10mb

log4j.appender.file.Threshold=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.PreparedStatement=DEBUG

在要使用Log4j的类中，导入包 import org.apache.log4j.Logger;
日志对象，参数设置为当前类的class
日志级别:INFO|DEBUG|ERROR

4.6 其他配置

typeHandlers（类型处理器）
objectFactory（对象工厂）
plugins（插件）
- mybatis-generator 自动生成MyBatis代码
- mybatis-plus 可以提高mybatis的效率
- PageHelper MyBatis分页插件
- 通用mapper

5、XML 映射器

MyBatis 的真正强大在于它的语句映射，这是它的魔力所在。

SQL 映射文件只有很少的几个顶级元素（按照应被定义的顺序列出）

cache – 该命名空间的缓存配置。
cache-ref – 引用其它命名空间的缓存配置。
resultMap – 描述如何从数据库结果集中加载对象，是最复杂也是最强大的元素。
sql – 可被其它语句引用的可重用语句块。
insert – 映射插入语句。
update – 映射更新语句。
delete – 映射删除语句。
select – 映射查询语句。

增删改需要提交事务

5.1 模糊查询

java代码执行的时候，传递通配符%
在SQL拼接中使用通配符

5.2 字符串替换

默认情况下，使用 #{} 参数语法时，MyBatis 会创建 PreparedStatement 参数占位符，并通过占位符安全地设置参数（就像使用 ? 一样）
#{}可以防止SQL注入
使用${}参数语法时，MyBatis 就不会修改或转义该字符串了
- 用这种方式接受用户的输入，并用作语句参数是不安全的，会导致潜在的 SQL 注入攻击。
- 因此，要么不允许用户输入这些字段，要么自行转义并检验这些参数。

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

别名：查询SQL中使用别名
结果集映射：resultMap
- resultMap 元素是 MyBatis 中最重要最强大的元素
- ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了
- ResultMap 的优秀之处——你完全可以不用显式地配置它们

如果这个世界总是这么简单就好了

5.4 分页

为什么要分页 - 减少数据的处理量

使用Limit分页

select * from user limit startIndex,pageSize;

使用mybatis实现分页，核心是SQL
使用RowBounds分页，不在使用SQL实现分页（了解即可，不推荐使用）
分页插件
- Mybatis-PageHelper

5.5 高级结果映射

5.5.1 多对一处理

对象：association - 关联【多对一】
按照查询嵌套处理
按结果嵌套处理
MySQL多对一查询方式
- 子查询
- 联表查询
JavaType：用来指定实体类中属性的类型
ofType：用来指定映射到List或者集合中的POJO类型，泛型中的约束类型

5.5.2 练习

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.IOException;
import java.io.InputStream;

public class MybatisUtil {

    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 getSession() {
        // 打开事务自动提交
        return sqlSessionFactory.openSession(true);
        // 事务不会自动提交
//        return sqlSessionFactory.openSession();
    }
}

配置文件

<?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="properties/db.properties"/>

    <settings>
        <!--设置日志-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

    <typeAliases>
        <typeAlias type="com.ghost.mybatis.pojo.Teacher" alias="Teacher" />
        <typeAlias type="com.ghost.mybatis.pojo.Student" alias="Student" />
    </typeAliases>

    <!--设置数据连接-->
    <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="mapper/StudentMapper.xml"/>
        <mapper resource="mapper/TeacherMapper.xml"/>
    </mappers>
</configuration>

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://192.168.50.129:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
username=mybatis
password=123456

实体类

import lombok.Data;

@Data
public class Student {

    private int id;

    private String name;

    private Teacher teacher;
}

import lombok.Data;

@Data
public class Teacher {

    private int id;

    private String name;
}

Mapper接口

import com.ghost.mybatis.pojo.Student;

import java.util.List;

public interface StudentMapper {

    List<Student> selectStudentInNestedQuery();

    List<Student> selectStudentInResultsTheNested();
}

import com.ghost.mybatis.pojo.Teacher;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

public interface TeacherMapper {

}

Mapper.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ghost.mybatis.mapper.StudentMapper">

    <!-- 子查询方式 -->
    <select id="selectStudentInNestedQuery" resultMap="StudentInNestedQuery">
        select *
        from mybatis.student
    </select>

    <!-- 子查询方式结果集 -->
    <resultMap id="StudentInNestedQuery" type="Student">
        <association property="teacher" column="tid" javaType="Teacher" select="selectTeacher"/>
    </resultMap>

    <!-- 子查询方式 - 子查询方法 -->
    <select id="selectTeacher" parameterType="int" resultType="Teacher">
        select *
        from mybatis.teacher
        where id = #{tid}
    </select>

    <!-- 结果集查询方式 -->
    <select id="selectStudentInResultsTheNested" resultMap="StudentInResultsTheNested">
        select s.id sid, s.name sname, t.id tid, t.name tname
        from mybatis.student s,
             mybatis.teacher t
        where s.tid = t.id
    </select>

    <!-- 结果集查询方式结果集 -->
    <resultMap id="StudentInResultsTheNested" type="Student">
        <id property="id" column="sid"/>
        <result property="name" column="sname"/>
        <association property="teacher" javaType="Teacher">
            <id property="id" column="tid"/>
            <result property="name" column="tname"/>
        </association>
    </resultMap>
</mapper>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ghost.mybatis.mapper.TeacherMapper">

</mapper>

测试类

import com.ghost.mybatis.mapper.StudentMapper;
import com.ghost.mybatis.mapper.TeacherMapper;
import com.ghost.mybatis.pojo.Student;
import com.ghost.mybatis.pojo.Teacher;
import com.ghost.mybatis.utils.MybatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class MyTest {

    /*
    联合查询
     */
    @Test
    public void selectStudentInNestedQuery() {
        SqlSession sqlSession = MybatisUtil.getSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List<Student> students = mapper.selectStudentInNestedQuery();
        for (Student student : students) {
            System.out.println(student);
        }
        sqlSession.close();
    }

    /*
    结果集查询方式
     */
    @Test
    public void selectStudentInResultsTheNested() {
        SqlSession sqlSession = MybatisUtil.getSession();
        StudentMapper mapper = sqlSession.getMapper(StudentMapper.class);
        List<Student> students = mapper.selectStudentInResultsTheNested();
        for (Student student : students) {
            System.out.println(student);
        }
        sqlSession.close();
    }
}

5.5.3 一对多处理

集合：collection - 集合【一对多】
按照查询嵌套处理
按结果嵌套处理

5.5.4 练习

mybatis工具类和配置文件与“多对一查询”一样
实体类

import lombok.Data;

@Data
public class Student {

    private int id;

    private String name;

    private int tid;
}

import lombok.Data;

import java.util.List;

@Data
public class Teacher {

    private int id;

    private String name;

    List<Student> studentList;
}

Mapper接口

public interface StudentMapper {

}

import com.ghost.mybatis.pojo.Teacher;
import org.apache.ibatis.annotations.Param;
import org.apache.ibatis.annotations.Select;

import java.util.List;

public interface TeacherMapper {

    @Select("select * from teacher where id = #{tid}")
    Teacher selectTeacherById(@Param("tid") int id);

    List<Teacher> selectTeacherInNestedQuery();

    List<Teacher> selectTeacherInResultsTheNested();
}

Mapper.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ghost.mybatis.mapper.StudentMapper">

</mapper>

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ghost.mybatis.mapper.TeacherMapper">

    <select id="selectTeacherInNestedQuery" resultMap="TeacherInNestedQueryMap">
        select *
        from mybatis.teacher
    </select>

    <resultMap id="TeacherInNestedQueryMap" type="Teacher">
        <collection property="studentList" ofType="Student" select="selectStudent" column="id">
            <id property="id" column="id"/>
            <result property="name" column="name"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>

    <select id="selectStudent" parameterType="int" resultType="Student">
        select *
        from mybatis.student
        where tid = #{id}
    </select>

    <select id="selectTeacherInResultsTheNested" resultMap="TeacherInResultsTheNested">
        select t.id, t.name tname, s.id sid, s.name sname, s.tid
        from mybatis.teacher t,
             mybatis.student s
        where t.id = s.tid
    </select>

    <resultMap id="TeacherInResultsTheNested" type="Teacher">
        <id property="id" column="id"/>
        <result property="name" column="tname"/>
        <collection property="studentList" ofType="Student">
            <id property="id" column="sid"/>
            <result property="name" column="sname"/>
            <result property="tid" column="tid"/>
        </collection>
    </resultMap>
</mapper>

测试类

import com.ghost.mybatis.mapper.TeacherMapper;
import com.ghost.mybatis.pojo.Teacher;
import com.ghost.mybatis.utils.MyBatisUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class MyTest {

    @Test
    public void selectTeacherById() {
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        Teacher teacher = mapper.selectTeacherById(1);
        System.out.println(teacher);
        sqlSession.close();
    }

    @Test
    public void selectTeacherInNestedQuery() {
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        List<Teacher> teachers = mapper.selectTeacherInNestedQuery();
        for (Teacher teacher : teachers) {
            System.out.println(teacher);
        }
        sqlSession.close();
    }

    @Test
    public void selectTeacherInResultsTheNested() {
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);
        List<Teacher> teachers = mapper.selectTeacherInResultsTheNested();
        for (Teacher teacher : teachers) {
            System.out.println(teacher);
        }
        sqlSession.close();
    }
}

5.5.5 注意点

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

6、使用注解开发

6.1 面向接口编程

什么是面向接口编程
- 根本原因：解耦
- 关于接口的理解
  - 接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离。
  - 接口的本身反映了系统设计人员对系统的抽象理解。
  - 接口应有两类：第一类是对一个个体的抽象，它可对应为一个抽象体(abstract class)；第二类是对一个个体某一方面的抽象，即形成一个抽象面（interface）
  - 一个体有可能有多个抽象面；抽象体与抽象面是有区别的
- 接口是一种规范和约束，更高层的抽象更像是一类行为，面向接口编程只是代码层体现的一种格式体现而已，真正的面向接口设计更贴近面向行为编程
三个面向区别
- 面向对象是指，我们考虑问题时，以对象为单位，考虑它的属性及方法
- 面向过程是指，我们考虑问题时，以一个具体的流程（事务过程）为单位，考虑它的实现 .
- 接口设计与非接口设计是针对复用技术而言的，与面向对象（过程）不是一个问题.更多的体现就是对系统整体的架构
面向接口编程的优点
- 解耦
- 可扩展性高
- 提高复用
- 分层开发中，上层不用管具体的实现，大家都遵守共同的标准，使得开发变得容易，规范性更好
- 符合“开放-关闭原则”（对扩展开放，对修改关闭）

6.2 使用注解开发

本质：反射机制实现
底层：动态代理
注解在接口上实现
需要在核心配置文件中绑定接口

6.3 MyBatis详细执行过程

6.4 关于@Param()注解

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

7、Lombok

7.1 使用步骤

在IDEA安装lombok插件
在项目中导入lombok的jar包（最好使用高版本，低版本的有时会出现“com.sun.tools.javac.code.TypeTags”错误）
在实体类加注解即可

7.2 部分注解

@Data
- 无参构造器
- getter
- setter
- toString
- hashcode
- equals
@AllArgsConstructor - 全参构造器
@NoArgsConstructor - 无参构造器
pom文件导入

	<dependencies>
        <!-- https://mvnrepository.com/artifact/org.projectlombok/lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.16</version>
        </dependency>
    </dependencies>

8、动态SQL

8.1 什么是动态SQL

动态SQL就是指根据不同的条件生成不同的SQL语句；

所谓的动态SQL，本质还是SQL语句，只是我们可以在SQL层面，去执行一个逻辑代码；

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

首先要写原生的 sql 语句出来，然后在通过 mybatis 动态sql 对照着改，防止出错

8.2 IF

8.3 choose、when、otherwise

不想使用所有的条件，而只是想从多个条件中选择一个使用
针对这种情况，MyBatis 提供了 choose 元素，它有点像 Java 中的 switch 语句

8.4 trim、where、set

where
- 若子句的开头为 “AND” 或 “OR”，where 元素也会将它们去除
- where 元素只会在子元素返回任何内容的情况下才插入 “WHERE” 子句
set
- 用于动态更新语句的类似解决方案叫做 set
- set 元素可以用于动态包含需要更新的列，忽略其它不更新的列
- set 元素会动态地在行首插入 SET 关键字，并会删掉额外的逗号
trim
- prefixOverrides 属性会忽略通过管道符分隔的文本序列
- 插入 prefix 属性中指定的内容（前缀值）
- suffixOverrides（后缀值）

8.5 SQL片段

有的时候我们会将一些功能抽取出来方便复用
sql标签 - 公共SQL语句
include标签 - 引入公共SQL片段
注意事项
- 最好基于单表来定义SQL片段
- 不要存在where标签

8.6 foreach

foreach 元素的功能非常强大，它允许你指定一个集合，声明可以在元素体内使用的集合项（item）和索引（index）变量
它也允许你指定开头与结尾的字符串以及集合项迭代之间的分隔符

8.7 练习

创建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.IOException;
import java.io.InputStream;

public class MyBatisUtil {

    private static SqlSessionFactory sqlSessionFactory;

    static {
        String resource = "mybatis-config.xml";
        InputStream inputStream = null;
        try {
            inputStream = Resources.getResourceAsStream(resource);
        } catch (IOException e) {
            e.printStackTrace();
        }
        sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    }

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

创建UUID工具类

import java.util.UUID;

public class UUIDUtil {

    public static String getUUID() {
        return UUID.randomUUID().toString().replace("-", "");
    }
}

创建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>
    <!--引入外部properties文件-->
    <properties resource="properties/db.properties"/>

    <settings>
        <!--开启驼峰命名自动映射，即从经典数据库列名 A_COLUMN 映射到经典 Java 属性名 aColumn-->
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        <!--开启日志-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

    <typeAliases>
        <!--别名-->
        <typeAlias type="com.ghost.mybatis.pojo.Book" alias="Book"/>
    </typeAliases>

    <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/ghost/mybatis/mapper/BookMapper.xml"/>
    </mappers>
</configuration>

创建数据库配置文件

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://192.168.50.129:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8&serverTimezone=Asia/Shanghai
username=mybatis
password=123456

新建Book表

create table book
(
	id varchar(32) not null
		primary key,
	book_name varchar(100) null,
	author varchar(50) null,
	publication_time datetime default CURRENT_TIMESTAMP not null
);

创建实体类

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

import java.util.Date;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class Book {

    public Book(String id, String bookName, String author) {
        this.id = id;
        this.bookName = bookName;
        this.author = author;
    }

    private String id;

    private String bookName;

    private String author;

    private Date publicationTime;
}

创建Mapper接口

import com.ghost.mybatis.pojo.Book;
import org.apache.ibatis.annotations.Insert;

import java.util.List;

public interface BookMapper {

    @Insert("insert into book(id, book_name, author) values (#{id}, #{bookName}, #{author})")
    int addBook(Book book);

    List<Book> selectBook(Book book);

    List<Book> selectBookByChoose(Book book);

    int updateBook(Book book);
}

创建Mapper.xml文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.ghost.mybatis.mapper.BookMapper">

    <sql id="selectSQL" >
        <if test="id != null">
            id = #{id}
        </if>
        <if test="author != null">
            and author = #{author}
        </if>
        <if test="bookName != null">
            and book_name = #{bookName}
        </if>
    </sql>

    <select id="selectBook" parameterType="Book" resultType="Book">
        select * from mybatis.book
        <trim prefix="where" prefixOverrides="and | or">
            <include refid="selectSQL"></include>
        </trim>
    </select>

    <select id="selectBookByChoose" parameterType="Book" resultType="Book">
        select * from mybatis.book
        <where>
            <choose>
                <when test="id != null">
                    id = #{id}
                </when>
                <when test="author != null">
                    and author = #{author}
                </when>
                <otherwise>
                    and book_name = "测试书籍"
                </otherwise>
            </choose>
        </where>
    </select>

    <update id="updateBook" parameterType="Book">
        update mybatis.book
        <set>
            <if test="author != null">author = #{author},</if>
            <if test="bookName != null">book_name = #{bookName},</if>
        </set>
        where id = #{id}
    </update>

</mapper>

创建测试类

import com.ghost.mybatis.mapper.BookMapper;
import com.ghost.mybatis.pojo.Book;
import com.ghost.mybatis.utils.MyBatisUtil;
import com.ghost.mybatis.utils.UUIDUtil;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class MyTest {

    @Test
    public void getUUID() {
        System.out.println(UUIDUtil.getUUID());
    }

    @Test
    public void addBook() {
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        BookMapper mapper = sqlSession.getMapper(BookMapper.class);
        mapper.addBook(new Book(UUIDUtil.getUUID(), "测试书籍1", "ghost"));
        mapper.addBook(new Book(UUIDUtil.getUUID(), "测试书籍2", "ghost"));
        mapper.addBook(new Book(UUIDUtil.getUUID(), "测试书籍3", "ghost"));
        mapper.addBook(new Book(UUIDUtil.getUUID(), "测试书籍4", "ghost"));
        mapper.addBook(new Book(UUIDUtil.getUUID(), "测试书籍5", "ghost"));
        sqlSession.close();
    }

    @Test
    public void selectBook() {
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        BookMapper mapper = sqlSession.getMapper(BookMapper.class);
        try {
            Book book = new Book();
            List<Book> books = mapper.selectBook(book);
            for (Book book1 : books) {
                System.out.println(book1);
            }
        } finally {
            sqlSession.close();
        }
    }

    @Test
    public void selectBookByChoose() {
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        BookMapper mapper = sqlSession.getMapper(BookMapper.class);
        Book book = new Book();
        book.setId("0cfd6fb6aa414df7b1483f66d0862b40");
        List<Book> books = mapper.selectBookByChoose(book);
        for (Book book1 : books) {
            System.out.println(book1);
        }
        sqlSession.close();
    }

    @Test
    public void updateBook() {
        SqlSession sqlSession = MyBatisUtil.getSqlSession();
        BookMapper mapper = sqlSession.getMapper(BookMapper.class);
        mapper.updateBook(new Book("9e07c2afff7b471186116a99355ce965", "测试修改书籍", "ghost"));
        sqlSession.close();
    }
}

9、缓存

数据库优化：读写分离、主从复制

9.1 什么是缓存【Cache】

存在内存中的临时数据
将用户经常查询的数据放在缓存（内存）中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题

9.2 为什么使用缓存

减少和数据库的交互次数
减少系统开销
提高系统效率

9.3 什么样的数据能够使用缓存

经常查询并且不经常改变的数据

9.4 MyBatis缓存

MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率
MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存
默认情况下，只有一级缓存开启。（SqlSession级别的缓存，也称为本地缓存）
二级缓存需要手动开启和配置，他是基于namespace级别的缓存
为了提高扩展性，MyBatis定义了缓存接口Cache。我们可以通过实现Cache接口来自定义二级缓存

9.5 一级缓存

一级缓存也叫本地缓存
- 与数据库同一次会话期间查询到的数据会放在本地缓存中
- 以后如果需要获取相同的数据，直接从缓存中拿，没必须再去查询数据库
一级缓存是SqlSession级别的缓存，是一直开启的，我们关闭不了它
一级缓存失效情况：没有使用到当前的一级缓存，效果就是，还需要再向数据库中发起一次查询请求
一级缓存失效的四种情况
- sqlSession不同（每个sqlSession中的缓存相互独立）
- sqlSession相同，查询条件不同（当前缓存中，不存在这个数据）
- sqlSession相同，两次查询之间执行了增删改操作（因为增删改操作可能会对当前数据产生影响）
- sqlSession相同，手动清除一级缓存（一级缓存就是一个map）

9.6 二级缓存

二级缓存也叫全局缓存，一级缓存作用域太低了，所以诞生了二级缓存
基于namespace级别的缓存，一个名称空间，对应一个二级缓存
工作机制
- 一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中
- 如果当前会话关闭了，这个会话对应的一级缓存就没了；但是我们想要的是，会话关闭了，一级缓存中的数据被保存到二级缓存中
- 新的会话查询信息，就可以从二级缓存中获取内容
- 不同的mapper查出的数据会放在自己对应的缓存（map）中
使用步骤
- 开启全局缓存【mybatis-config.xml】
```
<setting name="cacheEnabled" value="true"/>
```
- 去每个mapper.xml中配置使用二级缓存，这个配置非常简单；【xxxMapper.xml】
```
<cache
  eviction="FIFO"
  flushInterval="60000"
  size="512"
  readOnly="true"/>
```
需要将实体类序列化

9.7 MyBatis一级缓存和二级缓存总结

只要开启了二级缓存，我们在同一个Mapper中的查询，可以在二级缓存中拿到数据
查出的数据都会被默认先放在一级缓存中
查出的数据都会被默认先放在一级缓存中

9.8 其他缓存

自定义缓存 - EhCache
Redis

Ghost-programmer

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
MyBatis学习

1、什么是MyBatisMyBatis是一款优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录MyBatis 是一个半自动化的ORM框架 (Object Relationship Mapping) -->对象关系映射MyB
复制链接

扫一扫