Jedis和redisTemplate 共用问题--序列化不一致(生产事故-＞解决-＞两个redisTemplate)

最新推荐文章于 2023-10-16 16:23:22 发布
最新推荐文章于 2023-10-16 16:23:22 发布
阅读量1.1k 收藏 4
点赞数
分类专栏： 笔记 文章标签： redis java redisTemplate 序列化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46690280/article/details/119964607
版权

Jedis和redisTemplate 共用问题

Jedis和redisTemplate 共用问题

老项目用Jedis,放入redis中,用的是比较老的框架,还进行序列化.
用redisTemplate试了下拿不到.因为序列化的方式不同

Jedis

老项目的Put方法.

@Override
	public boolean put(String key, Object value, int TTL) throws Exception {
		Jedis jedis = null;
		try {
			jedis = jedisPool.getResource();
			jedis.set(SerializeUtil.serialize(key), SerializeUtil.serialize(value));
			jedis.expire(SerializeUtil.serialize(key), TTL);
		} catch (Exception e) {
			log.error("缓存存入失败", e);
			return false;
		} finally {
			returnResource(jedisPool, jedis);
		}

		return true;
	}

然后把工具类搬过来了

public class SerializeUtil {
    /**
     *序列化
     * 
     * @param object
     * @return
     */
    public static byte[] serialize(Object object) {
        ObjectOutputStream oos = null;
        ByteArrayOutputStream baos = null;
        try {
            baos = new ByteArrayOutputStream();
            oos = new ObjectOutputStream(baos);
            oos.writeObject(object);
            byte[] bytes = baos.toByteArray();
            return bytes;
        } catch (Exception e) {

        }
        return null;
    }

    /**
     * 反序列化
     * 
     * @param bytes
     * @return
     */
    public static Object unserialize(byte[] bytes) {
        ByteArrayInputStream bais = null;
        try {
            bais = new ByteArrayInputStream(bytes);
            ObjectInputStream ois = new ObjectInputStream(bais);
            return ois.readObject();
        } catch (Exception e) {

        }
        return null;
    }
}

写个测试来看看

  @Test
    public void test1() {

        Jedis jedis = null;
        jedis = new Jedis("localhost", 6379);

        jedis.set(SerializeUtil.serialize("xx"), SerializeUtil.serialize("brgfewfe"));
        jedis.expire(SerializeUtil.serialize("xx"), 3000);
    }

redisTemplate尝试和解决

配置什么就不说了,想着这样应该能解决吧,发现不行.后来查了好多资料,发现redisTemplate的序列化需要配置方法

  
    @Autowired
    private static RedisTemplate redisTemplate;

        ValueOperations valueOperations = redisTemplate.opsForValue();
        Object wenzhouToken = valueOperations.get(SerializeUtil.serialize("xx"));
        System.out.println(wenzhouToken);

于是

          RedisSerializerUtil redisSerializerUtil = new RedisSerializerUtil();
                redisTemplate.setKeySerializer(redisSerializerUtil);
                redisTemplate.setHashKeySerializer(redisSerializerUtil);
                redisTemplate.setValueSerializer(redisSerializerUtil);
                redisTemplate.setHashValueSerializer(redisSerializerUtil);
                ValueOperations valueOperations = redisTemplate.opsForValue();
                valueOperations.set("xx",token,3000, TimeUnit.SECONDS);

附上序列化工具类

public class RedisSerializerUtil implements RedisSerializer<Object> {
        private final Charset charset;

        public RedisSerializerUtil() {
            this(Charset.forName("UTF8"));
        }

        public RedisSerializerUtil(Charset charset) {
            Assert.notNull(charset, "Charset must not be null!");
            this.charset = charset;
        }

        @Override
        public byte[] serialize(Object object) throws SerializationException {

            return object == null ? null : SerializeUtil.serialize(object);
        }

        @Override
        public Object deserialize(byte[] bytes) throws SerializationException {
            return bytes == null ? null : SerializeUtil.unserialize(bytes);
        }
    }

这样就和上面的jedis序列化一样了,就可以取了
一点,用完后记得还原默认的序列化方式

     RedisSerializerUtil redisSerializerUtil = new RedisSerializerUtil();
                redisTemplate.setKeySerializer(redisSerializerUtil);
                redisTemplate.setHashKeySerializer(redisSerializerUtil);
                redisTemplate.setValueSerializer(redisSerializerUtil);
                redisTemplate.setHashValueSerializer(redisSerializerUtil);
                ValueOperations valueOperations = redisTemplate.opsForValue();
                valueOperations.set("xx",token,3000, TimeUnit.SECONDS);
                StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
                redisTemplate.setKeySerializer(stringRedisSerializer);
                redisTemplate.setHashKeySerializer(stringRedisSerializer);
                redisTemplate.setValueSerializer(stringRedisSerializer);
                redisTemplate.setHashValueSerializer(stringRedisSerializer);

问题！！！

线上发布后，发现和RedisConfig

 @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<String,
                Object>();
        template.setConnectionFactory(redisConnectionFactory);
        // Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new
                Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // String 的序列化
        StringRedisSerializer stringRedisSerializer = new
                StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }

两边序列化不一样，然后线上用的定时刷新字典炸了！！！抢救了1个多小时。我的天

注意序列化一定要一致

第二版代码类似，只是把序列化一致了，线上没出现问题。但是不能心存侥幸，因为有可能在设置序列化后还没来得及换回原来的方式，这个时间节点，可能会执行刷新字典的方法，这个时候还是会出现问题！！！

后来经过高人指点，配置两个redisTemplate也就隔离开，最终代码

@Configuration
@EnableCaching //开启注解
public class RedisConfig extends CachingConfigurerSupport {
    //编写redisTemplate
    @Bean
    @SuppressWarnings("all")
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<String,
                Object>();
        template.setConnectionFactory(redisConnectionFactory);
        // Json序列化配置
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new
                Jackson2JsonRedisSerializer(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        // String 的序列化
        StringRedisSerializer stringRedisSerializer = new
                StringRedisSerializer();
        // key采用String的序列化方式
        template.setKeySerializer(stringRedisSerializer);
        // hash的key也采用String的序列化方式
        template.setHashKeySerializer(stringRedisSerializer);
        // value序列化方式采用jackson
        template.setValueSerializer(jackson2JsonRedisSerializer);
        // hash的value序列化方式采用jackson
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        return template;
    }



    @Bean(name = "SerializeRedisTemplate")
    public RedisTemplate<String, Object> getRedisTemplate1(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<String, Object> template = new RedisTemplate<String,
                Object>();
        template.setConnectionFactory(redisConnectionFactory);
        // Json序列化配置

        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        RedisSerializerUtil redisSerializerUtil = new RedisSerializerUtil();
        template.setKeySerializer(redisSerializerUtil);
        template.setHashKeySerializer(redisSerializerUtil);
        template.setValueSerializer(redisSerializerUtil);
        template.setHashValueSerializer(redisSerializerUtil);
        return template;
    }
}

这样就隔离开来了

  @Resource(name = "SerializeRedisTemplate")
    private RedisTemplate serializeRedisTemplate;


         redisTemplate.opsForValue().set("xx", token, 60 * 40, TimeUnit.SECONDS);
                serializeRedisTemplate.opsForValue().set("xx", token, 60 * 40, TimeUnit.SECONDS);

网上找的比较全的配置

package com.example.config;
 
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.jedis.JedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
 
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
 
import redis.clients.jedis.JedisPoolConfig;
 
@Configuration
@EnableAutoConfiguration
public class RedisConfig {
 
    private static Logger logger = LoggerFactory.getLogger(RedisConfig.class);
 
    @Bean
    @ConfigurationProperties(prefix="spring.redis")
    public JedisPoolConfig getRedisConfig(){
        JedisPoolConfig config = new JedisPoolConfig();
        return config;
    }
 
    @Bean
    @ConfigurationProperties(prefix="spring.redis")
    public JedisConnectionFactory getConnectionFactory(){
        JedisConnectionFactory factory = new JedisConnectionFactory();
        JedisPoolConfig config = getRedisConfig();
        factory.setPoolConfig(config);
        logger.info("JedisConnectionFactory bean init success.");
        return factory;
    }
 
    @Bean
    public RedisTemplate<?, ?> getRedisTemplate(){
        RedisTemplate<?,?> template = new StringRedisTemplate(getConnectionFactory()); //只能对字符串的键值操作
        System.out.println("生成<?,?>template:" + template);
        return template;
    }
    
    @Bean(name = "LongRedisTemplate")
    public RedisTemplate<String, Long> getRedisTemplate1(){
        RedisTemplate<String,Long> template = new RedisTemplate<String,Long>(); //只能对字符串的键值操作
        template.setConnectionFactory(getConnectionFactory());
    
     // 使用Jackson2JsonRedisSerialize 替换默认序列化(默认采用的是JDK序列化)
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        
        template.setKeySerializer(jackson2JsonRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        
        System.out.println("生成<String, Long>template:" + template);
        return template;
    }
    
    @Bean(name = "StringRedisTemplate")
    public RedisTemplate<String, String> getRedisTemplate2(){
        RedisTemplate<String,String> template = new RedisTemplate<String,String>(); //只能对字符串的键值操作
        template.setConnectionFactory(getConnectionFactory());
        
        // 使用Jackson2JsonRedisSerialize 替换默认序列化(默认采用的是JDK序列化)
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        
        template.setKeySerializer(jackson2JsonRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        
        System.out.println("生成<String, String>template:" + template);
        return template;
    }
    
    @Bean(name = "IntegerRedisTemplate")
    public RedisTemplate<String, Integer> getRedisTemplate3(){
        RedisTemplate<String,Integer> template = new RedisTemplate<String,Integer>(); //只能对字符串的键值操作
        template.setConnectionFactory(getConnectionFactory());
    
     // 使用Jackson2JsonRedisSerialize 替换默认序列化(默认采用的是JDK序列化)
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
        
        template.setKeySerializer(jackson2JsonRedisSerializer);
        template.setValueSerializer(jackson2JsonRedisSerializer);
        template.setHashKeySerializer(jackson2JsonRedisSerializer);
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
        template.afterPropertiesSet();
        
        System.out.println("生成<String,Integer>template:" + template);
        return template;
    }
}

import java.util.Set;
 
import javax.annotation.Resource;
 
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.SetOperations;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class RedisController {
	
	@Resource(name = "StringRedisTemplate")
	private RedisTemplate<String, String> stringRedisTemplate;
	
	@Resource(name = "LongRedisTemplate")
	private RedisTemplate<String, Long> longRedisTemplate;
	
	@Resource(name = "IntegerRedisTemplate")
	private RedisTemplate<String, Integer> integerRedisTemplate;
	
	@RequestMapping(value = "/redis")
	public String testRedis() {
		System.out.println("stringRedisTemplate:" + stringRedisTemplate);
		System.out.println("longRedisTemplate:" + longRedisTemplate);
		System.out.println("integerRedisTemplate:" + integerRedisTemplate);
		testStringRedis();
		testLongRedis();
		testIntegerRedis();
		return "成功！";
	}
	
	private void testStringRedis() {
		SetOperations<String, String> set = stringRedisTemplate.opsForSet(); //保存Set
		set.add("set1","22");  
		set.add("set1","33");  
		set.add("set1","33");  
		Set<String> resultSet =stringRedisTemplate.opsForSet().members("set1"); //获取Set
		System.out.println("resultSet:"+resultSet); 
	}
	
	private void testLongRedis() {
		SetOperations<String, Long> set = longRedisTemplate.opsForSet();
		set.add("set2",22L);  
		set.add("set2",22L);  
		set.add("set2",23L);  
		Set<Long> resultSet =longRedisTemplate.opsForSet().members("set2");  
		System.out.println("resultSet:"+resultSet); 
	}
	
	private void testIntegerRedis() {
		SetOperations<String, Integer> set = integerRedisTemplate.opsForSet();
		set.add("set3",222);  
		set.add("set3",333);  
		set.add("set3",555);  
		Set<Integer> resultSet =integerRedisTemplate.opsForSet().members("set3");  
		System.out.println("resultSet:"+resultSet); 
	}
	
}
Ybb_studyRecord
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
jedis-2.9.0-API文档-中英对照版.zip
04-07
赠送jar包：jedis-2.9.0.jar 赠送原API文档：jedis-2.9.0-javadoc.jar 赠送源代码：jedis-2.9.0-sources.jar 包含翻译后的API文档：jedis-2.9.0-javadoc-API文档-中文(简体)-英语-对照版.zip 对应Maven信息：groupId：redis.clients，artifactId：jedis，version：2.9.0 使用方法：解压翻译后的API文档，用浏览器打开“index.html”文件，即可纵览文档内容。 人性化翻译，文档中的代码和结构保持不变，注释和说明精准翻译，请放心使用。 双语对照，边学技术、边学英语。
jedis-3.2.0.jar + commons-pool2-2.6.2.jar
09-23
jedis-3.2.0+commons-pool2-2.6.2，该版本的jedis可以使用bitfield 属性，低于该版本没有该属性。
jedis-2.7.2+commons-pool-1.6.zip
09-24
将以下jar包导入jmeter\lib目录下 jedis-2.2.1.jar commons-pool-1.6.jar 注：需要重启Jmeter才会生效； commons-pool.jar包是一款常用在java开发内的进行java数据库连接池的框架常用包，如果您想对java开发进行数据库连接池，可以前来下载这款commons-pool.jar包使用。
Springboot+redis(Jedis和RedisTemplate)+CRUD
Selenium的博客
05-29 4683
talk is cheap,show you my code 方法一:使用jedis(Jedis是Redis官方推荐的面向Java的操作Redis的客户端,详细文档可见jedis文档) 0.当然，首先你要先安装redis数据库,不会安装的自行百度(ubuntu:apt-get install redis-server) 1.创建Springboot项目 2.在pom文件中导入jedis和fastj...
Jedis异常问题处理
最新发布
深圳市多克创新科技有限公司
10-16 598
Jedis常见问题汇总
spring-data-redis 与jedis jar包不兼容导致stringRedisTemplate 用scan命令报错NoSuchMethodError
sky198989的博客
03-01 424
转载：https://blog.csdn.net/zgc978823534/article/details/103368127
springboot2.0以上版本 使用 Jedis 和 Template 两种方式连接redis
追风筝的人博客
03-29 2043
首先我们要知道，Springboot整合Redis有两种方式，分别是Jedis和RedisTemplate，这两者有何区别？ Jedis是Redis官方推荐的面向Java的操作Redis的客户端，而RedisTemplate是SpringDataRedis中对JedisApi的高度封装。其实在Springboot的官网上我们也能看到，官方现在推荐的是SpringDataRedis形式，相对于Je...
redisTemplate解决序列化问题
阿巴阿巴……
08-04 2950
解决redis序列化问题，学习StringRedisTemplate
混用StringRedisTemplate和RedisTemplate，同时使用@Autowired和@Resource。导致序列化不一致问题
小净的博客
04-28 1435
简单记录下重构项目遇到的坑。 问题描述： 数据存入redis后，反序列化操作时报错。业务层引用其他业务层，此时其他业务层通过@Autowired注入了【RedisTemplate】，将数据存入redis。但是查询业务时，最先注入的是【StringRedisTemplate】。导致反序列化失败。 一、@Autowired和@Resource区别： @Resource装配顺序 　　1. 如果同时指定name和type，则从Spring上下文中找到唯一匹配的bean进行装配 　　2. 如果只指定name，则从上
使用Java操作Redis的两种方式Jedis、RedisTemplate
扎哇太枣糕的笔记博客
05-08 3867
  各位小伙伴们大家好，欢迎来到这个小扎扎的Redis 6专栏，在这个系列专栏中我对B站尚硅谷的Redis教程进行一个总结，鉴于 看到就是学到、学到就是赚到 精神，这波依然是血赚 ┗|｀O′|┛
jedis-2.9.0和commons-pool2
11-12
里面包含了jedis相关的两个jar包。jedis-2.9.0和commons-pool2.4.3.2
jedis-2.9.0.jar和mongo-java-driver-3.0.2.jar
04-02
jedis-2.9.0.jar和mongo-java-driver-3.0.2.jar包下载！
关于RedisTemplate和StringRedisTemplate不能共用的问题剖析
保护我方程序员
10-13 1384
近期在开发中遇到了这样一个问题，起初为了方便起见，使用StringRedisTemplate来操作redis，后来采用RedisTemplate去取值的时候，发现无法拿到值，具体的业务场景我用一个案例来描述。 @Autowired private StringRedisTemplate stringRedisTemplate; @Autowired private RedisTemplate redisTemplate; @Test void contextLoa
关于redis序列化的问题
Gj1999的博客
03-31 1339
工作中遇到一个reids序列化问题，当你存储map的时候，传统的：GenericJackson2JsonRedisSerializer jsonRedisSerializer = new GenericJackson2JsonRedisSerializer(); // 采用Json序列化 redisTemplate.setHashValueSerializer(jsonRedisSerializer); redisTemplate.setValueSerializer(jsonRedisSerializer
多个应用公用一个redis，如何隔离数据
热门推荐
zlt的博客
05-23 1万+
多个应用公用一个redis，如何隔离数据 Redis单机支持多个数据库，并且每个数据库的数据是隔离的不能共享。Redis集群就没有数据库的概念，不支持多数据库。 Redis单机默认支持16个数据库（可以通过配置文件支持更多，无上限），db0、1……15,以编号命名，名字不可修改。 Redis单机不支持为每个数据库设置不同的访问密码，所以一个客户端要么可以访问全部数据库，要么连一个数据库也没有权限...
Springboot 使用 Jedis、RedisTemplate 整合 Redis 实现并发锁
weixin_44605704的博客
07-19 3481
代码实现 1、maven依赖pom.xml <!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data...
redis 序列化id不一致时怎么处理
零零落落的博客
02-20 1098
1 将存储某个序列化的java对象的序列化id手动设置上 private static final long serialVersionUID = 1L; 2 在代码设置序列号后，问题解决。 以下是我的关于腾讯云redis操作遇到的几个问题： 3 腾讯云redis上keys ,flushdb操作等有些可能被禁用了，可查看官方文档 4 redis desktopmanager客...
Java如何使用redis：Jedis和RedisTemplate
qq_34826261的博客
05-07 3168
本文详细介绍了Java使用redis的两种方式：Jedis和RedisTemplate的详细配置和使用。其中Jedis提供了各个数据类型的操作方法；RedisTemplate介绍了如何配置redis，以配置类的方式进行结合，提供了一个封装类RedisUtil更好的使用RedisTemplate，并且详细介绍了RedisTemplate的序列化问题(解决RedisTemplate前缀问题)。
对接海康威视监控-hls实现h5播放
m0_46690280的博客
10-19 8993
对接海康威视监控-hls实现h5播放前戏联系海康和对接方最后一步配置格式--成功附上对接文档和html 前戏 活干着干着突然老大丢给我一个css文件，说是改吧成Java的 public class OnLineVideoController { private static String appkey = "xx"; private static String secret = "xxx"; private static String ip = "36.26.24.126";
jedis和redistemplate
08-17
RedisTemplate支持事务操作、管道操作、序列化和反序列化等功能，并且可以与Spring中的其他组件无缝集成。 总的来说，Jedis更加底层和灵活，适合对Redis的原生命令进行直接操作；而RedisTemplate则是在Jedis基础之...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值