MyBatis 操作数据库

目录

什么是MyBatis?

注释

@Mapper注释的介绍和使用

@Select注释的介绍和使用

@SpringBootTest注释的介绍和使用

@Test注释的介绍的使用

MyBatis入门​

1）准备工作

<1>创建工程​

<2>数据准备​

2）配置数据库连接字符串

3）写持久层代码​

4）单元测试

MyBatis的基础操作​

打印日志

参数传递​

1）传递一个参数

2）传递多个参数

增(Insert)​

删(Delete)​

改(Update)​

查(Select)​

1）起别名​

2）结果映射

3）开启驼峰命名(推荐)​

MyBatis XML配置文件

配置连接字符串和MyBatis​

写持久层代码​

添加 mapper 接口​

添加 UserInfoXMLMapper.xml​

增删改查操作​

1）增(Insert)

2）删(Delete)

3）改(Update)

4）查(select)

（1）起别名

（2）结果映射

（3）开启驼峰命名

其他查询操作​

多表查询​

#{} 和 ${} ​【重点】

#{} 和${} 使用​

#{} 和${} 区别

1. 性能更高

2. 更安全(防止SQL注入)​

排序功能​

like 查询​

内置函数 concat() 

动态sql

标签​

标签

标签​

标签

标签​

---

什么是MyBatis?

MyBatis是一款优秀的持久层框架，用于简化JDBC的开发。​

持久层：指的就是持久化操作的层, 通常指数据访问层(dao), 是用来操作数据库的

简单来说 MyBatis 是更简单完成程序和数据库交互的框架，也就是更简单的操作和读取数据库工具​

---

注释

在本篇博客中出现的所有注释小编都提到这个章节进行介绍.但是在之前的博客中进行介绍的注释，这里就不做过多的介绍。

@Mapper注释的介绍和使用

@Mapper
public interface UserInfoMapper {@Select("select * from user_info")List<UserInfo> getUserInfoAll();
}

告诉 Spring 框架这是一个与数据库交互的 Mapper 接口，Spring 会自动生成该接口的代理对象，在运行时通过代理对象执行 SQL 映射语句，实现数据库的增删改查操作。

---

@Select注释的介绍和使用

@Mapper
public interface UserInfoMapper {@Select("select * from user_info")List<UserInfo> getUserInfoAll();
}

通过在 Mapper 接口的方法上添加 @Select 注解，并在注解中编写 SQL 查询语句，MyBatis 框架在运行时会根据该注解对应的方法调用，执行相应的 SQL 查询，并将查询结果按照配置或默认规则进行映射处理，返回给调用方。例如，可用于从数据库表中查询特定条件的数据记录，如获取用户信息、订单信息等。

---

@SpringBootTest注释的介绍和使用

启动一个完整的 Spring 应用程序上下文，加载所有配置的 Bean、自动配置以及配置文件。基于此，能够对应用程序的各个组件（如 Controller、Service、Repository 等 ）进行全面测试，验证它们是否能正常协同工作 。

package org.example.mybatis_test.Mapper;import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;import static org.junit.jupiter.api.Assertions.*;@SpringBootTest
class UserInfoMapperTest {@Autowiredprivate UserInfoMapper userInfoMapper;@Testvoid getUserInfoAll() {System.out.println(userInfoMapper.getUserInfoAll());}
}

---

@Test注释的介绍的使用

标记在测试类的方法上，使该方法成为一个可单独执行的测试单元。通过运行这些被 @Test 注解标记的方法，可以验证代码中特定功能或逻辑的正确性。例如，验证一个计算方法的输出结果是否符合预期，或者验证数据库操作是否成功等。

代码展示：

同上一个代码一样。

---

---

MyBatis入门​

Mybatis操作数据库的步骤：​
1. 准备工作(创建springboot工程、数据库表准备、实体类)​
2. 引入Mybatis的相关依赖，配置Mybatis(数据库连接信息)​
3. 编写SQL语句(注解/XML)​
4. 测试

1）准备工作

<1>创建工程​

这里的创建工程就是创建spring boot项目，与前面小编创建项目的不同点在于多引入两个依赖，如下图所示。分别是MyBatis Framework、Mysql Drive

这里小编要多一句嘴，对于这个依赖的引入是非常容易出错的，尤其是对于一些在校的大学生这个依赖的引入非常容易出现问题，即为网络的问题。

不要使用校园网！不要使用校园卡的热点！切换成自己最常用的那张卡的热点！不然真的捣鼓一整天就弄不出来！

<2>数据准备​

(1)创建用户表, 并创建对应的实体类User​

如上图所示，小编已经在MySQL中创建好了对应的数据库、数据表、以及表的内容...

sql代码如下示：

-- 删除数据库（如果存在）
DROP DATABASE IF EXISTS mybatis_test;
-- 创建数据库
CREATE DATABASE mybatis_test DEFAULT CHARACTER SET utf8mb4;-- 使用数据库
USE mybatis_test;-- 删除表（如果存在）
DROP TABLE IF EXISTS user_info;
-- 创建用户表
CREATE TABLE `user_info` (`id` INT(11) NOT NULL AUTO_INCREMENT,`username` VARCHAR(127) NOT NULL,`password` VARCHAR(127) NOT NULL,`age` TINYINT(4) NOT NULL,`gender` TINYINT(4) DEFAULT '0' COMMENT '1-男 2-女 0-默认',`phone` VARCHAR(15) DEFAULT NULL,`delete_flag` TINYINT(4) DEFAULT 0 COMMENT '0-正常, 1-删除',`create_time` DATETIME DEFAULT now(),`update_time` DATETIME DEFAULT now() ON UPDATE now(),PRIMARY KEY (`id`)
) ENGINE = INNODB DEFAULT CHARSET = utf8mb4;-- 插入用户信息
INSERT INTO user_info (username, `password`, age, gender, phone)
VALUES ('admin', 'admin', 18, 1, '18612340001');
INSERT INTO user_info (username, `password`, age, gender, phone)
VALUES ('zhangsan', 'zhangsan', 18, 1, '18612340002');
INSERT INTO user_info (username, `password`, age, gender, phone)
VALUES ('lisi', 'lisi', 18, 1, '18612340003');
INSERT INTO user_info (username, `password`, age, gender, phone)
VALUES ('wangwu', 'wangwu', 18, 1, '18612340004');

不想手敲代码的，直接cv小编的即可！

(2)创建对应的实体类 UserInfo​

在MySQL中把数据库准备好之后，就需要在我们的Mybatis中创建一个类来对应上MySQL中的数据的字段，MySQL中的数据字段和程序中对应的代码如下示：

MySQL中的数据字段：

程序中对应的代码：

package org.example.mybatis_test.model;import lombok.Data;import java.util.Date;
@Data
public class UserInfo {private int id;private String username;private String password;private Integer age;private Integer gender;private String phone;private Integer deleteFlag;private Date createTime;private Date updateTime;}

这两个地方的字段示一一对应的关系。

---

2）配置数据库连接字符串

Mybatis中要连接数据库，需要数据库相关参数配置​
• MySQL驱动类​
• 登录名
• 密码
• 数据库连接字符串

复制代码：

#数据库相关配置
spring:datasource:url: jdbc:mysql://127.0.0.1:3306/mybatis_test?characterEncoding=utf8&useSSL=falseusername: rootpassword: rootdriver-class-name: com.mysql.cj.jdbc.Driver

注意，这里大家不要盲目地复制，看清自己数据库地用户名、密码、地址、端口...但凡有一个与自己地数据库信息对应不上都会导致报错，所以大家不要盲目地跟随小编。小编还是那句话，每个同学的电脑配置环境配置都是不尽相同，所以要学会自己去变通以及解决问题。

---

3）写持久层代码​

大家先扫一眼小编的目录，是由哪些功能实现的。

（1）UserInfoMapper接口

@Mapper
public interface UserInfoMapper {@Select("select * from user_info")List<UserInfo> getUserInfoAll();
}

如上代码，"select * from user_info"这个语句与我们MySQL中查询整张表的格式是一样的【这里要注意，这个表的名字一定要和MySQL数据库中存储的表头名字是一样的，不然就会报错！】，下一句的语句就是创建一个List去存储我们从这张表中获取的全部数据，通过getUserInfoAll()这个方法。

如上述这个代码就是持久层的代码，我们一般把这个代码统一放在Mapper这个包下，方便企业中进行管理。【这个包下代码都是添加了@Mapper注解的】

（2）UserService

package org.example.mybatis_test.Service;import org.example.mybatis_test.Mapper.UserInfoMapper;
import org.example.mybatis_test.model.UserInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;import java.util.List;
@Service
public class UserService {@Autowiredprivate UserInfoMapper userInfoMapper;public List<UserInfo> getUserAll() {return userInfoMapper.getUserInfoAll();}
}

（3）UserController

package org.example.mybatis_test.Controller;import org.example.mybatis_test.Service.UserService;
import org.example.mybatis_test.model.UserInfo;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;import java.util.List;
@RestController
@RequestMapping("/user")
public class UserController {@Autowiredprivate UserService userService;@RequestMapping("/getUserAll")public List<UserInfo> getUserAll() {System.out.println(userService.getUserAll());return userService.getUserAll();}
}

上述代码已经基本实现了我们从MySQL中获取user_info这个表全部内容的需求了。接下来我们在测试类中测试一下这个代码是否能够顺利访问到MySQL数据库中的代码。

代码展示：

package org.example.mybatis_test;import org.example.mybatis_test.Mapper.UserInfoMapper;
import org.example.mybatis_test.model.UserInfo;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;import java.util.List;@SpringBootTest
class MybatisTestApplicationTests {@Autowired   //注入进来private UserInfoMapper userInfoMapper;@Testvoid contextLoads() {List<UserInfo> userInfos = userInfoMapper.getUserInfoAll();System.out.println(userInfos);}
}

结果展示：

如上图所示，我们在运行测试代码之后呢，也是顺利在控制台获取到了MySQL数据库中，user_info表中的全部信息。

那在浏览器中呢？接下来我们通过Controller中的路由进行一个访问,验证一下我们这个代码在http的请求下能否顺利访问到MySQL数据库中指定路径中的信息。

（1）先把我们项目先启动起来

如上图所示，我们的项目顺利启动！

（2）在浏览器中向后端发起http请求

如上图所示，我们也成功在浏览器中通过http请求获取到MySQL数据库中的信息了。

---

那是不是所有的测试都只能在同一个测试类中进行，能不能有一种简便方法直接对某一方法直接生成对应的测试类。那当然有了，接下来我们介绍一下单元测试

4）单元测试

以UserInfoMapper举例：

（1）在UserInfoMapper点击鼠标左键

（2）选择Test

（3）选择对应的方法

（4）在目录中找到对应的方法然后进行测试

（5）填写自己的测试需求

package org.example.mybatis_test.Mapper;import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;import static org.junit.jupiter.api.Assertions.*;@SpringBootTest
class UserInfoMapperTest {@Autowiredprivate UserInfoMapper userInfoMapper;@Testvoid getUserInfoAll() {System.out.println(userInfoMapper.getUserInfoAll());}
}

结果展示：

如上图所示，测试的结果与我们使用Spring boot架构自身提供的那个Test类进行测试一样。

---

MyBatis的基础操作​

上面我们学习了Mybatis的查询操作, 接下来我们学习MyBatis的增, 删, 改操作​
在学习这些操作之前, 我们先来学习MyBatis日志打印​。

打印日志

在Mybatis当中我们可以借助日志, 查看到sql语句的执行、执行传递的参数以及执行结果​
在配置文件中进行配置即可

下面这些内容是放在配置文件yml中的。

mybatis:configuration:# 配置打印MyBatis日志log-impl: org.apache.ibatis.logging.stdout.StdOutImpl

运行结果：

①: 查询语句​
②: 传递参数及类型​
③: SQL执行结果​

---

参数传递​

在进行参数传递之前，我们要明确我们的MySQL数据表中有哪些参数【哪些字段】，我们才能够通过这个参数去进行查询。通过参数的传递我们可以找到我们想要的数据，比如我们只想查看user_info表中名字叫zhangsan的人的所有信息，那我们就要通过名字进行定位。

1）传递一个参数

如上图我们看到这个delete_fla这一列中只有叫lisi的这个人是1，那咱们就通过下述代码来查找delete_flag为1的人，预期的结果应该是只出现id为1，3，4的人。

代码示例：

@Mapper
public interface UserInfoMapper {/*** 参数的传递【一个】*/@Select("select * from user_info where delete_flag = #{deleteFlag}")List<UserInfo> getUserInfoAllByDeleteFlg(Integer deleteFlag);
}

单元测试的方式进行测试：

package org.example.mybatis_test.Mapper;import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;import static org.junit.jupiter.api.Assertions.*;@SpringBootTest
class UserInfoMapperTest {@Autowiredprivate UserInfoMapper userInfoMapper;@Testvoid getUserInfoAllByDeleteFlg() {System.out.println(userInfoMapper.getUserInfoAllByDeleteFlg(0));}}

结果展示：

结果如上图所示，我们确实是顺利的找到这三个人。

但是，此时我们要想一个问题，我们在Mapper代码中可得，其中

这两个名字是一样的，若名字不一样会不会出错呢？我们接下来就开始试验一下，寻找答案

由上述的结果，我们看出得到的结果是一样的。那我们是不是可以笃定这个参数一不一致都不会影响我们的结果呢？还是说只是在特殊情况下才可以这么做呢？我们留下一个疑问，继续往前走。

2）传递多个参数

上面是传递一个参数的情况，要是传递两个参数得到的又是一些什么信息呢？我们依旧是先看一下这个MySQL数据库的这个user_info这个表中有写什么信息先。

如上图，假设我们要查询gander为1，且delete_flag为0的信息，只能查到两条。

代码展示：

@Mapper
public interface UserInfoMapper {/*** 参数的传递【多个】*/@Select("select * from user_info where delete_flag = #{deleteFlag} and gender = #{gender}")List<UserInfo> getUserInfoAllByDeleteFlg2(Integer deleteFlag,Integer gender);
}

测试代码：

package org.example.mybatis_test.Mapper;import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;import static org.junit.jupiter.api.Assertions.*;@SpringBootTest
class UserInfoMapperTest {@Autowiredprivate UserInfoMapper userInfoMapper;@Testvoid getUserInfoAllByDeleteFlg2() {System.out.println(userInfoMapper.getUserInfoAllByDeleteFlg2(0,1));}}

结果展示：

如上图所示，又符合我们刚开始的预期，返回的是id为1、2的两条信息。

但是我们把问题又抛到上面遗留的那个问题，是否参数都要一样才可以从数据库中获取信息呢？心动不如行动，我们测试一下便能知晓答案。

改动后的代码：

@Mapper
public interface UserInfoMapper {/*** 参数的传递【多个】*/@Select("select * from user_info where delete_flag = #{deleteFlag} and gender = #{gender}")List<UserInfo> getUserInfoAllByDeleteFlg2(Integer flag,Integer gender);
}

测试结果：

唉！报错了！那这就值得我们总结一下咯。经过多测实验，小编发现当传递的参数只有一个的时候，参数的名字对不对应都可以获取到预期的结果。但是一旦参数超过一个的时候，参数的名称必须对应才可以找到数据库中对应的数据！

---

增(Insert)​

代码展示：

1）方法代码：

@Mapper
public interface UserInfoMapper {/*** 1.增*/@Options(useGeneratedKeys = true,keyProperty = "id")@Insert("insert into user_info (username,password,age,gender) values (#{username},#{password},#{age},#{gender})")Integer insertUserInfo(UserInfo userInfo);
}

2）测试代码：

package org.example.mybatis_test.Mapper;import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;import static org.junit.jupiter.api.Assertions.*;@SpringBootTest
class UserInfoMapperTest {@Autowiredprivate UserInfoMapper userInfoMapper;@Testvoid insertUserInfo() {UserInfo userInfo = new UserInfo();userInfo.setUsername("dayun");userInfo.setPassword("123456");userInfo.setAge(18);userInfo.setGender(1);Integer result = userInfoMapper.insertUserInfo(userInfo);System.out.println("影响行数: "+result+","+"id: "+userInfo.getId());}
}

结果展示：

如上图所示，成功在数据库中添加了这条数据！测试成功！

---

删(Delete)​

代码展示：

1）方法代码：

@Mapper
public interface UserInfoMapper {/*** 2.删*/@Delete("delete from user_info where id = #{id}")Integer delete(Integer id);
}

2）测试代码：

package org.example.mybatis_test.Mapper;import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;import static org.junit.jupiter.api.Assertions.*;@SpringBootTest
class UserInfoMapperTest {@Autowiredprivate UserInfoMapper userInfoMapper;@Testvoid delete() {Integer result = userInfoMapper.delete(19);System.out.println("影响行数: "+result);}
}

上述代码，是要删除id为19的数据【即我们刚刚插入的位置】。

结果展示：

由结果展示，刚刚我们添加到数据库的数据被删除掉了！测试成功！

---

改(Update)​

代码展示：

1）方法代码：

@Mapper
public interface UserInfoMapper {/*** 3.更新操作*/@Update("update user_info set password = #{password},age = #{age},gender = #{gender} where id = #{id}")Integer updateUserInfo(UserInfo userInfo);
}

2）测试代码：

package org.example.mybatis_test.Mapper;import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;import static org.junit.jupiter.api.Assertions.*;@SpringBootTest
class UserInfoMapperTest {@Autowiredprivate UserInfoMapper userInfoMapper;@Testvoid updateUserInfo() {UserInfo userInfo = new UserInfo();userInfo.setId(1);userInfo.setPassword("1122334455");userInfo.setAge(88);userInfo.setGender(1);Integer result = userInfoMapper.updateUserInfo(userInfo);System.out.println("影响行数: "+result);}}
}

如上述代码，是要把id为1的数据更新！

结果展示：

如上述三张图所示，id为1的数据已经更新了！测试成功！

---

查(Select)​

1）起别名​

代码展示：

1）方法代码：

@Mapper
public interface UserInfoMapper {// 1.起别名@Select("select id,username,password,age,gender,phone,delete_flag as " +"deleteFlag,create_time as createTime,update_time as updateTime from user_info")List<UserInfo> getUserInfoByUsername();
}

2）测试代码：

package org.example.mybatis_test.Mapper;import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;import static org.junit.jupiter.api.Assertions.*;@SpringBootTest
class UserInfoMapperTest {@Autowiredprivate UserInfoMapper userInfoMapper;@Testvoid getUserInfoByUsername() {System.out.println(userInfoMapper.getUserInfoByUsername());}}

结果展示：

如上图所示，数据库中的所有内容都展示出来了！测试成功！【包括UserInfo属性与数据库中字段不同的部分也已经显示出来了！】，即映射上了！

2）结果映射

代码展示：

1）方法代码：

@Mapper
public interface UserInfoMapper {// 2.结果映射【结果能不能复用呢？】@Results(id = "resultMap",value = {@Result(column = "delete_flag",property = "deleteFlag"),@Result(column = "create_time",property = "createTime"),@Result(column = "update_time",property = "updateTime")})@Select("select * from user_info")List<UserInfo> getUserInfoByResult();
}

如上述代码所示，是利用注解@Result的Map映射

2）测试代码：

package org.example.mybatis_test.Mapper;import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;import static org.junit.jupiter.api.Assertions.*;@SpringBootTest
class UserInfoMapperTest {@Autowiredprivate UserInfoMapper userInfoMapper;@Testvoid getUserInfoByResult() {System.out.println(userInfoMapper.getUserInfoByResult());}
}

结果展示：

3）开启驼峰命名(推荐)​

代码展示：

1）方法代码：

@Mapper
public interface UserInfoMapper {// 3.驼峰自动转换的方式@Select("select * from user_info")List<UserInfo> getUserInfoByChange();
}

mybatis:configuration:map-underscore-to-camel-case: true

上述这个代码是一个配置文件，要更新我们的配置文件才能使用这个功能！

2）测试代码：

package org.example.mybatis_test.Mapper;import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;import static org.junit.jupiter.api.Assertions.*;@SpringBootTest
class UserInfoMapperTest {@Autowiredprivate UserInfoMapper userInfoMapper;@Testvoid getUserInfoByChange() {System.out.println(userInfoMapper.getUserInfoByChange());}
}

结果展示：

---

MyBatis XML配置文件

Mybatis的开发有两种方式：​
        1. 注解
        2. XML​
上面学习了注解的方式, 接下来我们学习XML的方式​
使用Mybatis的注解方式，主要是来完成一些简单的增删改查功能. 如果需要实现复杂的SQL功能，建议使用XML来配置映射语句，也就是将SQL语句写在XML配置文件中. ​
MyBatis XML的方式需要以下两步:​
        1. 配置数据库连接字符串和MyBatis​
        2. 写持久层代码

---

配置连接字符串和MyBatis​

#数据库相关配置
spring:datasource:url: jdbc:mysql://127.0.0.1:3306/mybatis_test?characterEncoding=utf8&useSSL=falseusername: rootpassword: yqy,25602Xdriver-class-name: com.mysql.cj.jdbc.Drivermybatis:mapper-locations: classpath:mybatis/**Mapper.xml

---

写持久层代码​

1）方法定义 Interface

2）方法实现: XXX.xml​

如上图所示，这个.xml文件的路径要按照配置文件中的路径！

---

添加 mapper 接口​

添加 UserInfoXMLMapper.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="org.example.mybatis.mapper.UserInfoXmlMapper"></mapper>

这个文件也一定要根据自己的路径来配！【即mapper标签下的，namespace属性】

---

增删改查操作​

1）增(Insert)

代码展示：

package org.example.mybatis.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.example.mybatis.model.UserInfo;
import java.util.List;
@Mapper    
public interface UserInfoXmlMapper {/*** 1.增*/Integer insert(UserInfo userInfo);
}

    <insert id="insert">insert into user_info (username,password,age,gender)values (#{username},#{password},#{age},#{gender})</insert>

package org.example.mybatis.mapper;
/**
这里的包我就不展示了，需要再导入
*/
@SpringBootTest
class UserInfoXmlMapperTest {@Autowiredprivate UserInfoXmlMapper userInfoXmlMapper; /*** 1.增*/@Testvoid insert() {UserInfo userInfo = new UserInfo();userInfo.setUsername("云惠强");userInfo.setPassword("8999999998");userInfo.setAge(45);userInfo.setGender(2);Integer result = userInfoXmlMapper.insert(userInfo);System.out.println("插入的数量： "+result);}
}

结果展示：

如上图所示，数据库中出现了新的数据！测试成功！

2）删(Delete)

代码展示：

package org.example.mybatis.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.example.mybatis.model.UserInfo;
import java.util.List;
@Mapper    
public interface UserInfoXmlMapper {/*** 2.删除*/Integer delete(Integer id);
}

    <delete id="delete">delete from user_info where id = #{id}</delete>

package org.example.mybatis.mapper;
/**
这里的包我就不展示了，需要再导入
*/
@SpringBootTest
class UserInfoXmlMapperTest {@Autowiredprivate UserInfoXmlMapper userInfoXmlMapper; @Testvoid delete() {Integer result = userInfoXmlMapper.delete(13);}
}

结果展示：

如上图所示，我们的代码是要删除id为13的数据！id为13的数据成功删除！测试成功！

3）改(Update)

代码展示：

package org.example.mybatis.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.example.mybatis.model.UserInfo;
import java.util.List;
@Mapper    
public interface UserInfoXmlMapper {/*** 3.改【更新】*/Integer update(UserInfo userInfo);
}

/*** 3.改【更新】*/Integer update(UserInfo userInfo);

package org.example.mybatis.mapper;
/**
这里的包我就不展示了，需要再导入
*/
@SpringBootTest
class UserInfoXmlMapperTest {@Autowiredprivate UserInfoXmlMapper userInfoXmlMapper; @Testvoid update() {UserInfo userInfo = new UserInfo();userInfo.setId(11);userInfo.setPassword("5201314");userInfo.setAge(21);userInfo.setGender(1);Integer result = userInfoXmlMapper.update(userInfo);System.out.println("影响行数: "+result);}
}

结果展示：

如图所示，

4）查(select)

（1）起别名

这里起别名的方式和注解起别名的方式一致。

（2）结果映射

代码展示：

package org.example.mybatis.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.example.mybatis.model.UserInfo;
import java.util.List;
@Mapper    
public interface UserInfoXmlMapper {/*** 3.改【更新】*/Integer update(UserInfo userInfo);
}

    <resultMap id="BaseMap" type="org.example.mybatis.model.UserInfo"><id column="id" property="id"></id><result column="delete_flag" property="deleteFlag"></result><result column="create_time" property="createTime"></result><result column="update_time" property="updateTime"></result></resultMap><select id="selectAllUser2" resultMap="BaseMap">select * from user_info</select>

package org.example.mybatis.mapper;
/**
这里的包我就不展示了，需要再导入
*/
@SpringBootTest
class UserInfoXmlMapperTest {@Autowiredprivate UserInfoXmlMapper userInfoXmlMapper; @Testvoid selectAllUser2() {System.out.println(userInfoXmlMapper.selectAllUser2());}
}

结果展示：

（3）开启驼峰命名

这个方式也与注解的方式一致，只要在yml文件中进行配置相关文件即可！

---

其他查询操作​

多表查询​

现在我们的数据库中有两张表，如下图所示：

代码展示：

package org.example.mybatis.model;
import lombok.Data;
import java.util.Date;
@Data
public class ArticleInfo {private Integer id;private String title;private String content;private Integer uid;private Integer deleteFlag;private Date createTime;private Date updateTime;private String username;private Integer gender;
}

package org.example.mybatis.mapper;
import org.apache.ibatis.annotations.Mapper;
import org.example.mybatis.model.ArticleInfo;
@Mapper
public interface ArticleInfoMapper {ArticleInfo selectByPrimaryKey(Integer id);ArticleInfo selectArticleAndUserById(Integer id);
}

<?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="org.example.mybatis.mapper.ArticleInfoMapper"><select id="selectByPrimaryKey" resultType="org.example.mybatis.model.ArticleInfo">select * from articleinfo where id = #{id}</select><select id="selectArticleAndUserById" resultType="org.example.mybatis.model.ArticleInfo">select ta.*,tb.username,tb.gender from articleinfo taleft join user_info tb on ta.uid = tb.id where ta.id = #{id}</select></mapper>

package org.example.mybatis.mapper;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import static org.junit.jupiter.api.Assertions.*;
@SpringBootTest
class ArticleInfoMapperTest {@Autowiredprivate ArticleInfoMapper articleInfoMapper;@Testvoid selectByPrimaryKey() {System.out.println(articleInfoMapper.selectByPrimaryKey(1));}@Testvoid selectArticleAndUserById() {System.out.println(articleInfoMapper.selectArticleAndUserById(1));}
}

结果展示：

---

#{} 和 ${} ​【重点】

MyBatis 参数赋值有两种方式, 咱们前面使用了 #{} 进行赋值, 接下来我们看下二者的区别​

#{} 和${} 使用​

代码展示：

package org.example.mybatis.mapper;
import org.apache.ibatis.annotations.*;
import org.example.mybatis.model.UserInfo;
import java.util.List;
@Mapper
public interface UserInfoMapper {/*** #和 $ 的区别*/// 为什么使用#而不使用$符号呢？使用一个例子来进行说明@Select("select * from user_info where username = #{username}")UserInfo getUserName(String username);@Select("select * from user_info where username = ${username}")UserInfo getUserName2(String username);
}

测试代码：

package org.example.mybatis.mapper;
/**
这里的包我就不展示了，需要再导入
*/
@SpringBootTest
class UserInfoXmlMapperTest {@Autowiredprivate UserInfoXmlMapper userInfoXmlMapper; // # :预编译sql@Testvoid getUserName() {System.out.println(userInfoMapper.getUserName("wangwu"));}// $【出错】 :即时sql@Testvoid getUserName2() {System.out.println(userInfoMapper.getUserName2("wangwu"));}
}

结果展示：

结果一【${}】：

结果二【#{}】：

如上图的两个结果，当我们使用${}的时候报错了，但是使用#{}没有报错，这两个不都是传参数吗？为什么一个会编译通过，一个却出现了sql语句错误的信息？这个问题留到后面讲二者去别的时候再解答。同时小编又发现了，当我们传的参数是Integer类型的时候，两者都可以拿到正确的结果，这又是为什么呢？

---

#{} 和${} 区别

#{} 和 ${} 的区别就是预编译SQL和即时SQL 的区别.​

1. 性能更高

绝大多数情况下, 某一条 SQL 语句可能会被反复调用执行, 或者每次执行的时候只有个别的值不同(比如 select 的 where 子句值不同, update 的 set 子句值不同, insert 的 values 值不同). 如果每次都需要经过上面的语法解析, SQL优化、SQL编译等，则效率就明显不行了. 

预编译SQL，编译一次之后会将编译后的SQL语句缓存起来，后面再次执行这条语句时，不会再次编译(只是输入的参数不同), 省去了解析优化等过程, 以此来提高效率​

2. 更安全(防止SQL注入)​

SQL注入：是通过操作输入的数据来修改事先定义好的SQL语句，以达到执行代码对服务器进行攻击的方法。

下面举个例子更便于理解：

如上图所示，我们可以看到这张表里面的所有数据，当我们使用where语句，只想找到username为"admin"的这个人的信息的时候，我们加上了一个or语句却查到了所有人的信息，这是一个相当危险的操作！！！

这个sql注入的情况最经常发生在用户登录的情况！

---

排序功能​

对于这个排序功能，我们使用分别使用#{} 和${}来试验一下，看会不会报错？是只有其中一个行，还是两个都行？还是两个都不行？还是在某一些条件下行，在某一些条件下不信？实践会告诉我们答案。

代码示例：

package org.example.mybatis.mapper;
import org.apache.ibatis.annotations.*;
import org.example.mybatis.model.UserInfo;
import java.util.List;
@Mapper
public interface UserInfoMapper {/*** 排序之使用 # 和 $ 的区别*/@Select("select * from user_info order by id #{order}")List<UserInfo> queryUserListByOrder(String order);@Select("select * from user_info order by id ${order}")List<UserInfo> queryUserListByOrder2(String order);
}

测试代码：

package org.example.mybatis.mapper;
/**
这里的包我就不展示了，需要再导入
*/
@SpringBootTest
class UserInfoXmlMapperTest {@Autowiredprivate UserInfoXmlMapper userInfoXmlMapper; // 报错[#]@Testvoid queryUserListByOrder() {System.out.println(userInfoMapper.queryUserListByOrder("asc"));}// 没报错[$]@Testvoid queryUserListByOrder2() {System.out.println(userInfoMapper.queryUserListByOrder2("desc"));}
}

结果展示：

结果一【${}】：

结果二【#{}】：

如上述的两个结果可知，当使用#{}发生了报错，而使用${}的时候却能运行成功。这这这不对啊，我们刚刚才说#{}性能更强啊，怎么会报错呢？让我们一起来分析一下这个报错信息，这里出现了' 'asc' ' 出现了两个单引号，导致识别不出来了。主要原因是因为，#{}当识别到这个类型是一个String类型的时候就会自动加上一对引号，导致最后sql语句的错误！

---

like 查询​

那我们又要探讨一下这个like语句了到底是使用#{}还是${}，因为在sql语句中，是使用类似于下图

我们想让这个引号加在'% %'百分号的两边，而不是参数的两边，而#{}只能加载参数的两边，${}又不加引号。有想法我们就大胆去尝试，实验出真知！我们要实践才能知道结果

代码展示：

package org.example.mybatis.mapper;
import org.apache.ibatis.annotations.*;
import org.example.mybatis.model.UserInfo;
import java.util.List;
@Mapper
public interface UserInfoMapper {/*** like查询问题*/@Select("select * from user_info where username like '%${username}%'")List<UserInfo> queryUserListByLike(String username);
}

测试代码：

package org.example.mybatis.mapper;
/**
这里的包我就不展示了，需要再导入
*/
@SpringBootTest
class UserInfoXmlMapperTest {@Autowiredprivate UserInfoXmlMapper userInfoXmlMapper; @Testvoid queryUserListByLike() {userInfoMapper.queryUserListByLike("yun");}
}

结果展示：

结果展示1【${}】:

结果展示2【#{}】：

结果如上展示，${}虽然能正确展示结果，但是毕竟还是有注入的风险。那有没有什么办法能够解决这个问题的呢？那当然了，我们程序员最擅长的事情就是偷懒了！

---

内置函数 concat() 

package org.example.mybatis.mapper;
import org.apache.ibatis.annotations.*;
import org.example.mybatis.model.UserInfo;
import java.util.List;
@Mapper
public interface UserInfoMapper {/*** 既然like查询使用$符号，就要考虑到注入得问题* 那怎么解决呢？* 使用CONCAT函数？*/@Select("select * from user_info where username like CONCAT('%',#{username},'%')")List<UserInfo> queryUserListByLike2(String username);
}

测试代码：

package org.example.mybatis.mapper;
/**
这里的包我就不展示了，需要再导入
*/
@SpringBootTest
class UserInfoXmlMapperTest {@Autowiredprivate UserInfoXmlMapper userInfoXmlMapper; @Testvoid queryUserListByLike2() {userInfoMapper.queryUserListByLike2("yun");}
}

结果展示：

如上图所示，能正确得得到结果！测试成功！方法生效！

---

动态sql

动态 SQL 是Mybatis的强大特性之一，能够完成不同条件下不同的 sql 拼接​。

动态 SQL 是指在程序运行时根据条件或参数的不同生成和执行 SQL 语句的技术，与在编译时就确定好的静态 SQL 相对。其主要思想是依据不同需求和条件，灵活生成可变的 SQL 语句，涵盖查询、插入、更新、删除等操作 。

<if>标签​

mapper代码：

package org.example.mybatis.mapper;
import org.apache.ibatis.annotations.*;
import org.example.mybatis.model.UserInfo;
import java.util.List;
@Mapper
public interface UserInfoMapper {/*** <if test = "">标签</if>* @param userInfo* @return*/Integer insertByCondition(UserInfo userInfo);
}

xml代码：

    <select id="insertByCondition" >insert into user_info(username,password,age<if test="gender != null">, gender</if>) values (#{username},#{password},#{age}<if test="gender != null">, #{gender}</if>)</select>

测试代码：

package org.example.mybatis.mapper;
/**
这里的包我就不展示了，需要再导入
*/
@SpringBootTest
class UserInfoXmlMapperTest {@Autowiredprivate UserInfoXmlMapper userInfoXmlMapper; @Testvoid insertByCondition() {UserInfo userInfo = new UserInfo();userInfo.setUsername("云鹏");userInfo.setPassword("33445566");userInfo.setAge(18);System.out.println(userInfoXmlMapper.insertByCondition(userInfo));}
}

如上述代码可知，我们使用if标签，让gender这个字段变得动态起来。如果有参数传入则接受，如果没有参数传入则为空。

结果展示：

如上图所示，id为5的user的gender字段为默认的0；

---

但是if标签其实有bug,就是逗号的问题，那我们就需要使用另外一个功能较大的标签来进行解决

<trim>标签

之前的插入用户功能，只是有一个 gender 字段可能是选填项，如果有多个字段，一般考虑使用标签结合标签，对多个字段都采取动态生成的方式。标签中有如下属性：

• prefix：表示整个语句块，以prefix的值作为前缀​
• suffix：表示整个语句块，以suffix的值作为后缀​
• prefixOverrides：表示整个语句块要去除掉的前缀​
• suffixOverrides：表示整个语句块要去除掉的后缀​

mapper代码：

package org.example.mybatis.mapper;
import org.apache.ibatis.annotations.*;
import org.example.mybatis.model.UserInfo;
import java.util.List;
@Mapper
public interface UserInfoMapper {/*** <trim>标签</trim>* 是否能解决逗号问题*/Integer insertByCondition2(UserInfo userInfo);
}

xml代码：

    <select id="insertByCondition2">insert into user_info<trim prefix="(" suffix=")" suffixOverrides="," ><if test="username!= null">username,</if><if test="password != null">password,</if><if test="age != null">age,</if><if test="gender != null">gender</if></trim>values<trim prefix="(" suffix=")" suffixOverrides=","><if test="username != null">#{username},</if><if test="password != null">#{password},</if><if test="age != null">#{age},</if><if test="gender != null">#{gender}</if></trim></select>

测试代码：

package org.example.mybatis.mapper;
/**
这里的包我就不展示了，需要再导入
*/
@SpringBootTest
class UserInfoXmlMapperTest {@Autowiredprivate UserInfoXmlMapper userInfoXmlMapper; @Testvoid insertByCondition2() {UserInfo userInfo = new UserInfo();userInfo.setGender(2);System.out.println(userInfoXmlMapper.insertByCondition2(userInfo));}
}

结果展示：

结果如上图所示，id为6的user，只有一个gender的信息！测试成功，方法失效！

---

<where>标签​

在日常生活中，我们需要一些筛选的功能。比如小编在逛拼多多的时候，小编就喜欢筛选免邮费的！【毕竟小编是一个穷鬼！】

1）报错版本：

mapper代码:

package org.example.mybatis.mapper;
import org.apache.ibatis.annotations.*;
import org.example.mybatis.model.UserInfo;
import java.util.List;
@Mapper
public interface UserInfoMapper {/*** <where>标签*/// 报错List<UserInfo> queryUserByCondition(UserInfo userInfo);
}

xml代码:

    <select id="queryUserByCondition" resultType="org.example.mybatis.model.UserInfo">select * from user_infowhere<if test="age != null">age = #{age}</if><if test="gender != null">and gender = #{gender}</if><if test="deleteFlag != null">and delete_flag = #{deleteFlag}</if></select>

测试代码：

package org.example.mybatis.mapper;
/**
这里的包我就不展示了，需要再导入
*/
@SpringBootTest
class UserInfoXmlMapperTest {@Autowiredprivate UserInfoXmlMapper userInfoXmlMapper; @Testvoid queryUserByCondition() {UserInfo userInfo = new UserInfo();userInfo.setGender(1);System.out.println(userInfoXmlMapper.queryUserByCondition(userInfo));}
}

结果展示：

结果如上图，报错了已经！这里报错的主要原是因为这里只传了gender这个参数，导致前面的and无法被sql语句识别到！所以进行了报错，因此解决方法是将多余的and去除！这时候我们第一时间想到了我们刚刚去多余的逗号使用的<trim>标签。

2）<trim>标签版本

mapper代码:

package org.example.mybatis.mapper;
import org.apache.ibatis.annotations.*;
import org.example.mybatis.model.UserInfo;
import java.util.List;
@Mapper
public interface UserInfoMapper {// 正确【<trim>标签】List<UserInfo> queryUserByCondition2(UserInfo userInfo);
}

xml代码:

    <select id="queryUserByCondition2" resultType="org.example.mybatis.model.UserInfo">select * from user_info<trim prefix="where" prefixOverrides="and"><if test="age != null">age = #{age}</if><if test="gender != null">and gender = #{gender}</if><if test="deleteFlag != null">and delete_flag = #{deleteFlag}</if></trim></select>

测试代码：

package org.example.mybatis.mapper;
/**
这里的包我就不展示了，需要再导入
*/
@SpringBootTest
class UserInfoXmlMapperTest {@Autowiredprivate UserInfoXmlMapper userInfoXmlMapper; @Testvoid queryUserByCondition2() {UserInfo userInfo = new UserInfo();userInfo.setGender(1);System.out.println(userInfoXmlMapper.queryUserByCondition2(userInfo));}
}

结果展示：

如上图所示，我们查找了表中所有gender为1的user信息！

3）最简洁的版本：

mapper代码:

package org.example.mybatis.mapper;
import org.apache.ibatis.annotations.*;
import org.example.mybatis.model.UserInfo;
import java.util.List;
@Mapper
public interface UserInfoMapper {// 更简洁的标签【<where标签>】List<UserInfo> queryUserByCondition3(UserInfo userInfo);
}

xml代码:

    <select id="queryUserByCondition3" resultType="org.example.mybatis.model.UserInfo">select * from user_info<where><if test="age != null">age = #{age}</if><if test="gender != null">and gender = #{gender}</if><if test="deleteFlag != null">and delete_flag = #{deleteFlag}</if></where></select>

测试代码：

package org.example.mybatis.mapper;
/**
这里的包我就不展示了，需要再导入
*/
@SpringBootTest
class UserInfoXmlMapperTest {@Autowiredprivate UserInfoXmlMapper userInfoXmlMapper; @Testvoid queryUserByCondition3() {UserInfo userInfo = new UserInfo();userInfo.setGender(1);System.out.println(userInfoXmlMapper.queryUserByCondition2(userInfo));}
}

结果展示：

如上图的控制台信息可知，我们也是顺利通过<where>标签获取了表中符合标准的信息！

---

<set>标签

需求: 根据传入的用户对象属性来更新用户数据，可以使用标签来指定动态内容.​
接口定义: 根据传入的用户 id 属性，修改其他不为 null 的属性​

1）<trim>标签版本

mapper代码：

package org.example.mybatis.mapper;
import org.apache.ibatis.annotations.*;
import org.example.mybatis.model.UserInfo;
import java.util.List;
@Mapper
public interface UserInfoMapper {/*** 更新的动态sql,传值才更新，不传值不更新*/// <trim>标签List<UserInfo> updateByCondition(UserInfo userInfo);
}

xml代码：

    <update id="updateByCondition">update user_info<trim prefix="set" suffixOverrides=","><if test="password != null">password = #{password},</if><if test="age != null">age = #{age},</if><if test="gender != null">gender = #{gender}</if></trim>where id = #{id}</update>

测试代码：

package org.example.mybatis.mapper;
/**
这里的包我就不展示了，需要再导入
*/
@SpringBootTest
class UserInfoXmlMapperTest {@Autowiredprivate UserInfoXmlMapper userInfoXmlMapper; @Testvoid updateByCondition() {UserInfo userInfo = new UserInfo();userInfo.setId(1);userInfo.setPassword("55666778899");userInfo.setAge(33);userInfo.setGender(2);Integer result = userInfoXmlMapper.update(userInfo);System.out.println("影响行数: "+result);}
}

结果展示：

如上述结果展示，id为1的user已经更新！

2）简洁版本【<set>标签】

mapper代码：

package org.example.mybatis.mapper;
import org.apache.ibatis.annotations.*;
import org.example.mybatis.model.UserInfo;
import java.util.List;
@Mapper
public interface UserInfoMapper {/*** 更新的动态sql,传值才更新，不传值不更新*/// 简洁版本<set>List<UserInfo> updateByCondition2(UserInfo userInfo);
}

xml代码：

<update id="updateByCondition2"><set><if test="password != null">password = #{password},</if><if test="age != null">age = #{age},</if><if test="gender != null">gender = #{gender}</if></set>where id = #{id}</update>

测试代码：

package org.example.mybatis.mapper;
/**
这里的包我就不展示了，需要再导入
*/
@SpringBootTest
class UserInfoXmlMapperTest {@Autowiredprivate UserInfoXmlMapper userInfoXmlMapper; @Testvoid updateByCondition2() {UserInfo userInfo = new UserInfo();userInfo.setId(4);userInfo.setPassword("88990033");userInfo.setAge(36);userInfo.setGender(1);Integer result = userInfoXmlMapper.update(userInfo);System.out.println("影响行数: "+result);}
}

结果展示：

如上述结果所示，id为4的use的部分信息也得到了更新！

---

<foreach>标签​

对集合进行遍历时可以使用该标签。标签有如下属性：
• collection：绑定方法参数中的集合，如 List，Set，Map或数组对象​
• item：遍历时的每一个对象​
• open：语句块开头的字符串​
• close：语句块结束的字符串​
• separator：每次遍历之间间隔的字符串​
需求: 根据多个userid, 删除用户数据​

mapper代码：

package org.example.mybatis.mapper;
import org.apache.ibatis.annotations.*;
import org.example.mybatis.model.UserInfo;
import java.util.List;
@Mapper
public interface UserInfoMapper {/*** <foreach><foreach/>* 对集合进行遍历【批量插入、批量删除】*/// 1.批量删除Integer batchDelete(List<Integer> ids);
}

xml代码：

    <delete id="batchDelete">delete from user_infowhere id in<foreach collection="ids" open="(" close=")" item="id" separator=",">#{id}</foreach></delete>

测试代码：

package org.example.mybatis.mapper;
/**
这里的包我就不展示了，需要再导入
*/
@SpringBootTest
class UserInfoXmlMapperTest {@Autowiredprivate UserInfoXmlMapper userInfoXmlMapper; @Testvoid batchDelete() {List<Integer> ids = Arrays.asList(new Integer[]{4,5,6});userInfoXmlMapper.batchDelete(ids);}

结果展示：

结果如图所示，id为4，5，6的user信息全部被删除了！

---