Java中配置和使用Redis

于 2024-04-29 20:00:00 发布
阅读量598 收藏 18
点赞数 16
分类专栏： # Redis 文章标签： java redis 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mo_sss/article/details/138004183
版权

天行健，君子以自强不息；地势坤，君子以厚德载物。

每个人都有惰性，但不断学习是好好生活的根本，共勉！

文章均为学习整理笔记，分享记录为主，如有错误请指正，共同学习进步。

文章目录

Redis（Windows版本下载安装和使用）
Redis可视化工具：Another Redis Desktop Manager下载安装使用

本篇基于springboot实现

1. 依赖引入

在pom中引入redis依赖

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

2. 配置文件

在配置文件中配置redis
application.yaml

spring:
#redis缓存数据库的配置
  redis:
    host: 127.0.0.1 # Redis服务器地址
    port: 6379 # Redis服务器连接端口
    password: 12345 # Redis服务器连接密码 默认为空
    database: 0 # Redis数据库索引 默认为0
    jedis:
      pool:
        max-idle: 8 # 连接池中的最大空闲连接
        min-idle: 1 # 连接池中的最小空闲连接
        max-active: 8 # 连接池最大连接数 使用负值表示没有限制
        max-wait: -1 # 连接池最大阻塞等待时间 使用负值表示没有限制
    timeout: 20000 # 连接超时时间 毫秒

3. 配置类

RedisConfig.java

package com.redis.config;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;

/**
 * @ClassDescription:
 * @JdkVersion: 1.8
 * @Author: 李白
 * @Created: 2024/3/19 20:12
 */
@Configuration
public class RedisConfig {
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String,Object> redisTemplate(RedisConnectionFactory connectionFactory){

        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(connectionFactory);
        // 使用StringRedisSerializer来序列化和反序列化redis的key值
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        template.setKeySerializer(stringRedisSerializer);
        template.setValueSerializer(stringRedisSerializer);

        GenericJackson2JsonRedisSerializer genericJackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();
        // Hash的key也采用StringRedisSerializer的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // Hash的key也采用GenericJackson2JsonRedisSerializer的序列化方式
        template.setHashValueSerializer(genericJackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }
}

4. 工具类

RedisUtil.java

package com.redis.utils;

/**
 * @ClassDescription:
 * @JdkVersion: 1.8
 * @Author: 李白
 * @Created: 2024/3/19 20:20
 */

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;
import org.springframework.util.CollectionUtils;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.TimeUnit;

@Component
public class RedisUtil {

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    // =============================common============================
    /**
     * 指定缓存失效时间
     *
     * @param key  键
     * @param time 时间(秒)
     * @return
     */
    public boolean expire(String key, long time) {
        try {
            if (time > 0) {
                redisTemplate.expire(key, time, TimeUnit.SECONDS);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据key 获取过期时间
     *
     * @param key 键 不能为null
     * @return 时间(秒) 返回0代表为永久有效
     */
    public long getExpire(String key) {
        return redisTemplate.getExpire(key, TimeUnit.SECONDS);
    }

    /**
     * 判断key是否存在
     *
     * @param key 键
     * @return true 存在 false不存在
     */
    public boolean hasKey(String key) {
        try {
            return redisTemplate.hasKey(key);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    // 查询key
    public Set<String> searchKeys(String keyword){
        return redisTemplate.keys("*"+keyword+"*");
    }

    /**
     * 删除缓存
     *
     * @param key 可以传一个值 或多个
     */
    @SuppressWarnings("unchecked")
    public void del(String... key) {
        if (key != null && key.length > 0) {
            if (key.length == 1) {
                redisTemplate.delete(key[0]);
            } else {
//                redisTemplate.delete(CollectionUtils.arrayToList(key));
                redisTemplate.delete((Collection<String>) CollectionUtils.arrayToList(key));
            }
        }
    }

    // ============================String=============================

    /**
     * 普通缓存获取
     *
     * @param key 键
     * @return 值
     */
    public Object get(String key) {
        return key == null ? null : redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     *
     * @param key   键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key, Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }

    }

    /**
     * 普通缓存放入并设置时间
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key, Object value, long time) {
        try {
            if (time > 0) {
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            } else {
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 递增
     *
     * @param key   键
     * @param delta 要增加几(大于0)
     * @return
     */
    public long incr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递增因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, delta);
    }

    /**
     * 递减
     *
     * @param key   键
     * @param delta 要减少几(小于0)
     * @return
     */
    public long decr(String key, long delta) {
        if (delta < 0) {
            throw new RuntimeException("递减因子必须大于0");
        }
        return redisTemplate.opsForValue().increment(key, -delta);
    }

    // ================================Map=================================

    /**
     * HashGet
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return 值
     */
    public Object hget(String key, String item) {
        return redisTemplate.opsForHash().get(key, item);
    }

    /**
     * 获取hashKey对应的所有键值
     *
     * @param key 键
     * @return 对应的多个键值
     */
    public Map<Object, Object> hmget(String key) {
        return redisTemplate.opsForHash().entries(key);
    }

    /**
     * HashSet
     *
     * @param key 键
     * @param map 对应多个键值
     * @return true 成功 false 失败
     */
    public boolean hmset(String key, Map<String, Object> map) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * HashSet 并设置时间
     *
     * @param key  键
     * @param map  对应多个键值
     * @param time 时间(秒)
     * @return true成功 false失败
     */
    public boolean hmset(String key, Map<String, Object> map, long time) {
        try {
            redisTemplate.opsForHash().putAll(key, map);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    ///**
    // * 向一张hash表中放入java对象
    // * @param key
    // * @param item
    // * @param value
    // * @param javaObject
    // * @return
    // */
    //public boolean hset(String key, String item, Object value, boolean javaObject) {
    //    //https://blog.csdn.net/jiachengwin/article/details/66480717
    //    try {
    //        if (javaObject){
    //            redisTemplate.opsForHash().put(key, item, value);
    //            return true;
    //            SerializeUtil.serialize(value)
    //        }
    //
    //    } catch (Exception e) {
    //        e.printStackTrace();
    //        return false;
    //    }
    //}


    /**
     * 向一张hash表中放入数据,如果不存在将创建
     *
     * @param key   键
     * @param item  项
     * @param value 值
     * @param time  时间(秒) 注意:如果已存在的hash表有时间,这里将会替换原有的时间
     * @return true 成功 false失败
     */
    public boolean hset(String key, String item, Object value, long time) {
        try {
            redisTemplate.opsForHash().put(key, item, value);
            if (time > 0) {
                expire(key, time);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 删除hash表中的值
     *
     * @param key  键 不能为null
     * @param item 项 可以使多个 不能为null
     */
    public void hdel(String key, Object... item) {
        redisTemplate.opsForHash().delete(key, item);
    }

    /**
     * 判断hash表中是否有该项的值
     *
     * @param key  键 不能为null
     * @param item 项 不能为null
     * @return true 存在 false不存在
     */
    public boolean hHasKey(String key, String item) {
        return redisTemplate.opsForHash().hasKey(key, item);
    }

    /**
     * hash递增 如果不存在,就会创建一个 并把新增后的值返回
     *
     * @param key  键
     * @param item 项
     * @param by   要增加几(大于0)
     * @return
     */
    public double hincr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, by);
    }

    /**
     * hash递减
     *
     * @param key  键
     * @param item 项
     * @param by   要减少记(小于0)
     * @return
     */
    public double hdecr(String key, String item, double by) {
        return redisTemplate.opsForHash().increment(key, item, -by);
    }

    // ============================set=============================

    /**
     * 根据key获取Set中的所有值
     *
     * @param key 键
     * @return
     */
    public Set<Object> sGet(String key) {



        try {
            return redisTemplate.opsForSet().members(key);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 根据value从一个set中查询,是否存在
     *
     * @param key   键
     * @param value 值
     * @return true 存在 false不存在
     */
    public boolean sHasKey(String key, Object value) {
        try {
            return redisTemplate.opsForSet().isMember(key, value);
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将数据放入set缓存
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSet(String key, Object... values) {
        try {
            return redisTemplate.opsForSet().add(key, values);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 将set数据放入缓存
     *
     * @param key    键
     * @param time   时间(秒)
     * @param values 值 可以是多个
     * @return 成功个数
     */
    public long sSetAndTime(String key, long time, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().add(key, values);
            if (time > 0)
                expire(key, time);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 获取set缓存的长度
     *
     * @param key 键
     * @return
     */
    public long sGetSetSize(String key) {
        try {
            return redisTemplate.opsForSet().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 移除值为value的
     *
     * @param key    键
     * @param values 值 可以是多个
     * @return 移除的个数
     */
    public long setRemove(String key, Object... values) {
        try {
            Long count = redisTemplate.opsForSet().remove(key, values);
            return count;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }
    // ===============================list=================================

    /**
     * 获取list缓存的内容
     *
     * @param key   键
     * @param start 开始
     * @param end   结束 0 到 -1代表所有值
     * @return
     */
    public List<Object> lGet(String key, long start, long end) {
        try {
            return redisTemplate.opsForList().range(key, start, end);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 获取list缓存的长度
     *
     * @param key 键
     * @return
     */
    public long lGetListSize(String key) {
        try {
            return redisTemplate.opsForList().size(key);
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

    /**
     * 通过索引 获取list中的值
     *
     * @param key   键
     * @param index 索引 index>=0时， 0 表头，1 第二个元素，依次类推；index<0时，-1，表尾，-2倒数第二个元素，依次类推
     * @return
     */
    public Object lGetIndex(String key, long index) {
        try {
            return redisTemplate.opsForList().index(key, index);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, Object value) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, Object value, long time) {
        try {
            redisTemplate.opsForList().rightPush(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @return
     */
    public boolean lSet(String key, List<Object> value) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 将list放入缓存
     *
     * @param key   键
     * @param value 值
     * @param time  时间(秒)
     * @return
     */
    public boolean lSet(String key, List<Object> value, long time) {
        try {
            redisTemplate.opsForList().rightPushAll(key, value);
            if (time > 0)
                expire(key, time);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 根据索引修改list中的某条数据
     *
     * @param key   键
     * @param index 索引
     * @param value 值
     * @return
     */
    public boolean lUpdateIndex(String key, long index, Object value) {
        try {
            redisTemplate.opsForList().set(key, index, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 移除N个值为value
     *
     * @param key   键
     * @param count 移除多少个
     * @param value 值
     * @return 移除的个数
     */
    public long lRemove(String key, long count, Object value) {
        try {
            Long remove = redisTemplate.opsForList().remove(key, count, value);
            return remove;
        } catch (Exception e) {
            e.printStackTrace();
            return 0;
        }
    }

}

5. 使用

请求测试的类
RedisTest.java

package com.redis.controller;

import com.redis.utils.RedisUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @ClassDescription:
 * @JdkVersion: 1.8
 * @Author: 李白
 * @Created: 2024/4/20 17:08
 */

@RestController
@RequestMapping(value = "/redis")
public class RedisTest {
    @Autowired
    RedisUtil redisUtil;

    @GetMapping(value = "/test")
    public String test() {
		//存入redis，键为redis-test-key，值为redis-test-value
        redisUtil.set("redis-test-key","redis-test-value");
		//获取键为libai的值
        Object object = redisUtil.get("libai");
        System.out.println(object);

        return "";
    }
}

6. 测试

启动服务，postman调用接口

127.0.0.1:8089/redis/test

然后到redis可视化工具中查看
在这里插入图片描述

感谢阅读，祝君暴富！

寒山李白
关注
  • 16
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
springboot集成 redis
weixin_43694038的博客
09-07 85
虽然原博主很 @#￥%## 但我尊重原创 https://www.cnblogs.com/zeng1994/p/03303c805731afc9aa9c60dbbd32a323.html 一、Maven依赖 （1）本文所采用的SpringBoot的版本如 org.springframework.boot spring-boot-starter-parent 2.0.2.RELEASE （2...
一文带你了解如何在Java中操作Redis
热门推荐
HHX_01的博客
07-21 1万+
一、 Redis客户端简介 1. Redis客户端分类 2. Spring 整合 Redis 的两种方式 二、 使用 Jedis 操作 Redis 1. Jedis的maven坐标 2. 使用Jedis操作Redis的步骤 3. Jedis 操作 Redis 示例 三、 使用 Spring Data Redis 操作 Redis 1. Spring Data Redis 的 maven 坐标 2. spring Data Redis 中 op
redis配置和Java使用redis
liuyichen999521的博客
10-24 963
redis配置和Java使用redis
Spring Boot redis 配置 以及 redis中各种数据类型在Java中的使用
xiangwang2016的博客
05-02 363
了解 Redis 并在 Spring Boot 项目中使用 Redis Spring中使用RedisTemplate操作Redis redis修改密码不生效问题 redis.conf参数配置 @EnableScheduling 、@EnableCaching 用于redis 支持 redisConfig类： @Configuration public class RedisCon...
Redis——（自定义工具类&Redis的Java配置类）
努力的小C
12-12 846
redis 自定义工具类的封装和使用
java操作Redis缓存设置过期时间的方法
08-19
主要介绍了java操作Redis缓存设置过期时间的方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
java中redis工具类
最新发布
01-27
java中redis工具类 指定缓存失效时间 根据key 获取过期时间，返回0代表为永久有效 判断key是否存在 删除缓存，可以传一个值 或多个 普通缓存获取 普通缓存放入 普通缓存放入并设置时间，time要大于0 如果time小于...
Java 使用 Redis
12-16
开始在 Java 中使用 Redis 前， 我们需要确保已经安装了 redis 服务及 Java redis 驱动，且你的机器上能正常使用 Java。 Java的安装配置可以参考我们的 Java开发环境配置 接下来让我们安装 Java redis 驱动： 首先你...
Java后台开发 Redis使用指南.pdf
03-13
适用于Java后台开发Redis使用者，包括Redis的安装与配置、Redis的持久化方案、Redis集群的搭建和在Java中Jedis的运用
spring boot redis配置及使用+redis
01-06
Redis介绍 NoSQL介绍 Redis介绍 Redis安装:Docker-Compose安装 使用redis-cli连接Redis 使用图形化界面连接Redis ...spring boot 配置Redis数据库连接 RedisTemplate： 验证码+redis应用 Redis常见问题
redis在spring中的配置及java代码实现
weixin_30414245的博客
05-16 148
1、建一个redis.properties属性文件 # Redis Setting redis.addr = 127.0.0.1 redis.port = 6379 redis.auth = master redis.maxIdle = 200 redis.maxActive = 1024 redis.maxWait = 10000 redis.timeOut = 10...
java配置redis_Java项目配置redis
weixin_39605647的博客
02-12 1802
成功配置redis之后，便来学习使用redis。首先了解下redis的数据类型。Redis的数据类型Redis支持五种数据类型：string(字符串)，hash(哈希)，list(列表)，set(集合)及zset(sorted set：有序集合)。Stringstring是redis最基本的类型，你可以理解成与Memcached一模一样的类型，一个key对应一个value。string类型是二进制...
java redis自定义配置类
mclt2017的博客
09-21 714
package com.redis.demo; import com.fasterxml.jackson.annotation.JsonAutoDetect; import com.fasterxml.jackson.annotation.PropertyAccessor; import com.fasterxml.jackson.databind.ObjectMapper; import org.springframework.boot.autoconfigure.jsonb.JsonbAutoCon.
SpringBoot整合Redis工具类
m0_52653999的博客
05-31 440
可以使用windows版的redis，方便开发顺便安装了一个Redis图形化界面工具，Another Redis Desktop，除了不能在里面输入命令，没什么大问题。
SpringBoot 中操作 Redis 及工具类的封装
m0_71777195的博客
05-06 1067
在我们项目开发中总是免不了会使用缓存，Redis现在基本是我们公司中非常常见的缓存方案，包括在用户token的缓存，热点信息的缓存等，这篇文章主要讲讲在SpringBoot项目中如何去操作Redis，及最后工具类的封装。
SpringBoot集成redis乱码问题以及工具类
qq_38786320的博客
10-10 518
版本 SoringBoot2.1.2 Redis集成SpringBoot中产生乱码问题，引入下方类可解决（注意扫描该配置） import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframew...
【7】Springboot整合Redis
浮笙
02-10 660
说明︰在SpringBoot2.x之后，原来使用的jedis被替换为了lettuce。
SpringBoot整合Redis，自定义Redis序列化以及Redis常用工具类分享
g1024173314的博客
10-25 915
SpringBoot整合Redis，自定义RedisTemplate，使用fastjson和Jackson来对Redis序列化以及Redis常用工具类分享
编写redis工具类
永恩&猫咪的博客
06-17 367
1. 新建一个redis接口 public interface ICacheUtil { void removePattern(String var1); void remove(String key); boolean exists(String key); Object get(String key); boolean set(String key, Object value); boolean set(String key, Object v
java中使用redis加锁
05-25
在Java中使用Redis实现分布式锁的一般步骤如下： 1. 首先，连接Redis服务器，获取JedisClient对象。 2. 使用setnx操作，尝试获取锁。setnx是Redis的一个原子操作，如果key存在则返回0，否则返回1。我们可以把key设置为锁的名称，value设置为当前时间加上一个超时时间（避免出现死锁），并设置过期时间。 3. 如果setnx返回1，说明获取锁成功，可以执行业务逻辑。如果返回0，说明锁已经被其他线程持有，需要等待一段时间再次尝试获取锁。 4. 执行完业务逻辑后，使用del操作释放锁。在释放锁之前，需要先判断锁是否已经过期，如果锁已经过期，则不能再释放锁，因为此时有可能锁已经被其他线程持有。 下面是一个简单的Redis分布式锁的示例代码： ```java public class RedisLock { private static final String LOCK_PREFIX = "lock:"; private static final int LOCK_EXPIRE_TIME = 300; // 锁的过期时间，单位为秒 private Jedis jedis; private String lockName; public RedisLock(Jedis jedis, String lockName) { this.jedis = jedis; this.lockName = LOCK_PREFIX + lockName; } public boolean tryLock() { String value = System.currentTimeMillis() + LOCK_EXPIRE_TIME + ""; long result = jedis.setnx(lockName, value); if (result == 1) { jedis.expire(lockName, LOCK_EXPIRE_TIME); return true; } return false; } public void unlock() { String value = jedis.get(lockName); if (value != null && System.currentTimeMillis() < Long.parseLong(value)) { jedis.del(lockName); } } } ``` 使用示例： ```java Jedis jedis = new Jedis("localhost", 6379); RedisLock lock = new RedisLock(jedis, "mylock"); if (lock.tryLock()) { try { // 执行业务逻辑 } finally { lock.unlock(); } } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

寒山李白

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值