So implementieren Sie die Demo von springboot+mybatisplus+redis-Redis-php.cn

Heim

Datenbank

Redis

So implementieren Sie die Demo von springboot+mybatisplus+redis

王林

May 29, 2023 pm 12:43 PM

redisspringbootmybatisplus

1.Fügen Sie das erforderliche JAR-Paket in .pom.xml

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

2.application.yml-Konfigurationsinformationen

#端口
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

3 ein. Zum Starten der Klasse erforderliche Anmerkungen

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);
    }

}

4.mybatisplus-Vorlage – baseQuery

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;

}

5.mybatisplus-Vorlage ——Controller

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>

6.mybatisplus-Vorlage——entity

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

7.mybatisplus-Vorlage——Mapper

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>

8.mybatisplus-Vorlage——mybatisplusConfig

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

}

9.mybatisplus.-Vorlage——result

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;

}

10.mybatisplus Vorlage ——service

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>

11.mybatisplus-Vorlage——serviceImpl

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>

12.mybatisplus-Vorlagencodegenerator——CodeGenerator

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();
    }

}

13.redis-Konfigurationsdatei

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

    }

}

14.redis-Vorlage einige gängige Methoden

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

    }

}

15 .Verwendung von einige Anmerkungen zum Betrieb von Redis

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;

    }

}

Das obige ist der detaillierte Inhalt vonSo implementieren Sie die Demo von springboot+mybatisplus+redis. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!

Stellungnahme

Dieser Artikel ist reproduziert unter:亿速云. Bei Verstößen wenden Sie sich bitte an admin@php.cn löschen

Verwandter Artikel

Redis vs. SQL -Datenbanken: SchlüsselunterschiedeApr 25, 2025 am 12:02 AM

Der Hauptunterschied zwischen Redis- und SQL-Datenbanken besteht darin, dass Redis eine In-Memory-Datenbank ist, die für hohe Leistung und Flexibilitätsanforderungen geeignet ist. Die SQL -Datenbank ist eine relationale Datenbank, die für komplexe Abfragen und Datenkonsistenzanforderungen geeignet ist. Insbesondere 1) REDIS bietet Hochgeschwindigkeits-Datenzugriffs- und Caching-Dienste und unterstützt mehrere Datentypen, die für die Verarbeitung von Caching und Echtzeit geeignet sind. 2) Die SQL-Datenbank verwaltet Daten über eine Tabellenstruktur, unterstützt komplexe Abfragen und Transaktionsverarbeitung und eignet sich für Szenarien wie E-Commerce- und Finanzsysteme, die Datenkonsistenz erfordern.

Redis: Wie es als Datenspeicher und Dienst fungiertApr 24, 2025 am 12:08 AM

RedisactsasbothadatastoreandService.1) Asadatastore, itusesin-MemoryStorageForfastoperationen, unterstützende Variiousdatastructures Likekey-Valuepairs und sortierte Sets.2) Asasservice, ItprovidesFunctionalitys Likespub/SubMessing-SetsandluascriptingForComplexoperationen

Redis gegen andere Datenbanken: Eine vergleichende AnalyseApr 23, 2025 am 12:16 AM

Im Vergleich zu anderen Datenbanken hat Redis die folgenden einzigartigen Vorteile: 1) extrem schnelle Geschwindigkeit, und Lese- und Schreibvorgänge befinden sich normalerweise auf Mikrosekunde; 2) unterstützt reichhaltige Datenstrukturen und Operationen; 3) Flexible Nutzungsszenarien wie Caches, Zähler und Veröffentlichung von Abonnements. Bei der Auswahl von Redis oder anderen Datenbanken hängt dies von den spezifischen Anforderungen und Szenarien ab. Redis spielt eine gute Leistung in leistungsstarken und niedrigen Latenzanwendungen.

Redis 'Rolle: Erforschung der Datenspeicher- und VerwaltungsfunktionenApr 22, 2025 am 12:10 AM

Redis spielt eine Schlüsselrolle bei der Datenspeicherung und -verwaltung und ist durch seine mehreren Datenstrukturen und Persistenzmechanismen zum Kern moderner Anwendungen geworden. 1) Redis unterstützt Datenstrukturen wie Zeichenfolgen, Listen, Sammlungen, geordnete Sammlungen und Hash -Tabellen und eignet sich für Cache und komplexe Geschäftslogik. 2) RDB und AOF sorgt durch zwei Persistenzmethoden für eine zuverlässige Speicherung und eine schnelle Wiederherstellung von Daten.

Redis: NoSQL -Konzepte verstehenApr 21, 2025 am 12:04 AM

Redis ist eine NoSQL-Datenbank, die für einen effizienten Speicher und Zugriff auf groß angelegte Daten geeignet ist. 1.Redis ist ein Open Source -Speicherdatenstruktur -Speichersystem, das mehrere Datenstrukturen unterstützt. 2. Es bietet extrem schnelle Lektüre und Schreibgeschwindigkeiten, geeignet für Caching, Sitzungsmanagement usw. 3.Redis unterstützt die Persistenz und sorgt für die Datensicherheit durch RDB und AOF. 4. Verwendungsbeispiele umfassen grundlegende Schlüsselwertpaarvorgänge und erweiterte Sammeldeduplizierungsfunktionen. 5. Zu den häufigen Fehlern gehören Verbindungsprobleme, Datentypfehlanpassungen und Speicherüberlauf, sodass Sie auf das Debuggen achten müssen. 6. Vorschläge zur Leistungsoptimierung umfassen die Auswahl der geeigneten Datenstruktur und die Einrichtung von Strategien zur Speicherung der Speicherung.

Redis: Anwendungsfälle und Beispiele in realer WeltApr 20, 2025 am 12:06 AM

Zu den Anwendungen von Redis in der realen Welt gehören: 1. Als Cache-System beschleunigen Sie die Datenbankabfrage, 2. Um die Sitzungsdaten von Webanwendungen zu speichern, um in Echtzeit-Rankings zu implementieren, 4. Um die Nachrichtenzustellung als Nachrichtenwarteschlange zu vereinfachen. Redis 'Vielseitigkeit und hohe Leistung lassen es in diesen Szenarien glänzen.

Redis: Erforschen der Funktionen und FunktionenApr 19, 2025 am 12:04 AM

Redis sticht aufgrund seiner hohen Geschwindigkeit, Vielseitigkeit und reichhaltigen Datenstruktur auf. 1) Redis unterstützt Datenstrukturen wie Zeichenfolgen, Listen, Sammlungen, Hashs und geordnete Sammlungen. 2) Es speichert Daten über den Speicher und unterstützt RDB und AOF Persistenz. 3) Ausgehend von Redis 6.0 wurden Multi-Thread-E/A-Operationen eingeführt, was die Leistung in hohen Parallelitätsszenarien verbessert hat.

Ist Redis eine SQL- oder NoSQL -Datenbank? Die Antwort erklärteApr 18, 2025 am 12:11 AM

RedisiscassifizedasanosqldatabaseBecauseituseSakey-valuedatamodelinSteAfThetitionalrelationalDatabasemodel

See all articles

Heiße KI -Werkzeuge

Undresser.AI Undress

KI-gestützte App zum Erstellen realistischer Aktfotos

AI Clothes Remover

Online-KI-Tool zum Entfernen von Kleidung aus Fotos.

Undress AI Tool

Ausziehbilder kostenlos

Clothoff.io

KI-Kleiderentferner

Video Face Swap

Tauschen Sie Gesichter in jedem Video mühelos mit unserem völlig kostenlosen KI-Gesichtstausch-Tool aus!

Heißer Artikel

Assassin's Creed Shadows: Seashell Riddle -Lösung

4 Wochen vorByDDD

Was ist neu in Windows 11 KB5054979 und wie Sie Update -Probleme beheben

3 Wochen vorByDDD

Wo kann man die Kransteuerungsschlüsselkarten in Atomfall finden

4 Wochen vorByDDD

<🎜>: Dead Rails - wie man jede Herausforderung abschließt

1 Monate vorByDDD

Atomfall Guide: Gegenstandsstandorte, Questführer und Tipps

1 Monate vorByDDD

Heiße Werkzeuge

SecLists

SecLists ist der ultimative Begleiter für Sicherheitstester. Dabei handelt es sich um eine Sammlung verschiedener Arten von Listen, die häufig bei Sicherheitsbewertungen verwendet werden, an einem Ort. SecLists trägt dazu bei, Sicherheitstests effizienter und produktiver zu gestalten, indem es bequem alle Listen bereitstellt, die ein Sicherheitstester benötigen könnte. Zu den Listentypen gehören Benutzernamen, Passwörter, URLs, Fuzzing-Payloads, Muster für vertrauliche Daten, Web-Shells und mehr. Der Tester kann dieses Repository einfach auf einen neuen Testcomputer übertragen und hat dann Zugriff auf alle Arten von Listen, die er benötigt.

mPDF

mPDF ist eine PHP-Bibliothek, die PDF-Dateien aus UTF-8-codiertem HTML generieren kann. Der ursprüngliche Autor, Ian Back, hat mPDF geschrieben, um PDF-Dateien „on the fly“ von seiner Website auszugeben und verschiedene Sprachen zu verarbeiten. Es ist langsamer und erzeugt bei der Verwendung von Unicode-Schriftarten größere Dateien als Originalskripte wie HTML2FPDF, unterstützt aber CSS-Stile usw. und verfügt über viele Verbesserungen. Unterstützt fast alle Sprachen, einschließlich RTL (Arabisch und Hebräisch) und CJK (Chinesisch, Japanisch und Koreanisch). Unterstützt verschachtelte Elemente auf Blockebene (wie P, DIV),

SublimeText3 Linux neue Version

SublimeText3 Linux neueste Version

Notepad++7.3.1

Einfach zu bedienender und kostenloser Code-Editor

DVWA

Damn Vulnerable Web App (DVWA) ist eine PHP/MySQL-Webanwendung, die sehr anfällig ist. Seine Hauptziele bestehen darin, Sicherheitsexperten dabei zu helfen, ihre Fähigkeiten und Tools in einem rechtlichen Umfeld zu testen, Webentwicklern dabei zu helfen, den Prozess der Sicherung von Webanwendungen besser zu verstehen, und Lehrern/Schülern dabei zu helfen, in einer Unterrichtsumgebung Webanwendungen zu lehren/lernen Sicherheit. Das Ziel von DVWA besteht darin, einige der häufigsten Web-Schwachstellen über eine einfache und unkomplizierte Benutzeroberfläche mit unterschiedlichen Schwierigkeitsgraden zu üben. Bitte beachten Sie, dass diese Software

Heiße Themen

Wo ist der Login-Zugang für Gmail-E-Mail?

7706

1640

1394

1288

1231