Dubbo

最新推荐文章于 2023-12-03 16:24:38 发布
最新推荐文章于 2023-12-03 16:24:38 发布
阅读量182 收藏
点赞数 1
分类专栏： SpringBoot 文章标签： 分布式 java 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_67296957/article/details/131062288
版权
本文介绍了分布式系统的基本概念，包括从单一应用架构到垂直应用架构，再到SOA和服务治理的演变。接着详细讲解了RPC远程过程调用的原理，并重点讨论了Dubbo的核心概念，如服务提供者、消费者、注册中心和监控中心。文中还提供了Dubbo环境搭建的步骤，包括Zookeeper的安装和Dubbo-admin的配置，并展示了如何创建服务提供者和消费者工程。最后，文章提到了Dubbo的高可用策略，如负载均衡和服务容错机制。
摘要由CSDN通过智能技术生成

（一）分布式系统概述

1、分布式系统介绍

分布式系统是若干个独立计算机的集合，这些计算机对于用户来说就像单个相关系统

分布式系统是建立在网络上的软件系统

2、软件架构的演变

（1）单一的应用架构

当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时用于简化增删改查工作量的数据访问框架（ORM）是关键。

适用于小型网站，小型管理系统，将所有功能都部署到一个功能里，简单易用。

缺点：1、性能扩展比较难

​ 2、协同开发问题

​ 3、不利于升级维护

（2）垂直的应用架构

当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，将应用拆成互不相干的几个应用，以提升效率。此时，用于加速前端页面开发的Web框架(MVC)是关键。

通过切分业务来实现各个模块独立部署，降低了维护部署的难度，团队各司其职更易管理，性能扩展也更方便，更有针对性。

缺点： 公用模块无法重复利用，开发性的浪费

（3）SOA

当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。此时用于提高业务复用及整合的分布式服务框架(RPC)是关键。

（4）流动计算架构

当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。此时，用于提高机器利用率的资源调度和治理中心(SOA)[ ServiceOriented Architecture]是关键。

3、RPC概述

RPC【Remote Procedure Call】是指远程过程调用，是一种进程间通信方式，他是一种技术的思想，而不是规范。它允许程序调用另一个地址空间（通常是共享网络的另一台机器上）的过程或函数，而不用程序员显式编码这个远程调用的细节。即程序员无论是调用本地的还是远程的函数，本质上编写的调用代码基本相同。

RPC基本原理如下：
在这里插入图片描述

（二）Dubbo核心概念

1、Dubbo的简介

Apache Dubbo (incubating) 是一款高性能、轻量级的开源Java RPC框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。

Dubbox 是一个分布式服务框架，其前身是阿里巴巴开源项目Dubbo ，被国内电商及互联网项目中使用，后期阿里巴巴停止了该项目的维护，当当网便在Dubbo基础上进行优化，并继续维护，为了与原有的Dubbo区分，故将其命名为Dubbox。

Dubbox 致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。简单的说，dubbox就是个服务框架，如果没有分布式的需求，其实是不需要用的，只有在分布式的时候，才有dubbox这样的分布式服务框架的需求，并且本质上是个服务调用的东东，说白了就是个远程服务调用的分布式框架。

2、Dubbo的官网内容介绍

官网：http://dubbo.apache.org/

官方文档：https://dubbo.apache.org/zh/docs/v2.7/
在这里插入图片描述

3、Dubbo的基本概念

在这里插入图片描述

（1）节点角色说明

服务提供者（Provider）：暴露服务的服务提供方，服务提供者在启动时，向注册中心注册自己提供的服务。

服务消费者（Consumer）: 调用远程服务的服务消费方，服务消费者在启动时，向注册中心订阅自己所需的服务，服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。

注册中心（Registry）：注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者.

监控中心（Monitor）：服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心

（2）调用关系说明
  1. 服务容器负责启动，加载，运行服务提供者。
  2. 服务提供者在启动时，向注册中心注册自己提供的服务。
  3. 服务消费者在启动时，向注册中心订阅自己所需的服务。
  4. 注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。
  5. 服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
  6. 服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心

（三）Dubbo环境搭建

1、安装Zookeeper

在Windows安装Zookeeper

（1）下载zookeeper

网址：https://archive.apache.org/dist/zookeeper/zookeeper-3.6.2/

（2）解压zookeeper

在解压的bin目录中打开命令窗口，运行zkServer.org/dist/zookeeper/zookeeper-3.6.2/

（3）修改zoo.cfg配置文件

将conf下的zoo_sample.cfg复制一份改名为zoo.cfg即可。

注意几个重要的位置：

dataDir=./ 临时数据存储的目录（可写相对路径）

clientPort=2181 zookeeper的端口号

修改完成后再次启动zookeeper

（4）使用zkCli.cmd测试

ls / :列出zookeeper根下保存的所有节点

create -e /name"why"：创建一个name节点，值为why

get /name：获取/name节点值

2、安装Dubbo-admin管理控制台

dubbo本身并不是一个服务软件。它其实就是一个jar包能够帮你的java程序连接到zookeeper，并利用zookeeper消费、提供服务。所以你不用在Linux上启动什么dubbo服务。但是为了让用户更好的管理监控众多的dubbo服务，官方提供了一个可视化的监控程序，不过这个监控即使不装也不影响使用。

（1）下载dubbo-admin

下载路径：https://github.com/apache/dubbo-admin/tree/master

（2）进入目录，修改dubbo-admin配置

打开配置文件src\main\resources\application.properties，在其中指定Zookeeper

dubbo.registry.address=zookeeper://127.0.0.1:2181

（3）打包dubbo-admin

在pom文件所在目录下打开命令窗口执行mvn clean package

（4）运行dubbo-admin

在打包好的jar包路径下打开命令窗口执行：

java -jar dubbo-admin-0.0.1-SNAPSHOT.jar

（5）测试

打开浏览器输入localhost:7001/,登录用户名和密码均为root 进入首页。

3、在linux上安装dubbo监控软件

dubbo-admin-2.6.1.war

由于这个软件是属于一个web应用,所以需要将这个文件存放到tomcat下的webapps下就可以,然后去启动

tomcat及其zookeeper.

注意: zookeeper3.6.0-bin: 中有一个管理的端口默认为8080,可以修改该端口号:

在 zoo.cfg配置文件中添加：admin.serverPort:9999

启动zookeeper

启动tomcat

通过浏览器,进行访问: http://192.168.150.133:8080/dubbo-admin-2.6.1

输入用户名与密码：
在这里插入图片描述

4、创建提供者消费工程

（1）创建一个打包方式为pom的maven父工程
<packaging>pom</packaging>
<dependencies>
    <dependency>
    	<groupId>org.springframework</groupId>
    	<artifactId>spring-webmvc</artifactId>
    	<version>5.3.4</version>
    </dependency>

    <dependency>
    	<groupId>com.alibaba</groupId>
    	<artifactId>dubbo</artifactId>
    	<version>2.6.1</version>
    </dependency>

    <dependency>
    	<groupId>org.apache.zookeeper</groupId>
    	<artifactId>zookeeper</artifactId>
    	<version>3.6.0</version>
    </dependency>

    <!-- zookeeper的客户端 -->
    <dependency>
    	<groupId>org.apache.curator</groupId>
    	<artifactId>curator-framework</artifactId>
    	<version>2.12.0</version>
	</dependency>
</dependencies>
（2）在父工程中创建一个子工程（offcn_commons）【实体类，接口】
public class Customer implements Serializable{
	private Integer cid;
	private String cname;
	private List<CustomerAddress> address;

    public Customer() {
    }

    public void setAddress(List<CustomerAddress> address) {
        this.address = address;
    }

    public Integer getCid() {
        return cid;
    }

    public void setCid(Integer cid) {
        this.cid = cid;
    }

    public String getCname() {
        return cname;
    }

    public void setCname(String cname) {
        this.cname = cname;
    }

    public List<CustomerAddress> getAddress() {
        return address;
    }
}

package com.offcn.bean;
import java.io.Serializable;

public class CustomerAddress implements Serializable {

    private Integer caid;
    private String caDes;

    public CustomerAddress(Integer caid, String caDes) {
        this.caid = caid;
        this.caDes = caDes;
    }

    public CustomerAddress() {
    }

    public Integer getCaid() {
        return caid;
    }

    public void setCaid(Integer caid) {
        this.caid = caid;
    }

    public String getCaDes() {
        return caDes;
    }

    public void setCaDes(String caDes) {
        this.caDes = caDes;
    }

    @Override
    public String toString() {
        return "CustomerAddress{" +
            "caid=" + caid +
            ", caDes='" + caDes + '\'' +
            '}';
    }
}
（3）在offcn_commons工程中构建接口
package com.offcn.service;
import com.offcn.bean.CustomerAddress;
import java.util.List;

public interface CustomerService {

    public List<CustomerAddress> showAllAddress(Integer cid);
}

package com.offcn.service;
import com.offcn.bean.CustomerAddress;
import java.util.List;

public interface OrderService {
    public List<CustomerAddress> showAddressByCid(Integer cid);
}

（4）发布offcn_commons工程到本地仓库

执行 mvn install 命令

（四）Dubbo服务开发测试

1、Dubbo服务提供方开发测试

在dubbo父工程下，在创建一个子模块：offcn_service_provider

（1）在offcn_service_provider工程的pom文件中添加offcn_commons工程依赖
<dependency>
	<groupId>com.offcn</groupId>
	<artifactId>offcn_commons</artifactId>
	<version>1.0-SNAPSHOT</version>
</dependency>
（2）构建CustomerService接口实现类
public class CustomerServiceImpl implements CustomerService {

    //根据用户id查询用户地址
    @Override
    public List<CustomerAddress> showAllAddress(Integer id) {
        List<CustomerAddress> list = new ArrayList<>();
        CustomerAddress customerAddress = new CustomerAddress(1,"五道口职业技术学院");                                                            	CustomerAddress customerAddress1 = new CustomerAddress(2,"圆明园职业技术学院");                                                      		list.add(customerAddress);   
		list.add(customerAddress1);
		return list;
	}
}
（3）构建provider.xml文件暴露服务
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
	http://www.springframework.org/schema/beans/spring-beans.xsd
	http://code.alibabatech.com/schema/dubbo
	http://code.alibabatech.com/schema/dubbo/dubbo.xsd">

    <!--dubbo:应用名-->
    <dubbo:application name="offcn_service_provider"/>
	<!--指定注册中心:(zookeeper)-->
	<dubbo:registry address="zookeeper://192.168.150.133:2181"/>
	<!-- 用dubbo协议在20880端口暴露服务 -->
	<dubbo:protocol name="dubbo" port="20880" />
	<!--声明要暴露的服务端口-->
	<!--interface:要暴露的接口类型; ref:接口对应的实现类-->
	<dubbo:service interface="com.offcn.service.CustomerService"
	ref="customerService"/>
	<!--实现类对象的定义-->
	<bean id="customerService" class="com.offcn.service.CustomerServiceImpl">
</bean>
</beans>
（4）在web.xml中初始化配置文件
<!--将spring(provider).xml做为当前应用的的上下文参数-->
<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>classpath:provider.xml</param-value>
</context-param>
	
<!--加载provider.xml,并进行监听-->
<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
（5）启动服务

2、Dubbo服务消费方开发测试

（1）创建一个子模块(offcn_service_constumer)

在对应的pom文件中添加db_commons的依赖

<dependency>
	<groupId>com.offcn</groupId>
	<artifactId>offcn_commons</artifactId>
	<version>1.0-SNAPSHOT</version>
</dependency>
（2）构建OrderService接口的实现类
@Service
public class OrderServiceImpl implements OrderService {

    @Resource
	private CustomerService customerService;

    @Override
	public List<CustomerAddress> showAddressByCid(Integer cid) {
		return customerService.showAllAddress(cid);
	}
}
（3）构建控制器代码
@Controller
public class OrderController {

    @Resource
    private OrderService orderService;

    @RequestMapping("/showInfo")
    public String showInfo(){
        List<CustomerAddress> customerAddresses = orderService.showAddressByCid(1);
        System.out.println(customerAddresses);
        return "show";
    }
}
（4）构建consumer.xml订阅服务
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"     		   xmlns:bubbo="http://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
	   http://code.alibabatech.com/schema/dubbo
	   http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
	<!--扫描service注解-->
	<context:component-scan base-package="com.offcn.service"/>

    <!--dubbo:应用名-->
	<dubbo:application name="offcn_service_constumer"/>

    <!--指定注册中心:(zookeeper)-->
    <dubbo:registry address="zookeeper://192.168.150.133:2181"/>

    <!--远程调用-->
    <bubbo:reference interface="com.offcn.service.CustomerService"
id="customerService"/>
</beans>
（5）构建springmvc.xml配置文件
<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:mvc="http://www.springframework.org/schema/mvc"
	   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/mvc
		http://www.springframework.org/schema/mvc/spring-mvc.xsd">

    <context:component-scan base-package="com.offcn.controller"/>	

    <mvc:annotation-driven/>
	<bean
class="org.springframework.web.servlet.view.InternalResourceViewResolver">
		<property name="prefix" value="/"></property>
		<property name="suffix" value=".jsp"></property>
	</bean>
</beans>
（6）web.xml中初始化配置文件
<context-param>
	<param-name>contextConfigLocation</param-name>
	<param-value>classpath:customer.xml</param-value>
</context-param>
<listener>
	<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
	<servlet-name>springmvc</servlet-name>
	<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
	<init-param>
		<param-name>contextConfigLocation</param-name>
		<param-value>classpath:springmvc.xml</param-value>
	</init-param>
</servlet>
<servlet-mapping>
	<servlet-name>springmvc</servlet-name>
	<url-pattern>/</url-pattern>
</servlet-mapping>
（7）构建测试页面
show.jsp

<body>
	<h2>展示数据</h2>
</body>
（8）启动服务器进行测试

（五）Dubbo的高可用操作

1、负载均衡

在集群负载均衡时，Dubbo提供了多种均衡策略。

（1）Random LoadBalance

随机，按权重设置随机概率

在一个截面上碰撞的概率高，但调用量越大分布越均匀，而且按概率使用权重后也比较均匀，有利于动态调整提供者权重。

（2）RoundRobin LoadBalance

轮循，按公约后的权重设置轮循比率

存在慢的提供者累积请求的问题，比如：第二台机器很慢，但没挂，当请求调到第二台时就卡在那，久而久之，所有请求都卡在调到第二台上。

（3）LeastActive LoadBalance

最少活跃调用数，相同活跃数的随机，活跃数指调用前后计数差。

使慢的提供者收到更少请求，因为越慢的提供者的调用前后计数差会越大。

（4）ConsistentHash LoadBalance

一致性 Hash，相同参数的请求总是发到同一提供者。

当某一台提供者挂时，原本发往该提供者的请求，基于虚拟节点，平摊到其它提供者，不会引起剧烈变动。

2、服务降级

当服务器压力剧增的情况下，根据实际业务情况及流量，对一些服务和页面有策略的不处理或换种简单的方式处理，从而释放服务器资源以保证核心交易正常运作或高效运作。

可以通过服务降级功能临时屏蔽某个出错的非关键服务，并定义降级后的返回策略。

向注册中心写入动态配置覆盖规则：

RegistryFactory registryFactory = ExtensionLoader.getExtensionLoader(RegistryFactory.class).getAdaptiveExtension();
Registry registry = registryFactory.getRegistry(URL.valueOf("zookeeper://10.20.153.10:2181"));
registry.register(URL.valueOf("override://0.0.0.0/com.foo.BarService?category=configurators&dynamic=false&application=foo&mock=force:return+null"));

其中：

1、mock=force.mocked 表示消费方对该服务的方法调用都直接返回 null 值，不发起远程调用.

2、还可以改为 mock=fail.mocked 表示消费方对该服务的方法调用在失败后，再返回 null 值，不抛异常。

3、服务容错

在集群调用失败时，Dubbo 提供了多种容错方案，缺省为 failover 重试。

集群容错模式

（1）Failover Cluster

失败自动切换，当出现失败，重试其它服务器。通常用于读操作，但重试会带来更长延迟。可通过retries=“2” 来设置重试次数(不含第一次)。

重试次数配置如下：

<dubbo:service retries="2" />
或
<dubbo:reference retries="2" />
或
<dubbo:reference>
<dubbo:method name="findFoo" retries="2" />
</dubbo:reference>
（2）Failfast Cluster

快速失败，只发起一次调用，失败立即报错。通常用于非幂等性的写操作，比如新增记录

（3）Failsafe Cluster

失败安全，出现异常时，直接忽略。通常用于写入审计日志等操作。

（4）Failback Cluster

失败自动恢复，后台记录失败请求，定时重发。通常用于消息通知操作。

（5）Forking Custer

并行调用多个服务器，只要一个成功即返回。通常用于实时性要求较高的读操作，但需要浪费更多服务资源。

可通过 forks=“2” 来设置最大并行数。

（6）Broadcast Cluster

广播调用所有提供者，逐个调用，任意一台报错则报错 [2]。通常用于通知所有提供者更新缓存或日志等本地资源信息。

集群模式配置

按照以下示例在服务提供方和消费方配置集群模式

<dubbo:service cluster=“failsafe” />

或

<dubbo:reference cluster=“failsafe” />

互联网底层民工
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
dubbo示例代码dubbo-sample
08-05
【Dubbo 示例代码详解】 Dubbo 是阿里巴巴开源的一款高性能、轻量级的Java服务治理框架，它主要提供了RPC（远程过程调用）服务，并且包含了服务注册与发现、负载均衡、容错处理、监控等全面的服务治理功能。本示例...
Dubbo简介
kevin
08-04 5422
一、简介 Dubbo官网为http://dubbo.apache.org/zh-cn/。该官网是Dubbo正式进入Apache开源孵化器后改的 Dubbo原官网为：http://dubbo.io 二、RPC RPC（Remote Procedure Call Protocol）——远程过程调用协议，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术...
dubbo 中文官网
m0_54850825的博客
03-31 5130
https://dubbo.gitbooks.io/dubbo-user-book/content/demos/async-call.html
dubbo中文官网地址
m0_67394360的博客
09-01 1864
和大家分享一下：dubbo的中文官网迁移到了githup上地址：之前的不能用了。
Dubbo配置说明
04-25
### Dubbo配置说明详解 #### 一、Dubbo概述 Dubbo是一款由阿里巴巴开发的分布式服务框架，旨在提供高效、透明的远程服务调用机制，同时支持服务治理功能。Dubbo每天支撑着超过2,000个服务，处理超过30亿次的服务...
dubbodubbo.zip
05-15
《Dubbo技术详解与实战应用》 Dubbo是一款由阿里巴巴开源的高性能、轻量级的服务治理框架，它致力于提供一个简单、高效的分布式服务解决方案。在Java世界里，Dubbo已经成为了微服务架构的重要组成部分，其核心特性...
dubbo xsd
06-27
《Dubbo XSD详解——构建高效微服务架构的关键》 在现代企业级应用开发中，分布式服务框架Dubbo扮演了至关重要的角色。Dubbo XSD是Dubbo框架的一部分，它是XML Schema Definition的缩写，主要用于定义XML文档的结构...
Dubbo Dubbo
11-28
由于Dubbo将这些协议的实现进行了封装了，无论是服务端（开发服务）还是客户端（调用服务），都不需要关心协议的细节，只需要在配置中指定使用的协议即可，从而保证了服务提供方与服务消费方之间的透明。 另外，如果...
Dubbo中文官方文档
m0_55070913的博客
04-01 1341
Dubbo中文官方文档 由于市面并没有dubbo相关的书籍，最好的自学方式除了看教学视频就只能看官方文档了，小伙伴找不到中文官方文档的，可以用我的url，一起学习！ http://dubbo.apache.org/zh-cn/docs/user/quick-start.html 有好视频的可以给我分享下哈，谢谢！ ...
分布式RPC框架Apache Dubbo
m0_56187876的博客
07-18 1500
分布式RPC框架Apache Dubbo 1. 软件架构的演进过程 软件架构的发展经历了由单体架构、垂直架构、SOA架构到微服务架构的演进过程，下面我们分别了解一下这几个架构。 1.1 单体架构 1.2 垂直架构 1.3 SOA架构 SOA全称为Service-Oriented Architecture，即面向服务的架构。它可以根据需求通过网络对松散耦合的粗粒度应用组件(服务)进行分布式部署、组合和使用。一个服务通常以独立的形式存在于操作系统进程中。 站在功能的角度，把业务逻辑抽象成可复用的服务，通
dubbo简介及部分特性使用
最新发布
ludkjava的博客
12-03 1106
简要的介绍了dubbo，并描述了dubbo部分特性的使用。
Hadoop（3）—— Zookeeper（2）—— 修改Zookeeper配置文件
weixin_54348877的博客
10-19 4321
一、修改zookeeper的配置文件 1复制配置文件 zoo_sample.cfg 并重命名 在/export/servers目录下 输入：cd zookeeper-3.4.10/ 输入：cd conf/ 拷贝文件为zoo.cfg 输入：cp zoo_sample.cfg zoo.cfg 2. 修改zoo_cfg文件 输入：vi zoo.cfg 找到dataDir=/tmp/zookeeper 2.1 把 dataDir=/tmp/zookeeper改成data...
dubbo官网
dyh200896的专栏
04-24 671
dubbo官网 http://dubbo.apache.org/zh-cn/
Dubbo使用与安装指南
"dubbo文档1" Dubbo是一个高性能、轻量级的开源Java RPC框架，由阿里巴巴开发并维护。文档1主要介绍了如何安装和运维基于Dubbo构建的应用，包括多种注册中心的安装与配置，以及如何进行简单的系统监控。 1. **安装...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

互联网底层民工

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值