redisController工具类

文章目录

      • redisController
      • opsForHash的一次优化经历
      • redisTemplate执行命令
    • 其他
      • 报错

redis-cli连接redis太不直观，一直寻思弄个工具类，网上一看到处都是，拿来直接用吧。

这代码也没多少啊，编辑时居然卡卡的。。。

redisController

代码：

/*
 * redis功能
 */
@RestController
@RequestMapping(value = "/interface/redis")
public class RedisController {

    private static Logger logger = LoggerFactory.getLogger(RedisController.class);

    @Autowired
    private RedisTemplate redisTemplate;


    @RequestMapping("/setString")
    public Object set(@RequestBody RedisRequest request) {
        redisTemplate.opsForValue().set(request.getKey(), request.getValue());
        return "OK";
    }

    // 注：get方法在不确定类型的情况下不能直接用
    @RequestMapping("/getString")
    public String get(@RequestBody RedisRequest request) {
        Object o = redisTemplate.opsForValue().get(request.getKey());
        return JSON.toJSONString(o);
    }

    // type也是通用功能，不区分类型  keys加强下  实际用不到这个接口了
    @RequestMapping("/type")
    public JsonResult type(@RequestBody RedisRequest request) {
        JsonResult result = new JsonResult<>();
        try {
            logger.info("redis功能_delete请求开始，request={}", JSON.toJSONString(request));
            DataType type = redisTemplate.type(request.getKey());
            logger.info("redis功能_delete请求完成，result={}",JSON.toJSONString(result));
            result=JsonResult.success(type);
            return result;
        }catch(Exception e){
            logger.error("redis功能_delete请求异常，error：",e);
            return JsonResult.error("-1","redis功能_delete请求异常,error="+e.getMessage());
        }

    }

    // 删除的时候区分类型吗? 不区分
    @RequestMapping("/delete")
    public JsonResult delete(@RequestBody RedisRequest request) {
        JsonResult result = new JsonResult<>();
        try {
            logger.info("redis功能_delete请求开始，request={}", JSON.toJSONString(request));
            redisTemplate.delete(request.getKey());
            logger.info("redis功能_delete请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch(Exception e){
            logger.error("redis功能_delete请求异常，error：",e);
            return JsonResult.error("-1","redis功能_delete请求异常,error="+e.getMessage());
        }
    }

    @RequestMapping("/keys")
    public JsonResult keys(@RequestBody RedisMapRequest request) {
        JsonResult<Object> result = new JsonResult<>();
        HashMap keysMap  = new HashMap<>();
        Set<String> keys = new HashSet<String>();
        try {
            logger.info("redis功能_keys请求开始，request={}",JSON.toJSONString(request));
            if(!StringUtils.isEmpty(request.getKey())){
                keys=redisTemplate.keys(request.getKey());
            }else{
                keys = redisTemplate.keys("*");
            }
            for (String item:keys) {
                DataType type = redisTemplate.type(item);
                keysMap.put(item,type);
            }
            result=JsonResult.success(keysMap);
            logger.info("redis功能_keys请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch (Exception e){
            logger.error("redis功能_keys请求异常，error：",e);
            return JsonResult.error("-1","redis功能_keys请求异常,error="+e.getMessage());
        }

    }

    @RequestMapping("/info")
    public JsonResult info(@RequestBody RedisRequest request) {
        JsonResult result = new JsonResult<>();
        try {
            logger.info("redis功能_info请求开始，request={}", JSON.toJSONString(request));
            Properties info = redisTemplate.getConnectionFactory().getConnection().info();
            result=JsonResult.success(info);
            logger.info("redis功能_info请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch(Exception e){
            logger.error("redis功能_info请求异常，error：",e);
            return JsonResult.error("-1","redis功能_info请求异常,error="+e.getMessage());
        }

    }



    // 添加单条记录
    @RequestMapping("/putToMap")
    public JsonResult putToMap(@RequestBody RedisMapRequest request) {
        JsonResult result = new JsonResult<>();
        try {
            logger.info("redis功能_putToMap请求开始，request={}", JSON.toJSONString(request));
            redisTemplate.opsForHash().put(request.getKey(), request.getSonKey(),request.getSonValue());
            // 重查
            Map map = redisTemplate.opsForHash().entries(request.getKey());
            result=JsonResult.success(map);
            logger.info("redis功能_putToMap请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch(Exception e){
            logger.error("redis功能_putToMap请求异常，error：",e);
            return JsonResult.error("-1","redis功能_putToMap请求异常,error="+e.getMessage());
        }
    }


    /*
     * 添加所有到map
     * 注：这是个增量接口
     * 如果key相同，会覆盖
     * 如果map为空 不会影响原有map
     */
    @RequestMapping("/putAllToMap")
    public JsonResult putAllToMap(@RequestBody RedisMapRequest request) {
        JsonResult<Object> result = new JsonResult<>();
        try {
            logger.info("redis功能_putAllToMap请求开始，request={}", JSON.toJSONString(request));
            redisTemplate.opsForHash().putAll(request.getKey(),request.getMap());
            logger.info("redis功能_putAllToMap请求开始，request={}", JSON.toJSONString(request));
            return result;
        }catch(Exception e) {
            logger.error("redis功能_putAllToMap请求异常，error：", e);
            return JsonResult.error("-1", "redis功能_putAllToMap请求异常,error=" + e.getMessage());
        }

    }

    @RequestMapping("/getFromMap")
    public JsonResult getFromMap(@RequestBody RedisMapRequest request) {
        JsonResult<Object> result = new JsonResult<>();
        try {
            logger.info("redis功能_getFromMap请求开始，request={}",JSON.toJSONString(request));
            Object o = redisTemplate.opsForHash().get(request.getKey(), request.getSonKey());
            result=JsonResult.success(o);
            return result;
        }catch(Exception e){
            logger.error("redis功能_putAllToMap请求异常，error：", e);
            return JsonResult.error("-1", "redis功能_putAllToMap请求异常,error=" + e.getMessage());
        }
    }


    // 强制set  先删除 再set全部
    @RequestMapping("/setMap")
    public JsonResult setMap(@RequestBody RedisMapRequest request,HashMap map) {
        JsonResult<Object> result = new JsonResult<>();
        try {
            logger.info("redis功能_setMap请求开始，request={}",JSON.toJSONString(request));
            if(null==map){
                map = new HashMap<>();
            }
            redisTemplate.opsForHash().delete(request.getKey());
            redisTemplate.opsForHash().putAll(request.getKey(), map);
            logger.info("redis功能_setMap请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch(Exception e){
            logger.error("redis功能_setMap请求异常，error：", e);
            return JsonResult.error("-1", "redis功能_setMap请求异常,error=" + e.getMessage());

        }

    }

    @RequestMapping("/getMapValues")
    public JsonResult getMapValues(@RequestBody RedisMapRequest request) {
        JsonResult result = new JsonResult<>();
        try {
            logger.info("redis功能_getMapValues请求开始，request={}",JSON.toJSONString(request));
            List list = redisTemplate.opsForHash().values(request.getKey());
            result=JsonResult.success(list);
            logger.info("redis功能_getMapValues请求完成，request={}",JSON.toJSONString(request));
            return result;
        }catch(Exception e){
            logger.error("redis功能_getMapValues请求异常，error：", e);
            return JsonResult.error("-1", "redis功能_getMapValues请求异常,error=" + e.getMessage());
        }

    }

    @RequestMapping("/getMapEntries")
    public JsonResult getMapEntries(@RequestBody RedisMapRequest request) {
        JsonResult<Object> result = new JsonResult<>();
        try {
            logger.info("redis功能_getMapEntries请求开始，request={}",JSON.toJSONString(request));
            Map map = redisTemplate.opsForHash().entries(request.getKey());
            result=JsonResult.success(map);
            logger.info("redis功能_getMapEntries请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch(Exception e){
            logger.error("redis功能_getMapEntries请求异常，error：", e);
            return JsonResult.error("-1", "redis功能_getMapEntries请求异常,error=" + e.getMessage());
        }


    }

    @RequestMapping("/delMap")
    public JsonResult delMap(@RequestBody RedisMapRequest request) {
        JsonResult<Object> result = new JsonResult<>();
        try {
            logger.info("redis功能_delMap请求开始，request={}",JSON.toJSONString(request));
            Long delflag = redisTemplate.opsForHash().delete(request.getKey());
            result=JsonResult.success(delflag);
            logger.info("redis功能_delMap请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch(Exception e){
            logger.error("redis功能_delMap请求异常，error：", e);
            return JsonResult.error("-1", "redis功能_delMap请求异常,error=" + e.getMessage());
        }
    }

    // 从map中删除一个键值对
    @RequestMapping("/deleteKeyFromMap")
    public JsonResult deleteKeyFromMap(@RequestBody RedisMapRequest request) {
        JsonResult<Object> result = new JsonResult<>();
        try {
            logger.info("redis功能_deleteKeyFromMap请求开始，request={}",JSON.toJSONString(request));
            Long delflag = redisTemplate.opsForHash().delete(request.getKey(), request.getSonKey());
            result=JsonResult.success(delflag);
            logger.info("redis功能_deleteKeyFromMap请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch(Exception e){
            logger.error("redis功能_deleteKeyFromMap请求异常，error：", e);
            return JsonResult.error("-1", "redis功能_deleteKeyFromMap请求异常,error=" + e.getMessage());
        }
    }

    @RequestMapping("/listAddValues")
    public JsonResult listAddValues(@RequestBody RedisListRequest request) {

        try {
            logger.info("redis功能_listAddValues请求开始，request={}", JSON.toJSONString(request));
            JsonResult result = new JsonResult<>();
            Long i = redisTemplate.opsForList().rightPushAll(request.getKey(), request.getValues());
            logger.info("redis功能_listAddValues请求完成，i={}", i);
            result.setMessage("redis功能_listAddValues请求完成，i="+i);
            return result;
        }catch(Exception e){
            logger.error("redis功能_listAddValues请求异常，error：",e);
            return JsonResult.error("-1","redis功能_listAddValues请求异常");
        }

    }

    @RequestMapping("/listLeftPush")
    public JsonResult listLeftPush(@RequestBody RedisListRequest request) {

        try {
            logger.info("redis功能_listLeftPush请求开始，request={}", JSON.toJSONString(request));
            JsonResult result = new JsonResult<>();
            Long i = redisTemplate.opsForList().leftPush(request.getKey(), request.getValue());
            logger.info("redis功能_listLeftPush请求完成，i={}",i);
            result.setMessage("redis功能_listLeftPush请求完成，i="+i);
            return result;
        }catch(Exception e){
            logger.error("redis功能_listLeftPush请求异常，error：",e);
            return JsonResult.error("-1","redis功能_listLeftPush请求异常");
        }

    }

    @RequestMapping("/listLeftPop")
    public JsonResult listLeftPop(@RequestBody RedisListRequest request) {

        try {
            logger.info("redis功能_listLeftPop请求开始，request={}", JSON.toJSONString(request));
            JsonResult result = new JsonResult<>();
            // 注： pop是不需要值得
            Object object = redisTemplate.opsForList().leftPop(request.getKey());
            logger.info("redis功能_listLeftPop请求完成，object={}",JSON.toJSONString(object));
            result.setMessage("redis功能_listLeftPush请求完成,object="+JSON.toJSONString(object));
            return result;
        }catch(Exception e){
            logger.error("redis功能_listLeftPush请求异常，error：",e);
            return JsonResult.error("-1","redis功能_listLeftPush请求异常");
        }

    }

    @RequestMapping("/listShowAll")
    public JsonResult listShowAll(@RequestBody RedisListRequest request) {

        try {
            logger.info("redis功能_listShowAll请求开始，request={}", JSON.toJSONString(request));
            JsonResult result = new JsonResult<>();
            // 小技巧，遍历全部
            Object object = redisTemplate.opsForList().range(request.getKey(),0,-1);
            logger.info("redis功能_listShowAll请求完成，object={}",JSON.toJSONString(object));
            result.setMessage("redis功能_listShowAll请求完成,object="+JSON.toJSONString(object));
            return result;
        }catch(Exception e){
            logger.error("redis功能_listShowAll请求异常，error：",e);
            return JsonResult.error("-1","redis功能_listShowAll请求异常,error="+e.getMessage());
        }

    }


    @RequestMapping("/setZset")
    public JsonResult setZset(@RequestBody RedisZsetRequest request) {

        try {
            logger.info("redis功能_setZset请求开始，request={}", JSON.toJSONString(request));
            JsonResult result = new JsonResult<>();

            Boolean flag = redisTemplate.opsForZSet().add(request.getKey(), request.getValue(), request.getScore());
            logger.info("redis功能_setZset请求完成，flag={}",flag);
            result.setMessage("redis功能_setZset请求完成,条数="+flag);
            return result;
        }catch(Exception e){
            logger.error("redis功能_setZset请求异常，error：",e);
            return JsonResult.error("-1","redis功能_setZset请求异常,error="+e.getMessage());
        }

    }


    @RequestMapping("/zsetRangeMembersAndScores")
    public JsonResult zsetRangeMembersAndScores(@RequestBody RedisZsetRequest request) {
        JsonResult result = new JsonResult<>();
        try {
            logger.info("redis功能_zsetRangeMembersAndScores请求开始，request={}", JSON.toJSONString(request));
            Set set = redisTemplate.opsForZSet().range(request.getKey(), request.getStart(), request.getEnd());
            ZSetOperations<String, String> zSetOps = redisTemplate.opsForZSet();
            ArrayList<Object> zsetList = new ArrayList<>();
            RedisZsetEntity zsetEntity=null;
            for (Object item: set) {
                zsetEntity = new RedisZsetEntity();
                Double score = zSetOps.score(request.getKey(), item);
                zsetEntity.setKey(request.getKey());
                zsetEntity.setValue(item.toString());
                zsetEntity.setScore(score);
                zsetList.add(zsetEntity);
            }
            result=JsonResult.success(zsetList);
            logger.info("redis功能_zsetRangeMembersAndScores请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch(Exception e){
            logger.error("redis功能_zsetRangeMembersAndScores请求异常，error：",e);
            return JsonResult.error("-1","redis功能_zsetRangeMembersAndScores请求异常,error="+e.getMessage());
        }

    }

    @RequestMapping("/zsetIncrementScore")
    public JsonResult zsetIncrementScore(@RequestBody RedisZsetRequest request) {
        JsonResult result = new JsonResult<>();
        try {
            logger.info("redis功能_zsetIncrementScore请求开始，request={}", JSON.toJSONString(request));
            ZSetOperations<String, String> zSetOps = redisTemplate.opsForZSet();
            Double yScore = zSetOps.score(request.getKey(), request.getValue());
            Double newScore = zSetOps.incrementScore(request.getKey(), request.getValue(), request.getDelta());
            result.setMessage("redis功能_zsetIncrementScore请求完成，yScore={}"+yScore+",newScore="+ newScore);
            logger.info("redis功能_zsetIncrementScore请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch(Exception e){
            logger.error("redis功能_zsetIncrementScore请求异常，error：",e);
            return JsonResult.error("-1","redis功能_zsetIncrementScore请求异常,error="+e.getMessage());
        }

    }


    @RequestMapping("/zsetIntersectAndStore")
    public JsonResult zsetIntersectAndStore(@RequestBody RedisZsetRequest request) {
        JsonResult result = new JsonResult<>();
        try {
            logger.info("redis功能_zsetIntersectAndStore请求开始，request={}", JSON.toJSONString(request));
            ZSetOperations<String, String> zSetOps = redisTemplate.opsForZSet();
            zSetOps.intersectAndStore(request.getKey(), request.getOtherKey(), request.getDestKey());
            // 新集合
            logger.info("redis功能_zsetIntersectAndStore请求完成，result={}",JSON.toJSONString(result));
            return result;
        }catch(Exception e){
            logger.error("redis功能_zsetIntersectAndStore请求异常，error：",e);
            return JsonResult.error("-1","redis功能_zsetIntersectAndStore请求异常,error="+e.getMessage());
        }

    }




    public JsonResult removeFromList(@RequestBody RedisListRequest request) {

        try {
            logger.info("redis功能_removeFromList请求开始，request={}", JSON.toJSONString(request));
            JsonResult result = new JsonResult<>();
            // 小技巧，遍历全部
            Long i = redisTemplate.opsForList().remove(request.getKey(), request.getCount(), request.getValue());
            logger.info("redis功能_removeFromList请求完成，条数={}",i);
            result.setMessage("redis功能_removeFromList请求完成,条数="+i);
            return result;
        }catch(Exception e){
            logger.error("redis功能_removeFromList请求异常，error：",e);
            return JsonResult.error("-1","redis功能_removeFromList请求异常,error="+e.getMessage());
        }

    }
}

opsForHash的一次优化经历

opsForHash有put方法也有putAll方法，如果条数比较多，非常推荐先放到一个map，再用putAll，这样减少和redis交互的次数，性能提高很多。

有一次执行时发现明显的卡两秒，排查了下，是在for循环里面单条put了，所以非常慢，优化为putAll之后快了许多。

redisTemplate执行命令

毫无疑问，肯定是支持的，controller代码中后续也会放上，这里单独拿出来易于说明。

@RequestMapping("/execute")
public JsonResult execute(@RequestBody RedisCommandRequest request) {
    JsonResult result = new JsonResult<>();
    try {
        logger.info("定制redis_execute请求开始，request={}", JSON.toJSONString(request));
        Object executeResult = redisTemplate.execute((RedisCallback<Object>) (connection) -> {
            ArrayList<byte[]> byteArrList = new ArrayList<>();
            ArrayList<String> args = request.getArgs();
            byte[][] byteArgs=new byte[0][];
            if(!CollectionUtils.isEmpty(request.getArgs())){
                byteArgs=new byte[args.size()][];
                for (int i = 0; i <args.size() ; i++) {
                    byteArgs[i]=args.get(i).getBytes(StandardCharsets.UTF_8);
                }
            }
            Object memory = connection.execute(request.getCommand(),byteArgs );
            return memory;
        });
        result=JsonResult.success(executeResult);
        logger.info("定制redis_execute请求完成，result={}",JSON.toJSONString(result));
        return result;
    }catch(Exception e){
        logger.error("定制redis_execute请求异常，error：",e);
        return JsonResult.error("-1","定制redis_execute请求异常,error="+e.getMessage());
    }

}

其他

报错

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mfbz.cn/a/881309.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Ceph官方文档_01_Ceph简介

Ceph官方文档_01_Ceph简介

目录 Ceph介绍Ceph介绍 Ceph可用于向云平台提供Ceph对象存储，Ceph可用于向云平台提供Ceph块设备服务。Ceph可用于部署Ceph文件系统。所有Ceph存储群集部署开始都是先设置每个Ceph节点，然后再设置网络。 Ceph存储集群需要以下内容：至少一个Ceph监视器和至少一个Ceph管理器，…
阅读更多...
毕业设计选题：基于ssm+vue+uniapp的捷邻小程序

毕业设计选题：基于ssm+vue+uniapp的捷邻小程序

开发语言&#xff1a;Java框架&#xff1a;ssmuniappJDK版本&#xff1a;JDK1.8服务器&#xff1a;tomcat7数据库&#xff1a;mysql 5.7&#xff08;一定要5.7版本&#xff09;数据库工具&#xff1a;Navicat11开发软件&#xff1a;eclipse/myeclipse/ideaMaven包&#xff1a;M…
阅读更多...
Linux top命令详解与重点内容说明

Linux top命令详解与重点内容说明

文章目录 重点说明基本信息进程(任务)信息cpu占用信息%Cpu(s)内存信息交换内存信息每列含义说明交互命令多窗口模式颜色配置命令参数 重点说明 top命令非常强大&#xff0c;也非常复杂&#xff0c;很难面面俱到&#xff0c;也没有必要&#xff0c;这篇文章的目的是介绍重点&am…
阅读更多...
en造数据结构与算法C# 群组行为优化 和 头鸟控制

en造数据结构与算法C# 群组行为优化 和 头鸟控制

实现&#xff1a; 1.给鸟类随机播放随机动画使得每一只鸟扇翅膀的频率都不尽相同 2.可以自行添加权重&#xff0c;并在最后 sumForce separationForce cohesionForce alignmentForce;分别乘上相应权重&#xff0c;这样鸟就能快速飞行和转向辣 using System.Collections.Ge…
阅读更多...
Linux系统编程（基础指令）上

Linux系统编程（基础指令）上

1.Linux常见目录介绍 Linux目录为树形结构 /&#xff1a;根目录&#xff0c;一般根目录下只存放目录&#xff0c;在Linux下有且只有一个根目录。所有的东西都是从这里开始。当你在终端里输入“/home”&#xff0c;你其实是在告诉电脑&#xff0c;先从/&#xff08;根目录&…
阅读更多...
Unity3D入门(二) :Unity3D实现视角的丝滑过渡切换

Unity3D入门(二) :Unity3D实现视角的丝滑过渡切换

1. 前言 上篇文章&#xff0c;我们已经初步了解了Unity3D&#xff0c;并新建并运行起来了一个项目&#xff0c;使相机视角自动围绕着立方体旋转。 这篇文章&#xff0c;我们来讲一下Unity3D怎么过渡地切换视角。 我们继续是我上篇文章中的项目&#xff0c;但是需要向把Camera…
阅读更多...
​OpenAI最强模型o1系列：开启人工智能推理新时代

​OpenAI最强模型o1系列：开启人工智能推理新时代

前不久OpenAI发布全新模型——o1模型&#xff0c;也就是业界说的“草莓模型”&#xff0c;包含三款型号&#xff1a;OpenAI o1、OpenAI o1-preview和OpenAI o1-mini。 其中&#xff0c;OpenAI o1-mini和 o1-preview已经对用户开放使用&#xff1a; OpenAI o1&#xff1a;高级推…
阅读更多...
企业急于采用人工智能，忽视了安全强化

企业急于采用人工智能，忽视了安全强化

对主要云提供商基础设施上托管的资产的安全分析显示&#xff0c;许多公司为了急于构建和部署 AI 应用程序而打开安全漏洞。常见的发现包括对 AI 相关服务使用默认且可能不安全的设置、部署易受攻击的 AI 软件包以及不遵循安全强化指南。 这项分析由 Orca Security 的研究人员进…
阅读更多...
Redis学习以及SpringBoot集成使用Redis

Redis学习以及SpringBoot集成使用Redis

目录 一、Redis概述 二、Linux下使用Docker安装Redis 三、SpringBoot集成使用Redis 3.1 添加redis依赖 3.2 配置连接redis 3.3 实现序列化 3.4 注入RedisTemplate 3.5 测试 四、Redis数据结构 一、Redis概述 什么是redis&#xff1f; redis 是一个高性能的&#xf…
阅读更多...
vue项目加载cdn失败解决方法

vue项目加载cdn失败解决方法

注释index.html文件中 找到vue.config.js文件注释、
阅读更多...
【Python语言初识(二)】

【Python语言初识(二)】

一、分支结构 1.1、if语句 在Python中&#xff0c;要构造分支结构可以使用if、elif和else关键字。所谓关键字就是有特殊含义的单词&#xff0c;像if和else就是专门用于构造分支结构的关键字&#xff0c;很显然你不能够使用它作为变量名&#xff08;事实上&#xff0c;用作其他…
阅读更多...
0基础带你入门Linux之使用

0基础带你入门Linux之使用

1.Ubuntu软件管理 回顾一下&#xff0c;我们之前使用su root切换到root模式&#xff0c;使用who 发现为什么显示的还是bd用户呢&#xff1f;为什么呢&#xff1f; 这个who是主要来查看的是我们登录的时候是以什么用户登录的 所以即使我们使用who进行查看的时候显示的还是bd用…
阅读更多...
【JavaWeb】利用IDEA2024+tomcat10配置web6.0版本搭建JavaWeb开发项目

【JavaWeb】利用IDEA2024+tomcat10配置web6.0版本搭建JavaWeb开发项目

之前写过一篇文章&#xff1a;《【JavaWeb】利用IntelliJ IDEA 2024.1.4 Tomcat10 搭建Java Web项目开发环境&#xff08;图文超详细&#xff09;》详细讲解了如何搭建JavaWeb项目的开发环境&#xff0c;里面默认使用的Web版本是4.0版本的。但在某些时候tomcat10可能无法运行we…
阅读更多...
提升效率的AI工具集 - 轻松实现自动化

提升效率的AI工具集 - 轻松实现自动化

在这个快节奏、高效率的社会中&#xff0c;我们每个人都渴望能够找到提升工作效率的捷径。幸运的是&#xff0c;随着人工智能&#xff08;AI&#xff09;技术的迅猛发展&#xff0c;越来越多的AI工具涌现出来&#xff0c;为我们提供了强大的支持。这些工具不仅能够帮助我们提高…
阅读更多...
计算机毕业设计 美发管理系统的设计与实现 Java实战项目 附源码+文档+视频讲解

计算机毕业设计 美发管理系统的设计与实现 Java实战项目 附源码+文档+视频讲解

博主介绍&#xff1a;✌从事软件开发10年之余&#xff0c;专注于Java技术领域、Python人工智能及数据挖掘、小程序项目开发和Android项目开发等。CSDN、掘金、华为云、InfoQ、阿里云等平台优质作者✌ &#x1f345;文末获取源码联系&#x1f345; &#x1f447;&#x1f3fb; 精…
阅读更多...
尚品汇-秒杀成功下单接口、秒杀结束定时任务-清空缓存数据（五十四）

尚品汇-秒杀成功下单接口、秒杀结束定时任务-清空缓存数据（五十四）

目录&#xff1a; &#xff08;1&#xff09;下单页面 &#xff08;2&#xff09;service-activity-client添加接口 &#xff08;3&#xff09;web-all 编写去下单控制器 &#xff08;4&#xff09;service-order模块提供秒杀下单接口 &#xff08;5&#xff09;service-or…
阅读更多...
安全基础学习-AES128加密算法

安全基础学习-AES128加密算法

前言 AES&#xff08;Advanced Encryption Standard&#xff09;是对称加密算法的一个标准&#xff0c;主要用于保护电子数据的安全。AES 支持128、192、和256位密钥长度&#xff0c;其中AES-128是最常用的一种&#xff0c;它使用128位&#xff08;16字节&#xff09;的密钥进…
阅读更多...
推荐系统-电商直播 多目标排序算法探秘

推荐系统-电商直播 多目标排序算法探秘

前言&#xff1a; 电商直播已经成为电商平台流量的主要入口&#xff0c;今天我们一起探讨推荐算法在直播中所面临的核心问题和解决方案。以下内容参考阿里1688的技术方案整理完成。 一、核心问题介绍 在电商网站中&#xff0c;用户的主要行为是在商品上的行为&#xff0c;直播…
阅读更多...
机器学习笔记（一）初识机器学习

机器学习笔记（一）初识机器学习

1.定义 机器学习是一门多学科交叉专业&#xff0c;涵盖概率论知识&#xff0c;统计学知识&#xff0c;近似理论知识和复杂算法知识&#xff0c;使用计算机作为工具并致力于真实实时的模拟人类学习方式&#xff0c;并将现有内容进行知识结构划分来有效提高学习效率。 机器学习有…
阅读更多...
JUC学习笔记（三）

JUC学习笔记（三）

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 八、共享模型之工具--JUC8.1 AQS 原理1. 概述2 实现不可重入锁自定义同步器自定义锁 3.心得起源目标设计1) state 设计2&#xff09;阻塞恢复设计3&#xff09;队列…
阅读更多...
最新文章

Copyright @ 2022~2023