springboot redis多租户切换统一切换key前缀

已于 2022-04-19 19:46:05 修改
阅读量2.8k 收藏 5
点赞数
文章标签： redis java spring
于 2022-04-18 17:48:51 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41205473/article/details/123902395
版权

根据请求切换租户，修改redis前缀，不修改原来的代码，以最小改动实现，支持并发。

ThreadLocal 保存当前请求的数据以及租户相关信息，利用 Filter 拦截请求，判断配置当前请求的租户类型，保存设置到RequestContext中。

1.RequestContext 是当前线程文本类，存储当前线程中的一些变量以及租户信息，

TenantType是枚举类，定义租户信息，读者自行定义，这里不提供了。

public class RequestContext {

   private static final String TENANT_TYPE = "TENANT_TYPE";

   private Map<String, Object> values = new HashMap<String, Object>();
   
   private static final ThreadLocal<RequestContext> LOCAL = new ThreadLocal<RequestContext>() {
      @Override
      protected RequestContext initialValue() {
         return new RequestContext();
      }
   };

   public static RequestContext getContext() {
       return LOCAL.get();
   }
   
   public static void clearContext() {
       LOCAL.remove();
       LOCAL.set(new RequestContext());
   }
   
   public Object get(String key) {
        return values.get(key);
    }
   
   public void remove(String key) {
      values.remove(key);
   }
   
   public RequestContext set(String key, Object value) {
        if (value == null) {
            values.remove(key);
        } else {
            values.put(key, value);
        }
        return this;
    }

   /**
    * 设置数据源
    * @param value
    * @return
    */
   public RequestContext setDataSource(String value) {
      if (value == null) {
         values.remove(TENANT_TYPE);
      } else {
         values.put(TENANT_TYPE, value);
      }
      return this;
   }

   /**
    * 设置数据源
    * @param value
    * @return
    */
   public RequestContext setTenantType(String value) {
      if (value == null) {
         values.remove(TENANT_TYPE);
      } else {
         values.put(TENANT_TYPE, value);
      }
      return this;
   }

   /**
    * Get current DataSource
    *
    * @return data source name
    */
   public String getTenantType() {
      return (String) values.get(TENANT_TYPE);
   }

   /**
    * Get current DataSource
    *
    * @return data source name
    */
   public String getRedisPre() {
      if(StringUtils.isBlank(this.getTenantType())){
         throw new IllegalArgumentException("当前请求未找到租户类型");
      }
      return TenantType.getRedisPre(this.getTenantType());
   }

   /**
    * Get current DataSource
    *
    * @return data source name
    */
   public String getDataSource() {
      return (String) values.get(TENANT_TYPE);
   }

   /**
    * Clear current DataSource
    *
    * @return data source name
    */
   public void clearDataSource() {
      remove(TENANT_TYPE);
   }

}

 2.利用 Filter 过滤器在请求进入后，根据请求域名来判断租户（每个租户的域名请求是不同的），并且把租户保存到 RequestContext 中，供当前后续代码获取。

public class SwitchTenantFilter implements Filter {
   /** 日志 */
   private static Logger logger = LoggerFactory.getLogger(SwitchTenantFilter.class);

   @Override
   public void doFilter(ServletRequest req, ServletResponse resp,
         FilterChain filterChain) throws IOException, ServletException {
      HttpServletRequest request = (HttpServletRequest) req;
      HttpServletResponse response = (HttpServletResponse) resp;

      String host = request.getHeader("host");

      // 租户1访问
      if(host.contains("test1")){
         RequestContext.getContext().setDataSource("test1");
      }

      // 租户2访问
      if(host.contains("test2")){
         RequestContext.getContext().setDataSource("test2");
      }

      String dataSource = RequestContext.getContext().getDataSource();
      if(StringUtils.isBlank(dataSource)){
         logger.error("访问host：{}，切换数据源失败！！！", host);
         filterChain.doFilter(request, response);
         return;
      }
      logger.info("访问host：{}，切换数据源成功，数据源key：{}", host, RequestContext.getContext().getDataSource());
      filterChain.doFilter(request, response);
      // 清除 ThreadLocal 变量
   }
   
   @Override
   public void init(FilterConfig filterConfig) throws ServletException {
      // TODO Auto-generated method stub
      
   }

   @Override
   public void destroy() {
      // TODO Auto-generated method stub
      
   }

}

3.在Configuration类中实例化这个Filter  Bean，配置拦截

//  ===SwitchTenantFilter  切换租户,在WebAccessLogFilter之前加载===
    @Bean
    public FilterRegistrationBean switchDataSourceFilterRegistrationBean() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        SwitchTenantFilter switchTenantFilter = new SwitchTenantFilter();
        registration.setFilter(switchTenantFilter);

        registration.addUrlPatterns("/*");
        registration.setName("switchDataSourceFilter");
        registration.setOrder(12);
        registration.setDispatcherTypes(DispatcherType.REQUEST);
        return registration;
    }
// ===SwitchTenantFilter===

--------------------------------------------------------------------------------------------------------------------

以下是简单的源码跟踪，不需要的可以跳过：

springboot 使用 RedisTemplate 操作redis

redisTemplate.opsForValue().set(key, val); // 设置数据
redisTemplate.opsForValue().get(key); // 获取数据
redisTemplate.delete(key); //删除数据
等等....

 跟踪源码可以发现，RedisTemplate 在操作key和value时，会进行序列化。

AbstractOperations：

 这里扩展点就出来了，我们可以重写RedisTemplate  的 getKeySerializer 方法，来根据当前租户切换 keySerializer ，来达到修改前缀的目的。

-----------------------------------------------------------------------------------------------------------------------

以下是重写的RedisTemplate：

public class DynamicRedisTemplate<K, V> extends RedisTemplate<K, V> {

    public static final String SEPARATE=":";

    private RedisSerializer<String> stringSerializer = RedisSerializer.string();

    @Override
    public RedisSerializer getKeySerializer() {
        RedisSerializer<?> redisSerializer = super.getKeySerializer();
        if(StringUtils.isNotBlank(RequestContext.getContext().getRedisPre())){
            String cachePrefix = RequestContext.getContext().getRedisPre() + DynamicRedisTemplate.SEPARATE;
            redisSerializer = new KeyStringRedisSerializer(cachePrefix);
        }
        return redisSerializer;
    }

    /*
     * (non-Javadoc)
     * @see org.springframework.data.redis.core.RedisOperations#delete(java.lang.Object)
     */
    @Override
    public Boolean delete(K key) {

        byte[] rawKey = rawKey(key);

        Long result = execute(connection -> connection.del(rawKey), true);

        return result != null && result.intValue() == 1;
    }

    /*
     * (non-Javadoc)
     * @see org.springframework.data.redis.core.RedisOperations#delete(java.util.Collection)
     */
    @Override
    public Long delete(Collection<K> keys) {

        if (CollectionUtils.isEmpty(keys)) {
            return 0L;
        }

        byte[][] rawKeys = rawKeys(keys);

        return execute(connection -> connection.del(rawKeys), true);
    }

    /*
     * (non-Javadoc)
     * @see org.springframework.data.redis.core.RedisOperations#unlink(java.lang.Object)
     */
    @Override
    public Boolean unlink(K key) {

        byte[] rawKey = rawKey(key);

        Long result = execute(connection -> connection.unlink(rawKey), true);

        return result != null && result.intValue() == 1;
    }

    /*
     * (non-Javadoc)
     * @see org.springframework.data.redis.core.RedisOperations#unlink(java.util.Collection)
     */
    @Override
    public Long unlink(Collection<K> keys) {

        if (CollectionUtils.isEmpty(keys)) {
            return 0L;
        }

        byte[][] rawKeys = rawKeys(keys);

        return execute(connection -> connection.unlink(rawKeys), true);
    }

    /*
     * (non-Javadoc)
     * @see org.springframework.data.redis.core.RedisOperations#countExistingKeys(java.util.Collection)
     */
    @Override
    public Long countExistingKeys(Collection<K> keys) {

        Assert.notNull(keys, "Keys must not be null!");

        byte[][] rawKeys = rawKeys(keys);
        return execute(connection -> connection.exists(rawKeys), true);
    }

    /*
     * (non-Javadoc)
     * @see org.springframework.data.redis.core.RedisOperations#hasKey(java.lang.Object)
     */
    @Override
    public Boolean hasKey(K key) {

        byte[] rawKey = rawKey(key);

        return execute(connection -> connection.exists(rawKey), true);
    }

    /*
     * (non-Javadoc)
     * @see org.springframework.data.redis.core.RedisOperations#expire(java.lang.Object, long, java.util.concurrent.TimeUnit)
     */
    @Override
    public Boolean expire(K key, final long timeout, final TimeUnit unit) {

        byte[] rawKey = rawKey(key);
        long rawTimeout = TimeoutUtils.toMillis(timeout, unit);

        return execute(connection -> {
            try {
                return connection.pExpire(rawKey, rawTimeout);
            } catch (Exception e) {
                // Driver may not support pExpire or we may be running on Redis 2.4
                return connection.expire(rawKey, TimeoutUtils.toSeconds(timeout, unit));
            }
        }, true);
    }

    /*
     * (non-Javadoc)
     * @see org.springframework.data.redis.core.RedisOperations#expireAt(java.lang.Object, java.util.Date)
     */
    @Override
    public Boolean expireAt(K key, final Date date) {

        byte[] rawKey = rawKey(key);

        return execute(connection -> {
            try {
                return connection.pExpireAt(rawKey, date.getTime());
            } catch (Exception e) {
                return connection.expireAt(rawKey, date.getTime() / 1000);
            }
        }, true);
    }

    /*
     * (non-Javadoc)
     * @see org.springframework.data.redis.core.RedisOperations#getExpire(java.lang.Object)
     */
    @Override
    public Long getExpire(K key) {

        byte[] rawKey = rawKey(key);
        return execute(connection -> connection.ttl(rawKey), true);
    }

    /*
     * (non-Javadoc)
     * @see org.springframework.data.redis.core.RedisOperations#getExpire(java.lang.Object, java.util.concurrent.TimeUnit)
     */
    @Override
    public Long getExpire(K key, final TimeUnit timeUnit) {

        byte[] rawKey = rawKey(key);
        return execute(connection -> {
            try {
                return connection.pTtl(rawKey, timeUnit);
            } catch (Exception e) {
                // Driver may not support pTtl or we may be running on Redis 2.4
                return connection.ttl(rawKey, timeUnit);
            }
        }, true);
    }

    /*
     * (non-Javadoc)
     * @see org.springframework.data.redis.core.RedisOperations#keys(java.lang.Object)
     */
    @Override
    @SuppressWarnings("unchecked")
    public Set<K> keys(K pattern) {

        byte[] rawKey = rawKey(pattern);
        Set<byte[]> rawKeys = execute(connection -> connection.keys(rawKey), true);

        return getKeySerializer() != null ? SerializationUtils.deserialize(rawKeys, getKeySerializer()) : (Set<K>) rawKeys;
    }

    /*
     * (non-Javadoc)
     * @see org.springframework.data.redis.core.RedisOperations#persist(java.lang.Object)
     */
    @Override
    public Boolean persist(K key) {

        byte[] rawKey = rawKey(key);
        return execute(connection -> connection.persist(rawKey), true);
    }

    /*
     * (non-Javadoc)
     * @see org.springframework.data.redis.core.RedisOperations#move(java.lang.Object, int)
     */
    @Override
    public Boolean move(K key, final int dbIndex) {

        byte[] rawKey = rawKey(key);
        return execute(connection -> connection.move(rawKey, dbIndex), true);
    }

    /*
     * (non-Javadoc)
     * @see org.springframework.data.redis.core.RedisOperations#randomKey()
     */
    @Override
    public K randomKey() {

        byte[] rawKey = execute(RedisKeyCommands::randomKey, true);
        return deserializeKey(rawKey);
    }

    @SuppressWarnings("unchecked")
    private K deserializeKey(byte[] value) {
        return getKeySerializer() != null ? (K) getKeySerializer().deserialize(value) : (K) value;
    }

    /*
     * (non-Javadoc)
     * @see org.springframework.data.redis.core.RedisOperations#rename(java.lang.Object, java.lang.Object)
     */
    @Override
    public void rename(K oldKey, K newKey) {

        byte[] rawOldKey = rawKey(oldKey);
        byte[] rawNewKey = rawKey(newKey);

        execute(connection -> {
            connection.rename(rawOldKey, rawNewKey);
            return null;
        }, true);
    }

    /*
     * (non-Javadoc)
     * @see org.springframework.data.redis.core.RedisOperations#renameIfAbsent(java.lang.Object, java.lang.Object)
     */
    @Override
    public Boolean renameIfAbsent(K oldKey, K newKey) {

        byte[] rawOldKey = rawKey(oldKey);
        byte[] rawNewKey = rawKey(newKey);
        return execute(connection -> connection.renameNX(rawOldKey, rawNewKey), true);
    }

    /*
     * (non-Javadoc)
     * @see org.springframework.data.redis.core.RedisOperations#type(java.lang.Object)
     */
    @Override
    public DataType type(K key) {

        byte[] rawKey = rawKey(key);
        return execute(connection -> connection.type(rawKey), true);
    }

    /**
     * Executes the Redis dump command and returns the results. Redis uses a non-standard serialization mechanism and
     * includes checksum information, thus the raw bytes are returned as opposed to deserializing with valueSerializer.
     * Use the return value of dump as the value argument to restore
     *
     * @param key The key to dump
     * @return results The results of the dump operation
     */
    @Override
    public byte[] dump(K key) {

        byte[] rawKey = rawKey(key);
        return execute(connection -> connection.dump(rawKey), true);
    }

    /**
     * Executes the Redis restore command. The value passed in should be the exact serialized data returned from
     * {@link #dump(Object)}, since Redis uses a non-standard serialization mechanism.
     *
     * @param key The key to restore
     * @param value The value to restore, as returned by {@link #dump(Object)}
     * @param timeToLive An expiration for the restored key, or 0 for no expiration
     * @param unit The time unit for timeToLive
     * @param replace use {@literal true} to replace a potentially existing value instead of erroring.
     * @throws RedisSystemException if the key you are attempting to restore already exists and {@code replace} is set to
     *           {@literal false}.
     */
    @Override
    public void restore(K key, final byte[] value, long timeToLive, TimeUnit unit, boolean replace) {

        byte[] rawKey = rawKey(key);
        long rawTimeout = TimeoutUtils.toMillis(timeToLive, unit);

        execute(connection -> {
            connection.restore(rawKey, rawTimeout, value, replace);
            return null;
        }, true);
    }

    /*
     * (non-Javadoc)
     * @see org.springframework.data.redis.core.RedisOperations#watch(java.lang.Object)
     */
    @Override
    public void watch(K key) {

        byte[] rawKey = rawKey(key);

        execute(connection -> {
            connection.watch(rawKey);
            return null;
        }, true);
    }

    /*
     * (non-Javadoc)
     * @see org.springframework.data.redis.core.RedisOperations#watch(java.util.Collection)
     */
    @Override
    public void watch(Collection<K> keys) {

        byte[][] rawKeys = rawKeys(keys);

        execute(connection -> {
            connection.watch(rawKeys);
            return null;
        }, true);
    }

    /*
     * (non-Javadoc)
     * @see org.springframework.data.redis.core.RedisOperations#sort(org.springframework.data.redis.core.query.SortQuery, org.springframework.data.redis.serializer.RedisSerializer)
     */
    @Override
    public <T> List<T> sort(SortQuery<K> query, @Nullable RedisSerializer<T> resultSerializer) {

        byte[] rawKey = rawKey(query.getKey());
        SortParameters params = QueryUtils.convertQuery(query, stringSerializer);

        List<byte[]> vals = execute(connection -> connection.sort(rawKey, params), true);

        return SerializationUtils.deserialize(vals, resultSerializer);
    }

    /*
     * (non-Javadoc)
     * @see org.springframework.data.redis.core.RedisOperations#sort(org.springframework.data.redis.core.query.SortQuery, java.lang.Object)
     */
    @Override
    public Long sort(SortQuery<K> query, K storeKey) {

        byte[] rawStoreKey = rawKey(storeKey);
        byte[] rawKey = rawKey(query.getKey());
        SortParameters params = QueryUtils.convertQuery(query, stringSerializer);

        return execute(connection -> connection.sort(rawKey, params, rawStoreKey), true);
    }

    @SuppressWarnings("unchecked")
    private byte[] rawKey(Object key) {
        Assert.notNull(key, "non null key required");
        if (getKeySerializer() == null && key instanceof byte[]) {
            return (byte[]) key;
        }
        return getKeySerializer().serialize(key);
    }

    private byte[][] rawKeys(Collection<K> keys) {
        final byte[][] rawKeys = new byte[keys.size()][];

        int i = 0;
        for (K key : keys) {
            rawKeys[i++] = rawKey(key);
        }

        return rawKeys;
    }
}

发现我们重写了 RedisTemplate里面的挺多方法没这事什么原因？

原因：这里RedisTemplate里面有个“坑”，不能只重写getKeySerializer方法。

因为调用 redisTemplate.delete 等RedisTemplate本身的方法时，获取keySerializer的方法 rawKey

是私有的，并且不是通过 getKeySerializer 方法获取的 keySerializer，而是直接使用RedisTemplate本身的变量，这就不得以把 RedisTemplate 一些操作方法都进行重写。

RedisTemplate：

 

qq_41205473
关注
  • 0
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
【SpringBoot】50、SpringBoot为Redis的key统一加上前缀
Asurplus
08-12 21万+
我们在实际的项目应用中，Redis一般都是用来缓存热点数据，一台服务器可能部署了多个应用，应用直接的 Redis 数据需要加上前缀区分开来，我们可以使用序列化的方式，统一为所有的 key 加上前缀 一、关于在 SpringBoot 中整合 Redis https://lizhou.blog.csdn.net/article/details/98358258 二、关于在 SpringBoot 中整合 Redis 实现序列化存储Java对象 https://lizhou.blog.csdn.net/artic
redis 多租户隔离 ACL 权限控制(redis-cli / nodejs的ioredis )
qq_42152032的博客
09-08 584
Redis 6版本之后：提供ACL的功能对用户进行更细粒度的权限控制 ：（1）接入权限:用户名和密码（2）可以执行的命令（3）可以操作的 KEYACL常用规则介绍：+指令列表 //增加可操作指令列表， 比如：select auth+@指令类别 //增加可操作指令类别，比如@admin @setacl cat //查看所有指令类别~ //可操作的匹配pattern的键redis多租户的几种实现方式：1.redis6 之后可以通过acl 进行多租户隔离，每个用户一个db2.基于容器，
Springboot动态切换数据源实现多租户架构
最新发布
秃了也弱了
04-09 772
一个支持多租户技术的系统需要在设计上对它的数据和配置进行虚拟分区，从而使系统的每个租户或称组织都能够使用一个单独的系统实例，并且每个租户都可以根据自己的需求对租用的系统实例进行个性化配置。使用数据库级别的数据隔离是实现多租户架构的一种常见方式。数据隔离是指在多租户架构中，保持各个租户之间的数据相互独立，确保一个租户的数据不会被其他租户访问或篡改。进一步我们可以总结出，可以通过当前登录的用户session，来获取到该用户的租户信息，并通过租户信息来获取到该租户所持有的数据源，来实现多租户的数据隔离。
Springboot统一给redisKey加前缀
疯狂撸代码的奋青博客
03-28 3069
@Slf4j @Order @Configuration public class PreKeyRedisConfig { public static final String DEFUAL_PREFIX = "XXX##"; @Autowired private StringRedisTemplate stringRedisTemplate; @Autowired private RedisTemplate redisTemplate; class Pre
SpringBoot读写Redis客户端并实现技术切换（Jedis）
Rkun18的博客
01-25 849
一个是服务端设置的"name"，一个是客户端设置的"name",服务端设置的"name" ，服务端设置的"name"不能使用String类型获取，而客户端设置的name可以。整合Redis中，使用RedisTemplate获取到的是对象，而StringRedisTemplate获取到的是字符串。SpringBoot整合Redis。将测试操作放入测试类中。
Redis 序列化方式StringRedisSerializer、FastJsonRedisSerializer和KryoRedisSerializer
热门推荐
xiaolyuh的专栏
11-30 4万+
当我们的数据存储到Redis的时候，我们的键（key）和值（value）都是通过Spring提供的Serializer序列化到数据库的。RedisTemplate默认使用的是JdkSerializationRedisSerializer，StringRedisTemplate默认使用的是StringRedisSerializer。 Spring Data JPA为我们提供了下面的Serializ...
Redis 序列化器
NiceWeather9的博客
08-23 1505
在 Redis 中，序列化器（Serializer）是用于将数据在存储和读取时进行序列化和反序列化操作，即对数据进行编码和解码
SpringBoot使用注解实现 Redis 数据库的切换.zip
04-08
SpringBoot，注解实现Redis 库的切换。
springboot整合redis动态切换每个数据库
06-20
springboot整合redis动态切换每个数据库，
springboot根据配置实现单机与集群redis的切换
11-10
通过配置文件实现连接单机redis或集群redis demo，实现开发时使用单机redis，线上使用集群redis
详解springboot配置多个redis连接
08-30
Spring Boot为Redis, MongoDB, Elasticsearch, Solr和Gemfire提供自动配置。本文详细介绍了springboot配置多个redis连接，有兴趣的可以了解一下。
多租户方案
08-01
mycat多租户
springboot redis分布式锁代码实例
08-25
"SpringBoot Redis分布式锁代码实例" SpringBoot Redis分布式锁代码实例是指通过SpringBoot框架和Redis数据库来实现分布式锁的机制。分布式锁是指在分布式系统中，多个节点或进程需要访问共享资源时，为了避免冲突...
SpringBoot中配置redis的序列化方式实战
nandao158的博客
12-14 3533
springboot项目中使用redis是很常见的业务场景，今天我们分享一下boot项目中，redis的连接配置、序列化等。 1、引入jar <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> <version>2.1.6.RELEASE</version>
多租户改造（字段隔离和表隔离混合模式）
crf_c的博客
09-27 3026
字段隔离为主，表隔离为辅实现多租户改造
redisTemplate.opsForValue()中方法讲解
FighterLiu的专栏
10-27 3万+
查看源码可以看到redisTemplate.opsForValue()中的方法都定义在ValueOperations<K, V> 中，该接口中一共有17个方法： public interface ValueOperations<K, V> { void set(K key, V value); void set(K key, V value, long timeout, TimeUnit unit); Boolean setIfAbsent(K key, V value);
华为云企业级Redis第17期：集群搭载多DB，多租隔离更降本
GaussDB数据库
03-23 1188
GaussDB(for Redis)支持真正可扩展的多DB，轻松实现降本增效
【Spring】Day19
shortcutsuccess的博客
09-20 451
当已经安装Redis，并确保环境变量可用后，可以在命令提示符窗口（CMD）或终端（IDEA的Terminal，或MacOS/Linux的命令窗口）中执行相关命令。在终端下，可以通过redis-cliredis-cli在Redis客户端中，可以通过ping检测Redis是否正常工作，将得到PONGping在Redis客户端中，可以通过set命令向Redis中或在Redis客户端中，可以通过get命令从Redis中get name如果使用的Key并不存在，使用get命令时，得到的结果将是(nil)
多租户用户管理常用业务场景
加斯特独挨踢
11-23 1万+
在多租户用户管理系统中，常见的业务场景有以下几种： 用户注册 用户通过填写手机号码等信息，进行注册操作；该场景这重验证用户手机号码的有效性，一般通过短信验证码进行验证； 租户注册 用户通过填写租户的相关信息，注册租户，该用户默认为租户的超级管理员。该场景注重收集租户的相关信息； 用户登录 通过验证用户的手机和密码等方式，进
springboot 实现redis 多租户隔离
11-02
在 Spring Boot 中实现 Redis 多租户隔离可以通过以下步骤实现： 1. 配置 RedisTemplate Bean，指定 Redis 连接工厂和序列化方式。 2. 创建一个 RedisKeyGenerator 类，用于生成 Redis Key，可以根据租户信息生成...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值