How to implement the demo of springboot+mybatisplus+redis

<?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>org.example</groupId>
    <artifactId>springboot_redis_demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.5.0</version>
    </parent>

    <dependencies>

        <!--web-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
            <version>2.5.0</version>
        </dependency>

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

        <!--jdbc-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
            <version>2.5.0</version>
        </dependency>

        <!--druid-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.2.6</version>
        </dependency>

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

        <!--generator-->
        <dependency>
            <groupId>com.baomidou</groupId>
            <artifactId>mybatis-plus-generator</artifactId>
            <version>3.4.1</version>
        </dependency>

        <!--freemarker-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-freemarker</artifactId>
            <version>2.5.0</version>
        </dependency>

        <!--redis-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
            <version>2.5.0</version>
        </dependency>

        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.18.20</version>
            <scope>provided</scope>
        </dependency>

        <!--springboot-test-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <version>2.5.0</version>
            <scope>test</scope>
        </dependency>

        <!--junit-->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.13.2</version>
            <scope>test</scope>
        </dependency>

        <!--swagger2-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>3.0.0</version>
        </dependency>

        <!--swagger-ui-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>3.0.0</version>
        </dependency>

    </dependencies>

</project>

#端口
server:
  port: 1010

#配置数据源
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/test?useUnicode=true&characterEncoding=utf-8&allowMultiQueries=true&serverTimezone=GMT%2B8&useSSL=false
    username: root
    password: 123456
    type: com.alibaba.druid.pool.DruidDataSource

  #配置redis
  redis:
    host: 127.0.0.1
    port: 6379
    database: 0
    password: 123456

package com.zengjx.project;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

/**
 * @author fastrabbit
 * @date 2021/6/9 9:43
 */
@SpringBootApplication
@EnableCaching
@MapperScan("com.zengjx.project.*.mapper")
public class RedisApp {

    public static void main(String[] args) {
        SpringApplication.run(RedisApp.class, args);
    }

}

package ${cfg.packagePath}.common;

import com.baomidou.mybatisplus.annotation.TableField;
import lombok.Data;

/**
 * @author ${author}
 * @date ${date}
 */
@Data
public class BaseQuery {

	/**
     * 当前页数  默认为1
     */
    @TableField(exist=false)
    private Integer page = 1;

    /**
     * 每页数据量  默认为10
     */
    @TableField(exist=false)
    private Integer rows =10;

}

package ${package.Controller};

import ${cfg.packagePath}.common.Result;
import ${package.Entity}.${entity};
import ${package.Service}.${table.serviceName};
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
<#if restControllerStyle>
import org.springframework.web.bind.annotation.RestController;
<#else>
import org.springframework.stereotype.Controller;
</#if>

import java.util.List;
<#if superControllerClassPackage??>
import ${superControllerClassPackage};
</#if>

/**
 * @author ${author}
 * @date ${date}
 */
@Api(tags = {"${table.comment!}"})
<#if restControllerStyle>
@RestController
<#else>
@Controller
</#if>
@RequestMapping("<#if package.ModuleName?? && package.ModuleName != "">/${package.ModuleName}</#if>/<#if controllerMappingHyphenStyle??>${controllerMappingHyphen}<#else>${table.entityPath}</#if>")
<#if kotlin>
class ${table.controllerName}<#if superControllerClass??> : ${superControllerClass}()</#if>
<#else>
<#if superControllerClass??>
public class ${table.controllerName} extends ${superControllerClass} {
<#else>
public class ${table.controllerName} {
</#if>

    private Logger logger = LoggerFactory.getLogger(getClass());

    @Autowired
    private ${table.serviceName} ${(table.serviceName?substring(1))?uncap_first};

    /**
     * @author fastrabbit
     * @description 根据id查询单个数据
     * @date ${date}
     */
    @ApiOperation(value = "根据id查询单个数据")
    @RequestMapping(value = "/getById")
    public Result<${entity}> getById(@RequestBody ${entity} ${entity?uncap_first}){

        return ${(table.serviceName?substring(1))?uncap_first}.getById(${entity?uncap_first});

    }

    /**
     * @author fastrabbit
     * @description 根据查询条件查询分页数据
     * @date ${date}
     */
    @ApiOperation(value = "根据查询条件查询分页数据")
    @RequestMapping(value = "/list")
    public Result<List<${entity}>> findListByPage(@RequestBody ${entity} ${entity?uncap_first}){

        return ${(table.serviceName?substring(1))?uncap_first}.findListByPage(${entity?uncap_first});

    }

    /**
     * @author fastrabbit
     * @description 查询所有数据
     * @date ${date}
     */
    @ApiOperation(value = "查询所有数据")
    @RequestMapping(value = "/getAll")
    public Result<List<${entity}>> getAll(){

        return ${(table.serviceName?substring(1))?uncap_first}.getAll();

    }

    /**
     * @author fastrabbit
     * @description 新增单个数据
     * @date ${date}
     */
    @ApiOperation(value = "新增单个数据")
    @RequestMapping(value = "/insert", method = RequestMethod.POST)
    public Result<Object> insert(@RequestBody ${entity} ${entity?uncap_first}){

        return ${(table.serviceName?substring(1))?uncap_first}.insert(${entity?uncap_first});

    }

    /**
     * @author fastrabbit
     * @description 删除单个数据
     * @date ${date}
     */
    @ApiOperation(value = "删除单个数据")
    @RequestMapping(value = "/delete")
    public Result<Object> delete(@RequestBody ${entity} ${entity?uncap_first}){

        return ${(table.serviceName?substring(1))?uncap_first}.delete(${entity?uncap_first});

    }

    /**
     * @author fastrabbit
     * @description 修改单个数据
     * @date ${date}
     */
    @ApiOperation(value = "修改单个数据")
    @RequestMapping(value = "/update", method = RequestMethod.POST)
    public Result<Object> update(@RequestBody ${entity} ${entity?uncap_first}){

        return ${(table.serviceName?substring(1))?uncap_first}.update(${entity?uncap_first});

    }

 }
</#if>

package ${package.Entity};

<#list table.importPackages as pkg>
import ${pkg};
</#list>
<#if swagger2>
import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
</#if>
import ${cfg.packagePath}.common.BaseQuery;
<#if entityLombokModel>
import lombok.Data;
import lombok.EqualsAndHashCode;
    <#if chainModel>
import lombok.experimental.Accessors;
    </#if>
</#if>

/**
 * @author ${author}
 * @date ${date}
 */
<#if entityLombokModel>
@Data
    <#if superEntityClass??>
@EqualsAndHashCode(callSuper = true)
    <#else>
@EqualsAndHashCode(callSuper = false)
    </#if>
    <#if chainModel>
@Accessors(chain = true)
    </#if>
</#if>
<#if table.convert>
@TableName("${table.name}")
</#if>
<#if swagger2>
@ApiModel(value="${entity}对象", description="${table.comment!}")
</#if>
<#if superEntityClass??>
public class ${entity} extends ${superEntityClass}<#if activeRecord><${entity}></#if> {
<#elseif activeRecord>
public class ${entity} extends Model<${entity}> {
<#else>
public class ${entity} extends BaseQuery implements Serializable {
</#if>

<#if entitySerialVersionUID>
    private static final long serialVersionUID = 1L;
</#if>
<#-- ----------  BEGIN 字段循环遍历  ---------->
<#list table.fields as field>
    <#if field.keyFlag>
        <#assign keyPropertyName="${field.propertyName}"/>
    </#if>

    <#if field.comment!?length gt 0>
        <#if swagger2>
    @ApiModelProperty(value = "${field.comment}")
        <#else>
    /**
     * ${field.comment}
     */
        </#if>
    </#if>
    <#if field.keyFlag>
        <#-- 主键 -->
        <#if field.keyIdentityFlag>
    @TableId(value = "${field.annotationColumnName}", type = IdType.AUTO)
        <#elseif idType??>
    @TableId(value = "${field.annotationColumnName}", type = IdType.${idType})
        <#elseif field.convert>
    @TableId("${field.annotationColumnName}")
        </#if>
        <#-- 普通字段 -->
    <#elseif field.fill??>
    <#-- -----   存在字段填充设置   ----->
        <#if field.convert>
    @TableField(value = "${field.annotationColumnName}", fill = FieldFill.${field.fill})
        <#else>
    @TableField(fill = FieldFill.${field.fill})
        </#if>
    <#elseif field.convert>
    @TableField("${field.annotationColumnName}")
    </#if>
    <#-- 乐观锁注解 -->
    <#if (versionFieldName!"") == field.name>
    @Version
    </#if>
    <#-- 逻辑删除注解 -->
    <#if (logicDeleteFieldName!"") == field.name>
    @TableLogic
    </#if>
    private ${field.propertyType} ${field.propertyName};
</#list>
<#------------  END 字段循环遍历  ---------->

<#if !entityLombokModel>
    <#list table.fields as field>
        <#if field.propertyType == "boolean">
            <#assign getprefix="is"/>
        <#else>
            <#assign getprefix="get"/>
        </#if>
    public ${field.propertyType} ${getprefix}${field.capitalName}() {
        return ${field.propertyName};
    }

    <#if chainModel>
    public ${entity} set${field.capitalName}(${field.propertyType} ${field.propertyName}) {
    <#else>
    public void set${field.capitalName}(${field.propertyType} ${field.propertyName}) {
    </#if>
        this.${field.propertyName} = ${field.propertyName};
        <#if chainModel>
        return this;
        </#if>
    }
    </#list>
</#if>

<#if entityColumnConstant>
    <#list table.fields as field>
    public static final String ${field.name?upper_case} = "${field.name}";

    </#list>
</#if>
<#if activeRecord>
    @Override
    protected Serializable pkVal() {
    <#if keyPropertyName??>
        return this.${keyPropertyName};
    <#else>
        return null;
    </#if>
    }

</#if>
<#if !entityLombokModel>
    @Override
    public String toString() {
        return "${entity}{" +
    <#list table.fields as field>
        <#if field_index==0>
            "${field.propertyName}=" + ${field.propertyName} +
        <#else>
            ", ${field.propertyName}=" + ${field.propertyName} +
        </#if>
    </#list>
        "}";
    }
</#if>
}

package ${package.Mapper};

import ${package.Entity}.${entity};
import ${superMapperClassPackage};

/**
 * @author ${author}
 * @date ${date}
 */
<#if kotlin>
interface ${table.mapperName} : ${superMapperClass}<${entity}>
<#else>
public interface ${table.mapperName} extends ${superMapperClass}<${entity}> {

}
</#if>

package ${cfg.packagePath}.globalconfig;

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

/**
 * @author ${author}
 * @date ${date}
 */
@Configuration
@EnableTransactionManagement
public class MybatisPlusConfig {

    /**
     * @author fastrabbit
     * @description 获取分页插件
     * @date ${date}
     */
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.H2));
        return interceptor;
    }

}

package ${cfg.packagePath}.common;

import lombok.Data;

/**
 * @author ${author}
 * @date ${date}
 */
@Data
public class Result<T> {

    /**
     * 是否成功  默认为成功
     */
    private Boolean success = true;

    /**
     * 状态码  默认为200
     */
    private Integer code = 200;

    /**
     * 返回信息描述
     */
    private String message;

    /**
     * 返回数据
     */
    private T data;

    /**
     * 返回数据量
     */
    private Integer total;

}

package ${package.Service};

import ${superServiceClassPackage};
import ${cfg.packagePath}.common.Result;
import ${package.Entity}.${entity};

import java.util.List;

/**
 * @author ${author}
 * @date ${date}
 */
<#if kotlin>
interface ${table.serviceName} : ${superServiceClass}<${entity}>
<#else>
public interface ${table.serviceName} extends ${superServiceClass}<${entity}> {

    /**
     * @author fastrabbit
     * @description 根据id查询单个数据
     * @date ${date}
     */
    Result<${entity}> getById(${entity} ${entity?uncap_first});

    /**
     * @author fastrabbit
     * @description 根据查询条件查询分页数据
     * @date ${date}
     */
    Result<List<${entity}>> findListByPage(${entity} ${entity?uncap_first});

    /**
     * @author fastrabbit
     * @description 查询所有数据
     * @date ${date}
     */
    Result<List<${entity}>> getAll();

    /**
     * @author fastrabbit
     * @description 新增单个数据
     * @date ${date}
     */
    Result<Object> insert(${entity} ${entity?uncap_first});

    /**
    * @author fastrabbit
    * @description 修改单个数据
    * @date ${date}
    */
    Result<Object> update(${entity} ${entity?uncap_first});

    /**
     * @author fastrabbit
     * @description 删除单个数据
     * @date ${date}
     */
    Result<Object> delete(${entity} ${entity?uncap_first});

}
</#if>

package ${package.ServiceImpl};

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import ${cfg.packagePath}.common.Result;
import ${package.Entity}.${entity};
import ${package.Mapper}.${table.mapperName};
import ${package.Service}.${table.serviceName};
import ${superServiceImplClassPackage};
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * @author ${author}
 * @date ${date}
 */
@Service
@Transactional(rollbackFor=Exception.class)
<#if kotlin>
open class ${table.serviceImplName} : ${superServiceImplClass}<${table.mapperName}, ${entity}>(), ${table.serviceName} {

}
<#else>
public class ${table.serviceImplName} extends ${superServiceImplClass}<${table.mapperName}, ${entity}> implements ${table.serviceName} {

    @Autowired
    private ${table.mapperName} ${table.mapperName?uncap_first};

    /**
     * @author fastrabbit
     * @description 根据id查询单个数据
     * @date ${date}
     */
    @Override
    public Result<${entity}> getById(Food food) {

        Result<${entity}> foodResult = new Result<>();
        foodResult.setData(foodMapper.selectById(food.getId()));
        return foodResult;

    }

    /**
     * @author fastrabbit
     * @description 根据查询条件查询分页数据
     * @date ${date}
     */
    @Override
    public Result<List<${entity}>> findListByPage(Food food) {

        Result<List<${entity}>> listResult = new Result<>();
        Page<${entity}> foodPage = new Page<>(food.getPage(), food.getRows());
        QueryWrapper<${entity}> foodQueryWrapper = new QueryWrapper<>();
        List<${entity}> records = foodMapper.selectPage(foodPage, foodQueryWrapper).getRecords();
        listResult.setData(records);
        listResult.setTotal(records.size());
        return listResult;

    }

    /**
     * @author fastrabbit
     * @description 查询所有数据
     * @date ${date}
     */
    @Override
    public Result<List<${entity}>> getAll() {

        Result<List<${entity}>> foodResult = new Result<>();
        List<${entity}> foods = foodMapper.selectList(null);
        foodResult.setData(foods);
        foodResult.setTotal(foods.size());
        return foodResult;

    }

    /**
     * @author fastrabbit
     * @description 新增单个数据
     * @date ${date}
     */
    @Override
    public Result<Object> insert(Food food) {

        Result<Object> objectResult = new Result<>();
        foodMapper.insert(food);
        return objectResult;

    }

    /**
     * @author fastrabbit
     * @description 修改单个数据
     * @date ${date}
     */
    @Override
    public Result<Object> update(Food food) {

        Result<Object> objectResult = new Result<>();
        foodMapper.updateById(food);
        return objectResult;

    }

    /**
     * @author fastrabbit
     * @description 删除单个数据
     * @date ${date}
     */
    @Override
    public Result<Object> delete(Food food) {

        Result<Object> objectResult = new Result<>();
        foodMapper.deleteById(food.getId());
        return objectResult;

    }

}
</#if>

package com.zengjx.project;

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.io.File;
import java.util.*;

/**
 * @author fastrabbit
 * @date 2021/5/25 9:28
 */
public class CodeGenerator {

    /**
     * <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.isNotBlank(ipt)) {
                return ipt;
            }
        }
        throw new MybatisPlusException("请输入正确的" + tip + "！");
    }

    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("fastrabbit");
        // 是否打开输出目录
        gc.setOpen(false);
        // 实体属性 Swagger2 注解
        gc.setSwagger2(true);
        // 开启activeRecord模式 开启后entity会继承Model类
        gc.setActiveRecord(false);
        // XML ResultMap: mapper.xml生成查询映射结果
        gc.setBaseResultMap(true);
        // 是否覆盖原来的文件
        gc.setFileOverride(false);
        mpg.setGlobalConfig(gc);

//======================================================================================================================

        // 数据源配置
        DataSourceConfig dsc = new DataSourceConfig();
        dsc.setUrl("jdbc:mysql://192.168.0.199:3306/test?useUnicode=true&useSSL=false&characterEncoding=utf8");
        // dsc.setSchemaName("public");
        dsc.setDriverName("com.mysql.cj.jdbc.Driver");
        dsc.setUsername("root");
        dsc.setPassword("123456");
        mpg.setDataSource(dsc);

//======================================================================================================================

        // 包配置
        PackageConfig pc = new PackageConfig();
        pc.setModuleName(scanner("模块名"));
        // 设置包的路径  该路径为 com.公司名.项目名
        String packagePath = "com.zengjx.project";
        pc.setParent(packagePath);
        mpg.setPackageInfo(pc);

//======================================================================================================================

        // 自定义配置
        InjectionConfig cfg = new InjectionConfig() {
            @Override
            public void initMap() {
                Map<String, Object> map = new HashMap<>();
                List<TableInfo> tableInfoList = this.getConfig().getTableInfoList();
                for (TableInfo tableInfo : tableInfoList) {
                    //项目包的路径 使用到的类有BaseQuery、MybatisPlusConfig、Result
                    map.put("packagePath", packagePath);
                }
                this.setMap(map);
            }
        };

//======================================================================================================================

        // 如果模板引擎是 freemarker
        String templatePath = "/templates/mapper.xml.ftl";
        // 如果模板引擎是 velocity
        // String templatePath = "/templates/mapper.xml.vm";

        // 自定义输出配置
        List<FileOutConfig> focList = new ArrayList<>();
        // 自定义配置会被优先输出  这是一个示例
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名，如果你 Entity 设置了前后缀、此处注意 xml 的名称会跟着发生变化！！
                // 指定xml文件输出位置
                return projectPath + "/src/main/resources/com/zengjx/project/" + pc.getModuleName() + "/mapper"
                        + "/" + tableInfo.getEntityName() + "Mapper" + StringPool.DOT_XML;
            }
        });

        // 自定义controller的代码模板
        templatePath = "/templates/controller.java.ftl";
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 + pc.getModuleName()
                String expand = projectPath + "/src/main/java/com/zengjx/project/" + pc.getModuleName() + "/" + "controller";
                return String.format((expand + File.separator + "%s" + ".java") , tableInfo.getControllerName());
            }
        });

        // 自定义entity的代码模板
        templatePath = "/templates/entity.java.ftl";
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 + pc.getModuleName()
                String expand = projectPath + "/src/main/java/com/zengjx/project/" + pc.getModuleName() + "/" + "entity";
                return String.format((expand + File.separator + "%s" + ".java") , tableInfo.getEntityName());
            }
        });

        // 自定义service的代码模板
        templatePath = "/templates/service.java.ftl";
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 + pc.getModuleName()
                String expand = projectPath + "/src/main/java/com/zengjx/project/" + pc.getModuleName() + "/" + "service";
                return String.format((expand + File.separator + "%s" + ".java") , tableInfo.getServiceName());
            }
        });

        // 自定义BaseQuery代码模板
        templatePath = "/templates/baseQuery.java.ftl";
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 + pc.getModuleName()
                String expand = projectPath + "/src/main/java/com/zengjx/project/" + "common";
                return String.format((expand + File.separator + "%s" + ".java") , "BaseQuery");
            }
        });

        // 自定义Result代码模板
        templatePath = "/templates/result.java.ftl";
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 + pc.getModuleName()
                String expand = projectPath + "/src/main/java/com/zengjx/project/" + "common";
                return String.format((expand + File.separator + "%s" + ".java") , "Result");
            }
        });

        // 自定义全局MybatisPlusConfig代码模板
        templatePath = "/templates/mybatisPlusConfig.java.ftl";
        // 自定义配置会被优先输出
        focList.add(new FileOutConfig(templatePath) {
            @Override
            public String outputFile(TableInfo tableInfo) {
                // 自定义输出文件名 + pc.getModuleName()
                String expand = projectPath + "/src/main/java/com/zengjx/project/" + "globalconfig";
                return String.format((expand + File.separator + "%s" + ".java") , "MybatisPlusConfig");
            }
        });

//======================================================================================================================

        cfg.setFileOutConfigList(focList);
        mpg.setCfg(cfg);

        // 配置模板
        TemplateConfig templateConfig = new TemplateConfig();

        // 配置自定义输出模板
        // 指定自定义模板路径，注意不要带上.ftl/.vm, 会根据使用的模板引擎自动识别
        // templateConfig.setEntity("templates/entity2.java");
        // templateConfig.setService();
        // templateConfig.setController();

        templateConfig.setXml(null);
        mpg.setTemplate(templateConfig);

//======================================================================================================================

        // 策略配置
        StrategyConfig strategy = new StrategyConfig();
        // 数据库表映射到实体的命名策略  下划线转驼峰命名
        strategy.setNaming(NamingStrategy.underline_to_camel);
        // 数据库表字段映射到实体的命名策略  下划线转驼峰命名
        strategy.setColumnNaming(NamingStrategy.underline_to_camel);
        // 设置entity继承的父类
        //strategy.setSuperEntityClass("你自己的父类实体,没有就不用设置!");
        // 设置实体类是否为lombok模型
        strategy.setEntityLombokModel(true);
        // 设置controller为restful风格
        strategy.setRestControllerStyle(true);
        // 设置controller的公共父类
        //strategy.setSuperControllerClass("你自己的父类控制器,没有就不用设置!");
        // 设置entity公共父类中的公共字段  如果这里设置了那么生成的entity就不会去生成Id了
        //strategy.setSuperEntityColumns("id");
        // 给那些表创建文件
        strategy.setInclude(scanner("表名，多个英文逗号分割").split(","));
        // 驼峰转连字符
        strategy.setControllerMappingHyphenStyle(true);
        // 设置表的前缀
        strategy.setTablePrefix(pc.getModuleName() + "_");
        // 将表的配置交给代码生成器
        mpg.setStrategy(strategy);
        // 创建模板引擎
        mpg.setTemplateEngine(new FreemarkerTemplateEngine());
        // 执行
        mpg.execute();
    }

}

package com.zengjx.project.globalconfig;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @author fastrabbit
 * @date 2021/6/9 9:55
 */
@Configuration
public class RedisConfig extends CachingConfigurerSupport {

    /**
     * @description: 将模板RedisTemplate<String, Object>中的key和value进行序列化
     * @param: RedisConnectionFactory
     * @return: RedisTemplate<String, Object>
     * @author: fastrabbit
     * @date: 2021/6/11 9:12
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {

        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper objectMapper = new ObjectMapper();
        objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance, ObjectMapper.DefaultTyping.NON_FINAL, JsonTypeInfo.As.WRAPPER_ARRAY);
        serializer.setObjectMapper(objectMapper);

        RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.setValueSerializer(serializer);
        redisTemplate.setHashKeySerializer(new StringRedisSerializer());
        redisTemplate.setHashValueSerializer(serializer);
        redisTemplate.afterPropertiesSet();

        return redisTemplate;

    }

    /**
     * @description: 设置RedisCacheManager
     * @param: RedisTemplate
     * @return: RedisCacheManager
     * @author: fastrabbit
     * @date: 2021/6/11 9:12
     */
    @Bean
    public RedisCacheManager redisCacheManager(RedisTemplate redisTemplate) {

        RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisTemplate.getConnectionFactory());
        RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig().serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(redisTemplate.getValueSerializer()));
        return new RedisCacheManager(redisCacheWriter, redisCacheConfiguration);

    }

}

package com.zengjx.project.redis.test;

import io.swagger.models.auth.In;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.connection.DataType;
import org.springframework.data.redis.core.*;
import org.springframework.test.context.junit4.SpringRunner;

import java.util.*;
import java.util.concurrent.TimeUnit;

/**
 * @author fastrabbit
 * @date 2021/6/9 9:30
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class RedisTemplateTest {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    @Test
    public void stringRedisTemplateTest() {

        //保存：保存key和value
        redisTemplate.opsForValue().set("stringKey1", "stringKey1_value");

        //保存：保存key和value  如果Key存在则返回false  否则保存成功并返回true
        Boolean message1 = redisTemplate.opsForValue().setIfAbsent("stringKey1", "message1");
        System.out.println(message1);

        //保存：保存key和value并设置过期时间
        redisTemplate.opsForValue().set("stringKey2", "stringKey2_value", 20, TimeUnit.SECONDS);

        //保存：通过map的方式保存key和value
        HashMap<String, Object> hashMap1 = new HashMap<>();
        hashMap1.put("stringKeyHash1", "stringKeyHash1_value");
        hashMap1.put("stringKeyHash2", "stringKeyHash2_value");
        hashMap1.put("stringKeyHash3", "stringKeyHash3_value");
        redisTemplate.opsForValue().multiSet(hashMap1);

        //保存：通过map的方式保存key和valu  如果map集合中的所有key在redis中不存在则添加否则不做修改
        HashMap<String, Object> hashMap2 = new HashMap<>();
        hashMap2.put("stringKeyHash3", "stringKeyHash3_value");
        hashMap2.put("stringKeyHash4", "stringKeyHash4_value");
        hashMap2.put("stringKeyHash5", "stringKeyHash5_value");
        redisTemplate.opsForValue().multiSetIfAbsent(hashMap2);

        //修改：在原来key值对应的value新增字符串到末尾处
        redisTemplate.opsForValue().set("stringKey3", "stringKey3_value");
        redisTemplate.opsForValue().append("stringKey3", "+新增字符串");

        //修改：修改key对应的value值  使用覆盖的方式
        redisTemplate.opsForValue().set("stringKey4", "stringKey4_value");
        redisTemplate.opsForValue().set("stringKey4", "stringKey4_newValue");

        //修改：修改key的值
        redisTemplate.opsForValue().set("stringKey5", "stringKey5_value");
        redisTemplate.rename("stringKey5", "newStringKey5");

        //修改：修改key的值  如果存在则修改返回ture  否则报错：ERR no such key
        redisTemplate.opsForValue().set("stringKey6", "stringKey6_value");
        Boolean message2 = redisTemplate.renameIfAbsent("stringKey6", "newStringKey6");
        System.out.println(message2);

        //修改：修改key的value值并返回原来的value值
        redisTemplate.opsForValue().set("stringKey7", "stringKey7_value");
        String exchange = (String)redisTemplate.opsForValue().getAndSet("stringKey7", "newStringKey7_value");
        System.out.println(exchange);

        //查询：获取指定key对应的value值
        redisTemplate.opsForValue().set("stringKey8", "stringKey8_value");
        String stringKey8 = (String)redisTemplate.opsForValue().get("stringKey8");
        System.out.println(stringKey8);

        //查询：批量获取到key对应的value值  参数为Collection<String> keys
        ArrayList<String> arrayListKeys = new ArrayList<>();
        arrayListKeys.add("stringKey1");
        arrayListKeys.add("stringKey2");
        arrayListKeys.add("stringKey3");
        List<Object> arrayListValues = redisTemplate.opsForValue().multiGet(arrayListKeys);
        for (Object arrayListValue : arrayListValues) {
            System.out.println(arrayListValue);
        }

        //查询：获取指定Key的value值并设定截取长度
        redisTemplate.opsForValue().set("stringKey9", "stringKey9_value");
        String stringKey9Value = redisTemplate.opsForValue().get("stringKey9", 1, 5);
        System.out.println(stringKey9Value);

        //查询：获取指定key的过期时间
        redisTemplate.opsForValue().set("stringKey10", "stringKey10_value", 666, TimeUnit.SECONDS);
        Long stringKey10Expire = redisTemplate.getExpire("stringKey10", TimeUnit.SECONDS);
        System.out.println(stringKey10Expire);

        //查询：从redis中随机获取到一个key值
        String randomKey = redisTemplate.randomKey();
        System.out.println(randomKey);

        //查询：返回key的value的类型
        redisTemplate.opsForValue().set("stringKey11", "stringKey11_value");
        DataType stringKey11DataType = redisTemplate.type("stringKey11");
        System.out.println(stringKey11DataType);

        //查询：查询匹配的key值  *：匹配任意多个字符  ?：配置单个字符  []：配置括号内的某1个字符
        Set<String> allKeys = redisTemplate.keys("*");
        Set<String> somekeys = redisTemplate.keys("stringKey?");
        Set<String> otherKeys = redisTemplate.keys("stringKey[123]");

        //删除：删除单个的key和它的vlue
        redisTemplate.opsForValue().set("stringKey12", "stringKey12_value");
        Boolean deleteStringKey12 = redisTemplate.delete("stringKey12");
        System.out.println(deleteStringKey12);

        //删除：批量删除集合中的key值  返回删除了的数量
        redisTemplate.opsForValue().set("stringKey13", "stringKey13_value");
        redisTemplate.opsForValue().set("stringKey14", "stringKey14_value");
        redisTemplate.opsForValue().set("stringKey15", "stringKey15_value");
        ArrayList<String> arrayListDelete = new ArrayList<>();
        arrayListDelete.add("stringKey13");
        arrayListDelete.add("stringKey14");
        arrayListDelete.add("stringKey15");
        Long deleteArrayList = redisTemplate.delete(arrayListDelete);
        System.out.println(deleteArrayList);

        //其他：将key序列化为byte[]类型
        redisTemplate.opsForValue().set("stringKey16", "stringKey16_value");
        byte[] stringKey16ByteArray = redisTemplate.dump("stringKey16");
        System.out.println(stringKey16ByteArray);

        //其他：将key进行持久化保存
        redisTemplate.opsForValue().set("stringKey17", "stringKey17_value");
        Boolean stringKey17Persist = redisTemplate.persist("stringKey17");
        System.out.println(stringKey17Persist);

        //其他：将当前库中的key移动到指定的库中
        redisTemplate.opsForValue().set("stringKey18", "stringKey18_value");
        Boolean stringKey18Move = redisTemplate.move("stringKey18", 1);
        System.out.println(stringKey18Move);

        //其他：获取到key的value字符串长度
        redisTemplate.opsForValue().set("stringKey19", "stringKey19_value");
        Long stringKey19Size = redisTemplate.opsForValue().size("stringKey19");
        System.out.println(stringKey19Size);

        //其他：查看是否存在指定的key
        Boolean hasStringKey19 = redisTemplate.hasKey("stringKey19");
        System.out.println(hasStringKey19);

    }

    @Test
    public void hashRedisTemplateTest() {

        //保存：保存一个hashMap
        redisTemplate.opsForHash().put("hashKey1", "field1", "field1_value");

        //保存：保存一个hashMap  仅当field不存在的时候才保存成功
        Boolean putIfAbsentField = redisTemplate.opsForHash().putIfAbsent("hashKey1", "field1", "field1_value_attach");
        System.out.println(putIfAbsentField);

        //保存：通过map的形式添加键值对
        HashMap<String, Object> hashMap3 = new HashMap<>();
        hashMap3.put("field2", "field2_value");
        hashMap3.put("field2_attach1", "field2_attach1_value");
        hashMap3.put("field2_attach2", "field2_attach2_value");
        redisTemplate.opsForHash().putAll("hashKey2", hashMap3);

        //修改：
        redisTemplate.opsForHash().put("hashKey3", "field3", "field3_value");
        redisTemplate.opsForHash().put("hashKey3", "field3", "newField3_value");

        //查询：获取指定hashKey、field的value值
        redisTemplate.opsForHash().put("hashKey4", "field4", "field4_value");
        String getSpecifyValue = (String)redisTemplate.opsForHash().get("hashKey4", "field4");
        System.out.println(getSpecifyValue);

        //查询：获取指定hashKey的map值
        redisTemplate.opsForHash().put("hashKey5", "field5", "field5_value");
        Map<Object, Object> getSpecifyMap = redisTemplate.opsForHash().entries("hashKey5");
        for (Object o : getSpecifyMap.keySet()) {
            System.out.println(o);
            System.out.println(getSpecifyMap.get(o));
        }

        //查询：获取指定hashkey中的所有field字段
        HashMap<String, Object> hashMap4 = new HashMap<>();
        hashMap4.put("field6", "field6_value");
        hashMap4.put("field6_attach1", "field6_attach1_value");
        hashMap4.put("field6_attach2", "field6_attach2_value");
        redisTemplate.opsForHash().putAll("hashKey6", hashMap4);
        Set<Object> getSpecifySet = redisTemplate.opsForHash().keys("hashKey6");
        for (Object o : getSpecifySet) {
            System.out.println(o);
        }

        //查询：获取到指定hashKey的field的数量
        HashMap<String, Object> hashMap5 = new HashMap<>();
        hashMap5.put("field7", "fiele7_value");
        hashMap5.put("field7_attach1", "fiele7_attach1_value");
        hashMap5.put("field7_attach2", "fiele7_attach2_value");
        redisTemplate.opsForHash().putAll("hashKey7", hashMap5);
        Long hashKey7Size = redisTemplate.opsForHash().size("hashKey7");
        System.out.println(hashKey7Size);

        //查询：获取指定hashKey的所有field的value值
        HashMap<String, Object> hashMap6 = new HashMap<>();
        hashMap6.put("field8", "field8_value");
        hashMap6.put("field8_attach1", "field8_attach1_value");
        hashMap6.put("field8_attach2", "field8_attach2_value");
        redisTemplate.opsForHash().putAll("hashKey8", hashMap6);
        List<Object> hashKey8Values = redisTemplate.opsForHash().values("hashKey8");
        for (Object hashKey8Value : hashKey8Values) {
            System.out.println(hashKey8Value);
        }

    }

    @Test
    public void listRedisTemplateTest() {

        //保存：存储在key链表的右边  并返回长度
        Long listKey1Length = redisTemplate.opsForList().rightPush("listKey1", "listKey1_value");
        System.out.println(listKey1Length);

        //保存：存储多个值在list的右边  参数为Collect<T>  参数泛型需要和设置的模板的泛型一致，不然保存的是数组而不是数组元素
        redisTemplate.opsForList().rightPush("listKey2", "listKey2_value");
        ArrayList<Object> arrayList1 = new ArrayList<>();
        arrayList1.add("listKey2_attach1_value");
        arrayList1.add("listKey2_attach2_value");
        arrayList1.add("listKey2_attach3_value");
        Long listKey2Length1 = redisTemplate.opsForList().rightPushAll("listKey2", "listKey2_attach1_value", "listKey2_attach2_value", "listKey2_attach3_value");
        Long listKey2Length2 = redisTemplate.opsForList().rightPushAll("listKey2", arrayList1);
        System.out.println(listKey2Length1);
        System.out.println(listKey2Length2);

        //保存：存储在key连表的左边  并返回长度
        Long listKey3Length1 = redisTemplate.opsForList().leftPush("listKey3", "listKey3_value");
        Long listKey3Length2 = redisTemplate.opsForList().leftPush("listKey3", "listKey3_attach1_value");
        System.out.println(listKey3Length1);
        System.out.println(listKey3Length2);

        //保存：存储多个值在list的左边  参数为collect<T>
        redisTemplate.opsForList().leftPush("listKey4", "listKey4_value");
        ArrayList<Object> arrayList2 = new ArrayList<>();
        arrayList2.add("listKey4_attach1_value");
        arrayList2.add("listKey4_attach2_value");
        arrayList2.add("listKey4_attach3_value");
        Long listKey4Length1 = redisTemplate.opsForList().leftPushAll("listKey4", "listKey4_attach1_value", "listKey4_attach2_value", "listKey4_attach3_value");
        Long listKey4Length2 = redisTemplate.opsForList().leftPushAll("listKey4", arrayList2);
        System.out.println(listKey4Length1);
        System.out.println(listKey4Length2);

        //保存：在指定的key中的pivot(key的value)的前面添加值  如果存在则添加  否则不添加并返回-1
        redisTemplate.opsForList().leftPush("listKey5", "listKey5_value");
        Long listKey5Length1 = redisTemplate.opsForList().leftPush("listKey5", "nothing", "listKey5_attach1_value");
        System.out.println(listKey5Length1);

        //保存：在指定的key中的pivot(key的value)的后面添加值  如果存在则添加  否则不添加并返回-1
        redisTemplate.opsForList().rightPush("listKey6", "listKey6_value");
        Long listKey6Length1 = redisTemplate.opsForList().rightPush("listKey6", "nothing", "listKey6_attach1_value");
        System.out.println(listKey6Length1);

        //保存：只有当链表存在的时候才加入  否则返回0
        Long nothing1 = redisTemplate.opsForList().leftPushIfPresent("nothing", "test");
        Long nothing2 = redisTemplate.opsForList().rightPushIfPresent("nothing", "test");
        System.out.println(nothing1);
        System.out.println(nothing2);

        //修改：修改指定索引处的值  如果索引大于链表长度或报错ERR index out of range
        redisTemplate.opsForList().rightPush("listKey7", "listKey7_value");
        redisTemplate.opsForList().set("listKey7", 0, "listKey7_attach1_value");

        //修改：将链表key进行剪切，从指定的索引处开始到指定索引处结束
        redisTemplate.opsForList().rightPushAll("listKey7", "listKey7_value", "listKey7_attach1_value", "listKey7_attach2_value");
        redisTemplate.opsForList().trim("listKey7", 0, 1);

        //查询：获取指定key和索引处的元素
        redisTemplate.opsForList().rightPushAll("listKey8", "listKey8_value", "listKey8_attach1_value", "listKey8_attach2_value");
        String listKey8IndexValues = (String)redisTemplate.opsForList().index("listKey8", 0);
        System.out.println(listKey8IndexValues);

        //查询：获取指定key和范围的元素集合 -1表示返回所有
        redisTemplate.opsForList().rightPushAll("listKey9", "listKey9_value", "listKey9_attach1_value", "listKey9_attach2_value");
        List<Object> listKey9RangeValues = redisTemplate.opsForList().range("listKey9", 0, 1);
        for (Object listKey9RangeValue : listKey9RangeValues) {
            System.out.println(listKey9RangeValue);
        }

        //删除：移除链表左边的第一个元素并获取到它的value值（如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止）可以设置超时时间
        redisTemplate.opsForList().rightPushAll("listKey10", "listKey10_value", "listKey10_attach1_value", "listKey10_attach2_value");
        Object listKey10PopValue = redisTemplate.opsForList().leftPop("listKey10", 10, TimeUnit.SECONDS);
        System.out.println(listKey10PopValue);

        //删除：移除链表右边的第一个元素并获取到它的value值（如果列表没有元素会阻塞列表直到等待超时或发现可弹出元素为止）可以设置超时时间
        redisTemplate.opsForList().rightPushAll("listKey11", "listKey11_value", "listKey11_attach1_value", "listKey11_attach2_value");
        Object listKey11PopValue = redisTemplate.opsForList().rightPop("listKey11", 10, TimeUnit.SECONDS);
        System.out.println(listKey11PopValue);

        //删除：将一个链表的右边的第一个元素弹出放到另一个链表的左边
        redisTemplate.opsForList().rightPushAll("listKey12", "listKey12_value", "listKey12_attach1_value", "listKey12_attach2_value");
        redisTemplate.opsForList().rightPushAll("listKey13", "listKey13_value", "listKey13_attach1_value", "listKey13_attach2_value");
        Object rightPopAndLeftPushValue = redisTemplate.opsForList().rightPopAndLeftPush("listKey12", "listKey13", 10, TimeUnit.SECONDS);
        System.out.println(rightPopAndLeftPushValue);

        //删除：将链表中值等于value的元素删除（index=0, 删除所有值等于value的元素; index>0, 从头部开始删除第一个值等于value的元素; index<0, 从尾部开始删除第一个值等于value的元素）
        redisTemplate.opsForList().rightPushAll("listKey14", "listKey14_value", "listKey14_attach1_value", "listKey14_attach2_value");
        redisTemplate.opsForList().rightPushAll("listKey15", "listKey15_value", "listKey15_attach1_value", "listKey15_attach2_value");
        redisTemplate.opsForList().rightPushAll("listKey16", "listKey16_value", "listKey16_attach1_value", "listKey16_attach2_value");
        Long listKey14Remove = redisTemplate.opsForList().remove("listKey14", 0, "listKey14_value");
        Long listKey15Remove = redisTemplate.opsForList().remove("listKey15", 2, "listKey15_value");
        Long listKey16Remove = redisTemplate.opsForList().remove("listKey16", -3, "listKey16_value");
        System.out.println(listKey14Remove);
        System.out.println(listKey15Remove);
        System.out.println(listKey16Remove);

        //其他：获取到指定的key的list的长度
        redisTemplate.opsForList().rightPushAll("listKey17", "listKey17_value", "listKey17_attach1_value", "listKey17_attach2_value");
        Long listKey17Size = redisTemplate.opsForList().size("listKey17");
        System.out.println(listKey17Size);

    }

    @Test
    public void setRedisTemplateTest() {

        //保存：保存一个元素
        Long setKey1Length1 = redisTemplate.opsForSet().add("setKey1", "setKey1_value");
        System.out.println(setKey1Length1);

        //保存：批量添加元素  好像不能使用set、list集合来批量添加
        Long setKey2Length1 = redisTemplate.opsForSet().add("setKey2", "setKey2_value", "setKey2_attach1_value", "setKey2_attach2_value");
        System.out.println(setKey2Length1);

        //修改：没有找到修改value值的方法  可以通过先删除再保存的方式进行修改

        //查询：获取指定集合中的所有元素
        redisTemplate.opsForSet().add("setKey3", "setKey3_value", "setKey3_attach1_value", "setKey3_attach2_value");
        Set<Object> setKey3Values = redisTemplate.opsForSet().members("setKey3");
        for (Object setKey3Value : setKey3Values) {
            System.out.println(setKey3Value);
        }

        //查询：随机获取到集合中的count个元素
        redisTemplate.opsForSet().add("setKey4", "setKey4_value", "setKey4_attach1_value", "setKey4_attach2_value");
        List<Object> setKey4Values = redisTemplate.opsForSet().randomMembers("setKey4", 2);
        for (Object setKey4Value : setKey4Values) {
            System.out.println(setKey4Value);
        }

        //查询：获取到两个集合的交集
        redisTemplate.opsForSet().add("setKey5", "setKey5_value", "setKey5_attach1_value", "setKey5_setKey6_value");
        redisTemplate.opsForSet().add("setKey6", "setKey6_value", "setKey6_attach1_value", "setKey5_setKey6_value");
        Set<Object> set5AndSet6intersect = redisTemplate.opsForSet().intersect("setKey5", "setKey6");
        for (Object o : set5AndSet6intersect) {
            System.out.println(o);
        }

        //查询：获取多个集合的交集
        ArrayList<String> arrayList1 = new ArrayList<>();
        redisTemplate.opsForSet().add("setKey7", "setKey7_value", "setKey7_attach1_value", "setKey7_setKey8_setKey9_value");
        redisTemplate.opsForSet().add("setKey8", "setKey8_value", "setKey8_attach1_value", "setKey7_setKey8_setKey9_value");
        redisTemplate.opsForSet().add("setKey9", "setKey9_value", "setKey9_attach1_value", "setKey7_setKey8_setKey9_value");
        arrayList1.add("setKey8");
        arrayList1.add("setKey9");
        Set<Object> setKey7AndSet8AndSet9Intersect = redisTemplate.opsForSet().intersect("setKey7", arrayList1);
        for (Object o : setKey7AndSet8AndSet9Intersect) {
            System.out.println(o);
        }

        //查询：将一个集合和一个或者多个集合的交集存储到另一个集合中
        ArrayList<String> arrayList2 = new ArrayList<>();
        redisTemplate.opsForSet().add("setKey10", "setKey10_value", "setKey10_attach1_value", "setKey10_setKey11_setKey12_value");
        redisTemplate.opsForSet().add("setKey11", "setKey11_value", "setKey11_attach1_value", "setKey10_setKey11_setKey12_value");
        redisTemplate.opsForSet().add("setKey12", "setKey12_value", "setKey12_attach1_value", "setKey10_setKey11_setKey12_value");
        arrayList2.add("setKey11");
        arrayList2.add("setKey12");
        redisTemplate.opsForSet().intersectAndStore("setKey10", arrayList2, "setKey13");

        //查询：获取一个和另一个或者一个和多个集合的并集
        ArrayList<String> arrayList3 = new ArrayList<>();
        redisTemplate.opsForSet().add("setKey14", "setKey14_value", "setKey14_attach1_value", "setKey14_setKey15_setKey16_value");
        redisTemplate.opsForSet().add("setKey15", "setKey15_value", "setKey15_attach1_value", "setKey14_setKey15_setKey16_value");
        redisTemplate.opsForSet().add("setKey16", "setKey16_value", "setKey16_attach1_value", "setKey14_setKey15_setKey16_value");
        arrayList3.add("setKey15");
        arrayList3.add("setKey16");
        Set<Object> setKey14AndSet15AndSet16Union = redisTemplate.opsForSet().union("setKey14", arrayList3);
        for (Object o : setKey14AndSet15AndSet16Union) {
            System.out.println(o);
        }
        //查询：获取一个和另一个或者一个和多个集合的并集  并将集合存储在指定Key的reids中  并返回集合长度
        Long setKey14AndSet15AndSet16Length = redisTemplate.opsForSet().unionAndStore("setKey14", arrayList3, "setKey17");
        System.out.println(setKey14AndSet15AndSet16Length);

        //查询：获取一个和另一个或者一个和多个集合的差集  就是第一个集合和其他集合独有的元素提取出来为一个新的集合
        ArrayList<String> arrayList4 = new ArrayList<>();
        redisTemplate.opsForSet().add("setKey18", "setKey18_value", "setKey18_attach1_value", "setKey18_setKey19_setKey20_value");
        redisTemplate.opsForSet().add("setKey19", "setKey19_value", "setKey19_attach1_value", "setKey18_setKey19_setKey20_value");
        redisTemplate.opsForSet().add("setKey20", "setKey20_value", "setKey20_attach1_value", "setKey18_setKey19_setKey20_value");
        arrayList4.add("setKey19");
        arrayList4.add("setKey20");
        Set<Object> setKey18AndSet19AndSet20Difference = redisTemplate.opsForSet().difference("setKey18", arrayList4);
        for (Object o : setKey18AndSet19AndSet20Difference) {
            System.out.println(o);
        }
        //查询：获取一个和另一个或者一个和多个集合的差集  并将集合设置到指定key的redis中  并返回集合长度
        Long setKey18AndSet19AndSet20Length = redisTemplate.opsForSet().differenceAndStore("setKey18", arrayList4, "setKey21");
        System.out.println(setKey18AndSet19AndSet20Length);

        //查询：随机获取一个集合中的元素
        redisTemplate.opsForSet().add("setKey22", "setKey22_value", "setKey22_attach1_value", "setKey22_attach2_value");
        String setKey22RandomValues = (String)redisTemplate.opsForSet().randomMember("setKey22");
        System.out.println(setKey22RandomValues);

        //查询：获取集合中的所有元素
        redisTemplate.opsForSet().add("setKey23", "setKey23_value", "setKey23_attach1_value", "setKey23_attach2_value");
        Set<Object> setKey23Values = redisTemplate.opsForSet().members("setKey23");
        for (Object setKey23Value : setKey23Values) {
            System.out.println(setKey23Value);
        }

        //删除：移除指定Key中的value元素  并返回集合长度
        redisTemplate.opsForSet().add("setKey24", "setKey24_value", "setKey24_attach1_value", "setKey24_attach2_value");
        Long setKey24Length = redisTemplate.opsForSet().remove("setKey24", "setKey24_attach2_value");
        System.out.println(setKey24Length);

        //删除：随机删除指定key中的一个元素并返回
        redisTemplate.opsForSet().add("setKey25", "setKey25_value", "setKey25_attach1_value", "setKey25_attach2_value");
        Object setKey25Value = redisTemplate.opsForSet().pop("setKey25");
        System.out.println(setKey25Value);

        //其他：获取集合的大小
        redisTemplate.opsForSet().add("setKey26", "setKey26_value", "setKey26_attach1_value", "setKey26_attach2_value");
        Long setKey26Length = redisTemplate.opsForSet().size("setKey26");
        System.out.println(setKey26Length);

    }

    @Test
    public void zSetRedisTemplateTest() {

        //保存：保存一个一个元素到集合中  第三个参数score为排序的权值  权值越小排序越前（左）
        Boolean zSetKey1 = redisTemplate.opsForZSet().add("zSetKey1", "zSetKey1_value", 1);
        System.out.println(zSetKey1);

        //修改：给指定的key的value的score增加值  原来的score+新增值
        redisTemplate.opsForZSet().add("zSetKey2", "zSetKey2_value", 1);
        Double zSetKey2Score = redisTemplate.opsForZSet().incrementScore("zSetKey2", "zSetKey2_value", 5);
        System.out.println(zSetKey2Score);

        //查询：返回元素在集合中的排名
        redisTemplate.opsForZSet().add("zSetKey3", "zSetKey3_value", 1);
        redisTemplate.opsForZSet().add("zSetKey3", "zSetKey3_attach1_value", 2);
        redisTemplate.opsForZSet().add("zSetKey3", "zSetKey3_attach2_value", 3);
        Long zSetKey3Rank = redisTemplate.opsForZSet().rank("zSetKey3", "zSetKey3_attach2_value");
        System.out.println(zSetKey3Rank);

        //查询：获取集合集合给定区间的元素  -1表示查询所有
        DefaultTypedTuple<Object> objectDefaultTypedTuple1 = new DefaultTypedTuple<Object>("zSetKey4_value", 1d);
        DefaultTypedTuple<Object> objectDefaultTypedTuple2 = new DefaultTypedTuple<Object>("zSetKey4_attach1_value", 2d);
        DefaultTypedTuple<Object> objectDefaultTypedTuple3 = new DefaultTypedTuple<Object>("zSetKey4_attach2_value", 3d);
        Set<ZSetOperations.TypedTuple<Object>> typedTuples = new HashSet<>();
        typedTuples.add(objectDefaultTypedTuple1);
        typedTuples.add(objectDefaultTypedTuple2);
        typedTuples.add(objectDefaultTypedTuple3);
        redisTemplate.opsForZSet().add("zSetKey4", typedTuples);
        Set<ZSetOperations.TypedTuple<Object>> zSetKey4 = redisTemplate.opsForZSet().reverseRangeWithScores("zSetKey4", 1, 2);
        for (ZSetOperations.TypedTuple<Object> objectTypedTuple : zSetKey4) {
            Double score = objectTypedTuple.getScore();
            Object value = objectTypedTuple.getValue();
            System.out.println(value);
            System.out.println(score);
        }
        //查询：按照score值进行  结果按照score从小到大进行排序
        Set<ZSetOperations.TypedTuple<Object>> zSetKey41 = redisTemplate.opsForZSet().reverseRangeWithScores("zSetKey4", 1, 2);
        for (ZSetOperations.TypedTuple<Object> objectTypedTuple : zSetKey41) {
            Double score = objectTypedTuple.getScore();
            Object value = objectTypedTuple.getValue();
            System.out.println(score);
            System.out.println(value);
        }
        //查询key对应的value值在集合中的排名
        Long zSetKey4ValueRank = redisTemplate.opsForZSet().reverseRank("zSetKey4", "zSetKey4_attach2_value");
        System.out.println(zSetKey4ValueRank);
        //获取集合的大小
        Long zSetKey4Length2 = redisTemplate.opsForZSet().size("zSetKey4");
        System.out.println(zSetKey4Length2);
        //获取指定key和value中的score值
        Double score = redisTemplate.opsForZSet().score("zSetKey4", "zSetKey4_value");
        System.out.println(score);
        
        //删除指定key的指定value值  并返回删除元素的个数
        redisTemplate.opsForZSet().add("zSetKey5", "zSetKey5_value", 1);
        redisTemplate.opsForZSet().add("zSetKey5", "zSetKey5_attach1_value", 2);
        redisTemplate.opsForZSet().add("zSetKey5", "zSetKey5_attach2_value", 3);
        Long zSetKey5Length1 = redisTemplate.opsForZSet().remove("zSetKey5", "zSetKey5_value");
        System.out.println(zSetKey5Length1);

    }

    @Test
    public void emptyRedis() {

        Set<String> keys = redisTemplate.keys("*");
        redisTemplate.delete(keys);

    }

}

package com.zengjx.project.annotation.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.zengjx.project.common.Result;
import com.zengjx.project.annotation.entity.Food;
import com.zengjx.project.annotation.mapper.FoodMapper;
import com.zengjx.project.annotation.service.IFoodService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

/**
 * @author fastrabbit
 * @date 2021-06-11
 */
@Service
@Transactional(rollbackFor=Exception.class)
public class FoodServiceImpl extends ServiceImpl<FoodMapper, Food> implements IFoodService {

    @Autowired
    private FoodMapper foodMapper;

    @Autowired
    private IFoodService foodService;

    /**
     * @author fastrabbit
     * @description 根据id查询单个数据  将查询到的数据放入到redis缓存中，如果根据key值能够在redis中找到则直接返回redis中的数据不执行代码  condition为缓存条件
     * @date 2021-06-11
     */
    @Override
    @Cacheable(value = "PROJECT:ANNOTATION", key = "&#39;FOOD:&#39;+#food.id", condition = "#food.id>0")
    public Result<Food> getById(Food food) {

        Result<Food> foodResult = new Result<>();
        foodResult.setData(foodMapper.selectById(food.getId()));
        return foodResult;

    }

    /**
     * @author fastrabbit
     * @description 根据查询条件查询分页数据  将查询到的数据放入到redis缓存中，如果根据key值能够在redis中找到则直接返回redis中的数据不执行代码  condition为缓存条件
     * @date 2021-06-11
     */
    @Override
    @Cacheable(value = "PROJECT:ANNOTATION", key = "&#39;FOOD:&#39;+#food.page+&#39;_&#39;+#food.rows", condition = "#food.page>0 and #food.rows>=10")
    public Result<List<Food>> findListByPage(Food food) {

        Result<List<Food>> listResult = new Result<>();
        Page<Food> foodPage = new Page<>(food.getPage(), food.getRows());
        QueryWrapper<Food> foodQueryWrapper = new QueryWrapper<>();
        List<Food> records = foodMapper.selectPage(foodPage, foodQueryWrapper).getRecords();
        listResult.setData(records);
        listResult.setTotal(records.size());
        return listResult;

    }

    /**
     * @author fastrabbit
     * @description 查询所有数据  将查询到的数据放入到redis缓存中，如果根据key值能够在redis中找到则直接返回redis中的数据不执行代码
     * @date 2021-06-11
     */
    @Override
    @Cacheable(value = "PROJECT:ANNOTATION", key = "&#39;FOOD:&#39;+&#39;ALL&#39;")
    public Result<List<Food>> getAll() {

        Result<List<Food>> foodResult = new Result<>();
        List<Food> foods = foodMapper.selectList(null);
        foodResult.setData(foods);
        foodResult.setTotal(foods.size());
        return foodResult;

    }

    /**
     * @author fastrabbit
     * @description 新增单个数据
     * @date 2021-06-11
     */
    @Override
    public Result<Object> insert(Food food) {

        Result<Object> objectResult = new Result<>();
        foodMapper.insert(food);
        // 通过调用上面的getById方法将新增的数据添加到redis中
        // 因为redis注解存储的方式使用的是spring的aop动态代理所以通过注入自己的方式来使用代理类中的方法
        foodService.getById(food);
        return objectResult;

    }

    /**
     * @author fastrabbit
     * @description 修改单个数据
     * @date 2021-06-11
     */
    @Override
    public Result<Object> update(Food food) {

        Result<Object> objectResult = new Result<>();
        foodMapper.updateById(food);
        // 通过调用下面的redisUpdate方法将存储在redis中的数据进行更新
        // 因为redis注解存储的方式使用的是spring的aop动态代理所以通过注入自己的方式来使用代理类中的方法
        Result<Food> byId = foodService.redisUpdate(food);
        Food data = byId.getData();
        System.out.println(data);
        return objectResult;

    }

    /**
     * @author fastrabbit
     * @Description 修改redis缓存中的数据  @CachePut注解：一定会执行代码然后将返回数据存放在redis中，保证数据库和redis中的数据一致性
     * @Date 13:38 2021/6/11
     */
    @Override
    @CachePut(value = "PROJECT:ANNOTATION", key = "&#39;FOOD:&#39;+#food.id", condition = "#food.id>0")
    public Result<Food> redisUpdate(Food food) {

        Result<Food> foodResult = new Result<>();
        foodResult.setData(foodMapper.selectById(food.getId()));
        return foodResult;

    }

    /**
     * @author fastrabbit
     * @description 删除单个数据  @CacheEvict：当执行到该方法时会根据key将redis中的数据进行删除，具有多项配置
     * @date 2021-06-11
     */
    @Override
    @CacheEvict(value = "PROJECT:ANNOTATION", key = "&#39;FOOD:&#39;+#food.id", condition = "#food.id>0")
    public Result<Object> delete(Food food) {

        Result<Object> objectResult = new Result<>();
        foodMapper.deleteById(food.getId());
        return objectResult;

    }

}