MyBatisPlus
环境搭建
一、创建测试表
1 | /*创建数据库*/ |
二、创建javaBean
1 | public class Employee { |
三、添加依赖配置
==如下配置不是MyBatis-Plus的配置，是MyBatis的配置，整合了Spring==
添加Maven依赖
在 pom.xml 中加入对 MP、Spring、连接池、Junit、Mysql 驱动等依赖
==特别说明: Mybatis 及 Mybatis-Spring 依赖请勿加入项目配置，以免引起版本冲突！！！ Mybatis-Plus 会自动帮你维护！==
1 | <dependencies> |
添加MyBatis的核心配置文件
==文件名字默认为：mybatis-config.xml，该配置文件到时候可以省略，可以将该配置文件的信息配置到Spring中==
1 |
|
添加Log4j.xml
1 |
|
添加jdbc.properties
1 | jdbc.driver=com.mysql.cj.jdbc.Driver |
Spring的配置文件
==文件名字默认为：applicationContext.xml==
1 |
|
四、创建测试类，测试是否配置成功
1 | public class TestMP { |
五、集成MP
==Mybatis-Plus 的集成非常简单，在applicationContext.xml文件中，只需要把 Mybatis 自带的 SqlSessionFactoryBean 替换为MybatisSqlSessionFactoryBean==
1 | <!--MyBatis-Plus的配置只是将配置SqlSessionFactoryBean改为了MybatisSqlSessionFactoryBean --> |
简单使用CRUD
一、通用 CRUD
BaseMapper
- 实现方式:
- 基于 Mybatis
- 需要编写 EmployeeMapper 接口，并手动编写 CRUD 方法
- 提供 EmployeeMapper.xml 映射文件，并手动编写每个方法对应的 SQL 语句.
- 基于 MP
- 只需要创建 EmployeeMapper 接口, 并继承 BaseMapper 接口.这就是使用 MP
- 需要完成的所有操作，甚至不需要创建 SQL 映射文件。
- 基于 Mybatis
二、类名与表名不一致
局部配置解决
==在JavaBean中使用使用注解来解决==
1 | //数据库的表名为tbl_employee，此时javaBean的名为Employee， |
全局配置解决
==在ApplicationComtext.xml配置文件中配置==
1 | <!--配置mp的全局策略 配置了这个就可以省略类上的@TableName()注解和主键上的@TableId()注解--> |
三、字段名和属性名不一致
主键字段
局部配置：@TableId(value = “字段名”, type = IdType.AUTO)
==在JavaBean的属性名上加上@TableId注解 ， 使用@TableId注解之后，如果字段名字和属性名字一致，系统则不会给字段起别名，如果字段名字和属性名字不一致，系统则会给字段起别名，属性的名字为字段的别名==
1 | public class Employee { |
全局配置
==当属性名字和字段名字一致的时候可以使用全局配置来让主键字段自增长，如果不开启自增长，系统会随机赋值，这时候会报错==
1 | <!--配置mp的全局策略 配置了这个就可以省略类上的@TableName()注解和主键上的@TableId()注解--> |
非主键字段
不满足驼峰命名法
==使用@TableField注解==
1 | public class Employee { |
满足驼峰命名法
==在MyBatis-Plus的新版本中，驼峰命名法是默认开启的，所以可以不需要配置==
1 | <!--这个等于Mybatis的全局配置文件，如果在MybatisSqlSessionFactoryBean里面已经配置了configLocation属性（外部加载Mybatis全局配置文件），就不能再配置configuration属性--> |
四、插入操作
1 | //插入一条记录，insert方法在插入时， 会根据实体类的每个属性进行非空判断，只有非空的属性对应的字段才会出现到SQL语句中 |
使用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24public class TestMP {
private static final ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
private static final EmployeeMapper employeeMapper = context.getBean("employeeMapper", EmployeeMapper.class);
/**
* 通用插入操作
*
* 需要设置主键策略，将主键设置为自增长
*/
public void testMPInsert() {
Employee employee = new Employee();
employee.setLastName("张三");
employee.setEmailN("1903078434@qq.com");
employee.setGender(1);
employee.setAge(22);
//插入的表的名字，默认为传入的实体类的名字
int result = employeeMapper.insert(employee);
System.out.println("修改的条数 = " + result);
}
}
五、删除操作
1 | // 根据 ID 删除 |
int deleteById(Serializable id);
1
2
3
4
5
6
7
8
9
10
11public class TestMP {
private static final ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
private static final EmployeeMapper employeeMapper = context.getBean("employeeMapper", EmployeeMapper.class);
public void testCommonDelete() {
//（根据id删除）：int deleteById(Serializable id);
//执行的SQL：DELETE FROM tbl_employee WHERE id=?
employeeMapper.deleteById(12);
}
}
int deleteByMap(@Param(Constants.COLUMN_MAP) Map
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16public class TestMP {
private static final ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
private static final EmployeeMapper employeeMapper = context.getBean("employeeMapper", EmployeeMapper.class);
public void testCommonDelete() {
//（根据条件进行删除）：int deleteByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
//Map集合中的格式 （key：表中的字段名）（value：值）
//执行的SQL：DELETE FROM tbl_employee WHERE last_name = ? AND email = ?
Map<String, Object> columnMap = new HashMap<>();
columnMap.put("last_name", "张三");
columnMap.put("email", "1903078434@qq.com");
int result = employeeMapper.deleteByMap(columnMap);
System.out.println("result = " + result);
}
}
int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15public class TestMP {
private static final ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");
private static final EmployeeMapper employeeMapper = context.getBean("employeeMapper", EmployeeMapper.class);
public void testCommonDelete() {
//int deleteBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
//执行的SQL：DELETE FROM tbl_employee WHERE id IN ( ? , ? )
List<Integer> idList = new ArrayList<>();
idList.add(13);
idList.add(14);
int result = employeeMapper.deleteBatchIds(idList);
System.out.println("result = " + result);
}
}
六、修改操作
1 | //根据 ID 修改：修改之前会判断传入的值是否为null，当值不为null的之后，才会将该字段加入需要修改的部分，如果传入需要修改的值为null，则不会修改该字段 |
int updateById(@Param(Constants.ENTITY) T entity);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public void testCommonUpdate() {
//int updateById(@Param(Constants.ENTITY) T entity);
//执行的SQL为：UPDATE tbl_employee SET last_name=?, email=?, gender=?, age=? WHERE id=?
Employee employee = new Employee();
employee.setLastName("马尔扎哈");
employee.setEmailN("19030@qq.com");
employee.setGender(0);
employee.setAge(18);
employee.setEmpId(15);
int result = employeeMapper.updateById(employee);
System.out.println("修改的条数 = " + result);
}
int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper
updateWrapper); 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public void testCommonUpdate() {
//int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper<T> updateWrapper)
//执行的SQL为：UPDATE tbl_employee SET last_name=?, email=?, gender=?, age=?
Employee employee = new Employee();
employee.setLastName("马尔扎哈");
employee.setEmailN("19030@qq.com");
employee.setGender(0);
employee.setAge(18);
employee.setEmpId(15);
int result = employeeMapper.updateById(employee);
System.out.println("修改的条数 = " + result);
}
七、查询操作
1 | //根据 ID 查询 |
（根据 ID 查询 ）：T selectById(Serializable id);
1
2
3
4
5
6
public void testCommonSelect() {
//（根据 ID 查询 ）：T selectById(Serializable id);
//执行的SQL：SELECT id AS empId,last_name,email AS emailN,gender,age FROM tbl_employee WHERE id=?
employeeMapper.selectById(1);
}
查询（根据ID 批量查询）List
selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList); 1
2
3
4
5
6
7
8
9
10
public void testCommonSelect() {
//查询（根据ID 批量查询）
//List<T> selectBatchIds(@Param(Constants.COLLECTION) Collection<? extends Serializable> idList);
//执行的SQL：SELECT id AS empId,last_name,email AS emailN,gender,age FROM tbl_employee WHERE id IN ( ? , ? )
List<Integer> idList = new ArrayList<>();
idList.add(1);
idList.add(2);
employeeMapper.selectBatchIds(idList);
}
查询（根据 columnMap 条件）：List
selectByMap(@Param(Constants.COLUMN_MAP) Map 1
2
3
4
5
6
7
8
9
10
public void testCommonSelect() {
//查询（根据 columnMap 条件）
//List<T> selectByMap(@Param(Constants.COLUMN_MAP) Map<String, Object> columnMap);
//执行的SQL：SELECT id AS empId,last_name,email AS emailN FROM tbl_employee WHERE last_name = ? AND email = ?
Map<String, Object> columnMap = new HashMap<>();
columnMap.put("last_name", "张三");
columnMap.put("email", "1903078434@qq.com");
employeeMapper.selectByMap(columnMap);
}
mybatis-plus注解
常用注解：@TableName、@TableId、@TableField、@Version（配合乐观锁使用）、@TableLogic
条件构造器QueryWrapper
==还有其他的条件构造器，具体有哪些和使用方法上网去查找==
一、条件构造器中的方法
==具体使用可以去官网查询==
二、删除操作
1 | //根据 entity（条件构造器） 条件，删除记录，具体使用在后面的条件构造器中去看 |
int delete(@Param(Constants.WRAPPER) Wrapper
queryWrapper) 1
2
3
4
5
public void testCommonDelete() {
//执行的SQL：DELETE FROM tbl_employee WHERE (last_name = ? AND age BETWEEN ? AND ?)
employeeMapper.delete(new QueryWrapper<Employee>().eq("last_name","张三").between("age",17,20));
}
三、修改操作
1 | //根据 whereEntity 条件，更新记录 |
（根据条件修改数据库的信息：）int update(@Param(Constants.ENTITY) T entity, @Param(Constants.WRAPPER) Wrapper
updateWrapper); 1
2
3
4
5
6
7
8
9
public void updateWrapperTest() {
Employee employee = new Employee();
employee.setLastName("王五");
employee.setEmailN("2297");
//执行的SQL：UPDATE tbl_employee SET last_name=?, email=? WHERE (last_name LIKE ? AND age BETWEEN ? AND ?)
employeeMapper.update(employee,new QueryWrapper<Employee>().like("last_name","马尔").between("age",18,20));
}
四、查询
1 | //根据 entity 条件，查询一条记录 ，具体使用在后面的条件构造器中去看 |
（根据条件查询一条数据：）T selectOne(@Param(Constants.WRAPPER) Wrapper
queryWrapper); 1
2
3
4
5
public void queryWrapperTest() {
//执行的SQL：SELECT id AS empId,last_name FROM tbl_employee WHERE (last_name LIKE ?)
employeeMapper.selectOne(new QueryWrapper<Employee>().like("last_name", "李四"));
}（根据条件查询总数：）Integer selectCount(@Param(Constants.WRAPPER) Wrapper
queryWrapper); 1
2
3
4
5
6
7
8
9
10
11
public void queryWrapperTest() {
//执行的SQL：SELECT COUNT( * ) FROM tbl_employee WHERE (last_name LIKE ? OR last_name = ? AND age = ?)
System.out.println("count = " + employeeMapper.selectCount(
new QueryWrapper<Employee>()
.like("last_name", "马尔")
.or()
.eq("last_name", "马尔扎哈")
.eq("age", "18")));
}（根据条件查询全部的数据返回一个集合：）List
selectList(@Param(Constants.WRAPPER) Wrapper queryWrapper); 1
2
3
4
5
public void queryWrapperTest() {
//执行的SQL：SELECT id AS empId,last_name,email FROM tbl_employee WHERE (last_name LIKE ? AND age BETWEEN ? AND ?)
employeeMapper.selectList(new QueryWrapper<Employee>().like("last_name", "马尔").between("age", 17, 20));
}（根据条件查询全部的数据返回一个类型为Map集合的List集合：）List
queryWrapper); 1
2
3
4
5
public void queryWrapperTest() {
//执行的SQL：SELECT id AS empId,last_name,email FROM tbl_employee WHERE (last_name = ?)
employeeMapper.selectMaps(new QueryWrapper<Employee>().eq("last_name","马尔扎哈"));
}（根据条件查询全部数据返回一个存着每一列数据的第一个值的集合：）List
1
2
3
4
5
public void queryWrapperTest() {
//执行的SQL：SELECT id AS empId,last_name,email AS emailN,gender,age FROM tbl_employee WHERE (last_name = ?)
employeeMapper.selectObjs(new QueryWrapper<Employee>().eq("last_name","马尔扎哈")).forEach(System.out::println);
}
ActiveRecord(活动记录)
Active Record(活动记录)，是一种领域模型模式，特点是一个模型类对应关系型数据库中的 一个表，而模型类的一个实例对应表中的一行记录。
ActiveRecord 一直广受动态语言（ PHP 、 Ruby 等）的喜爱，而 Java 作为准静态语言， 对于 ActiveRecord 往往只能感叹其优雅，所以 MP 也在 AR 道路上进行了一定的探索
==MybatisPlus会默认使用实体类的类名到数据中找对应的表.==
一、 如何使用 AR 模式
写一个JavaBean来继承 com.baomidou.mybatisplus.extension.activerecord.Model; 这个类
1 | package com.hngy.lf.pojo; |
二、AR 基本 CRUD
1、查询操作
1 | //查询所有 |
2、查询使用：
1 |
|
3、插入操作
1 | //插入（字段选择插入） |
4、插入使用
1 |
|
5、修改操作
1 | //更新（字段选择更新） |
6、修改使用
1 |
|
7、删除操作
1 | //根据 ID 删除 |
8、删除使用
1 |
|
三、AR 小结
AR 模式提供了一种更加便捷的方式实现 CRUD 操作，其本质还是调用的 Mybatis 对 应的方法，类似于语法糖 语法糖是指计算机语言中添加的某种语法，这种语法对原本语言的功能并没有影响. 可以更方便开发者使用，可以避免出错的机会，让程序可读性更好.
到此，简单领略了 Mybatis-Plus 的魅力与高效率，值得注意的一点是：MP提供 了强大的代码生成器，可以快速生成各类代码，真正的做到了即开即用
代码生成器
==如下只是生成了一部分配置，如果还想生成其他的配置，可以去官网查询==
1 |
|
插件
==这里只展示分页插件、其他插件想要了解，可以去官网查询==
一、分页插件
==除了这个分页插件，还可以使用PageHelper插件，需要导包==
Spring注册分页插件
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29<bean id="sqlSessionFactory" class="com.baomidou.mybatisplus.extension.spring.MybatisSqlSessionFactoryBean">
<!-- 其他属性 略 -->
<property name="configuration" ref="configuration"/>
<property name="plugins">
<array>
<ref bean="mybatisPlusInterceptor"/>
</array>
</property>
</bean>
<!-- 该配置相当于mybatis的核心配置文件 -->
<bean id="configuration" class="com.baomidou.mybatisplus.core.MybatisConfiguration">
<!-- 需配置该值为false,避免1或2级缓存可能出现问题,该属性会在旧插件移除后一同移除 -->
<property name="useDeprecatedExecutor" value="false"/>
</bean>
<bean id="mybatisPlusInterceptor" class="com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor">
<property name="interceptors">
<list>
<ref bean="paginationInnerInterceptor"/>
</list>
</property>
</bean>
<bean id="paginationInnerInterceptor"
class="com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor">
<!-- 对于单一数据库类型来说,都建议配置该值,避免每次分页都去抓取数据库类型 -->
<constructor-arg name="dbType" value="H2"/>
</bean>
在MyBatis的核心配置文件中注册
1
2
3
4
5
6<plugins>
<plugin interceptor="com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor">
<property name="@page" value="com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor"/>
<property name="page:dbType" value="h2"/>
</plugin>
</plugins>
二、PageHelper分页
导入
1
2
3
4
5
6<!-- pageHelper分页插件 -->
<dependency>
<groupId>com.github.pagehelper</groupId>
<artifactId>pagehelper</artifactId>
<version>5.2.0</version>
</dependency>使用：（一下列举了两种实现方式）
PageHelper.offsetPage(参数1,参数2 )==（参数一：从第几条数据开始查询，参数二：每页查询多少条数据）==
接口
1
2
List<User> selectAll();
- 测试
1
2
3
4
5
6
7
8
9
10
11
public void test1() {
//参数一：从第几条数据查询 ----- 参数二：每页显示的数量
//执行的SQL：select *from user LIMIT ?, ?
Page<User> page = PageHelper.offsetPage(2, 4);
userMapper.selectAll();
System.out.println(page);
}
- PageHelper.startPage(参数一, 参数二);==**（参数一：从第几页开始查询。参数二：每页显示多少条数据）**==
> **这里只介绍了两种方法的使用，其他方法的使用可以去PageHelper官网查询使用**
MP-Spring整合配置
mybatis-plus-逻辑删除
第一步：在配置文件中配置
1 | mybatis-plus: |
第二步：实体类用于判断是否删除的字段上加上
@TableLogic注解
1 |
|
相关推荐
评论