MyBatisPlus配置

1.添加依赖

<!--mybatis-plus-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.3.1</version>
        </dependency>

        <!--mysql-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.28</version>
        </dependency>

        <!--lombok用来简化实体类-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

2.application.properties配置

#注意
mysql8以上（spring boot 2.1）注意：driver和url的变化
spring.datasource.driver-class-name=com.mysql.jdbc.Driver
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
#=========================================================================

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url: jdbc:mysql://localhost:3306/admin?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai
spring.datasource.username=root
spring.datasource.password=root

#逻辑已删除值 还需要在实体类中添加注解
mybatis-plus.global-config.db-config.logic-delete-value=1 
#逻辑未删除值 
mybatis-plus.global-config.db-config.logic-not-delete-value=0 
#设置主键自增格式
mybatis-plus.global-config.db-config.id-type: auto

#sql映射文件位置
mybatis-plus.mapper-locations: classpath:/mapper/**/*.xml

 
#返回json的全局时间格式
spring.jackson.date-format=yyyy-MM-dd HH:mm:ss
spring.jackson.time-zone=GMT+8

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

3.分页配置类

@Configuration
@EnableTransactionManagement //开启事务
//告诉MyBatis-Plus，sql映射文件位置
@MapperScan("com.base.demo.ceshi.dao") 
public class MyBatisConfig {
    //引入分页插件
    @Bean
    public PaginationInterceptor paginationInterceptor() {
        PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
        // 设置请求的页面大于最大页后操作， true调回到首页，false 继续请求  默认false
        //paginationInterceptor.setOverflow(true);
        // 设置最大单页限制数量，默认 500 条，-1 不受限制
        //paginationInterceptor.setLimit(1000);
        return paginationInterceptor;
    }
}

//测试
@Test
public void testSelectPage() {
    Page<User> page = new Page<>(1,5);
    userMapper.selectPage(page, null);
    page.getRecords().forEach(System.out::println);
    System.out.println(page.getCurrent());
    System.out.println(page.getPages());
    System.out.println(page.getSize());
    System.out.println(page.getTotal());
    System.out.println(page.hasNext());
    System.out.println(page.hasPrevious());
}

4.实体类

@Data
@TableName("sys_user")
public class SysUserEntity implements Serializable {
    /**
     * 用户ID
     */
    @TableId
    private Long userId;

    /**
     * 用户名
     */
    private String username;

    /**
     * 密码
     */
    private String password;
    @TableLogic(value = "1",delval = "0")
	private Integer showStatus;
}

@TableName

​ 描述：表名注解，标识实体类对应的表

​ 使用位置：实体类

@TableId

​ 描述：主键注解，表明此字段是表中主键

​ 使用位置：实体类主键字段

注解参数：

属性	类型	必须指定	默认值	描述
value	String	否	“”	主键字段名
type	Enum	否	IdType.NONE	指定主键类型

IdType 中包含主键自增策略

值	描述
AUTO	数据库 ID 自增
NONE	无状态，该类型为未设置主键类型（注解里等于跟随全局，全局里约等于 INPUT）
INPUT	insert 前自行 set 主键值
ASSIGN_ID	分配 ID (主键类型为 Number(Long 和 Integer) 或 String) (since 3.3.0)，使用接口 IdentifierGenerator 的方法 nextId (默认实现类为 DefaultIdentifierGenerato 雪花算法)
ASSIGN_UUID	分配 UUID,主键类型为 String(since 3.3.0)，使用接口 IdentifierGenerator 的方法 nextUUID (默认 default 方法)
ID_WORKER	分布式全局唯一 ID 长整型类型(please use ASSIGN_ID)
UUID	32 位 UUID 字符串(please use ASSIGN_UUID)
ID_WORKER_STR	分布式全局唯一 ID 字符串类型(please use ASSIGN_ID)

@TableField：标注其为非数据库, 但又是必须使用的, 防止 BaseMapper 基础查询时误加上此条件

@TableLogic：表字段逻辑处理注解(逻辑删除)

@Version：乐观锁注解

@OrderBy：内置 SQL 默认指定排序，优先级低于 wrapper 条件查询

5.创建controlle

@RestController
@RequestMapping("/sys/user")
public class SysUserController  {

    @Autowired
    private SysUserService sysUserService;
    
    /**
     * 所有用户列表
     */
    @GetMapping("/list")
    public List<SysUserEntity> list(@RequestParam Map<String, Object> params){
        List<SysUserEntity> sysUserEntity = sysUserService.queryPage(params);
        return sysUserEntity;
    }
}

6.创建service

public interface SysUserService extends IService<SysUserEntity> {

    List<SysUserEntity> queryPage(Map<String, Object> params);
}

7.创建serviceImpl

@Service("sysUserService")
public class SysUserServiceImpl extends ServiceImpl<SysUserDao, SysUserEntity> implements SysUserService {
    @Override
    public List<SysUserEntity> queryPage(Map<String, Object> params) {
        List<SysUserEntity> list = this.list();
        return list;
    }
}

通过使用条件构造器 QueryWrapper，我们可以与上面的 BaseMapper 中封装好的 CRUD 方法结合起来，作为方法的参数即可使用代码的方式进行数据库的相关操作。。。

queryWrapper.lt() ——小于
queryWrapper.le() ——小于等于
queryWrapper.gt() ——大于
queryWrapper.ge() ——大于等于
queryWrapper.eq() ——等于
queryWrapper.ne() ——不等于
queryWrapper.betweeen("age",10,20) ——age在值10到20之间
queryWrapper.notBetweeen("age",10,20) ——age不在值10到20之间
queryWrapper.like("属性", "值") ——模糊查询匹配值‘%值%’
queryWrapper.notLike("属性","值") ——模糊查询不匹配值‘%值%’
queryWrapper.likeLeft("属性","值") ——模糊查询匹配最后一位值‘%值’
queryWrapper.likeRight("属性", "值")——模糊查询匹配第一位值‘值%’
queryWrapper.isNull() ——值为空或null
queryWrapper.isNotNull() ——值不为空或null
queryWrapper.in("属性", 条件, 条件)——符合多个条件的值
queryWrapper.notIn("属性" , 条件, 条件) ——不符合多个条件的值
queryWrapper.or() ——或者
queryWrapper.and() ——和
queryWrapper.orderByAsc("属性")——根据属性升序排序
queryWrapper.orderByDesc("属性")——根据属性降序排序

@Test
public void squery() {
    //创建QueryWrapper 对象
    QueryWrapper<User> queryWrapper = new QueryWrapper<>();

    //ge gt le lt: 大于等于 大于 小于等于 小于
    queryWrapper.ge("age",29);
    List<User> users = userMapper.selectList(queryWrapper);
    System.out.println(users);
    
    //eq ne  等于 不等于

    //between 介于查询
    queryWrapper.between("age",28,30);
    List<User> users1 = userMapper.selectList(queryWrapper);
    System.out.println(users1);
    
    //模糊查询
    queryWrapper.like("nam","l");
    queryWrapper.select("id","nam");
    List<User> users2 = userMapper.selectList(queryWrapper);
    System.out.println(users2);
    
    // orderByDesc 降序查找
    queryWrapper.orderByDesc;
    
    //last 在sql语句后面拼接
    queryWrapper.last("limit 1");

}

8.创建Dao

@Mapper
public interface SysUserDao extends BaseMapper<SysUserEntity>  {

}

BaseMapper 中常用方法为：

/**
 * Mapper 继承该接口后，无需编写 mapper.xml 文件，即可获得CRUD功能
 * 这个 Mapper 支持 id 泛型
 */
public interface BaseMapper<T> {
 
    /**
     * 插入一条记录
     * @param entity
     * 实体对象
     * @return int
     */
    Integer insert(T entity);
 
    /**
     * 根据 ID 删除
     * @param id
     * 主键ID
     * @return int
     */
    Integer deleteById(Serializable id);
 
    /**
     * 根据 columnMap 条件，删除记录
     * @param columnMap
     * 表字段 map 对象
     * @return int
     */
    Integer deleteByMap(@Param("cm") Map<String, Object> columnMap);
 
    /**
     * 根据 entity 条件，删除记录
     * @param wrapper
     * 实体对象封装操作类（可以为 null）
     * @return int
     */
    Integer delete(@Param("ew") Wrapper<T> wrapper);
 
    /**
     * 删除（根据ID 批量删除）
     * @param idList
     * 主键ID列表
     * @return int
     */
    Integer deleteBatchIds(List<? extends Serializable> idList);
 
    /**
     * 根据 ID 修改
     * @param entity
     * 实体对象
     * @return int
     */
    Integer updateById(T entity);
 
    /**
     * 根据 whereEntity 条件，更新记录
     * @param entity
     * 实体对象
     * @param wrapper
     * 实体对象封装操作类（可以为 null）
     * @return
     */
    Integer update(@Param("et") T entity, @Param("ew") Wrapper<T> wrapper);
 
    /**
     * 根据 ID 查询
     * @param id
     * 主键ID
     * @return T
     */
    T selectById(Serializable id);
 
    /**
     * 查询（根据ID 批量查询）
     * @param idList
     * 主键ID列表
     * @return List<T>
     */
    List<T> selectBatchIds(List<? extends Serializable> idList);
 
    /**
     * 查询（根据 columnMap 条件）
     * @param columnMap
     * 表字段 map 对象
     * @return List<T>
     */
    List<T> selectByMap(@Param("cm") Map<String, Object> columnMap);
 
    /**
     * 根据 entity 条件，查询一条记录
     * @param entity
     * 实体对象
     * @return T
     */
    T selectOne(@Param("ew") T entity);
 
    /**
     * 根据 Wrapper 条件，查询总记录数
     * @param wrapper
     * 实体对象
     * @return int
     */
    Integer selectCount(@Param("ew") Wrapper<T> wrapper);
 
    /**
     * 根据 entity 条件，查询全部记录
     * @param wrapper
     * 实体对象封装操作类（可以为 null）
     * @return List<T>
     */
    List<T> selectList(@Param("ew") Wrapper<T> wrapper);
 
    /**
     * 根据 Wrapper 条件，查询全部记录
     * @param wrapper
     * 实体对象封装操作类（可以为 null）
     * @return List<T>
     */
    List<Map<String, Object>> selectMaps(@Param("ew") Wrapper<T> wrapper);
 
    /**
     * 根据 Wrapper 条件，查询全部记录
     * @param wrapper
     * 实体对象封装操作类（可以为 null）
     * @return List<Object>
     */
    List<Object> selectObjs(@Param("ew") Wrapper<T> wrapper);
 
    /** 
     * 用法：(new RowBounds(offset, limit), ew);
     * 根据 entity 条件，查询全部记录（并翻页）
     * @param rowBounds
     * 分页查询条件（可以为 RowBounds.DEFAULT）
     * @param wrapper
     * 实体对象封装操作类（可以为 null）
     * @return List<T>
     */
    List<T> selectPage(RowBounds rowBounds, @Param("ew") Wrapper<T> wrapper);
 
    /** -- 不常用,
     * 根据 Wrapper 条件，查询全部记录（并翻页）
     * @param rowBounds
     * 分页查询条件（可以为 RowBounds.DEFAULT）
     * @param wrapper
     * 实体对象封装操作类
     * @return List<Map<String, Object>>
     */
    List<Map<String, Object>> selectMapsPage(RowBounds rowBounds, @Param("ew") Wrapper<T> wrapper);
}

9.创建Mapper.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="io.renren.modules.sys.dao.SysLogDao">

</mapper>

扩展

1.mapper 无法加载的问题

#mapper不放在resources中
#application.properties添加
mybatis-plus.mapper-locations=classpath:com/atguigu/ggkt/vod/mapper/xml/*.xml

service模块pom.xml添加

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
    <resources>
        <resource>
            <directory>src/main/java</directory>
            <includes>
                <include>**/*.yml</include>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
        <resource>
            <directory>src/main/resources</directory>
            <includes> <include>**/*.yml</include>
                <include>**/*.properties</include>
                <include>**/*.xml</include>
            </includes>
            <filtering>false</filtering>
        </resource>
    </resources>
</build>