go开源项目slgserver源码分析

news2024/9/26 3:32:29

个人博客地址: 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)

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

ajax实现跳转页面或返回上一页面并刷新

ajax实现跳转页面或返回上一页面并刷新

返回上一页面并刷新 window.location.href document.referrer; 跳转至另一个页面 window.location.href ‘/admin’; 图为登录页面实现时的代码
阅读更多...
【OpenCV】获取各种分类器的haarcascades_*.XML 文件的详细介绍

【OpenCV】获取各种分类器的haarcascades_*.XML 文件的详细介绍

文章目录 获取方式下载opencv获取直接下载 文件说明 获取方式 下载opencv获取 安装 OpenCV并获取xml文件&#xff1a; 首先&#xff0c;请参考Windows下 OpenCV 的下载安装教程&#xff08;详细&#xff09;中的步骤&#xff0c;下载 OpenCV。 一旦下载完成&#xff0c;请找到…
阅读更多...
Mentor PADS创建BGA IC封装

Mentor PADS创建BGA IC封装

创建BGA IC封装也是可以使用PCB封装向导去进行设置创建。 1、点击“绘图工具栏”图标&#xff0c;弹出对应的分列&#xff0c;点击“向导”&#xff0c;弹出“Decal Wizard”对话框&#xff0c;如图1所示。 图1“Decal Wizard”对话框 2、然后点击左上角的BGA/PGA选项&#xf…
阅读更多...
【算法】贡献法相关题目练习

【算法】贡献法相关题目练习

文章目录 贡献法介绍相关题目2104. 子数组范围和907. 子数组的最小值之和1856. 子数组最小乘积的最大值2681. 英雄的力量2281. 巫师的总力量和 相关链接 本文介绍一些 使用 贡献法 的算法题目。 TODO &#xff1a;先把框架写了&#xff0c;文章内容后续会补上。 贡献法介绍 相…
阅读更多...
【李宏毅机器学习2021春】01-机器学习基本概念介绍

【李宏毅机器学习2021春】01-机器学习基本概念介绍

01 - 机器学习基本概念介绍 1. 机器学习的基本任务 1.1 Regression 回归 如&#xff0c;输入过去的数据&#xff0c;对未来的数据进行预测。对数据进行拟合的过程叫做回归。 1.2 Classifiation 分类 给出选项&#xff0c;函数输出正确的选项。 如&#xff0c;下棋&#x…
阅读更多...
postgresql 获取建表信息

postgresql 获取建表信息

通过函数获取 创建自定义函数 CREATE OR REPLACE FUNCTION tabledef(text,text) RETURNS text LANGUAGE sql STRICT AS $$ WITH attrdef AS (SELECT n.nspname, c.relname, c.oid, pg_catalog.array_to_string(c.reloptions || array(select toast. || x from pg_catalog.un…
阅读更多...
7.1.9 【Linux】XFS 文件系统简介

7.1.9 【Linux】XFS 文件系统简介

EXT当前的缺点&#xff1a;支持度最广&#xff0c;但格式化超慢 Ext 文件系统家族对于文件格式化的处理方面&#xff0c;采用的是预先规划出所有的 inode/block/metadata 等数据&#xff0c;未来系统可以直接取用&#xff0c; 不需要再进行动态配置的作法。这个作法在早期磁盘…
阅读更多...
14 动态主题类型Dynamic Topic Types

14 动态主题类型Dynamic Topic Types

14 动态主题类型Dynamic Topic Types eProsima Fast DDS提供了一种动态方式来定义和使用主题类型和主题数据。我们的实现遵循用于DDS接口的OMG可扩展和动态主题类型。有关更多信息，您可以阅读DDS XTypes V1.2的规范。 动态主题类型提供了在没有与IDL相关的限制的情况下通过RTP…
阅读更多...
vscode文档搜索机制

vscode文档搜索机制

vscode的全局搜索速度非常快&#xff0c;其中的奥妙是什么&#xff1f; 我们常常需要在一大堆文本文件里搜索一个字符串&#xff0c;在Linux下可以用自带的grep&#xff0c;不过grep的命令行还是有点难记。ripgrep是开源工具&#xff0c;使用Rust编写&#xff0c;全平台支持。看…
阅读更多...
工业RFID在自动化控制中的解决方案

工业RFID在自动化控制中的解决方案

在工业自动化控制领域中&#xff0c;利用RFID技术可以对物品、设备和工具的进行追踪&#xff0c;可以有效提高生产效率和管理水平。下面我们就一起来了解一下&#xff0c;RFID在工业自动化控制中的解决方案是什么样的。 工业RFID在自动化控制中的解决方案 在工业生产过程中&a…
阅读更多...
ai图片转绘画怎么转？分享几个ai图片生成绘画软件给你

ai图片转绘画怎么转？分享几个ai图片生成绘画软件给你

小伙伴们&#xff0c;我今天要给你分享一些超酷的东西——ai图片生成器&#xff0c;它们就像是一个神奇的艺术宝盒&#xff0c;可以将你的文字变成令人瞠目结舌的艺术作品。你有没有想象过可以用ai技术让你的文字爆发出无限创意和惊人的艺术风格&#xff1f;没错&#xff0c;这…
阅读更多...
共享打印机突然出现0x00000771

共享打印机突然出现0x00000771

操作无法完成0x00000771 当多台电脑共享一台打印机时&#xff0c;突然出现了操作无法完成0x00000771。 解决方法为&#xff1a; 在直接连接打印机的电脑上进行操作&#xff1a; 选中“此电脑”&#xff0c;右键选中“管理” 打开“服务与应用程序” 选择" 服务 ",找…
阅读更多...
与 TDengine 性能直接相关——3.0 的落盘机制优化及使用原则

与 TDengine 性能直接相关——3.0 的落盘机制优化及使用原则

许多用户会有一个疑问&#xff0c;“落盘”俩字听起来就很底层&#xff0c;似乎无法和手头的性能问题联系到一起&#xff0c;本篇文章的目的就是让大家对它们俩建立起直观的认识。 写到数据库的数据总要保存起来——所以时序数据库&#xff08;Time Series Database&#xff0…
阅读更多...
移动隔断屏风墙，无地轨设计，空间灵活应用

移动隔断屏风墙，无地轨设计，空间灵活应用

移动隔断屏风墙是一种非常适合办公室的设计选择&#xff0c;它可以提供灵活的办公空间布局&#xff0c;并且无地轨设计可以避免地面安装轨道&#xff0c;给空间带来更大的自由度。以下是一些关于移动隔断屏风墙的特点和设计建议&#xff1a; 1. 灵活应用&#xff1a;移动隔断屏…
阅读更多...
JavaScript多功能甘特图组件 - jsGantt

JavaScript多功能甘特图组件 - jsGantt

jsGantt 是一个可定制的、灵活的、多语言的甘特图组件&#xff0c;由原生 JavaScript 构建。它使用客户端渲染以获得快速的性能和动态的交互性。非常适用于任何需要交互式时间线或时间表显示的项目。 更多特点 多语言支持&#xff1a; 通过对多语言的支持&#xff0c;使您的甘…
阅读更多...
容器技术与容器编排系统详解

容器技术与容器编排系统详解

一、Docker 容器技术 概括起来&#xff0c;Docker 容器技术有3个核心概念容器、镜像和镜像仓库。如果把容器类比为动态的、有生命周期的进程&#xff0c;则镜像就像是静态的可执行程序及其运行环境的打包文件&#xff0c;而镜像仓库则可想象成应用程序分发仓库&#xff0c;事先…
阅读更多...
6.30学习-函数柯里化，回调解决异步多线程

6.30学习-函数柯里化，回调解决异步多线程

6.30学习-函数柯里化&#xff0c;回调解决异步多线程 1.函数柯里化1.1 确定参数的函数柯里化1.2参数不确定的函数柯里化1.3 用法1.3.1 给setTimeout传递进来的函数添加参数 2.回调解决异步多线程 1.函数柯里化 函数柯里化&#xff0c;经常可能就面试的时候听说过&#xff0c;反…
阅读更多...
【Unity3D编辑器开发】Unity3D中初次尝试使用PropertyDrawer属性

【Unity3D编辑器开发】Unity3D中初次尝试使用PropertyDrawer属性

推荐阅读 CSDN主页GitHub开源地址Unity3D插件分享简书地址我的个人博客 大家好&#xff0c;我是佛系工程师☆恬静的小魔龙☆&#xff0c;不定时更新Unity开发技巧&#xff0c;觉得有用记得一键三连哦。 一、前言 前段时间一直比较忙&#xff0c;没有时间更新博客&#xff0c;…
阅读更多...
SSH连接vmware 虚拟机 centos

SSH连接vmware 虚拟机 centos

检查虚拟机设置的网络连接是否为NAT模式 点击左上角“编辑” -> “虚拟网络编辑器” 在虚拟网络编辑器中查看IP地址 &#xff0c;点击NAT模式后&#xff0c;点击“NAT设置 记住自己的网关,下面在服务器中配置需要 进入服务器的 /etc/sysconfig/network-scripts/ 编辑 i…
阅读更多...
Java性能权威指南-总结22

Java性能权威指南-总结22

Java性能权威指南-总结22 对象序列化追踪对象复制 Java EE网络API小结 对象序列化 追踪对象复制 先介绍一个示例&#xff0c;如何不对对象引用进行序列化&#xff0c;以避免在反序列化时处理对象引用。然而&#xff0c;writeobject()中最有力的优化是不重复输出对象引用。 在…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023