Joseph_JL

MyBatis完整笔记（搭建环境CURD、配置解析、单表结果集映射多表查询一对多多对一、日志分页使用注解开发、动态SQL、mybatis缓存）

MyBatis

SSM框架

环境：

JDK1.8
Mysql 5.7 或者升版本
maven3.6.1或者升版本
IDEA

回顾：

JDBC
Mysql
Java基础
Maven
Junit

**框架：**配置文件的。学习框架最好的方式：看官方文档；

**Mybatis3官方开发文档：**https://mybatis.org/mybatis-3/zh/getting-started.html

1.简介

1.1 什么是MyBatis

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

MyBatis 本是apache的一个开源项目iBatis, 2010年这个项目由apache software foundation 迁移到了[google code](https://baike.baidu.com/item/google code/2346604)，并且改名为MyBatis 。2013年11月迁移到Github。
iBATIS一词来源于“internet”和“abatis”的组合，是一个基于Java的持久层框架。iBATIS提供的持久层框架包括SQL Maps和Data Access Objects（DAOs）

获取方式：

gitHub搜索下载 https://github.com/mybatis/mybatis-3/releases
Maven仓库 https://mvnrepository.com/search?q=mybatis


<dependency>
    <groupId>org.mybatisgroupId>
    <artifactId>mybatisartifactId>
    <version>3.5.6version>
dependency>

1.2 持久化

持久化是一个动作

数据持久化

持久化就是

将程序的数据在持久状态和瞬时状态转化的过程。
内存：断电即失
持久化方式：数据库（jdbc）,io文件持久化。
生活：冷藏罐头

为什么需要持久化

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

1.3 持久层

持久层是一个概念

Dao层，Service层， Controller层…

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

1.4 为什么需要Mybatis？

帮助程序员将数据存入到数据库中
方便
传统的JDBC代码太复杂了。简化，框架。自动化
不用Mybatis也可以，更容易上手。
优点：
- 简单易学
- 灵活
- 解除sql与程序代码的耦合
- 提供映射标签，支持对象与数据库的orm字段关系映射
- 提供对象关系映射标签，支持对象关系组建维护
- 提供xml标签，支持编写动态sql。

最重要的一点：是用的人多，Spring SpringMVC SpringBoot

2.第一个Mybatis程序

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

项目结构：

2.1 搭建环境

创建数据库和表：

CREATE DATABASE `mybatis`
USE mybatis

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

INSERT INTO `user`(`name`,`pwd`)VALUES
('狂神','123456'),
('张三','123456'),
('李四','123456');

新建项目：

1.新建一个普通的maven项目

2.删除src目录，便于后面创建子模块

3.导入maven依赖

导入mysql、mabatis、junit包

在build中配置resources，来防止我们资源导出的失败的问题

在父工程的pom.xml中


<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>

    <properties>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    properties>

    
    <groupId>org.examplegroupId>
    <artifactId>mybatisartifactId>
    <packaging>pompackaging>
    <version>1.0-SNAPSHOTversion>
    <modules>
        <module>simpleDemomodule>
    modules>

    <dependencies>
    
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>5.1.47version>
        dependency>
    
        <dependency>
            <groupId>org.mybatisgroupId>
            <artifactId>mybatisartifactId>
            <version>3.5.3version>
        dependency>
    
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.13version>
        dependency>
    dependencies>

    
    <build>
        <resources>
            <resource>
                <directory>src/main/resourcesdirectory>
                <includes>
                    <include>**/*.propertiesinclude>
                    <include>**/*.xmlinclude>
                includes>
                <filtering>truefiltering>
            resource>
            <resource>
                <directory>src/main/javadirectory>
                <includes>
                    <include>**/*.propertiesinclude>
                    <include>**/*.xmlinclude>
                includes>
                <filtering>truefiltering>
            resource>
        resources>
    build>


project>

2.2 创建一个子模块

（1）编写Mybatis的核心配置文件

在resources目录下创建mybatis-config.xml




<configuration>
    <environments default="development">
        <environment id="development">
            <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="com.mysql.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8"/>
                <property name="username" value="root"/>
                <property name="password" value="123456"/>
            dataSource>
        environment>
    environments>

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

configuration>

（2）编写Mybatis工具类

获取SqlSession对象（相当于connection对象），封装成工具类。

在utils包下建立工具类MybatisUtils

package com.kuang.utils;

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;

//工具类
//需要获得数据库操作对象SqlSession
//SqlSessionFactory---->SqlSession
public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;//提升作用域

    static {
        //使用Mybatis的第一步：获取SqlSessionFactory对象
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream =Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //有了SqlSessionFactory以后，我们可以从中获得SqlSession的实例
    //SqlSession提供了在数据库执行 SQL命令 所需的所有方法。
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

（3）创建实体类

在pojo包下面创建实体类User

package com.kuang.pojo;

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 void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

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

    public String getPwd() {
        return pwd;
    }

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

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

（4）dao层：UserDao接口和UserMapper.xml

持久层操作数据库执行sql

UserDao接口，UserMapper.xml采用配置文件形式替换以前的UserDaoImpl实现类实现操作数据库

UserDao接口：

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

UserMapper.xml:






<mapper namespace="com.kuang.dao.UserDao">
    <select id="getUserList" resultType="com.kuang.pojo.User">
        select * from `user`;
    select>
mapper>

（5）测试

在test目录下建立对应的dao包：test/com.kuang.dao

再建立UserDaoTest类添加测试方法

1.先获取SqlSession对象

2.利用SqlSession调用Mapper得到UserDao对象

3.操作数据库，返回与实体类对应的结果

package com.kuang.dao;

import com.kuang.pojo.User;
import com.kuang.utils.MybatisUtils;
import org.apache.ibatis.session.SqlSession;
import org.junit.Test;

import java.util.List;

public class UserDaoTest {
    @Test
    public void test(){
        //获取SqlSession对象
        SqlSession sqlSession= MybatisUtils.getSqlSession();

        //操作数据库 方式一：getMapper 推荐使用
        UserDao userDao = sqlSession.getMapper(UserDao.class);
        List<User> userList = userDao.getUserList();

        for (User user : userList) {
            System.out.println(user);
        }

        //关闭SqlSession
        sqlSession.close();
    }
}

2.3 可能会遇到的问题

1.配置文件getUserMapper.xml没有注册

每一个Mapper.xml都需要在Mybatis核心配置文件mybatis-config.xml中注册

注册的资源路径，采用斜杠，而不是点分隔



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

2.Maven导出资源问题，先放到外层pom.xml，如果没生效，子模块的pom.xml再放一次


<build>
    <resources>
        <resource>
            <directory>src/main/resourcesdirectory>
            <includes>
                <include>**/*.propertiesinclude>
                <include>**/*.xmlinclude>
            includes>
            <filtering>truefiltering>
        resource>
        <resource>
            <directory>src/main/javadirectory>
            <includes>
                <include>**/*.propertiesinclude>
                <include>**/*.xmlinclude>
            includes>
            <filtering>truefiltering>
        resource>
    resources>
build>

3.注意Mapper.xml文件中：绑定接口、方法名、返回类型

错误：

Cause: com.sun.org.apache.xerces.internal.impl.io.MalformedByteSequenceExcep

解决方法：之前在pom.xml文件中删除了下面代码，现在加上：

<properties>
    <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
properties>

2.4 运行思路

连接数据库，导入jar包（mysql、mabatis、junit、此处还可以配置好maven的资源导出问题build)
操作数据库需要一个SqlSession对象，为此建造了一个工具类utils/MybatisUtils，编写了配置文件mybatis-config.xml（配置文件一上来连接了数据库，仅需修改选项参数；删除mapper.xml的注册配置）
创建实体类User
创建接口UserDao，并创建getUserList()抽象方法
写Mapper配置文件UserMapper.xml，代替原来实现类Impl：namespace绑定接口，标签id绑定接口方法，标签体专注sql，返回类型专注返回值类型；每一个mapper写完需要到mabatis-config.xml中去注册

3.CURD

namespace：

Mapper.xml中使用的namespace中分包名，要和Dao/Mapper接口中的包名一致。

过程：

完成MyBatis的实现后，操作数据库：

所有的操作只和“接口”和“配置文件”有关
实体类、工具类、mybatis.config.xml不在需要改变
mapper.xml只需要去mybatis.config.xml中配置一次，mapper.xml中只需要有一个

dao层：

UserMapper接口（从UserDao改名为UserMapper）

UserMapper配置文件（相当于实体类UserMapperImpl）

Mapper.xml元素概念

id: 就是对应的nsmespace中的方法名
resultType: Sql语句执行的返回值
parameterType: 参数类型

步骤：

3.1编写接口

在UserMapper中

public interface UserMapper {
    
    //根据id查询用户
    User getUserById(int id);

    //insert用户
    int insertUser(User user);

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

    //删除用户
    int deleteUserById(int id);

}

3.2编写对应的mapper.xml中的sql语句

在UserMapper.xml中






<mapper namespace="com.kuang.dao.UserMapper">
    
    <select id="getUserById" parameterType="int" resultType="com.kuang.pojo.User">
        select * from `user` where `id`=#{id};
    select>

    
    <insert id="insertUser" parameterType="com.kuang.pojo.User">
        insert into `user`(`name`,`pwd`) values ('zhaoliu','zhao123456');
    insert>

    
    <update id="updateUser" parameterType="com.kuang.pojo.User">
        update `user` set `name`=#{name},`pwd`=#{pwd} where id=#{id};
    update>

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

3.3测试

在UserMapperTest中

public class UserMapperTest {

    //根据id查找用户
    @Test
    public void getUserById() {
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class); //相当于获得实现类对象
        User user = mapper.getUserById(1);

        System.out.println(user);

        sqlSession.close();

    }
    
    //插入用户
    @Test
    public void insertUser(){
        SqlSession sqlSession=MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        int i = mapper.insertUser(new User(0, "liu", "liu123"));
        if(i>0){
            System.out.println("插入成功");
        }

        //【关键】Mybatis中增删改查，需要提交事务才能生效
        sqlSession.commit();

        sqlSession.close();
    }

    //修改用户
    @Test
    public void updateUser(){
        SqlSession sqlSession=MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        int i = mapper.updateUser(new User(1, "liu", "liu123"));
        if(i>0){
            System.out.println("修改成功");
        }

        //【关键】Mybatis中增删改查，需要提交事务才能生效
        sqlSession.commit();

        sqlSession.close();
    }

    //删除用户
    @Test
    public void deleteUserById(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        UserMapper mapper = sqlSession.getMapper(UserMapper.class);

        int i = mapper.deleteUserById(4);
        if(i>0){
            System.out.println("删除成功");
        }

        //【关键】Mybatis中增删改查，需要提交事务才能生效
        sqlSession.commit();

        sqlSession.close();
    }
}

在Mapper.xml中，对象中的属性，可以直接取出来，与实体类对应

Mybatis增删改必须提交事务才能生效

注意SqlSession对象使用完后关闭

3.4遇到的问题

Mapper.xml的curd标签不要匹配错
Mapper.xml需要到resource中的mybatis-config.xml中注册，路径要用‘/’，前面的命名空间使用的是包名 ‘.’
```
<mappers>
    <mapper resource="com/kuang/dao/UserMapper.xml"/>
mappers>
```
程序配置文件mybatis-config.xml必须符合规范

NullPointerException，没有注册到资源，MybatisUtils中提升作用域内外定义变量sqlSessionFactory

public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;//提升作用域

    static {
        //使用Mybatis的第一步：获取SqlSessionFactory对象
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream =Resources.getResourceAsStream(resource);
            SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //有了SqlSessionFactory以后，我们可以从中获得SqlSession的实例
    //SqlSession提供了在数据库执行 SQL命令 所需的所有方法。
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

输出的xml文件如果存在乱码，删除即可
maven资源导出问题，pom.xml中加

3.5万能的Map

Mapper.xml中参数类型如果为实体类，在测试时需要初始化所有字段，传递整个实体类对象；如果sql操作只需要少量字段，则不合适；
实体类中的字段名和参数中字段名必须一致。

在接口方法中，参数直接传递实体类User；

//insert用户
int insertUser(User user);

编写sql语句的时候，需要传递参数类型，参数类型为实体类"com.kuang.pojo.User"



<insert id="insertUser" parameterType="com.kuang.pojo.User">
    insert into `user`(`name`,`pwd`) values (#{name},#{pwd});
insert>

在使用方法的时候，需要创建实体类User对象，赋值所有属性

使用实体类：test中传入的“对象中的属性”必须和“数据库表中字段名”对应

//插入用户
@Test
public void insertUser(){
    SqlSession sqlSession=MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    int i = mapper.insertUser(new User(0, "田七1", "tian123456"));
    if(i>0){
        System.out.println("插入成功");
    }

    //【关键】Mybatis中增删改查，需要提交事务才能生效
    sqlSession.commit();

    sqlSession.close();
}

考虑用map作为参数，map中的key值也可以自定义，只需要在测试类中定义相应的key值。

在接口方法中，参数直接传递Map；

//insert用户
int insertUser(User user);

编写sql语句的时候，需要传递参数类型，参数类型为Map



<insert id="insertUser2" parameterType="map">
    insert into `user`(`name`,`pwd`) values (#{username},#{password});
insert>

在使用方法的时候，需要创建实体类User对象，赋值所有属性

使用万能的Map：test中传入的“map的key值”可以自定义，无需和“数据库表中字段名”对应

//插入用户
@Test
public void insertUser2(){
    SqlSession sqlSession=MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    Map<String,Object> map=new HashMap<>();
    map.put("username","田七");
    map.put("password","tian123456");
    int i = mapper.insertUser2(map);
    if(i>0){
        System.out.println("插入成功");
    }

    //【关键】Mybatis中增删改查，需要提交事务才能生效
    sqlSession.commit();

    sqlSession.close();
}

传递参数类型：

对象传递参数：直接在sql中取出对象的属性（实体类定义时属性和数据库表字段名一一对应）【parameterType=“Object”】
Map传递参数：直接在sql中取出key即可，map的key值无需和数据库表字段名一致，【parameterType=“map”】
传递参数类型只有一个，且为基本类型，如int，可省略不写，直接在sql中取到。

多个参数用map，或者注解

返回结果类型：当为实体类对象时需要写，当为int时可省略。

3.6模糊查询

1.test中传递的字符串采用拼接，传递通配符%

容易造成sql注入，用户传入的值一般我们要求只能为值，不能拼接字符串

 List<User> userList = mapper.getUserLike("%李%");

2.在Mapper.xml的sql中拼接，使用通配符，推荐

select * from `user` where name like "%"#{name}"%"

4.配置解析

核心配置文件mybatis-config.xml

【注意】在mybatis-config.xml的标签中，所有配置标签有顺序

4.1环境配置（enviroments）

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

事务管理器（transactionManager）

在 MyBatis 中有两种类型的事务管理器（也就是 type="[JDBC|MANAGED]"）：

JDBC – 这个配置直接使用了 JDBC 的提交和回滚设施，它依赖从数据源获得的连接来管理事务作用域。
MANAGED – 这个配置几乎没做什么。它从不提交或回滚一个连接，而是让容器来管理事务的整个生命周期（比如 JEE 应用服务器的上下文）。默认情况下它会关闭连接。然而一些容器并不希望连接被关闭，因此需要将 closeConnection 属性设置为 false 来阻止默认的关闭行为。

数据源（dataSource）

是否使用连接池

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

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

4.2属性（properties）

我们可以通过properties属性来实现引用配置文件。

mybatis-config.xml使用到的属性可以在外部进行配置，并可以进行动态替换:

既可以在典型的 Java 属性文件中配置这些属性【db.properties】

db.properties

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8
username=root
password=123456

mybatis-config.xml中引入配置文件并使用

<properties resource="db.properties"/>

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

也可以在 properties 元素的子元素中设置
```
     
    
```

mybatis-config.xml的属性配置：

可以直接配置
可以全部放到db.properties中，再在mybatis-config.xml中引用
可以部分放到db.properties中，mybatis-config.xml中可以动态增加属性（如果两个文件有同一个字段，优先使用外部配置文件。properties里面的属性优先）

4.3类型别名（typeAliases）

类型别名可为 Java 类型设置一个缩写名字。
它仅用于 XML 配置，意在降低冗余的全限定类名书写
常用于在mybatis-config.xml中，为实体类起别名，简化在Mapper.xml中对实体类引用包名的书写

（1）为具体实体类指定类型别名

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

在Mapper.xml中使用

<select id="getUserList" parameterType="map" resultType="User">
    select * from `user` where `name` like "%"#{name}"%";
select>

（2）指定一个包名

MyBatis会在包名下面搜索需要的实体类（JavaBean）

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

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

在Mapper.xml中使用

<select id="getUserList" parameterType="map" resultType="user">
    select * from `user` where `name` like "%"#{name}"%";
select>

（3）自定义类型别名

为具体实体类指定类型别名，可以自定义包名
指定一个包名，别名默认类名，且首字母小写。但可以通过在实体类上增加注解自定义包名
```
//实体类
@Alias("user")
public class User {
    ...
}
```

4.4映射器（mapper）

MapperRegistry：每一个Mapper.xml都需要到mybatis-config.xml中的中去配置

配置方法：

1.使用resource绑定注册

注意路径采用反斜杠分隔

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

2.使用class文件绑定注册

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

注意点：

接口和他的Mapper配置文件必须同名！
接口和他的Mapper配置文件必须在同一个包下！（方式一Mapper.xml随便放）

3.使用扫描包进行注册绑定

<mappers>
     <package name="com.kuang.dao"/>
mappers>

注意点：

接口和他的Mapper配置文件必须同名！
接口和他的Mapper配置文件必须在同一个包下！（方式一随便放）

4.5设置（enviroments）

这是 MyBatis 中极为重要的调整设置，它们会改变 MyBatis 的运行时行为。

数据库命名与实体类字段转换，需要Mabatis框架的设置支持

4.6其他

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

4.7生命周期和作用域

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

SqlSessionFactoryBuilder:

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

SqlSessionFactory：

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

SqlSession：

连接池的一个请求。
SqlSession 的实例不是线程安全的，因此是不能被共享的，所以它的作用域是请求或方法作用域。
用完之后赶紧关闭，否则资源被占用。

这里的每一个Mapper,就代表一个具体的业务！

5.ResultMap结果集映射

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

5.1 实体类属性和数据库字段不匹配问题

数据库字段：

实体类属性：

public class User {
    private int id;
    private  String name;
    private String password; //字段和属性不一致
}

测试字段不一致问题：

Mapper.xml


<select id="getUserById" parameterType="_int" resultType="com.kuang.pojo.User">
    select * from `user` where `id`=#{id};
select>

查询结果：password属性为null

解决办法：

sql查询字段起别名 pwd as password

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

结果集映射resultMap，属性名和字段名映射

5.2 resultMap

结果集映射

实体类User： id  name  pwd
数据库user表：id  name  password

在Mapper.xml中配置resultMap

<mapper namespace="com.kuang.dao.UserMapper">
    
    
    <resultMap id="UserMap" type="User">
    
    
        <result column="pwd" property="password"/>
    resultMap>
    
    <select id="getUserById"  resultMap="UserMap">
        select * from mybatis.user where id = #{id}
    select>
mapper>

resultMap元素时MyBatis中最重要的最强大的元素。
ResultMap 的设计思想是，对简单的语句做到零配置，对于复杂一点的语句，只需要描述语句之间的关系就行了。
ResultMap 的优秀之处——你完全可以不用显式地配置它们，可以只映射不一致的字段和属性

6.日志

如果一个数据库操作，出现了异常，我们需要排错。日志就是最好的助手。

曾经：sout 、debug

现在：日志工厂

SLF4J
LOG4J 【掌握】
LOG4J2
JDK_LOGGING
COMMONS_LOGGING
STDOUT_LOGGING 【掌握】
NO_LOGGING

在mybatis-config.xml中配置

在Mybatis中具体使用哪一个日志实现，在设置中设定。

6.1.STDOUT_LOGGING标准日志输出

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

【注意】书写日志不要有空格

STDOUT_LOGGING日志只需要配置一下setting，就能使用。

6.2.LOG4J 拓展日志输出

什么是LOG4J：

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

1.先导出log4j的包

<dependency>
    <groupId>log4jgroupId>
    <artifactId>log4jartifactId>
    <version>1.2.17version>
dependency>

2.在resources目录下创建log4j.properties

#将等级为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

3.配置log4j为日志实现

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

4.Log4j的使用，直接测试运行刚才的查询

简单实用：

1.在要使用Log4j的类中，导入包import org.apache.log4j.Logger;

2.日志对象，参数为当前类的class

3.可以设置日志级别

import org.apache.log4j.Logger; //导入包

public class log4j{
    static Logger logger=Logger.getLogger(log4j.class); //获取当前类的反射
    @Test
    public void testLog(){
        logger.info("info：进入selectUser方法");
        logger.debug("debug：进入selectUser方法");
        logger.error("error: 进入selectUser方法");

        SqlSession session= MybatisUtils.getSqlSession();
        UserMapper mapper = session.getMapper(UserMapper.class);
        List<User> userList = mapper.getUserList();

        for (User user : userList) {
            System.out.println(user);
        }

        session.close();
    }
}

7.分页

思考：为什么要分页？

减少数据的处理量

7.1 sql层面limit实现分页

1.接口

//分页查询
List<User> getUserByLimit(Map<String,Integer> map);

2.Mapper.xml



<resultMap id="UserMap" type="User">
    
    
    
    <result column="pwd" property="password"/>
resultMap>


<select id="getUserByLimit" parameterType="map" resultMap="UserMap">
    select * from `user` limit #{startIndex},#{pageSize};
select>

3.测试

//分页查询
@Test
public void getUserByLimit(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(UserMapper.class);

    Map<String,Object> map=new HashMap<>();
    map.put("startIndex",0);
    map.put("pageSize",3);

    List<User> userList = mapper.getUserByLimit(map);
    for (User user : userList) {
        System.out.println(user);
    }

    sqlSession.close();
}

7.2 使用RowBounds实现分页

1.接口

//分页查询
List<User> getUserByRowBounds();

2.Mapper.xml



<resultMap id="UserMap" type="User">
    
    
    
    <result column="pwd" property="password"/>
resultMap>


<select id="getUserByRowBounds" parameterType="map" resultMap="UserMap">
    select * from `user` limit #{startIndex},#{pageSize};
select>

3.测试

//RowBounds分页查询
@Test
public void getUserByRowBounds(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    int currentPage=2; //第几页
    int pageSize=2; //每页显示几个
    RowBounds rowBounds = new RowBounds((currentPage - 1) * pageSize, pageSize);

    List<User> userList = sqlSession.selectList("com.kuang.dao.UserMapper.getUserByRowBounds", null, rowBounds);
    for (User user : userList) {
        System.out.println(user);
    }

    sqlSession.close();
}

7.3 分页插件

MyBatis分页插件 PageHelper

https://pagehelper.github.io/

了解即可，万一以后公司的架构师，说要使用，你需要知道它是什么东西。

8.使用注解开发

8.1面向接口编程

大家之前都学过面向对象编程，也学习过接口，但在真正的开发中，很多时候我们会选择面向接口编程
根本原因 : 解耦 , 可拓展 , 提高复用 , 分层开发中 , 上层不用管具体的实现 , 大家都遵守共同的标准 , 使得开发变得容易 , 规范性更好
在一个面向对象的系统中，系统的各种功能是由许许多多的不同对象协作完成的。在这种情况下，各个对象内部是如何实现自己的,对系统设计人员来讲就不那么重要了；
而各个对象之间的协作关系则成为系统设计的关键。小到不同类之间的通信，大到各模块之间的交互，在系统设计之初都是要着重考虑的，这也是系统设计的主要工作内容。面向接口编程就是指按照这种思想来编程

关于接口的理解：

接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离。
接口从更深层次的理解，应是定义（规范，约束）与实现（名实分离的原则）的分离。
接口应有两类：
- 第一类是对一个个体的抽象，它可对应为一个抽象体（abstract class)
- 第二类是对一个个体某一方面的抽象，即形成一个抽象面（interface）
一个个体可能有多个抽象面，抽象体和抽象面是有区别的。

三个“面向”区别：

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

8.2利用注解开发

mybatis最初配置信息是基于XML，映射语句（SQL）也是定义在XML中的。到Mybatis3提供了新的基于注解的配置。
不幸的是，Java注解的表达力和灵活性十分有限。最强到的MyBatis映射并不能用注解来构建，所以真实项目开发尽量少用
Sql类型主要分成：
- @Select()
- @Update()
- @Insert()
- @Delete()
**利用注解开发，就不需要Mapper.xml映射文件了。**利用在Mapper接口中注解代替 Mapper.xml

1.在我们的接口中直接添加注解

//查询所有用户
@Select("select * from user")
List<User> getUserList();

2.记得每个Mapper都要去mybatis-config.xml核心配置文件中注册

利用mapper.xml时可以采用三种注册方式，利用注解开发只能使用class绑定接口

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

3.测试

//查找所有用户
@Test
public void getUserList() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    List<User> userList = mapper.getUserList();

    for (User user : userList) {
        System.out.println(user);
    }

    sqlSession.close();
}

4.查看Debugben本质

在test中打断点Debug

5.本质上利用了jvm的动态代理机制

6.Mybatis详细执行流程

8.3 采用注解CURD

可以改造MybatisUtils工具类的getSession( ) 方法，开启自动提交；但是实际开发中一般不采用自动提交

public static SqlSession getSession(boolean flag){
	return sqlSessionFactory.openSession(flag);
}

UserMapper接口：

//根据id查询用户
@Select("select * from `user` where id=#{id}")
User selectUserById(@Param("id") int id);

//添加一个用户
@Insert("insert into `user`(id,name,pwd) values(#{id},#{name},#{pwd})")
int addUser(User user);

//修改用户
@Update("update user set name=#{name},pwd=#{pwd} where id=#{id}")
int updateUser(User user);

//删除用户
@Delete("delete from `user` where id=#{id}")
int deleteUser(@Param("id") int id);

测试：

//根据id查询用户
@Test
public void selectUserById() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    User user = mapper.selectUserById(3);

    System.out.println(user);

    sqlSession.close();
}

//添加一个用户
@Test
public void addUser() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.addUser(new User(8,"zhangsan","zhang123"));

    sqlSession.commit();
    sqlSession.close();
}

//修改用户
@Test
public void updateUser() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.updateUser(new User(8,"zhangsan333","zhang123"));

    sqlSession.commit();
    sqlSession.close();
}

//删除用户
@Test
public void deleteUser() {
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    UserMapper mapper = sqlSession.getMapper(UserMapper.class);
    mapper.deleteUser(8);

    sqlSession.commit();
    sqlSession.close();
}

注意增删改需要提交事务
采用注解开发，需要确保实体类和数据库字段对应
在需要传参的情况下，接口中基本类型和String类型需要使用@Param声明，对象实体类不需要

关于@Param：

@Param注解用于给方法参数起一个名字。以下是总结的使用原则：

在方法只接受一个参数的情况下，可以不使用@Param。
在方法接受多个参数的情况下，建议一定要使用@Param注解给参数命名。
如果参数是 JavaBean ，则不能使用@Param。
不使用@Param注解时，参数只能有一个，并且是Javabean。

#{}和${}区别：

#{}的作用主要是替换预编译语句（PrepareStatement）中占位符【推荐使用】
```
INSERT INTO user (name) VALUES (#{name});
INSERT INTO user (name) VALUES (?);
```

${}的作用是直接进行字符串替换

INSERT INTO user (name) VALUES ('${name}');
INSERT INTO user (name) VALUES ('kuangshen');

8.4 Lombok注解插件

Lombok是为了偷懒，主要是自动实体类生成：无参构造和有参构造、getter和setter、toString等

优点：

能够通过注解的形式自动生成代码：构造器、getter/setter，equals,hashcode,toString等方法，提高了一定的开发效率
让代码变得简洁，不用过多的去关注相应的方法
属性做修改时，也简化了维护这些属性所生成的getter/setter方法等

缺点：

不支持多种参数构造器的重载，但可以在类中手动添加重载
虽然省去了手动创建getter/setter方法的麻烦，但大大降低了源代码的可读性和完整性，降低了阅读源代码的舒适度，公司一般不建议使用，了解即可

常用注解：

使用步骤：

1.在IDEA中安装Lombok插件，一般自动安装了，如果没有手动安装

file->setting->plugins,Marketplace，Browse repositories

2.使用lombok需要添加jar包

<dependency>
    <groupId>org.projectlombokgroupId>
    <artifactId>lombokartifactId>
    <version>1.18.12version>
dependency>

3.实体类中直接应用

@Data //无参构造。get set toString hashcode equals
@AllArgsConstructor //有参构造
@NoArgsConstructor //无参构造
public class User {
    private int id;
    private String name;
    private String pwd;
}

9.多表查询结果集映射

问题：

需要多表查询，但是返回的结果集往往只能是一个实体类型；
数据库多表查询结果（可能多张表的字段），与实体类（可能涉及多个实体类），但是Mybatis返回结果中，只有一个returnType——结果集映射

两种情况：

student表：id，name，tid

techear表：id，name

多对一：需要查询所有学生，及其对应的老师姓名（s.id s.name t.name），主体是学生（查询结果存在多个学生对应一个老师）

查询条件是所有的学生，学生表join老师表
**一对多：**需要查询指定老师，及其所有的学生信息（s.id s.name t.name），主体是老师（一个老师对应多个学生）

查询结果是指定老师，老师表join学生表

此处把握住是**“谁是主体”+“谁连接谁”**，join后面的是一个对象（多对一），join后面是一个集合（一对多）

9.1 老师学生例子数据库表

对于学生而言：多个学生对应一个老师，association关系，多对一
对于老师而言：一个老师对应多个学生，collection关系，一对多

新建数据库表：

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');

9.2多对一

需求：

需要查询所有学生，及其对应的老师姓名（s.id s.name t.name），主体是学生（查询结果存在多个学生对应一个老师）
查询条件是所有的学生，学生表join老师表

（1）测试环境搭建

项目结构：

导入lombok

1.新建实体类

Student:

@Data
public class Student {
    private int id;
    private String name;

    //学生需要关联一个老师，此处属性为一个对象
    private Teacher teacher;
}

Teacher:

@Data
public class Teacher {
    private int id;
    private String name;

}

2.建立Mapper接口

StudentMapper:

public interface StudentMapper {
	//查找所有学生，以及每个学生对应的老师姓名
    List<Student> getStudent();

}

TeacherMapper:

public interface TeacherMapper {
	//根据id查找老师，及老师的所有学生
    Teacher getTeacher(int id);
}

3.建立Mapper.xml文件（后续改）

在Resources目录下，建立和java目录下同样的包结构com.kuang.dao，易错：resources下建包用 / 分隔，java下建包用 . 分隔

而且Mapper.xml需要和Mapper同名

StudentMapper.xml




<mapper namespace="com.kuang.dao.StudentMapper">
    
mapper>

TeacherMapper.xml




<mapper namespace="com.kuang.dao.TeacherMapper">

mapper>

5.在核心配置文件中绑定注册Mapper接口或者Mapper.xml或者包

<mappers>
    <mapper class="com.kuang.dao.TeacherMapper"/>
    <mapper class="com.kuang.dao.StudentMapper"/>
mappers>

6.测试是否能够查询成功（后续改）

（2）按照结果嵌套处理（类连接查询、重点）

查询主体是学生

StudentMapper.xml：

<select id="getStudent" resultMap="StudentTeacher">
    select s.id sid,s.name sname,t.name tname
    from student s,teacher t
    where s.tid = t.id;
select>


<resultMap id="StudentTeacher" type="Student">
    <result property="id" column="sid"/>
    <result property="name" column="sname"/>
    
    
    <association property="teacher" javaType="Teacher"> 
        <result property="name" column="tname"/>
    association>
resultMap>

先通过sql查询出结果，再 “sql结果字段” 与“实体类对象属性” 映射

测试：

@Test
public void testStudent(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(StudentMapper.class);
    
    List<Student> studentList = mapper.getStudent();
    for (Student student : studentList) {
        System.out.println(student);
    }
    sqlSession.close();
}

（3）按照查询嵌套处理（类子查询）

查询主体是学生

StudentMapper.xml：

<mapper namespace="com.kuang.dao.StudentMapper">
 
    
    
    <select id="getStudent" resultMap="StudentTeacher">
        select * from student
    select>
    
    <resultMap id="StudentTeacher" type="Student">
        <result property="id" column="id"/>
        <result property="name" column="name"/>
        
        
        
        <association property="teacher" javaType="Teacher" select="getTeacher" column="tid"  />
    resultMap>

    
    <select id="getTeacher" resultType="Teacher">
        select * from teacher where id = #{id}
    select>
mapper>

测试：

@Test
public void testStudent(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();
    UserMapper mapper = sqlSession.getMapper(StudentMapper.class);
    
    List<Student> studentList = mapper.getStudent();
    for (Student student : studentList) {
        System.out.println(student);
    }
    sqlSession.close();
}

9.3一对多

需求：

需要查询指定老师，及其所有的学生信息（s.id s.name t.name），主体是老师（一个老师对应多个学生）
查询结果是指定老师，老师表join学生表

（1）测试环境搭建

实体类：

Student:

@Data
public class Student {
    private int id;
    private String name;
    private int tid;

}

Teacher:

@Data
public class Teacher {
    private int id;
    private String name;

    //一个老师拥有多个学生,此处属性为一个List
    private List<Student> students;
}

（2）按照结果嵌套处理（类连接查询、重点）

查询主体是老师

TeacherMapper.xml：

<select id="getTeacher" resultMap="TeacherStudent">
    select s.id sid,s.name sname,t.name tname,t.id tid
    from teacher t
    	inner join student s
    		on t.id=s.tid
    where t.id=#{id}
select>


<resultMap id="TeacherStudent" type="Teacher">
    <result property="id" column="tid"/>
    <result property="name" column="tname"/>
        
     
    <collection property="students" javaType="ArrayList" ofType="Student">
        <result property="id" column="sid"/>
        <result property="name" column="sname"/>
        <result property="tid" column="tid"/>
    collection>
resultMap>

先通过sql查询出结果，再 “sql结果字段” 与“实体类对象属性” 一一映射

测试：

public class TeacherMapperTest {
    @Test
    public void getTeacher(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);

        Teacher teacher = mapper.getTeacher(1);
        System.out.println(teacher);

        sqlSession.close();
    }
}

（3）按照查询嵌套处理（类子查询）

查询主体是老师

TeacherMapper.xml：

<select id="getTeacher" resultMap="TeacherStudent">
    select * from `teacher` where id=#{id}
select>

<resultMap id="TeacherStudent" type="Teacher">
    <collection property="students" javaType="ArrayList" ofType="Student"
                select="getStudent" column="id"/>
resultMap>

<select id="getStudent" resultType="Student">
    select * from `student` where tid=#{id};
select>

测试：

public class TeacherMapperTest {
    @Test
    public void getTeacher(){
        SqlSession sqlSession = MybatisUtils.getSqlSession();
        TeacherMapper mapper = sqlSession.getMapper(TeacherMapper.class);

        Teacher teacher = mapper.getTeacher(1);
        System.out.println(teacher);

        sqlSession.close();
    }
}

小结：

关联 association，多对一
集合 collection，一对多
javaType 和 ofType
- javaType 用来制定实体类中属性的类型
- ofType用来指定映射到List（或者集合）中的pojo类型，泛型中的约束类

注意点：

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

面试高频：

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

10.动态SQL

10.1简介

什么是动态SQL：

动态SQL是指根据==不同的查询条件，拼接生成不同的Sql语句==

简介：

MyBatis 的强大特性之一便是它的动态 SQL
如果你有使用 JDBC 或其它类似框架的经验，你就能体会到根据不同条件拼接 SQL 语句的痛苦：
- 拼接是要确保不能忘记添加必要的空格
- 第一个查询条件不要and where id=1 and name=“zhangsan” and password=“123456”
- 去掉列名最后一个列名的逗号 insert into user(id,name,value) values(1,”zhangsna”,”123456) update user set name=”zhangsan2”,password=”123” where id=1
动态sql元素和 JSTL标签类似；
复杂的SQL语句，往往需要拼接。而拼接SQL稍微不注意，由于引号，空格等的缺失可能都会导致错误。

解决办法：

使用MyBatis的动态SQL，通过if where,set,trim foreach choose,when,otherwise等标签，可以组合成非常灵活的SQL语句，从而在提高SQL语句的准确性的同时，也大大提高了开发人员的效率。

10.2搭建环境

新建一个数据库表：blog

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

1.创建一个maven基础工程

2.IDutils工具类

使用UUID创建唯一id

IDUtils:

public class IDUtils {
    public static String getId(){
        return UUID.randomUUID().toString().replaceAll("-","");
    }
}

3.实体类的编写

Blog:

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

}

4.编写Mapper接口及xml文件

BlogMapper：

public interface BlogMapper {
}

BlogMapper.xml:




<mapper namespace="com.kuang.dao.BlogMapper">

mapper>

5.mybatis核心配置文件，下划线命名驼峰命名自动转换

<settings>

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


<mappers>
    <mapper class="com.kuang.dao.BlogMapper"/>
mappers>

6.初始化接口数据

编写接口：

//新增一个博客
int addBlog(Blog blog);

Mapper.xml：

<insert id="addBlog" parameterType="Blog">
    insert into mybatis.blog (id,title,author,create_time,views)
    values (#{id},#{title},#{author},#{createTime},#{views});
insert>

test:初始化博客数据

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

    Blog blog = new Blog();

    blog.setId(IDUtils.getId());
    blog.setTitle("Mybatis如此简单");
    blog.setAuthor("狂神说");
    blog.setCreateTime(new Date());
    blog.setViews(9999);
    mapper.addBlog(blog);

    blog.setId(IDUtils.getId());
    blog.setTitle("Java如此简单");
    mapper.addBlog(blog);

    blog.setId(IDUtils.getId());
    blog.setTitle("Spring如此简单");
    mapper.addBlog(blog);

    blog.setId(IDUtils.getId());
    blog.setTitle("微服务如此简单");
    mapper.addBlog(blog);

    session.commit();
    session.close();
}

10.3 if标签

应用场景：

根据条件append查询条件，拼接SQL

需求：根据作者名字author和博客名字title来查询博客：

如果author和title都为空，查询全部博客
author不为空，title为空，查询所有属于author的博客
author为空，title不为空，查询指定博客名字的博客
author和title都不为空，查询符合两者条件的博客

1.编写接口类：

//需求1
List<Blog> queryBlogIf(Map map);

2.编写Mapper.xml中SQL语句

<select id="queryBlogIf" parameterType="map" resultType="Blog">
    select * from `blog` where

    <if test="author!=null">
        author=#{author}
    if>
    <if test="title!=null">
        and title=#{title}
    if>

select>

3.测试

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

    Map<String,Object> map=new HashMap<String, Object>();
    map.put("author","狂神说");
    map.put("title","Mybatis如此简单");

    List<Blog> blogs = mapper.queryBlogIf(map);
    for (Blog blog : blogs) {
        System.out.println(blog);
    }
    session.close();
}

问题：

当author为null,title不为空时，select语句为：select * from blog where and title=#{title} ，这是错误的SQL语句。如何解决呢？采用下面where标签；

10.4 where标签

应用场景：

如果查询条件有返回值，就插入where；没有查询条件不插入where；
如果第一个查询条件前有and，就去除该and

修改上面的SQL语句：

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

set标签

应用场景：

update操作，尾部最后一个逗号 , 剔除
当author不为null，title为null时，造成错误： SQL尾部多了一个逗号 update blog set author=#{author},

编写Mapper.xml中SQL语句

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

trim标签

10.5 foreach标签

应用场景：

**对应于 select * from blog where id in (1,2,3,4) **

1.编写接口类：

List<Blog> queryBlogForeach(Map map);

2.编写Mapper.xml中SQL语句

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

3.测试

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

    Map<String,Object> map=new HashMap<String, Object>();
    List<String> idList=new ArrayList<String>();
    idList.add("ae52b845132a4a7190d4c3e192265fd2");
    map.put("idList",idList); //List是map的一个属性

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

    session.commit();
    session.close();
}

10.6 choose、when、otherwise标签

应用场景：

有时候我们不想用所有的查询条件，只想选择其中一个，查询条件有一个满足即可
使用choose，类似switch语句，前面的优先匹配优先级更高

1.编写接口类：

List<Blog> queryBlogChoose(Map map);

2.编写Mapper.xml中SQL语句

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

    where>
select>

3.测试

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

    Map<String,Object> map=new HashMap<String, Object>();
    map.put("title","Java如此简单2");
    map.put("author","狂神说2");
    map.put("views",9999);

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

    session.commit();
    session.close();
}

10.7 提取SQL片段

有时候可能某个sql语句我们用的特别多，为了增加代码的复用性，简化代码，我们需要将这些代码抽取出来，然后使用时直接调用。

提取SQL片段：

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

引用SQL片段：

<select id="queryBlogIf" parameterType="map" resultType="Blog">
    select * from `blog`
    <where>
        
        <include refid="if-title-author"/>
        
    where>
select>

注意：

最好基于单表定义sql片段，提高片段的可重用性
在sql片段中不要包括where

动态SQL小结：

动态SQL语句的编写往往就是一个拼接的问题
为了保证拼接准确，最好先写出原生的sql语句
然后再通过mabatis动态SQL对照修改，防止出错

11.缓存

11.1简介

问题：

查询：连接数据库，耗费资源。

一次查询的结果，给他暂存在一个可以直接取到的地方——内存：缓存

我们再次查询相同数据的时候，直接走缓存，就不用走数据库了。

1.什么是缓存？

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

2.为什么使用缓存？

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

3.什么样的数据能使用缓存

经常查询并且不经常改变的数据
不经常查询 or 经常改变的数据不使用缓存

11.2Mybatis缓存

MyBatis包含一个非常强大的查询缓存特性，它可以非常方便地定制和配置缓存。缓存可以极大的提升查询效率。
MyBatis系统中默认定义了两级缓存：一级缓存和二级缓存
- 默认情况下，只有一级缓存开启（SQLSession级别的缓存，也称本地缓存，作用域从SQLSession开启到结束
- 二级缓存需要手动配置和开启，它是基于namespace级别的缓存（在一个Mapper中有效，也称全局缓存；查询数据库，数据存入一级缓存，当SQLSession关闭时，将其缓存交付给二级缓存）
- MyBatis自定义了缓存接口Cache，可以自定义二级缓存

缓存清除策略：

11.3一级缓存

一级缓存也叫本地缓存，SqlSession级别，从SqlSession开始到关闭期间
- 与数据库同一次会话期间查询到的数据会放在本地缓存中
- 这期间需要获取相同的数据，直接从缓存中拿，没必要再去查询数据库；
- 一级缓存自动开启

1.测试

在同一SqlSession中查询两次相同记录

开启日志
测试代码：

Mapper接口：

//根据id查询用户
User queryUserbyId(@Param("id") int id);

Mapper.xml：

<select id="queryUserbyId" resultType="com.kuang.pojo.User">
    select * from `user` where id=#{id};
select>

test:

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

    User user1 =mapper.queryUserbyId(1);
    System.out.println(user1);

    System.out.println("===========同一个SqlSession中两次查询相同记录================");

    User user2 =mapper.queryUserbyId(1);
    System.out.println(user2);

    System.out.println("user1==user2:"+(user1==user2));

    sqlSession.close();
}

测试结果：

2.一级缓存失效

SqlSession一级缓存失效的情况

（1）SqlSession不同

public void testQueryUserById(){
    SqlSession sqlSession1 = MybatisUtils.getSqlSession();
    SqlSession sqlSession2 = MybatisUtils.getSqlSession();

    //第一次查询
    UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);
    User user1 =mapper1.queryUserbyId(1);
    System.out.println(user1);

    System.out.println("===========Sqlsession不同================");

    //第二次查询
    UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);
    User user2 =mapper2.queryUserbyId(1);
    System.out.println(user2);


    sqlSession1.close();
    sqlSession2.close();
}

观察结果：两次查询都查询了数据库；

结论：每个SqlSession中缓存相互独立

（2）SqlSession相同，查询条件不同

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

    User user1 =mapper.queryUserbyId(1);
    System.out.println(user1);

    System.out.println("===========SqlSession相同，查询条件不同================");

    User user2 =mapper.queryUserbyId(2);
    System.out.println(user2);

    System.out.println("user1==user2:"+(user1==user2));

    sqlSession.close();
}

（3）增删改操作，可能会改变原来的数据，所以必定会刷新缓存

增删改之后，再次查询，会重新查询数据库；

//第一次查询
User user1 =mapper.queryUserbyId(1);
System.out.println(user1);

System.out.println("===========增删改操作，会刷新缓存================");
//更新
Map<String,Object> map=new HashMap<String, Object>();
map.put("id",1);
map.put("name","zhangsan2");
map.put("pwd","zhang123321");
mapper.updateUser(map);

//第二次查询
User user2 =mapper.queryUserbyId(1);
System.out.println(user2);

（4）SqlSession相同，手动清除一级缓存

第二次查询会重新查询数据库

public void testQueryUserById(){
    SqlSession sqlSession = MybatisUtils.getSqlSession();

    //第一次查询
    UserMapper mapper1 = sqlSession.getMapper(UserMapper.class);
    User user1 =mapper1.queryUserbyId(1);
    System.out.println(user1);

    System.out.println("===========手动清除以及缓存================");

    //手动清除以及缓存
    sqlSession.clearCache();

    //第二次查询
    UserMapper mapper2 = sqlSession.getMapper(UserMapper.class);
    User user2 =mapper2.queryUserbyId(1);
    System.out.println(user2);

    sqlSession.close();

}

一级缓存就是一个Map，key-value键值对

11.4二级缓存

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

使用步骤

1.在mybatis-config.xml核心配置文件中，开启全局缓存

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

2.在要使用二级缓存的Mapper.xml中开启

<cache/>

也可以自定义参数

<cache
  eviction="FIFO"
  flushInterval="60000"
  size="512"
  readOnly="true"/>

3.测试

（1）遇到问题：实体类需要序列化，否则就会报错

Cause: java.io.NotSerializableException: com.kuang.pojo.User

解决：

public class User implements Serializable {......}

（2）两个SqlSession测试二级缓存：

public void testQueryUserById(){
    //第一次查询
    SqlSession sqlSession1 = MybatisUtils.getSqlSession();
    UserMapper mapper1 = sqlSession1.getMapper(UserMapper.class);
    User user1 =mapper1.queryUserbyId(1);
    System.out.println(user1);
    sqlSession1.close();

    System.out.println("===========两个SqlSession测试二级缓存================");

    //第二次查询
    SqlSession sqlSession2 = MybatisUtils.getSqlSession();
    UserMapper mapper2 = sqlSession2.getMapper(UserMapper.class);
    User user2 =mapper2.queryUserbyId(1);
    System.out.println(user2);
    sqlSession2.close();
}

小结

只要开启了二级缓存，在同一个Mapper下就有效
所有的数据都会先放在一级缓存中
只有当会话提交或者关闭时，才会提交到二级缓存中

11.5缓存原理

采用缓存后，查询数据先后顺序：

1.先看二级缓存中有没有

2.再看二级缓存中有没有

3.都没有查询数据库

11.6自定义缓存ehcache

ehcache是第三方缓存，是一个纯Java的进程内缓存框架
是一种广泛使用的java分布式缓存，用于通用缓存

1.使用需要导入jar包

<dependency>
    <groupId>org.mybatis.cachesgroupId>
    <artifactId>mybatis-ehcacheartifactId>
    <version>1.2.1version>
dependency>

2.在mapper.xml中使用对应的缓存即可

<mapper namespace="com.kuang.dao.UserMapper">
    <cache type="org.mybatis.caches.ehcache.EhcacheCache"/>
mapper>

3.编写ehcache.xml配置文件，放在resources中；如果在加载时未找到/ehcache.xml资源，将使用默认配置


<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
         updateCheck="false">
    
    <diskStore path="./tmpdir/Tmp_EhCache"/>
    
    <defaultCache
            eternal="false"
            maxElementsInMemory="10000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="259200"
            memoryStoreEvictionPolicy="LRU"/>
 
    <cache
            name="cloud_user"
            eternal="false"
            maxElementsInMemory="5000"
            overflowToDisk="false"
            diskPersistent="false"
            timeToIdleSeconds="1800"
            timeToLiveSeconds="1800"
            memoryStoreEvictionPolicy="LRU"/>
    
    

ehcache>

Mybatis缓存使用不多，大多被Redis缓存数据库，key-value键值对。

12.错误

【错误1】测试类不要和Mapper接口同名，测试类的测试函数不要和Mapper中接口函数同名

否则会出现找不到java方法

或者找到测试类的测试函数，但是传递方法参数不对

【错误2】

Cause: com.sun.org.apache.xerces.internal.impl.io.MalformedByteSequenceExcep

解决方法：之前在pom.xml文件中删除了下面代码，现在加上：

<properties>
    <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
properties>

【错误3】

新建Mapper接口时不要建成了类

13.Mybatis常用配置总结

13.1Mybatis流程

项目结构

Mapper.xml和Mapper接口放在一起

Mapper.xml和Mapper接口放在相同包名下，Mapper.xml放在Resources目录下

Mybatis项目构建

1.新建配置文件

mybatis-config.xml 核心配置文件（后续不要忘记在此注册Mappper）
db.properties 数据库配置文件
log4j.properties 日志配置文件

2.新建工具类

MybatisUtils 提取生成SqlSession工具类
其他工具类

3.新建实体类

4.新建dao层

Mapper接口
Mapper.xml（类实现类，书写sql）（每个需要在mybatis-config.xml 核心配置文件中注册）

5.测试

13.2常用配置

MyBatis的maven项目pom.xml常用依赖


<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0modelVersion>

    <groupId>org.examplegroupId>
    <artifactId>mybatis3artifactId>
    <packaging>pompackaging>
    <version>1.0-SNAPSHOTversion>

    <properties>
        <project.build.sourceEncoding>UTF-8project.build.sourceEncoding>
    properties>

    <dependencies>
        
        <dependency>
            <groupId>mysqlgroupId>
            <artifactId>mysql-connector-javaartifactId>
            <version>5.1.47version>
        dependency>
        
        <dependency>
            <groupId>org.mybatisgroupId>
            <artifactId>mybatisartifactId>
            <version>3.5.3version>
        dependency>
        
        <dependency>
            <groupId>junitgroupId>
            <artifactId>junitartifactId>
            <version>4.13version>
        dependency>
        
        <dependency>
            <groupId>log4jgroupId>
            <artifactId>log4jartifactId>
            <version>1.2.17version>
        dependency>
        
        <dependency>
            <groupId>org.projectlombokgroupId>
            <artifactId>lombokartifactId>
            <version>1.18.12version>
        dependency>
        
        <dependency>
            <groupId>org.mybatis.cachesgroupId>
            <artifactId>mybatis-ehcacheartifactId>
            <version>1.2.1version>
        dependency>

    dependencies>

    
    <build>
        <resources>
            <resource>
                <directory>src/main/resourcesdirectory>
                <includes>
                    <include>**/*.propertiesinclude>
                    <include>**/*.xmlinclude>
                includes>
                <filtering>truefiltering>
            resource>
            <resource>
                <directory>src/main/javadirectory>
                <includes>
                    <include>**/*.propertiesinclude>
                    <include>**/*.xmlinclude>
                includes>
                <filtering>truefiltering>
            resource>
        resources>
    build>


project>

1.新建配置文件

mybatis-config.xml 核心配置文件（后续不要忘记在此注册Mappper）




<configuration>
    <properties resource="db.properties"/>
    
    <settings>
        
        <setting name="logImpl" value="LOG4J"/>
        
        <setting name="mapUnderscoreToCamelCase" value="true"/>
        
        <setting name="cacheEnabled" value="true"/>
    settings>

    
    <typeAliases>
        <package name="com.kuang.pojo"/>
    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 class="com.kuang.dao.BlogMapper"/>
    mappers>

configuration>

db.properties 数据库配置文件

driver=com.mysql.jdbc.Driver
url=jdbc:mysql://localhost:3306/mybatis?useSSL=true&useUnicode=true&characterEncoding=utf8
username=root
password=123456

log4j.properties 日志配置文件

#将等级为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

2.新建工具类

MybatisUtils 提取生成SqlSession工具类

//工具类
//需要获得数据库操作对象SqlSession
//SqlSessionFactory---->SqlSession
public class MybatisUtils {
    private static SqlSessionFactory sqlSessionFactory;//提升作用域

    static {
        //使用Mybatis的第一步：获取SqlSessionFactory对象
        try {
            String resource = "mybatis-config.xml";
            InputStream inputStream =Resources.getResourceAsStream(resource);
            sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //有了SqlSessionFactory以后，我们可以从中获得SqlSession的实例
    //SqlSession提供了在数据库执行 SQL命令 所需的所有方法
    public static SqlSession getSqlSession(){
        return sqlSessionFactory.openSession();
    }
}

其他工具类，如IDUtils

public class IDUtils {
    public static String getId(){
        return UUID.randomUUID().toString().replaceAll("-","");
    }
}

3.新建实体类

import java.util.Date;
@Data
public class Blog {
    private String id;
    private String title;
    private String author;
    private Date createTime;
    private int views;

}

4.新建dao层

Mapper接口

public interface BlogMapper {
    //查询
    List<Blog> queryBlogIf(Map map);
}

Mapper.xml（类实现类，书写sql）（每个需要在mybatis-config.xml 核心配置文件中注册）




<mapper namespace="com.kuang.dao.BlogMapper">

    <select id="queryBlogIf" parameterType="map" resultType="Blog">
        select * from `blog`
        <where>
            <if test="author!=null">
                author=#{author}
            if>
            <if test="title!=null">
                and title=#{title}
            if>
        where>
    select>

mapper>

5.测试

public class BlogTest {
    @Test
    public void test(){
        SqlSession session = MybatisUtils.getSqlSession();
        BlogMapper mapper = session.getMapper(BlogMapper.class);

        Map<String,Object> map=new HashMap<String, Object>();
        map.put("title","Java如此简单2");
        map.put("author","狂神说2");


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

        session.commit();
        session.close();
    }
}

你可能感兴趣的:(mybatis)

insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insert into select 主键自增 mybatis delete返回值 mybatis insert返回主键 mybatis insert返回对象 mybatis plus insert返回主键 mybatis plus 插入生成id
前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
MyBatis 详解阿贾克斯的黎明 java mybatis
目录目录一、MyBatis是什么二、为什么使用MyBatis（一）灵活性高（二）性能优化（三）易于维护三、怎么用MyBatis（一）添加依赖（二）配置MyBatis（三）创建实体类和接口（四）使用MyBatis一、MyBatis是什么MyBatis是一个优秀的持久层框架，它支持自定义SQL、存储过程以及高级映射。MyBatis免除了几乎所有的JDBC代码以及设置参数和获取结果集的工作。它可以通过简
mybatis 二级缓存失效_Mybatis 缓存原理及失效情况解析 weixin_39844942 mybatis 二级缓存失效
这篇文章主要介绍了Mybatis缓存原理及失效情况解析,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下1、什么是缓存[Cache]存在内存中的临时数据。将用户经常查询的数据放在缓存(内存)中，用户去查询数据就不用从磁盘上(关系型数据库数据文件)查询，从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。2、为什么要使用缓存减少和数据库的交互次
详解mybatis的一二级缓存以及缓存失效原因仰望天花板缓存数据库 mybatis java mysql
数据库的大部分场景下是从磁盘读取，如果数据从内存进行读取，速度较比磁盘要快得多。但因为内存的容量有限，所以一般只会把使用和查询较多的数据缓存起来，以便快速反应，其他使用率不太多的继续存放在磁盘。mybatis分为一级缓存和二级缓存1.一级缓存一级缓存存放在SqlSqeeion上，默认开启1.1pojo@DatapublicclassRole{privateLongid;privateStringr
36. MyBatis如何支持多数据库操作？如何配置不同的数据源？这孩子叫逆 Mybatis笔记 mybatis 数据库
在许多企业级应用中，可能需要访问多个数据库。MyBatis可以通过配置多个数据源和动态切换数据源来支持多数据库操作。下面介绍如何在MyBatis中配置和使用多个数据源。1.多数据源的基本配置1.1配置多个数据源要支持多个数据源，首先需要在Spring或SpringBoot中配置不同的数据源。假设我们要连接两个数据库db1和db2，可以通过以下步骤进行配置。SpringBoot示例：applicat
MyBatis批量插入大量数据小黑屋说YYDS MyBatis java
1.思路分析批量插入这个问题，我们用JDBC操作，其实就是两种思路吧：用一个for循环，把数据一条一条的插入（这种需要开启批处理）。生成一条插入sql，类似这种insertintouser(username,address)values(‘aa’,‘bb’),(‘cc’,‘dd’)…。到底哪种快呢？我们从两方面来考虑这个问题：插入SQL本身执行的效率。网络I/O。先说第一种方案，就是用for循环循
MyBatis 查询数据库_mybatis查询某个库的所有表名(2) 2401_84181942 程序员 mybatis oracle tomcat
标签说明：***``标签**：需要指定namespace属性，表示命名空间，值为mapper接口的全限定名，包括全包名.类名。***``查询标签**：是用来执行数据库的查询操作的：`id`：是和Interface（接口）中定义的方法名称一样的，表示对接口的具体实现方法。`resultType`：是返回的数据类型，也就是开头我们定义的实体类。####2.4.4添加Service服务层实现代码如下：@
5-【JavaWeb】JUnit 单元测试及JUL 日志系统 weixin_44329069 JavaWeb junit 单元测试
1.使用JUnit进行单元测试JUnit是Java中非常流行的单元测试框架，MyBatis与JUnit可以很好地结合，来测试持久层代码的正确性。1.1添加JUnit依赖在使用JUnit之前，需要在pom.xml中引入JUnit依赖。junitjunit4.13.2test1.2单元测试基本结构假设我们要测试UserMapper中的getUserById方法，测试代码如下：importorg.apa
【免费】springboot项目申报管理系统|毕业设计|Javaweb项目计算机学姐来啦 springboot ssm java spring boot 课程设计后端毕设毕业设计 java-ee
收藏点赞不迷路关注作者有好处编号：springboot375springboot项目申报管理系统开发语言：Java数据库：MySQL技术：Spring+SpringMVC+MyBatis工具：IDEA/Ecilpse、Navicat、Maven1.万字文档展示(部分)2.系统图片展示第5章系统详细设计5.1管理员功能模块的实现5.1.1项目列表如图5.1显示的就是项目列表页面，此页面提供给管理员的
MyBatis系统学习（一）——项目结构及其含义 OEC小胖胖 MyBatis mybatis 学习 web 后端
1.MyBatis简介MyBatis是一款优秀的持久层框架，它通过SQL映射的方式实现Java对数据库操作的映射，既保留了SQL语句的灵活性，也简化了代码的编写。在一个MyBatis项目中，核心部分主要有：配置文件（mybatis-config.xml）映射文件（Mapper.xml）实体类（Entity/POJO）接口类（Mapper接口）MyBatis会话工厂（SqlSessionFactor
MyBatis 如何将 Mapper 接口与其 XML 映射文件关联：深入原理与实现 OEC小胖胖 web后端 mybatis xml java web 后端
MyBatis如何将Mapper接口与其XML映射文件关联：深入原理与实现1.概述MyBatis是一个简单、灵活的持久层框架，它通过SQL语句将Java对象与数据库进行映射。MyBatis支持基于XML和注解的配置方式。在实际开发中，XML映射文件与Mapper接口的关联是MyBatis的核心功能之一。通过这种关联，开发者可以在Mapper接口中定义方法，并在XML文件中编写SQL语句，从而实现数
Mybatis实现员工管理系统 wu1113_ mybatis java maven
文章目录1.案例需求2.编程思路3.案例源码4.小结1.案例需求在上次做的父子模块的maven以及Ajax实现人工管理系统的基础上使用Mybatis实现员工管理系统的增删改查，具体运行效果如下：2.编程思路Mybatis框架的一般执行流程：创建MyBatis配置文件mybatis-config.xml在里面加载数据源、事务等，管理映射文件创建需要的映射文件mapper.xml，用于映射表中列和实体
springboot+mybatisplus实现基本的增删改查以及分页查询。这里使用的是Restful风格包括简单描述Restful是什么 okchan666 spring boot java
先实现springboot+mybatisplus的增删改查接口使用postman测试：第一步创建项目导入依赖：直接给大家了：4.0.0org.springframework.bootspring-boot-starter-parent2.6.6com.okchanspringboot_07_ssmp0.0.1-SNAPSHOT1.8org.springframework.bootspring-b
MyBatis 方法重载的陷阱及解决方案 molashaonian mybatis 方法重载异常方法名相同
在使用MyBatis进行开发时，尤其是使用注解模式（如@Select、@Insert等）时，开发者常常会遇到这样一个问题：为什么我的方法重载不能正常工作？即使在Java中允许方法名相同但参数不同的重载，MyBatis在处理注解的SQL方法时却并不支持这种方式。这篇文章将深入探讨MyBatis的这个特性及如何规避相关的坑。问题背景在标准的Java开发中，方法重载是一种常见的设计模式。方法重载允许我们
Spring Cloud+Spring Boot+Mybatis+Java版电子招标采购系统源码及功能清单 Xiaohong0716 mybatis java spring cloud
一、立项管理1、招标立项申请功能点：招标类项目立项申请入口，用户可以保存为草稿，提交。2、非招标立项申请功能点：非招标立项申请入口、用户可以保存为草稿、提交。3、采购立项列表功能点：对草稿进行编辑，驳回的立项编辑，在途流程查看。二、项目管理1、采购计划管理功能点：采购计划新增、编辑、删除2、采购过程管理功能点：查询、维护基准价、组建评审小组、项目答疑澄清、文件费保证金审核、供应商报价维护、查看评审
BindingException: Invalid bound statement (not found) 小卡车555 MyBatis mybatis java mysql
Mybatis出现绑定异常问题的解决org.apache.ibatis.binding.BindingException:Invalidboundstatement(notfound)一般的原因是Mapperinterface和xml文件的定义对应不上，需要检查包名，namespace，函数名称等能否对应上，需要比较细致的对比，我经常就是写错了一两个字母搞的很长时间找不到错误按以下步骤一一执行：1
工程项目管理系统源码与Spring Cloud：实现高效系统管理与二次开发微服务技术分享 spring cloud java 工程项目管理系统源码
随着企业规模的不断扩大和业务的快速发展，传统的工程项目管理方式已经无法满足现代企业的需求。为了提高工程管理效率、减轻劳动强度、提高信息处理速度和准确性，企业需要借助先进的数字化技术进行转型。本文将介绍一款采用SpringCloud+SpringBoot+Mybatis技术框架的工程项目管理系统，该系统涵盖了项目管理、合同管理、预警管理、竣工管理、质量管理等多个方面，通过数据字典、编码管理、用户管理
[附源码]SSM计算机毕业设计游戏账号交易平台JAVA 计算机程序源码 java 游戏 mysql
项目运行环境配置：Jdk1.8+Tomcat7.0+Mysql+HBuilderX（Webstorm也行）+Eclispe（IntelliJIDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：SSM+mybatis+Maven+Vue等等组成，B/S模式+Maven管理等等。环境需要1.运行环境：最好是javajdk1.8，我们在这个平台上运行的。其他版本理论上也可以。2.ID
Mybatis Mysql 莫夏_b560
1、查询失败或者结果异常andfwbdh=#{fwbdh}更换成andfwbdh=#{fwbdh}
33. MyBatis中的@Param注解如何使用？如何在Mapper接口中传递多个参数？这孩子叫逆 Mybatis笔记 java mybatis tomcat
在MyBatis中，@Param注解用于将方法参数绑定到SQL语句中的命名参数。它主要用于在Mapper接口中传递多个参数，以便在SQL语句中更方便地引用这些参数。为什么使用@Param注解？在MyBatis中，当Mapper接口的方法只有一个参数时，MyBatis会默认将这个参数的名称绑定为#{parameter}，可以直接在SQL语句中引用它。如果方法有多个参数，MyBatis默认使用para
Python+Django毕业设计校园易购二手交易平台（程序+LW+部署） Python、JAVA毕设程序源码课程设计 java mysql
项目运行环境配置：Jdk1.8+Tomcat7.0+Mysql+HBuilderX（Webstorm也行）+Eclispe（IntelliJIDEA,Eclispe,MyEclispe,Sts都支持）。项目技术：SSM+mybatis+Maven+Vue等等组成，B/S模式+Maven管理等等。环境需要1.运行环境：最好是javajdk1.8，我们在这个平台上运行的。其他版本理论上也可以。2.ID
Springboot3 整合 Mybatis3 （前程似锦） mybatis java spring boot
Springboot3整合MybatisSpringboot3整合MybatisSpringboot3整合Mybatis一、导入依赖二、编写配置文件三、定义模型entity实体类四、在启动类上添加注解，表示mapper接口所在位置五、定义mapper接口六、定义mapper.xml映射文件七、service层八、测试一、导入依赖mybatis的必要依赖注意：使用springboot3的话要使用my
mybatis支持json，Spring boot配置 Knight_9
mysql5.7版本以后支持原生json格式，基于Springboot进行配置说明。mybatis支持mysql的json格式mysql-connector，mysql的驱动版本要大于等于5.1.40，否则json字段查询会发生乱码。继承BaseTypeHandler自定义一个json类型处理器，放到一个handler包下，例：packagecom.c.config.handler;importc
【Java】Mybatis Druid连接池配置详细 beautiful_huang Java
pom.xmlcom.alibabadruid1.0.18.propertiesspring.datasource.driver-class-name=com.mysql.jdbc.Driverspring.datasource.url=jdbc:mysql://localhost:3306/mybatis2?characterEncoding=utf-8&useSSL=truespring.da
关于com.baomidou:mybatis-plus-boot-starter:jar:unknown was not found解决办法波斯CD mybatis jar java
原型com.baomidoumybatis-plus-boot-starter修改以后解决了com.baomidoumybatis-plus-boot-starter3.5.3.1
MyBatis-Plus 3.5.5的代码生成器实践【完整代码】 qq_43513957 mybatis
MyBatis-Plus3.5.5的代码生成器实践【完整代码】1.表：要有一个version字段，乐观锁更新。配置拦截器的代码packagecom.example.demo.zmybatisplusGenerator.config;importcom.baomidou.mybatisplus.annotation.DbType;importcom.baomidou.mybatisplus.exte
深入解析 MyBatis：从理论到项目实例 OEC小胖胖 web后端 mybatis java spring web 后端
深入解析MyBatis：从理论到项目实例目录MyBatis概述MyBatis项目结构及作用核心概念详解分页功能的实现与深入剖析动态SQL缓存机制详解与Spring集成常见问题与深入分析完整项目示例总结1.MyBatis概述MyBatis是一个轻量级的持久层框架，使用SQL查询语句来访问数据库。它与Java对象建立映射关系，通过配置文件或注解来管理SQL语句，灵活性高且与数据库操作直接相关，适合需要
MyBatis Plus 实战详解 Aries263 redis 分布式数据库
一、引言MyBatisPlus（简称MP）是MyBatis的增强工具，旨在简化开发、提高效率。它保留了MyBatis的强大功能，并在其基础上进行了扩展和优化，提供了强大的CRUD操作、配置选项、条件构造器等功能。本文将详细介绍MyBatisPlus的安装、配置、基本操作以及分页和条件查询的使用。二、安装与配置1.添加依赖首先，在Maven项目的pom.xml中添加MyBatisPlus的依赖。以下
在springboot中，利用xml配置mybatis的方法猪猡猪猡猪 java mybatis mybatis spring boot xml java mysql
前置步骤参考博客：SpringBoot配置Mybatis的两种方式（通过XML配置和通过YML配置文件配置）_Darreni的博客-CSDN博客但按照博客中的关键代码和步骤创建的项目无法启动启动报错：Description:FailedtoconfigureaDataSource:'url’attributeisnotspecif:Reason:Failedtodetermineasuitable
MyBatis 学习笔记(4) 动态SQL 张云飞Vir
1.背景本节讲mybatis应对动态SQL的场景。2.知识动态SQL是指“条件"不固定的SQL，对比于一般的SQL，动态SQL会有一个或者多个条件/参数。比如：场景：查询的时候，如果用户输入了姓名，就按姓名模糊查询；同时又输入了邮箱，就再增加一个条件按姓名+邮箱两个条件查询。传统的拼接SQL很费力，拼接时要确保不能忘记添加必要的空格，还要注意去掉列表最后一个列名的逗号。借助功能强大的基于OGNL的
多线程编程之卫生间周凡杨 java 并发卫生间线程厕所
如大家所知，火车上车厢的卫生间很小，每次只能容纳一个人，一个车厢只有一个卫生间，这个卫生间会被多个人同时使用，在实际使用时，当一个人进入卫生间时则会把卫生间锁上，等出来时打开门，下一个人进去把门锁上，如果有一个人在卫生间内部则别人的人发现门是锁的则只能在外面等待。问题分析：首先问题中有两个实体，一个是人，一个是厕所，所以设计程序时就可以设计两个类。人是多数的，厕所只有一个（暂且模拟的是一个车厢）。
How to Install GUI to Centos Minimal sunjing linux Install Desktop GUI
http://www.namhuy.net/475/how-to-install-gui-to-centos-minimal.html I have centos 6.3 minimal running as web server. I’m looking to install gui to my server to vnc to my server. You can insta
Shell 函数 daizj shell 函数
Shell 函数 linux shell 可以用户定义函数，然后在shell脚本中可以随便调用。 shell中函数的定义格式如下： [function] funname [()]{ action; [return int;] } 说明： 1、可以带function fun() 定义，也可以直接fun() 定义,不带任何参数。 2、参数返回
Linux服务器新手操作之一周凡杨 Linux 简单操作
1.whoami 当一个用户登录Linux系统之后，也许他想知道自己是发哪个用户登录的。此时可以使用whoami命令。 [ecuser@HA5-DZ05 ~]$ whoami e
浅谈Socket通信（一）朱辉辉33 socket
在java中ServerSocket用于服务器端，用来监听端口。通过服务器监听，客户端发送请求，双方建立链接后才能通信。当服务器和客户端建立链接后，两边都会产生一个Socket实例，我们可以通过操作Socket来建立通信。首先我建立一个ServerSocket对象。当然要导入java.net.ServerSocket包 ServerSock
关于框架的简单认识西蜀石兰框架
入职两个月多，依然是一个不会写代码的小白，每天的工作就是看代码，写wiki。前端接触CSS、HTML、JS等语言，一直在用的CS模型，自然免不了数据库的链接及使用，真心涉及框架，项目中用到的BootStrap算一个吧，哦，JQuery只能算半个框架吧，我更觉得它是另外一种语言。后台一直是纯Java代码，涉及的框架是Quzrtz和log4j。都说学前端的要知道三大框架，目前node.
You have an error in your SQL syntax; check the manual that corresponds to your 林鹤霄
You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'option,changed_ids ) values('0ac91f167f754c8cbac00e9e3dc372
MySQL5.6的my.ini配置 aigo mysql
注意：以下配置的服务器硬件是：8核16G内存 [client] port=3306 [mysql] default-character-set=utf8 [mysqld] port=3306 basedir=D:/mysql-5.6.21-win
mysql 全文模糊查找便捷解决方案 alxw4616 mysql
mysql 全文模糊查找便捷解决方案 2013/6/14 by 半仙 [email protected] 目的: 项目需求实现模糊查找. 原则: 查询不能超过 1秒. 问题: 目标表中有超过1千万条记录. 使用like '%str%' 进行模糊查询无法达到性能需求. 解决方案: 使用mysql全文索引. 1.全文索引 : MySQL支持全文索引和搜索功能。MySQL中的全文索
自定义数据结构链表(单项 ,双向,环形) 百合不是茶单项链表双向链表
链表与动态数组的实现方式差不多, 数组适合快速删除某个元素链表则可以快速的保存数组并且可以是不连续的单项链表;数据从第一个指向最后一个实现代码: //定义动态链表 clas
threadLocal实例 bijian1013 java thread java多线程 threadLocal
实例1： package com.bijian.thread; public class MyThread extends Thread { private static ThreadLocal tl = new ThreadLocal() { protected synchronized Object initialValue() { return new Inte
activemq安全设置—设置admin的用户名和密码 bijian1013 java activemq
ActiveMQ使用的是jetty服务器, 打开conf/jetty.xml文件，找到 <bean id="adminSecurityConstraint" class="org.eclipse.jetty.util.security.Constraint"> <p
【Java范型一】Java范型详解之范型集合和自定义范型类 bit1129 java
本文详细介绍Java的范型，写一篇关于范型的博客原因有两个，前几天要写个范型方法(返回值根据传入的类型而定)，竟然想了半天，最后还是从网上找了个范型方法的写法；再者，前一段时间在看Gson, Gson这个JSON包的精华就在于对范型的优雅简单的处理，看它的源代码就比较迷糊，只其然不知其所以然。所以，还是花点时间系统的整理总结下范型吧。范型内容范型集合类范型类
【HBase十二】HFile存储的是一个列族的数据 bit1129 hbase
在HBase中，每个HFile存储的是一个表中一个列族的数据，也就是说，当一个表中有多个列簇时，针对每个列簇插入数据，最后产生的数据是多个HFile，每个对应一个列族，通过如下操作验证 1. 建立一个有两个列族的表 create 'members','colfam1','colfam2' 2. 在members表中的colfam1中插入50*5
Nginx 官方一个配置实例 ronin47 nginx 配置实例
user www www; worker_processes 5; error_log logs/error.log; pid logs/nginx.pid; worker_rlimit_nofile 8192; events { worker_connections 4096;} http { include conf/mim
java-15.输入一颗二元查找树，将该树转换为它的镜像，即在转换后的二元查找树中，左子树的结点都大于右子树的结点。用递归和循环 bylijinnan java
//use recursion public static void mirrorHelp1(Node node){ if(node==null)return; swapChild(node); mirrorHelp1(node.getLeft()); mirrorHelp1(node.getRight()); } //use no recursion bu
返回null还是empty bylijinnan java apache spring 编程
第一个问题，函数是应当返回null还是长度为0的数组（或集合）？第二个问题，函数输入参数不当时，是异常还是返回null？先看第一个问题有两个约定我觉得应当遵守： 1.返回零长度的数组或集合而不是null（详见《Effective Java》）理由就是，如果返回empty，就可以少了很多not-null判断： List<Person> list
[科技与项目]工作流厂商的战略机遇期 comsci 工作流
在新的战略平衡形成之前，这里有一个短暂的战略机遇期，只有大概最短6年，最长14年的时间，这段时间就好像我们森林里面的小动物，在秋天中，必须抓紧一切时间存储坚果一样，否则无法熬过漫长的冬季。。。。在微软，甲骨文，谷歌，IBM,SONY
过度设计-举例 cuityang 过度设计
过度设计，需要更多设计时间和测试成本，如无必要，还是尽量简洁一些好。未来的事情，比如访问量，比如数据库的容量，比如是否需要改成分布式都是无法预料的再举一个例子，对闰年的判断逻辑：　　1、 if($Year%4==0) return True; else return Fasle; 　　2、if ( ($Year%4==0 &am
java进阶，《Java性能优化权威指南》试读 darkblue086 java性能优化
记得当年随意读了微软出版社的.NET 2.0应用程序调试，才发现调试器如此强大，应用程序开发调试其实真的简单了很多，不仅仅是因为里面介绍了很多调试器工具的使用，更是因为里面寻找问题并重现问题的思想让我震撼，时隔多年，Java已经如日中天，成为许多大型企业应用的首选，而今天，这本《Java性能优化权威指南》让我再次找到了这种感觉，从不经意的开发过程让我刮目相看，原来性能调优不是简单地看看热点在哪里，
网络学习笔记初识OSI七层模型与TCP协议 dcj3sjt126com 学习笔记
协议：在计算机网络中通信各方面所达成的、共同遵守和执行的一系列约定　　计算机网络的体系结构：计算机网络的层次结构和各层协议的集合。　　两类服务：　　面向连接的服务通信双方在通信之前先建立某种状态，并在通信过程中维持这种状态的变化，同时为服务对象预先分配一定的资源。这种服务叫做面向连接的服务。　　面向无连接的服务通信双方在通信前后不建立和维持状态，不为服务对象
mac中用命令行运行mysql dcj3sjt126com mysql linux mac
参考这篇博客：http://www.cnblogs.com/macro-cheng/archive/2011/10/25/mysql-001.html 感觉workbench不好用（有点先入为主了）。 1，安装mysql 在mysql的官方网站下载 mysql 5.5.23 http://www.mysql.com/downloads/mysql/，根据我的机器的配置情况选择了64
MongDB查询（1）——基本查询[五] eksliang mongodb mongodb 查询 mongodb find
MongDB查询转载请出自出处：http://eksliang.iteye.com/blog/2174452 一、find简介 MongoDB中使用find来进行查询。 API:如下 function ( query , fields , limit , skip, batchSize, options ){.....} 参数含义： query:查询参数 fie
base64，加密解密经融加密，对接 y806839048 经融加密对接
String data0 = new String(Base64.encode(bo.getPaymentResult().getBytes(("GBK")))); String data1 = new String(Base64.decode(data0.toCharArray()),"GBK"); // 注意编码格式，注意用于加密，解密的要是同
JavaWeb之JSP概述 ihuning javaweb
什么是JSP？为什么使用JSP？ JSP表示Java Server Page，即嵌有Java代码的HTML页面。使用JSP是因为在HTML中嵌入Java代码比在Java代码中拼接字符串更容易、更方便和更高效。 JSP起源在很多动态网页中，绝大部分内容都是固定不变的，只有局部内容需要动态产生和改变。如果使用Servl
apple watch 指南啸笑天 apple
1. 文档 WatchKit Programming Guide（中译在线版 By @CocoaChina）译文译者原文概览 - 开始为 Apple Watch 进行开发 @星夜暮晨 Overview - Developing for Apple Watch 概览 - 配置 Xcode 项目 - Overview - Configuring Yo
java经典的基础题目 macroli java 编程
1.列举出 10个JAVA语言的优势 a:免费，开源，跨平台(平台独立性)，简单易用，功能完善，面向对象，健壮性，多线程，结构中立，企业应用的成熟平台, 无线应用 2.列举出JAVA中10个面向对象编程的术语 a:包，类，接口，对象，属性，方法，构造器，继承，封装，多态，抽象，范型 3.列举出JAVA中6个比较常用的包 Java.lang;java.util;java.io;java.sql;ja
你所不知道神奇的js replace正则表达式 qiaolevip 每天进步一点点学习永无止境纵观千象 regex
var v = 'C9CFBAA3CAD0'; console.log(v); var arr = v.split(''); for (var i = 0; i < arr.length; i ++) { if (i % 2 == 0) arr[i] = '%' + arr[i]; } console.log(arr.join('')); console.log(v.r
[一起学Hive]之十五-分析Hive表和分区的统计信息(Statistics) superlxw1234 hive hive分析表 hive统计信息 hive Statistics
关键字：Hive统计信息、分析Hive表、Hive Statistics 类似于Oracle的分析表，Hive中也提供了分析表和分区的功能，通过自动和手动分析Hive表，将Hive表的一些统计信息存储到元数据中。表和分区的统计信息主要包括：行数、文件数、原始数据大小、所占存储大小、最后一次操作时间等； 14.1 新表的统计信息对于一个新创建
Spring Boot 1.2.5 发布 wiselyman spring boot
Spring Boot 1.2.5已在7月2日发布，现在可以从spring的maven库和maven中心库下载。这个版本是一个维护的发布版，主要是一些修复以及将Spring的依赖提升至4.1.7(包含重要的安全修复)。官方建议所有的Spring Boot用户升级这个版本。项目首页 | 源

MyBatis完整笔记（搭建环境CURD、配置解析、单表结果集映射 多表查询一对多多对一、日志 分页 使用注解开发、动态SQL、mybatis缓存）

MyBatis

1.简介

1.1 什么是MyBatis

1.2 持久化

1.3 持久层

1.4 为什么需要Mybatis？

2.第一个Mybatis程序

2.1 搭建环境

2.2 创建一个子模块

（1）编写Mybatis的核心配置文件

（2）编写Mybatis工具类

（3）创建实体类

（4）dao层：UserDao接口和UserMapper.xml

（5）测试

2.3 可能会遇到的问题

2.4 运行思路

3.CURD

3.1编写接口

3.2编写对应的mapper.xml中的sql语句

3.3测试

3.4遇到的问题

3.5万能的Map

3.6模糊查询

4.配置解析

4.1环境配置（enviroments）

4.2属性（properties）

4.3类型别名（typeAliases）

（1）为具体实体类指定类型别名

（2）指定一个包名

（3）自定义类型别名

4.4映射器（mapper）

4.5设置（enviroments）

4.6其他

4.7生命周期和作用域

5.ResultMap结果集映射

5.1 实体类属性和数据库字段不匹配问题

5.2 resultMap

6.日志

6.1.STDOUT_LOGGING标准日志输出

6.2.LOG4J 拓展日志输出

7.分页

7.1 sql层面limit实现分页

7.2 使用RowBounds实现分页

7.3 分页插件

8.使用注解开发

8.1面向接口编程

8.2利用注解开发

8.3 采用注解CURD

8.4 Lombok注解插件

9.多表查询结果集映射

9.1 老师学生例子数据库表

9.2多对一

（1）测试环境搭建

（2）按照结果嵌套处理（类连接查询、重点）

（3）按照查询嵌套处理（类子查询）

9.3一对多

（1）测试环境搭建

（2）按照结果嵌套处理（类连接查询、重点）

（3）按照查询嵌套处理（类子查询）

10.动态SQL

10.1简介

10.2搭建环境

10.3 if标签

10.4 where标签

set标签

trim标签

10.5 foreach标签

10.6 choose、when、otherwise标签

10.7 提取SQL片段

11.缓存

11.1简介

11.2Mybatis缓存

11.3一级缓存

1.测试

2.一级缓存失效

11.4二级缓存

使用步骤

小结

11.5缓存原理

MyBatis完整笔记（搭建环境CURD、配置解析、单表结果集映射多表查询一对多多对一、日志分页使用注解开发、动态SQL、mybatis缓存）