1. 直接使用jdbc,访问数据库，创建Connection,ResultSet
2. 把jdbc操作进行了封装，创建了很多工具类，比如DBUtil
3. 持久层框架
(1)hibernate:全程的ORM框架。 实现java object ---表的映射，操作java对象操作数据库表
可以使用hibernate访问不同的数据库，不需要改变代码
(2)jpa规范：hibernate open-jpa ,link(定义一样的方法操作数据库)
(3)mybatis:编写xml文件，在xml中编写sql语句，访问数据库，任何操作都需要使用xml文件
需要熟悉sql语言，开发效率低一些，单表的CRUD也需要使用xml文件编写sql语句
(4)Mybatis-plus 简称MP，对mybatis的增强，在mybatis-plus之外加一层，单表操作
可以不使用xml文件，分页，性能统计，逻辑删除等。
MyBatis-Plus（简称 MP ）是一个 MyBatis 的增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。Mybatis-Plus 在 MyBatis 之上套了一层外衣，单表 CURD 的操作几乎都可以由 MyBatis-Plus 代替执行。而且提供了各种查询方式，分页行为。作为使用者无需编写 xml,直接调用 MyBatis-Plus 提供的 API 就可以了。
1.无侵入：只做增强不做改变，引入它不会对现有工程产生影响，如丝般顺滑
2.损耗小：启动即会自动注入基本 CURD，性能基本无损耗，直接面向对象操作
3.强大的 CRUD 操作：内置通用 Mapper、通用 Service，仅仅通过少量配置即可实现单表大部分 CRUD 操作，
更有强大的条件构造器，满足各类使用需求
4.支持 Lambda 形式调用：通过 Lambda 表达式，方便的编写各类查询条件，无需再担心字段写错
5.支持主键自动生成：支持多达 4 种主键策略（内含分布式唯一 ID 生成器 - Sequence），
可自由配置，完美解决主键问题
6.支持 ActiveRecord 模式：支持 ActiveRecord 形式调用，
实体类只需继承 Model 类即可进行强大的 CRUD 操作
7.支持自定义全局通用操作：支持全局通用方法注入（ Write once, use anywhere ）
8.内置代码生成器：采用代码或者 Maven 插件可快速生成 Mapper 、 Model 、 Service 、 Controller 层代码，
支持模板引擎，更有超多自定义配置等您来使用
9.内置分页插件：基于 MyBatis 物理分页，开发者无需关心具体操作，
配置好插件之后，写分页等同于普通 List 查询
10.分页插件支持多种数据库：支持 MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer 等多种数据库
11.内置性能分析插件：可输出 SQL 语句以及其执行时间，建议开发测试时启用该功能，能快速揪出慢查询
12.内置全局拦截插件：提供全表 delete 、 update 操作智能分析阻断，也可自定义拦截规则，预防误操作
CREATE TABLE USER ( id INT ( 11 ) NOT NULL AUTO_INCREMENT, NAME VARCHAR ( 50 ) DEFAULT NULL, email VARCHAR ( 80 ) DEFAULT NULL, age INT ( 11 ) DEFAULT NULL, PRIMARY KEY ( id ) ) ENGINE = INNODB AUTO_INCREMENT = 1 DEFAULT CHARSET = utf8;
(1)新建的Spring Boot 工程
(2)指定maven的mp坐标
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.3.2</version>
</dependency>
(3)指定数据库的驱动
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<scope>runtime</scope>
</dependency>
在application.yml中进行配置数据库（数据库名plus）
spring:
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://127.0.0.1:3306/plus?useSSL=false&serverTimezone=UTC
username: root
password: root
(4)创建实体类 定义属性 指定主键的类型
public class User {
/**
* 指定主键的方式
* value:主键字段的名称，如果是id可以不用写
* type:指定主键的类型，主键的值如何生成：IdType.AUTO表示自动增长
*/
@TableId(value ="id",type = IdType.AUTO)
private Integer id;
private String name;
private String email;
private Integer age;
(5)创建dao接口，需要继承BaseMapper<实体.class>
/**
* @author 王恒杰
* @Description:
* 自定义的mapper,dao接口
* 1.实现BaseMapper
* 2.要指定实体类对象
*
* BaseMapper是mybatis-plus的对象，定义了17个方法(crud)
*/
public interface UserMapper extends BaseMapper<User> {
}
(6)在springboot的启动类上，加入@MappperScan(value=“指定dao接口的包名”);
/**
* @author 王恒杰
* @MapperScan:扫描器，指定Mapper所在的包名
*/
@SpringBootApplication
@MapperScan(value = "com.tjcu.mapper")
public class MybatisPlusApplication {
public static void main(String[] args) {
SpringApplication.run(MybatisPlusApplication.class, args);
}
}
(7)测试使用
在测试类或Service注入Dao接口，框架使用动态代理 创建Dao的实现类对象 。
调用BaseMapper 中的方法，完成CRUD操作
/*
SuppressWarnings:该批注的作用是给编译器一条指令，
告诉它对被批注的代码元素内部的某些警告保持静默。
添加@SuppressWarnings("all")之后 private UserMapper UserDao;中的UserDao才不报错
*/
@SuppressWarnings("all")
@SpringBootTest
class MybatisPlusApplicationTests {
/**
使用自动注入，注入Mapper对象（Dao）
* @Autowired 注释，它可以对类成员变量、方法及构造函数进行标注，
* 完成自动装配的工作。 通过 @Autowired的使用来消除 set ，get方法。
*/
@Autowired
private UserMapper UserDao;
/**
* 测试添加操作
*/
@Test
public void testUserInsert() {
//创建User对象
User user = new User();
user.setName("王恒杰");
user.setAge(20);
user.setEmail("123@qq.com");
//调用UserMapper的方法，也就是父接口BaseMapper中提供的方法
int i = UserDao.insert(user);
System.out.println(i);
}
}
@Autowired解释
@Autowired 注释，它可以对类成员变量、方法及构造函数进行标注，完成自动装配的工作。
通过 @Autowired的使用来消除 set ，get方法。
@SuppressWarnings(“all”)解释
@SuppressWarnings:该批注的作用是给编译器一条指令，
告诉它对被批注的代码元素内部的某些警告保持静默。
在application.yml中进行配置
mybatis-plus:
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
配置日志文件后的控制台
操作插入数据之前数据库的数据
测试代码
/**
* 测试添加数据后，获取主键值
*/
@Test
public void testUserInsertGetId() {
User user = new User();
user.setName("杨福君");
user.setAge(19);
user.setEmail("10019@qq.com");
int rows = UserDao.insert(user);
//获取主键的id,刚添加数据的id ,getId主键字段对应的get方法
Integer id = user.getId();
System.out.println("主键的id"+id);
}
操作插入数据之后数据库的数据
BaseMapper接口中的更新方法（源码 ）
int updateById(@Param("et") T entity);
int update(@Param("et") T entity, @Param("ew") Wrapper<T> updateWrapper);
（1）更新数据实现 更新数据之前数据库的数据
mybatis-plus封装的sql语句
UPDATE user SET name=?, email=?, age=? WHERE id=?
测试代码
/**
* 更新用户
*/
@Test
public void updateUser(){
User user = new User();
user.setName("被修改后的王恒杰");
user.setAge(22);
user.setEmail("1259387078@qq.com");
//被更改的用户
user.setId(2);
//更新所有非null的值
int i = UserDao.updateById(user);
System.out.println("影响行数"+i);
}
更新数据之后数据库的数据
（2）更新数据的是所有非null的值
int updateById(@Param("et") T entity);
这个方法更新的是所有非null的值，如果实体类是int类型的（非包装类型），那这个数就自动更改为0
将age的类型改为int之后
@TableId(value ="id",type = IdType.AUTO)
private Integer id;
private String name;
private String email;
private int age;
测试代码
/**
* 更新用户，只更新姓名数据
*/
@Test
public void updateUser(){
User user = new User();
user.setName("被修改后的杨福君");
//被更改的用户
user.setId(3);
//更新所有非null的值
int i = UserDao.updateById(user);
System.out.println("影响行数"+i);
}
mybatis-plus封装的sql语句
UPDATE user SET name=?, age=? WHERE id=?
更新数据之后数据库的数据
注意： 我们使用mybatis-plus时实体类最好使用包装类型 ，避免出现基本数据类型 ，更新数据时，没修改的为0的情况
BaseMapper接口中的删除方法（源码 ）
1.int deleteById(Serializable id);
2.int deleteByMap(@Param("cm") Map<String, Object> columnMap);
3.int delete(@Param("ew") Wrapper<T> wrapper);
4.int deleteBatchIds(@Param("coll") Collection<? extends Serializable> idList);
（1）deleteById:按主键删除 删除数据之前数据库的数据
测试代码
/**
* 删除用户
* 按主键删除一条用户
* 方法为：deleteById
* 参数：主键值
* 返回值：是删除的成功的记录数
*/
@Test
public void deleteUserById(){
int i = UserDao.deleteById(2);
System.out.println(i);
}
mybatis-plus封装的sql语句
DELETE FROM user WHERE id=?
删除数据之后数据库的数据
（2）根据Map中条件删除
删除数据之前数据库的数据
测试代码
/**
* 按条件删除数据，条件是封装到Map对象中
* 方法：deleteByMap(map对象)
*/
@Test
public void deleteUserByMap(){
// 创建Map对象，保存条件值
HashMap<String, Object> map = new HashMap<>();
map.put("name","王恒杰");
map.put("age",20);
//DELETE FROM user WHERE name = ? AND age = ?
int i = UserDao.deleteByMap(map);
System.out.println(i);
}
mybatis-plus封装的sql语句
DELETE FROM user WHERE name = ? AND age = ?
删除数据之后数据库的数据
（3）批量删除
删除数据之前数据库的数据
测试代码
/**
* 批量删除
* deleteBatchIds(@Param("coll") Collection<? extends Serializable> idList);
*/
@Test
public void deleteBatchIds(){
ArrayList<Integer> ids = new ArrayList<>();
ids.add(4);
ids.add(5);
ids.add(6);
int i = UserDao.deleteBatchIds(ids);
System.out.println(i);
}
mybatis-plus封装的sql语句
DELETE FROM user WHERE id IN ( ? , ? , ? )
删除数据之后数据库的数据
(4)使用Lambda表达式实现批量删除
批量删除数据之前数据库的数据
测试代码
/**
* Lambda实现批量删除
* deleteBatchIds(@Param("coll") Collection<? extends Serializable> idList);
*/
@Test
public void deleteByLambda(){
List<Integer> ids=
Stream.of(3, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19).collect(Collectors.toList());
int i = UserDao.deleteBatchIds(ids);
System.out.println(i);
}
mybatis-plus封装的sql语句
DELETE FROM user WHERE id IN ( ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? , ? )
批量删除数据之后数据库的数据
BaseMapper接口中的查询十种 方法（源码 ）
//通过id查询
T selectById(Serializable id);
//批量查询
List<T> selectBatchIds(@Param("coll") Collection<? extends Serializable> idList);
//多个条件查询
List<T> selectByMap(@Param("cm") Map<String, Object> columnMap);
//查询一个对象
T selectOne(@Param("ew") Wrapper<T> queryWrapper);
//统计的count值
Integer selectCount(@Param("ew") Wrapper<T> queryWrapper);
//条件查询
List<T> selectList(@Param("ew") Wrapper<T> queryWrapper);
List<Map<String, Object>> selectMaps(@Param("ew") Wrapper<T> queryWrapper);
List<Object> selectObjs(@Param("ew") Wrapper<T> queryWrapper);
//分页查询
<E extends IPage<T>> E selectPage(E page, @Param("ew") Wrapper<T> queryWrapper);
<E extends IPage<Map<String, Object>>> E selectMapsPage(E page, @Param("ew") Wrapper<T> queryWrapper);
（1）根据 id 主键查询
测试代码
/**
* 通过id查询
* 如果根据主键没有查到数据，得到的返回值是null
*
*/
@Test
public void selectUserById(){
User user = UserDao.selectById(26);
System.out.println(user);
}
mybatis-plus封装的sql语句
SELECT id,name,email,age FROM user WHERE id=?
控制台展示
（2）批量查询记录 测试代码
/**
* 实现批处理查询，根据多个主键查询，获取到list
* 方法：selectBatchIds
* 参数：id集合
* 返回值：list<T>
*/
@Test
public void selectBatchIds(){
ArrayList<Integer> ids = new ArrayList<>();
ids.add(23);
ids.add(24);
ids.add(25);
ids.add(26);
List<User> users = UserDao.selectBatchIds(ids);
for (User user : users) {
System.out.println(user);
}
}
mybatis-plus封装的sql语句
SELECT id,name,email,age FROM user WHERE id IN ( ? , ? , ? , ? )
控制台输出结果
（3）Lambda实现批量查询
测试代码
/**
* 使用Lambda实现批处理查询，根据多个主键查询，获取到list
* 方法：selectBatchIdsByLambda
* 参数：id集合
* 返回值：list<T>
*/
@Test
public void selectBatchIdsByLambda(){
List<Integer> ids = Stream.of(24, 25, 26, 27, 28).collect(Collectors.toList());
List<User> users = UserDao.selectBatchIds(ids);
//遍历
for (int i = 0; i < users.size(); i++) {
System.out.println("查询出来的第"+(i+1)+"个用户："+users.get(i));
}
}
mybatis-plus封装的sql语句
SELECT id,name,email,age FROM user WHERE id IN ( ? , ? , ? , ? , ? )
控制台输出结果
（4）使用Map条件查询查询单个用户
测试代码
//查询单个用户
HashMap<String, Object> map1 = new HashMap<>();
// 姓名：杨福君
map1.put("name", "杨福君");
// 年龄 ：19
map1.put("age", 19);
List<User> users = UserDao.selectByMap(map1);
for (User user : users) {
System.out.println(user);
}
mybatis-plus封装的sql语句
//查询单个用户
HashMap<String, Object> map1 = new HashMap<>();
// 姓名：杨福君
map1.put("name", "杨福君");
// 年龄 ：19
map1.put("age", 19);
List<User> users = UserDao.selectByMap(map1);
for (User user : users) {
System.out.println(user);
}
控制台输出结果
（5）使用Map条件查询查询多个用户 测试代码
//询多个用户
HashMap<String, Object> map2 = new HashMap<>();
// 姓名：王恒杰
map2.put("name", "王恒杰");
// 年龄 ：21
map2.put("age", 21);
List<User> users1 = UserDao.selectByMap(map2);
for (User user : users1) {
System.out.println(user);
}
mybatis-plus封装的sql语句
SELECT id,name,email,age FROM user WHERE name = ? AND age = ?
控制台输出结果
通过使用动态代理 的方式来生成dao对象，来调用sqlSession底层方法，对mybatis进行封装和增强，用mybatis-plus替代mybatis
到此这篇关于详解Mybatis-plus(MP)中CRUD操作保姆级笔记的文章就介绍到这了,更多相关Mybatis-plus中CRUD操作内容请搜索
千自学 >> 更多相关MyBatis的文章
标签：MyBatis
声明：本站信息仅供参考，如有转载或引用文章涉及版权问题请速与我们联系删除
Copyright © 2022 All Rights Reserved 千自学(1000zx.cn) 版权所有