MyBatis-PLUS学习

快落靓仔

已于 2022-11-02 11:05:02 修改

阅读量2.4k

点赞数 1

文章标签： mybatis 数据库 java

于 2021-06-18 12:01:05 首次发布

本文链接：https://blog.csdn.net/qq_42923605/article/details/117934336

版权

MyBatis学习

复习Mybatis
开始使用MybatisPlus
MbatisPlus的一些注解
MbatisPlus 继承BaseMapper< T >后的功能
MP的配置
- mapper映射文件配置
- DB配置
条件构造器 QueryWrapper的一些函数
ActiveRecord
MP的插件
MybatisX 快速开发插件

复习Mybatis

创建一个数据库表

USE 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@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');

导入对应依赖

<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>
<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>

创建一个子modle

xzh-mybatis-plus-simple
在子modle文件下分别创建配置文件
在这里插入图片描述
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-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"/>
                <property name="username" value="root"/>
                <property name="password" value="000000"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="UserMapper.xml"/>
    </mappers>
</configuration>

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>

对应的User

package cn.itcast.mp.simple.pojo;

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;

@Data
@NoArgsConstructor
@AllArgsConstructor
public class User {
    private Long id;
    private String user_name;
    private String password;
    private String name;
    private Integer age;
    private String email;
}

对应的Mapper

package cn.itcast.mp.simple.mapper;
import cn.itcast.mp.simple.pojo.User;
import java.util.List;
public interface UserMapper {
    List<User> findAll();
}

对应测试类

package cn.itcast.mp.simple;
import cn.itcast.mp.simple.mapper.UserMapper;
import cn.itcast.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);
        }
    }
}

开始使用MybatisPlus

Mabits+MP

第一步接口继承BaseMapper
T是泛型，就是对应的javabean
继承过后就拥有了基本的增删改查功能哦

Mapper代码：

package cn.itcast.mp.simple.mapper;
import cn.itcast.mp.simple.pojo.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

import java.util.List;
public interface UserMapper extends BaseMapper<User> {
    List<User> findAll();
}

测试代码：
测试代码发生了一些改变

@Test
    public void testUserList() throws Exception{
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new
                MybatisSqlSessionFactoryBuilder().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);
        }
    }

主要变化为

SqlSessionFactory sqlSessionFactory = new
                SqlSessionFactoryBuilder().build(inputStream);

变为

SqlSessionFactory sqlSessionFactory = new
                MybatisSqlSessionFactoryBuilder().build(inputStream);

其余不变

需要注意的是这个插件会把Bean的名字默认为表名可以通过@TableName(“tb_user”)注解
放到bean上面来指定表名

Spring+Mabits+Mp

导入相关依赖

<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>

配置propertiese

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://127.0.0.1:3306/mp
jdbc.username=root
jdbc.password=000000

配置applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns="http://www.springframework.org/schema/beans"
       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>

对应的mapper接口

package cn.itcast.mp.simple.mapper;
import cn.itcast.mp.simple.pojo.User;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
public interface UserMapper extends BaseMapper<User> {
}

测试类：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "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

在pom中添加依赖

<!--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>

编写的pojo和mapper和之前一样
需要注意的是
在springboot的启动类上需要加上mapper的扫描注解
@MapperScan(“cn.itcast.mp.mapper”)

总的来说就是
1.导入MP的依赖

<!--mybatis-plus的springboot支持-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.1.1</version>
        </dependency>

2.配置数据源

spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.url=jdbc:mysql://127.0.0.1:3306/mp
spring.datasource.username=root
spring.datasource.password=000000

3.编写对应的pojo
4.编写Mapper必须继承 BaseMapper<User>
5.测试

MbatisPlus的一些注解

@TableId(type=IdType.AUTO)这个注解是可以写在id上用于标注id自增长
@TableField这个注解解决两个问题：
1、对象中的属性名和字段名不一致的问题（非驼峰）@TableField(value=“数据库表字段名”)
2、对象中的属性字段在表中不存在的问题
@TableField(exist=false)表示这个字段在数据库中不存在
@TableField(select=false)表示这个字段不查询

MbatisPlus 继承BaseMapper< T >后的功能

他记进行操作后会把自增长的数据回写回对象

.insert(T)

返回为数据库受影响的行数 int类型

.updateById(T)

返回为受影响的行数
需要注意的是必须设置id和要修改的属性

.update(T,QueryWrapper< T >)

用法一：

User user = new User();
        user.setId(1l);
        user.setAge(111);
        //实例化一个条件语句
        QueryWrapper< User > wrapper = new QueryWrapper<>();
        //调用eq函数eq第一个是数据库列名 第二个是等于他的意思
        //就是匹配 数据库中  name=张三  的数据
        wrapper.eq("name", "张三");
        //调用update实现更新
        userMapper.update(user,wrapper);

用法二：

实例化一个UpdateWrapper
UpdateWrapper< User > wrapper=new UpdateWrapper<>();
		//设置要修改的值  第一个数据为列名 第二个为值
        wrapper.set("password", "123123");
        //设置修改条件
        wrapper.eq("name", "张三");
        userMapper.update(null,wrapper );

.deleteById(T的ID)

.deleteByMap(Map)

里面放入Map集合
Key为列名
value为值
多个K/V之间条件为AND 即同时满足

.delete(QueryWrapper< T > )

需要实例化一个QueryWrapper
用.eq()设置条件这个函数的用法看上面的更新用法
然后放入这个对象就ok
多个条件之间为AND

用法二：
直接实例化一个bean
设置bean‘的属性值来充当条件
只需要在实例化的时候把bean当参数传入进去就可以自动配eq条件

		User user=new User();
        user.setId(8l);
        QueryWrapper<User> mapper=new QueryWrapper<>(user);
        userMapper.delete(mapper);

.deleteBatchIds(多个id的集合)

根据id批量删除

.selectById(ID)

返回T的对象传入id

.selectBatchIds(多个id的集合)

根据id批量查询返回集合

.selectOne(QueryWrapper< T >)

只会返回一个对象
QueryWrapper参考.delete的写法
如果返回的数据有很多条九福报错

selectCount(queryWrapper)

返回根据条件查询得到的条数

.selectList(queryWrapper)

返回根据条件查询得到一个T的集合
条件为NULL就是全部查询

.selectPage(Page< T >, queryWrapper);

（分页函数）
想要用这个函数
必须要有一个配置类并且配置一个Bean

//设置组件扫描mapper
@MapperScan("cn.itcast.mp.mapper")
@Configuration
public class MybatisPlusConfig {
    @Bean  //配置分页插件
    public PaginationInterceptor paginationInterceptor(){
        return new PaginationInterceptor();
    }
}

具体测试类：
这个测试类没有写条件就是全部查询

 @Test
    public void testSelect() {
    	//这里是 调用构造函数
    	//第一个参数是 当前页  第二个参数是  每页显示条数
        Page<User> page=new Page<>(2,1);
        //通过userIPage可以得到许多分页数据
        IPage< User > userIPage = userMapper.selectPage(page, null);
        //IPage的一些方法函数：
        System.out.println("当前页==> "+userIPage.getCurrent());
        System.out.println("总页数==> "+userIPage.getPages());
        System.out.println("每页显示的数据==> "+userIPage.getSize());
        System.out.println("总记录数==> "+userIPage.getTotal());
        //通过getRecords()函数得到这个页的数据
        List< User > records = userIPage.getRecords();
        for (User record : records) {
            System.out.println(record);
        }
    }

MP的配置

mapper映射文件配置

springBoot项目中直接在application.properties指定配置文件的位置：
全局配置文件

spring.banner.image.location=classpath*:mybatis-config.xml

需要自己写sql语句（指定Mapper.xml）绑定方法为：
在application.properties添加

mybatis-plus.mapper-locations=classpath*:mybatis/*.xml

设置包别名
就是说设置了这个过后凡在cn.itcast.mp.pojo的javabean就可以省略前面这段
直接就写类名就可以

mybatis-plus.type-aliases-package=cn.itcast.mp.pojo

DB配置

#配置全局的id生成策略
mybatis-plus.global-config.db-config.id-type=auto

#配置表名前缀  加上这个  那么所有的表Bean都会以  tb_xxxx  为表名
mybatis-plus.global-config.db-config.table-prefix=tb_

条件构造器 QueryWrapper的一些函数

allEq

.allEq(params)
用法一传入一个map集合 key对应列名 value对应查询的值

.allEq(params,false)
用法二传入一个map集合和Boolean值如果Boolean为false那么集合中的value为null的不会作为查询条件

.allEq((k, v) -> (k.equals(“name”) || k.equals(“age”)),params)
用法三传入一个lambda表达式只有满足这个表达式才会作为查询方式

多个集合之间为and关系

基本比较操作

.eq() 等于 =
需要两个参数，第一个为列名第二个为数据

.ne() 不等于 <>
需要两个参数，第一个为列名第二个为数据

.gt() 大于 >
需要两个参数，第一个为列名第二个为数据

.ge() 大于等于 >=
需要两个参数，第一个为列名第二个为数据

.lt() 小于 <
需要两个参数，第一个为列名第二个为数据

.le() 小于等于 <=
需要两个参数，第一个为列名第二个为数据

.between() 在值1 和值2 之间
需要三个参数，第一个为列名第二、三个为数据

.notBetween() 不在值1 和值2 之间
需要三个参数，第一个为列名第二、三个为数据

.in() 字段 IN (list集合)
例子：in(“id”, Arrays.asList(1, 2, 3, 4, 5))
查询字段的值包括集合中的数据

.notIn() 字段 NOT IN (list集合)
例子：notIn(“id”, Arrays.asList(1,2,3))
查询字段的值不包括集合中的数据

模糊查询

like
LIKE ‘%值%’
例: like(“name”, “王”) 对应SQL语句 name like ‘%王%’

notLike
NOT LIKE ‘%值%’
例: notLike(“name”, “王”) 对应SQL语句 name not like ‘%王%’

likeLeft
LIKE ‘%值’
例: likeLeft(“name”, “王”) 对应SQL语句 name like ‘%王’

likeRight
LIKE ‘值%’
例: likeRight(“name”, “王”) 对应SQL语句 name like '王%

排序

orderBy
排序：ORDER BY 字段, …
例: orderBy(true, true, “id”, “name”) 对应SQL语句 order by id ASC,name ASC

orderByAsc
排序：ORDER BY 字段, … ASC
例: orderByAsc(“id”, “name”) 对应SQL语句 order by id ASC,name ASC

orderByDesc
排序：ORDER BY 字段, … DESC
例: orderByDesc(“id”, “name”) 对应SQL语句 order by id DESC,name DESC

逻辑查询

or
拼接 OR
主动调用 or 表示紧接着下一个方法不是用 and 连接!(不调用 or 则默认为使用 and 连接)
例子：wrapper.eq(“name”,“李四”).or().eq(“age”, 24);

and
AND 嵌套
例: and(i -> i.eq(“name”, “李白”).ne(“status”, “活着”)) —> and (name = ‘李白’ and status
<> ‘活着’)

select

指定查询的字段只会返回自己需要的字段
例子.select(“id”, “name”, “age”);

ActiveRecord

这个东西和Mapper接口差不多可以看看上面继承接口后的使用和有哪些函数
只需要在javaBean上继承Model< T >就可使用了
使用也非常简单类似于之前的mapper继承BaseMapper的功能
但是不需要再使用接口了但是接口还是要有因为底层用到了他

使用步骤
1.编写Bean继承Model< T >
2.编写Mapper继承BaseMapper< T >
3.new一个bean对象
4.直接用bean对象调用方法即可

对应Bean

@Data
@NoArgsConstructor
@AllArgsConstructor
@ToString
@TableName("tb_user")
public class User extends Model<User> {
//    @TableId(type=IdType.AUTO)
    private Long id;
    private String userName;
    private String password;
    private String name;
    private Integer age;
    private String email;
}

对应测试类：

@Test
    public void testselectById() {
        User user=new User();
        user.setId(1l);
        User user1 = user.selectById();
        System.out.println(user1);
    }

MP的插件

乐观锁

意图：
当要更新一条记录的时候，希望这条记录没有被别人更新
乐观锁实现方式：
取出记录时，获取当前version
更新时，带上这个version
执行更新时， set version = newVersion where version = oldVersion
如果version不对，就更新失败

如何实现：

（1）数据库中添加version字段

ALTER TABLE user ADD COLUMN version INT

（2）实体类添加version字段
并添加 @Version 注解和在插入的时候初始化这个值不要忘记在配置类中完善这个属性的值

@Version
@TableField(fill = FieldFill.INSERT)
private Integer version;

（3）元对象处理器接口添加version的insert默认值

@Override
public void insertFill(MetaObject metaObject) {
    ......
    this.setFieldValByName("version", 1, metaObject);
}

（4）在 MybatisPlusConfig 中注册 Bean

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;
import org.springframework.transaction.annotation.EnableTransactionManagement;

@EnableTransactionManagement
@Configuration
@MapperScan("com.atguigu.mybatis_plus.mapper")
public class MybatisPlusConfig {

    /**
     * 乐观锁插件
     */
    @Bean
    public OptimisticLockerInterceptor optimisticLockerInterceptor() {
        return new OptimisticLockerInterceptor();
    }
}

特别说明
支持的数据类型只有:int,Integer,long,Long,Date,Timestamp,LocalDateTime
整数类型下 newVersion = oldVersion + 1
newVersion 会回写到 entity 中
仅支持 updateById(id) 与 update(entity, wrapper) 方法
在 update(entity, wrapper) 方法下, wrapper 不能复用!!!

Sql注入器(增强BaseMapper方法)

首先自定义一个接口，并继承BaseMapper
在这个接口中写需要添加的方法

public interface MyBaseMapper<T> extends BaseMapper<T> {
    List<T> FindAll();
}

怎么写对应的Sql语句
编写一个方法并且继承于DefaultSqlInjector

为什么不直接继承AbstractSqlInjector，因为继承了他过后，他的默认注入器就不会加载到ioc容器中，会导致BaseMapper接口中的方法失效，所以选择继承他的子类，并且把方法添加到自己的接口中

public class MySqlInjector extends DefaultSqlInjector {
    @Override
    public List< AbstractMethod > getMethodList() {
        List< AbstractMethod > list=new ArrayList<>();
        //把父类的方法全部添加到集合中
        list.addAll(super.getMethodList());
        //扩充需要功能
        list.add(new FindAll());
        return list;
    }
}

再编写一个方法，继承DefaultSqlInjector

public class MySqlInjector extends DefaultSqlInjector {
    @Override
    public List< AbstractMethod > getMethodList() {
        List< AbstractMethod > list=new ArrayList<>();
        //把父类的方法全部添加到集合中
        list.addAll(super.getMethodList());
        //扩充需要功能
        list.add(new FindAll());
        return list;
    }
}

核心语句操作
再编写一个对应的添加方法的类：
对应的复杂编写逻辑可以查看AbstractMethod （上面一段代码继承的类）的其他继承类

public class FindAll extends AbstractMethod {
    @Override
    public MappedStatement injectMappedStatement(Class< ? > mapperClass, Class< ? > modelClass, TableInfo tableInfo) {
        String sql="select * from "+tableInfo.getTableName();
        //对应的第二个参数是sql语句就是添加的方法中需要的语句
        //这里的写法差不多也是固定的不同的方法实现的功能不一样需要修改sql语句
        SqlSource sqlSource= languageDriver.createSqlSource(configuration, sql,modelClass);
        //第二个参数是填写在Mapper中需要增强的方法的方法名
        //第三个参数是写SqlSource 对应创建的方法看上面
        //这里的return基本是固定写法，除了上述的两个参数以外
        return this.addSelectMappedStatement(mapperClass, "findAll", sqlSource, modelClass, tableInfo);
    }
}

最后把自己定义的增强接口注册到ioc容器中
springboot只需要在配置类中添加Bean就可以了

@Bean
    public MySqlInjector mySqlInjector(){
        return new MySqlInjector();
    }

测试：

@Test
    public void testFindAll() {
        List< User > all = userMapper.findAll();
        for (User user : all) {
            System.out.println(user);
        }
    }

在控制台查看sql语句只需要在yaml中加上如下配置

#mybatis日志
mybatis-plus.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl

利用MabatisPlus自动生成ID

在为id的属性上放入一个注解 @TableId(type = IdType.XX)
这个注解有几种策略不同的策略说明如下
在这里插入图片描述
当然全局也可以生成只需要在配置文件中加上如下代码即可：

#全局设置主键生成策略
mybatis-plus.global-config.db-config.id-type=xxx

自动填充

（1）数据库表中添加自动填充字段
在User表中添加datetime类型的新的字段 create_time、update_time

（2）实体上添加属性和注解

@Data
public class User {
    ......
        
    @TableField(fill = FieldFill.INSERT)
    private Date createTime;

    //@TableField(fill = FieldFill.UPDATE)
    @TableField(fill = FieldFill.INSERT_UPDATE)
    private Date updateTime;
}

（3）实现元对象处理器接口


@Component
public class MyMetaObjectHandler implements MetaObjectHandler {

    @Override
    public void insertFill(MetaObject metaObject) {
       //表示在新增的时候添加值
        this.setFieldValByName("createTime", new Date(), metaObject);
        this.setFieldValByName("updateTime", new Date(), metaObject);
    }

    @Override
    public void updateFill(MetaObject metaObject) {
      //表示在修改的时候添加值
        this.setFieldValByName("updateTime", new Date(), metaObject);
    }
}

逻辑删除

这个功能就是不在磁盘上删除

（1）数据库中添加 deleted字段

ALTER TABLE user ADD COLUMN deleted boolean

2）实体类添加deleted 字段
并加上 @TableLogic 注解和 @TableField(fill = FieldFill.INSERT) 注解

@TableLogic
@TableField(fill = FieldFill.INSERT)
private Integer deleted

（3）元对象处理器接口添加deleted的insert默认值

@Override
public void insertFill(MetaObject metaObject) {
    ......
    this.setFieldValByName("deleted", 0, metaObject);
}

（4）application.properties 加入配置
此为默认值，如果你的默认值和mp默认的一样,该配置可无

mybatis-plus.global-config.db-config.logic-delete-value=1
mybatis-plus.global-config.db-config.logic-not-delete-value=0

（5）在配置类中中注册 Bean

@Bean
public ISqlInjector sqlInjector() {
    return new LogicSqlInjector();
}

代码生成器

AutoGenerator 是 MyBatis-Plus 的代码生成器，通过 AutoGenerator 可以快速生成 Entity、Mapper、Mapper
XML、Service、Controller 等各个模块的代码，极大的提升了开发效率。
1.首先创建一个springboot工程
2.在pom文件中引入依赖

<!--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>
        <!--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>

自动生成代码：

package com.xzh.mp.generator;

import com.baomidou.mybatisplus.core.exceptions.MybatisPlusException;
import com.baomidou.mybatisplus.core.toolkit.StringPool;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.generator.AutoGenerator;
import com.baomidou.mybatisplus.generator.InjectionConfig;
import com.baomidou.mybatisplus.generator.config.*;
import com.baomidou.mybatisplus.generator.config.po.TableInfo;
import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
import com.baomidou.mybatisplus.generator.engine.FreemarkerTemplateEngine;

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

/**
 * <p>
 * mysql 代码生成器演示例子
 * </p>
 */
public class MysqlGenerator {
    /**
     * <p>
     * 读取控制台内容
     * </p>
     */
    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("xzh");
        gc.setOpen(false);
        mpg.setGlobalConfig(gc);
// 数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://127.0.0.1:3306/mp");
        // dsc.setSchemaName("public");
        dsc.setDriverName("com.mysql.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("000000");
        mpg.setDataSource(dsc);
// 包配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName(scanner("模块名"));
        //设置放在哪个包下
        pc.setParent("com.xzh.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 + "/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();
    }
}

分页插件

1）简介
　　与 mybatis 的插件 pagehelper 用法类似。
　　通过简单的配置即可使用。

【推荐拦截器方式】直接写一个配置类

import com.baomidou.mybatisplus.annotation.DbType;
import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class PlmcPageConfig {
    /**
     * 分页插件
     * @return 分页插件的实例
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
        return interceptor;
    }
}

（2）使用
Step1：
　　配置分页插件。
　　编写一个配置类，内部使用 @Bean 注解将 PaginationInterceptor 交给 Spring 容器管理。

package com.lyh.test.test_mybatis_plus.config;

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;

/**
 * 自定义一个配置类，mapper 扫描也可在此写上
 */
@Configuration
@MapperScan("com.lyh.test.test_mybatis_plus.mapper")
public class Myconfig {
    /**
     * 分页插件
     * @return 分页插件的实例
     */
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        return new PaginationInterceptor();
    }
}

Step2：
　　编写分页代码。
　　直接 new 一个 Page 对象，对象需要传递两个参数（当前页，每页显示的条数）。
　　调用 mybatis-plus 提供的分页查询方法，其会将分页查询的数据封装到 Page 对象中。

@Test
public void testPage() {
    // Step1：创建一个 Page 对象
    Page<User> page = new Page<>();
    // Page<User> page = new Page<>(2, 5);
    // Step2：调用 mybatis-plus 提供的分页查询方法
    userService.page(page, null);
    // Step3：获取分页数据
    System.out.println(page.getCurrent()); // 获取当前页
    System.out.println(page.getTotal()); // 获取总记录数
    System.out.println(page.getSize()); // 获取每页的条数
    System.out.println(page.getRecords()); // 获取每页数据的集合
    System.out.println(page.getPages()); // 获取总页数
    System.out.println(page.hasNext()); // 是否存在下一页
    System.out.println(page.hasPrevious()); // 是否存在上一页
}

MybatisX 快速开发插件

在idea中安装插件 MybatisX
功能：
Java 与 XML 调回跳转
Mapper 方法自动生成 XML
如果需要写方法的增加只需要在Mapper中写方法和参数再使用插件，就可以一件生成xml代码
在这里插入图片描述
如图自动生成的xml

只需要在里面写sql语句即可

快落靓仔

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
1
评论
MyBatis-PLUS学习

MyBatis学习复习Mybatis创建一个数据库表导入对应依赖创建一个子modle开始使用MybatisPlusMabits+MPSpring+Mabits+MpSpringBoot + Mybatis + MP复习Mybatis创建一个数据库表USE mp;-- 创建测试表CREATE TABLE `tb_user` (`id` BIGINT(20) NOT NULL AUTO_INCREMENT COMMENT '主键ID',`user_name` VARCHAR(20) NOT NUL
复制链接

扫一扫