Mybatis-plus的快速集成和入门使用
一、MyBatis Plus 介绍
MyBatis Plus 是国内人员开发的 MyBatis 增强工具，在 MyBatis 的基础上只做增强不做改变，为简化开发、提高效率而生。
MyBatis Plus 的核心功能有：支持通用的 CRUD、代码生成器与条件构造器。
- 通用 CRUD：内置通用 Mapper，定义好 Mapper 接口后，只需要继承
BaseMapper<T>接口即可获得通用的增删改查功能，无需编写任何接口方法与配置文件 - 条件构造器：通过
Wrapper<T>（实体包装类），可以用于拼接 SQL 语句，并且支持排序、分组查询等复杂的 SQL - 代码生成器：支持一系列的策略配置与全局配置，比 MyBatis 的代码生成更好用。
这里就不过多叙述了 更多 Mybatis-plus 介绍 可以去官网了解。
BaseMapper 接口中通用的 CRUD 方法：
二、MyBatis Plus 集成
将会讲解 Mybatis + MP 、Spring + Mybatis + MP 、SpringBoot + Mybatis + MP
一、准备工作
创建数据库以及表
-- 创建测试表
CREATE TABLE `tb_user` (
`id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',
`user_name` varchar(20) NOT NULL COMMENT '用户名',
`password` varchar(20) NOT NULL COMMENT '密码',
`name` varchar(30) DEFAULT NULL COMMENT '姓名',
`age` int(11) DEFAULT NULL COMMENT '年龄',
`email` varchar(50) DEFAULT NULL COMMENT '邮箱',
PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8;
-- 插入测试数据
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES
('1', 'zhangsan', '123456', '张三', '18', 'test1@test.cn');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES
('2', 'lisi', '123456', '李四', '20', 'test2@test.cn');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES
('3', 'wangwu', '123456', '王五', '28', 'test3@test.cn');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES
('4', 'zhaoliu', '123456', '赵六', '21', 'test4@test.cn');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES
('5', 'sunqi', '123456', '孙七', '24', 'test5@test.cn');
二、Mybatis + MP 整合
1、创建工程+导入依赖+日志配置
<?xml version="1.0" encoding="UTF-8"?>
<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.0</modelVersion>
<groupId>com.plus.demo</groupId>
<artifactId>mybatis-plus-simple</artifactId>
<packaging>pom</packaging>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<!-- 连接池 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.0.11</version>
</dependency>
<!--简化bean代码的工具包-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
<version>1.18.4</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.6.4</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
log4j.properties：
log4j.rootLogger=DEBUG,A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=[%t] [%c]-[%p] %m%n
有些人会问为啥不引 Mybatis 依赖 因为 Mybatis-plus 依赖包含了 还包含和spring整合的依赖
2、Mybatis实现查询User
2.1 编写mybatis-config.xml文件：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<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://127.0.0.1:3306/mybatis_plus?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&useSSL=false"/>
<property name="username" value="root"/>
<property name="password" value="123456"/>
</dataSource>
</environment>
</environments>
<mappers>
<mapper resource="UserMapper.xml"/>
</mappers>
</configuration>
2.2 编写User实体对象：（这里使用lombok进行了进化bean操作）
@Data //自动提供getter和setter、hashCode、equals、toString等方法
@NoArgsConstructor //无参构造
@AllArgsConstructor //全参构造
public class User {
private Long id;
private String userName;
private String password;
private String name;
private Integer age;
private String email;
}
2.3 编写UserMapper接口:
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.mp.boot.pojo.User;
public interface UserMapper {
User findById(Long id);
}
2.4 编写UserMapper.xml文件：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mp.boot.mapper.UserMapper">
<select id="findById" resultType="User">
select * from tb_user where id = #{id}
</select>
</mapper>
2.5 编写TestMybatis测试用例：
package com.mp.simple;
import com.baomidou.mybatisplus.core.MybatisSqlSessionFactoryBuilder;
import com.mp.simple.mapper.UserMapper;
import com.mp.simple.pojo.User;
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 org.junit.Test;
import java.io.InputStream;
import java.util.List;
public class TestMybatis {
@Test
public void testUserList() throws Exception{
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
SqlSessionFactory sqlSessionFactory = new
SqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
List<User> list = userMapper.findAll();
for (User user : list) {
System.out.println(user);
}
}
}
测试结果：
User(id=1, userName=null, password=123456, name=张三, age=18, email=test1@163.cn)
User(id=2, userName=null, password=123456, name=李四, age=20, email=test2@163.cn)
User(id=3, userName=null, password=123456, name=王五, age=28, email=test3@163.cn)
User(id=4, userName=null, password=123456, name=赵六, age=21, email=test4@163.cn)
User(id=5, userName=null, password=123456, name=孙七, age=24, email=test5@163.cn)
有些人会问为啥userName为null 因为实体类属性和数据库字段不匹配 我们也没配置驼峰！！！
2.6 Mybatis+MP实现查询User
第一步，将UserMapper继承BaseMapper，将拥有了BaseMapper中的所有方法：
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.mp.simple.pojo.User;
import java.util.List;
public interface UserMapper extends BaseMapper<User> {
List<User> findAll();
}
第二步，使用MP中的MybatisSqlSessionFactoryBuilder进程构建：
import com.baomidou.mybatisplus.core.MybatisSqlSessionFactoryBuilder;
import com.mp.simple.mapper.UserMapper;
import com.mp.simple.pojo.User;
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 org.junit.Test;
import java.io.InputStream;
import java.util.List;
public class TestMybatis {
@Test
public void testUserList() throws Exception{
String resource = "mybatis-config.xml";
InputStream inputStream = Resources.getResourceAsStream(resource);
//这里使用的是MP中的MybatisSqlSessionFactoryBuilder
SqlSessionFactory sqlSessionFactory = new MybatisSqlSessionFactoryBuilder().build(inputStream);
SqlSession sqlSession = sqlSessionFactory.openSession();
UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
// 可以调用BaseMapper中定义的方法
// queryWrapper 条件构造器 我们先不填 填null 直接查所有
List<User> list = userMapper.selectList(null);
for (User user : list) {
System.out.println(user);
}
}
}
运行报错：
原因：他会把实体类首字母小写 然后去数据库查user这张表 但我们定义的表是tb_user 所以是查不到的。
解决：在User对象中添加@TableName，指定数据库表名
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
//对象中添加@TableName，指定数据库表名
@TableName("tb_user")
public class User {
private Long id;
private String userName;
private String password;
private String name;
private Integer age;
private String email;
}
再次运行 就没有问题啦 现在userName就有值 那么就说明MP自带驼峰：
User(id=1, userName=zhangsan, password=123456, name=张三, age=18, email=test1@163.cn)
User(id=2, userName=lisi, password=123456, name=李四, age=20, email=test2@163.cn)
User(id=3, userName=wangwu, password=123456, name=王五, age=28, email=test3@163.cn)
User(id=4, userName=zhaoliu, password=123456, name=赵六, age=21, email=test4@163.cn)
User(id=5, userName=sunqi, password=123456, name=孙七, age=24, email=test5@163.cn)
简单说明：主要要让
Mapper接口继承MP提供的BaseMapper由于使用了MybatisSqlSessionFactoryBuilder进行了构建，继承的BaseMapper中的方法就载入到了 SqlSession 中，所以就可以直接使用相关的方法；
三、Spring + Mybatis + MP
引入了Spring框架，数据源、构建等工作就交给了Spring管理。
1、创建工程+导入依赖+配置
<?xml version="1.0" encoding="UTF-8"?>
<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.0</modelVersion>
<groupId>com.plus.demo</groupId>
<artifactId>mybatis-plus-spring</artifactId>
<packaging>pom</packaging>
<version>1.0-SNAPSHOT</version>
<properties>
<spring.version>5.1.6.RELEASE</spring.version>
</properties>
<dependencies>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus</artifactId>
<version>3.3.0</version>
</dependency>
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<!-- 连接池 -->
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.0.11</version>
</dependency>
<!--简化bean代码的工具包-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
<version>1.18.4</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
<version>1.6.4</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>${spring.version}</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<configuration>
<source>1.8</source>
<target>1.8</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
编写jdbc.properties：
jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/mybatis_plus?
useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&useSSL=false
jdbc.username=root
jdbc.password=123456
编写applicationContext.xml：
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<context:property-placeholder location="classpath:*.properties"/>
<!-- 定义数据源 -->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
destroy-method="close">
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
<property name="driverClassName" value="${jdbc.driver}"/>
<property name="maxActive" value="10"/>
<property name="minIdle" value="5"/>
</bean>
<!--这里使用Mybatis-plus提供的sqlSessionFactory，完成了Spring与MP的整合-->
<bean id="sqlSessionFactory"
class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
</bean>
<!--扫描mapper接口，使用的依然是Mybatis原生的扫描器-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.mp.spring.mapper"/>
</bean>
</beans>
2、实现查询User
2.1 编写User对象以及UserMapper接口：
@Data
@NoArgsConstructor
@AllArgsConstructor
//指定数据库表名
@TableName("tb_user")
public class User {
private Long id;
private String userName;
private String password;
private String name;
private Integer age;
private String email;
}
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.mp.spring.pojo.User;
public interface UserMapper extends BaseMapper<User> {
}
2.2 编写编写测试用例：
import com.mp.spring.mapper.UserMapper;
import com.mp.spring.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import java.util.List;
@RunWith(SpringJUnit4ClassRunner.class)
// 拿到applicationContext.xml里面所有的配置 可以理解为加载xml文件
// 这样就可以在测试类中使用注解简单的注入需要的bean了
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class TestMybatis {
@Autowired
private UserMapper userMapper;
@Test
public void testSelectList(){
List<User> users = this.userMapper.selectList(null);
for (User user : users) {
System.out.println(user);
}
}
}
尴尬的是 又报错了：
因为我们是在test里写的 他读取读的是test模块下的jdbc.properties 但我们test下面没有resources 所以读取不到 有两种解决方法 第一就是把数据库的参数写死 或者 在test模块里 加resources 加个jdbc.properties
这样可以正常运行了：
User(id=1, userName=zhangsan, password=123456, name=张三, age=18, email=test1@163.cn)
User(id=2, userName=lisi, password=123456, name=李四, age=20, email=test2@163.cn)
User(id=3, userName=wangwu, password=123456, name=王五, age=28, email=test3@163.cn)
User(id=4, userName=zhaoliu, password=123456, name=赵六, age=21, email=test4@163.cn)
User(id=5, userName=sunqi, password=123456, name=孙七, age=24, email=test5@163.cn)
四、SpringBoot + Mybatis + MP
1、创建工程+导入依赖+日志配置
<?xml version="1.0" encoding="UTF-8"?>
<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.0</modelVersion>
<!--
使用SpringBoot将进一步的简化MP的整合，
-->
<groupId>com.boot.mybatis.plus</groupId>
<artifactId>mybatis-plus-boot-test</artifactId>
<version>1.0-SNAPSHOT</version>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.4.RELEASE</version>
</parent>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
<exclusions>
<exclusion>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!--简化代码的工具包-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<optional>true</optional>
</dependency>
<!--mybatis-plus的springboot支持-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.1.1</version>
</dependency>
<!--mysql驱动-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
<version>5.1.47</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-log4j12</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
log4j.properties：
log4j.rootLogger=DEBUG,A1
log4j.appender.A1=org.apache.log4j.ConsoleAppender
log4j.appender.A1.layout=org.apache.log4j.PatternLayout
log4j.appender.A1.layout.ConversionPattern=[%t] [%c]-[%p] %m%n
2、编写application.yml
spring.application.name: mp-springboot
spring.datasource.driver-class-name: com.mysql.jdbc.Driver
spring.datasource.url: jdbc:mysql://127.0.0.1:3306/mybatis_plus?useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&useSSL=false
spring.datasource.username: root
spring.datasource.password: 123456
3、编写pojo、Mapper
package com.mp.boot.pojo;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_user")
public class User {
private Long id;
private String userName;
private String password;
private String name;
private Integer age;
private String email;
}
package com.mp.boot.mapper;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.mp.boot.pojo.User;
public interface UserMapper extends BaseMapper<User> {
User findById(Long id);
}
4、编写boot启动类
package com.mp.boot;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
5、编写测试用例
package com.mp.boot;
import com.mp.boot.mapper.UserMapper;
import com.mp.boot.pojo.User;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;
@RunWith(SpringRunner.class) //等同于 SpringJUnit4ClassRunner 因为他继承了 SpringJUnit4ClassRunner
@SpringBootTest //是springboot 用于测试的注解，可指定启动类或者测试环境等，这里直接默认
public class TestMybatisSpringBoot {
@Autowired
private UserMapper userMapper;
@Test
public void testSelect() {
//queryWrapper 是构建条件 咱们暂时不构建 直接查所有
List<User> userList = userMapper.selectList(null);
for (User user : userList) {
System.out.println(user);
}
}
}
运行成功
User(id=1, userName=zhangsan, password=123456, name=张三, age=18, email=test1@163.cn)
User(id=2, userName=lisi, password=123456, name=李四, age=20, mail=test2@163.cn)
User(id=3, userName=wangwu, password=123456, name=王五, age=28, email=test3@163.cn)
User(id=4, userName=zhaoliu, password=123456, name=赵六, age=21, email=test4@163.cn)
User(id=5, userName=sunqi, password=123456, name=孙七, age=24, email=test5@163.cn)
三、Plus-入门 通用CRUD
注意：
以下所有操作都是使用 boot集成mybatis的项目
一、插入操作
insert
@RunWith(SpringRunner.class)
@SpringBootTest
public class UserMapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testInsert(){
User user = new User();
user.setAge(21);
user.setName("狗剩");
user.setPassword("123456");
user.setUserName("gousheng");
//新增操作 需要给个user实体类
int result = userMapper.insert(user); //返回的result是受影响的行数，并不是自增后的id
System.out.println("result="+result);
System.out.println("result = " + result);
System.out.println(user.getId()); //自增后的id会回填到对象中
}
}
[main] [com.mp.boot.mapper.UserMapper.insert]-[DEBUG] ==> Preparing: INSERT INTO tb_user ( id, user_name, password, name, age ) VALUES ( ?, ?, ?, ?, ? )
[main] [com.mp.boot.mapper.UserMapper.insert]-[DEBUG] ==> Parameters: 1207198118517411842(Long), gousheng(String), 123456(String), 狗剩(String), 21(Integer)
[main] [com.mp.boot.mapper.UserMapper.insert]-[DEBUG] <== Updates: 1
[main] [org.mybatis.spring.SqlSessionUtils]-[DEBUG] Closing non transactional SqlSession [org.apache.ibatis.session.defaults.DefaultSqlSession@160396db]
result=1
result = 1
1207198118517411842
可以看到，数据已经写入到了数据库，但是，id的值不正确，我们期望的是数据库自增长，实际是MP生成了id的值写入到了数据库。
设置id生成策略 id自增长 @TableId(type = IdType.AUTO)：
package com.mp.boot.pojo;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_user")
public class User {
//设置主键id的生成策略 默认是NONE
//大家也可以点击这个注解进去看一下 有五种策略可以指定 默认的是是随机生成的
@TableId(type = IdType.AUTO) //指定id类型为自增长
private Long id;
private String userName;
private String password;
private String name;
private Integer age;
private String email;
}
数据插入成功：
@TableField
在MP中通过@TableField注解可以指定字段的一些属性，常常解决的问题有2个：
1、对象中的属性名和字段名不一致的问题（非驼峰）
2、对象中的属性字段在表中不存在的问题
使用：
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_user")
public class User {
//设置主键id的生成策略 默认是NONE
@TableId(type = IdType.AUTO)
private Long id;
//指定映射字段
@TableField(value = "user_name")
private String userName;
//字段不加入查询字段
@TableField(select = false)
private String password;
private String name;
private Integer age;
@TableField(value = "email") //解决字段名不一致 比如数据库里是email 变量写的是mail
private String mail;
//我们数据库中是没有这个字段的 新增的时候 给他也赋值了 他的sql 语句
// INSERT INTO tb_user ( user_name, password, name, age, address ) VALUES ( ?, ?, ?, ?, ? )
// 但我们数据库里根本没有 字段 所以会报错 我们加注解 可以指定对改属性不做操作
@TableField(exist = false) // 该字段 在数据库里不存在 查询或新增 就不会查这个字段了
private String address;
}
因为我password 设置不加入查询 所以就没查了 password为null
sql=>SELECT id,user_name,name,age,email AS mail FROM tb_user
User(id=1, userName=zhangsan, password=null, name=张三, age=18, mail=test1@163.cn, address=null)
User(id=2, userName=lisi, password=null, name=李四, age=20, mail=test2@163.cn, address=null)
User(id=3, userName=wangwu, password=null, name=王五, age=28, mail=test3@163.cn, address=null)
User(id=4, userName=zhaoliu, password=null, name=赵六, age=21, mail=test4@163.cn, address=null)
User(id=5, userName=sunqi, password=null, name=孙七, age=24, mail=test5@163.cn, address=null)
二、更新操作
updateById
/**
* 根据 ID 修改
*
* @param entity 实体对象
*/
int updateById(@Param(Constants.ENTITY) T entity);
@Test
public void testUpdateById() {
User user = new User();
user.setId(6L); //主键
user.setAge(23); //更新的字段
//sql UPDATE tb_user SET age=? WHERE id=?
//根据id更新，更新不为null的字段
int result = userMapper.updateById(user);
System.out.println("result="+result);
}
根据条件更新 之前我们有个条件构造器 我们一直没填 现在开始来讲解它
/**
* 根据 whereEntity 条件，更新记录
*
* @param entity 实体对象 (set 条件值,可以为 null)
* @param updateWrapper 实体对象封装操作类（可以为 null,里面的 entity 用于生成 where 语句）
*/
int update(@Param(Constants.ENTITY) T entity,
@Param(Constants.WRAPPER) Wrapper<T>
updateWrapper);
@Test
public void testUpdate() {
User user = new User();
//更新数据
user.setAge(30);
//更新的条件
QueryWrapper<User> wrapper = new QueryWrapper<>();
wrapper.eq("user_name", "zhangsan"); //匹配user_name = zhangsan 的用户数据
//sql UPDATE tb_user SET age=? WHERE user_name = ?
int result = userMapper.update(user, wrapper);
System.out.println("result="+result);
}
可以用两种条件的构造器 UpdateWrapper 和 QueryWrapper
UpdateWrapper 可以直接set参数 Query是没有的set方法的
@Test
public void testUpdate2() {
UpdateWrapper<User> wrapper = new UpdateWrapper<>();
//QueryWrapper 是没有set方法的
//这里都是字段名字 不是实体中的属性
wrapper.set("age",888) //更新的字段
.eq("id",6); //更新的条件
int result = userMapper.update(null, wrapper); //返回的result是受影响的行数，并不是自增后的id
System.out.println("result="+result);
}
三、删除操作
deleteById
/**
* 根据 ID 删除
*
* @param id 主键ID
*/
int deleteById(Serializable id);
@Test
public void testDeleteById() {
//执行删除操作
int result = userMapper.deleteById(6L);
//result 是受影响的行数
System.out.println("result="+result);
}
结果：
deleteByMap
/**
* 根据 columnMap 条件，删除记录
*
* @param columnMap 表字段 map 对象
*/
int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
@Test
public void testDeleteByMap() {
//构造删除条件
Map<String, Object> columnMap = new HashMap<>();
columnMap.put("age",20);
columnMap.put("user_name","zhangsan");
//将columnMap中的元素设置为删除的条件，多个之间为and关系
int result = this.userMapper.deleteByMap(columnMap);
System.out.println("result = " + result);
}
结果：
因为我们数据库中张三的年龄是30 所以没有对应的数据
delete
/**
* 根据 entity 条件，删除记录
*
* @param wrapper 实体对象封装操作类（可以为 null）
*/
int delete(@Param(Constants.WRAPPER) Wrapper<T> wrapper);
@Test
public void testDelete() {
//方法一
// User user = new User();
// user.setAge(20);
// user.setName("张三");
// //将实体对象进行包装，包装为操作条件
// QueryWrapper<User> wrapper = new QueryWrapper<>(user);
//方法二
QueryWrapper<User> wrapper = new QueryWrapper<>();
//多个eq 也是and 的关系
wrapper.eq("name","张三").eq("password","123456");
int result = this.userMapper.delete(wrapper);
System.out.println("result = " + result);
}
结果：
deleteBatchIds
/**
* 删除（根据ID 批量删除）
*
* @param idList 主键ID列表(不能为 null 以及 empty)
*/
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable>
idList);
@Test
public void testDeleteBatchIds() {
//根据id集合批量删除
int result = this.userMapper.deleteBatchIds(Arrays.asList(2L,10L,20L));
System.out.println("result = " + result);
}
结果：
四、查询操作
MP提供了多种查询操作，包括根据id查询、批量查询、查询单条数据、查询列表、分页查询等操作。
selectById
/**
* 根据 ID 查询
*
* @param id 主键ID
*/
T selectById(Serializable id);
@Test
public void testSelectById() {
//根据id查询数据
User user = this.userMapper.selectById(3L);
System.out.println("result = " + user);
}
结果：
selectBatchIds
/**
* 查询（根据ID 批量查询）
*
* @param idList 主键ID列表(不能为 null 以及 empty)
*/
List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable>
idList);
@Test
public void testSelectBatchIds() {
//根据id集合批量查询
List<User> users = this.userMapper.selectBatchIds(Arrays.asList(2L, 3L, 4L));
for (User user : users) {
System.out.println(user);
}
}
结果：
selectOne
/**
* 根据 entity 条件，查询一条记录
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
T selectOne(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
@Test
public void testSelectOne() {
QueryWrapper<User> wrapper = new QueryWrapper<User>();
wrapper.eq("name", "王五");
//根据条件查询一条数据，如果结果超过一条会报错
User user = this.userMapper.selectOne(wrapper);
System.out.println(user);
}
结果：
selectCount
/**
* 根据 Wrapper 条件，查询总记录数
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
Integer selectCount(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
@Test
public void testSelectCount() {
QueryWrapper<User> wrapper = new QueryWrapper<User>();
wrapper.gt("age", 23); //年龄大于23岁
//根据条件查询数据条数
//sql---> SELECT COUNT( 1 ) FROM tb_user WHERE age > ?
Integer count = this.userMapper.selectCount(wrapper);
System.out.println("count = " + count);
}
结果：
selectList
/**
* 根据 entity 条件，查询全部记录
*
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
List<T> selectList(@Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
@Test
public void testSelectList() {
QueryWrapper<User> wrapper = new QueryWrapper<User>();
wrapper.gt("age", 23); //年龄大于23岁
//根据条件查询数据
List<User> users = this.userMapper.selectList(wrapper);
for (User user : users) {
System.out.println("user = " + user);
}
}
结果：
selectPage
/**
* 根据 entity 条件，查询全部记录（并翻页）
*
* @param page 分页查询条件（可以为 RowBounds.DEFAULT）
* @param queryWrapper 实体对象封装操作类（可以为 null）
*/
IPage<T> selectPage(IPage<T> page, @Param(Constants.WRAPPER) Wrapper<T> queryWrapper);
@Test
public void testSelectPage() {
//构造查询条件
QueryWrapper<User> wrapper = new QueryWrapper<User>();
wrapper.like("email","test");
//构建分页
Page<User> page = new Page<>(1,1); //查询第一页 查询一条数据
//根据条件查询数据
IPage<User> iPage = userMapper.selectPage(page, wrapper);
System.out.println("数据总条数="+iPage.getTotal());
System.out.println("总页数="+iPage.getPages());
System.out.println("当前页="+iPage.getCurrent());
List<User> records = iPage.getRecords();
records.forEach(System.out::println);
}
配置分页插件：
package com.mp.boot;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration //标记为这是一个配置类 可以理解有了这个注解就等于spring的xml
@MapperScan("com.mp.boot.mapper") //设置mapper接口的扫描包
public class MybatisPlusConfig {
/**
* @Bean这个注解 就是产生一个bean 注入到ioc容器里 交给spring容器管理
* 等同于 <bean class="org.mybatis.spring.mapper.MapperScannerConfigurer"> </bean>
*/
@Bean //配置分页插件
public PaginationInterceptor paginationInterceptor() {
return new PaginationInterceptor();
}
}
使用分页一定要配置分页插件 不然会没用
结果：
四、Plus-入门 配置
在MP中有大量的配置，其中有一部分是Mybatis原生的配置，另一部分是MP的配置。
一、基本配置
configLocation
MyBatis 配置文件位置，如果您有单独的 MyBatis 配置，请将其路径配置到 configLocation 中。 MyBatis Configuration 的具体内容请参考MyBatis 官方文档
Spring Boot：
#指定全局的配置文件
mybatis-plus.config-location: classpath:mybatis-config.xml
把分页插件注释掉了
创建mybatis-config.xml 设置分页插件 又可以使用分页了
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
<plugins>
<plugin interceptor="com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor"></plugin>
</plugins>
</configuration>
Spring MVC：
<!--这里使用Mybatis-plus提供的sqlSessionFactory，完成了Spring与MP的整合-->
<bean id="sqlSessionFactory"
class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<!--
mybatis-config.xml 可以设置分页插件 然后这边也可以进行分页查询了
-->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
</bean>
mapperLocations
MyBatis Mapper 所对应的 XML 文件位置，如果您在 Mapper 中有自定义方法（XML 中有自定义实现），需要进行该配置，告诉 Mapper 所对应的 XML 文件位置。
Spring Boot：
#单表查询不满足需求 需要写xml 进行联查等 指定mapper.xml 文件的路径
# classpath* 加上*是 可以扫描所有依赖中的classpath(即加载多个 jar 包下的 XML 文件)下面的xml文件 没有*号 是扫描当前resources下的文件
mybatis-plus.mapper-locations: classpath*:mybatis/*.xml
创建UserMapper,xml
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.mp.boot.mapper.UserMapper">
<select id="findById" resultType="com.mp.boot.pojo.User">
select * from tb_user where id = #{id}
</select>
</mapper>
目录结构：
测试：
@Test
public void test(){
User user = userMapper.findById(1L);
System.out.println(user);
}
结果：
Spring MVC：
<bean id="sqlSessionFactory"
class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
<property name="mapperLocations" value="classpath*:mybatis/*.xml"/>
</bean>
typeAliasesPackage
MyBaits 别名包扫描路径，通过该属性可以给包中的类注册别名，注册后在 Mapper 对应的 XML 文件中可以直接使用类名，而不用使用全限定的类名（即 XML 中调用的时候不用包含包名）。
Spring Boot：
#实体对象扫描包
mybatis-plus.type-aliases-package: com.mp.boot.pojo
Spring MVC：
<!--这里使用Mybatis-plus提供的sqlSessionFactory，完成了Spring与MP的整合-->
<bean id="sqlSessionFactory"
class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<!--
mybatis-config.xml 可以设置分页插件 然后这边也可以进行分页查询了
-->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<!--实体类包扫描-->
<property name="typeAliasesPackage"
value="com.baomidou.mybatisplus.samples.quickstart.entity"/>
</bean>
<!--扫描mapper接口，使用的依然是Mybatis原生的扫描器-->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.mp.spring.mapper"/>
</bean>
配置了这个 Mapper就可以这样填
二、进阶配置
本部分（Configuration）的配置大都为 MyBatis 原生支持的配置，这意味着您可以通过 MyBatis XML 配置文件的形式进行配置。
mapUnderscoreToCamelCase
是否开启自动驼峰命名规则（camel case）映射，即从经典数据库列名 A_COLUMN（下划线命名） 到经典 Java 属性名 aColumn（驼峰命名） 的类似映射。
SpringBoot：
#默认是开启的
#关闭自动驼峰映射，该参数不能和mybatis-plus.config-location同时存在
mybatis-plus.configuration.map-underscore-to-camel-case: false
因为你指定了配置文件 文件里自己可以写这写插件 所以这里就让这两个配置不能同时存在
cacheEnabled
全局地开启或关闭配置文件中的所有映射器已经配置的任何缓存，默认为 true
#开启二级缓存
mybatis-plus.configuration.cache-enabled: false
三、DB 策略配置
idType
全局默认主键类型，设置后，即可省略实体对象中的@TableId(type = IdType.AUTO)配置。
#全局默认主键类型，设置后，即可省略实体对象中的@TableId(type = IdType.AUTO)配置。
mybatis-plus.global-config.db-config.id-type: auto
SpringMVC：
<bean id="sqlSessionFactory"
class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<!--
mybatis-config.xml 可以设置分页插件 然后这边也可以进行分页查询了
-->
<property name="configLocation" value="classpath:mybatis-config.xml"/>
<!--实体类包扫描-->
<property name="typeAliasesPackage"
value="com.baomidou.mybatisplus.samples.quickstart.entity"/>
<property name="globalConfig">
<bean class="com.baomidou.mybatisplus.core.config.GlobalConfig">
<property name="dbConfig">
<bean
class="com.baomidou.mybatisplus.core.config.GlobalConfig$DbConfig">
<property name="idType" value="AUTO"/>
</bean>
</property>
</bean>
</property>
</bean>
tablePrefix
表名前缀，全局配置后可省略@TableName()配置。
SpringBoot：
#表名前缀，全局配置后可省略@TableName()配置。
#类名首字母小写 加上这前缀 就等于tb_user
mybatis-plus.global-config.db-config.table-prefix: tb_
五、条件构造器
在MP中，Wrapper接口的实现类关系如下：
可以看到，AbstractWrapper和AbstractChainWrapper是重点实现，接下来我们重点学习AbstractWrapper以及其子类。
一、allEq
说明
allEq(Map<R, V> params)
allEq(Map<R, V> params, boolean null2IsNull)
allEq(boolean condition, Map<R, V> params, boolean null2IsNull)
个别参数说明: params : key 为数据库字段名, value 为字段值 null2IsNull : 为 true 则在 map 的 value 为null 时调用 isNull 方法,为 false 时则忽略 value 为 null 的：
- 例1: allEq({id:1,name:“老王”,age:null}) —> id = 1 and name = ‘老王’ and
age is null - 例2: allEq({id:1,name:“老王”,age:null}, false) —> id = 1 and name = ‘老王’
allEq(BiPredicate<R, V> filter, Map<R, V> params)
allEq(BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull)
allEq(boolean condition, BiPredicate<R, V> filter, Map<R, V> params, boolean null2IsNull)
个别参数说明: filter : 过滤函数,是否允许字段传入比对条件中 params 与 null2IsNull : 同上
- 例1: allEq((k,v) -> k.indexOf(“a”) > 0, {id:1,name:“老王”,age:null}) —> name = ‘老王’ and age is null
- 例2: allEq((k,v) -> k.indexOf(“a”) > 0, {id:1,name:“老王”,age:null}, false) —> name =‘老王’
测试用例：
@Test
public void testWrapper() {
//条件构造器
QueryWrapper<User> wrapper=new QueryWrapper<>();
//设置条件
Map<String,Object> params = new HashMap<>();
params.put("name", "狗剩");
params.put("age", "21");
params.put("password", null);
// wrapper.allEq(params);
// wrapper.allEq(params,false);
wrapper.allEq((k, v) -> (k.equals("names") || k.equals("age")),params);
List<User> users = userMapper.selectList(wrapper);
for (User user : users) {
System.out.println(user);
}
}
二、基本比较操作
| 查询方式 | 说明 |
|---|---|
| eq | 等于 = |
| ne | 不等于 <> |
| gt | 大于 > |
| ge | 大于等于 >= |
| lt | 小于 < |
| le | 小于等于 <= |
| between | BETWEEN 值1 AND 值2 |
| notBetween | NOT BETWEEN 值1 AND 值2 |
| in | 字段 IN (value.get(0), value.get(1), …) |
| notIn | 字段 NOT IN (v0, v1, …) |
| like | LIKE ‘%值%’ |
| likeLeft | LIKE ‘%值’ |
| likeRight | LIKE ‘值%’ |
| orderBy | ORDER BY 字段, … |
| orderByAsc | ORDER BY 字段, … ASC |
| orderByDesc | ORDER BY 字段, … DESC |
| or | 拼接 OR |
| and | AND 嵌套 |
测试用例：
@Test
public void testEqWrapper() {
QueryWrapper<User> wrapper = new QueryWrapper<>();
//SELECT id,user_name,password,name,age,email FROM tb_user WHERE password = ? AND age >= ? AND name IN (?,?,?)
wrapper.eq("password","123456").gt("age",21).in("name",Arrays.asList("张三","李四","王五"));
List<User> users = this.userMapper.selectList(wrapper);
for (User user : users) {
System.out.println(user);
}
}
三、模糊查询
测试用例：
@Test
public void testLikeWrapper() {
QueryWrapper<User> wrapper = new QueryWrapper<>();
//SELECT id,user_name,password,name,age,email FROM tb_user WHERE name LIKE ?
//parameters '%曹%'
// wrapper.like("name", "曹");
//parameters '%王'
wrapper.likeLeft("name","王");
List<User> users = this.userMapper.selectList(wrapper);
for (User user : users) {
System.out.println(user);
}
}
四、排序
@Test
public void testOrderByWrapper() {
//条件构造器
QueryWrapper<User> wrapper = new QueryWrapper<>();
//SELECT id,user_name,password,name,age,email FROM tb_user ORDER BY age DESC
wrapper.orderByDesc("age");
List<User> users = this.userMapper.selectList(wrapper);
for (User user : users) {
System.out.println(user);
}
}
五、逻辑查询
测试用例：
@Test
public void testOrWrapper() {
//条件构造器
QueryWrapper<User> wrapper = new QueryWrapper<>();
//SELECT id,user_name AS userName,name,age,email AS mail FROM tb_user WHERE name = ? OR name = ?
wrapper.eq("name","李四").or().eq("name","张三");
List<User> users = this.userMapper.selectList(wrapper);
for (User user : users) {
System.out.println(user);
}
}
六、select
在MP查询中，默认查询所有的字段，如果有需要也可以通过select方法进行指定字段。
@Test
public void testSelectWrapper() {
QueryWrapper<User> wrapper = new QueryWrapper<>();
//SELECT id,name,age FROM tb_user WHERE name = ? OR age = ?
wrapper.eq("name", "李四")
.or()
.eq("age", 24)
.select("id", "name", "age");
List<User> users = this.userMapper.selectList(wrapper);
for (User user : users) {
System.out.println(user);
}
}
版权声明：本文为xjk_nb原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。