nacos服务端服务注册原理_4(订阅者客户端接收服务端推送的serviceInfo请求)

已于 2022-08-09 17:48:00 修改
阅读量4k 收藏 6
点赞数
分类专栏： nacos spring cloud 文章标签： java spring cloud
于 2022-07-02 12:23:41 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guntun8987/article/details/125570748
版权

在nacos服务端服务注册原理_3文章分析到了当服务端接收到服务注册和注销后，通过一系列的事件发布后和处理后，最后会通过grpc再通知给对应的订阅服务的客户端，这篇文章就来分析客户端接收服务端相应的过程

客户端的监听

NacosWatch

public class NacosWatch
		implements ApplicationEventPublisherAware, SmartLifecycle, DisposableBean {...}

NacosWatch实现了SmartLifecycle接口，所以当容器启动后会执行start方法。下面来分析此方法

NacosWatch.start()

public void start() {
	//判断服务端通知的监听是否开启，没有的话设置为true然后开启监听
	if (this.running.compareAndSet(false, true)) {
		EventListener eventListener = listenerMap.computeIfAbsent(buildKey(),
				event -> new EventListener() {
					@Override
					//当接口服务端通知后处理even事件
					public void onEvent(Event event) {
						if (event instanceof NamingEvent) {
							List<Instance> instances = ((NamingEvent) event)
									.getInstances();
							Optional<Instance> instanceOptional = selectCurrentInstance(
									instances);
							instanceOptional.ifPresent(currentInstance -> {
								resetIfNeeded(currentInstance);
							});
						}
					}
				});
		//获得namingService ，此方法内会创建接收服务端的grpc连接
		NamingService namingService = nacosServiceManager
				.getNamingService(properties.getNacosProperties());
		try {
			namingService.subscribe(properties.getService(), properties.getGroup(),
					Arrays.asList(properties.getClusterName()), eventListener);
		}
		catch (Exception e) {
			log.error("namingService subscribe failed, properties:{}", properties, e);
		}

		this.watchFuture = this.taskScheduler.scheduleWithFixedDelay(
				this::nacosServicesWatch, this.properties.getWatchDelay());
	}
}
nacosServiceManager.getNamingService(properties.getNacosProperties())

此方法会创建接收服务端的grpc连接，链路较长为
NacosServiceManager.getNamingService
—>
NacosServiceManager.buildNamingService(properties)
—>
NacosServiceManager.createNewNamingService(properties)
—>
NacosServiceManager.createNamingService(properties)
—>
NamingFactory.createNamingService(properties)

Class<?> driverImplClass = Class.forName("com.alibaba.nacos.client.naming.NacosNamingService");
Constructor constructor = driverImplClass.getConstructor(Properties.class);
return (NamingService) constructor.newInstance(properties);

—>
(NamingService) constructor.newInstance(properties)
—>
public NacosNamingService(Properties properties)
—>
NacosNamingService.init(properties)
—>
new NamingClientProxyDelegate(...)
—>
new NamingGrpcClientProxy(...)
—>
NamingGrpcClientProxy.start(serverListFactory, serviceInfoHolder)

NamingGrpcClientProxy.start(serverListFactory, serviceInfoHolder)

此方法开始真正的建立接收服务端的grpc连接

private void start(ServerListFactory serverListFactory, ServiceInfoHolder serviceInfoHolder) throws NacosException {
    rpcClient.serverListFactory(serverListFactory);
    // 注册连接事件Listener，当连接建立和断开时处理事件
    rpcClient.registerConnectionListener(redoService);
    //在客户端建立gRPC时，注册registerServerRequestHandler
    //用于处理从服务端推送到客户端的请求，添加到了serverRequestHandlers集合
    rpcClient.registerServerRequestHandler(new NamingPushRequestHandler(serviceInfoHolder));
    //grpc客户端启动
    rpcClient.start();
    NotifyCenter.registerSubscriber(this);
}

RpcClient.start()

public final void start() throws NacosException {
    
    boolean success = rpcClientStatus.compareAndSet(RpcClientStatus.INITIALIZED, RpcClientStatus.STARTING);
    if (!success) {
        return;
    
    /**
     * 省略
     */
    //connect to server ,try to connect to server sync once, async starting if fail.
    Connection connectToServer = null;
    rpcClientStatus.set(RpcClientStatus.STARTING);
    
    int startUpRetryTimes = RETRY_TIMES;
    while (startUpRetryTimes > 0 && connectToServer == null) {
        try {
            startUpRetryTimes--;
            ServerInfo serverInfo = nextRpcServer();
            
            LoggerUtils.printIfInfoEnabled(LOGGER, "[{}] Try to connect to server on start up, server: {}", name,
                    serverInfo);
            
            connectToServer = connectToServer(serverInfo);
        } catch (Throwable e) {
            LoggerUtils.printIfWarnEnabled(LOGGER,
                    "[{}]Fail to connect to server on start up, error message={}, start up retry times left: {}",
                    name, e.getMessage(), startUpRetryTimes);
        }
        
    }
    
    if (connectToServer != null) {
        LoggerUtils.printIfInfoEnabled(LOGGER, "[{}] Success to connect to server [{}] on start up,connectionId={}",
                name, connectToServer.serverInfo.getAddress(), connectToServer.getConnectionId());
        this.currentConnection = connectToServer;
        rpcClientStatus.set(RpcClientStatus.RUNNING);
        eventLinkedBlockingQueue.offer(new ConnectionEvent(ConnectionEvent.CONNECTED));
    } else {
        switchServerAsync();
    }
    
    registerServerRequestHandler(new ConnectResetRequestHandler());
    
    //register client detection request.
    registerServerRequestHandler(new ServerRequestHandler() {
        @Override
        public Response requestReply(Request request) {
            if (request instanceof ClientDetectionRequest) {
                return new ClientDetectionResponse();
            }
            
            return null;
        }
    });
    
}
RpcClient.connectToServer(serverInfo)
public Connection connectToServer(ServerInfo serverInfo) {
    try {
        if (grpcExecutor == null) {
            int threadNumber = ThreadUtils.getSuitableThreadCount(8);
            grpcExecutor = new ThreadPoolExecutor(threadNumber, threadNumber, 10L, TimeUnit.SECONDS,
                    new LinkedBlockingQueue<>(10000),
                    new ThreadFactoryBuilder().setDaemon(true).setNameFormat("nacos-grpc-client-executor-%d")
                            .build());
            grpcExecutor.allowCoreThreadTimeOut(true);
            
        }
        int port = serverInfo.getServerPort() + rpcPortOffset();
        RequestGrpc.RequestFutureStub newChannelStubTemp = createNewChannelStub(serverInfo.getServerIp(), port);
        if (newChannelStubTemp != null) {
            
            Response response = serverCheck(serverInfo.getServerIp(), port, newChannelStubTemp);
            if (response == null || !(response instanceof ServerCheckResponse)) {
                shuntDownChannel((ManagedChannel) newChannelStubTemp.getChannel());
                return null;
            }
            
            BiRequestStreamGrpc.BiRequestStreamStub biRequestStreamStub = BiRequestStreamGrpc
                    .newStub(newChannelStubTemp.getChannel());
            GrpcConnection grpcConn = new GrpcConnection(serverInfo, grpcExecutor);
            grpcConn.setConnectionId(((ServerCheckResponse) response).getConnectionId());
            
            //在连接server时绑定相关事件
            StreamObserver<Payload> payloadStreamObserver = bindRequestStream(biRequestStreamStub, grpcConn);
            
            
            grpcConn.setPayloadStreamObserver(payloadStreamObserver);
            grpcConn.setGrpcFutureServiceStub(newChannelStubTemp);
            grpcConn.setChannel((ManagedChannel) newChannelStubTemp.getChannel());
            
            ConnectionSetupRequest conSetupRequest = new ConnectionSetupRequest();
            conSetupRequest.setClientVersion(VersionUtils.getFullClientVersion());
            conSetupRequest.setLabels(super.getLabels());
            conSetupRequest.setAbilities(super.clientAbilities);
            conSetupRequest.setTenant(super.getTenant());
            grpcConn.sendRequest(conSetupRequest);
            //wait to register connection setup
            Thread.sleep(100L);
            return grpcConn;
        }
        return null;
    } catch (Exception e) {
        LOGGER.error("[{}]Fail to connect to server!,error={}", GrpcClient.this.getName(), e);
    }
    return null;
}
RpcClient.bindRequestStream
private StreamObserver<Payload> bindRequestStream(final BiRequestStreamGrpc.BiRequestStreamStub streamStub,
        final GrpcConnection grpcConn) {
    
    return streamStub.requestBiStream(new StreamObserver<Payload>() {
        
        @Override
        public void onNext(Payload payload) {
            
            LoggerUtils.printIfDebugEnabled(LOGGER, "[{}]Stream server request receive, original info: {}",
                    grpcConn.getConnectionId(), payload.toString());
            try {
                Object parseBody = GrpcUtils.parse(payload);
                final Request request = (Request) parseBody;
                if (request != null) {
                    
                    try {
                        //接受server push处理
                        Response response = handleServerRequest(request);
                        if (response != null) {
                            response.setRequestId(request.getRequestId());
                            sendResponse(response);
                        } else {
                            LOGGER.warn("[{}]Fail to process server request, ackId->{}", grpcConn.getConnectionId(),
                                    request.getRequestId());
                        }
                        
                    } catch (Exception e) {
                        LoggerUtils.printIfErrorEnabled(LOGGER, "[{}]Handle server request exception: {}",
                                grpcConn.getConnectionId(), payload.toString(), e.getMessage());
                        sendResponse(request.getRequestId(), false);
                    }
                    
                }
                
            } catch (Exception e) {
                LoggerUtils.printIfErrorEnabled(LOGGER, "[{}]Error to process server push response: {}",
                        grpcConn.getConnectionId(), payload.getBody().getValue().toStringUtf8());
            }
        }
        
       
    });
}
RpcClient.handleServerRequest
protected Response handleServerRequest(final Request request) {
    
    LoggerUtils.printIfInfoEnabled(LOGGER, "[{}]receive server push request,request={},requestId={}", name,
            request.getClass().getSimpleName(), request.getRequestId());
    lastActiveTimeStamp = System.currentTimeMillis();
    //此循环中有个元素是NamingPushRequestHandler
    for (ServerRequestHandler serverRequestHandler : serverRequestHandlers) {
        try {
            Response response = serverRequestHandler.requestReply(request);
            
            if (response != null) {
                LoggerUtils.printIfInfoEnabled(LOGGER, "[{}]ack server push request,request={},requestId={}", name,
                        request.getClass().getSimpleName(), request.getRequestId());
                return response;
            }
        } catch (Exception e) {
            LoggerUtils.printIfInfoEnabled(LOGGER, "[{}]handleServerRequest:{}, errorMessage={}", name,
                    serverRequestHandler.getClass().getName(), e.getMessage());
        }
        
    }
    return null;
}
NamingPushRequestHandler.requestReply(Request request)
public Response requestReply(Request request) {
    if (request instanceof NotifySubscriberRequest) {
        NotifySubscriberRequest notifyResponse = (NotifySubscriberRequest) request;
        serviceInfoHolder.processServiceInfo(notifyResponse.getServiceInfo());
        return new NotifySubscriberResponse();
    }
    return null;
}

到这里serviceInfoHolder.processServiceInfo(notifyResponse.getServiceInfo())更新缓存的逻辑nacos客户端获取服务原理(订阅机制)已经做了详细的分析，这里只分析事件发布机制
serviceInfoHolder.processServiceInfo(serviceObj)

public ServiceInfo processServiceInfo(ServiceInfo serviceInfo) {
    /**
     * 省略
     */
    
    NAMING_LOGGER.info("current ips:(" + serviceInfo.ipCount() + ") service: " + serviceInfo.getKey() + " -> "
            + JacksonUtils.toJson(serviceInfo.getHosts()));
    // 添加实例变更事件，会被订阅者执行
    NotifyCenter.publishEvent(new InstancesChangeEvent(serviceInfo.getName(), serviceInfo.getGroupName(),
            serviceInfo.getClusters(), serviceInfo.getHosts()));
    return serviceInfo;
}

事件发布机制 NotifyCenter.publishEvent(new InstancesChangeEvent(…))

事件发布机制的详细过程在nacos服务端服务注册原理_2和_3文章中，针对服务端的事件发布机制已做了详细的分析，客户端流程也是相同，所以这里只分析主要的过程。

NotifyCenter.publishEvent(new InstancesChangeEvent(…))

  1. 当发布了InstancesChangeEvent事件后，仍旧放入队列queue中.
  2. 放入队列失败，或者放入成功从队列取出后，都是执行DefaultPublisher.receiveEvent
  3. 然后执行InstancesChangeNotifier.onEvent(InstancesChangeEvent event)

InstancesChangeNotifier.onEvent(InstancesChangeEvent event)

在这里插入图片描述
可以看到for循环中的listener就是NacosWatch中的eventListener，然后就执行onEvent中的逻辑了。

EventListener.onEvent
EventListener eventListener = listenerMap.computeIfAbsent(buildKey(),
    event -> new EventListener() {
        @Override
        public void onEvent(Event event) {
            if (event instanceof NamingEvent) {
                List<Instance> instances = ((NamingEvent) event)
                        .getInstances();
                Optional<Instance> instanceOptional = selectCurrentInstance(
                        instances);
                instanceOptional.ifPresent(currentInstance -> {
                    resetIfNeeded(currentInstance);
                });
            }
        }
    });

到这里还有个问题，NacosWatch中的eventListener是什么时候放入到InstancesChangeNotifier里的listenerMap呢。

回到NacosWatch.start()

public void start() {
    if (this.running.compareAndSet(false, true)) {
        EventListener eventListener = listenerMap.computeIfAbsent(buildKey(),
                event -> new EventListener() {
                    @Override
                    public void onEvent(Event event) {
                        if (event instanceof NamingEvent) {
                            List<Instance> instances = ((NamingEvent) event)
                                    .getInstances();
                            Optional<Instance> instanceOptional = selectCurrentInstance(
                                    instances);
                            instanceOptional.ifPresent(currentInstance -> {
                                resetIfNeeded(currentInstance);
                            });
                        }
                    }
                });

        NamingService namingService = nacosServiceManager
                .getNamingService(properties.getNacosProperties());
        try {
            namingService.subscribe(properties.getService(), properties.getGroup(),
                    Arrays.asList(properties.getClusterName()), eventListener);
        }
        catch (Exception e) {
            log.error("namingService subscribe failed, properties:{}", properties, e);
        }

        this.watchFuture = this.taskScheduler.scheduleWithFixedDelay(
                this::nacosServicesWatch, this.properties.getWatchDelay());
    }
}

重点关注namingService.subscribe

namingService.subscribe(properties.getService(), properties.getGroup(),
		 Arrays.asList(properties.getClusterName()), eventListener)

public void subscribe(String serviceName, String groupName, List<String> clusters, EventListener listener)
        throws NacosException {
    if (null == listener) {
        return;
    }
    String clusterString = StringUtils.join(clusters, ",");
	//这时的changeNotifier实际就是InstancesChangeNotifier
    changeNotifier.registerListener(groupName, serviceName, clusterString, listener);
    clientProxy.subscribe(serviceName, groupName, clusterString);
}

InstancesChangeNotifier.registerListener

public void registerListener(String groupName, String serviceName, String clusters, EventListener listener) {
    String key = ServiceInfo.getKey(NamingUtils.getGroupedName(serviceName, groupName), clusters);
    ConcurrentHashSet<EventListener> eventListeners = listenerMap.get(key);
    if (eventListeners == null) {
        synchronized (lock) {
            eventListeners = listenerMap.get(key);
            if (eventListeners == null) {
                eventListeners = new ConcurrentHashSet<EventListener>();
                listenerMap.put(key, eventListeners);
            }
        }
    }
    eventListeners.add(listener);
}

到这里就可以看到NacosWatch中的eventListener是什么时候放入到InstancesChangeNotifier里的listenerMap的过程了。

总结

  1. 服务端接收到服务注册请求后，发布了ClientRegisterServiceEvent客户端注册事件
  2. ClientRegisterServiceEvent事件被ClientServiceIndexesManager订阅后发布ServiceChangedEvent服务变更事件
  3. ServiceChangedEvent被NamingSubscriberServiceV2Impl订阅并创建PushDelayTask并被PushExecuteTask执行，负责向订阅该服务的客户端发起推送serviceInfo请求
  4. 推送的请求被NamingPushRequestHandler处理并发布InstancesChangeEvent，最终回调AbstractEventListener
星哥的编程之路
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
nacosserver2.0.4.zip
05-23
github下载太慢，传一份保留下。
搭建springcloud服务初次启动报错
whatisthespring的博客
02-27 244
启动SpringCloudEureka 报错： com.netflix.discovery.shared.transport.TransportException: Cannot execute request on any known server 原因是SpringCloudEureka这个应用本身就是eureka服务器，不需要不断的尝试连接注册自己。 可以添加以下配置： 如果配置文件a...
Nacos9# 服务端响应连接和注册源码分析（二）
gaoliang1719的专栏
07-19 857
引言在《Nacos4# 服务端响应连接和注册源码分析（一）》在服务注册后发布了三个事件ClientEvent.ClientChangedEvent、ClientOperationEvent...
iOS__推送通知
ZH952016281的博客
11-07 612
推送通知 和本地通知不同，推送通知是由应用服务提供商发起的，通过苹果的APNs（Apple Push Notification Server）发送到应用客户端。下面是苹果官方关于推送通知的过程示意图： 推送通知的过程可以分为以下几步： 应用服务提供商从服务器端把要发送的消息和设备令牌（device token）发送给苹果的消息推送服务器APNs。 APNs根据设备令牌在已
Nacos2# 服务注册与发现客户端示例与源码解析（二）
gaoliang1719的专栏
05-23 2033
引言引言上一篇客户端初始化没有撸完，这篇继续。Nacos从2.0以后增加了对grpc的支持，代码中HTTP的代理初始化还有保留，我们注册发现通常为临时节点，这部分已由gRPC接管。可以对比...
seata 报JacksonUndoLogParser - [encode,127] - json encode exception
zy_crazy_code的博客
02-23 2004
seata序列化错误
nacos Error to process server push response
axe的专栏
08-29 2420
nacos2.0.3报错： Error to process server push response。如果有，把版本改成0.9.11，低于0.9.11会有问题。
nacos2.3.0配置中心问题处理
山炮之家
12-31 1582
问题：Error to process server push response: {"headers":{},"abilityTable":{"supportPersistentInstanceByGrpc":true},"module":"internal"}
【Seata】AT模式常见报错及解决
柒杯红酒
11-14 5504
seata 、RmTransactionException:Runtime、ShouldNeverHappenException、RmTransactionException:Response
Springboot启动出现Error to process server push response的解决方法
码农研究僧的博客
12-17 1580
注意，此篇博客只提供一种bug排查思路，毕竟每个项目引起的依赖包冲突都不一致
nacos服务端下载安装和客户端源码
09-28
1、Springboot 实践（16）Nacos server 2.2.3 下载安装 2、Springboot 实践（17）spring boot整合Nacos配置中心 3、Springboot 实践（18）Nacos配置中心...5、Springboot-Nacos-Client Springboot整合Nacos客户端源代码
nacos-server-1.1.4.tar（Nacos控制台，Nacos服务端）
11-06
Nacos的服务台程序。Spring-Cloud-Alibaba中的服务治理采用了Nacos，只需要解压资源后，运行bin目录下的开始脚本即可，支持Linux，Windows，Mac系统。1.1.4是截止到目前2019年11月的最新版本。
nacos服务端安装程序
12-29
用于微服务的注册与发现 nacos的服务端安装程序包 直接点击一直下一步即可安装
Nacos配置中心原理分析
02-02
动态配置管理是Nacos的三大功能之一，通过动态配置服务，我们可以在所有环境中以集中和动态的方式管理所有应用程序或服务的配置信息。动态配置中心可以实现配置更新时无需重新部署应用程序和服务即可使相应的配置...
Nacos源码流程——服务注册与发现.png
04-02
Nacos服务注册与发现源码流程图， 通过流程图展示了服务注册到Nacos服务注册中心的整个源码过程，同时对Nacos代码中一些优秀的思想进行总结
java方法重写（重点讲），方法重载
weixin_46281068的博客
04-27 1249
一、方法重载定义：一个类中，出现多个方法的名称相同，但是它们的形参列表是不同的，那么这些方法就称为方法重载了。注意：一个类中，只要一些方法的名称相同、形参列表不同，那么它们就是方法重载了，其它的都不管（如:修饰符，返回值类型是否一样都无所谓）。形参列表不同指的是:形参的个数、类型、顺序不同，不关心形参的名称。应用场景：开发中我们经常需要为处理一类业务，提供多种解决方案，此时用方法重载来设计是很专业的。
Day25-Java基础之常用类1
m0_46053885的博客
04-27 1099
同时我们发现Math类中的方法都是静态的，因此在使用的时候我们可以直接通过类名去调用。对于计算机而言，其实是没有数据类型的概念的，都是0101010101，数据类型是编程语言自己规定的，所以在实际存储的时候，先把具体的数字变成二进制，每32个bit为一组，存储在数组中。比较内存地址值一般情况下是没有意义的，我们希望比较的是对象的属性，如果两个对象的属性相同，我们认为就是同一个对象；如果我们的数据是一个浮点类型的数据，有的时候计算机并不会将这个数据完全转换成一个二进制数据，而是将这个将其转换成一个无限的。
Spring Cloud——LoadBalancer
最新发布
????
05-01 1104
这里只是简单的讲解了一下LoadBalancer如何使用，因为实际上我们使用的不是很多，主要还是使用OpenFeign。
d15(136-148)-勇敢开始Java，咖啡拯救人生
m0_73459387的博客
04-28 1061
对象哈希值的特点：同一个对象调用hashCode()返回的哈希值相同；HashMap的键依赖hashCode方法和equals方法保证键的唯一，存储自定义类型的对象时，重写这两个方法。实际上，Set系列集合的底层就是基于Map实现的，只是Set集合中的元素要键数据，不要值数据。当12个位置都占满时就会扩容，大约扩容为原来的二倍，再把原数组数据转移到新数组。使用迭代器遍历集合时，又同时在删除集合中的数据，程序就会出现并发修改异常的错误。基于哈希表实现，每个键值对额外多了一个双链表的机制，记录元素顺序（保证。
idea在springboot2.7.12下nacos创建服务端与客户端，实现服务的注册与发现
06-02
下面是在 Spring Boot 2.7.12 中使用 Nacos 实现服务注册与发现的步骤： 1. 引入 Nacos 相关依赖 在 pom.xml 文件中添加以下依赖： ```xml <dependency> <groupId>com.alibaba.cloud</groupId> <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId> <version>2.2.6.RELEASE</version> </dependency> ``` 2. 配置 Nacos 服务器地址 在 application.yml 文件中添加以下配置： ```yaml spring: cloud: nacos: discovery: server-addr: localhost:8848 ``` 其中，server-addr 指定了 Nacos 服务器的地址。 3. 创建服务提供者 在 Spring Boot 应用中，可以通过添加 @EnableDiscoveryClient 注解来启用服务注册与发现功能。同时，需要在服务提供者的代码中添加 @RestController 和 @GetMapping 注解，定义一个简单的 REST 接口，用于测试服务的注册与发现。 ```java @RestController public class HelloController { @GetMapping("/hello") public String hello() { return "Hello, Nacos!"; } } ``` 4. 创建服务消费者 在服务消费者的代码中，同样需要添加 @EnableDiscoveryClient 注解来启用服务注册与发现功能。同时，需要使用 @Autowired 注解注入一个 RestTemplate 对象，并使用 @LoadBalanced 注解对其进行修饰，以支持负载均衡。具体代码如下： ```java @RestController public class ConsumerController { @Autowired @LoadBalanced private RestTemplate restTemplate; @GetMapping("/hello") public String hello() { String url = "http://service-provider/hello"; return restTemplate.getForObject(url, String.class); } } ``` 其中，service-provider 是服务提供者的应用名称，可以通过 @GetMapping 注解中的 URL 地址进行访问。 5. 运行应用 启动服务提供者和服务消费者应用后，可以通过 Nacos 控制台进行服务的注册与发现，或者直接通过服务消费者的接口进行访问。 以上就是在 Spring Boot 2.7.12 中使用 Nacos 实现服务注册与发现的简单示例，希望对你有所帮助。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值