Mybatis-Plus的MapperCRUD接口测试案例

大魔王的日常Log

已于 2022-03-18 18:17:08 修改

阅读量1.7k

点赞数

分类专栏： mybatis 文章标签： java spring boot mysql

于 2022-03-18 18:11:06 首次发布

本文链接：https://blog.csdn.net/taoshao521/article/details/123581385

版权

mybatis 专栏收录该内容

3 篇文章 0 订阅

订阅专栏

创建个mysql数据库表

CREATE TABLE `user` (
  `id` bigint NOT NULL COMMENT '主键ID',
  `name` varchar(30) DEFAULT NULL COMMENT '姓名',
  `age` int DEFAULT NULL COMMENT '年龄',
  `email` varchar(50) DEFAULT NULL COMMENT '邮箱',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb3;

创建个SpringBoot项目安装mybatis-Plus插件
官网在这
User实体类

package com.enjoy.stu.pojo;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableField;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import lombok.EqualsAndHashCode;

import java.io.Serializable;

/**
 * 类说明: <br>
 * 〈〉
 *
 * @Author: wlt
 * @Date: 2022/3/16 11:18
 */
@Data
@TableName("user")
public class User implements Serializable {
    @TableId(type = IdType.ASSIGN_ID)
    private Long id;
    @TableField("name")
    private String userName;
    private Integer age;
    private String email;
}

直接上单元测试代码

package com.enjoy.stu;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.enjoy.stu.client.MyClient;
import com.enjoy.stu.config.CustomIdGenerator;
import com.enjoy.stu.mapper.UserMapper;
import com.enjoy.stu.pojo.User;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.transaction.annotation.Transactional;

import java.util.*;

/**
 * 类说明: <br>
 * 〈〉
 *
 * @Author: wlt
 * @Date: 2022/3/16 11:22
 */
@SpringBootTest
public class SampleTest {
    @Autowired
    private UserMapper userMapper;
    @Autowired
    private CustomIdGenerator customIdGenerator;
    @Autowired
    private MyClient myClient;

    /**
     * 功能描述: <br>
     * <根据ID查询>
     *
     * @return 应答消息
     * @Param []
     * @Author: wlt
     * @Date: 2022/3/18 9:08
     **/
    @Test
    public void testSelect() {
        User user = new User();
        user.setId(1L);
        System.out.println(("----- selectAll method test ------"));
        List<User> userList = userMapper.selectList(null);
        User user1 = userMapper.selectById(user.getId());
        System.out.println(user1);
//        userList.forEach(System.out::println);
    }

    /**
     * 功能描述: <br>
     * <单条插入>
     *
     * @return 应答消息
     * @Param []
     * @Author: wlt
     * @Date: 2022/3/18 9:08
     **/
    @Test
    public void testInsert() {
        User user = new User();
        user.setId(88L);
        user.setUserName("猫耳朵");
        user.setEmail("18765898125@163.com");
        user.setAge(29);
        int insert = userMapper.insert(user);
        System.out.println(insert);
    }

    /**
     * 功能描述: <br>
     * <批量插入>
     *
     * @return 应答消息
     * @Param []
     * @Author: wlt
     * @Date: 2022/3/18 9:08
     **/
    @Test
    public void testInsertBatch() {
        List<User> userList = new ArrayList<>();
        User user = new User();
        user.setId(888L);
        user.setUserName("猫耳朵1");
        user.setEmail("18765898125@163.com");
        user.setAge(2);
        User user2 = new User();
        user2.setId(899L);
        user2.setUserName("猫耳朵2");
        user2.setEmail("18765898125@163.com");
        user2.setAge(292);
        userList.add(user);
        userList.add(user2);
        //批量插入
        boolean b = userMapper.insertBatch(userList);
        System.out.println(b);
    }

    /**
     * 功能描述: <br>
     * <插入或修改>
     *
     * @return 应答消息
     * @Param []
     * @Author: wlt
     * @Date: 2022/3/18 9:09
     **/
    @Test
    @Transactional(rollbackFor = Exception.class)
    public void testUpdateBatch() {
        User user = new User();
        user.setId(888L);
        user.setUserName("安琪拉");
        user.setEmail("1876589xxax8125@163.com");
        user.setAge(99);
        //插入或者修改
//        boolean b = userMapper.insertOrUpdate(user);
        //update()方法传递一个wrapper对象，则根据条件修改记录，返回受影响的行数；
        //其中实体类是要修改成的结果，wrapper是匹配条件
        UpdateWrapper<User> wrapper = new UpdateWrapper<>();
        wrapper.eq(true, "name", user.getUserName());
//        int update = userMapper.update(user, wrapper);
//        UPDATE user SET name=?, age=?, email=? WHERE (name = ?)
        //根据 ID 修改
        int update = userMapper.updateById(user);
//        UPDATE user SET name=?, age=?, email=? WHERE id=?
        System.out.println(update);

    }

    /**
     * 功能描述: <br>
     * <批量修改或新增>
     * 效率极低不建议使用 逻辑是 先根据id查数据库如果有就修改 如果没有就新增
     *
     * @return 应答消息
     * @Param []
     * @Author: wlt
     * @Date: 2022/3/18 9:36
     **/
    @Test
//   @Transactional(rollbackFor = Exception.class)
    public void testInsertOrUpdateBatch() {
        List<User> userList = new ArrayList<>();
        for (int i = 0; i < 1002; i++) {
            User user = new User();
            user.setId(1888L + Long.valueOf(i));
            user.setUserName("大魔王222" + String.valueOf(i));
            user.setEmail("1876589xxax8125@163.com");
            user.setAge(28 + i);
            userList.add(user);
        }
        userMapper.insertOrUpdateBatch(userList);
    }

    /**
     * 功能描述: <br>
     * <批量更新>
     * 1000条一批  唉效率也不怎么高
     *
     * @return 应答消息
     * @Param []
     * @Author: wlt
     * @Date: 2022/3/18 9:55
     **/
    @Test
//    @Transactional(rollbackFor = Exception.class)
    public void updateBatchById() {
        List<User> userList = new ArrayList<>();
        for (int i = 0; i < 1002; i++) {
            User user = new User();
            user.setId(1888L + Long.valueOf(i));
            user.setUserName("达摩祖师" + String.valueOf(i));
            user.setEmail("1876589xxax8125@163.com");
            user.setAge(i);
            userList.add(user);
        }
        userMapper.updateBatchById(userList);
    }

    @Test
    @Transactional(rollbackFor = Exception.class)
    public void deleteById() {
        User user = new User();
        user.setId(888L);
        user.setUserName("安琪拉");
        user.setEmail("1876589xxax8125@163.com");
        user.setAge(0);
        QueryWrapper<User> wrapper = new QueryWrapper<>();
        /**
         * 第一个参数: 数据库表中的字段名
         * 第二个参数: 字段对应的值
         * where name = xxx and age =xxx
         **/
        wrapper.eq("name", user.getUserName());
        wrapper.eq("age", user.getAge());
        //根据where条件删除
//        userMapper.delete(wrapper);
        //根据ID删除
//        userMapper.deleteById(user);
        //根据id批量删除
        //userMapper.deleteBatchIds(Arrays.asList(888L,889L,890L));
        //根据map删除记录
        Map<String, Object> userMap = new HashMap<>();
        userMap.put("name", user.getUserName());
        userMapper.deleteByMap(userMap);
    }
    /**
     * 功能描述: <br>
     * <查询方法测试>
     * @Param []
     * @return 应答消息
     * @Author: wlt
     * @Date: 2022/3/18 14:00
     **/
    @Test
    public void select(){
        User user = new User();
        user.setId(888L);
        user.setUserName("安琪拉");
        user.setEmail("1876589xxax8125@163.com");
        user.setAge(111);
        //根据 ID 查询
//        User user2 = userMapper.selectById(user.getId());
//        SELECT id,name AS userName,age,email FROM user WHERE id=?
//        System.out.println(user2);
        //根据条件查询
        LambdaQueryWrapper<User> lambdaQueryWrapper=new LambdaQueryWrapper<>();
        //=  第二个参数 lambda表达式的方式写数据库表的字段名,第三个参数是对应的字段值
        lambdaQueryWrapper.eq(true,User::getUserName,user.getUserName());
        //!=
        lambdaQueryWrapper.ne(true,User::getAge,user.getAge());
        //apply 拼接sql语句用
        lambdaQueryWrapper.apply("email ='"+user.getEmail()+"'");
        User user1 = userMapper.selectOne(lambdaQueryWrapper);
        //SELECT id,name AS userName,age,email FROM user WHERE (name = ? AND age <> ? AND email ='1876589xxax8125@163.com')
        System.out.println(user1);
    }
    /**
     * 功能描述: <br>
     * <查询（根据ID 批量查询）>
     * @Param []
     * @return 应答消息
     * @Author: wlt
     * @Date: 2022/3/18 15:40
     **/
    @Test
    public void selectBatchIds(){
        /*List<User> userList = userMapper.selectBatchIds(Arrays.asList(888L, 889L, 890L));
        //SELECT id,name AS userName,age,email FROM user WHERE id IN ( ? , ? , ? )
        userList.stream().forEach(user -> System.out.println(user));*/
        User user = new User();
        user.setId(888L);
        user.setUserName("安琪拉");
        user.setEmail("1876589xxax8125@163.com");
        user.setAge(0);
        Map<String, Object> columnMap =new HashMap<>();
        columnMap.put("name",user.getUserName());
        columnMap.put("age",user.getAge());
        List<User> userList = userMapper.selectByMap(columnMap);
        //SELECT id,name AS userName,age,email FROM user WHERE name = ? AND age = ?
        userList.stream().forEach(user1 -> System.out.println(user1));
    }
    /**
     * 功能描述: <br>
     * <根据 entity 条件，查询全部记录>
     * @Param []
     * @return 应答消息
     * @Author: wlt
     * @Date: 2022/3/18 15:44       
     **/
    @Test
    public void selectList(){
        User user=new User();
        user.setUserName("安琪拉");
        LambdaQueryWrapper<User> lambdaQueryWrapper=new LambdaQueryWrapper<>();
        lambdaQueryWrapper.eq(true,User::getUserName,user.getUserName());
       /* List<User> userList = userMapper.selectList(lambdaQueryWrapper);
        userList.stream().forEach(user1 -> System.out.println(user1));*/
        //SELECT id,name AS userName,age,email FROM user WHERE (name = ?)
        //根据 Wrapper 条件，查询全部记录
        List<Map<String, Object>> maps = userMapper.selectMaps(lambdaQueryWrapper);
        maps.stream().forEach(stringObjectMap -> System.out.println(stringObjectMap));
        //SELECT id,name AS userName,age,email FROM user WHERE (name = ?)
    }

    @Test
    public void testSelectObjs() {
        User user=new User();
        user.setUserName("安琪拉");
        user.setAge(0);
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getUserName, user.getUserName());
        //>=
        queryWrapper.ge(User::getAge,user.getAge());
        //<=
        queryWrapper.le(User::getAge,30);
        //根据字段分组
//        queryWrapper.groupBy(User::getId,User::getUserName);
        // 根据 Wrapper 条件，查询全部记录。注意： 只返回第一个字段的值
        List<Object> userList = userMapper.selectObjs(queryWrapper);
        userList.stream().forEach(user1-> System.out.println(user1));
        // 根据 Wrapper 条件，查询总记录数
        Long aLong = userMapper.selectCount(queryWrapper);
        System.out.println(aLong);
    }
    /**
     * 功能描述: <br>
     * <分页查询>
     * @Param []
     * @return 应答消息
     * @Author: wlt
     * @Date: 2022/3/18 17:37
     **/
    @Test
    public void selectPage(){
        User user =new User();
        user.setUserName("达摩祖师");
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        //模糊查询
        queryWrapper.like(User::getUserName,user.getUserName());
        /*** Page是分页查询对象，实现IPage接口，下面构造方法表示当前页，每页工几条记录 ***/
        Page<User> page =new Page<>(1,10);
        Page<User> pageList = userMapper.selectPage(page, queryWrapper);
        List<User> records = pageList.getRecords();
        /*** 当前页 ***/
        System.out.println(pageList.getCurrent());

        /*** 当前分页总页数 ***/
        System.out.println(pageList.getPages());

        /*** 每页显示条数 ***/
        System.out.println(pageList.getSize());

        /*** 当前分页总记录数 ***/
        System.out.println(pageList.getTotal());
    }
    /**
     * 功能描述: <br>
     * <根据 Wrapper 条件，查询全部记录（并翻页）>
     * @Param []
     * @return 应答消息
     * @Author: wlt
     * @Date: 2022/3/18 17:59       
     **/
    @Test
    public void selectMapsPage(){
        User user =new User();
        user.setUserName("达摩祖师");
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        //模糊查询
        queryWrapper.like(User::getUserName,user.getUserName());
        /*** IPage是分页查询对象，下面构造方法表示当前页，每页工几条记录 ***/
        IPage<Map<String, Object>> page = new Page<>(1, 10);
        /***
         * selectMaps()参数为IPage(RowBounds.DEFAULT)、QueryWrapper，参数可为null，
         * 根据条件查询实体集合，若无结果则返回空集合，返回Map，key是字段名(非属性名)，value是字段值
         ***/
        IPage<Map<String, Object>> pageList = userMapper.selectMapsPage(page, queryWrapper);
        List<Map<String, Object>> records = pageList.getRecords();
        /*** 当前页 ***/
        System.out.println(pageList.getCurrent());

        /*** 当前分页总页数 ***/
        System.out.println(pageList.getPages());

        /*** 每页显示条数 ***/
        System.out.println(pageList.getSize());

        /*** 当前分页总记录数 ***/
        System.out.println(pageList.getTotal());
    }

    @Test
    public void testForest() {
        JSONObject weather = myClient.weather("济南");
        System.out.println(weather);
    }
}

继承了个Mapper

package com.enjoy.stu.mapper;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.ObjectUtil;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.enums.SqlMethod;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.metadata.TableInfo;
import com.baomidou.mybatisplus.core.metadata.TableInfoHelper;
import com.baomidou.mybatisplus.core.toolkit.*;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.toolkit.SqlHelper;
import com.enjoy.stu.util.BeanCopyUtils;
import org.apache.ibatis.binding.MapperMethod;
import org.apache.ibatis.logging.Log;
import org.apache.ibatis.logging.LogFactory;

import java.io.Serializable;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Objects;

/**
 * 自定义 Mapper 接口, 实现 自定义扩展
 *
 * @param <M> mapper 泛型
 * @param <T> table 泛型
 * @param <V> vo 泛型
 * @author Lion Li
 * @since 2021-05-13
 */
@SuppressWarnings("unchecked")
public interface BaseMapperPlus<M, T, V> extends BaseMapper<T> {

    Log log = LogFactory.getLog(BaseMapperPlus.class);

    int DEFAULT_BATCH_SIZE = 1000;

    default Class<V> currentVoClass() {
        return (Class<V>) ReflectionKit.getSuperClassGenericType(this.getClass(), BaseMapperPlus.class, 2);
    }

    default Class<T> currentModelClass() {
        return (Class<T>) ReflectionKit.getSuperClassGenericType(this.getClass(), BaseMapperPlus.class, 1);
    }

    default Class<M> currentMapperClass() {
        return (Class<M>) ReflectionKit.getSuperClassGenericType(this.getClass(), BaseMapperPlus.class, 0);
    }

    default List<T> selectList() {
        return this.selectList(new QueryWrapper<>());
    }

    /**
     * 批量插入
     */
    default boolean insertBatch(Collection<T> entityList) {
        return insertBatch(entityList, DEFAULT_BATCH_SIZE);
    }

    /**
     * 批量更新
     */
    default boolean updateBatchById(Collection<T> entityList) {
        return updateBatchById(entityList, DEFAULT_BATCH_SIZE);
    }

    /**
     * 批量插入或更新
     */
    default boolean insertOrUpdateBatch(Collection<T> entityList) {
        return insertOrUpdateBatch(entityList, DEFAULT_BATCH_SIZE);
    }

    /**
     * 批量插入(包含限制条数)
     */
    default boolean insertBatch(Collection<T> entityList, int batchSize) {
        String sqlStatement = SqlHelper.getSqlStatement(this.currentMapperClass(), SqlMethod.INSERT_ONE);
        return SqlHelper.executeBatch(this.currentModelClass(), log, entityList, batchSize,
            (sqlSession, entity) -> sqlSession.insert(sqlStatement, entity));
    }

    /**
     * 批量更新(包含限制条数)
     */
    default boolean updateBatchById(Collection<T> entityList, int batchSize) {
        String sqlStatement = SqlHelper.getSqlStatement(this.currentMapperClass(), SqlMethod.UPDATE_BY_ID);
        return SqlHelper.executeBatch(this.currentModelClass(), log, entityList, batchSize,
            (sqlSession, entity) -> {
                MapperMethod.ParamMap<T> param = new MapperMethod.ParamMap<>();
                param.put(Constants.ENTITY, entity);
                sqlSession.update(sqlStatement, param);
            });
    }

    /**
     * 批量插入或更新(包含限制条数)
     */
    default boolean insertOrUpdateBatch(Collection<T> entityList, int batchSize) {
        TableInfo tableInfo = TableInfoHelper.getTableInfo(this.currentModelClass());
        Assert.notNull(tableInfo, "error: can not execute. because can not find cache of TableInfo for entity!");
        String keyProperty = tableInfo.getKeyProperty();
        Assert.notEmpty(keyProperty, "error: can not execute. because can not find column for id from entity!");
        return SqlHelper.saveOrUpdateBatch(this.currentModelClass(), this.currentMapperClass(), log, entityList, batchSize, (sqlSession, entity) -> {
            Object idVal = tableInfo.getPropertyValue(entity, keyProperty);
            String sqlStatement = SqlHelper.getSqlStatement(this.currentMapperClass(), SqlMethod.SELECT_BY_ID);
            return StringUtils.checkValNull(idVal)
                || CollectionUtils.isEmpty(sqlSession.selectList(sqlStatement, entity));
        }, (sqlSession, entity) -> {
            MapperMethod.ParamMap<T> param = new MapperMethod.ParamMap<>();
            param.put(Constants.ENTITY, entity);
            String sqlStatement = SqlHelper.getSqlStatement(this.currentMapperClass(), SqlMethod.UPDATE_BY_ID);
            sqlSession.update(sqlStatement, param);
        });
    }

    /**
     * 插入或更新(包含限制条数)
     */
    default boolean insertOrUpdate(T entity) {
        if (null != entity) {
            TableInfo tableInfo = TableInfoHelper.getTableInfo(this.currentModelClass());
            Assert.notNull(tableInfo, "error: can not execute. because can not find cache of TableInfo for entity!");
            String keyProperty = tableInfo.getKeyProperty();
            Assert.notEmpty(keyProperty, "error: can not execute. because can not find column for id from entity!");
            Object idVal = tableInfo.getPropertyValue(entity, tableInfo.getKeyProperty());
            return StringUtils.checkValNull(idVal) || Objects.isNull(selectById((Serializable) idVal)) ? insert(entity) > 0 : updateById(entity) > 0;
        }
        return false;
    }

    default V selectVoById(Serializable id) {
        return selectVoById(id, this.currentVoClass());
    }

    /**
     * 根据 ID 查询
     */
    default <C> C selectVoById(Serializable id, Class<C> voClass) {
        T obj = this.selectById(id);
        if (ObjectUtil.isNull(obj)) {
            return null;
        }
        return BeanCopyUtils.copy(obj, voClass);
    }

    default List<V> selectVoById(Collection<? extends Serializable> idList) {
        return selectVoBatchIds(idList, this.currentVoClass());
    }

    /**
     * 查询（根据ID 批量查询）
     */
    default <C> List<C> selectVoBatchIds(Collection<? extends Serializable> idList, Class<C> voClass) {
        List<T> list = this.selectBatchIds(idList);
        if (CollUtil.isEmpty(list)) {
            return CollUtil.newArrayList();
        }
        return BeanCopyUtils.copyList(list, voClass);
    }

    default List<V> selectVoByMap(Map<String, Object> map) {
        return selectVoByMap(map, this.currentVoClass());
    }

    /**
     * 查询（根据 columnMap 条件）
     */
    default <C> List<C> selectVoByMap(Map<String, Object> map, Class<C> voClass) {
        List<T> list = this.selectByMap(map);
        if (CollUtil.isEmpty(list)) {
            return CollUtil.newArrayList();
        }
        return BeanCopyUtils.copyList(list, voClass);
    }

    default V selectVoOne(Wrapper<T> wrapper) {
        return selectVoOne(wrapper, this.currentVoClass());
    }

    /**
     * 根据 entity 条件，查询一条记录
     */
    default <C> C selectVoOne(Wrapper<T> wrapper, Class<C> voClass) {
        T obj = this.selectOne(wrapper);
        if (ObjectUtil.isNull(obj)) {
            return null;
        }
        return BeanCopyUtils.copy(obj, voClass);
    }

    default List<V> selectVoList(Wrapper<T> wrapper) {
        return selectVoList(wrapper, this.currentVoClass());
    }

    /**
     * 根据 entity 条件，查询全部记录
     */
    default <C> List<C> selectVoList(Wrapper<T> wrapper, Class<C> voClass) {
        List<T> list = this.selectList(wrapper);
        if (CollUtil.isEmpty(list)) {
            return CollUtil.newArrayList();
        }
        return BeanCopyUtils.copyList(list, voClass);
    }

    default <P extends IPage<V>> P selectVoPage(IPage<T> page, Wrapper<T> wrapper) {
        return selectVoPage(page, wrapper, this.currentVoClass());
    }

    /**
     * 分页查询VO
     */
    default <C, P extends IPage<C>> P selectVoPage(IPage<T> page, Wrapper<T> wrapper, Class<C> voClass) {
        IPage<T> pageData = this.selectPage(page, wrapper);
        IPage<C> voPage = new Page<>(pageData.getCurrent(), pageData.getSize(), pageData.getTotal());
        if (CollUtil.isEmpty(pageData.getRecords())) {
            return (P) voPage;
        }
        voPage.setRecords(BeanCopyUtils.copyList(pageData.getRecords(), voClass));
        return (P) voPage;
    }

}

UserMapper

/**
 * 类说明: <br>
 * 〈〉
 *
 * @Author: wlt
 * @Date: 2022/3/16 11:21
 */
@Mapper
public interface UserMapper extends BaseMapperPlus<UserMapper,User,User> {

}

单表操作几乎不用写sql语句都可以实现
多表操作还没测试
大家都共同学习一下吧
附带一下我的pom.xml和yml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.enjoy.stu</groupId>
    <artifactId>studyEnjoy</artifactId>
    <version>1.0.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.4</version>
        <relativePath/>
    </parent>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-boot-starter</artifactId>
            <version>3.5.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <version>8.0.11</version>
        </dependency>
        <dependency>
            <groupId>com.h2database</groupId>
            <artifactId>h2</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>cn.hutool</groupId>
            <artifactId>hutool-bom</artifactId>
            <version>5.7.20</version>
        </dependency>
        <!-- Sa-Token 权限认证, 在线文档：http://sa-token.dev33.cn/ -->
        <dependency>
            <groupId>cn.dev33</groupId>
            <artifactId>sa-token-spring-boot-starter</artifactId>
            <version>1.29.0</version>
        </dependency>
        <dependency>
            <groupId>com.dtflys.forest</groupId>
            <artifactId>forest-spring-boot-starter</artifactId>
            <version>1.5.19</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.48</version>
        </dependency>
        <dependency>
            <groupId>com.google.protobuf</groupId>
            <artifactId>protobuf-java</artifactId>
            <version>3.18.1</version>
        </dependency>
    </dependencies>
</project>

server:
  port: 13500

# DataSource Config
spring:
  application:
    name: enjoy
  datasource:
    url: jdbc:mysql://你的服务器IP:3306/test?serverTimeZone=UTC&rewriteBatchedStatements=true
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
sa-token:
  # token名称 (同时也是cookie名称)
  token-name: satoken
  # token有效期，单位s 默认30天, -1代表永不过期
  timeout: 2592000
  # token临时有效期 (指定时间内无操作就视为token过期) 单位: 秒
  activity-timeout: -1
  # 是否允许同一账号并发登录 (为true时允许一起登录, 为false时新登录挤掉旧登录)
  is-concurrent: true
  # 在多人登录同一账号时，是否共用一个token (为true时所有登录共用一个token, 为false时每次登录新建一个token)
  is-share: false
  # token风格
  token-style: uuid
  # 是否输出操作日志
  is-log: false
forest:
  bean-id: config0 # 在spring上下文中bean的id（默认为 forestConfiguration）
  backend: okhttp3 # 后端HTTP框架（默认为 okhttp3）
  max-connections: 1000 # 连接池最大连接数（默认为 500）
  max-route-connections: 500 # 每个路由的最大连接数（默认为 500）
  timeout: 3000 # 请求超时时间，单位为毫秒（默认为 3000）
  connect-timeout: 3000 # 连接超时时间，单位为毫秒（默认为 timeout）
  read-timeout: 3000 # 数据读取超时时间，单位为毫秒（默认为 timeout）
  max-retry-count: 0 # 请求失败后重试次数（默认为 0 次不重试）
  ssl-protocol: SSLv3 # 单向验证的HTTPS的默认SSL协议（默认为 SSLv3）
  logEnabled: true # 打开或关闭日志（默认为 true）
  log-request: true # 打开/关闭Forest请求日志（默认为 true）
  log-response-status: true # 打开/关闭Forest响应状态日志（默认为 true）
  log-response-content: true # 打开/关闭Forest响应内容日志（默认为 false）
mybatis-plus:
  configuration:
    #默认不显示SQL日志
    #    log-impl: org.apache.ibatis.logging.nologging.NoLoggingImpl
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl