Dubbo Cluster

已于 2022-12-02 23:22:34 修改
阅读量309 收藏
点赞数
分类专栏： Dubbo 文章标签： Spring java AOP
于 2022-03-29 07:30:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lijinxiong520/article/details/123810814
版权

Cluster 层

集群容错层、该层中包含 Cluster、Directory、Router、LoadBalance几大核心接口

@SPI(FailoverCluster.NAME)
public interface Cluster {
    @Adaptive
    <T> Invoker<T> join(Directory<T> directory) throws RpcException;
}

image-20220305143240818

这个版本有 10 种容错机制

每个具体的 Cluster 实现都是创建一个对应的 Invoker、然后直接返回

Failover

当出现失败时、会重试其他服务器、用户可以通过 retries 参数设置重试次数、默认是两次。是 Dubbo 的默认容错机制。会对服务提供者列表做负载均衡、通常使用在读操作或者幂等写操作。但重试会导致接口延迟增大、增加下游服务器的负载。

@Override
public <T> AbstractClusterInvoker<T> doJoin(Directory<T> directory) throws RpcException {
    return new FailoverClusterInvoker<>(directory);
}

从继承关系图中我们知道它的父类是 AbstractCluster 。 invoke 方法如下

@Override
public Result invoke(final Invocation invocation) throws RpcException {
    checkWhetherDestroyed();

    // binding attachments into invocation.
    Map<String, Object> contextAttachments = RpcContext.getContext().getObjectAttachments();
    if (contextAttachments != null && contextAttachments.size() != 0) {
        ((RpcInvocation) invocation).addObjectAttachments(contextAttachments);
    }
		
    List<Invoker<T>> invokers = list(invocation);
    LoadBalance loadbalance = initLoadBalance(invokers, invocation);
    RpcUtils.attachInvocationIdIfAsync(getUrl(), invocation);
    return doInvoke(invocation, invokers, loadbalance);
}
  • list(invocation) 从 Directory 中获取提供者的列表
  • initLoadBalance(invokers, invocation); 选择出负载均衡策略
  • doInvoke(invocation, invokers, loadbalance) 调用子类具体实现

很明显、这个是一个模板方法

public Result doInvoke(Invocation invocation, final List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
    List<Invoker<T>> copyInvokers = invokers;
    checkInvokers(copyInvokers, invocation);
    String methodName = RpcUtils.getMethodName(invocation);
    int len = getUrl().getMethodParameter(methodName, RETRIES_KEY, DEFAULT_RETRIES) + 1;
    if (len <= 0) {
        len = 1;
    }
    // retry loop.
    RpcException le = null; // last exception.
    List<Invoker<T>> invoked = new ArrayList<Invoker<T>>(copyInvokers.size()); // invoked invokers.
    Set<String> providers = new HashSet<String>(len);
    for (int i = 0; i < len; i++) {
        //Reselect before retry to avoid a change of candidate `invokers`.
        //NOTE: if `invokers` changed, then `invoked` also lose accuracy.
        if (i > 0) {
            checkWhetherDestroyed();
            copyInvokers = list(invocation);
            // check again
            checkInvokers(copyInvokers, invocation);
        }
        Invoker<T> invoker = select(loadbalance, invocation, copyInvokers, invoked);
        invoked.add(invoker);
        RpcContext.getContext().setInvokers((List) invoked);
        try {
            Result result = invoker.invoke(invocation);
            return result;
        } catch (RpcException e) {
            if (e.isBiz()) { // biz exception.
                throw e;
            }
            le = e;
        } catch (Throwable e) {
            le = new RpcException(e.getMessage(), e);
        } finally {
            providers.add(invoker.getUrl().getAddress());
        }
    }
    throw new RpcException(le.getCode(), "Failed to invoke the method ");
}
  • checkInvokers(copyInvokers, invocation) 判断 Invoker 列表是否为空、为空则抛出异常
  • int len = getUrl().getMethodParameter(methodName, RETRIES_KEY, DEFAULT_RETRIES) + 1; 获取用户配置的重试次数、如果没有则默认是重试 2 次、这里 +1 是因为正常调用
  • invoked 变脸用于存储已经发起调用过的 Invoker、也就是存在于这个集合里面的、都是调用过发生RPC异常的
  • 当你第一次调用失败之后、那么每一次循环都会重新从 Diretory 中获取最新的 Invoker 列表、因为调用次数是死的、已经失败过一次了、尽可能保证被调用的 Invoker 的质量
  • select(loadbalance, invocation, copyInvokers, invoked) 根据具体的负载均衡算法算出一个 Invoker

Failfast

快速失败、当请求失败之后、快速返回异常结、不做任何重试

@Override
public Result doInvoke(Invocation invocation, List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
    checkInvokers(invokers, invocation);
    Invoker<T> invoker = select(loadbalance, invocation, invokers, null);
    try {
        return invoker.invoke(invocation);
    } catch (Throwable e) {
        if (e instanceof RpcException && ((RpcException) e).isBiz()) { // biz exception.
            throw (RpcException) e;
        }
        throw new RpcException();
    }

负载均衡选出一个 Invoker 之后直接进行调用。如果有异常、直接抛出

这个通常使用在非幂等的接口中、但是该策略受网络抖动影响较大。

Failsafe

当出现异常时、直接忽略异常。通常对调用结果不关心、并且不想影响外层调用。比如说上传一些不重要的日志啊、监控数据啊

@Override
public Result doInvoke(Invocation invocation, List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
    try {
        checkInvokers(invokers, invocation);
        Invoker<T> invoker = select(loadbalance, invocation, invokers, null);
        return invoker.invoke(invocation);
    } catch (Throwable e) {
        return AsyncRpcResult.newDefaultAsyncResult(null, null, invocation); // ignore
    }
}

Failback

请求失败之后、会自动记录在失败记录中、并有一个定时线程池定时重试、适用于一些异步或者最终一致性的请求

@Override
protected Result doInvoke(Invocation invocation, List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
    Invoker<T> invoker = null;
    try {
        checkInvokers(invokers, invocation);
        invoker = select(loadbalance, invocation, invokers, null);
        return invoker.invoke(invocation);
    } catch (Throwable e) {
        addFailed(loadbalance, invocation, invokers, invoker);
        return AsyncRpcResult.newDefaultAsyncResult(null, null, invocation); // ignore
    }
}

private void addFailed(LoadBalance loadbalance, Invocation invocation, List<Invoker<T>> invokers, Invoker<T> lastInvoker) {
    if (failTimer == null) {
        synchronized (this) {
            if (failTimer == null) {
                failTimer = new HashedWheelTimer(
                        new NamedThreadFactory("failback-cluster-timer", true),
                        1,
                        TimeUnit.SECONDS, 32, failbackTasks);
            }
        }
    }
    RetryTimerTask retryTimerTask = new RetryTimerTask(loadbalance, invocation, invokers, lastInvoker, retries, RETRY_FAILED_PERIOD);
    try {
        failTimer.newTimeout(retryTimerTask, RETRY_FAILED_PERIOD, TimeUnit.SECONDS);
    } catch (Throwable e) {
    }
}

@Override
public void run(Timeout timeout) {
  try {
    Invoker<T> retryInvoker = select(loadbalance, invocation, invokers, Collections.singletonList(lastInvoker));
    lastInvoker = retryInvoker;
    retryInvoker.invoke(invocation);
  } catch (Throwable e) {
    if ((++retryTimes) >= retries) {
    } else {
      rePut(timeout);
    }
  }
}

这个后续的调度重试涉及到时间轮的设计、但是我们在这里只要知道它也会重试、这里默认重试的次数是三次

Forking

同时调用多个相同的服务、只要其中一个返回、则立即返回结果。用户可以配置 forking 参数、来确定最大并行调用的服务数量。

通常使用在对接口实时性要求极高的调用上、但会浪费更多的资源

@Override
@SuppressWarnings({"unchecked", "rawtypes"})
public Result doInvoke(final Invocation invocation, List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
    try {
        checkInvokers(invokers, invocation);
        final List<Invoker<T>> selected;
        final int forks = getUrl().getParameter(FORKS_KEY, DEFAULT_FORKS);
        final int timeout = getUrl().getParameter(TIMEOUT_KEY, DEFAULT_TIMEOUT);
        if (forks <= 0 || forks >= invokers.size()) {
            selected = invokers;
        } else {
            selected = new ArrayList<>(forks);
            while (selected.size() < forks) {
                Invoker<T> invoker = select(loadbalance, invocation, invokers, selected);
                if (!selected.contains(invoker)) {
                    selected.add(invoker);
                }
            }
        }
        RpcContext.getContext().setInvokers((List) selected);
        final AtomicInteger count = new AtomicInteger();
        final BlockingQueue<Object> ref = new LinkedBlockingQueue<>();
        for (final Invoker<T> invoker : selected) {
            executor.execute(() -> {
                try {
                    Result result = invoker.invoke(invocation);
                    ref.offer(result);
                } catch (Throwable e) {
                    int value = count.incrementAndGet();
                    if (value >= selected.size()) {
                        ref.offer(e);
                    }
                }
            });
        }
        try {
            Object ret = ref.poll(timeout, TimeUnit.MILLISECONDS);
            if (ret instanceof Throwable) {
                Throwable e = (Throwable) ret;
                throw new RpcException("");
            }
            return (Result) ret;
        } catch (InterruptedException e) {
            throw new RpcException();
        }
    } finally {
        // clear attachments which is binding to current thread.
        RpcContext.getContext().clearAttachments();
    }
}

默认最大的并行数是 2 个、超时时间是 1 秒。

第一步就是选出合适的 invoker、根据负载均衡算法。如果 forking 的数量大于等于 invoker 的数量、那么就直接不用选了

后续使用线程池异步发起调用、使用 BlockingQueue 对存储结果。最后使用 poll 等待结果、

Broadcast

广播调用所有可用服务、任意一个节点报错则报错。因为请求是调用所以节点、所以不需要做负载均衡

@Override
@SuppressWarnings({"unchecked", "rawtypes"})
public Result doInvoke(final Invocation invocation, List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
    checkInvokers(invokers, invocation);
    RpcContext.getContext().setInvokers((List) invokers);
    RpcException exception = null;
    Result result = null;
    for (Invoker<T> invoker : invokers) {
        try {
            result = invoker.invoke(invocation);
        } catch (RpcException e) {
            exception = e;
            logger.warn(e.getMessage(), e);
        } catch (Throwable e) {
            exception = new RpcException(e.getMessage(), e);
            logger.warn(e.getMessage(), e);
        }
    }
    if (exception != null) {
        throw exception;
    }
    return result;
}

Mock

提供者调用失败时、返回伪造的响应结果。或直接强制返回伪造结果、不会发起远程调用

@Override
public Result invoke(Invocation invocation) throws RpcException {
    Result result = null;

    String value = getUrl().getMethodParameter(invocation.getMethodName(), MOCK_KEY, Boolean.FALSE.toString()).trim();
    if (value.length() == 0 || "false".equalsIgnoreCase(value)) {
        //no mock
        result = this.invoker.invoke(invocation);
    } else if (value.startsWith("force")) {
        if (logger.isWarnEnabled()) {
            logger.warn("force-mock: " + invocation.getMethodName() + " force-mock enabled , url : " + getUrl());
        }
        //force:direct mock
        result = doMockInvoke(invocation, null);
    } else {
        //fail-mock
        try {
            result = this.invoker.invoke(invocation);

            //fix:#4585
            if(result.getException() != null && result.getException() instanceof RpcException){
                RpcException rpcException= (RpcException)result.getException();
                if(rpcException.isBiz()){
                    throw  rpcException;
                }else {
                    result = doMockInvoke(invocation, rpcException);
                }
            }

        } catch (RpcException e) {
            if (e.isBiz()) {
                throw e;
            }
            result = doMockInvoke(invocation, e);
        }
    }
    return result;
}
  • 默认情况下、或者明确配置了 false、那么直接调用 invoker
  • 配置了 force 开头、那么直接走 mock 逻辑(相当于熔断了)
  • 除了上面的情况、invoker 失败或者异常的情况下、走 mock (相当于降级)

Available

最简单的方式、请求不会负载均衡、使用列表中的第一个 invoker

@Override
public Result doInvoke(Invocation invocation, List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
    for (Invoker<T> invoker : invokers) {
        if (invoker.isAvailable()) {
            return invoker.invoke(invocation);
        }
    }
    throw new RpcException("No provider available in " + invokers);
}

Mergeable

自动把多个节点请求得到的结果进行合并

@Override
protected Result doInvoke(Invocation invocation, List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
    checkInvokers(invokers, invocation);
    String merger = getUrl().getMethodParameter(invocation.getMethodName(), MERGER_KEY);
    if (ConfigUtils.isEmpty(merger)) { // If a method doesn't have a merger, only invoke one Group
        for (final Invoker<T> invoker : invokers) {
            if (invoker.isAvailable()) {
                try {
                    return invoker.invoke(invocation);
                } catch (RpcException e) {
                        throw e;
                }
            }
        }
        return invokers.iterator().next().invoke(invocation);
    }

    Class<?> returnType;
    try {
        returnType = getInterface().getMethod(
                invocation.getMethodName(), invocation.getParameterTypes()).getReturnType();
    } catch (NoSuchMethodException e) {
        returnType = null;
    }

    Map<String, Result> results = new HashMap<>();
    for (final Invoker<T> invoker : invokers) {
        RpcInvocation subInvocation = new RpcInvocation(invocation, invoker);
        subInvocation.setAttachment(ASYNC_KEY, "true");
        results.put(invoker.getUrl().getServiceKey(), invoker.invoke(subInvocation));
    }

    Object result = null;

    List<Result> resultList = new ArrayList<Result>(results.size());

    for (Map.Entry<String, Result> entry : results.entrySet()) {
        Result asyncResult = entry.getValue();
        try {
            Result r = asyncResult.get();
            if (r.hasException()) {
            } else {
                resultList.add(r);
            }
        } catch (Exception e) {
            throw new RpcException("Failed to invoke service " + entry.getKey() + ": " + e.getMessage(), e);
        }
    }

    if (resultList.isEmpty()) {
        return AsyncRpcResult.newDefaultAsyncResult(invocation);
    } else if (resultList.size() == 1) {
        return resultList.iterator().next();
    }

    if (returnType == void.class) {
        return AsyncRpcResult.newDefaultAsyncResult(invocation);
    }

    if (merger.startsWith(".")) {
        merger = merger.substring(1);
        ..........
    } else {
        Merger resultMerger;
        if (ConfigUtils.isDefault(merger)) {
            resultMerger = MergerFactory.getMerger(returnType);
        } else {
            resultMerger = ExtensionLoader.getExtensionLoader(Merger.class).getExtension(merger);
        }
        if (resultMerger != null) {
            List<Object> rets = new ArrayList<Object>(resultList.size());
            for (Result r : resultList) {
                rets.add(r.getValue());
            }
            result = resultMerger.merge(
                    rets.toArray((Object[]) Array.newInstance(returnType, 0)));
        } else {
            throw new RpcException("There is no merger to merge result.");
        }
    }
    return AsyncRpcResult.newDefaultAsyncResult(result, invocation);
}

调用所有的 invoker、设置为异步调用。后续对返回的结果进行处理合并

内置的合并器

image-20220305201657819

Zone

这个是新版本家的一个集群策略、主要是真的注册中心的负载、也即是对多注册中心进行负载均衡

public Result doInvoke(Invocation invocation, final List<Invoker<T>> invokers, LoadBalance loadbalance) throws RpcException {
    for (Invoker<T> invoker : invokers) {
        ClusterInvoker<T> clusterInvoker = (ClusterInvoker<T>) invoker;
        if (clusterInvoker.isAvailable() && clusterInvoker.getRegistryUrl()
                .getParameter(REGISTRY_KEY + "." + PREFERRED_KEY, false)) {
            return clusterInvoker.invoke(invocation);
        }
    }
    String zone = invocation.getAttachment(REGISTRY_ZONE);
    if (StringUtils.isNotEmpty(zone)) {
        for (Invoker<T> invoker : invokers) {
            ClusterInvoker<T> clusterInvoker = (ClusterInvoker<T>) invoker;
            if (clusterInvoker.isAvailable() && zone.equals(clusterInvoker.getRegistryUrl().getParameter(REGISTRY_KEY + "." + ZONE_KEY))) {
                return clusterInvoker.invoke(invocation);
            }
        }
        String force = invocation.getAttachment(REGISTRY_ZONE_FORCE);
        if (StringUtils.isNotEmpty(force) && "true".equalsIgnoreCase(force)) {
            throw new IllegalStateException();
        }
    }
    // load balance among all registries, with registry weight count in.
    Invoker<T> balancedInvoker = select(loadbalance, invocation, invokers, null);
    if (balancedInvoker.isAvailable()) {
        return balancedInvoker.invoke(invocation);
    }
    for (Invoker<T> invoker : invokers) {
        ClusterInvoker<T> clusterInvoker = (ClusterInvoker<T>) invoker;
        if (clusterInvoker.isAvailable()) {
            return clusterInvoker.invoke(invocation);
        }
    }
    return invokers.get(0).invoke(invocation);
}

  • 如果该 Invoker 中有 preferred 值为 true 、那么就直接选该注册中心

  • 如果消费者和服务注册中心注册地址是在同一个 zone 的话、那么优先选择该服务注册中心

  • 如果都没有配置、那么就根据负载均衡算法选出一个

CoderLi_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Dubbo分析之Cluster层
weixin_34072857的博客
11-22 128
2019独角兽企业重金招聘Python工程师标准>>> ...
实战Dubbo常用参数与服务治理参数配置
YZX2018的博客
05-15 1842
上一编说到了springboot整合dubbo注解版搭建和最简单的RPC远程调用的基本使用，但是dubbo不仅仅是能进行RPC调用，它也是一个服务治理的框架，官网对dubbo的介绍 Apache Dubbo (incubating) |ˈdʌbəʊ| 是一款高性能、轻量级的开源Java RPC框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。 现在...
Dubbo Cluster集群那点你不知道的事。
浅羽技术
11-01 688
现在有这样一个需求：一个如果接口调用失败，需要自动进行重试。虽然关系不大，但是我还是想到了Dubbo的集群容错策略：Failover Cluster，即失败自动切换。（这个转折是不是有点...
Dubbo服务Cluster
shaolong1013的博客
04-19 338
1.简介 为了避免单点故障，现在的应用通常至少会部署在两台服务器上。对于一些负载比较高的服务，会部署更多的服务器。这样，在同一环境下的服务提供者数量会大于1。对于服务消费者来说，同一环境下出现了多个服务提供者。这时会出现一个问题，服务消费者需要决定选择哪个服务提供者进行调用。另外服务调用失败时的处理措施也是需要考虑的，是重试呢，还是抛出异常，亦或是只打印异常等。为了处理这些问题，Dubbo 定义...
dubbo常用配置总结
Bejpse的博客
09-07 1449
1）连接控制或者： //最多在同一时刻接受10个连接2）并发控制如果和都配了 connections，优先.3）负载均衡的配置load balance配置服务的客户端的属性为，此 Loadbalance 会调用并发数最小的 Provider（Consumer端并发数）。4）异步调用客户端的配置；基于 NIO 的非阻塞实现并行调用，客户端不需要启动多线程即可完成并行调用多个远程服务，相对多线程开销较小。
dubbodubbo.zip
05-15
6. **集群（Cluster）**：集群负责将多个服务提供者的实例聚合为一个逻辑服务，提供了负载均衡、故障转移等功能。 7. **路由（Route）**：路由规则允许根据特定条件动态调整服务调用路径，实现流量控制、灰度发布等...
Dubbo 源码分析
09-18
这些策略可以在`com.alibaba.dubbo.rpc.cluster.faulttolerant.FaultToleranceStrategy`接口中找到相应的实现。 通过深入分析Dubbo的源码，开发者可以更好地理解其内部机制，从而优化服务性能，定制更符合业务需求...
dubbo 源码
03-23
`Monitor`组件用于收集服务调用的统计信息，当服务异常时，`Cluster`组件可以根据预设策略进行熔断或降级，例如切换到备选服务或者返回默认值。 六、服务监控 Dubbo提供了服务治理平台，可以实时查看服务的调用...
Dubbo离线文档
11-08
8. **集群容错（Cluster）** 集群容错是处理服务实例故障的关键，Dubbo提供了多种容错策略，如失败快速返回、重试、Failsafe、Failover、Failfast、Forking等，以确保服务的高可用性。 9. **监控（Monitor）** ...
dubbo-2.6.0
01-22
其中，负载均衡算法如随机、轮询、一致性哈希等，可在`com.alibaba.dubbo.rpc.cluster.loadbalance`包下找到源码实现。 6. **协议与序列化** Dubbo支持多种通信协议，如Dubbo协议、RMI、HTTP等，其中Dubbo协议以其...
Dubbo—Cluster剖析
qq_30051265的博客
09-20 1847
概述 本文将介绍以下内容： 集群容错 集群容错模式 自定义扩展集群 集群容错 集群容错 在集群调用失败时，Dubbo 提供了多种容错方案，缺省为 failover 重试。 各节点关系： 这里的 Invoker 是 Provider 的一个可调用 Service 的抽象，Invoker 封装了 Provider 地址及 Service 接口信息 Directory 代表多个 Invoker，...
dubbo-cluster结构简述
icool_ali的博客
07-31 1307
 dubbo的集群子项目结构 dubbo容错，路由及负载均衡策略 （确定cluster 类型，从directory中获取注册信息，router根据规则来过滤list&lt;Invoker&gt; ，然后loadBalance 做负载，抽取 invoker） Cluster(集群容错类型)   Directory(集群服务提供者目录，StaticDirectory中的Static...
dubbo学习笔记 十二 dubbo-cluster
akfly的专栏
12-19 2604
cluster也是从rpc分出来的，包名叫com.alibaba.dubbo.rpc.cluster 也是rpc的一部分,从官方文档中可以看出 确定cluster 类型，从directory中获取注册信息，router根据规则来过滤list ，然后loadBalance 做负载，抽取 invoker Cluster Directory Ro
Dubbo系列之Cluster容错机制和负载均衡机制(六)
贾红平
06-29 765
dd
Dubbo之旅--集群容错和负载均衡
热门推荐
潛龍，勿用
06-30 3万+
当我们的系统中用到Dubbo的集群环境,因为各种原因在集群调用失败时，Dubbo提供了多种容错方案，缺省为failover重试。          Dubbo的集群容错在这里想说说他是因为我们实际的项目中出现了此类的问题,因为依赖的第三方项目出现异常,导致dubbo调用超时,此时使用的是默认的集群容错方式,而配置的reties='3',这样前段系统连续掉用了三次服务,结果可想而知.  
Dubbo笔记 ⑬ ：Dubbo 集群组件 之 Cluster & ClusterInvoker
猫吻鱼的博客
06-04 1603
Dubbo集群容错中存在两个概念，分别是集群接口 Cluster 和 Cluster Invoker，这两者是不同的。Cluster 是接口，而 Cluster Invoker 是一种 Invoker。服务提供者的选择逻辑，以及远程调用失败后的的处理逻辑均是封装在 Cluster Invoker 中。而 Cluster 接口和相关实现类的用途比较简单，仅用于生成 Cluster Invoker。**简单来说，Cluster 就是用来创建 Cluster Invoker 的，并且一一对应。而Cluster 和
Dubbo面试杀招--Dubbo集群容错负载均衡
敖丙
09-24 9208
dubbo系列终章
Dubbo设计经验分享.pptx
最新发布
04-04
6. **Cluster**：集群层负责服务的容错和路由，如Failover、Failfast、Broadcast等策略，以及路由规则的实现。 7. **Transporter**：传输层处理网络通信，包括Exchanger（交换器）和Transport（传输器）。Exchanger...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值