go开源项目slgserver源码分析

个人博客地址: https://cxx001.gitee.io

前言

项目开源地址：https://github.com/llr104/slgserver

比较适合作为go语言入门学习项目或轻量级游戏项目，整体的项目结构和编码质量还是可以的。不过距离商业项目还是差点意思，如服务负载、容灾这块还没有。

项目总共有5个类型独立服务：

  1. gateserver 网关服
  2. loginserver 登录服
  3. chatserver 聊天服
  4. httpserver http服
  5. slgserver 游戏服

其中httpserver就是常规http服务，主要提供一些辅助操作，如账号注册、修改密码什么的。其它4类服务则是用websocket相互连接的。客户端只与网关服相连，网关服负责消息解析、前置处理，然后转发给对应的业务服处理，处理完后响应再原路返回给客户端。

下面我们就已gateserver网关服为例来分析整个项目框架，搞清楚各服务都从哪里启动、消息怎么流转的。如果你不想知道源码实现细节，可直接只看第4步结论。

1. 服务入口

go程序都是从main开始，下面是gateserver的main入口：

// gateserver.go
func main() {
  fmt.Println(os.Getwd())
    
  // 初始化路由(下面第2步) 
  gateserver.Init()
    
  // 启动服务监听(下面第3步)
  needSecret := config.File.MustBool("gateserver", "need_secret", false)  // 读取env.ini配置文件信息
  s := net.NewServer(getGateServerAddr(), needSecret)  // ip/port信息
  s.Router(gateserver.MyRouter)  // 路由信息
  s.SetOnBeforeClose(controller.GHandle.OnServerConnClose) // 连接关闭前回调
  s.Start()  // 开启监听，启动服务
}

接下来我们展开分析下里边具体实现细节。

2. 初始化路由

gateserver.Init()里边具体做了些什么？就只调用了下面这个方法：

func (this*Handle) InitRouter(r *net.Router) {
  this.init()
  g := r.Group("*").Use(middleware.ElapsedTime(), middleware.Log())
  g.AddRouter("*", this.all)
}

先看里面的init，获取到了游戏服、聊天服、登录服连接地址信息。

func (this*Handle) init() {
  this.slgProxy = config.File.MustValue("gateserver", "slg_proxy", "ws://127.0.0.1:8001")
  this.chatProxy = config.File.MustValue("gateserver", "chat_proxy", "ws://127.0.0.1:8002")
  this.loginProxy = config.File.MustValue("gateserver", "login_proxy", "ws://127.0.0.1:8003")
}

接下来这句我们来看看做了什么，g := r.Group("*").Use(middleware.ElapsedTime(), middleware.Log())

首先调用路由对象Router里的Group方法，参数传的*，返回一个Group对象指针，这个Router对象是在gateserver的init.go里创建，通过上面InitRouter方法传递进来的。

func (this*Router) Group(prefix string) *Group{
  g := &Group{prefix: prefix,
    hMap: make(map[string]HandlerFunc),
    hMapMidd: make(map[string][]MiddlewareFunc),
  }

  this.groups = append(this.groups, g)
  return g
}

这个方法创建了一个Group对象，然后把这个对象添加到了Router对象里groups数组里。

type HandlerFunc func(req *WsMsgReq, rsp *WsMsgRsp)
type MiddlewareFunc func(HandlerFunc) HandlerFunc

type Group struct {
  prefix     	string    // 前缀(*)
  hMap       	map[string]HandlerFunc   // 消息存储的map容器
  hMapMidd	map[string][]MiddlewareFunc  // 中间件map容器
  middleware 	[]MiddlewareFunc  // 中间件数组容器
}

然后接着调用Group对象里的Use方法，传递了两个中间件函数middleware.ElapsedTime(), middleware.Log()。把这两个函数添加到了上面Group对象里的middleware数组里。

func (this* Group) Use(middleware ...MiddlewareFunc) *Group{
  this.middleware = append(this.middleware, middleware...)
  return this
}

至此：g := r.Group(“*”).Use(middleware.ElapsedTime(), middleware.Log())干的事情就是，返回了一个Group指针对象，并对这个对象里的prefix字段和middleware字段赋了值。一个赋值字符串*，一个插入了两个中间件函数。

接下来调用g.AddRouter("*", this.all)，首先我们来看传递的参数this.all它是一个方法，参数是消息请求/响应体：

func (this*Handle) all(req *net.WsMsgReq, rsp *net.WsMsgRsp) {
  log.DefaultLog.Info("gateserver handle all begin",
  zap.String("proxyStr", req.Body.Proxy),
  zap.String("msgName", req.Body.Name))
  this.deal(req, rsp)

  if req.Body.Name == "role.enterServer" && rsp.Body.Code == constant.OK  {
    //登录聊天服
    rspObj := &proto.EnterServerRsp{}
    mapstructure.Decode(rsp.Body.Msg, rspObj)
    r := &chat_proto.LoginReq{RId: rspObj.Role.RId, NickName: rspObj.Role.NickName, Token: rspObj.Token}
    reqBody := &net.ReqBody{Seq: 0, Name: "chat.login", Msg: r, Proxy: ""}
    rspBody := &net.RspBody{Seq: 0, Name: "chat.login", Msg: r, Code: 0}
    this.deal(&net.WsMsgReq{Body: reqBody, Conn:req.Conn}, &net.WsMsgRsp{Body: rspBody})
  }

  log.DefaultLog.Info("gateserver handle all end",
  zap.String("proxyStr", req.Body.Proxy),
  zap.String("msgName", req.Body.Name))
}

再来看调用的AddRouter方法：

func (this*Group) AddRouter(name string, handlerFunc HandlerFunc, middleware ...MiddlewareFunc) {
  this.hMap[name] = handlerFunc
  this.hMapMidd[name] = middleware
}

这里对于网关服，没有传递中间件函数，只传递了上面的this.all消息体函数给到了Group对象里的hMap，key=*，value=this.all;

最后，我们再来回答最开始的疑问gateserver.Init()做了什么？我们总结下：

在server/gateserver/controller/handle.go Handle对象里创建了一个Group对象指针，并给这个对象赋了值：

type Group struct {
  prefix     	string    // *
  hMap       	map[string]HandlerFunc   // key:"*" value: this.all
  hMapMidd	  map[string][]MiddlewareFunc  // 空
  middleware 	[]MiddlewareFunc  // middleware.ElapsedTime(), middleware.Log()
}

然后把这个Group对象放到上面初始化传递进来的Router对象里的groups数组里了。

3. 启动服务监听

启动网关服务由下面几句代码完成：

needSecret := config.File.MustBool("gateserver", "need_secret", false)  // 从data/conf/env.ini中读取need_secret字段的值，就是对网络传输数据是否加密标志

// 下面就是创建server对象，并调用它的一些方法启动服务
s := net.NewServer(getGateServerAddr(), needSecret)
s.Router(gateserver.MyRouter)
s.SetOnBeforeClose(controller.GHandle.OnServerConnClose)
s.Start()

s := net.NewServer(getGateServerAddr(), needSecret) 返回server对象，并对里边addr(网关服的ip:port)、needSecret赋值。

type server struct {
  addr        string      // ":8004"
  router      *Router
  needSecret  bool        // true
  beforeClose func (WSConn)
}

func NewServer(addr string, needSecret bool) *server {
  s := server{
    addr: addr,
    needSecret: needSecret,
  }
  return &s
}

s.Router(gateserver.MyRouter)，就是把第二步创建的路由对象赋值给了server对象里的router字段。

func (this*server) Router(router *Router) {
  this.router = router
}

s.SetOnBeforeClose(controller.GHandle.OnServerConnClose)

func (this*server) SetOnBeforeClose(hookFunc func (WSConn))  {
  this.beforeClose = hookFunc
}

把业务控制的server/gateserver/controller/handle.go Handle对象里OnServerConnClose方法赋值给了server对象的beforeClose字段，即用来在网络关闭前做些事情。即释放this.proxy，然后关闭网络。proxy是在上面all方法里的deal里赋值的，this.proxy [ip:port][cid]` = proxyClient(与业务服务连接的客户端对象)

func (this*Handle) OnServerConnClose (conn net.WSConn){
  c, err := conn.GetProperty("cid")
  arr := make([]*net.ProxyClient, 0)

  if err == nil{
    cid := c.(int64)
    this.proxyMutex.Lock()
    for _, m := range this.proxys {
      proxy, ok := m[cid]
      if ok {
        arr = append(arr, proxy)
      }
      delete(m, cid)
    }
    this.proxyMutex.Unlock()
  }

  for _, client := range arr {
    client.Close()
  }
}

至此，创建的server对象的4个数据字段都已经赋了值。

type server struct {
  addr        string        // :8004
  router      *Router       // 第二步的Router
  needSecret  bool          // true
  beforeClose func (WSConn) // 业务控制里的OnServerConnClose
}

最后调用s.Start()启动服务

func (this*server) Start()  {
  log.DefaultLog.Info("server starting")
  // 使用的是go内置的http模块
  http.HandleFunc("/", this.wsHandler)  // 客户端连接请求时，会调用wsHandler
  http.ListenAndServe(this.addr, nil)   // 开启服务监听
}

我们重点看看this.wsHandler，创建websocket对象并初始化事件循环。

func (this*server) wsHandler(resp http.ResponseWriter, req *http.Request) {
  // 创建websocket对象
  wsSocket, err := wsUpgrader.Upgrade(resp, req, nil)  
  if err != nil {
    return
  }

  // websocket用ServerConn对象再包装一层
  conn := ConnMgr.NewConn(wsSocket, this.needSecret)
  log.DefaultLog.Info("client connect", zap.String("addr", wsSocket.RemoteAddr().String()))
  conn.SetRouter(this.router)
  conn.SetOnClose(ConnMgr.RemoveConn)
  conn.SetOnBeforeClose(this.beforeClose)
  conn.Start()
  conn.Handshake()
}

conn.Start()，异步开启两个线程循环，分别处理消息读取和写入。

func (this *ServerConn) Start() {
  go this.wsReadLoop()
  go this.wsWriteLoop()
}

先来看看接收客户端消息：

func (this *ServerConn) wsReadLoop() {
  // defer延迟调用，在wsReadLoop返回前最后调用
  defer func() {
    // recover 是go内置函数，防止宕机，尝试恢复，这个函数只能在defer函数里使用
    if err := recover(); err != nil {
      e := fmt.Sprintf("%v", err)
      log.DefaultLog.Error("wsReadLoop error", zap.String("err", e))
      this.Close()
    }
  }()

  // 消息接收循环
  for {
    // 读一个message
    _, data, err := this.wsSocket.ReadMessage()
    if err != nil {
      break
    }
    
    data, err = util.UnZip(data)
    if err != nil {
      log.DefaultLog.Error("wsReadLoop UnZip error", zap.Error(err))
      continue
    }

    body := &ReqBody{}
    if this.needSecret {
      //检测是否有加密，没有加密发起Handshake,与客户端同步密钥
      if secretKey, err:= this.GetProperty("secretKey"); err == nil {
        key := secretKey.(string)
        d, err := util.AesCBCDecrypt(data, []byte(key), []byte(key), openssl.ZEROS_PADDING)
        if err != nil {
          log.DefaultLog.Error("AesDecrypt error", zap.Error(err))
          this.Handshake()
        }else{
          data = d
        }
      }else{
        log.DefaultLog.Info("secretKey not found client need handshake", zap.Error(err))
        this.Handshake()
        return
      }
    }

    if err := util.Unmarshal(data, body); err == nil {
      req := &WsMsgReq{Conn: this, Body: body}
      rsp := &WsMsgRsp{Body: &RspBody{Name: body.Name, Seq: req.Body.Seq}}
      
      if req.Body.Name == HeartbeatMsg {
        // 心跳信息
        h := &Heartbeat{}
        mapstructure.Decode(body.Msg, h)
        h.STime = time.Now().UnixNano()/1e6
        rsp.Body.Msg = h
      }else{
        if this.router != nil {
          this.router.Run(req, rsp)  // 将解析出来的消息转发出去
        }
      }
      this.outChan <- rsp  // 响应消息放入通道，消息请求到响应是同步的
    }else{
      log.DefaultLog.Error("wsReadLoop Unmarshal error", zap.Error(err))
      this.Handshake()
    }
  }

  this.Close()
}

再来看看发送给客户端的响应消息，这里流程是先收到客户端请求，然后转发到对应的业务服务器，返回后再把回复消息插入通道，最后发给客户端。这里websocket是用的阻塞模式，所以消息都是这么个流程。

func (this *ServerConn) wsWriteLoop() {
  defer func() {
    if err := recover(); err != nil {
      log.DefaultLog.Error("wsWriteLoop error")
      this.Close()
    }
  }()

  for {
    select {
    // 取一个消息
    case msg := <- this.outChan:
      // 写给websocket
      this.write(msg.Body)
    }
  }
}

// 将响应消息加密、打包后发送
func (this *ServerConn) write(msg interface{}) error{
  data, err := util.Marshal(msg)
  if err == nil {
    if this.needSecret {
      if secretKey, err:= this.GetProperty("secretKey"); err == nil {
        key := secretKey.(string)
        data, _ = util.AesCBCEncrypt(data, []byte(key), []byte(key), openssl.ZEROS_PADDING)
      }
    }
  }else {
    log.DefaultLog.Error("wsWriteLoop Marshal body error", zap.Error(err))
    return err
  }

  if data, err := util.Zip(data); err == nil{
    if err := this.wsSocket.WriteMessage(websocket.BinaryMessage, data); err != nil {
      this.Close()
      return err
    }
  }else{
    return err
  }
  return nil
}

总结一下，这一步主要做了创建websocket对象，开启监听端口和消息的读取/发送循环。

4. 客户端与网关及各业务服通信过程

如果你认真跟了前面每一步分析的话，其实整个框架的消息结构已经清晰了。

最后我们来做个总结，总体回顾下：

客户端只与网关服相连，网关服负责消息解析、前置处理，然后转发给对应的业务服处理，处理完后响应再原路返回给客户端。它们之间的连接方式都是websocket。

下面是一条完整请求响应链的流程：

  1. 客户端连接网关服，发起消息请求

  2. 网关服消息读取循环(wsReadLoop)接收到消息，解析解包后转发消息this.router.Run(req, rsp)

  3. 网关消息转发最终实际就是依次调用了middleware.ElapsedTime() , middleware.Log() , gateserver.all()

func (this*Group) applyMiddleware(name string) HandlerFunc {
    h, ok := this.hMap[name]
    if ok == false{
      h, ok = this.hMap["*"]
    }

    if ok {
      // this.middleware存的就是第2步的两个中间件函数，然后h就是来自this.hMap["*"]，即前面的all函数。
      // 从这里可以看出消息在中间件之间流转，其实就是用了go函数的闭包实现的。
      // 函数嵌套，依次调用ElapsedTime、Log、all
      for i := len(this.middleware) - 1; i >= 0; i-- {
        h = this.middleware[i](h)  
      }

      for i := len(this.hMapMidd[name]) - 1; i >= 0; i-- {
        h = this.hMapMidd[name][i](h)
      }
    }

    return h
  }
   
  h(req, rsp)   // 外部调用返回的h

  1. gateserver.deal()将消息发送到对应的业务服务器(登录服、聊天服、游戏服)，并返回响应数据消息体

  2. 最后网关的写消息循环wsWriteLoop将响应消息发给客户端

这就是一个常规的req/resp消息的流程。

最后我们看看服务端怎么主动给客户端推送消息：

// connMgr.go
// 给具体某个玩家推送
func (this *Mgr) PushByRoleId(rid int, msgName string, data interface{}) bool

// 给所有玩家推送
func (this *Mgr) pushAll(msgName string, data interface{})

// 使用方式
net.ConnMgr.PushByRoleId(user.rid, "chat.push", data)

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/34497.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

弗迪科技携手纷享销客共建CRM系统，数智化升级加速“灯塔工厂”征程

弗迪科技携手纷享销客共建CRM系统，数智化升级加速“灯塔工厂”征程

当前&#xff0c;全球新一轮科技革命正和产业升级融合发展&#xff0c;数字化技术成为各行各业升级发展的重要推动力。 自2018年起&#xff0c;世界经济论坛与麦肯锡咨询公司发起“灯塔工厂”项目&#xff0c;全球严选制造业数字化转型典范作为“数字化制造”和“全球化4.0”的…
阅读更多...
360测试开发技术面试题目

360测试开发技术面试题目

目录 一、java方面 二、Linux方面 三、数据库方面 四、性能测试方面 五、HTTP协议方面 六、其他 总结&#xff1a; 最近面试了360测试开发的职位&#xff0c;将面试题整理出来分享~ 一、java方面 1、java重载和重写的区别 重载overloading 多个方法、相同的名字&#x…
阅读更多...
Nginx负载均衡、虚拟主机

Nginx负载均衡、虚拟主机

目录 常用的6种负载均衡算法 轮询算法(round robin)默认 权重(weight) 响应时间(fair) 连接数(least_conn) IP_hash url_hash(第三方) 开发优选&#xff1a;一致性哈希 安装步骤&#xff1a; 虚拟主机 常用的6种负载均衡算法 轮询算法(round robin)默认 轮询方式&a…
阅读更多...
C#扩展——Visual Studio 代码提示/智能提示字体大小更改方法.

C#扩展——Visual Studio 代码提示/智能提示字体大小更改方法.

声明&#xff1a;本文为个人笔记&#xff0c;用于学习研究使用非商用&#xff0c;内容为个人研究及综合整理所得&#xff0c;若有违规&#xff0c;请联系&#xff0c;违规必改。 C#扩展——Visual Studio 代码提示/智能提示字体大小更改方法. 文章目录 C#扩展——Visual Studio…
阅读更多...
stm32或gd32移植libcanard实现UAVCAN协议

stm32或gd32移植libcanard实现UAVCAN协议

一、源码下载 1、git下载 点击我下载 2、csdn下载 自己上传的点击下载 二、源码移植 我自己是使用rt-thread操作系统移植的。但是不局限与操作系统&#xff0c;裸机也可以。 1、首先将源码加入到工程 2、分别实现一个内存的分配与释放函数&#xff0c;他是一个指针函数&…
阅读更多...
基于预测帧的视频异常检测经典论文

基于预测帧的视频异常检测经典论文

16年上海科技的论文&#xff0c;上海科技做这个方向的系大佬多多的。 摘要 受基于稀疏编码的异常检测能力的激励&#xff0c;我们提出了一种时间相干稀疏编码(TSC)&#xff0c;其中我们强制用相似的重构系数对相似的相邻帧进行编码。然后&#xff0c;我们用一种特殊类型的层叠…
阅读更多...
【开源工具】使用Whisper提取视频、语音的字幕

【开源工具】使用Whisper提取视频、语音的字幕

这里写目录标题 一、语音转字幕操作步骤1、下载安装包Assets\WhisperDesktop.zip[^2]2、加载模型2.1 下载模型2.1.1 进入Hugging Face[^3]的仓库2.1.2 选择需要下载的模型2.1.3 配置模型路径 3、语音转字幕4、实时语言转录功能 二、相关简介[^1]特点开发人员指南构建说明其他注…
阅读更多...
英国 Tortoise Media发布2023年全球AI指数排名；美团宣布完成收购光年之外

英国 Tortoise Media发布2023年全球AI指数排名；美团宣布完成收购光年之外

&#x1f989; AI新闻 &#x1f680; 美团宣布完成收购光年之外&#xff0c;加强人工智能竞争力 摘要&#xff1a;美团在公告中宣布于2023年6月29日盘后收购光年之外的全部权益&#xff0c;以加强其在快速增长的人工智能行业中的竞争力。光年之外是中国领先的通用人工智能创新…
阅读更多...
SpringBoot整合RabbitMQ实现消息延迟队列(含源码)

SpringBoot整合RabbitMQ实现消息延迟队列(含源码)

环境依赖 SpringBoot 3.1.0 JDK 17 前期准备 安装MQ: liunxdockerrabbitmq安装延迟队列插件 实例 实现延迟队列的一种方式是在 RabbitMQ 中使用消息延迟插件&#xff0c;这个插件可以让你在消息发送时设置一个延迟时间&#xff0c;超过这个时间后消息才会被消费者接收到…
阅读更多...
【JVM内存模型】—— 每天一点小知识

【JVM内存模型】—— 每天一点小知识

&#x1f4a7; J V M 内存模型 \color{#FF1493}{JVM内存模型} JVM内存模型&#x1f4a7; &#x1f337; 仰望天空&#xff0c;妳我亦是行人.✨ &#x1f984; 个人主页——微风撞见云的博客&#x1f390; &#x1f433; 《数据结构与算法》专栏的文章图文并茂&#x…
阅读更多...
智谱AI-算法实习生（知识图谱方向）实习面试记录

智谱AI-算法实习生（知识图谱方向）实习面试记录

岗位描述 没错和我的经历可以说是match得不能再match了&#xff0c;但是还是挂了hh。 面试内容 给我面试的是唐杰老师的博士生&#xff0c;方向是社交网络数据挖掘&#xff0c;知识图谱。不cue名了&#xff0c;态度很友好的 &#xff0c;很赞。 date&#xff1a;6.28 Q1 自…
阅读更多...
【Spark】介绍,部署与快速入门

【Spark】介绍,部署与快速入门

文章目录 介绍核心模块Spark CoreSpark SQLSpark StreamingSpark MLlibSpark GraphX 部署命令行Web UI提交应用Local 模式Standalone配置文件添加 JAVA_HOME 环境变量和集群对应的 master 节点启动集群配置历史服务添加日志存储路径添加日志配置webui 配置高可用 Yarn模式配置文…
阅读更多...
使用npm install -g @vue/cli 命令安装最新的脚手架与Vue版本不匹配的问题

使用npm install -g @vue/cli 命令安装最新的脚手架与Vue版本不匹配的问题

使用npm install -g vue/cli 命令安装最新的脚手架 创建项目时不要选择Vue版本&#xff0c;让它默认选择&#xff08;默认选择 Vue2&#xff09;否则会出现 vue版本和脚手架版本vue-cli 不兼容的问题&#xff08;怪哉&#xff09; 脚手架兼容vue2 不兼容vue3 &#xff1f; 不理…
阅读更多...
2023 年 10 大前端发展趋势

2023 年 10 大前端发展趋势

新技术的出现和老技术的淘汰让前端开发者们需要不断地学习和更新知识。特别是在经济不好的情况下&#xff0c;是否掌握新的技术很大程度决定着你是否被淘汰。 虽然应用程序试图将网站替代&#xff0c;但前端 Web 开发业务仍在快速变化和增长&#xff0c;前端开发人员的功能并没…
阅读更多...
配置Jenkins slave agent（通过jnlp）方式连接

配置Jenkins slave agent（通过jnlp）方式连接

上一章&#xff0c;使用ssh的方式添加了两个agent&#xff0c;并都成功完成了构建任务&#xff0c;这一章使用jnlp的方式配置agent&#xff0c;jnlp方式配置agent有个好处&#xff0c;就是agent是主动去找到Master请求连接的&#xff0c;master->agent的通道可以配置一个age…
阅读更多...
Leetcode-每日一题【234.回文链表】

Leetcode-每日一题【234.回文链表】

题目 给你一个单链表的头节点 head &#xff0c;请你判断该链表是否为回文链表。如果是&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 示例 1&#xff1a; 输入&#xff1a;head [1,2,2,1]输出&#xff1a;true 示例 2&#xff1a; 输入&#xff1a;head…
阅读更多...
要从HTML中提取img标签的src属性(图片链接),可以使用正则表达式方式。

要从HTML中提取img标签的src属性(图片链接),可以使用正则表达式方式。

1. 定义提取src属性的正则表达式: const srcRegex /<img\s(?:[^>]*?\s)?src\s*\s*(["])((?:[^\1"]|\\\1|.)*?)\1/g 这个正则会匹配类似<img src"http://example.com/1.jpg">中的src属性和括号中的连接。2. 调用字符串的matchAll()方法…
阅读更多...
【数据仓库】Apache Doris介绍

【数据仓库】Apache Doris介绍

Apache Doris介绍 Apache Doris应用场景 Apache Doris核心特性 Apache Doris架构 Doris数据模型三种 Aggregate模型介绍 Uniq模型介绍 在某些多维分析场景下,用户更关注的是如何保证Key的唯一性Key 唯一性约束。因此&#xff0c;我们引入了 Unig 的数据模型。该模型本质上是聚…
阅读更多...
redis高可用（二）

redis高可用（二）

redis高可用&#xff08;二&#xff09; 一、主从复制 1.概念 主从复制&#xff0c;是指将一台Redis服务器的数据&#xff0c;复制到其他的Redis服务器。前者称为主节点(Master)&#xff0c;后者称为从节点(Slave)&#xff1b;数据的复制是单向的&#xff0c;只能由主节点到…
阅读更多...
爬虫入门指南(5): 分布式爬虫与并发控制 【提高爬取效率与请求合理性控制的实现方法】

爬虫入门指南(5): 分布式爬虫与并发控制 【提高爬取效率与请求合理性控制的实现方法】

文章目录 前言多线程与多进程多线程多进程多线程和多进程的选择 使用Scrapy框架实现分布式爬虫1. 创建Scrapy项目2. 配置Scrapy-Redis3. 创建爬虫4. 启动爬虫节点5. 添加任务到队列 并发控制与限制请求频率并发控制限制请求频率 未完待续... 前言 在进行爬虫任务时&#xff0c;…
阅读更多...
最新文章

Copyright @ 2022~2023