初识MP
介绍
MyBatis-Plus是一个MyBatis增强工具,在MyBatis的基础上只做增强不做改变,为简化开发、提高效率而生。
愿景:我们的愿景是成为MyBatis最好的搭档,就像魂斗罗中的1P、2P,基友搭配,效率翻倍。
特性
- 无侵入:只做增强不做改变,引入它不会对现有工程产生影响,如丝般顺滑
- 损耗小:启动即会自动注入基本CRUD,性能基本无损耗,直接面向对象操作
- 强大的CRUD操作:内置通用Mapper、通用Service,仅仅通过少量配置即可实现单表大部分CRUD操作,更有强大的条件构造器,满足各类使用需求
- 支持Lambda形式调用:通过Lambda表达式,方便的编写各类查询条件,无需再担心字段写错
- 支持多种数据库:支持MySQL、MariaDB、Oracle、DB2、H2、HSQL、SQLite、Postgre、SQLServer等多种数据库
- 支持主键自动生成:支持多达4种主键策略(内含分布式唯一ID生成器Sequence),可自由配置,完美解决主键问题
- 支持XML热加载:Mapper对应的XML支持热加载,对于简单的CRUD操作,甚至可以无XML启动
- 支持ActiveRecord模式:支持ActiveRecord形式调用,实体类只需继承Model类即可进行强大的CRUD操作
- 支持自定义全局通用操作:支持全局通用方法注入(Write once, use anywhere)
- 支持关键词自动转义:支持数据库关键词(order、key…)自动转义,还可自定义关键词
- 内置代码生成器:采用代码或Maven插件可快速生成Mapper、Model、Service、Controller层代码,支持模板引擎,更有超多自定义配置
- 内置分页插件:基于MyBatis物理分页,开发者无需关心具体操作,配置好插件之后,写分页等同于普通 List查询
- 内置性能分析插件:可输出Sql语句以及其执行时间,能快速揪出慢查询
- 内置全局拦截插件:提供全表delete、update操作智能分析阻断,也可自定义拦截规则,预防误操作
- 内置Sql注入剥离器:支持Sql注入剥离,有效预防Sql注入攻击
架构
快速开始
前置准备
对于Mybatis整合MP常有三种用法,分别是Mybatis+MP、Spring+Mybatis+MP、Spring Boot+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`)
)CHARSET utf8;
-- 插入测试数据
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES('1', 'zhangsan', '123456', '张三', '18', 'test1@itcast.cn');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES('2', 'lisi', '123456', '李四', '20', 'test2@itcast.cn');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES('3', 'wangwu', '123456', '王五', '28', 'test3@itcast.cn');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES('4', 'zhaoliu', '123456', '赵六', '21', 'test4@itcast.cn');
INSERT INTO `tb_user` (`id`, `user_name`, `password`, `name`, `age`, `email`) VALUES('5', 'sunqi', '123456', '孙七', '24', 'test5@itcast.cn');
创建工程并导入依赖
<?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>cn.itcast.mp</groupId>
<artifactId>itcast-mybatis-plus</artifactId>
<version>1.0-SNAPSHOT</version>
<modules>
<module>itcast-mybatis-plus-simple</module>
</modules>
<packaging>pom</packaging>
<dependencies>
<!-- mybatis-plus插件依赖 -->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus</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>com.alibaba</groupId>
<artifactId>druid</artifactId>
<version>1.0.11</version>
</dependency>
<!--简化bean代码的工具包-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.18.4</version>
<optional>true</optional>
</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>
Mybatis+MP
创建子Module
<?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>
<packaging>jar</packaging>
<parent>
<artifactId>itcast-mybatis-plus</artifactId>
<groupId>cn.itcast.mp</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<artifactId>itcast-mybatis-plus-simple</artifactId>
</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查询User
-
编写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/mp? useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&useSSL=false"/> <property name="username" value="root"/> <property name="password" value="root"/> </dataSource> </environment> </environments> <mappers> <mapper resource="UserMapper.xml"/> </mappers> </configuration>
-
编写
User
实体对象:@Data @NoArgsConstructor @AllArgsConstructor public class User { private Long id; private String userName; private String password; private String name; private Integer age; private String email; }
-
编写
UserMapper
接口public interface UserMapper { List<User> findAll(); }
-
编写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="cn.itcast.mp.simple.mapper.UserMapper"> <select id="findAll" resultType="cn.itcast.mp.simple.pojo.User"> select * from tb_user </select> </mapper>
-
编写测试用例
public class TestMybatis { @Test public void testUserList() throws Exception{ InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml"); SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream); SqlSession sqlSession = sqlSessionFactory.openSession(); UserMapper userMapper = sqlSession.getMapper(UserMapper.class); List<User> list = userMapper.findAll(); for (User user : list) { System.out.println(user); } } }
Mybatis+MP查询User
-
创建
UserMapper
继承BaseMapper
:public interface UserMapper extends BaseMapper<User> { List<User> findAll(); }
-
使用MP中的
MybatisSqlSessionFactoryBuilder
进程构建,这样继承BaseMapper
中的方法就载入到了SqlSession
中,就可以直接使用相关的方法;public class TestMybatisPlus { @Test public void testUserList() throws Exception{ InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml"); // 这里使用的是MP中的MybatisSqlSessionFactoryBuilder SqlSessionFactory sqlSessionFactory = new MybatisSqlSessionFactoryBuilder().build(resourceAsStream); SqlSession sqlSession = sqlSessionFactory.openSession(); UserMapper userMapper = sqlSession.getMapper(UserMapper.class); // 可以调用BaseMapper中定义的方法 List<User> list = userMapper.selectList(null); for (User user : list) { System.out.println(user); } } }
-
运行报错:
解决:在
User
对象中添加@TableName
,指定数据库表名 -
测试:
Spring+Mybatis+MP
引入了Spring框架,数据源、构建等工作就交给了Spring管理
创建子Module
<?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>
<parent>
<artifactId>itcast-mybatis-plus</artifactId>
<groupId>cn.itcast.mp</groupId>
<version>1.0-SNAPSHOT</version>
</parent>
<artifactId>itcast-mybatis-plus-spring</artifactId>
<properties>
<spring.version>5.1.6.RELEASE</spring.version>
</properties>
<dependencies>
<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>
</project>
查询User
-
编写jdbc.properties
jdbc.driver=com.mysql.jdbc.Driver jdbc.url=jdbc:mysql://127.0.0.1:3306/mp? useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&useSSL=false jdbc.username=root jdbc.password=root
-
编写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> <!--这里使用MP提供的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="cn.itcast.mp.simple.mapper"/> </bean> </beans>
-
编写
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; }
public interface UserMapper extends BaseMapper<User> { }
-
编写测试用例
@RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration("classpath:applicationContext.xml") public class TestSpringMP { @Autowired private UserMapper userMapper; @Test public void testSelectList(){ List<User> users = this.userMapper.selectList(null); for (User user : users) { System.out.println(user); } } }
SpringBoot+Mybatis+MP
使用SpringBoot将进一步的简化MP的整合,需要注意的是,由于使用SpringBoot需要继承parent,所以需要重新创建工程,并不是创建子Module
创建工程及导入依赖
<?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>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.4.RELEASE</version>
</parent>
<groupId>cn.itcast.mp</groupId>
<artifactId>itcast-mp-springboot</artifactId>
<version>1.0-SNAPSHOT</version>
<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
编写application.properties
spring.application.name = itcast-mp-springboot
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/mp?
useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueries=true&useSSL=false
spring.datasource.username=root
spring.datasource.password=root
编写实体类及Mapper
@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;
}
public interface UserMapper extends BaseMapper<User> {
}
编写启动类
@MapperScan("cn.itcast.mp.mapper") // 设置mapper接口的扫描包
@SpringBootApplication
public class MyApplication {
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
}
编写测试用例
@SpringBootTest
public class UserMapperTest {
@Autowired
private UserMapper userMapper;
@Test
public void testSelect() {
List<User> userList = userMapper.selectList(null);
for (User user : userList) {
System.out.println(user);
}
}
}
通用CRUD
继承BaseMapper就可以获取到各种各样的单表操作
插入
示例
@Test
public void testInsert(){
User user = new User();
user.setAge(20);
user.setEmail("test@itcast.cn");
user.setName("曹操");
user.setUserName("caocao");
user.setPassword("123456");
// 返回的result是受影响的行数,并不是自增后的id
int result = userMapper.insert(user);
System.out.println(result);
System.out.println(user.getId()); // 自增后的id会回填到对象中
}
可以看到,数据已经写入到了数据库,但是我们期望id
的值是数据库自增长,如何设置id的生成策略呢?
id生成策略
MP支持的id策略:
public enum IdType {
/**
* 数据库ID自增
*/
AUTO(0),
/**
* 该类型为未设置主键类型
*/
NONE(1),
/**
* 用户输入ID
* <p>该类型可以通过自己注册自动填充插件进行填充</p>
*/
INPUT(2),
/* 以下3种类型、只有当插入对象ID为空,才自动填充。 */
/**
* 全局唯一ID (idWorker)
*/
ID_WORKER(3),
/**
* 全局唯一ID (UUID)
*/
UUID(4),
/**
* 字符串全局唯一ID (idWorker 的字符串表示)
*/
ID_WORKER_STR(5);
private final int key;
IdType(int key) {
this.key = key;
}
}
修改User
对象,id策略为自增主键
@Data
@NoArgsConstructor
@AllArgsConstructor
@TableName("tb_user")
public class User {
@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个:
- 对象中的属性名和字段名不一致的问题(非驼峰)
- 对象中的属性字段在表中不存在的问题
敏感字段不加入查询字段:
更新
在MP中,更新操作有2种,一种是根据id更新,另一种是根据条件更新
updateById
@Test
public void testUpdateById() {
User user = new User();
user.setId(6L); // 主键
user.setAge(21); // 更新的字段
// 根据id更新, 更新不为null的字段
this.userMapper.updateById(user);
}
QueryWrapper
@Test
public void testUpdate() {
User user = new User();
user.setAge(22); // 更新的字段
// 执行更新操作
int result = userMapper.update(user, new QueryWrapper<User>()
.eq("id", 6)); // 更新的条件
System.out.println("result = " + result);
}
UpdateWrapper
@Test
public void testUpdate() {
// 执行更新操作
int result = userMapper.update(null, new UpdateWrapper<User>()
.eq("id", 6).set("age", 23)); // 更新的条件以及字段
System.out.println("result = " + result);
}
删除
deleteById
@Test
public void testDeleteById() {
int result = userMapper.deleteById(6L);
System.out.println("result = " + result);
}
deleteBatchIds
@Test
public void testDeleteByMap() {
// 根据id集合批量删除
int result = userMapper.deleteBatchIds(Arrays.asList(1L, 10L, 20L));
System.out.println("result = " + result);
}
deleteByMap
@Test
public void testDeleteByMap() {
Map<String, Object> map = new HashMap<>();
map.put("age", 20);
map.put("name", "张三");
// 将map中的元素设置为删除的条件,多个之间为and关系
int result = userMapper.deleteByMap(columnMap);
System.out.println("result = " + result);
}
delete
@Test
public void testDeleteByMap() {
User user = new User();
user.setAge(20);
user.setName("张三");
// 将实体对象进行包装,包装为操作条件
int result = userMapper.delete(new QueryWrapper<User>(user));
System.out.println("result = " + result);
}
查询
MP提供了多种查询操作,包括根据id查询、批量查询、查询单条数据、查询列表、分页查询等操作
selectById
@Test
public void testSelectById() {
// 根据id查询数据
User user = userMapper.selectById(2L);
System.out.println("result = " + user);
}
selectBatchIds
@Test
public void testSelectBatchIds() {
// 根据id集合批量查询
List<User> users = userMapper.selectBatchIds(Arrays.asList(2L, 3L, 10L));
for (User user : users) {
System.out.println(user);
}
}
selectOne
@Test
public void testSelectOne() {
// 根据条件查询一条数据,如果结果超过一条会报错
User user = userMapper.selectOne(new QueryWrapper<User>()
.eq("name", "李四"));
System.out.println(user);
}
selectList
@Test
public void testSelectList() {
// 根据条件查询数据
List<User> users = userMapper.selectList(new QueryWrapper<User>()
.gt("age", 23));
for (User user : users) {
System.out.println("user = " + user);
}
}
selectCount
@Test
public void testSelectCount() {
// 根据条件查询数据条数
Integer count = userMapper.selectCount(new QueryWrapper<User>()
.gt("age", 23));
System.out.println("count = " + count);
}
selectPage
配置分页插件:
@Configuration
public class MybatisPlusConfig {
@Bean
public PaginationInterceptor paginationInterceptor() {
return new PaginationInterceptor();
}
}
测试:
@Test
public void testSelectPage() {
Page<User> page = new Page<>(1, 1);
// 根据条件查询数据
IPage<User> iPage = userMapper.selectPage(page, new QueryWrapper<User>()
.gt("age", 20));
// 获取分页信息
System.out.println("数据总条数:" + iPage.getTotal());
System.out.println("总页数:" + iPage.getPages());
// 获取分页列表
List<User> userList = iPage.getRecords();
for (User user : userList) {
System.out.println("user = " + user);
}
}
配置
在MP中有大量的配置,其中有一部分是Mybatis原生的配置,另一部分是MP的配置,详情
基本配置
configLocation
MyBatis配置文件位置,如果有单独的MyBatis配置,请将其路径配置到configLocation
中
Spring Boot:
mybatis-plus.config-location = classpath:mybatis-config.xml
Spring MVC:
<bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
<property name="configLocation" value="classpath:mybatis-config.xml"/>
</bean>
mapperLocations
MyBatis中Mapper所对应的XML文件位置,如果在Mapper中有自定义方法(XML中有自定义实现),需要该配置告诉Mapper所对应的XML文件位置。注意Maven多模块项目的扫描路径需以classpath*:
开头(即加载多个jar包下的XML文件)
Spring Boot:
mybatis-plus.mapper-locations = classpath*:mybatis/*.xml 1
Spring MVC:
<bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
<property name="mapperLocations" value="classpath*:mybatis/*.xml"/>
</bean>
测试:
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="cn.itcast.mp.mapper.UserMapper">
<select id="findById" resultType="cn.itcast.mp.pojo.User">
select * from tb_user where id = #{id}
</select>
</mapper>
UserMapper.java:
public interface UserMapper extends BaseMapper<User> {
User findById(Long id);
}
测试用例:
@Test
public void testSelectPage() {
User user = userMapper.findById(2L);
System.out.println(user);
}
typeAliasesPackage
MyBaits别名包扫描路径,通过该属性可以给包中的类注册别名,注册后在Mapper对应的XML文件中可以直接使用别名,而不用使用全限定的类名
SpringBoot:
mybatis-plus.type-aliases-package = cn.itcast.mp.pojo
Spring MVC:
<bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
<property name="typeAliasesPackage" value="cn.itcast.mp.pojo"/>
</bean>
进阶配置
本部分大都为MyBatis原生支持的配置,意味着可以通过XML配置文件的形式进行配置
mapUnderscoreToCamelCase
概述:是否开启自动驼峰映射,即从经典数据库列名A_COLUMN
(下划线命名)到经典Java属性名aColumn
(驼峰命名)的类似映射
**注意:**此属性在MyBatis中原默认值为false,在MyBatis-Plus中,此属性也将用于生成最终SQL的select body。如果数据库命名符合规则无需使用@TableField
注解指定数据库字段名。
SpringBoot:
# 关闭自动驼峰映射,该参数不能和mybatis-plus.config-location同时存在
mybatis-plus.configuration.map-underscore-to-camel-case=false
cacheEnabled
全局开启或关闭配置文件中的所有映射器已经配置的任何缓存,默认true。
mybatis-plus.configuration.cache-enabled=false
DB策略配置
idType
- 类型:
com.baomidou.mybatisplus.annotation.IdType
- 默认值:
ID_WORKER
全局默认主键类型,设置后可省略实体对象中的@TableId(type = IdType.AUTO)
配置
SpringBoot:
mybatis-plus.global-config.db-config.id-type=auto
SpringMVC:
<!--这里使用MP提供的sqlSessionFactory,完成了Spring与MP的整合-->
<bean id="sqlSessionFactory"
class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<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
-
类型:
String
-
默认值:
null
表名前缀,全局配置后可省略@TableName()
配置
SpringBoot:
mybatis-plus.global-config.db-config.table-prefix=tb_
SpringMVC:
<bean id="sqlSessionFactory"
class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<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"/>
<property name="tablePrefix" value="tb_"/>
</bean>
</property>
</bean>
</property>
</bean>
条件构造器
在MP中,Wrapper
接口的实现类关系如下:
可以看到,AbstractWrapper
和AbstractChainWrapper
是重点实现,接下来重点学习AbstractWrapper
以及其子类
说明:QueryWrapper
(LambdaQueryWrapper
) 和UpdateWrapper
(LambdaUpdateWrapper
)的父类用于生成sql的where条件,entity属性也用于生成sql的where条件。注意entity生成的where条件与使用各个api生成的where条件没有任何关联行为
allEq
语法
allEq(Map<R, V> params);
allEq(Map<R, V> params, boolean null2IsNull);
allEq(boolean condition, Map<R, V> params, boolean null2IsNull);
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);
// 例1: id = 1 and name = '老王' and age is null
allEq({id: 1, name: "老王", age: null})
// 例2: id = 1 and name = '老王'
allEq({id: 1, name: "老王", age: null}, false)
// 例1: name = '老王' and age is null
allEq((k, v) -> k.indexOf("a") > 0, {id: 1, name: "老王", age: null})
// 例2: name ='老王'
allEq((k, v) -> k.indexOf("a") > 0, {id: 1, name: "老王", age: null}, false)
全部eq
或个别isNull
,参数说明:
-
params
:key
为数据库字段名,value
为字段值 -
null2IsNull
:默认true
表示在map的value
为null
时调用isNull
方法,为false时则忽略value=null
的 -
filter
:过滤函数,是否允许字段传入比对条件中
测试
@Test
public void testWrapper() {
QueryWrapper<User> wrapper = new QueryWrapper<>();
//设置条件
Map<String, Object> params = new HashMap<>();
params.put("name", "曹操");
params.put("age", "20");
params.put("password", null);
// SELECT * FROM tb_user WHERE password IS NULL AND name = ? AND age = ?
wrapper.allEq(params);
// SELECT * FROM tb_user WHERE name = ? AND age = ?
wrapper.allEq(params, false);
// SELECT * FROM tb_user WHERE name = ? AND age = ?
wrapper.allEq((k, v) -> (k.equals("name") || k.equals("age")), params);
List<User> userList = userMapper.selectList(wrapper);
for (User user : userList) {
System.out.println(user);
}
}
基本比较操作
关键字
eq
:等于 =ne
:不等于 <>gt
:大于 >ge
:大于等于 >=lt
:小于 <le
:小于等于 <=between
:BETWEEN 值1 AND 值2notBetween
:NOT BETWEEN 值1 AND 值2in
:字段 IN (value.get(0), value.get(1), …)notIn
:字段 NOT IN (v0, v1, …)
测试
@Test
public void testEq() {
// SELECT id,user_name,password,name,age,email FROM tb_user WHERE password = ? AND age >= ? AND name IN (?,?,?)
QueryWrapper<User> wrapper = new QueryWrapper<User>()
.eq("password", "123456")
.ge("age", 20)
.in("name", "李四", "王五", "赵六");
List<User> userList = userMapper.selectList(wrapper);
for (User user : userList) {
System.out.println(user);
}
}
模糊查询
关键字
like
:LIKE '%值%'
notLike
:NOT LIKE '%值%
likeLeft
:LIKE '%值'
likeRight
:LIKE '值%'
// name like '%王%'
like("name", "王");
// name not like '%王%'
notLike("name", "王");
// name like '%王'
likeLeft("name", "王");
// name like '王%'
likeRight("name", "王");
测试
@Test
public void testWrapper() {
// SELECT id,user_name,password,name,age,email FROM tb_user WHERE name LIKE ?
// Parameters: %曹%
QueryWrapper<User> wrapper = new QueryWrapper<User>()
.like("name", "曹");
List<User> userList = userMapper.selectList(wrapper);
for (User user : userList) {
System.out.println(user);
}
}
排序
关键字
-
orderBy
排序:ORDER BY 字段,...
-
orderByAsc
排序:ORDER BY 字段, ... ASC
-
orderByDesc
排序:ORDER BY 字段, ... DESC
// order by id ASC,name ASC
orderBy(true, true, "id", "name");
// order by id ASC,name ASC
orderByAsc("id", "name");
//order by id DESC,name DESC
orderByDesc("id", "name");
测试
@Test
public void testWrapper() {
// SELECT id,user_name,password,name,age,email FROM tb_user ORDER BY age DESC
QueryWrapper<User> wrapper = new QueryWrapper<User>()
.orderByDesc("age");
List<User> userList = userMapper.selectList(wrapper);
for (User user : userList) {
System.out.println(user);
}
}
逻辑查询
关键字
-
or
:或,主动调用or表示紧接着下一个方法不是用and连接!(不调用or
则默认使用and
连接) -
and
:且,默认不显式调用就是and
// name = '李四' or age = 24
eq("name", "李四").or().eq("age", 24);
// and (name = '李白' and status != '活着')
and(i -> i.eq("name", "李白").ne("status", "活着"));
测试
@Test
public void testWrapper() {
// SELECT id,user_name,password,name,age,email FROM tb_user WHERE name = ? OR age = ?
QueryWrapper<User> wrapper = new QueryWrapper<User>()
.eq("name", "李四")
.or()
.eq("age", 24);
List<User> userList = this.userMapper.selectList(wrapper);
for (User user : userList) {
System.out.println(user);
}
}
select
在MP查询中,默认查询所有的字段,如果有需要也可以通过select
过滤指定字段
@Test
public void testWrapper() {
//SELECT id,name,age FROM tb_user WHERE name = ? OR age = ?
QueryWrapper<User> wrapper = new QueryWrapper<User>()
.eq("name", "李四")
.or()
.eq("age", 24)
.select("id", "name", "age");
List<User> userList = userMapper.selectList(wrapper);
for (User user : userList) {
System.out.println(user);
}
}
ActiveRecord
ActiveRecord简称AR,一直广受PHP,Ruby等动态语言的喜爱,而Java作为静态语言,对于ActiveRecord往往只能感叹其优雅,所以我们也在AR道路上进行了一定的探索
概述
什么是ActiveRecord?ActiveRecord也属于ORM(对象关系映射)层,由Rails最早提出,遵循标准的ORM模型:表映射到记录,记录映射到对象,字段映射到对象属性。配合遵循的命名和配置惯例,能够很大程度的快速实现模型的操作,而且简洁易懂。
ActiveRecord的主要思想:
-
每一个数据库表对应创建一个类,类的每一个对象实例对应数据库中表的一行记录;通常表的每个字段在类中都有相应的Field
-
ActiveRecord同时负责把自己持久化,在ActiveRecord中封装了对数据库的访问,即CURD
-
ActiveRecord是一种领域模型Domain Model,封装了部分业务逻辑
快速入门
在MP中,开启AR非常简单,只需要将实体类继承Model
类即可
@Data
@NoArgsConstructor
@AllArgsConstructor
public class User extends Model<User> {
private Long id;
private String userName;
private String password;
private String name;
private Integer age;
private String email;
}
CRUD
根据主键查询
@Test
public void testAR() {
User user = new User();
user.setId(2L);
User result = user.selectById();
System.out.println(result);
}
新增数据
@Test
public void testAR() {
User user = new User();
user.setName("刘备");
user.setAge(30);
user.setPassword("123456");
user.setUserName("liubei");
user.setEmail("liubei@itcast.cn");
boolean flag = user.insert();
System.out.println(flag);
}
更新
@Test
public void testAR() {
User user = new User();
user.setId(8L);
user.setAge(35);
boolean flag = user.updateById();
System.out.println(flag);
}
删除
@Test
public void testAR() {
User user = new User();
user.setId(7L);
boolean flag = user.deleteById();
System.out.println(flag);
}
根据条件查询
@Test
public void testAR() {
User user = new User();
List<User> userList = user.selectList(new QueryWrapper<User>()
.le("age", "20"));
for (User u : userList) {
System.out.println(u);
}
}
Oracle主键Sequence
在mysql中,主键往往是自增长的,这样使用起来是比较方便的。但如果使用的是Oracle数据库,那么就不能使用自增长,而使用Sequence序列生成id值
部署Oracle环境
为了简化环境部署,这里使用Docker进行部署安装Oracle
# 拉取镜像
docker pull sath89/oracle-12c
# 创建容器
docker create --name oracle -p 1521:1521 sath89/oracle-12c
# 启动
docker start oracle && docker logs -f oracle
# 下面是启动过程
Database not initialized. Initializing database.
Starting tnslsnr
Copying database files
1% complete
3% complete
11% complete
18% complete
26% complete
37% complete
Creating and starting Oracle instance
40% complete
45% complete
50% complete
55% complete
56% complete
60% complete
62% complete
Completing Database Creation
66% complete
70% complete
73% complete
85% complete
96% complete
100% complete
Look at the log file "/u01/app/oracle/cfgtoollogs/dbca/xe/xe.log" for further details.
Configuring Apex console
Database initialized. Please visit http://#containeer:8080/em
http://#containeer:8080/apex for extra configuration if needed
Starting web management console
PL/SQL procedure successfully completed.
Starting import from '/docker-entrypoint-initdb.d':
ls: cannot access /docker-entrypoint-initdb.d/*: No such file or directory
Import finished
Database ready to use. Enjoy! ;)
# 通过用户名密码即可登录,用户名和密码为:system/oracle
下面使用navicat连接并操作oracle,注意由于安装的Oracle是64位版本,所以navicat也需要使用64位版本,否则连接不成功。
创建表及序列
-- 创建表, 表名以及字段名都要大写
CREATE TABLE "TB_USER" (
"ID" NUMBER(20) VISIBLE NOT NULL,
"USER_NAME" VARCHAR2(255 BYTE) VISIBLE,
"PASSWORD" VARCHAR2(255 BYTE) VISIBLE,
"NAME" VARCHAR2(255 BYTE) VISIBLE,
"AGE" NUMBER(10) VISIBLE,
"EMAIL" VARCHAR2(255 BYTE) VISIBLE
);
-- 创建序列
CREATE SEQUENCE SEQ_USER START WITH 1 INCREMENT BY 1;
jdbc驱动包
由于版权原因,我们不能直接通过maven的中央仓库下载oracle数据库的jdbc驱动包,所以需要将驱动包安装到本地仓库,安装完成后再导入坐标
# ojdbc8.jar文件在资料中可以找到
mvn install:install-file -DgroupId=com.oracle -DartifactId=ojdbc8 -Dversion=12.1.0.1 -
Dpackaging=jar -Dfile=ojdbc8.jar
<dependency>
<groupId>com.oracle</groupId>
<artifactId>ojdbc8</artifactId>
<version>12.1.0.1</version>
</dependency>
application.properties
需要修改application.properties的2个位置:
# 数据库连接配置
spring.datasource.driver-class-name=oracle.jdbc.OracleDriver
spring.datasource.url=jdbc:oracle:thin:@192.168.31.81:1521:xe
spring.datasource.username=system
spring.datasource.password=oracle
# id生成策略
mybatis-plus.global-config.db-config.id-type=input
配置序列
使用Oracle序列需要做2件事情:
1.配置MP的序列生成器到Spring容器:
@Configuration
public class MPConfig {
@Bean
public PaginationInterceptor paginationInterceptor() {
return new PaginationInterceptor();
}
/**
* 序列生成器
*/
@Bean
public OracleKeyGenerator oracleKeyGenerator(){
return new OracleKeyGenerator();
}
}
2.在实体对象中指定序列名称:
@KeySequence(value = "SEQ_USER", clazz = Long.class)
public class User{
// ......
}
测试
@Test
public void testInsert(){
User user = new User();
user.setAge(20);
user.setEmail("test@itcast.cn");
user.setName("曹操");
user.setUserName("caocao");
user.setPassword("123456");
// 返回的result是受影响的行数,并不是自增后的id
int result = userMapper.insert(user);
System.out.println("result = " + result);
// 自增后的id会回填到对象中
System.out.println(user.getId());
}
@Test
public void testSelectById(){
User user = userMapper.selectById(8L);
System.out.println(user);
}
插件
mybatis插件机制
MyBatis允许在已映射语句执行过程中的某一点进行拦截调用。默认情况下,MyBatis允许使用插件来拦截的方法调用包括:
// 1. 拦截执行器的方法
Executor(update, query, flushStatements, commit, rollback, getTransaction, close, isClosed);
// 2. 拦截参数的处理
ParameterHandler(getParameterObject, setParameters);
// 3. 拦截结果集的处理
ResultSetHandler(handleResultSets, handleOutputParameters);
// 4. 拦截Sql语法构建的处理
StatementHandler(prepare, parameterize, batch, update, query);
我们看到可以拦截Executor
接口的部分方法,比如update,query,commit,rollback等方法,还有其他接口的一些方法等。
拦截器示例:
@Intercepts({@Signature(
type= Executor.class,
method = "update",
args = {MappedStatement.class,Object.class})})
public class MyInterceptor implements Interceptor {
@Override
public Object intercept(Invocation invocation) throws Throwable {
// 拦截方法,具体业务逻辑编写的位置
return invocation.proceed();
}
@Override
public Object plugin(Object target) {
// 创建target对象的代理对象,目的是将当前拦截器加入到该对象中
return Plugin.wrap(target, this);
}
@Override
public void setProperties(Properties properties) {
// 属性设置
}
}
分页插件
注入到Spring容器:
/**
* 自定义拦截器
*/
@Bean
public MyInterceptor myInterceptor(){
return new MyInterceptor();
}
或通过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="cn.itcast.mp.plugins.MyInterceptor"/>
</plugins>
</configuration>
执行分析插件
在MP中提供了对SQL执行进行分析的插件,可用作阻断全表更新、删除的操作,注意:该插件仅适用于开发环境,不适用于生产环境。
SpringBoot配置:
@Bean
public SqlExplainInterceptor sqlExplainInterceptor(){
SqlExplainInterceptor sqlExplainInterceptor = new SqlExplainInterceptor();
List<ISqlParser> sqlParserList = new ArrayList<>();
// 攻击SQL阻断解析器、加入解析链
sqlParserList.add(new BlockAttackSqlParser());
sqlExplainInterceptor.setSqlParserList(sqlParserList);
return sqlExplainInterceptor;
}
测试:
@Test
public void testUpdate(){
User user = new User();
user.setAge(20);
int result = userMapper.update(user, null);
System.out.println("result = " + result);
}
**结果:**可以看到,执行全表更新时会抛出异常,这样可有效防止一些误操作
性能分析插件
性能分析拦截器,用于输出每条SQL语句及其执行时间,可以设置最大执行时间,超过时间会抛出异常。该插件只用于开发环境,不建议生产环境使用。
配置:
<?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>
<!-- SQL执行性能分析,开发环境使用,线上不推荐,maxTime指的是sql最大执行时长 -->
<plugin interceptor="com.baomidou.mybatisplus.extension.plugins.PerformanceInterceptor">
<property name="maxTime" value="100"/>
<!--SQL是否格式化,默认false-->
<property name="format" value="true"/>
</plugin>
</plugins>
</configuration>
执行结果:
可以看到,执行时间为11ms。如果将maxTime
设置为1,那么该操作会抛出异常
乐观锁插件
适用场景
意图:当要更新一条记录的时候,希望这条记录没有被别人更新
乐观锁实现方式:
-
取出记录时,获取当前version
-
更新时,带上这个version
-
执行更新时,
set version=newVersion where version=oldVersion
-
如果version不对,就更新失败
插件配置
spring xml:
<bean class="com.baomidou.mybatisplus.extension.plugins.OptimisticLockerInterceptor"/>
SpringBoot:
@Bean
public OptimisticLockerInterceptor optimisticLockerInterceptor() {
return new OptimisticLockerInterceptor();
}
注解实体字段
需要为实体字段添加@Version
注解。
-
为表添加
version
字段,并且设置初始值为1:ALTER TABLE `tb_user` ADD COLUMN `version` int(10) NULL AFTER `email`; UPDATE `tb_user` SET `version`=1;
-
为
User
实体对象添加version
字段,并且添加@Version
注解:@Version private Integer version;
测试
@Test
public void testUpdate() {
User user = new User();
user.setAge(30);
user.setId(2L);
user.setVersion(1); // 获取到version为1
int result = userMapper.updateById(user);
System.out.println("result = " + result);
}
可以看到,更新条件中有version条件,并且更新的version为2。如果再次执行,更新不成功。这样就避免了多人同时更新时导致数据的不一致。
特别说明
-
支持的数据类型只有:
int,Integer,long,Long,Date,Timestamp,LocalDateTime
-
整数类型下:
newVersion = oldVersion+1
-
newVersion
会回写到entity中 -
仅支持
updateById(id)
与update(entity, wrapper)
方法 -
在
update(entity, wrapper)
方法下,wrapper
不能复用!!!
进阶操作
字段自动填充
有时候可能会有这样的需求,插入或更新数据时,希望有些字段可以自动填充数据,比如create_time、version等
添加@TableField
注解
@TableField(fill = FieldFill.INSERT) // 插入数据时进行填充
private String password;
为password
添加自动填充功能,在新增数据时有效,FieldFill
提供了多种模式选择:
public enum FieldFill {
/**
* 默认不处理
*/
DEFAULT,
/**
* 插入时填充字段
*/
INSERT,
/**
* 更新时填充字段
*/
UPDATE,
/**
* 插入和更新时填充字段
*/
INSERT_UPDATE
}
编写MyMetaObjectHandler
@Component
public class MyMetaObjectHandler implements MetaObjectHandler {
@Override
public void insertFill(MetaObject metaObject) {
Object password = getFieldValByName("password", metaObject);
if(null == password){
// 字段为空,可以进行填充
setFieldValByName("password", "123456", metaObject);
}
}
@Override
public void updateFill(MetaObject metaObject) {
}
}
测试
@Test
public void testInsert(){
// 不设置密码
User user = new User();
user.setName("关羽");
user.setUserName("guanyu");
user.setAge(30);
user.setEmail("guanyu@itast.cn");
user.setVersion(1);
int result = userMapper.insert(user);
System.out.println("result = " + result);
}
逻辑删除
有时删除操作需要实现逻辑删除,所谓逻辑删除就是将数据标记为删除,而并非真正的物理删除(非DELETE操作),查询时需要携带状态条件,确保被标记的数据不被查询到。这样做的目的就是避免数据被真正的删除
修改表结构
为tb_user
表增加deleted
字段,表示数据是否被删除,1
代表删除,0
代表未删除
ALTER TABLE `tb_user` ADD COLUMN `deleted` int(1) NULL DEFAULT 0 COMMENT '1代表删除,0代表未删除' AFTER `version`;
同时也修改User
实体,增加deleted
属性并且添加@TableLogic
注解:
@TableLogic
private Integer deleted;
配置application.properties
# 逻辑已删除值(默认为1)
mybatis-plus.global-config.db-config.logic-delete-value=1
# 逻辑未删除值(默认为0)
mybatis-plus.global-config.db-config.logic-not-delete-value=0
测试删除
@Test
public void testDeleteById() {
userMapper.deleteById(2L);
}
测试查询
@Test
public void testSelectById(){
User user = userMapper.selectById(2L);
System.out.println(user);
}
通用枚举
解决了繁琐的配置,让mybatis优雅的使用枚举属性
修改表结构
ALTER TABLE `tb_user` ADD COLUMN `sex` int(1) NULL DEFAULT 1 COMMENT '1-男,2-女' AFTER `deleted`;
定义枚举
public enum SexEnum implements IEnum<Integer> {
MAN(1, "男"),
WOMAN(2, "女");
private int value;
private String desc;
SexEnum(int value, String desc) {
this.value = value;
this.desc = desc;
}
@Override
public Integer getValue() {
return this.value;
}
@Override
public String toString() {
return this.desc;
}
}
配置application.properties
# 枚举包扫描
mybatis-plus.type-enums-package=cn.itcast.mp.enums
修改实体
private SexEnum sex;
测试插入
@Test
public void testInsert() {
User user = new User();
user.setName("貂蝉");
user.setUserName("diaochan");
user.setAge(20);
user.setEmail("diaochan@itast.cn");
user.setVersion(1);
// 枚举类型
user.setSex(SexEnum.WOMAN);
int result = userMapper.insert(user);
System.out.println("result = " + result);
}
测试查询
@Test
public void testSelectById(){
User user = userMapper.selectById(2L);
System.out.println(user);
}
从测试可以看出,可以很方便的使用枚举。查询条件时也是有效的:
@Test
public void testSelectBySex() {
List<User> userList = userMapper.selectList(new QueryWrapper<User>()
.eq("sex", SexEnum.WOMAN));
for (User user : userList) {
System.out.println(user);
}
}
Sql注入器扩展Mapper功能
SQL注入器原理
MP在启动后会将BaseMapper
中的一系列的方法注册到mappedStatements
中,那么究竟是如何注入的呢?流程又是怎么样的?在MP中,ISqlInjector
负责SQL的注入工作,它是一个接口,AbstractSqlInjector
是它的实现类,实现关系如下:
在AbstractSqlInjector
中,主要是由inspectInject()
进行注入:
@Override
public void inspectInject(MapperBuilderAssistant builderAssistant, Class<?> mapperClass) {
Class<?> modelClass = extractModelClass(mapperClass);
if (modelClass != null) {
String className = mapperClass.toString();
Set<String> mapperRegistryCache = GlobalConfigUtils.getMapperRegistryCache(builderAssistant.getConfiguration());
if (!mapperRegistryCache.contains(className)) {
List<AbstractMethod> methodList = this.getMethodList();
if (CollectionUtils.isNotEmpty(methodList)) {
TableInfo tableInfo = TableInfoHelper.initTableInfo(builderAssistant, modelClass);
// 循环注入自定义方法
methodList.forEach(m -> m.inject(builderAssistant, mapperClass, modelClass, tableInfo));
} else {
logger.debug(mapperClass.toString() + ", No effective injection method was found.");
}
mapperRegistryCache.add(className);
}
}
}
在实现方法中, methodList.forEach(m -> m.inject(builderAssistant, mapperClass, modelClass, tableInfo));
是关键,循环遍历进行注入。最终调用抽象方法injectMappedStatement
进行真正的注入:
/**
* 注入自定义 MappedStatement
*
* @param mapperClass mapper 接口
* @param modelClass mapper 泛型
* @param tableInfo 数据库表反射信息
* @return MappedStatement
*/
public abstract MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo);
该方法的所有实现:
以SelectById
为例:
public class SelectById extends AbstractMethod {
@Override
public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
SqlMethod sqlMethod = SqlMethod.LOGIC_SELECT_BY_ID;
SqlSource sqlSource = new RawSqlSource(configuration, String.format(
sqlMethod.getSql(), sqlSelectColumns(tableInfo, false),
tableInfo.getTableName(), tableInfo.getKeyColumn(),
tableInfo.getKeyProperty(), tableInfo.getLogicDeleteSql(true, false)
), Object.class);
return this.addSelectMappedStatement(mapperClass, sqlMethod.getMethod(), sqlSource, modelClass, tableInfo);
}
}
可以看到,生成了SqlSource
对象,再将SQL通过addSelectMappedStatement
方法添加到mappedStatements
中
在MP中通过AbstractSqlInjector
将BaseMapper
中的方法注入到了Mybatis容器,这样这些方法才可以正常执行。那么,如果需要扩充BaseMapper
中的方法,又该如何实现呢?下面以扩展findAll
方法为例
编写MyBaseMapper
public interface MyBaseMapper<T> extends BaseMapper<T> {
List<T> findAll();
}
其他的Mapper都可以继承该Mapper,这样实现了统一的扩展
public interface UserMapper extends MyBaseMapper<User> {
User findById(Long id);
}
编写FindAll
public class FindAll extends AbstractMethod {
@Override
public MappedStatement injectMappedStatement(Class<?> mapperClass, Class<?> modelClass, TableInfo tableInfo) {
String sqlMethod = "findAll";
String sql = "select * from " + tableInfo.getTableName();
SqlSource sqlSource = languageDriver.createSqlSource(configuration, sql, modelClass);
return this.addSelectMappedStatement(mapperClass, sqlMethod, sqlSource, modelClass, tableInfo);
}
}
编写MySqlInjector
如果直接继承AbstractSqlInjector
的话,原有的BaseMapper
中的方法将失效,所以需要继承DefaultSqlInjector
进行扩展
public class MySqlInjector extends DefaultSqlInjector {
@Override
public List<AbstractMethod> getMethodList() {
List<AbstractMethod> methodList = super.getMethodList();
// 扩充自定义的方法
methodList.add(new FindAll());
return methodList;
}
}
注册到Spring容器
/**
* 自定义SQL注入器
*/
@Bean
public MySqlInjector mySqlInjector(){
return new MySqlInjector();
}
测试
至此实现了全局扩展SQL注入器
@Test
public void testFindAll(){
List<User> userList = userMapper.findAll();
for (User user : userList) {
System.out.println(user);
}
}
代码生成器
AutoGenerator是MyBatis-Plus的代码生成器,通过AutoGenerator可以快速生成Entity,Mapper,MapperXML,Service,Controller等各个模块的代码,极大提升开发效率。
创建工程
<?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>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.1.4.RELEASE</version>
</parent>
<groupId>cn.itcast.mp</groupId>
<artifactId>itcast-mp-generator</artifactId>
<version>1.0-SNAPSHOT</version>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
<!--mybatis-plus的springboot支持-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.1.1</version>
</dependency>
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-generator</artifactId>
<version>3.1.1</version>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-freemarker</artifactId>
</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>
代码
/**
* mysql 代码生成器演示例子
*/
public class MysqlGenerator {
/**
* 读取控制台内容
*/
public static String scanner(String tip) {
Scanner scanner = new Scanner(System.in);
StringBuilder help = new StringBuilder();
help.append("请输入" + tip + ":");
System.out.println(help.toString());
if (scanner.hasNext()) {
String ipt = scanner.next();
if (StringUtils.isNotEmpty(ipt)) {
return ipt;
}
}
throw new MybatisPlusException("请输入正确的" + tip + "!");
}
/**
* RUN THIS
*/
public static void main(String[] args) {
// 代码生成器
AutoGenerator mpg = new AutoGenerator();
// 全局配置
GlobalConfig gc = new GlobalConfig();
String projectPath = System.getProperty("user.dir");
gc.setOutputDir(projectPath + "/src/main/java");
gc.setAuthor("itcast");
gc.setOpen(false);
mpg.setGlobalConfig(gc);
// 数据源配置
DataSourceConfig dsc = new DataSourceConfig();
dsc.setUrl("jdbc:mysql://127.0.0.1:3306/mp?useUnicode=true&useSSL=false&characterEncoding=utf8");
// dsc.setSchemaName("public");
dsc.setDriverName("com.mysql.jdbc.Driver");
dsc.setUsername("root");
dsc.setPassword("root");
mpg.setDataSource(dsc);
// 包配置
PackageConfig pc = new PackageConfig();
pc.setModuleName(scanner("模块名"));
pc.setParent("cn.itcast.mp.generator");
mpg.setPackageInfo(pc);
// 自定义配置
InjectionConfig cfg = new InjectionConfig() {
@Override
public void initMap() {
// to do nothing
}
};
List<FileOutConfig> focList = new ArrayList<>();
focList.add(new FileOutConfig("/templates/mapper.xml.ftl") {
@Override
public String outputFile(TableInfo tableInfo) {
// 自定义输入文件名称
return projectPath + "/itcast-mp-generator/src/main/resources/mapper/" + pc.getModuleName() + "/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
}
});
cfg.setFileOutConfigList(focList);
mpg.setCfg(cfg);
mpg.setTemplate(new TemplateConfig().setXml(null));
// 策略配置
StrategyConfig strategy = new StrategyConfig();
strategy.setNaming(NamingStrategy.underline_to_camel);
strategy.setColumnNaming(NamingStrategy.underline_to_camel);
// strategy.setSuperEntityClass("com.baomidou.mybatisplus.samples.generator.common.BaseEntity");
strategy.setEntityLombokModel(true);
// strategy.setSuperControllerClass("com.baomidou.mybatisplus.samples.generator.common.BaseController");
strategy.setInclude(scanner("表名"));
strategy.setSuperEntityColumns("id");
strategy.setControllerMappingHyphenStyle(true);
strategy.setTablePrefix(pc.getModuleName() + "_");
mpg.setStrategy(strategy);
// 选择freemarker引擎需要指定如下加,注意pom依赖必须有
mpg.setTemplateEngine(new FreemarkerTemplateEngine());
mpg.execute();
}
}
测试
代码已生成:
实体对象:
IDEA插件MybatisX
MybatisX是一款基于IDEA的快速开发插件,为效率而生。
安装方法:打开IDEA,进入File -> Settings -> Plugins -> Browse Repositories,输入mybatisx搜索并安装。
功能:
- Java与XML调回跳转
- Mapper方法自动生成XML
常用注解
实体类注解
@TableName
作用:用于定义表名
@TableId
作用:定义表的主键
属性:
value
:主键字段名type
:主键策略类型,IdType.AUTO
:主键自增,系统分配,不需要手动输入,但需要在mysql中设置auto_incrementIdType.NONE
:未设置主键IdType.INPUT
:自己输入主键值IdType.ASSIGN_ID
:系统分配ID,用于数值型数据,如Long, Integer等IdType.ASSIGN_UUID
:系统分配UUID,用于字符串型String数据
@TableField
作用:定义表的非主键字段
属性:
-
value
:非主键的字段名,一般用于别名匹配(数据库字段名和POJO属性名不一致) -
exist
:指定POJO的属性是否为数据库中的字段、是否存在 -
fill
:字段填充策略,一般用于createTime和updateTimeFieldFill.DEFAULT
:默认不填充FieldFill.INSERT
:插入时填充FieldFill.UPDATE
:更新时填充FieldFill.INSERT_UPDATE
:插入、更新时填充。
在使用
fill
填充策略时,需要实现处理才能生效:@Component public class MyMetaObjectHandler implements MetaObjectHandler { @Override public void insertFill(MetaObject metaObject) { setFieldValByName("createTime", new Date(), metaObject); setFieldValByName("updateTime", new Date(), metaObject); } @Override public void updateFill(MetaObject metaObject) { setFieldValByName("updateTime", new Date(), metaObject); } }
示例
@Data
// 指定表名
@TableName("tb_user")
public class User {
// 指定实体类的id,以及id类型, AUTO是自增长
@TableId(type = IdType.AUTO)
private Long id;
private String username;
private String password;
// 在数据表中不存在的字段
@TableField(exist = false)
private String region;
// fill指定填充的时机, INSERT插入
@TableField(fill = FieldFill.INSERT)
private LocalDateTime createTime;
// INSERT_UPDATE插入和更新
@TableField(fill = FieldFill.INSERT_UPDATE)
private LocalDateTime updateTime;
}
其他注解
@Version
详情:插件 -> 乐观锁插件
作用:乐观锁插件
@TableLogic
详情:进阶操作 -> 逻辑删除
作用:逻辑删除字段
@EnumValue
详情:进阶操作 -> 通用枚举
作用:实现通用枚举