在 Go 语言微服务中实现服务网关

已于 2024-09-23 23:36:05 修改
阅读量920 收藏 16
点赞数 26
分类专栏： golang 文章标签： iphone ios go
于 2024-09-23 22:54:45 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57836225/article/details/142470729
版权

目录

一、服务网关的概念和作用

（一）概念

（二）作用

二、在 Go 语言中实现服务网关的方法

（一）使用 HTTP 服务器

（二）使用反向代理服务器

（三）使用微服务框架

三、服务网关的功能实现

（一）负载均衡

（二）安全认证

（三）限流

在微服务架构中，服务网关扮演着重要的角色。它作为客户端与微服务之间的中间层，提供了统一的入口点、负载均衡、安全认证、限流等功能，有助于提高系统的可维护性、可扩展性和安全性。本文将介绍在 Go 语言微服务中如何实现服务网关。

一、服务网关的概念和作用

（一）概念

服务网关是一个位于客户端和微服务之间的组件，它接收来自客户端的请求，然后将这些请求转发到相应的微服务。服务网关通常使用反向代理技术来实现请求的转发。

（二）作用

  1. 统一入口点：为客户端提供一个统一的入口点，使得客户端无需知道各个微服务的具体地址，简化了客户端的开发和维护。
  2. 负载均衡：将客户端的请求分发到多个微服务实例上，实现负载均衡，提高系统的性能和可靠性。
  3. 安全认证：对客户端的请求进行安全认证，例如验证用户的身份、授权等，保护微服务的安全。
  4. 限流：限制客户端的请求速率，防止系统因过多的请求而崩溃。
  5. 监控和日志：记录请求的日志，监控系统的性能和可用性，以便及时发现和解决问题。

二、在 Go 语言中实现服务网关的方法

（一）使用 HTTP 服务器

  1. 创建 HTTP 服务器：使用 Go 语言的标准库net/http包创建一个 HTTP 服务器。

   package main

   import (
       "log"
       "net/http"
   )

   func main() {
       http.HandleFunc("/", handleRequest)
       log.Fatal(http.ListenAndServe(":8080", nil))
   }

   func handleRequest(w http.ResponseWriter, r *http.Request) {
       // 处理请求的逻辑
   }

  1. 处理请求：在请求处理函数中，根据请求的路径和方法，将请求转发到相应的微服务。
   func handleRequest(w http.ResponseWriter, r *http.Request) {
       if r.URL.Path == "/api/service1" {
          forwardRequest(w, r, "http://service1:8080")
       } else if r.URL.Path == "/api/service2" {
          forwardRequest(w, r, "http://service2:8080")
       } else {
          w.WriteHeader(http.StatusNotFound)
       }
   }

   func forwardRequest(w http.ResponseWriter, r *http.Request, targetURL string) {
       resp, err := http.Get(targetURL + r.URL.Path)
       if err!= nil {
          w.WriteHeader(http.StatusInternalServerError)
          return
       }
       defer resp.Body.Close()
       copyHeader(w.Header(), resp.Header)
       w.WriteHeader(resp.StatusCode)
       io.Copy(w, resp.Body)
   }

   func copyHeader(dst, src http.Header) {
       for k, vv := range src {
          for _, v := range vv {
             dst.Add(k, v)
          }
       }
   }

（二）使用反向代理服务器

  1. 安装反向代理服务器库：可以使用github.com/golang/go/src/net/http/httputil包中的ReverseProxy类型来实现反向代理服务器。

   go get golang.org/x/net/httputil

  1. 创建反向代理服务器：使用ReverseProxy类型创建一个反向代理服务器，并设置目标 URL。

   package main

   import (
       "log"
       "net/http"
       "net/http/httputil"
       "net/url"
   )

   func main() {
       targetURL, err := url.Parse("http://service1:8080")
       if err!= nil {
          log.Fatal(err)
       }
       proxy := httputil.NewSingleHostReverseProxy(targetURL)
       http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
          proxy.ServeHTTP(w, r)
       })
       log.Fatal(http.ListenAndServe(":8080", nil))
   }

（三）使用微服务框架

  1. 选择微服务框架：Go 语言有很多微服务框架，如go-kit、go-micro等，这些框架通常提供了服务网关的功能。
  2. 配置服务网关：根据框架的文档，配置服务网关的参数，如监听地址、后端微服务地址等。
  3. 启动服务网关：启动服务网关，使其开始接收客户端的请求，并将请求转发到后端的微服务。

三、服务网关的功能实现

（一）负载均衡

  1. 轮询算法：可以使用轮询算法将客户端的请求分发到多个微服务实例上。

   package main

   import (
       "log"
       "net/http"
       "sync"
   )

   type ServerPool struct {
       servers []string
       current int
       mutex   sync.Mutex
   }

   func (sp *ServerPool) NextServer() string {
       sp.mutex.Lock()
       defer sp.mutex.Unlock()
       server := sp.servers[sp.current]
       sp.current = (sp.current + 1) % len(sp.servers)
       return server
   }

   func main() {
       serverPool := &ServerPool{
          servers: []string{"http://service1:8080", "http://service2:8080"},
          current: 0,
       }
       http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
          targetURL := serverPool.NextServer()
          forwardRequest(w, r, targetURL)
       })
       log.Fatal(http.ListenAndServe(":8080", nil))
   }

   func forwardRequest(w http.ResponseWriter, r *http.Request, targetURL string) {
       resp, err := http.Get(targetURL + r.URL.Path)
       if err!= nil {
          w.WriteHeader(http.StatusInternalServerError)
          return
       }
       defer resp.Body.Close()
       copyHeader(w.Header(), resp.Header)
       w.WriteHeader(resp.StatusCode)
       io.Copy(w, resp.Body)
   }

   func copyHeader(dst, src http.Header) {
       for k, vv := range src {
          for _, v := range vv {
             dst.Add(k, v)
          }
       }
   }

  1. 加权轮询算法：根据微服务实例的权重，将请求分发到不同的实例上。

   package main

   import (
       "log"
       "net/http"
       "sync"
   )

   type ServerPool struct {
       servers []*Server
       current int
       mutex   sync.Mutex
   }

   type Server struct {
       url      string
       weight   int
       current  int
   }

   func (sp *ServerPool) NextServer() string {
       sp.mutex.Lock()
       defer sp.mutex.Unlock()
       totalWeight := 0
       for _, server := range sp.servers {
          totalWeight += server.weight
       }
       var selectedServer *Server
       for _, server := range sp.servers {
          server.current++
          if server.current.current > server.weight {
             server.current = 0
          }
          if selectedServer == nil || server.current > selectedServer.current {
             selectedServer = server
          }
       }
       return selectedServer.url
   }

   func main() {
       serverPool := &ServerPool{
          servers: []*Server{
             {url: "http://service1:8080", weight: 3},
             {url: "http://service2:8080", weight: 2},
          },
          current: 0,
       }
       http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
          targetURL := serverPool.NextServer()
          forwardRequest(w, r, targetURL)
       })
       log.Fatal(http.ListenAndServe(":8080", nil))
   }

   func forwardRequest(w http.ResponseWriter, r *http.Request, targetURL string) {
       resp, err := http.Get(targetURL + r.URL.Path)
       if err!= nil {
          w.WriteHeader(http.StatusInternalServerError)
          return
       }
       defer resp.Body.Close()
       copyHeader(w.Header(), resp.Header)
       w.WriteHeader(resp.StatusCode)
       io.Copy(w, resp.Body)
   }

   func copyHeader(dst, src http.Header) {
       for k, vv := range src {
          for _, v := range vv {
             dst.Add(k, v)
          }
       }
   }

（二）安全认证

  1. JWT 认证：使用 JSON Web Tokens（JWT）进行安全认证。
   package main

   import (
       "log"
       "net/http"
       "strings"

       "github.com/dgrijalva/jwt-go"
   )

   func main() {
       http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
          authHeader := r.Header.Get("Authorization")
          if authHeader == "" {
             w.WriteHeader(http.StatusUnauthorized)
             return
          }
          tokenString := strings.TrimPrefix(authHeader, "Bearer ")
          token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
             // 返回用于验证 JWT 的密钥
             return []byte("secret"), nil
          })
          if err!= nil ||!token.Valid {
             w.WriteHeader(http.StatusUnauthorized)
             return
          }
          forwardRequest(w, r, "http://service1:8080")
       })
       log.Fatal(http.ListenAndServe(":8080", nil))
   }

   func forwardRequest(w http.ResponseWriter, r *http.Request, targetURL string) {
       resp, err := http.Get(targetURL + r.URL.Path)
       if err!= nil {
          w.WriteHeader(http.StatusInternalServerError)
          return
       }
       defer resp.Body.Close()
       copyHeader(w.Header(), resp.Header)
       w.WriteHeader(resp.StatusCode)
       io.Copy(w, resp.Body)
   }

   func copyHeader(dst, src http.Header) {
       for k, vv := range src {
          for _, v := range vv {
             dst.Add(k, v)
          }
       }
   }

  1. OAuth2 认证：使用 OAuth2 进行安全认证。
   package main

   import (
       "log"
       "net/http"
       "strings"

       "golang.org/x/oauth2"
       "golang.org/x/oauth2/clientcredentials"
   )

   func main() {
       oauth2Config := &clientcredentials.Config{
          ClientID:     "client-id",
          ClientSecret: "client-secret",
          TokenURL:     "https://oauth2-server/token",
       }
       http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
          authHeader := r.Header.Get("Authorization")
          if authHeader == "" {
             w.WriteHeader(http.StatusUnauthorized)
             return
          }
          tokenString := strings.TrimPrefix(authHeader, "Bearer ")
          token, err := oauth2Config.TokenSource(r.Context(), &oauth2.Token{AccessToken: tokenString}).Token()
          if err!= nil || token.AccessToken!= tokenString {
             w.WriteHeader(http.StatusUnauthorized)
             return
          }
          forwardRequest(w, r, "http://service1:8080")
       })
       log.Fatal(http.ListenAndServe(":8080", nil))
   }

   func forwardRequest(w http.ResponseWriter, r *http.Request, targetURL string) {
       resp, err := http.Get(targetURL + r.URL.Path)
       if err!= nil {
          w.WriteHeader(http.StatusInternalServerError)
          return
       }
       defer resp.Body.Close()
       copyHeader(w.Header(), resp.Header)
       w.WriteHeader(resp.StatusCode)
       io.Copy(w, resp.Body)
   }

   func copyHeader(dst, src http.Header) {
       for k, vv := range src {
          for _, v := range vv {
             dst.Add(k, v)
          }
       }
   }

（三）限流

  1. 令牌桶算法：使用令牌桶算法限制客户端的请求速率。

   package main

   import (
       "log"
       "net/http"
       "time"
   )

   type RateLimiter struct {
       capacity int
       tokens   int
       rate     time.Duration
       lastFill time.Time
   }

   func NewRateLimiter(capacity int, rate time.Duration) *RateLimiter {
       return &RateLimiter{
          capacity: capacity,
          tokens:   capacity,
          rate:     rate,
          lastFill: time.Now(),
       }
   }

   func (rl *RateLimiter) Take() bool {
       now := time.Now()
       rl.fill(now)
       if rl.tokens > 0 {
          rl.tokens--
          return true
       }
       return false
   }

   func (rl *RateLimiter) fill(now time.Time) {
       elapsed := now.Sub(rl.lastFill)
       tokensToAdd := int(elapsed / rl.rate)
       if tokensToAdd > 0 {
          rl.tokens = min(rl.capacity, rl.tokens+tokensToAdd)
          rl.lastFill = now
       }
   }

   func min(a, b int) int {
       if a < b {
          return a
       }
       return b
   }

   func main() {
       rateLimiter := NewRateLimiter(10, time.Second)
       http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
          if!rateLimiter.Take() {
             w.WriteHeader(http.StatusTooManyRequests)
             return
          }
          forwardRequest(w, r, "http://service1:8080")
       })
       log.Fatal(http.ListenAndServe(":8080", nil))
   }

   func forwardRequest(w http.ResponseWriter, r *http.Request, targetURL string) {
       resp, err := http.Get(targetURL + r.URL.Path)
       if err!= nil {
          w.WriteHeader(http.StatusInternalServerError)
          return
       }
       defer resp.Body.Close()
       copyHeader(w.Header(), resp.Header)
       w.WriteHeader(resp.StatusCode)
       io.Copy(w, resp.Body)
   }

   func copyHeader(dst, src http.Header) {
       for k, vv := range src {
          for _, v := range vv {
             dst.Add(k, v)
          }
       }
   }

漏桶算法：使用漏桶算法限制客户端的请求速率。

func max(a, b int) int {
    if a > b {
       return a
    }
    return b
}

func main() {
    leakyBucket := NewLeakyBucket(10, time.Second)
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
       if!leakyBucket.Take() {
          w.WriteHeader(http.StatusTooManyRequests)
          return
       }
       // 转发请求到后端微服务
       targetURL := "http://service1:8080"
       resp, err := http.Get(targetURL + r.URL.Path)
       if err!= nil {
          log.Println(err)
          w.WriteHeader(http.StatusInternalServerError)
          return
       }
       defer resp.Body.Close()
       copyHeader(w.Header(), resp.Header)
       w.WriteHeader(resp.StatusCode)
       io.Copy(w, resp.Body)
    })
    log.Fatal(http.ListenAndServe(":8080", nil))
}

func forwardRequest(w http.ResponseWriter, r *http.Request, targetURL string) {
    resp, err := http.Get(targetURL + r.URL.Path)
    if err!= nil {
       w.WriteHeader(http.StatusInternalServerError)
       return
    }
    defer resp.Body.Close()
    copyHeader(w.Header(), resp.Header)
    w.WriteHeader(resp.StatusCode)
    io.Copy(w, resp.Body)
}

func copyHeader(dst, src http.Header) {
    for k, vv := range src {
       for _, v := range vv {
          dst.Add(k, v)
       }
    }
}

漏桶算法通过控制请求的流出速率来限制客户端的请求速率。在上述代码中，我们创建了一个漏桶结构体LeakyBucket，它包含容量、流出速率和当前令牌数等字段。NewLeakyBucket函数用于创建一个新的漏桶实例。Take方法用于从漏桶中获取令牌，如果有足够的令牌，则返回true，否则返回false。drip方法用于模拟漏桶的流出操作，根据时间的流逝减少令牌数。

在main函数中，我们创建了一个漏桶实例，并在处理请求的函数中使用漏桶来限制请求速率。如果漏桶中没有足够的令牌，返回TooManyRequests状态码。如果有足够的令牌，则转发请求到后端微服务，并将响应返回给客户端。

通过使用漏桶算法，我们可以有效地控制客户端的请求速率，防止系统因过多的请求而崩溃。同时，我们可以根据实际需求调整漏桶的容量和流出速率，以适应不同的场景。

阿贾克斯的黎明
关注
专栏目录
Go语言在微服务架构中的应用探索
AI天才研究院
04-03 846
Go语言在微服务架构中的应用探索 作者：禅与计算机程序设计艺术 1. 背景介绍 在当今快速发展的互联网时代,微服务架构已经成为构建可扩展、高度可靠和敏捷的应用程序的主流方法。与单体应用程序相比,微服务架构提供了更好的可维护性、可伸缩性和可部署性。其中,Go语言凭借其出色的性能
golang工程组件篇：微服务工具集go-kit之api网关
SMILY12138的博客
05-23 685
API 网关是指作为前端入口点的服务器程序，它通常扮演着反向代理、负载均衡器和流量控制器等角色。它接收来自客户端的请求，并根据路由规则将其转发到对应的后端服务上。API 网关还可以提供诸如身份验证、访问控制和日志记录等安全性和监视功能。API 网关是微服务架构中不可或缺的一部分。它可以帮助开发者实现负载均衡、流量控制等功能，并提供安全性和访问控制等特性。go-kit 提供了丰富的接口和工具来支持 API 网关实现。本文简要介绍了 go-kit 的 API 网关机制，并给出了示例代码作为参考。
Go语言微服务实战之API网关
天山折梅
05-19 7087
上一篇文章我们用etcd做为服务发现组件，替换了micro默认的基于mnds的服务发现，并简单通过跟踪源码了解了服务注册以及发现的原理。这篇文章，我们来认识微服务架构中另外一个很常见的东东：API Gateway。 1、API网关是什么 我们把一个应用拆分成了一个一个的微服务后，客户端如何调用就是个问题，因为服务是部署在不同的机器上面，这样客户端（比如iOS，android，web）势必将使用很多不同的URL，API网关最主要的作用实际上就是作为一个统一的入口，所有的请求都指向网关，再由网关负责协议转换
9.Go语言高并发与微服务实战 --- 微服务网关
enlyhua的专栏
10-26 483
【代码】9.Go语言高并发与微服务实战 --- 微服务网关。
Go微服务网关
m0_49337181的博客
03-25 5535
Go微服务网关 从核心原理理解网关的本质 网关具备的基本功能： 支持多种协议代理：tcp/http/ websocket/grpc 支持多种负载均衡策略：轮询，权重轮询，hash一致性轮询 支持下游的服务发现：主动探测 / 自动服务发现 支持横向扩展： 加机器就能解决高并发 借助网关处理高可用，高并发 限流：请求QPS限制 熔断：错误率达阈值则服务熔断 降级：确保核心业务可用 权限认证：请求拦截 网络基础大纲 OSI七层网络协议 经典协议与数据包 http 协议 GET/HTTP/1.1
GO语言：微服务--定义和标准
2401_87019212的博客
09-07 1001
另外，一般微服务在系统内部，通常是无状态的，而我们的用户在进行业务操作时，往往是跨业务模块进行操作，且需要是有状态的，在此时的这个系统架构中，也无法解决这个问题。服务调用者通过服务管理框架进行寻址，根据特定的算法，找到对应的服务，或者将服务的注册信息缓存到本地，这样提高性能。异步消息的方式在分布式系统中有特别广泛的应用，他既能减低调用服务之间的耦合，又能成为调用之间的缓冲，确保消息积压不会冲垮被调用方，同时能保证调用方的服务体验，继续干自己该干的活，不至于被后台性能拖慢。这就是服务的发现、识别与管理问题。
Go微服务开发指南
weixin_36865481的博客
07-17 899
在这篇深入探讨Go语言在微服务架构中的应用的文章中，我们介绍了选择Go构建微服务的优势、详细分析了主要的Go微服务框架，并探讨了服务发现与注册和API网关的实现及应用。 关注TechLead，复旦博士，分享云服务领域全维度开发技术。拥有10+年互联网服务架构、AI产品研发经验、团队管理经验，复旦机器人智能实验室成员，...
Go语言十一大主流微服务框架_go微服务框架
2401_87299854的博客
09-22 1308
由Apache 软件基金会官方发布Go 语言加入 Dubbo 生态，架构是基于dubbo的extension模块和分层的代码设计，主要解决 Go 项目与 Java & Dubbo 项目的互通问题，同时也为 Go 项目提供了一种 RPC 与微服务。开源的一套微服务治理框架，提供丰富的后台功能，管理应用的资源、配置，应用的性能、配置等可视化。项目简介：Goa 是一款用 Go 用于构建微服务的框架，采用独特的设计优先的方法。项目简介：最好的Go语言的RPC服务治理框架，快、易用却功能强大。
go语言微服务网关毕设项目（一）
weixin_45596912的博客
04-17 1094
管理员登陆功能后端 Dao层： type Admin struct { Id int `json:"id" gorm:"primary_key" description:"自增主键"` UserName string `json:"user_name" gorm:"column:user_name" description:"管理员用户名"` Salt string `json:"salt" gorm:"column:salt" description
goku-api-gateway：纯Golang中强大的HTTP API网关！Goku API Gateway（中文名称：悟空API网关）是一个基于Golang开发的微服务网关，能够实现高效的HTTP API转发，服务编排，多租户管理，API访问权限控制等目的，拥有强大的自定义插件系统可以自行扩展，并提供友好的图形化配置界面，能够快速帮助企业进行API服务治理，提高API服务的稳定性和安全性
01-30
Goku API网关是基于Golang的微服务网关，可实现高性能的动态路由，服务编排，多租户管理，API访问控制等。它也适用于微服务系统下的API管理。 Goku提供图形界面和插件系统，使配置更容易，扩展更方便。 摘要/ 为...
go语言的成神之路-筑基篇-第二章
2302_80329073的博客
11-26 390
go模板的基本用法1.定义模板2.解析模板3.渲染模板每次使用的时候都将这三部分先写上，根据顺序一步一步进行。
【H2O2|全栈】JS进阶知识（十一）axios入门
最新发布
过期的H2O2的博客
11-26 604
Axios是一个基于Promise的网络请求库，常用于Node.js中，它是通过Promise对AJAX进行的一种封装。axios和JQuery的ajax()方法几乎相同，只是在形式和参数上略有差别。axios以及它相关的API会返回一个Promise对象，因此可以调用Promise的相关方法。
uniapp前端开发,基于vue3,element plus组件库,以及axios通讯
killsime的博客
11-26 476
**UniApp** 是一个基于 Vue.js 的跨平台开发框架，旨在通过一次开发、编译后运行在多个平台上，如 iOS、Android、H5、以及小程序（微信小程序、支付宝小程序、百度小程序等）等。UniApp 为开发者提供了统一的开发体验，使得同一套代码可以在多个平台上运行，从而减少开发和维护成本。
iOS 19 重大更新泄露，将带来更“聪明”的 Siri 挑战 ChatGPT
TOPSTIP的博客
11-26 128
据报道称，iOS 19 将引入一个由“更先进的大型语言模型”驱动的“更具对话性的 Siri”。这一升级将会让 Siri 更加类似于 OpenAI 的 ChatGPT，能够处理“更复杂的请求”。苹果可能会在 2025 年 6 月的 WWDC 发布更新后的 Siri，但彭博社的古尔曼表示，该功能最早将在 2026 年春季推出，这意味着……预计 iOS 19 要到 2025 年 6 月才会发布，但该更新的第一个重大新功能已经泄露。
仿axios，封装微信小程序的请求
weixin_44152684的博客
11-22 670
由于小程序中的请求不是非常好用，没有axios好用，所以按照axios封装了一个简易的请求工具。axiosWechat.js文件。
iOS 18.2 Beta 4开发者预览版发布，相机新增辅助功能
hfxns_的博客
11-21 811
升级建议，目前 iOS 18 系统爆出的 Bug 有很多，如果你并非 iOS 18.2 测试版，那么可以不用考虑升级，尤其是老设备，但如果你运行的是 iOS 18.2 测试版，那么只能选择升级。（从 iOS / iPadOS 16.4 开发者预览版 Beta 1 开始，需要注册苹果开发者计划，注册后打开系统【设置】【软件更新】即可看到升级选项。虽然如此，但我们依旧发现了一些变化。4、 等待固件下载完成后，点击【开始升级】，然后等待升级成功即可。2、 然后选择升级功能，点击【升级】获取可升级iOS版本。
“iOS profile文件与私钥证书文件不匹配”总结打ipa包出现的问题
qq_66848092的博客
11-22 1411
在上线ios平台的时候，在Hbuilder中打包遇见了问题，生成ipa文件时候，一直提示“IOS profile文件与私钥证书文件不匹配”，但获取方法完全按网上所述且有专业ios开发人员获取，百分比没问题，但仍旧一直提示。
iOS 17.4 Not Installed
豪冷的博客
11-26 148
没有安装 17.4 的模拟器，任何操作都无法进行！点击OK去下载，完成之后，依旧是原样！
Xcode15（iOS17.4）打包的项目在 iOS12 系统上启动崩溃
豪冷的博客
11-26 323
崩溃日志，只有 2 行，看不出啥来。
Go语言实现的数据服务集成微服务项目源码
资源摘要信息:"数据服务集成微服务.zip" 在探讨“数据服务集成微服务.zip”这个压缩包内容之前，需要...这将有助于开发者在自己的项目中更好地运用微服务架构和Go语言的优势，实现更加高效、可靠和可扩展的应用程序。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值