[Redis]spring 配置 cache 缓存使用 ConcurrentMap EhCache Redis

最新推荐文章于 2024-08-16 18:05:23 发布
最新推荐文章于 2024-08-16 18:05:23 发布
阅读量2.3k 收藏 2
点赞数 2
分类专栏： Spring 文章标签： spring cache spring-data-redis ConcurrentMap GenericJackson2JsonRedisSerial Redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hkk666123/article/details/80177284
版权

spring cache 总结

    作用:  保证数据时效性的前提下, 提高查询效率; 减少查询数据库的次数, 减轻数据库压力;

    原理:  基于Proxy/AspectJ动态代理技术的AOP思想(面向切面编程), 在不改变目标方法的前提下在其切面进行缓存的增删改查(在服务方法执行前查询缓存, 在服务方法执行后添加缓存, 或者清除缓存);

    用法: 

        1. spring cache实现有基于XML/注解实现AOP;

        2. CacheManager负责对缓存的增删改查, CacheManager的缓存的介质可配置, 如: ConcurrentMap/EhCache/Redis等;

spring cache 实例

1. 导入jar包

<!-- redis架包 -->
<dependency>
	<groupId>org.springframework.data</groupId>
	<artifactId>spring-data-redis</artifactId>
	<version>1.6.2.RELEASE</version>
</dependency>
<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
	<version>2.9.0</version>
</dependency>

<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-core -->
<dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-core</artifactId>
	<version>2.9.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-databind -->
<dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-databind</artifactId>
	<version>2.9.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/com.fasterxml.jackson.core/jackson-annotations -->
<dependency>
	<groupId>com.fasterxml.jackson.core</groupId>
	<artifactId>jackson-annotations</artifactId>
	<version>2.9.2</version>
</dependency>

<!-- https://mvnrepository.com/artifact/commons-logging/commons-logging -->
<dependency>
	<groupId>commons-logging</groupId>
	<artifactId>commons-logging</artifactId>
	<version>1.2</version>
</dependency>
<!-- https://mvnrepository.com/artifact/log4j/log4j -->
<dependency>
	<groupId>log4j</groupId>
	<artifactId>log4j</artifactId>
	<version>1.2.17</version>
</dependency>

2. 配置spring-cache.xml

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:cache="http://www.springframework.org/schema/cache"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/cache
  http://www.springframework.org/schema/cache/spring-cache.xsd">

    <!-- 开启缓存注解: 使用 @Cacheable, @CachePut, @CacheEvict, @Caching, @CacheConfig 等注解引入缓存 -->
    <cache:annotation-driven/>

    <!-- generic cache manager -->
    <bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
        <property name="caches">
            <set>
                <bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean" p:name="default"/>
                <bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean" p:name="accountCache"/>
            </set>
        </property>
    </bean>
	
    <!-- 注入实体类 -->
    <bean id="accountServiceBean" class="com.csdn.learn.springcache.AccountService"/>
   
</beans>

3. 使用及测试

package com.csdn.learn.springcache;

import com.csdn.learn.annocache.Account;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;

/**
 * 使用@Cacheable, @CachePut, @CacheEvict, @CacheConfig spring通过AOP对方法进行缓存管理
 * @author liudong
 * @date 2018-04-27
 */
public class AccountService {

    /**
     * 使用了一个缓存名叫 accountCache
     * key condition ，前面的 # 号代表这是一个 SpEL 表达式
     * @param userName
     * @return
     */
    @Cacheable(value = "accountCache", key = "#userName", condition = "#userName.length() <= 4")
    public Account getAccountByName(String userName) {
        // 方法内部实现不考虑缓存逻辑，直接实现业务
        System.out.println("real querying db..." + acctName + "+" + password);
        return new Account(acctName);
    }

    /**
     * 更新 accountCache 缓存
     * @param account dd
     */
    @CachePut(value = "accountCache", key = "#account.getName()")
    public void updateAccount(Account account) {
        System.out.println("real update db..." + account.getName());
    }

    /**
     * reload 清空 accountCache 缓存
     */
    @CacheEvict(value = "accountCache", allEntries = true)
    public void reload() {
    }

}
package com.csdn.learn.annocache;

import java.io.Serializable;

/**
 * 首先定义一个实体类：账号类，具备基本的 id 和 name 属性，且具备 getter 和 setter 方法
 * @author liudong
 * @date 2018-04-27
 */
public class Account implements Serializable {
    private static final long serialVersionUID = 1L;

    private int id;
    private String name;
    private String password;

    public Account() {
        super();
    }

    public String getPassword() {
        return password;
    }
    public void setPassword(String password) {
        this.password = password;
    }
    public Account(String name) {
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Account{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}
package com.csdn.learn.rediscacheanno;

import com.csdn.learn.annocache.Account;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.data.redis.core.RedisTemplate;

public class Main {

    public static void main(String[] args) {
        // 加载 spring 配置文件
        ApplicationContext context = new ClassPathXmlApplicationContext("spring-cache.xml");

        AccountService s = (AccountService) context.getBean("accountServiceBean");
		
        // 第一次查询，应该走数据库
        System.out.print("first query...");
        s.getAccountByName("somebody");
        // 第二次查询，应该不查数据库，直接返回缓存的值
        System.out.print("second query...");
        s.getAccountByName("somebody");
        System.out.println();

	// TODO 自行测试@CachePut及@CacheEvict
		
	// 测试redisTemplate
	RedisTemplate redisTemplate = (RedisTemplate) context.getBean("redisTemplate");
	// redis中存取字符串
        redisTemplate.opsForValue().set("redis2", "ceshiRedis222");
        System.out.println(redisTemplate.opsForValue().get("redis2"));
	// redis中存取实体类
        redisTemplate.opsForValue().set("account", new Account("ceshi 123"));
        System.out.println(redisTemplate.opsForValue().get("account"));
    }
}

内存式普通缓存使用大功告成, 由于spring整合Redis的做缓存时配置最难搞定, 所以仅介绍配置

方式一. spring整合Redis的xml配置

#============================#
#==== Redis settings ====#
#============================#
#redis 服务器 IP
redis.host=127.0.0.1
#redis 服务器端口
redis.port=6379
#redis 密码
redis.pass=
#redis 支持16个数据库（相当于不同用户）可以使不同的应用程序数据彼此分开同时又存储在相同的实例上
redis.dbIndex=1
#redis 缓存数据过期时间单位秒
redis.expiration=3000
#控制一个 pool 最多有多少个状态为 idle 的jedis实例
redis.maxIdle=300
#控制一个 pool 可分配多少个jedis实例
redis.maxActive=600
#当borrow一个jedis实例时，最大的等待时间，如果超过等待时间，则直接抛出JedisConnectionException；
redis.maxWait=1000
#在borrow一个jedis实例时，是否提前进行alidate操作；如果为true，则得到的jedis实例均是可用的；
redis.testOnBorrow=true
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:cache="http://www.springframework.org/schema/cache"
       xmlns:p="http://www.springframework.org/schema/p"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
  http://www.springframework.org/schema/beans/spring-beans.xsd
  http://www.springframework.org/schema/context
  http://www.springframework.org/schema/context/spring-context.xsd
  http://www.springframework.org/schema/cache
  http://www.springframework.org/schema/cache/spring-cache.xsd">

    <!-- **************************************************redis********************************************************** -->
    <!-- 配置文件加载 -->
    <context:property-placeholder location="classpath:*.properties"/>
    <!-- 配置 JedisPoolConfig 实例 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}"/>
        <property name="maxTotal" value="${redis.maxActive}"/>
        <property name="maxWaitMillis" value="${redis.maxWait}"/>
        <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
    </bean>

    <!-- 配置JedisConnectionFactory -->
    <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory">
        <property name="hostName" value="${redis.host}"/>
        <property name="port" value="${redis.port}"/>
        <property name="password" value="${redis.pass}"/>
        <property name="database" value="${redis.dbIndex}"/>
        <property name="poolConfig" ref="poolConfig"/>
    </bean>

    <!-- 配置RedisTemplate -->
    <!-- redis 序列化策略 ，通常情况下key值采用String序列化策略， -->
    <!-- 如果不指定序列化策略，StringRedisTemplate的key和value都将采用String序列化策略； -->
    <!-- 但是RedisTemplate的key和value都将采用JDK序列化 这样就会出现采用不同template保存的数据不能用同一个template删除的问题 -->
    <bean id="redisTemplate" class="org.springframework.data.redis.core.RedisTemplate"
          p:connectionFactory-ref="jedisConnectionFactory"
          p:keySerializer-ref="stringRedisSerializer"
          p:hashKeySerializer-ref="stringRedisSerializer"
          p:valueSerializer-ref="genericJackson2JsonRedisSerializer"
          p:hashValueSerializer-ref="genericJackson2JsonRedisSerializer"
    />
    <!--JDK序列化,速度快但占用空间较大,对象必须实现java.io.Serializable接口 -->
    <bean id="jdkSerializationRedisSerializer" class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer" />
    <bean id="stringRedisSerializer" class="org.springframework.data.redis.serializer.StringRedisSerializer" />
    <!-- JSON序列化，空间占用小，无需指明但对象类型
            SerializationException:
                Could not read JSON: Cannot construct instance of `com.learn.cache.model.Account` (although at least one Creator exists):
                cannot deserialize from Object value (no delegate- or property-based Creator)
            解决办法: 给实体类com.learn.cache.model.Account添加默认的构造方法 public Account(){}
    -->
    <bean id="genericJackson2JsonRedisSerializer" class="org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer" />
    <!-- JSON序列化，空间占用小，需指明对象类型,不知道怎么在xml配置中注入参数类型为Class<?>的值，可在代码中指定 -->
    <!-- <bean id="jackson2JsonRedisSerializer" class="org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer"/> -->

    <!-- 配置RedisCacheManager -->
    <bean id="redisCacheManager" class="org.springframework.data.redis.cache.RedisCacheManager">
        <constructor-arg name="redisOperations" ref="redisTemplate"/>
        <property name="defaultExpiration" value="${redis.expiration}"/>
    </bean>

    <!-- 开启缓存注解: 使用 @Cacheable, @CachePut, @CacheEvict, @Caching, @CacheConfig 等注解引入缓存 -->
    <cache:annotation-driven/>
    <!-- 开启注解扫描 -->
    <!--<context:annotation-config />-->
    <context:component-scan base-package="com.learn"/>
    <bean id="testServiceBean" class="com.learn.cache.service.TestService"/>
    <bean id="accountServiceBean" class="com.learn.cache.service.AccountService"/>
</beans>

方式二. spring整合Redis的纯注解配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                        http://www.springframework.org/schema/beans/spring-beans-4.2.xsd
                        http://www.springframework.org/schema/context
                        http://www.springframework.org/schema/context/spring-context-4.2.xsd">

    <!-- 配置文件加载 -->
    <context:property-placeholder location="classpath:*.properties"/>
    <!-- redis连接池 -->
    <bean id="poolConfig" class="redis.clients.jedis.JedisPoolConfig">
        <property name="maxIdle" value="${redis.maxIdle}"/>
        <property name="maxWaitMillis" value="${redis.maxWait}"/>
        <property name="testOnBorrow" value="${redis.testOnBorrow}"/>
    </bean>
    <!-- 连接工厂 -->
    <bean id="redisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory"
          p:host-name="${redis.host}" p:port="${redis.port}" p:password="${redis.pass}" p:database="2" p:pool-config-ref="poolConfig"/>

    <!-- 开启注解扫描 -->
    <!--<context:annotation-config />-->
    <context:component-scan base-package="com.csdn.learn" />
    <bean id="accountServiceBean" class="com.csdn.learn.rediscacheanno.AccountService"/>
</beans>
package com.csdn.learn.rediscacheanno;

import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheManager;
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.StringRedisSerializer;

@Configuration
@EnableCaching
public class RedisConfig extends CachingConfigurerSupport {

    @Bean
    public CacheManager cacheManager(RedisTemplate redisTemplate) {
        RedisCacheManager cacheManager = new RedisCacheManager(redisTemplate);
//        cacheManager.setDefaultExpiration(3600);//默认缓存一小时
        return cacheManager;
    }

    /**
     * redisTemplate 序列化使用的jdkSerializeable, 存储二进制字节码, 所以自定义序列化类
     * @param redisConnectionFactory
     * @return
     */
    @Bean
    public RedisTemplate<Object, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory) {
        RedisTemplate<Object, Object> redisTemplate = new RedisTemplate<>();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        // 使用Jackson2JsonRedisSerialize 替换默认序列化
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);

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

        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        // 设置value的序列化规则和 key的序列化规则
        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);
        redisTemplate.setKeySerializer(new StringRedisSerializer());
        redisTemplate.afterPropertiesSet();
        return redisTemplate;
    }
}

最后, SpringBoot整合Redis做缓存Cache技术配置非常简单, 可以试着玩一玩

 

 

 

 

 

hkk666123
关注
专栏目录
Spring ： ConcurrentMapCacheManager
九师兄
07-04 1170
1.美图 2.概述 3.源码 public class ConcurrentMapCacheManager implements CacheManager, BeanClassLoaderAware { // 所有的cache组件都是有名字的 private final ConcurrentMap<String, Cache> cacheMap = new ConcurrentH...
若依将ehcache改为redis缓存详细整合步骤
猿小白的博客
04-21 3021
若依单体项目，目前的会话信息通过ehcache存储在本地，不方便集群会话管理，可能有的需求需要将ehcache替换为redis来实现集群会话管理。下面给大家介绍一下集成步骤。 目录 一、 删除shiro-ehcache依赖 二、添加 redis整合依赖 三、添加redis配置文件 四、删除一些ehcache相关的类 （1）删除java类 （2）删除ehcache配置文件 （3）删除mybatis的xml文件 五、加入整合相关代码 （1）com.ruoyi.web.contro...
通俗易懂讲解Spring Cache基于ConcurrentMapCache源码实现原理
weixin_43401380的博客
04-15 1794
通俗易懂讲解Spring Cache基于ConcurrentMapCache源码实现原理
Spring Boot (although at least one Creator exists): no int/Int-argument constructor/factory ...解决
最新发布
花花鱼的专栏
08-16 982
通过API文档来规划前后端一致的情况，来减少前后端调用方法不一致的情况。
Spring实现一个基于ConcurrentMapCacheManager的简单缓存
PrintfWu的博客
07-16 1872
写在前面 由于业务需要，最近写的一个项目不允许使用Redis等外部缓存，而且项目单节点部署，无需考虑数据互通的问题。因此手写一个基于ConcurrentMapCacheManager的缓存来使用。 该缓存仅支持过期删除淘汰策略，如果需要其他复杂的业务逻辑，可以考虑使用JCacheCacheManager, EhCacheCacheManager, CaffeineCacheManager来实现。 实现 最简单的缓存可以只用HashMap实现 Map<String, Object> cache =
spring boot 源码解析33-spring boot集成spring cache(基于ConcurrentMapCache)
qq_26000415的博客
01-23 1万+
前言接下来的几篇我们来讲解一下spring boot 中如何集成spring cache. spring cache 中支持如下cache: ConcurrentMap Cache Caffeine Cache EhCache GuavaCache(1.5版本废弃) Hazelcast Cache Infinispan Cache JCache Cache 我们只讲解ConcurrentMapCac
Spring Boot缓存实战 默认Cache（ConcurrentMapCacheManager）
热门推荐
xiaolyuh的专栏
08-11 1万+
Spring boot默认使用的是SimpleCacheConfiguration，即使用ConcurrentMapCacheManager来实现缓存。 pom文件 <dependencies> <dependency> <groupId>org.springframework.boot</groupId> ...
Springboot整合Cache缓存组件(Redis,Caffine,Jetcache,EhCache等)
青春不散场的专栏
06-23 715
Springboot整合各种缓存组件，在日常开发中除了分布式缓存，更多的还是各种服务内部缓存的组件，这里把Springboot整合的各种缓存组件都列出来，作为一个总结
技术总监告诉你：Spring Cache + Redis 缓存实战，原地起飞
澎湖Java架构师的博客
08-27 348
public abstract class AbstractValueAdaptingCache implements Cache { //是否允许Null值 private final boolean allowNullValues;
Spring Boot Cache 缓存使用
Carey丶zsh 的博客
06-23 1135
1.Spring Boot 使用 Cache 我们知道一个程序的瓶颈在于数据库，我们也知道内存的速度是远大于硬盘的速度的。当我们需要重复地获取相同的数据的时候，我们一次又一次的请求数据库或远程服务，导致大量的时间耗费在数据库查询或者远程方法调用上，导致程序性能的恶化，这便是数据缓存要解决的问题。 1.1 Spring 缓存支持 Spring 定义了 org.springframework.c...
SpringBoot专题学习Part26：Spring Cache整合Redis实现缓存及SpringBoot 2.x新版本自定义CacheManager
"✧treasure mountain✧"
03-30 8389
Spring Cache默认使用的是ConcurrentMapCacheManager管理器 创建的是ConcurrentMapCache缓存 然后将数据保存在ConcurrentMap中 实际使用缓存中间件的场合会更多 例如Redis EhCache等 Redis是一个高性能的支持网络 可基于内存亦可持久化的日志型 Key-Value数据库 Spring Cache默认使用的是SimpleCac...
Spring Boot 中的 ConcurrentMapCacheManager
程序员徐师兄的博客
06-28 1207
是 Spring Boot 提供的一个简单的缓存管理器，它基于 Java 并发包中的实现。使用可以快速实现缓存功能，提高应用程序的性能。在使用时，需要注意一些高级属性的设置，以满足不同的需求。
Spring Boot缓存------基于ConcurrentHashMap和Redis的两级缓存管理
豢龙先生
09-30 2610
Spring Boot项目缓存配置(未测试，未完善) 1、你需要准备和配置的事情 引入依赖 <!-- Redis数据库 --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis&...
spring配置ConcurrentMap实现缓存
weixin_30402085的博客
10-16 654
spring本身内置了对Cache的支持，本次记录的是基于Java API的ConcurrentMap的CacheManager配置。 1、xml文件中增加命名空间 <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema...
springboot2 缓存抽象（二）ConcurrentMapCache及缓存注解讲解
jue6628的博客
08-24 1498
一、导入pom <!-- 引入cache --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-cache</artifactId> </dependency> 二...
基于ConcurrentMap实现loadingCache
huangshanchun的专栏
02-24 522
0 概述 一般的缓存策略是缓存没有命中的时候，直接去获取数据然后再放入缓存，这样可能会出现多个请求同时没有命中缓存某个key，同时去取数据，造成资源浪费，loadingCache就是为了解决这个问题。本文基于ConcurrentMap实现loadingCache。 1 具体实现 /** * Created by apple on 18/2/23. */ public class ...
ConcurrentHashMap实现Localcache本地缓存
我爱学习 学习使我快乐
09-25 4541
很多场景下，有些请求的数据，是不会经常改变的，这种时候，为了减少数据库的查询压力，可以将这一部分数据放入缓存中，直接从缓存中读取。除了一些像Redis等缓存外，还可以通过本地内存，作为缓存。下边将使用ConcurrentHashMap来实现本地缓存。 相关的技术： ConcurrentHashMap --数据存储，线程安全的map ScheduledExecutorService --线...
ConcurrentHashMap进行缓存
爸爸去哪了2之熊猫三胞胎的博客
12-25 1302
import java.util.concurrent.ConcurrentHashMap; public class ConcurrentHashMapTest { private static ConcurrentHashMap<String, String> cacheMap = new ConcurrentHashMap<>(); /** * 获取缓存的对象
redisCacheManager
weixin_34067102的博客
09-27 1550
2019独角兽企业重金招聘Python工程师标准>>> ...
SpringCache与redis集成实现高效缓存
3. 启用SpringCache：在Spring配置中启用缓存管理，并指定使用Redis作为缓存提供者。这可以通过`@EnableCaching`注解完成，并配置相应的RedisCacheManager。 4. 注解驱动的缓存：在需要缓存的方法上添加`@Cacheable...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值