java使用spring配置jedis及jedis测试

最新推荐文章于 2022-12-06 14:45:19 发布
最新推荐文章于 2022-12-06 14:45:19 发布
阅读量2.1k 收藏 5
点赞数 1
分类专栏： redis 文章标签： spring redis java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/github_38924695/article/details/78721938
版权

之前项目使用spring进行注入redis，连接需要每调用一次进行连接，所以代码改成直接通过spring初始化连接池，并封装基本的jedis操作，写了一个测试，将医师所有的信息放在hash中，医师信息使用json保存，men集合存放的是性别为男的医师id，women为性别为女的医师，organ集合中存放不同机构下的医师id。查询某机构下的男医师，只需要求该机构和男医师两个set的交集，在hash中查询便可获取数据。具体代码如下：
redis.config中配置：

##redis数据库的相关配置
##连接地址ip
redis.addr = ip
##端口号
redis.port = 6379
##访问密码
redis.auth = 密码
##控制一个pool最多可以有多少个状态为Idle(空)的jedis实例默认值为8
redis.maxIdle = 200
##可用的最大连接实例数 默认为8
redis.maxActive = 1024
##等待可用连接的最大时间单位为毫秒  默认为-1表示永不超时，一旦超过等待时间则直接抛出
redis.maxWait = 10000
redis.timeOut = 10000
##设置为true则会在borrow一个jedis实例时，提前做validate操作
redis.testOnBorrow =true
##连接最小空闲时间(毫秒)
redis.minEvictableIdleTimeMillis=1800000
##释放连接的扫描间隔（毫秒）
redis.timeBetweenEvictionRunsMillis=30000
##每次释放连接的最大数目
redis.numTestsPerEvictionRun=1024
##最大连接数
redis.maxTotal=30
##在空闲时检查有效性, 默认false 
redis.testWhileIdle=true
##连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true
redis.blockWhenExhausted=false

applicationContext.xml中代码：

<context:property-placeholder location="classpath:redis.properties" />
<!-- redis连接池配置 -->
    <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <!-- 最大连接数 -->
        <property name="maxTotal" value="${redis.maxTotal}"/>
        <!-- 最大空闲连接数 -->
        <property name="maxIdle" value="${redis.maxIdle}"/>
        <!-- 每次释放连接的最大数目 -->
        <property  name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}"/>
        <!-- 释放连接的扫描间隔（毫秒） -->
        <property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}"/>
        <!-- 连接最小空闲时间 -->
        <property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}"/>
        <!-- 连接空闲多久后释放, 当空闲时间>该值且空闲连接>最大空闲连接数时直接释放 -->
        <property name="softMinEvictableIdleTimeMillis" value="10000"/>
        <!-- 获取连接时的最大等待毫秒数,小于零:阻塞不确定的时间,默认-1 -->
        <property name="maxWaitMillis" value="${redis.maxWait}"/>
        <!-- 在获取连接的时候检查有效性, 默认false -->
        <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
        <!-- 在空闲时检查有效性, 默认false -->
        <property name="testWhileIdle" value="${redis.testWhileIdle}"/>
        <!-- 连接耗尽时是否阻塞, false报异常,ture阻塞直到超时, 默认true -->
        <property name="blockWhenExhausted" value="${redis.blockWhenExhausted}"/>
    </bean>
    <!-- redis连接 -->
    <bean id="jedisPool" class="redis.clients.jedis.JedisPool"
        destroy-method="close">
           <constructor-arg index="0" ref="jedisPoolConfig"/>  
          <constructor-arg index="1" value="${redis.addr}"/>  
          <constructor-arg index="2" value="${redis.port}" type="int"/>  
          <constructor-arg index="3" value="${redis.timeOut}" type="int"/>  
          <constructor-arg index="4" value="${redis.auth}"/>  
    </bean>

basicRedisDao中封装基本的jedis操作

package com.wellness.platfront.common.util;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.annotation.Resource;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;

import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

/**
 * 用于连接redis的基本操作类
 * @author 
 * @since 2017/11/21
 */
@Service("basicRedisDao")
public class BasicRedisDao{
    //通过spring注入jedisPool
    @Resource
    private  JedisPool jedisPool;
    private Jedis jedis;
    private static Map<String, String> map;
    /**
     * 获取jedis
     * @return
     */
    public Jedis getJedis(){
        if (jedis == null) {
            jedis = jedisPool.getResource();
        }
        return jedis;
    }

    /**
     * 清空数据库
     */
    public void flushDB(){
        jedis = getJedis();
        if (jedis !=null ) {
            jedis.flushDB();
        }
    }
    /**
     * 保存string的数据
     */
    public  void saveString(String key,String value){
        jedis = getJedis();
        if (jedis!=null) {
            jedis.set(key, value);
        }
    }
    /**
     * 删除某个键
     */
    public  void removeKey(String key){
        jedis = getJedis();
        if (jedis!=null) {
            jedis.del(key);
        }
    }
    /**
     * 设置某个带时间的key
     */
    public  void saveTimeKey(String key,String value,int seconds){
        jedis = getJedis();
        if (jedis!=null) {
            jedis.setex(key, seconds, value);
        }
    }
    /**
     * 查询某个key是否存在
     */
    public  Boolean existKey(String key){
        jedis = getJedis();
        if (jedis!=null) {
            return jedis.exists(key);
        }else {
            return null;
        }
    }
    /**
     * 更新某个key并返回原来的值
     */
    public  String updateKey(String key,String value){
        jedis = getJedis();
        if (jedis!=null) {
            String old = jedis.getSet(key, value);
            return old;
        }
        return null;
    }
    /**
     * 往某个hash表中存放数据
     */
    public  void hset(String key,String field,String value){
        jedis = getJedis();
        if (jedis != null) {
            jedis.hset(key, field, value);
        }
    }
    /**
     * 获取某个hash中的所有filed和value
     */
    public  Map<String, String> getHashValues(String key){
        jedis = getJedis();
        map = new HashMap<String, String>();
        if (jedis != null ) {
            map = jedis.hgetAll(key);
        }
        return map;
    }
    /**
     * 判断hash中某个field是否已经存在
     */
    public  Boolean existsField(String key,String field){
        jedis = getJedis();
        Boolean hexists = null;
        if (jedis != null) {
            hexists = jedis.hexists(key, field);
        }
        return  hexists;
    }
    /**
     * 删除hash中的某个field
     */
    public  void removeField(String key,String field){
        jedis = getJedis();
        if (jedis!=null) {
            jedis.hdel(key, field);
        }
    }
    /**
     * 获取hash中某个field的值
     */
    public  String getHashFieldValue(String key,String field){
        jedis = getJedis();
        if (jedis !=null) {
            return jedis.hget(key, field);
        }
        return null;
    }
    /**
     * 查询hash中的所有filed
     */
    public  Set<String> getFields(String key){
        jedis = getJedis();
        if (jedis != null ) {
            return jedis.hkeys(key);
        }
        return null;
    }
    /**
     * 获取key中一个或多个field的值
     */
    public  List<String> hmgets(String key,String fields[]){
        jedis = getJedis();
        if (jedis != null && fields != null && fields.length >0) {
                return jedis.hmget(key, fields);
        }
        return null;
    }
    /**
     * 同时存入多个field到某个key中
     */
    public  void hmset(String key,Map<String, String> map){
        jedis = getJedis();
        if (jedis != null) {
            jedis.hmset(key, map);
        }
    }

    /**
     * 往集合中压数据(多条数据用空格隔开)
     */
    public  void saveList(String key,String value){
        jedis = getJedis();
        if (jedis != null) {
            jedis.lpush(key, value);
        }
    }
    /**
     * 取出集合中的所有元素
     */
    public  List<String> getListAllValues(String key){
        jedis = getJedis();
        if (jedis != null) {
            List<String> lrange = jedis.lrange(key, 0, -1);
            return lrange;
        }
        return null;
    }
    /**
     * 获取两个集合的交集
     */
    public  Set<String> getSinter(String set1,String set2){
        jedis = getJedis();
        if (jedis != null ) {
            return jedis.sinter(set1,set2);
        }
        return null;
    }
    /**
     * 向集合中添加多条数据
     */
    public  void sadd(String key,String member[]){
        jedis = getJedis();
        if (jedis != null ) {
            jedis.sadd(key, member);
        }
    }
    /**
     * 向集合中添加单条数据
     */
    public  void sadd(String key,String member){
        jedis = getJedis();
        if (jedis != null ) {
            jedis.sadd(key, member);
        }
    }
    /**
     * 判断member是否为某个集合的元素
     */
    public Boolean sismember(String key,String member){
        jedis = getJedis();
        if (jedis != null ) {
            return jedis.sismember(key, member);
        }
        return null;
    }

    /**
     * 删除hash中的某个field
     */
    public void hdel(String key,String field){
        jedis = getJedis();
        if (jedis != null ) {
             jedis.hdel(key, field);
        }
    }

    /**
     * 删除set中的某个member
     */
    public void srem(String key,String member){
        jedis = getJedis();
        if (jedis != null ) {
             jedis.srem(key, member);
        }
    }

}

RedisService中为具体的操作：保存对象时应当封装vo进行保存，因为这里只是测试，所以没有封装。

package com.wellness.platfront.common.redis;
/**
 * 具体redis业务的service
 * @author yangfuren
 * @Since 2017/12/05
 */
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;

import com.alibaba.fastjson.JSON;
import com.wellness.platfront.common.util.BasicRedisDao;
import com.wellness.platfront.entity.physician.doctor.DoctorAccount;

@Service("redisService")
public class RedisService {
    @Resource
    private BasicRedisDao basicRedisDao;
    public void flushDb(){
        basicRedisDao.flushDB();
    }
    /**
     * 获取organ集合和性别集合的交集
     */
    public List<String> getDoctorByOrganAndSex(String organId,String sex){
        List<String> sinters = new ArrayList<>();
        String doctorSex = null ;
        if (sex.equals("男")) {
            doctorSex= "man";
        }else if (sex.equals("女")) {
            doctorSex= "women";
        }
        Set<String> sinter = basicRedisDao.getSinter("organ"+organId, doctorSex);
        if (sinter !=null) {
            sinters.addAll(sinter);
        }
        return sinters;
    }
    /**
     * 根据id查询所有的医师
     */
    public List<Object> getDoctorAccount(String organId,String sex){
        List<String> doctorId = getDoctorByOrganAndSex(organId,sex);
        List<Object> doctorAccounts = new ArrayList<>();
        //将list转成数组
        String doctorIds[] = doctorId.toArray(new String[doctorId.size()]);
        if (doctorIds != null && doctorIds.length > 0) {
            List<String> hmget = basicRedisDao.hmgets("doctorAlls", doctorIds);
            //将查询出来的json串转成对象放入集合中
            if (hmget != null && hmget.size() > 0) {
                for (String string : hmget) {
                    doctorAccounts.add(JSON.parse(string));
                }
            }
        }
        return doctorAccounts;
    }
    /**
     * 将医师的信息存放到map
     */
    public void saveDoctors(List<DoctorAccount> doctorAccounts){
            Map<String,String> map1 = new HashMap<>();
            for (int i = 0; i < doctorAccounts.size(); i++) {
                map1.put(String.valueOf(doctorAccounts.get(i).getDoctorId()), JSON.toJSONString(doctorAccounts.get(i)));
                basicRedisDao.hmset("doctorAlls", map1);
        }
    }

    /**
     * 将所有的机构查询出来放入set中
     */
    public void saveOrgan(List<DoctorAccount> doctorAccounts,String organId){
            if (doctorAccounts != null && doctorAccounts.size() > 0 ) {
                List<String> doctorIds = new ArrayList<>();
                for (int j = 0; j < doctorAccounts.size(); j++) {
                    doctorIds.add(String.valueOf(doctorAccounts.get(j).getDoctorId()));
                }
                String doctorId[] = doctorIds.toArray(new String[doctorIds.size()]);
                basicRedisDao.sadd(organId, doctorId);
        }
    }

    /**
     * 按性别保存医师 1 男 2 女
     */
    public void savedoctorBySex(List<DoctorAccount> doctorAccounts,
            String sex) {
            if (doctorAccounts != null && doctorAccounts.size() > 0) {
                List<String> doctorIds = new ArrayList<>();
                for (int j = 0; j < doctorAccounts.size(); j++) {
                    doctorIds.add(String.valueOf(doctorAccounts.get(j)
                            .getDoctorId()));
                }
                String doctorId[] = doctorIds.toArray(new String[doctorIds
                        .size()]);
                basicRedisDao.sadd(sex, doctorId);
        }
    }
    /**
     * 更新医师信息  先用一次删除在调用新增
     */
    public void uploadDoctor(DoctorAccount doctorAccount){
            basicRedisDao.hset("doctorAlls", String.valueOf(doctorAccount.getDoctorId()), JSON.toJSONString(doctorAccount));
            if (!basicRedisDao.sismember("organ"+doctorAccount.getDoctorBasicInfo().getOrgan().getOrgan_id(), String.valueOf(doctorAccount.getDoctorId()))) {
                basicRedisDao.sadd("organ"+doctorAccount.getDoctorBasicInfo().getOrgan().getOrgan_id(), String.valueOf(doctorAccount.getDoctorId()));
            }
    }
    /**
     * 删除医师信息
     */
    public void removeDoctor(DoctorAccount doctorAccount){
          basicRedisDao.hdel("doctorAlls", String.valueOf(doctorAccount.getDoctorId()));
          basicRedisDao.srem("organ"+doctorAccount.getDoctorBasicInfo().getOrgan().getOrgan_id(), String.valueOf(doctorAccount.getDoctorId()));
    }
    /**
     * 新增医师信息
     */
    public void saveDoctor(DoctorAccount doctorAccount){
        basicRedisDao.hset("doctorAlls",String.valueOf(doctorAccount.getDoctorId()), JSON.toJSONString(doctorAccount));
        basicRedisDao.sadd("organ"+doctorAccount.getDoctorBasicInfo().getOrgan().getOrgan_id(), String.valueOf(doctorAccount.getDoctorId()));
    }

}

测试的RedisAction代码：

package com.wellness.platfront.physician.redis;

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.Namespace;

import com.wellness.platfront.business.doctor.service.IOrganService;
import com.wellness.platfront.business.physician.doctor.DoctorAccountService;
import com.wellness.platfront.common.redis.RedisDbUtils;
import com.wellness.platfront.common.redis.RedisService;
import com.wellness.platfront.common.util.SerializaUtil;
import com.wellness.platfront.common.util.Struts2Utils;
import com.wellness.platfront.entity.doctor.Organ;
import com.wellness.platfront.entity.physician.doctor.DoctorAccount;
import com.wellness.platfront.outInterface.util.MsgCode;

@Namespace("/redisTest")
@SuppressWarnings("unused")
public class RedisAction {
    @Resource
    private DoctorAccountService doctorAccountService;
    @Resource
    private IOrganService iOrganService;
    private Map<String, String> map = new HashMap<String, String>();
    Map<String, Object> msg = new HashMap<String, Object>();
    @Resource(name="redisService")
    private RedisService redisService;
    @Action("saveDoctor")
    public String saveDoctor() {
        List<DoctorAccount> doctors = doctorAccountService.listAllDoctor();
        redisService.saveDoctors(doctors);
        List<DoctorAccount> doctorAccounts = doctorAccountService
                .listDoctorBySex("男");
        redisService.savedoctorBySex(doctorAccounts, "man");
        List<DoctorAccount> doctorAccounts2 = doctorAccountService
                .listDoctorBySex("女");
        redisService.savedoctorBySex(doctorAccounts2, "women");
        List<Organ> organs = iOrganService.listOrgan();
        for (int i = 0; i < organs.size(); i++) {
            List<DoctorAccount> doctorAccounts3 = doctorAccountService
                    .getDoctorAccountsByOrganId(organs.get(i).getOrgan_id());
            redisService.saveOrgan(doctorAccounts3,
                    "organ" + String.valueOf(organs.get(i).getOrgan_id()));
        }
        return null;
    }

    @Action("selectDoctor")
    public String selectDoctor() {
        String organId = Struts2Utils.getRequest().getParameter("organId");
        String doctorSex = Struts2Utils.getRequest().getParameter("sex");
        List<Object> doctorAccount = redisService.getDoctorAccount(organId,
                doctorSex);
        msg.put("doctorAccount", doctorAccount);
        Struts2Utils.renderJson(msg);
        return null;
    }
}

调用action中的方法就可以保存和查询，因为只是测试，所以代码并不完善，其中的action方法测试能够使用。
以上代码频繁调用会出现java.net.SocketException: Broken pipe
redis.clients.jedis.exceptions.JedisConnectionException: java.net.SocketException: Broken pipe
后来修改将redisdao去掉，直接在service中使用jedis调用，在使用完后及时释放jedis并加线程同步：

    @Resource
    private JedisPool jedisPool;
    private Jedis jedis;
    /**
     * 判断医师是否已被冻结
     */
    public synchronized Boolean isPerssion(String doctorId){
        Boolean perssion = null;
        if (jedisPool != null ) {
                try {
                    jedis = jedisPool.getResource();
                    if (doctorId != null) {
                        perssion = jedis.sismember("NoPerssion", doctorId);
                        jedis.close();;
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                    throw new BasicRuntimeException(this, "redis判断医师是否已被冻结异常" + e.getMessage());
                }
            }
        return perssion;
    }
蓝色格子
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java Jedis NOAUTH Authentication required问题解决方法
08-25
主要介绍了Java Jedis NOAUTH Authentication required问题解决方法,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
java如何检测redis是否可用
学英语的程序员
09-23 2907
java项目如何检测redis是否可用
Jedis和Lettuce的区别
xiaohuangren_123的博客
12-06 997
redis客户端
SpringBoot项目Redis两种实现Lettuce和Jedis比较
wangpf2011的博客
05-31 8752
Jedis是直连模式，在多个线程间共享一个Jedis实例时是线程不安全的，可以通过创建多个Jedis实例来解决，但当连接数量增多时，物理连接成本就较高同时会影响性能，因此较好的解决方法是使用JedisPool。 Lettuce的连接是基于Netty的，连接实例可以在多个线程间共享，Netty可以使多线程的应用使用同一个连接实例，而不用担心并发线程的数量。通过异步的方式可以让我们更好地利用系统资源。 1、Jedis集成使用 1.1、pom.xml中添加redis相关依赖 <dependen
SpringBoot或Maven整合测试 Redis是否连接
qq_42030549的博客
05-20 1612
用Java代码使用Jedis操作Redis <!-- Jedis依赖 --> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>3.6.3</version> </dependency> 1、注销掉bind 127.0.0.1 #本机访问安全模式不带
IDEA测试Jedis
qq_51058681的博客
09-07 130
1、先在IDEA中创建maven工程 2、导入Jedis依赖 <!--jedis的相关依赖--> <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>3.2.0</version>
Redis集群的高可用测试（含Jedis客户端的使用）
weixin_33882452的博客
12-01 192
Redis集群的使用测试（Jedis客户端的使用）1、 Jedis客户端建议升级到最新版（当前为2.7.3），这样对3.0.x集群有比较好的支持。https://github.com/xetorthio/jedishttp://mvnrepository.com/artifact/redis.clients/jedis2、 直接在Java代码中链接Redis集群：// ...
Redis创建连接池与测试使用
m0_51392342的博客
02-16 396
连接池的创建 package com.jt.redis; import org.apache.commons.pool2.impl.GenericObjectPoolConfig; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; public class JedisDataSource { /** * Jedis连接池对象 * volatile 关键字作用 * 1）
使用jedis测试连接操作redis
Aaryn30的博客
11-09 2143
package cn.jedis; import org.junit.Test; import redis.clients.jedis.Jedis; import redis.clients.jedis.JedisPool; import redis.clients.jedis.JedisPoolConfig; /** * Jedis的测试 * @author Administrator
使用Jedis操作redis数据库（SpringBootTest）
weixin_45060598的博客
01-15 278
1.引入依赖 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>3.7.1</version> </dependency> 2.编写测试代码 public class MyJedis { public static void main(String[
spring boot + jedis
08-31
spring boot集成redis,使用redis官网推荐java语言jedis操作
spring_redis集成（jedis java客户端）
08-29
spring_redis集成，通过jedis作为redis的客户端。 只提供集成方式，具体api，参照jedis API
applicationContext-jedis.xml
04-05
Jedis是Redis官方推荐的Java连接开发工具。Redis（Remote Dictionary Server )，即远程字典服务，是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API...
redis-demo:Redis学习项目，包括1)Redis笔记；2)Jedis的基本使用；3）Spring Data Redis的基本使用（基于SpringBoot）
05-19
1 NoSQL 1.1 需求 高并发读写 海量数据的高效率存储与访问 高可扩展性和高可用性 1.2 产品分类 分类 代表产品 典型应用场景 数据模型 ...Tokyo Cabinet/Tyrant, Redis, Voldemort, Oracle BDB 内容缓存，主要用于处理...
springboot链redis出现 java.io.IOException: 远程主机强迫关闭了一个现有的连接
热门推荐
蓝色格子ren的博客
10-18 3万+
使用springboot2.0链接redis时候，出现以下错误： org.springframework.data.redis.RedisSystemException: Redis exception; nested exception is io.lettuce.core.RedisException: java.io.IOException: 远程主机强迫关闭了一个现有的连接。 at or...
JedisCluster连接redis集群(有密码)
蓝色格子ren的博客
03-16 1万+
redis集群是通过redis-trib.rb方式构建，在连接之前需要导入Jedis包 1.配置文件 ###############################redis数据库的相关配置################################## ##访问密码 redis.auth = yangfuren ##控制一个pool最多可以有多少个状态为Idle(空)的jedis实例...
java使用jedis连接redis
蓝色格子ren的博客
11-22 733
在安装好redis后需要修改redis.conf的几个配置： #requirepass foobared //将#删除并将foobared改成自己密码 bind 127.0.0.1(bind localhost) //将其注释掉，否则只能允许本机访问 daemonize yes //将其改为no 这样当启动redis服务后，
Redis中 MISCONF Redis is configured to save RDB snapshots, but is currently not able to persist
蓝色格子ren的博客
12-06 729
在向redis中加入大量数据（我是60w）时，会报MISCONF Redis is configured to save RDB snapshots, but is currently not able to persist on disk错误. Redis被配置为保存数据库快照，但它目前不能持久化到硬盘。用来修改集合数据的命令不能用。请查看Redis日志的详细错误信息. 出现这
spring集成jedis
最新发布
09-15
2. 在你的Spring Boot应用程序中，创建一个Redis配置类，用于配置Jedis连接池和Redis连接属性。这个类可以如下所示： ```java @Configuration public class RedisConfig { @Value("${spring.redis.host}") ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值