goframe
Compare original and translation side by side
🇺🇸
Original
English🇨🇳
Translation
Chinese重要规范
GoFrame Development Framework
—
Quick Start
—
Hello World
- 开发完整工程类型的项目时，需要先安装GoFrame CLI开发工具。
- 在GoFrame工程规范中，由开发工具自动维护的代码文件，不允许手动创建或修改。
- 除非用户有特别说明，否则不自动使用GoFrame文档中已标注为实验性的功能。例如，工程实践中的logic目录是实验性功能，默认不使用；在默认情况下，业务逻辑实现组件作为子目录存放到service目录下。
- 在service目录下，具体的业务模块使用子目录独立封装维护，不允许直接在service目录下创建go文件，如下示例：
bash
service/
├── user/ # 用户模块
├── order/ # 订单模块
└── ... # 其他业务模块Demonstrates building a simple Hello World Web Server using the GoFrame framework. GoFrame is a modular Go language framework that provides a convenient way to build web servers. This document analyzes the code example in detail, including Server object creation, route binding, port setting, and interpretation of running results, providing a quick start path for beginners.
Go参考资料
What's Next
| 参考资料 | 资料介绍 |
|---|---|
| WEB服务开发/Cookie | 在GoFrame框架中使用Cookie进行会话管理。通过ghttp.Request对象，开发者可以轻松获取、设置和删除Cookie。还讨论了SessionId的获取和设置，Cookie的过期时间处理，以及在控制器中继承和使用会话对象的简易方法。这些功能为Web开发者提供了强大的工具来管理用户会话，确保Web应用的灵活性和应变能力。 |
| WEB服务开发/HTTPClient/HTTPClient-代理Proxy设置 | 在GoFrame框架的HTTP客户端中设置代理服务器地址，支持http和socks5两种形式。通过SetProxy和Proxy方法，用户可以轻松配置代理，实现对外网资源的访问，包括普通调用示例和链式调用示例，帮助用户快速掌握代理功能的使用。 |
| WEB服务开发/HTTPClient/HTTPClient-基本使用 | 使用GoFrame框架通过基本的HTTP客户端操作来发送GET、POST、DELETE请求，并处理返回值。本文还讨论了如何使用POST方法发送JSON数据、使用多参数、map类型参数进行请求。同时，提供了*Bytes、Content和Var方法的简要介绍，以帮助开发者更便捷地处理HTTP请求和响应内容。 |
| WEB服务开发/HTTPClient/HTTPClient-常见问题 | 解释如何有效使用GoFrame框架中的gclient.Client对象，以提高效率和降低资源使用。包含gclient.Client对象复用的建议以及如何处理非法字符问题，通过示例演示设置正确的ContentType。 |
| WEB服务开发/HTTPClient/HTTPClient-拦截器中间件 | GoFrame框架中的HTTPClient拦截器/中间件特性，可用于全局请求拦截和参数校验。通过中间件，开发者可以在请求的前置和后置阶段插入自定义逻辑，修改提交参数或返回参数，实现签名参数注入等功能，确保接口参数的安全性。 |
| WEB服务开发/HTTPClient/HTTPClient-文件上传 | 使用GoFrame框架进行HTTP客户端文件上传，实现了方便的文件上传功能，并提供了三个主要的接口以支持单个和多个文件的上传。详细讲解了服务端及客户端的实现代码，并提供了自定义文件名称和规范路由接收上传文件的方法，适用于需要集成文件上传功能的开发场景。 |
| WEB服务开发/HTTPClient/HTTPClient-监控指标 | HTTP客户端的监控指标功能，默认情况下是关闭状态，以免影响性能。它提供了多种指标供用户参考，如请求执行的时间开销、连接创建时间以及请求的字节总大小等，只有在metric特性全局开启时才会启用这些指标，帮助用户更好地进行性能分析。 |
| WEB服务开发/HTTPClient/HTTPClient-自定义ContentType | 在GoFrame框架中使用HTTPClient自定义请求的ContentType。通过不同的操作方法如ContentJson和ContentXml，可以设置请求的Content-Type分别为application/json和application/xml。同时也提供了自定义ContentType的方法例子，帮助开发者灵活设置请求参数和编码方式，以满足不同的API请求需求。 |
| WEB服务开发/HTTPClient/HTTPClient-自定义Cookie | 在使用GoFrame框架的HTTP客户端中自定义发送给服务端的Cookie内容，主要通过SetCookie和SetCookieMap方法实现。通过简单的服务端和客户端示例展示了如何设置与接收自定义的Cookie参数，实现HTTP客户端的个性化请求。 |
| WEB服务开发/HTTPClient/HTTPClient-自定义Header | 通过GoFrame框架的HTTPClient功能，用户可以自定义HTTP请求的Header信息。本文介绍了如何利用SetHeader、SetHeaderMap和SetHeaderRaw等方法设置和发送Header，从而实现自定义链路跟踪信息，如Span-Id和Trace-Id。通过简单的代码示例，展示了客户端如何与服务端交互并返回结果。 |
| WEB服务开发/HTTPClient/HTTPClient-自定义Transport | 在GoFrame框架中，通过自定义Transport实现HTTPClient的高级用法。包括使用Unix Socket进行客户端与服务端通信的方法，以及设置客户端连接池大小参数的具体实现。示例提供了大量真实代码片段，帮助开发者更好地理解并应用这些技术。 |
| WEB服务开发/HTTPClient/HTTPClient-请求信息打印 | 使用GoFrame框架中的HTTP客户端功能获取和打印HTTP请求的原始输入和输出信息。主要方法包括Raw、RawDump、RawRequest和RawResponse，适用于调试HTTP请求。示例展示了使用GoFrame框架发送POST请求并打印请求和响应的具体方法。 |
| WEB服务开发/HTTPClient/HTTPClient | GoFrame框架提供的强大HTTP客户端gclient组件，支持HTTP请求的便捷链式操作。客户端支持自定义请求设置及返回对象操作，并详细介绍了超时、Cookie、Header等参数的设置方法。 |
| WEB服务开发/Session/Session-File | 使用GoFrame框架的ghttp.Server实现Session的文件存储。默认情况下，Session存储采用内存和文件结合的方式，通过StorageFile实现持久化管理。得益于gcache模块，Session数据操作高效，特别适合读多写少的场景。同时，演示示例展示了如何在GoFrame项目中设置与获取Session。 |
| WEB服务开发/Session/Session-Memory | 在GoFrame框架中使用内存存储实现Session功能。内存存储方式简单高效，但不支持持久化，因此在应用程序重启后Session数据会丢失。通过示例代码，详细说明了如何设置Session的过期时间以及如何存储和获取Session数据。 |
| WEB服务开发/Session/Session-Redis-HashTable | 在GoFrame框架中使用RedisHashTableStorage进行Session管理，区别于RedisKeyValueStorage，该方法直接通过Redis服务进行操作，无需全量拉取。通过示例代码，展示了基本的Session设置、获取和删除操作，以及如何在GoFrame中集成这个功能。 |
| WEB服务开发/Session/Session-Redis-KeyValue | 在GoFrame框架中使用Redis进行Session的KeyValue存储，以解决多节点部署下Session共享的问题。通过使用StorageRedis对象实现Redis存储，提高执行效率，适合单个用户Session数据量较小的场景，并提供具体的使用示例和说明。在示例中，Session过期时间设为1分钟，展示了设置、获取、删除Session的方法及Redis中Session数据的恢复功能。 |
| WEB服务开发/Session/Session-RegenerateI | GoFrame框架中的Session ID重新生成功能，通过RegenerateId和MustRegenerateId方法防止会话固定攻击，提高Web应用的安全性。详细介绍了会话固定攻击的原理、危害以及防范方法，并提供了完整的代码示例和安全建议。 |
| WEB服务开发/Session/Session-Storage接口开发 | 在GoFrame框架中使用gsession组件进行Session-Storage接口开发。通过组件内置的Storage实现，可以满足大部分业务场景的需求。开发者还可以根据特定情况，自定义Session存储。文中详细描述了Storage接口的定义及调用时机，为提高Session性能，建议使用gmap容器类型。本指南将帮助开发者更好地实现和优化存储接口。 |
| WEB服务开发/Session/Session | GoFrame框架中Session管理的相关功能，包括Session的基本概念、gsession模块的实现方式及其在不同场景中的应用。详细讨论了SessionId的传递方式和Session的初始化、销毁等操作，提供了四种常见的Session存储实现方式及其特点，为开发者在HTTP等多种服务环境下的Session管理提供了丰富的工具支持。 |
| WEB服务开发/分页管理/分页管理-Ajax分页 | 使用Ajax方法实现分页管理的技术细节。区别于传统分页方式，Ajax分页通过Javascript方法动态获取并渲染分页内容，以实现更流畅的用户体验。示例代码展示了如何在GoFrame框架中集成Ajax分页功能，提供一个实用的后端分页解决方案。 |
| WEB服务开发/分页管理/分页管理-URL模板 | 使用GoFrame框架的gpage进行分页管理，并通过自定义URL模板功能，使用内置变量替换页码内容来实现页面的动态渲染。文章提供了详细的代码示例，展示了通过设置UrlTemplate属性实现分页URL的个性化配置，为开发者提供了灵活高效的解决方案。 |
| WEB服务开发/分页管理/分页管理-动态分页 | 该文档介绍了如何在GoFrame框架中使用动态分页，通过GET参数传递分页配置，默认参数名为“page”。通过提供的示例代码，用户可以了解如何在网页中集成四种预定义的分页样式，以及实现分页管理的过程。 |
| WEB服务开发/分页管理/分页管理-自定义分页 | 在GoFrame框架中实现自定义分页样式和标签。通过分页对象公开的属性和方法，开发者可以通过正则匹配替换或自行组织分页内容的方式进行自定义，实现更高的灵活性和个性化。 |
| WEB服务开发/分页管理/分页管理-静态分页 | 在GoFrame框架中实现静态分页管理。静态分页通过使用路由传参的方式实现，具有较高的耦合性。通过示例说明了如何利用GoFrame框架中的模糊匹配路由、命名匹配路由以及字段匹配路由来实现分页功能，使得分页对象能够接受路由中的分页参数，从而实现页面的分开显示。 |
| WEB服务开发/分页管理/分页管理 | GoFrame框架中的分页管理功能，主要通过gpage模块实现。gpage模块支持动态和静态分页，并为开发者提供灵活的分页样式自定义方式。文章详细说明了分页对象的创建和使用，支持在Web服务中便捷地获取分页对象。还涵盖了预定义分页样式的使用以及Ajax分页的实现方法，以便于开发人员快速集成和使用。 |
| WEB服务开发/开始使用 | GoFrame框架提供强大的WebServer，由ghttp模块实现，涵盖路由、会话管理、缓存等功能。支持多端口监听、域名绑定、多实例运行，提供便捷的配置管理及服务器平滑重启能力，为开发者提供模块化和灵活性支持，为用户提供可靠的HTTP和HTTPS服务。 |
| WEB服务开发/异常处理 | 使用GoFrame框架中进行HTTP请求异常处理的策略。当请求过程中产生异常时，GoFrame会自动捕获panic，避免进程崩溃，并记录到日志文件中。开发者可以通过自定义中间件进行异常捕获和处理，同时可以获取详细的异常堆栈信息，更加有效地定位问题。本文还提供了多个代码示例，帮助读者理解异常处理的正确用法。 |
| WEB服务开发/接口文档/接口文档-OpenAPIv3 | 在GoFrame框架中使用OpenAPIv3协议来规范接口文档的生成。通过嵌入g.Meta元数据结构体，可以自动生成包含协议标签的接口信息。此外，文中还展示了如何自定义扩展标签和手动完善接口文档。 |
| WEB服务开发/接口文档/接口文档-扩展Response | GoFrame框架中OpenAPIv3接口文档的Response扩展功能，支持自定义HTTP状态码、响应结构体和示例数据。通过实现IEnhanceResponseStatus接口，开发者可以为API添加多种响应状态，增强接口文档的完整性和可读性，使文档更符合RESTful API设计规范。 |
| WEB服务开发/接口文档/接口文档-自定义UI | 在GoFrame框架中使用SwaggerUI自定义接口文档UI，以替代默认的Redoc组件UI。通过示例代码展示如何快速实现接口文档的替换，连接企业内部资源，避免外网依赖。详细演示了接口文档与第三方平台的对接，使用GoFrame Server进行UI模板切换，提升文档展示灵活性及可定制性。 |
| WEB服务开发/数据返回/数据返回-Exit控制 | GoFrame框架中的数据返回控制方法，包括Exit、ExitAll和ExitHook。Exit用于退出当前执行的逻辑方法，而ExitAll会强行中断当前执行流程，非常适用于权限控制。ExitHook用于当路由匹配到多个HOOK方法时，控制其执行顺序。这些方法在服务函数和HOOK事件回调函数中有效，并通过极少的运行时开销来提高易用性。 |
| WEB服务开发/数据返回/数据返回-JSONXML | 使用GoFrame框架的Response对象实现数据返回功能，支持JSON和XML格式输出。通过WriteJson、WriteXml等方法，可以轻松实现内容输出。示例代码展示了如何使用GoFrame构建HTTP服务器，并提供支持JSONP协议的实现方式。 |
| WEB服务开发/数据返回/数据返回-Redirect | 在GoFrame框架中使用RedirectTo和RedirectBack方法实现页面跳转功能。通过Location Header实现页面之间的跳转，包括跳转到指定地址和返回到上一页面。本示例演示了如何在本地服务中设置页面重定向，帮助开发者理解HTTP地址处理及Referer Header的应用。 |
| WEB服务开发/数据返回/数据返回-Stream返回 | 使用GoFrame框架实现HTTP流式数据返回，适用于框架版本小于v2.4及以上的版本。通过简化的代码实现高效的流式数据传输，适用于需要长连接和持续数据更新的场景，并提供注意事项和相关资料的参考。 |
| WEB服务开发/数据返回/数据返回-文件下载 | 在使用GoFrame框架构建的应用程序中通过Response对象实现文件下载功能。通过ServeFile方法可以展示文件内容，而通过ServeFileDownload方法则可以引导客户端下载指定路径的文件，充分利用流式下载技术以减少内存占用，提升性能。 |
| WEB服务开发/数据返回/数据返回-模板解析 | 在GoFrame框架中使用Response方法进行模板解析和数据返回的操作，包括WriteTpl和ParseTpl等方法。通过这些方法，可以将模板文件或内容进行解析并输出，同时支持使用内置变量如Config、Cookie、Session等，提供了灵活的模版操作方式。同时，包含详细的使用示例代码，帮助您更好地理解和应用。 |
| WEB服务开发/数据返回/数据返回-缓冲控制 | 在GoFrame框架中如何实现数据返回的缓冲控制。通过使用缓冲区可以提高执行效率并提供更灵活的输出控制。示例代码展示了如何通过中间件统一处理返回数据，避免错误信息直接暴露给客户端，并提供自定义的错误信息提示。 |
| WEB服务开发/数据返回/数据返回 | GoFrame框架中HTTP Server的数据返回处理。通过使用ghttp.Response对象及其提供的多种Write方法，用户可以实现高效的数据输出，包括Json、Xml格式的返回以及模板输出。此外，文中还涉及数据缓冲区的使用和HTTP头部信息的设置，帮助开发者更好地处理HTTP响应。 |
| WEB服务开发/服务配置/服务配置-配置文件 | 使用GoFrame框架的Server对象进行服务配置，支持通过配置文件进行配置，包括地址、日志设置和上传限制等。详细说明了单例对象的配置获取方式、默认值以及多配置管理方法，帮助用户优化服务配置策略。 |
| WEB服务开发/服务配置/服务配置-配置文件模板 | 一个GoFrame框架服务配置的文件模板，详细介绍了各项配置参数，如地址监听、TLS/HTTPS配置、静态服务、Cookie和Sessions设置、日志记录等，帮助用户更好地使用和配置GoFrame HTTP Server。 |
| WEB服务开发/服务配置/服务配置-配置方法 | 在GoFrame框架中通过SetConfig和SetConfigWithMap方法对服务器进行配置，包括配置对象ServerConfig的定义及使用Server对象进行特定配置。需要注意的是，配置项在Server执行Start后便不能再修改，以保证并发安全。 |
| WEB服务开发/请求输入/请求输入-Context | 在GoFrame框架中使用Context对象处理请求流程中的上下文变量共享。通过提供必要的方法，开发者可以在请求开始时设置自定义变量，并在后续的处理中访问它们。此外，本文包含了如何集成第三方组件以增强功能的示例代码和详细步骤。 |
| WEB服务开发/请求输入/请求输入-JSONXML | GoFrame框架对JSON和XML数据格式的原生支持，详细描述了如何通过GoFrame框架的Request对象来处理客户端提交的数据格式，提高开发效率。文档中包括示例代码演示如何解析和验证提交的数据，以及如何进行数据格式转换，为开发者提供了便捷的数据获取和处理能力。 |
| WEB服务开发/请求输入/请求输入-参数处理 | 在使用GoFrame框架构建的应用中，通过Query或Form参数实现复杂参数传递。文中详细阐述了同名参数、数组参数及Map参数的提交格式及其在服务端的解析方式，并给出相应的代码示例。建议在遇到复杂参数传递场景时，尽量使用JSON数据编码进行管理和维护。同时介绍了GetHeader方法获取请求头信息及默认值的使用。 |
| WEB服务开发/请求输入/请求输入-对象处理 | 该文档详细介绍了在使用GoFrame框架时如何处理请求输入的对象转换。通过将输入和输出定义为struct结构体对象，便于结构化参数的维护。文中介绍了默认和自定义的参数映射规则，以及如何通过Request对象的Parse方法进行便捷的对象转换和数据校验。 |
| WEB服务开发/请求输入/请求输入-自定义参数 | 在GoFrame框架中设置和获取自定义请求参数。自定义变量具有最高优先级，可覆盖客户端提交的参数，适用于请求流程中的变量共享。本教程还提供实际代码示例，展示如何在中间件中使用SetParam和GetParam方法来管理请求参数。 |
| WEB服务开发/请求输入/请求输入-请求校验 | 在GoFrame框架中通过v标签为结构体属性实现请求的输入校验。在示例中，我们讲解了如何使用gvalid模块进行校验，如何设置和解析注册请求的数据结构，以及在出现校验错误时如何处理，并展示了如何通过curl测试接口响应的数据和错误信息。此外，我们提供了不同版本的使用建议，以提高用户体验和代码的易用性。 |
| WEB服务开发/请求输入/请求输入-默认值绑定 | 在GoFrame框架中使用struct tag为请求输入对象的属性绑定默认值的功能。通过示例展示了如何定义参数对象并为其属性设置默认值，以及如何在服务端处理和验证请求参数。特别强调了在未提交参数时，默认值将生效，而在提交了参数（即使为空）的情况下，默认值将被忽略。同时提供了一些关于默认值参数绑定的注意事项建议。 |
| WEB服务开发/请求输入/请求输入 | 在GoFrame框架中通过ghttp.Request对象实现对请求输入的处理。参数获取方式丰富，包括Get、GetQuery、GetForm等常用方法，支持多种提交类型和参数类型的自动转换。文档还探讨了参数名称大小写敏感的问题及其对API对象接受参数的影响，并提供了完整的使用示例，帮助开发者更好地理解与应用。 |
| WEB服务开发/路由管理/路由管理-中间件拦截器/中间件拦截器-使用示例 | 使用GoFrame框架开发的文档展示中间件与拦截器功能。通过示例实现跨域请求、中间件鉴权、错误和日志处理等功能，进行路由管理和服务方法绑定，提供灵活的Web请求管理。 |
| WEB服务开发/路由管理/路由管理-中间件拦截器/中间件拦截器-基本介绍 | GoFrame框架中中间件和拦截器的基本使用。GoFrame通过优雅的中间件请求控制方式和经典的中间件洋葱模型，为WebServer提供灵活强大的插件机制。讨论了中间件定义、类型、注册方式及执行优先级，以提供全面的请求流程控制方案。 |
| WEB服务开发/路由管理/路由管理-中间件拦截器/中间件拦截器-常见问题 | 在使用GoFrame框架创建网站中，通过中间件修改请求参数和请求Body的常见问题及解决方案。特别关注自定义参数覆盖的机制以及修改请求Body时的注意事项，确保在中间件中正确处理HTTP请求的信息。 |
| WEB服务开发/路由管理/路由管理-路由注册/路由注册-函数注册 | 在GoFrame框架中进行路由注册，主要探讨了函数注册方法的灵活性。通过实例展示了如何利用包方法和对象方法进行路由函数的注册，以及如何确保并发安全。示例包括生成简单的“Hello World”和计算总访问量的方法，实现了通过并发安全类型gtype.Int的使用来维护访问计数。 |
| WEB服务开发/路由管理/路由管理-路由注册/路由注册-分组路由 | 在GoFrame框架中使用分组路由进行路由注册。分组路由是一种推荐的路由注册方式，支持层级和批量注册。用户可以为每个路由设置独特的HTTP Method以及应用中间件。通过这些特性，开发者能更高效地管理和优化项目的路由结构。 |
| WEB服务开发/路由管理/路由管理-路由注册/路由注册-对象注册 | 对象注册通过实例化的对象来执行路由注册，每个请求交由该对象处理，保持常驻内存不释放。该文档介绍了GoFrame框架中对象注册的相关方法，例如BindObject、BindObjectMethod、BindObjectRest等，并详细说明了对象如何按照RESTful设计进行注册。此外，还讨论了路由内置变量、命名风格规则以及Init和Shut的构造与析构方法。 |
| WEB服务开发/路由管理/路由管理-路由注册/路由注册-规范路由/规范路由-基本示例 | 使用GoFrame框架设置和运行一个简单的Hello服务示例，重点展示了配置文件的使用、路由定义和SwaggerUI页面的自动生成。此外，还探讨了接口文档生成、返回中间件处理以及如何定义规范化接口路径等问题，为开发者提供了一种便捷的方法来生成和测试API。 |
| WEB服务开发/路由管理/路由管理-路由注册/路由注册-规范路由/规范路由-如何使用 | 在GoFrame框架下定义路由方法、管理和注册路由，以及请求对象和返回对象的规范化结构。通过使用分组路由的Bind方法和基本的BindHandler方法，我们可以有效地管理路由。还包括如何进行输入数据校验以及使用统一的后置中间件进行数据处理。 |
| WEB服务开发/路由管理/路由管理-路由注册/路由注册-规范路由/规范路由-常见问题 | 在使用GoFrame框架的规范路由下，如何支持同一接口的多种HTTP Method提交方式。在设计RESTful接口时，每个API应有明确的HTTP Method对应，如创建用户、获取用户列表等。如果需要一个接口支持多个HTTP Method，可以通过Meta标签设置。此外，介绍如何使用类型别名让Response结构体的Data字段返回数组形式。 |
| WEB服务开发/路由管理/路由管理-路由注册/路由注册-规范路由/路由注册-规范路由 | GoFrame框架的规范路由注册方式，适合复杂项目和团队协作。新版本从v2.0开始支持，涵盖API结构化设计、参数风格定义、接口文档自动生成及同步维护等特性。 |
| WEB服务开发/路由管理/路由管理-路由注册/路由管理-路由注册 | 在GoFrame框架中如何进行路由注册和管理。WebServer通过ghttp包提供多种路由注册模式，提供强大的接口功能。特别是从框架v2版本开始，加入了规范路由的特性，旨在增强项目的工程化能力和复杂业务场景的适配。建议开发者在复杂业务中使用规范路由。 |
| WEB服务开发/路由管理/路由管理-路由规则 | GoFrame框架中强大的路由功能及其优化特性，包括命名匹配、模糊匹配和字段匹配等多种路由规则。通过示例代码展示如何使用这些规则管理和匹配不同的URL。此外，还详细讲解了如何利用精准匹配规则与动态匹配规则结合使用，以便更高效地控制路由优先级。 |
| WEB服务开发/高级特性/CORS跨域处理 | 使用GoFrame框架处理CORS跨域请求，结合路由管理中间件设置跨域规则，允许WebSocket跨域访问。提供CORS对象及其配置参数，包含默认和限制Origin来源的设置。同时，通过示例展示了基本使用方法、授权跨域Origin和自定义检测的方法，以实现更灵活的跨域请求管理。 |
| WEB服务开发/高级特性/CSRF防御设置 | 讲解如何在GoFrame框架中通过CSRF防御设置保护Web应用程序安全。我们将介绍使用token校验机制并通过中间件实现插件化防护的方法。包括插件的安装和配置以及前端对接的关键步骤和代码示例，帮助开发者有效抵御CSRF攻击。 |
| WEB服务开发/高级特性/HOOK事件回调 | GoFrame框架中ghttp.Server提供的HOOK事件回调功能，该功能类似于中间件，通过自定义监听处理特定事件，绑定事件回调注册顺序明确回调调用优先级。详细讲解了HOOK事件的使用方法、接口鉴权控制、跨域请求处理等实际应用场景，并结合示例代码展示事件回调的具体执行方式及优先级机制。 |
| WEB服务开发/高级特性/HTTPS & TLS | 使用GoFrame框架构建HTTPS服务，包括准备工作、示例代码以及通过Let’s Encrypt获取免费SSL证书的方法。同时，还探讨了如何在同一WebServer下同时支持HTTP和HTTPS访问协议的方法，确保您的应用更安全。 |
| WEB服务开发/高级特性/HTTPServer-监控指标 | 该文档介绍了如何在GoFrame框架中启用HTTP Server的监控指标功能，提供了详细的指标和属性列表，帮助用户实现HTTP服务器性能的监控与优化。通过启用metric特性，可以跟踪请求执行时间、请求总数以及传输字节大小等关键性能指标。 |
| WEB服务开发/高级特性/PProf服务性能分析 | 在使用GoFrame框架搭建的Web Server中利用pprof工具进行性能分析。GoFrame框架集成了pprof，可以借助EnablePProf方法便捷开启性能分析功能，并探讨了如何设置独立的PProf Server，以有效监控内存使用、goroutine行为及CPU性能等关键指标，同时提供具体命令行示例与解析。 |
| WEB服务开发/高级特性/SameSite 设置 | 在使用GoFrame框架构建的服务器中设置SameSite属性。通过详细的代码例子，您可以学习如何配置SameSite以确保cookie安全性，尤其是在chrome89及以上版本中处理不同协议的跨站请求。 |
| WEB服务开发/高级特性/WebSocket服务 | 使用GoFrame框架开发WebSocket服务，包括HTML5客户端、WebSocket服务端、HTTPS支持和安全校验等内容。通过示例代码，展示了WebSocket的连接与信息传递机制，并详细说明了服务端与客户端之间的通信流程和数据处理方法，让读者能够快速上手并实现功能齐全的WebSocket服务。 |
| WEB服务开发/高级特性/平滑重启特性 | 在使用GoFrame框架时启用和管理平滑重启特性。通过该功能，WebServer在更新版本或者重启时，无需中断已有请求，从而提高服务稳定性和用户体验。支持在*nix系统下的平滑重启和Windows系统下的完整重启，并提供Web和命令行的管理方法。还展示了具体的使用示例，包括基本使用、HTTPS支持和多服务多端口场景的平滑管理。 |
| WEB服务开发/高级特性/服务日志管理 | 使用GoFrame框架进行服务日志管理，包括access log和error log的配置与使用。详细解释了日志配置对象及属性，如Logger、LogPath、ErrorStack等，并提供了详细的日志格式说明和自定义日志处理方法。同时，还涉及如何通过配置文件和代码方法进行日志设置，以及日志格式和错误日志的记录方式和示例。 |
| WEB服务开发/高级特性/自定义状态码处理 | 在GoFrame框架中实现自定义状态码处理。通过使用BindStatusHandler方法，开发者可以为WebServer指定的状态码如404、403、500等进行自定义处理，包括展示自定义错误信息或页面内容，以及实现错误页面的重定向。示例代码演示了如何进行基本设置和批量状态码处理。 |
| WEB服务开发/高级特性/静态文件服务 | 了解如何在GoFrame框架中配置和使用静态文件服务，包括静态文件目录设置、静态文件服务开启条件、URI与静态目录映射、自定义URI重写规则及跨域配置示例，帮助开发者有效管理和优化项目中的静态资源访问。 |
| 常见问题-FAQ | 使用GoFrame框架和Golang进行开发时的常见问题解答，包括如何处理程序异常、新goroutine的创建方案、屏蔽json输出字段、解决兼容性问题、配置环境及glog错误修复，通过这些信息帮助开发者优化调试应用程序。 |
| 开发工具/交叉编译-buil | GoFrame提供的gf build命令是go build的强大封装工具，支持多平台多架构的交叉编译。该命令可自动嵌入编译变量（Go版本、GoFrame版本、Git Commit、编译时间等），支持配置文件和命令行参数，支持资源文件打包，为Go项目的跨平台构建提供便捷高效的解决方案。 |
| 开发工具/代码生成-gen/代码生成-gen | GoFrame框架CLI工具的核心代码生成功能模块，从v2版本开始提供的自动化代码生成能力，包含dao/do/entity数据模型生成、protobuf协议编译、接口控制器生成、业务服务接口生成、枚举值维护等多种代码生成命令。该工具旨在规范化项目代码编写、简化开发复杂度、让开发者聚焦业务逻辑实现，特别适用于企业级项目和多人协作的团队项目。工具通过统一的代码风格和规范化的目录结构，确保团队成员编码风格一致，显著提升开发效率和代码质量，但对于单人小型项目可根据实际需求灵活选择是否使用。 |
| 开发工具/代码生成-gen/协议编译-gen pb | GoFrame框架的协议编译命令工具，用于编译protobuf协议文件并自动生成相应的Go语言接口代码和控制器文件。该命令支持自定义接口文件和控制器文件的输出路径配置，能够智能识别已存在的接口实现方法并避免重复生成，有效防止代码覆盖。通过gf gen pb命令可以快速完成从proto协议定义到Go代码实现的转换，显著提升gRPC服务开发效率，简化微服务架构中的接口定义和实现流程。 |
| 开发工具/代码生成-gen/接口规范-gen ctrl | GoFrame提供的gf gen ctrl命令用于根据API接口定义自动生成控制器和SDK代码。该命令规范了API定义与控制器的命名和关联关系，支持按照/api/模块/版本/定义文件的目录结构组织代码，可自动生成控制器接口、初始化代码和HTTP SDK，支持File Watch自动化生成模式，有效减少重复性代码工作，降低多人协作时的代码冲突概率，提高团队开发效率。 |
| 开发工具/代码生成-gen/数据表PB-gen pbentity | GoFrame框架提供的数据表结构至protobuf文件的自动转换工具，通过gf gen pbentity命令读取数据库表结构生成对应的proto数据结构定义文件。该工具与gen dao模块生成的entity不同，pbentity主要用于gRPC服务中的数据传输实体，支持多种数据库类型，可自定义字段命名格式和JSON标签格式，提供灵活的类型映射配置，适用于需要同时提供HTTP和gRPC服务的微服务架构，实现数据库表结构与protobuf协议定义的自动同步维护。 |
| 开发工具/代码生成-gen/数据规范-gen dao | GoFrame框架的gf gen dao命令用于自动生成dao数据访问对象、do数据转化模型和entity实体数据模型的Go代码文件。该命令是框架工程规范落地的关键工具，支持通过命令行参数或配置文件管理生成规则，适用于MySQL、PostgreSQL、SQLite等多种数据库类型，支持表名通配符匹配、自定义类型映射、分表规则等高级功能，可显著提高数据层代码的开发效率和规范性。 |
| 开发工具/代码生成-gen/枚举维护-gen enums | GoFrame框架提供的枚举维护命令工具，通过自动分析项目源码生成规范化的枚举值定义和Go代码文件，主要用于完善OpenAPIv3文档中的枚举值维护。该工具能够有效解决API文档中枚举值类型参数展示不全、代码与文档脱节等问题，通过AST语法树解析技术自动识别和注册枚举值，显著降低手工维护成本，避免枚举值遗漏，提高前后端协作效率和开发质量。 |
| 开发工具/兼容修复-fix | GoFrame提供的gf fix命令用于自动修复GoFrame版本升级过程中的代码兼容性问题。该命令从v2.3版本开始提供，可自动检测项目中使用的GoFrame版本，并应用相应的兼容性修复规则，支持重复执行且无副作用。在框架难以保证完全向下兼容时，此命令可有效帮助开发者快速完成代码更新。 |
| 开发工具/工具安装-install | GoFrame框架命令行工具gf的安装指南，提供多种安装方式包括预编译二进制文件下载和通过go install命令安装。支持MacOS、Linux和Windows等多种操作系统，对于Mac/Linux系统提供一键快捷下载命令。install命令用于将gf工具安装到系统环境变量路径中，使用户可在任意目录下直接使用gf命令。文档详细说明了不同版本（v2/v1）的下载和安装方法，并提供了完整的安装示例和注意事项，包括MacOS zsh别名冲突的解决方案。 |
| 开发工具/开发工具 | GoFrame框架提供的功能强大的gf命令行开发辅助工具，是框架生态的重要组成部分。工具旨在简化工程开发流程、提高开发效率，并且支持框架工程设计规范准确落地。工具提供包括项目初始化、代码生成、自动编译、跨平台构建、框架升级等丰富功能。所有命令同时支持命令行参数和配置文件两种参数配置方式，提高易用性。工具版本与框架最新版本保持同步，需要Golang开发环境支持，遇到问题时可开启调试模式获取详细执行日志。 |
| 开发工具/框架升级-up | GoFrame框架提供的一键升级命令工具，从v2.3版本开始提供。通过gf up命令可以将项目中的GoFrame主框架和社区组件同时升级至最新版本，并且能够智能识别和自动修复版本升级过程中的不兼容代码变更。支持多种升级选项：单独升级框架版本、同时升级CLI工具、开启自动代码修复等。升级前建议git提交或备份代码，以便必要时回滚。该工具特别适合需要频繁更新框架版本的项目，能够大大简化版本迁移和升级流程。 |
| 开发工具/版本查看-version | GoFrame命令行工具的版本信息查看命令，通过gf -v或gf version查看gf工具的详细版本信息。命令会显示多项关键信息：CLI工具本身的编译版本、当前项目go.mod中使用的GoFrame框架版本、Go编译器版本、Git提交版本和构建时间等。特别需要注意区分项目中引用的GoFrame版本与CLI工具编译时的GF版本，这两者可能不同。该命令对于排查版本兼容性问题和确认工具安装状态非常有用。 |
| 开发工具/自动编译-run | GoFrame框架提供的自动编译运行命令工具，通过gf run命令实现类似热编译的开发体验。需要注意Golang本身不支持真正的热编译，gf run实际是通过监控项目go文件变化来自动触发重新编译和运行，从而避免手动停止、编译、启动的重复操作。工具会递归监控当前运行目录的所有go文件变化，支持自定义编译参数、运行参数、输出目录以及额外监控路径等配置，支持命令行和配置文件两种参数配置方式，显著提升本地开发调试效率。 |
| 开发工具/资源打包-pack | GoFrame框架提供的资源打包命令工具，通过gf pack命令将项目中的任意文件或目录（如静态资源、模板文件、配置文件等）打包成二进制资源文件或Go代码文件。打包后的资源文件可以嵌入到可执行文件中，实现单一可执行文件部署，无需另外携带资源文件。支持多源路径打包、自定义路径前缀、保留源路径等灵活配置，可与build命令结合实现打包和编译一步完成。该功能特别适用于需要将前端资源、配置文件嵌入后端服务的场景。 |
| 开发工具/镜像编译-docker | GoFrame提供的gf docker命令用于将Go项目编译并打包成Docker镜像。该命令支持自动执行二进制编译、镜像构建和推送等操作，支持通过命令行参数或配置文件管理构建选项。从v2.5版本起，推荐使用Makefile脚本组合gf build、gf gen enums、gf docker等命令，提供更灵活的镜像构建方案。 |
| 开发工具/项目创建-init | GoFrame框架提供的项目初始化命令工具，通过gf init命令快速创建标准化的GoFrame项目脚手架。从v2版本开始，项目模板已内置于工具二进制文件中，创建速度极快。支持创建SingleRepo单仓项目和MonoRepo大仓项目两种模式，生成的目录结构遵循框架推荐的代码分层设计规范，包含api、internal、manifest等标准目录，自动生成go.mod模块文件。项目结构采用通用化设计，开发者可根据实际需求灵活调整，适合各种规模和类型的Go项目开发。 |
| 微服务开发/工程管理 | 详细介绍GoFrame框架微服务开发的工程管理规范，包括统一的工程目录结构设计、协议文件的组织管理、接口文件的生成和存放规则。系统讲解如何使用框架内置的gf gen pbentity命令自动生成数据表对应的protobuf协议文件，以及如何通过gf gen pb命令编译proto文件并自动生成接口文件和控制器文件。同时阐述微服务的启动控制机制、接口实现与注册的规范流程，以及标签自动注入和数据校验插件的集成使用方法，帮助开发者快速构建标准化的微服务应用。 |
| 微服务开发/微服务开发 | 全面介绍GoFrame框架的微服务开发能力与特性。从v2.4版本开始，框架提供了完整的微服务组件支持，包括HTTP和gRPC两种通信协议的实现方式。详细讲解微服务的基本概念、低耦合组件化设计思想、服务注册发现机制的使用方法，以及内置的分布式链路跟踪能力。通过HTTP和gRPC两个完整的实战示例，演示服务端和客户端的开发流程，涵盖protobuf协议文件定义、服务注册配置、接口实现、服务启动和客户端调用等关键环节，帮助开发团队快速掌握GoFrame微服务架构的开发与应用。 |
| 微服务开发/拦截器组件 | 详细介绍GoFrame框架中gRPC拦截器的使用方法和内置拦截器功能。讲解如何在服务端和客户端灵活配置和使用拦截器，包括使用grpcx.Server.ChainUnary添加服务端拦截器和grpcx.Client.ChainUnary添加客户端拦截器。系统介绍框架grpcx组件提供的一系列常用拦截器，涵盖链路跟踪支持、错误处理组件集成、服务端Panic自动捕获、nil响应对象支持、基于结构体标签的自动数据校验等功能，帮助开发者提高gRPC服务的可扩展性、稳定性和可维护性。 |
| 微服务开发/服务注册发现 | 全面介绍GoFrame框架微服务架构中服务注册发现组件的使用方法和实现机制。详细讲解由gsvc组件管理的服务注册发现接口定义和社区实现，包括etcd、zookeeper、polaris、consul、nacos等多种主流注册中心的集成方式。通过HTTP和gRPC两种协议的完整示例，演示如何配置和使用服务注册发现功能，实现微服务的自动注册、服务发现和动态路由。阐述注册发现组件的启用方式、全局设置方法以及与框架各组件的协作机制，帮助开发者构建高可用、可扩展的分布式微服务系统。 |
| 微服务开发/服务端配置 | 详细介绍GoFrame框架gRPC服务端的配置管理方法和最佳实践。系统讲解GrpcServerConfig配置对象的各个参数含义和使用方式，包括服务名称、监听地址、日志存储目录、错误日志记录、访问日志记录等核心配置项。提供完整的YAML格式配置模板示例，涵盖基础配置和日志组件扩展配置的详细参数说明。阐述配置文件的自动读取和映射机制，以及访问端口配置、服务注册地址配置等重要注意事项，帮助开发者实现灵活高效的gRPC服务端配置管理和日志管理。 |
| 微服务开发/服务负载均衡 | 深入讲解GoFrame框架中客户端负载均衡组件gsel的使用方法和策略配置。详细介绍框架内置的四种负载均衡策略：LeastConnection（最小连接数）、Random（随机访问）、RoundRobin（轮询访问）和Weight（权重访问），阐述各策略的适用场景和特点。通过HTTP和gRPC两种协议的完整代码示例，演示如何在客户端配置和使用负载均衡策略，包括全局策略设置和请求级别策略选择。展示负载均衡在多服务端实例场景下的实际运行效果和请求分发机制，帮助开发者实现高可用、高性能的微服务架构。 |
| 微服务开发/服务配置管理 | 全面介绍GoFrame框架的配置管理组件及其在微服务架构中的应用。详细讲解框架的解耦化和接口化设计，支持灵活对接多种第三方配置管理中心，包括Polaris、Apollo、Nacos、Consul等主流配置中心，以及Kubernetes ConfigMap容器编排配置。通过Polaris配置中心的完整实战示例，演示配置管理组件的启用方式、初始化配置、参数说明和使用方法。阐述包初始化的引入顺序要求、配置文件的读取机制、以及配置数据的获取和验证方法，帮助开发者实现微服务的集中化配置管理和动态配置更新能力。 |
| 微服务开发/环境准备 | 介绍GoFrame微服务开发的环境准备工作，包括gRPC协议的依赖安装指南、protoc工具的配置方法、protoc-gen-go和protoc-gen-go-grpc插件的安装，以及GoFrame框架CLI工具（v2.4+版本）的准备工作，帮助开发者快速搭建微服务开发环境。 |
| 微服务开发/脚手架模块 | 介绍 GoFrame 框架 grpcx 脚手架组件的完整功能，包括 Server 服务端对象的创建与维护、Client 客户端的服务名称访问、Ctx 上下文的 Incoming/Outgoing 数据传递、Balancer 负载均衡策略（随机、轮询等）、Resolver 服务注册发现（支持 etcd 等组件），帮助开发者快速构建和管理 gRPC 微服务应用。 |
| 服务可观测性/服务监控告警/监控告警-内置指标 | 介绍 GoFrame 框架内置的 Go 运行时基础指标的使用方法。详细阐述如何通过 otelmetric.WithBuiltInMetrics() 参数开启 Go 基础指标，包括 cgo 调用次数、GC 周期统计、GC 暂停时间、协程数量、堆内存分配与使用情况等 13 种运行时指标。文中提供完整的示例代码，展示如何结合 Prometheus Exporter 导出指标，并启动 HTTP 服务器供 Prometheus 拉取指标数据。包含详细的指标说明表，明确每个指标的名称、类型（Counter、Histogram、Gauge）、单位和描述，帮助开发者实现 Go 应用的性能监测和优化。 |
| 服务可观测性/服务监控告警/监控告警-同步指标 | 在GoFrame框架中使用同步指标，通过gmetric提供的Counter、UpDownCounter和Histogram等类型快速暴露和记录HTTP请求的相关数据。利用Prometheus协议实现指标输出，以供外部监控工具抓取和分析，达到有效的性能监控和管理。 |
| 服务可观测性/服务监控告警/监控告警-基本介绍 | 介络GoFrame框架监控告警的基础知识，重点介绍 OpenTelemetry 关于监控和告警设计的相关规范和组件，涵盖 Meter Provider、Meter、Instrument、Measurements、View、Metric Reader、Metric Exporter 等组件及其数据流关系。详细阐述同步指标类型（Counter、UpDownCounter、Histogram）和异步指标类型（ObservableCounter、ObservableGauge等）的使用场景。介绍框架通过 gmetric 组件实现监控能力，采用抽象解耦设计，默认关闭监控，只有引入监控接口实现时才自动开启。 |
| 服务可观测性/服务监控告警/监控告警-基本使用 | 介绍在GoFrame框架中使用 gmetric 组件进行监控指标的开发方法。详细讲解如何通过引入 otelmetric 组件利用 OpenTelemetry 实现框架的监控指标接口。涵盖全局 Provider 获取、Meter 组件对象创建、监控指标对象的创建与配置（包括 Counter、UpDownCounter、Histogram 等同步指标类型，以及 ObservableCounter、ObservableGauge 等异步指标类型）。介绍 MetricOption 配置项的使用，包括 Help、Unit、Attributes、Buckets 等属性设置。演示如何使用 ManualReader 读取指标数据，以及 Provider 的全局设置与优雅关闭。通过完整的代码示例展示从初始化到数据读取的完整流程。 |
| 服务可观测性/服务监控告警/监控告警-异步指标 | 在GoFrame框架下使用异步监控指标，详细说明了ObservableCounter、ObservableUpDownCounter和ObservableGauge三种异步指标的使用方法。通过定义Callback函数管理指标数值变化，并利用Prometheus导出指标数据。 |
| 服务可观测性/服务监控告警/监控告警-指标属性 | 介绍GoFrame监控告警组件中指标属性的使用，包括常量属性、变量属性和全局属性三种注入方式，通过示例演示如何结合OpenTelemetry和Prometheus实现灵活的监控和分析。 |
| 服务可观测性/服务链路跟踪/链路跟踪-GRPC示例 | 使用GoFrame框架开发一个简单的GRPC服务端和客户端，并为GRPC微服务增加链路跟踪特性。示例代码说明了如何初始化Jaeger，用Redis适配器实现缓存，以及在客户端与服务端间进行链路信息传递。 |
| 服务可观测性/服务链路跟踪/链路跟踪-HTTP示例/链路跟踪-HTTP示例-Baggage | 使用GoFrame框架进行链路跟踪，重点展示了通过HTTP示例实现Baggage数据在服务间传递的方法。详细说明了客户端和服务端的代码实现，包括如何设置和获取Baggage，并提供了Jaeger查看链路信息的方式，为开发者在分布式系统中实现高效的链路跟踪提供了实用指南。 |
| 服务可观测性/服务链路跟踪/链路跟踪-HTTP示例/链路跟踪-HTTP示例-数据操作 | 该文档详细介绍了如何在GoFrame框架中实现链路跟踪，通过HTTP和数据库操作示例，展示了如何使用OTLP进行端到端的追踪。在示例中集成了缓存管理、数据库操作和Redis使用，通过Jaeger查看详细的链路信息，并分析了跨越客户端和服务端的追踪数据，帮助开发者优化和调试全流程。 |
| 服务可观测性/服务链路跟踪/链路跟踪-准备工作 | 介绍在 GoFrame 框架中使用 Jaeger 实现链路追踪的准备工作。包括 Jaeger 的基本介绍和快速部署方法（使用 Docker all-in-one 镜像）、GoFrame 框架中示例代码的位置、以及已封装好的 Jaeger、OTLP HTTP、OTLP GRPC 注册模块的使用方法，帮助开发者快速搭建 OpenTelemetry 分布式链路追踪环境。 |
| 服务可观测性/服务链路跟踪/链路跟踪-基本示例 | 介绍如何在单进程中使用GoFrame进行链路跟踪。通过创建Root Span来追踪方法调用链，展示如何使用gtrace.NewSpan在方法间创建Span记录方法调用过程。详细的示例代码演示了main函数创建root span、GetUser/GetInfo/GetDetail/GetScores等方法间的span调用关系和context传递。最后在Jaeger UI中查看链路追踪结果，包括span的调用顺序、调用关系、执行时间轴、Attributes和Events信息，帮助用户快速定位系统异常和发现性能瓶颈。 |
| 服务可观测性/服务链路跟踪/链路跟踪-最佳实践/链路跟踪-TraceID注入和获取 | 在链路跟踪中如何使用GoFrame框架进行TraceID的注入和获取。TraceID是服务间请求关联的重要标识，通过Context参数传递，可在客户端和服务端中自动生成、承接或自定义TraceID。使用glog日志组件可以自动记录TraceID，GoFrame的Client和Server拥有便捷的TraceID管理方法。并提供了一些实践示例，包括自定义TraceID和处理第三方RequestID的集成方式。 |
| 服务可观测性/服务链路跟踪/链路跟踪-背景知识 | OpenTelemetry项目的背景和重要概念，包括TracerProvider、Tracer、Span、Attributes、Events、SpanContext和Propagator等组件，并说明了GoFrame框架在这些技术上的支持，以及如何使用gtrace模块实现链路跟踪。此外，还列举了支持OpenTelemetry标准的GoFrame核心组件，如HTTP客户端、HTTP服务端、gRPC客户端和服务端、Logging、ORM和NoSQL Redis等。 |
| 核心组件/I18N国际化/I18N国际化-使用介绍 | 在GoFrame框架中使用i18n国际化功能，包括对象创建、语言设置、常用方法以及与视图引擎的集成。详细描述了通过单例和独立对象管理语言转译的方式，使用SetLanguage和WithLanguage方法进行语言设定，并通过T和Tf方法实现关键字和模板内容的转译。文章还展示了通过上下文设置和视图引擎进行国际化操作的示例。 |
| 核心组件/I18N国际化/I18N国际化-配置管理 | I18N国际化组件是GoFrame框架的核心组件之一，支持多种配置文件格式如xml、ini、yaml、toml等，并兼容多种目录结构和文件格式，开发者可通过配置实现多语言支持。系统自动识别语言文件，支持自定义路径设置，推荐使用标准国际化语言码进行文件命名，确保程序多语言兼容性。 |
| 核心组件/I18N国际化/I18N国际化 | GoFrame框架中的I18N国际化组件，它由gi18n模块实现。通过导入相关模块，开发者能够在软件项目中轻松实现多语言支持，从而提高应用的国际化能力。详细接口文档可通过提供的网址查看，以获得更多技术细节。 |
| 核心组件/命令管理/命令管理-Parser解析 | GoFrame框架的命令行解析功能，重点讲解了gcmd组件的Parser解析方法。通过自定义选项名称和数值解析，能够高效管理和解析命令行选项。包括代码示例和详细的接口文档，帮助开发者理解和应用于实际项目中。 |
| 核心组件/命令管理/命令管理-命令行对象 | 详细介绍 |
| 核心组件/命令管理/命令管理-基本概念 | 详细讲解命令行管理中参数( |
| 核心组件/命令管理/命令管理-基础方法 | 全面介绍 |
| 核心组件/命令管理/命令管理-终端交互 | 详细介绍 |
| 核心组件/命令管理/命令管理-结构化参数 | 深入讲解 |
| 核心组件/命令管理/命令管理-链路跟踪 | 详细介绍 |
| 核心组件/命令管理/命令管理 | 介绍GoFrame框架的gcmd命令行管理组件，提供结构化参数管理、多层级命令、自动类型转换、参数校验、链路跟踪等特性，支持从配置组件读取参数和自动生成帮助信息。 |
| 核心组件/对象管理 | 介绍GoFrame框架的g模块对象管理功能，包括常用数据类型别名（Var、Map、Slice等）以及单例对象的获取方法。通过g.*方法可以方便地获取HTTP客户端、数据校验、配置管理、日志管理、模板引擎、WEB/TCP/UDP Server、数据库ORM、Redis客户端等常用对象，实现简便高效的对象管理。 |
| 核心组件/数据库ORM/ORM上下文变量 | 在GoFrame框架中如何通过ORM支持自定义的上下文变量，以实现异步IO控制、链路跟踪、嵌套事务等功能。通过使用Ctx方法，开发者可以轻松传递自定义上下文变量，实现更复杂的请求控制和跟踪。文章提供了请求超时控制和模型上下文操作的具体示例和建议。 |
| 核心组件/数据库ORM/ORM事务处理/ORM事务处理-事务传播 | GoFrame ORM事务传播功能提供了灵活的事务管理机制，支持多种事务传播行为，满足复杂业务场景下的事务处理需求。 |
| 核心组件/数据库ORM/ORM事务处理/ORM事务处理-只读模式 | GoFrame ORM 事务只读模式详解，包括基本概念、优势、应用场景以及代码示例，帮助开发者提高数据库操作的安全性和性能。 |
| 核心组件/数据库ORM/ORM事务处理/ORM事务处理-嵌套事务 | 使用GoFrame框架中的ORM功能来处理嵌套事务的问题。文章详细讲解了嵌套事务的基本原理、方法以及日志信息，同时给出了常规操作和闭包操作的示例，并指出可能出现的问题。最后提供了嵌套事务在工程中的参考示例，帮助开发者理解在实际项目中如何应用。 |
| 核心组件/数据库ORM/ORM事务处理/ORM事务处理-常规操作 | 在GoFrame框架中进行ORM事务处理的基础操作，包括如何使用Begin、Commit和Rollback方法来开启、提交和回滚事务。同时特别提示事务操作后需要及时关闭事务以避免资源泄露，建议使用Transaction闭包方法实现安全事务操作。 |
| 核心组件/数据库ORM/ORM事务处理/ORM事务处理-闭包操作 | 在GoFrame框架中使用闭包操作进行ORM事务处理的优点，包括减少冗余代码、降低操作风险和简化嵌套事务，实现自动提交和回滚功能，并介绍了上下文参数在嵌套事务管理中的作用，确保事务处理的安全性和简便性。 |
| 核心组件/数据库ORM/ORM事务处理/ORM事务处理-隔离级别 | GoFrame ORM 事务隔离级别详解，包括基本概念、不同隔离级别的特点、优势与应用场景，以及在 GoFrame 中使用事务隔离级别的代码示例和实际应用案例。 |
| 核心组件/数据库ORM/ORM使用配置/ORM使用配置-配置文件 | 使用GoFrame框架的配置组件来管理数据库配置，包括推荐使用的yaml格式配置文件。通过g对象轻松获取数据库操作的单例对象，支持多种数据格式下的配置和简化的连接配置方式，实现集群模式与日志输出功能。 |
| 核心组件/数据库ORM/ORM使用配置/ORM使用配置-配置方法 | 在GoFrame框架中配置管理gdb数据库模块。主要涵盖了数据结构设计、配置特点、以及具体的配置方法。通过配置ConfigNode和ConfigGroup，开发者可以灵活地管理多节点数据库集群，实现高效的负载均衡和读写分离。此外，还提供了一些默认的分组和自定义全局配置的示例。 |
| 核心组件/数据库ORM/ORM分库分表/ORM分库分表-分库特性 | GoFrame ORM分库特性提供了灵活高效的库分片功能，支持自定义分库规则，轻松实现数据库水平扩展。 |
| 核心组件/数据库ORM/ORM分库分表/ORM分库分表-分表特性 | GoFrame ORM分表特性提供了简单高效的表分片功能，支持自定义分表规则，轻松应对大数据量场景。 |
| 核心组件/数据库ORM/ORM常见问题 | 在使用GoFrame框架进行ORM操作时可能遇到的几种常见问题及其解决方案，包括数据库连接池过期导致的连接错误、update和insert操作不生效、无法找到数据库驱动、查询条件带有WHERE 0=1的问题以及MySQL表情存储乱码问题等。同时给出了一些配置建议以优化使用体验。 |
| 核心组件/数据库ORM/ORM接口开发/ORM接口开发-回调处理 | 在使用GoFrame框架进行ORM接口开发时，通过自定义回调处理来对SQL语句进行日志记录或鉴权。通过实现并覆盖DoQuery、DoExec等接口方法，开发者可以注入自定义逻辑到默认实现中。示例中展示了如何自定义MySQL驱动以记录执行的SQL语句，并配置gdb以使用该驱动。 |
| 核心组件/数据库ORM/ORM接口开发/ORM接口开发-驱动开发 | 在GoFrame框架中进行ORM接口开发，特别是数据库驱动的开发和注册。通过实现gdb模块的接口，可以新增GoFrame默认不支持的第三方数据库驱动或对已有支持的驱动进行定制化修改，实现上层业务操作的一致性。本文档提供了详细的步骤和示例代码，帮助开发者快速上手。 |
| 核心组件/数据库ORM/ORM接口开发/ORM接口开发 | GoFrame框架中gdb模块的ORM接口开发，通过灵活的接口设计，开发者可以方便地自定义数据库操作实现。DB接口作为核心接口，提供了数据库连接创建、查询与执行等方法，而Driver接口则允许用户定义自己的驱动实现。详细的接口文档和方法说明将帮助您快速上手并进行二次开发。 |
| 核心组件/数据库ORM/ORM方法操作-原生 | 使用GoFrame框架进行原生SQL的ORM方法操作。详细讲解了通过方法操作来执行复杂SQL的方法，包括数据库查询、数据插入、更新、删除和批量操作的具体用法，同时提供了具体的代码示例。 |
| 核心组件/数据库ORM/ORM时区处理 | 在GoFrame框架中处理ORM操作中的时区问题，特别是使用MySQL数据库时的时区转换。我们讲解了如何通过设置loc参数来控制time.Time对象在提交到数据库时的时区处理，并提供了相关代码示例和配置建议，帮助开发者在处理数据库操作时更好地管理时区。 |
| 核心组件/数据库ORM/ORM最佳实践/利用指针属性和do对象实现灵活的修改接口 | 利用GoFrame框架中的指针和do对象实现灵活的修改接口API。通过指针类型的属性参数和do对象，开发者可以轻松实现用户信息的修改操作，包括密码、昵称、状态等字段的更新，从而有效简化数据库更新的复杂度。 |
| 核心组件/数据库ORM/ORM最佳实践/复杂类型尽量使用json存储，便于Scan到对象时自动化转换，避免自定义解析 | 在数据库设计中使用JSON格式存储复杂类型数据的优势，主要通过GoFrame框架实现自动化转换，从而简化代码。以产品售卖规格为例，通过定义和使用Go结构体实现数据库的增删查改，避免自定义解析的复杂操作。此外，详细展示了如何在Go应用中进行数据写入和查询，确保高效率的数据处理过程。 |
| 核心组件/数据库ORM/ORM最佳实践/查询时避免返回对象初始化及sql.ErrNoRows判断 | 在使用GoFrame框架进行SQL查询时，避免对象初始化以及sql.ErrNoRows错误判断问题。通过不初始化查询结果对象，使用指针为nil判断的方法，统一项目中对空查询结果的处理逻辑，从而降低代码对错误处理的复杂度。 |
| 核心组件/数据库ORM/ORM结果处理/ORM结果处理-为空判断 | 使用GoFrame框架进行ORM结果处理中的为空判断。包括处理数据集合、多条数据记录、数据字段值，以及Struct对象和Struct数组的结果处理方法。通过使用IsEmpty和IsNil等方法，可以轻松地判断查询结果是否为空。 |
| 核心组件/数据库ORM/ORM结果处理/ORM结果处理-空数组结构返回 | 在GoFrame框架中处理ORM查询结果，当未查询到数据时，通过初始化空数组避免返回null值，从而增强与前端的友好交互。这种改进可以在数据需要展示于网页时，确保返回格式的预测性与稳定性。 |
| 核心组件/数据库ORM/ORM结果处理/ORM结果处理-结果类型 | GoFrame框架中ORM结果处理的几种结果类型，包括Value、Record和Result的数据结构定义。通过示例详细讲解了如何将数据表记录转换为struct对象，以及Result/Record类型在特定字段检索场景下的应用。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-Handler特性 | 在GoFrame框架中使用ORM链式操作实现Handler特性，通过示例展示了如何复用常见的查询逻辑和分页操作，从而简化代码，提高开发效率。Handler特性允许开发者定义通用逻辑并应用于数据库模型，实现更为简洁和可维护的代码结构。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-Hook特性 | 在GoFrame框架中使用Hook特性，为Model对象绑定CRUD钩子，从而实现对数据库操作的增强和优化。文中详细介绍了相关定义、Hook注册方法以及使用示例，通过挂钩函数对查询操作进行了演示。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-主从切换 | 在GoFrame框架中使用gdb实现应用层的主从配置和读写分离。通过简单的配置，gdb可以自动进行主从切换，大幅度提高数据库的运行效率和可用性。本文还提供了一些使用Master和Slave方法自定义节点操作的示例，帮助开发者更好地应对主从同步延迟带来的问题，确保数据的即时性和准确性。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-事务处理 | 在GoFrame框架中使用事务处理对于ORM链式操作的方法。通过Transaction和TX接口，可以实现对数据库的事务性操作，确保数据的一致性和可靠性。详细讲解了使用TX接口创建Model对象的方法及其事务处理中Commit和Rollback的机制。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-写入保存 | GoFrame框架中ORM链式操作的写入保存方法，包括Insert、Replace、Save等方法的使用。这些方法支持自动单条或批量的数据写入，适用于多种数据库环境，并提供详细示例帮助理解如何结合使用Data方法进行数据操作。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-字段获取 | 使用GoFrame框架中的ORM链式操作来获取数据库表字段的技巧，包括使用GetFieldsStr和GetFieldsExStr方法获取指定表的字段及排除字段的用法，支持字段前缀自定义，提升开发效率和代码可读性。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-字段过滤 | 在使用GoFrame框架进行数据库操作时如何进行字段过滤。详细描述了Fields和FieldsEx方法的用途与示例，并深入探讨了OmitEmpty及OmitNil特性如何帮助在数据库写入过程中过滤空值数据。此外，还探讨了在数据查询过程中空值对条件参数的影响。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-对象输入 | 该文档介绍了如何在GoFrame框架中使用链式操作的对象输入功能，支持不同类型的数据参数，使得gdb具有极高的灵活性。详细说明了使用struct对象进行参数输入时的映射关系以及标签的优先级，以实现数据库ORM的有效转换。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-悲观锁 & 乐观锁 | 在GoFrame框架中如何通过链式操作实现悲观锁和乐观锁。悲观锁用于在每次数据访问时上锁以避免冲突，常用于高并发场景；而乐观锁则通过版本号机制检查数据更新，适用于多读少写的场合。详细分析了适用场景、实现方法及锁机制的优缺点，帮助开发者优化数据库性能。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-数据库切换 | 在使用GoFrame框架进行ORM链式操作时切换数据库。我们通过不同的配置分组、运行时更改单例对象的数据库配置、使用Schema方法进行链式操作，以及通过表名中带数据库名称来实现多种数据库切换方案。这些方法为开发者提供了灵活的数据库操作方式。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-数据查询/ORM查询-AllAndCount | 该文档介绍了GoFrame框架中从v2.5.0版本开始提供的AllAndCount方法，该方法用于在分页查询场景中同时检索数据记录列表及总数量，简化查询逻辑。通过在查询时忽略Limit/Page操作，AllAndCount方法能够提供一种便捷的方式对数据进行检索和计数。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-数据查询/ORM查询-Exist | 使用GoFrame框架的Exist方法能够有效判断满足特定条件的数据是否存在而无需获取完整数据结果。配合MySQL表结构，通过SELECT 1方式提升查询效率，降低不必要的数据传输。本文包含方法定义、MySQL表结构示例及实际使用情境，帮助开发者更好地优化模型查询环节。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-数据查询/ORM查询-Join查询 | 在GoFrame框架中如何使用ORM进行LeftJoin、RightJoin和InnerJoin查询，包括使用不同的关联查询方法及其应用场景。文中强调在大数据量和高并发环境中谨慎使用Join操作，推荐使用代码实现数据聚合。此外，还提供了通过自定义数据表别名和字段操作符进行join查询的示例，并结合dao展示具体的使用方法。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-数据查询/ORM查询-ScanAndCount | 在使用GoFrame框架进行ORM查询时简化分页查询场景。通过ScanAndCount方法，可以在一次操作中完成数据查询和总数量查询，有效减少代码冗余，提高开发效率。适用于需要同时获取数据和其总数量的情况，如分页查询。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-数据查询/ORM查询-Scan映射 | 在GoFrame框架中使用Scan方法进行ORM查询的技巧，主要包括如何将查询结果转换为struct对象和struct数组。通过示例代码说明了Scan方法的用法，如单条记录转换为struct对象、多条记录转换为struct数组等，帮助用户有效地处理数据库查询结果。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-数据查询/ORM查询-UnionUnionAll | 使用GoFrame框架中的ORM组件进行Union和UnionAll查询操作。使用Union操作符可以删除重复数据，而UnionAll操作符则保留所有数据。通过链式操作或者方法操作可以轻松实现这两种查询方式。文章还介绍了如何在MySQL中进行组合查询，并提供了详细的代码示例。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-数据查询/ORM查询-Where条件 | GoFrame框架中ORM组件提供的多种条件查询方法，详细阐述了Where、WhereOr、Wheref等方法的使用方式，及它们如何进行条件组合作用。通过示例展示了如何利用这些方法进行复杂数据库查询，并探讨了使用主键查询的优势。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-数据查询/ORM查询-分组排序过滤 | 使用GoFrame框架的ORM进行查询操作，包括分组、排序和条件过滤。通过Group方法实现数据分组，通过Order方法进行排序，以及通过Having方法对查询结果进行条件过滤，提供了详细的代码示例和方法说明，帮助用户更好地掌握数据库操作技能。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-数据查询/ORM查询-子查询特性 | GoFrame框架中ORM组件支持的三种子查询特性：Where子查询、Having子查询及From子查询。通过示例讲解如何在Where、Having条件以及使用Model方法创建模型时利用子查询提升数据库查询效率。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-数据查询/ORM查询-常用操作示例 | 使用GoFrame框架进行ORM查询的常用操作示例，包括IN、LIKE、MIN/MAX/AVG/SUM等操作，同时介绍了WhereIn、WhereNotIn、WhereBetween等链式查询方法的使用，通过案例帮助理解不同的查询策略和参数过滤方式。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-数据查询/ORM查询-常用查询方法 | 使用GoFrame框架中的五个常用数据查询方法：All、One、Array、Value和Count。这些方法允许您轻松地从数据库中获取多条或单条记录，并支持条件参数的直接输入。通过示例代码，您将学习如何在GoFrame中有效地进行数据库操作。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-时间维护/ORM链式操作-时间维护 | 使用GoFrame框架中的gdb模块进行ORM链式操作时的时间维护特性。通过自动填充创建、更新和删除时间，有效提高了开发效率。文章详细讲解了如何启用这些特性以及在执行数据库操作如插入、更新和删除时的实现方式。此外，还提供了针对软删除和忽略时间维护等场景的解决方案。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-时间维护/时间维护-SoftTimeOption | 介绍如何在GoFrame框架中使用SoftTimeOption控制时间写入粒度，实现秒级到毫秒级的时间戳转换，并提供相关MySQL表结构和示例代码，帮助开发者灵活配置时间字段，支持多种时间粒度选项以满足不同项目需求，并通过ORM方法插入数据 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-时间维护/时间维护-基本使用 | 本文介绍了使用GoFrame框架管理数据库时间字段的基本方法，包括created_at、updated_at和deleted_at字段的写入和更新机制，以及软删除特性对查询和更新操作的影响，同时展示了联表查询和忽略时间特性Unscoped的方法。通过这些示例，可以有效管理数据的软删除和时间戳，确保数据库记录的准确性。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-时间维护/时间维护-布尔字段 | 介绍GoFrame框架中时间字段为布尔字段的支持，通过示例展示如何使用布尔类型的deleted_at字段进行数据软删除。提供MySQL表结构定义以及在GoFrame中使用ORM组件进行创建记录和软删除操作的示例。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-时间维护/时间维护-整型字段 | 如果时间字段如created_at、updated_at、deleted_at为整型字段，GoFrame框架的ORM组件会自动识别并写入秒级时间戳。插入操作时created_at自动更新，但更新和删除不改变created_at。使用Replace方法会更新所有时间字段。在软删除情况下，所有查询自动包含deleted_at=0条件。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-更新删除 | 在GoFrame框架中进行ORM链式操作的数据更新和删除。详细阐述了使用Update和Delete方法时需要结合Where条件的重要性。此外，还探讨了通过Counter参数实现字段数值增减的特性，以及使用Increment和Decrement方法对字段进行自增自减的操作。同时，还讲解了嵌入原生SQL语句的技巧和实现软删除的方式，以确保数据处理的灵活性和安全性。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-查询缓存 | 使用GoFrame框架中的ORM进行查询缓存操作。它支持对查询结果进行缓存优化，适用于多读少写场景。文中详细介绍了缓存管理和适配，特别是如何通过Redis实现分布式缓存。还提供了示例代码展示数据表结构及其缓存效果，演示了查询缓存的实现与缓存清理功能。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-模型关联/模型关联-动态关联-ScanList | GoFrame框架中如何处理模型关联的设计，通过简化标签内容和关联属性，降低心智负担。详细讲解了如何使用ScanList方法进行数据结构的动态关联，展示了用户、用户详情和用户学分之间的1:1和1:N关系，并提供了Go语言的示例代码进行数据查询和写入操作，包括事务处理和数据绑定的实现方式。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-模型关联/模型关联-静态关联-With特性 | GoFrame框架中的With特性，通过示例展示了如何使用With特性实现模型关联、数据查询，介绍了数据结构定义、事务操作、数据写入与查询等方面的内容，帮助开发者更好地理解和使用GoFrame框架进行高效开发。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作-模型创建 | 使用GoFrame框架中的ORM工具进行链式操作，重点讲解了模型创建、Model对象的使用以及实现链式安全的几种方式。通过使用Model、Raw方法，在默认和切换的数据库配置上创建模型对象，并探讨链式安全的实现，包括默认非链式安全、Clone方法克隆、Safe方法设置链式安全等操作技巧。 |
| 核心组件/数据库ORM/ORM链式操作/ORM链式操作 | GoFrame框架中gdb的链式操作方式，这是一种灵活且官方推荐的数据库操作方式。通过db.Model或tx.Model方法，可以基于数据表返回链式操作对象*Model，支持多种数据库操作，如Replace、Save、InsertGetId等，并详细说明了每种数据库的支持情况。 |
| 核心组件/数据库ORM/ORM高级特性/ORM高级特性-RawSQL | 在GoFrame框架中使用ORM的RawSQL特性，通过使用gdb.Raw类型，可以在生成的SQL语句中嵌入自定义的SQL片段，实现更灵活的数据库操作。详细讲解了在Insert、Update和Select操作中使用RawSQL的方法及其示例，确保SQL语句的安全性和灵活性。 |
| 核心组件/数据库ORM/ORM高级特性/ORM高级特性-SQL捕获 | GoFrame框架中ORM的高级特性，主要关注SQL捕获和转换功能。通过CatchSQL和ToSQL方法，能够在执行SQL语句前捕获或预估SQL操作，并配合上下文对象实现操作记录与调试。这些功能有助于开发者高效调试和测试数据库操作。 |
| 核心组件/数据库ORM/ORM高级特性/ORM高级特性-内嵌结构支持 | GoFrame框架中ORM组件对内嵌结构的高级特性支持，包括结构体的参数传递和结果处理。通过示例讲解了如何在实践中应用这些功能，支持多层级的struct嵌套，提高开发效率。 |
| 核心组件/数据库ORM/ORM高级特性/ORM高级特性-字段映射 | 通过GoFrame框架的ORM高级特性，可实现自动化字段映射和识别。使用Map或Struct类型参数时，可自动匹配数据表字段名称，大幅减少开发者在数据字段与业务属性间人工匹配的工作量。此外，通过设计接口并在内存中缓存字段信息，提升数据操作效率。本文还展示了如何通过实际示例实现用户和医生信息的高效查询。 |
| 核心组件/数据库ORM/ORM高级特性/ORM高级特性-日志输出 | GoFrame框架中ORM组件的日志输出功能，重点讲解了如何通过SetLogger和GetLogger方法设置日志，以及如何在配置文件中启用日志输出功能。文中示例展示了SQL语句的调试过程，包括日志级别、执行耗时、SQL语句等详细信息，帮助用户更好地理解和调试应用程序中的数据库操作。 |
| 核心组件/数据库ORM/ORM高级特性/ORM高级特性-空跑特性 | GoFrame框架中的ORM空跑特性，该特性通过DryRun配置项启用，可以在不开启实际写入、更新、删除操作的情况下调试SQL语句。本文提供了详细的配置示例以及如何利用命令行参数和环境变量全局修改该特性的使用方法，帮助开发者在开发过程中验证SQL执行的正确性。 |
| 核心组件/数据库ORM/ORM高级特性/ORM高级特性-类型识别 | 在使用GoFrame框架进行ORM查询时的高级特性——类型识别。通过GoFrame框架，查询结果中的字段值会自动识别并映射为对应的Go语言变量类型，例如int类型或string类型。这一功能对于将查询结果编码并通过JSON等方式直接返回给客户端非常实用，并有助于提升开发效率。 |
| 核心组件/数据库ORM/ORM高级特性/ORM高级特性-类型转换 | 使用GoFrame框架中的gdb模块进行ORM高级特性实现，重点是在数据库记录结果的数据类型转换功能。gdb模块灵活支持多种数据类型的转换，并通过示例展示了如何在Go代码中实现对数据库表中商品信息的获取和处理。 |
| 核心组件/数据库ORM/ORM高级特性/ORM高级特性-调试模式 | 在GoFrame框架中使用ORM高级特性的调试模式。在开发阶段，通过Debug配置文件配置项或SetDebug配置方式，可以开启调试模式，使数据库SQL操作语句以DEBUG级别输出到终端或日志文件中，便于开发者进行问题排查和性能优化。 |
| 核心组件/数据库ORM/ORM高级特性/ORM高级特性-连接池状态 | 使用GoFrame框架的DB.Stats方法获取ORM对象的连接池状态。通过示例代码，开发者可以了解如何配置数据库连接，并通过GoFrame获取连接池的详细状态信息。同时，介绍了连接池状态输出的具体字段及其意义。 |
| 核心组件/数据库ORM/数据库ORM | 在GoFrame框架中使用gdb模块实现数据库的ORM功能，强调了连接池设计、预处理SQL参数以及自动识别Map/Struct的特点。GoFrame ORM组件支持事务嵌套、接口化设计，并兼容主流数据库驱动，具备强大的配置管理和调试特性。 |
| 核心组件/数据校验/数据校验-参数类型/数据校验-Map校验/Map校验-基本使用 | 在GoFrame框架中进行Map校验，演示了如何使用默认及自定义错误提示。通过示例代码展示了如何对参数进行验证，以及在验证失败时输出相应的错误信息，帮助开发者更好地实现数据验证和错误处理机制。 |
| 核心组件/数据校验/数据校验-参数类型/数据校验-Map校验/Map校验-校验顺序性 | 在GoFrame框架中实现Map校验的顺序性。通过修改规则参数类型为[]string，可以确保返回的错误信息顺序与设定规则一致，解决了golang中map类型无序性导致的校验结果不固定的问题。本教程提供了详细的示例代码和执行结果，帮助用户理解如何使用GoFrame进行顺序校验。 |
| 核心组件/数据校验/数据校验-参数类型/数据校验-Struct校验/Struct校验-Assoc关联 | 在GoFrame框架中，为了避免结构体默认值带来的问题，引入了Assoc方法，可以严格按照给定参数进行结构体校验。此方法特别适用于需要处理客户端请求参数的场景，确保校验规则不受默认值影响。 |
| 核心组件/数据校验/数据校验-参数类型/数据校验-Struct校验/Struct校验-基本使用 | 使用GoFrame框架进行Struct类型数据的校验，包括对校验tag规则的详细说明以及不同类型的数据校验方法，如基本校验、使用map自定义规则、以及结构体的递归校验示例。通过示例代码展示如何设置属性别名和自定义错误提示信息，实现对struct对象中不同属性的复杂校验逻辑。 |
| 核心组件/数据校验/数据校验-参数类型/数据校验-单数据校验 | 在GoFrame框架中如何进行单数据校验。它讨论了通过Data方法指定被校验数据，以及通过Rule方法指定校验规则的使用方法。实例演示了校验数据长度、数据类型和大小、以及正则表达式校验等不同的校验场景，包括如何应用多个自定义错误提示。 |
| 核心组件/数据校验/数据校验-可选校验 | 详细讲解 |
| 核心组件/数据校验/数据校验-常见问题 | 解决使用 |
| 核心组件/数据校验/数据校验-方法介绍 | 全面介绍 |
| 核心组件/数据校验/数据校验-校验对象 | 全面介绍 |
| 核心组件/数据校验/数据校验-校验结果 | 详细介绍 |
| 核心组件/数据校验/数据校验-校验规则 | 全面介绍 |
| 核心组件/数据校验/数据校验-自定义规则/自定义规则-完整数据校验 | 在GoFrame框架中使用自定义规则对结构体进行完整数据校验。通过给结构体添加元数据g.Meta，能够注册和使用自定义校验规则，例如UserCreateReq，实现对创建用户请求的校验。示例代码演示了如何实现和应用自定义校验方法，以确保数据的唯一性和有效性。 |
| 核心组件/数据校验/数据校验-自定义规则/自定义规则-规则注册 | 在GoFrame框架下如何进行自定义规则注册及数据校验。详细讲解了自定义规则的定义方法、参数说明以及全局和局部规则的注册方式。通过示例代码展示了订单ID存在校验和用户唯一性校验两种常见场景的实现，使开发者能够灵活应用自定义校验规则功能。 |
| 核心组件/数据校验/数据校验-自定义错误 | 介绍GoFrame框架数据校验组件如何通过i18n国际化特性自定义错误提示信息。详细讲解如何配置不同语言的错误提示文件，包括默认英文提示和中文提示的配置方法，以及如何在代码中通过上下文切换语言环境实现多语言错误提示。提供了完整的目录结构、配置文件示例和代码实现，帮助开发者快速实现国际化的数据校验错误提示功能。 |
| 核心组件/数据校验/数据校验-递归校验 | 详细介绍GoFrame框架数据校验组件的递归校验（嵌套校验）特性。支持对struct、slice、map等复杂数据类型进行自动递归校验，通过多个实际示例演示如何对嵌套结构体、数组和映射类型数据进行有效验证。特别说明了空对象在递归校验中的处理规则，包括带有默认值的空结构体将被视为已传递对象并执行校验，而空指针对象则不会触发递归校验。 |
| 核心组件/数据校验/数据校验 | 介绍 GoFrame 框架的 gvalid 数据校验组件，提供数十种内置校验规则、多数据多规则批量校验、自定义错误信息、国际化支持、结构体标签绑定等功能。 |
| 核心组件/日志组件/日志组件-Context | GoFrame框架中glog日志组件的使用，特别是如何通过Context上下文变量实现日志打印。文章详细讲解了自定义CtxKeys的配置和使用示例，并提供了链路跟踪支持的功能。此外，还涉及了日志Handler的实现，以帮助开发者更好地集成日志功能。 |
| 核心组件/日志组件/日志组件-Flags特性 | GoFrame框架中日志组件的Flags特性，说明如何通过不同的常量组合来控制日志输出的额外特性，包括异步输出、调用行号信息打印以及多种时间格式的选择。这些特性能够帮助开发者实现更灵活的日志记录和调试。 |
| 核心组件/日志组件/日志组件-Handler | 文章介绍了从v2.0版本开始，GoFrame框架的glog组件新增的可自定义日志处理的Handler特性。开发者可以通过Handler实现日志输出的自定义内容，例如将日志转为Json格式输出或者输出至第三方服务如Graylog。详细示例展示了如何在GoFrame框架中使用Handler进行日志处理。 |
| 核心组件/日志组件/日志组件-JSON格式 | 使用GoFrame框架中的glog组件以JSON格式输出日志，适合日志分析工具解析。您将学习如何通过map或struct参数实现JSON日志格式输出，以及结合gjson.MustEncode方法实现更复杂的JSON内容输出。 |
| 核心组件/日志组件/日志组件-Rotate特性 | GoFrame框架中glog组件的日志滚动切分特性，包括通过设置日志文件名称按照日期输出、通过设置RotateSize和RotateExpire进行日志滚动切分、支持日志文件压缩与备份、配置示例，以及注意事项等内容。提供详细的配置项说明和示例代码，帮助开发者更好地管理日志文件。 |
| 核心组件/日志组件/日志组件-Writer接口 | 在GoFrame框架中使用glog模块的Writer接口来自定义日志输出。通过实现自定义Writer对象，可以灵活地将日志输出到不同的目标如文件、标准输出和Graylog等。此外，还提供了示例代码说明如何实现日志HOOK功能，以便及时将严重错误通知到监控服务。 |
| 核心组件/日志组件/日志组件-堆栈打印 | 介绍 |
| 核心组件/日志组件/日志组件-常见问题 | 解答 |
| 核心组件/日志组件/日志组件-异步输出 | 介绍 |
| 核心组件/日志组件/日志组件-文件目录 | 介绍 |
| 核心组件/日志组件/日志组件-日志级别 | 详细介绍 |
| 核心组件/日志组件/日志组件-调试信息 | 介绍 |
| 核心组件/日志组件/日志组件-配置管理 | 详细介绍 |
| 核心组件/日志组件/日志组件-链式操作 | 详细介绍 |
| 核心组件/日志组件/日志组件-颜色打印 | 详细介绍 |
| 核心组件/日志组件/日志组件 | 介绍 GoFrame 框架的 glog 高性能日志管理模块，支持文件输出、日志级别、链式操作、异步输出、堆栈打印、链路跟踪等特性，提供单例模式与自定义 Handler 支持。 |
| 核心组件/模板引擎/模板引擎-XSS处理 | 在使用GoFrame框架的模板引擎时进行XSS处理。默认情况下，输出变量未进行HTML转码，可能导致XSS漏洞，但GoFrame框架提供了灵活的配置参数，通过AutoEncode或SetAutoEncode方法控制转义效果，以增强输出安全性。 |
| 核心组件/模板引擎/模板引擎-其他使用 | 介绍 |
| 核心组件/模板引擎/模板引擎-模板函数/模板函数-内置函数 | 介绍GoFrame框架中模板使用的内置函数，这些函数可以用于数学计算、HTML和URL转义、字符串处理、日期格式化以及数据格式转换，包括plus、minus、times、divide等函数，提升开发效率。 |
| 核心组件/模板引擎/模板引擎-模板函数/模板函数-基础函数 | Golang标准库中的基础函数及其在GoFrame框架中的改进使用。通过实用示例展示了如何在不同模板函数中进行参数传递，以及如何灵活调用函数。详细解读了and、or、not、call、index等函数的用法，以及GoFrame框架中对eq/ne/lt/le/gt/ge比较函数的自动类型转换优化。 |
| 核心组件/模板引擎/模板引擎-模板函数/模板函数-自定义函数 | 在GoFrame框架中自定义模板函数，开发者可以将这些函数全局绑定到指定的视图对象中。此外，还可以将自定义对象赋值给模板并通过该对象调用其封装的方法。示例代码展示了如何定义和绑定模板函数，以及使用普通方式和管道方式传递参数进行模板解析。 |
| 核心组件/模板引擎/模板引擎-模板变量 | 详细讲解 |
| 核心组件/模板引擎/模板引擎-模板布局 | 全面介绍 |
| 核心组件/模板引擎/模板引擎-模板标签 | 全面讲解 |
| 核心组件/模板引擎/模板引擎-模板配置 | 详细介绍 |
| 核心组件/模板引擎/模板引擎 | GoFrame框架的模板引擎提供了简单、易用、强大的功能，支持多模板目录搜索、layout模板设计以及模板文件自动更新等特性。通过gview模块实现通用视图管理，支持模板对象单例模式及视图对象管理器的使用，方便进行模板目录配置和模板变量、函数渲染。 |
| 核心组件/类型转换/类型转换-Converter | 使用GoFrame框架的gconv.Converter接口实现严谨的类型转换，支持错误处理、自定义转换规则和类型注册。相比传统的gconv包方法，Converter提供更严格的类型检查和错误处理机制，适合对数据准确性要求高的场景。 |
| 核心组件/类型转换/类型转换-Map转换 | 使用GoFrame框架中的gconv.Map方法实现类型转换，包括将任意map或struct/*struct类型转换为map[string]interface{}类型。支持属性标签和自定义标签，并可通过MapDeep方法实现递归转换，解析出嵌套对象的详细结构，适合多层次数据处理。 |
| 核心组件/类型转换/类型转换-Scan转换 | 了解如何使用GoFrame框架中强大的Scan方法实现任意参数到struct、struct数组、map、map数组的自动识别转换。本文介绍Scan方法的定义及其在Go语言中的应用，同时提供多个编程示例帮助快速理解和掌握此功能，为开发者提供高效便捷的类型转换解决方案。 |
| 核心组件/类型转换/类型转换-Structs转换 | GoFrame框架中的类型转换方法，主要聚焦于使用Structs方法实现对struct数组的转换。Structs方法与Struct方法类似，并在其基础上扩展了对struct数组的支持。文中还提供了具体的代码示例，演示了如何在实际应用中使用这一功能。 |
| 核心组件/类型转换/类型转换-Struct转换 | 使用GoFrame的gconv模块进行结构体转换，包括从各种数据类型到结构体的映射、自动创建对象、递归转换以及映射规则等实用功能，帮助开发者提升编码效率和项目维护能力。 |
| 核心组件/类型转换/类型转换-UnmarshalValue | 使用GoFrame框架中的gconv模块实现类型转换，尤其是通过UnmarshalValue接口实现自定义转换。详细探讨了反射特性在复杂类型转换中的应用及其性能影响，并提供了多个代码示例，包括自定义结构体转换和TCP数据解包，帮助开发者优化转换效率。 |
| 核心组件/类型转换/类型转换-基本类型 | 全面介绍 |
| 核心组件/类型转换/类型转换-性能测试 | 展示 |
| 核心组件/类型转换/类型转换-自定义类型转换 | 全面介绍 |
| 核心组件/类型转换/类型转换 | GoFrame框架中的gconv包，该包提供了高效的类型转换功能，支持从常用数据类型到指定类型的转换，并可将任意类型转换为struct对象。gconv广泛使用断言，有效提升程序性能，是开发者实现类型转换的理想选择。 |
| 核心组件/缓存管理/缓存管理-Redis缓存 | GoFrame框架中的缓存管理模块，重点讲解Redis缓存的适配实现及其使用方法，通过示例展示如何在多节点环境下确保数据一致性。文中提供了设置Redis客户端和使用Redis缓存适配器的详细步骤，同时探讨了Clear和Size方法在多对象连接情况下的操作注意事项，并建议针对不同业务配置独立的Redis db。 |
| 核心组件/缓存管理/缓存管理-内存缓存 | 全面介绍 |
| 核心组件/缓存管理/缓存管理-接口设计 | 详细介绍 |
| 核心组件/缓存管理/缓存管理-方法介绍 | 全面介绍 |
| 核心组件/缓存管理/缓存管理 | GoFrame框架中的gcache模块，它提供了统一的缓存管理功能，包括内存缓存适配实现。gcache支持自定义键名的数据类型和存储任意的数据类型，通过泛型对象进行类型转换，避免直接使用类型断言带来的风险。此外，gcache还提供了缓存过期时间设置，灵活适用于各种缓存应用场景。 |
| 核心组件/调试模式 | 介绍 GoFrame 框架调试模式，在该模式下框架组件将输出调试信息到终端。可通过命令行参数、环境变量或 g.SetDebug 方法开启。 |
| 核心组件/资源管理/资源管理-使用示例 | 通过完整示例展示 |
| 核心组件/资源管理/资源管理-工具打包 | 详细介绍如何使用 |
| 核心组件/资源管理/资源管理-方法介绍 | 全面介绍 |
| 核心组件/资源管理/资源管理-方法打包 | 详细讲解如何通过 |
| 核心组件/资源管理/资源管理-最佳实践 | 详细介绍 |
| 核心组件/资源管理/资源管理 | 通过GoFrame框架进行资源管理，将任意文件或目录打包为Golang源码文件，实现高效的内存操作。资源文件支持自定义加解密和压缩，并可作为独立二进制资源文件，使得文件操作更快捷。 |
| 核心组件/配置管理/配置管理-Loader加载器 | GoFrame框架的Loader配置加载器，提供类似Spring Boot @ConfigurationProperties的功能，支持自动配置绑定、配置监听和更新。使用Go泛型实现类型安全的配置管理，支持自定义转换器和回调处理，是管理应用配置的强大工具。 |
| 核心组件/配置管理/配置管理-TOML格式 | TOML格式在GoFrame框架中的使用，包括其与其他文件格式的比较、基础语法、数值与BOOL值处理、日期时间、数组、表格、表格数组等内容，帮助用户更好地理解和应用TOML配置管理。 |
| 核心组件/配置管理/配置管理-YAML格式 | 在GoFrame框架中使用YAML格式进行配置管理。YAML是一种便于人类读写的数据串行化格式，支持对象、数组和纯量等数据结构。文章还提供了YAML与JavaScript之间的转换示例，帮助读者更好地理解YAML格式的应用和实现。 |
| 核心组件/配置管理/配置管理-常用方法 | 介绍 |
| 核心组件/配置管理/配置管理-接口化设计/配置管理-AdapterContent | 使用GoFrame框架中的AdapterContent接口来管理配置。用户可以通过给定具体的配置内容生成相应的Adapter接口对象，支持多种格式。通过示例代码展示了如何使用g.Cfg单例对象进行基于文件的配置管理。 |
| 核心组件/配置管理/配置管理-接口化设计/配置管理-AdapterFile | GoFrame框架中配置管理的实现，主要通过AdapterFile进行基于文件的配置加载和读取。用户可以通过g.Cfg单例对象便捷地使用配置管理，亦可通过gcfg.NewWithAdapter方法创建配置管理对象。示例代码展示了如何在Go语言中实现和运行这些配置操作。 |
| 核心组件/配置管理/配置管理-接口化设计/配置管理-接口化设计 | GoFrame框架中gcfg组件的接口化设计及其高扩展性。通过接口化设计，用户可以自定义配置获取方式，包括使用etcd、zookeeper、consul、kubernetes configmap和apollo等，满足多样化的配置管理需求。详细的接口定义和实现设置指导为您提供配置功能的灵活性。 |
| 核心组件/配置管理/配置管理-文件配置 | 详细介绍 |
| 核心组件/配置管理/配置管理-配置对象 | 介绍 |
| 核心组件/配置管理/配置管理-配置监听回调 | 介绍 |
| 核心组件/配置管理/配置管理 | GoFrame框架的配置管理组件gcfg，该组件支持并发安全操作，提供文件系统接口实现，支持多种配置文件格式如yaml、toml、json等，并允许在配置项缺失时读取环境变量或命令行参数，具有自动检测配置文件热更新、单例管理等特性。 |
| 核心组件/错误处理/错误处理-其他特性 | 在GoFrame框架中进行错误处理的其他特性，涵盖了如何使用NewOption自定义错误对象创建、通过fmt格式化打印完整的堆栈信息，以及日志输出的强大支持。此外，从v2.6.0版本开始，错误组件在打印堆栈信息时提供了不同的打印模式以供选择，满足不同场景下的开发需求。 |
| 核心组件/错误处理/错误处理-国际化支持 | GoFrame框架提供的错误国际化支持功能，通过ITextArgs接口实现错误消息的多语言翻译。详细介绍了如何使用该接口获取错误消息模板和参数，实现错误信息的国际化处理，满足多语言应用场景的需求。 |
| 核心组件/错误处理/错误处理-堆栈特性 | GoFrame框架中的错误处理堆栈特性，通过gerror模块实现对错误的堆栈追溯，增强错误信息的可读性和可维护性。文中详细讲解了如何利用Wrap方法叠加错误信息、检查错误堆栈的HasStack方法、获取堆栈信息的Stack方法以及访问不同层级错误信息的方法。 |
| 核心组件/错误处理/错误处理-常用方法 | GoFrame框架中关于错误处理的常用方法，包括错误创建、错误包装以及错误码相关的函数，提供了创建和包装自定义错误信息的多种方式，以便开发者在使用GoFrame框架时能够有效管理错误和调试代码。 |
| 核心组件/错误处理/错误处理-性能测试 | 涵盖了使用GoFrame框架进行错误处理的基准性能测试，提供了常用方法的性能对比结果。通过这些性能测试，开发者可以更好地理解和优化Go语言编程中的错误处理效率，从而提升整个应用程序的性能表现。数据来源于GitHub上GoFrame的开源项目，详细列举了不同错误处理方法在不同配置下的性能表现，供开发者参考。 |
| 核心组件/错误处理/错误处理-最佳实践 | 在GoFrame框架中有效地处理错误，包括打印错误对象的堆栈信息和正确使用Wrap方式包裹错误对象，避免错误信息的重复。通过具体代码示例，展示应如何优化错误处理，提高GoFrame框架的应用程序稳定性。 |
| 核心组件/错误处理/错误处理-错误比较 | GoFrame框架中错误处理的比较方法，包括Equal和Is方法的使用。Equal方法用于判断两个错误对象是否相同，而Is方法用于判断给定错误是否在指定的错误链路中。并提供了接口定义和使用示例，帮助开发者更好地理解和应用这些方法。 |
| 核心组件/错误处理/错误处理-错误码特性/错误处理-错误码实现 | 在GoFrame框架中自定义实现业务的错误码，通过实现gcode.Code接口，可以定义复杂的错误码；并提供错误处理的代码实例，展示如何使用自定义错误码与中间件结合。 |
| 核心组件/错误处理/错误处理-错误码特性/错误处理-错误码扩展 | 在GoFrame框架中进行错误处理，尤其是错误码的扩展。通过使用错误码的Detail参数，可以根据业务需求自定义错误码。在具体场景中，我们可以通过WithCode方法灵活地创建新的错误码，并在中间件中进行应用和处理。该解决方案不仅增强了业务逻辑的灵活性，还为上层提供了详细的错误信息。 |
| 核心组件/错误处理/错误处理-错误码特性/错误处理-错误码接口 | GoFrame框架中用于错误处理的错误码接口，基本描述了错误码组件gcode的接口化设计和高扩展性。通过实现Code接口，开发者可以自定义错误码。框架提供了默认实现，开发者也可以根据需求自行扩展，实现自己的错误码逻辑。 |
| 核心组件/错误处理/错误处理-错误码特性/错误处理-错误码方法 | 在GoFrame框架中使用NewCode和WrapCode方法进行错误处理，通过这些方法可以创建和包裹带有自定义错误码和堆栈信息的error对象。文档提供了基于GoFrame框架的示例代码，帮助开发者更好地理解错误码在程序中的应用。 |
| 核心组件/错误处理/错误处理 | GoFrame框架提供了强大的错误处理能力，通过gerror组件实现，所有组件在返回错误时带有堆栈信息，方便开发者快速定位问题。使用该框架能有效提升编程效率及程序稳定性。 |
| 框架设计/Golang枚举值管理 | 在Go语言中实现枚举值，虽然Go语言本身不支持enum定义，但是可以通过const来模拟枚举类型。这种方法在Kubernetes项目中广泛使用。此外，本文还探讨了如何在跨服务调用和前后端协作中高效维护枚举值的问题，并提供了使用OpenAPI标准协议与相关工具来实现的方法。 |
| 框架设计/工程开发设计/代码分层设计 | GoFrame框架的代码分层设计，包括MVC设计模式和三层架构设计。MVC设计模式适合需要服务端渲染页面的业务场景，而三层架构设计强调高内聚低耦合的思想，通过将业务逻辑层与数据访问层进行分离，提高项目的维护性和灵活性。 |
| 框架设计/工程开发设计/工程目录设计 | GoFrame框架工程目录设计，基于三层架构模型并结合现代工程实践进行改进，为复杂业务项目提供通用且灵活的目录结构设计。目录组件包含api、internal、dao和service等模块，支持多种业务场景，同时鼓励开发者灵活增减目录，用于业务实现中各类具体应用。 |
| 框架设计/工程开发设计/微服务大仓管理模式 | GoFrame框架对微服务-单仓管理模式的支持，详细描述如何在这种模式下进行代码开发和服务协作。讨论了单仓管理的优缺点，以及如何通过划分仓库职责、管理代码可见性、统一镜像仓库等方法优化微服务协作。同时，提供了相关的框架指令，帮助开发者更高效地管理和部署微服务项目。 |
| 组件列表/功能调试/调试功能-gdebug | GoFrame框架通过gdebug组件提供了丰富的调试功能，适用于开发环境中堆栈和调用链的分析。虽然调试方法与性能效率相关性不强，但可以帮助开发者更好地了解代码执行路径和调用信息。 |
| 组件列表/加密解密/AES算法-gaes | 在GoFrame框架中使用AES算法进行数据加解密。通过引入go包以及调用相关功能函数，用户可以实现安全的数据传输和存储。特别注意在加解密过程中如果数据经过其他编码如base64，则需要准确解码和编码，以确保数据的完整性和安全性。 |
| 组件列表/加密解密/DES算法-gdes | 在GoFrame框架中使用DES算法的方式，展示了如何通过gdes包实现加密操作。通过链接至官方接口文档以便开发者获取更多技术细节。在包中支持两种补位方式，并对三倍长DES算法的密钥使用进行了特殊说明，以确保数据安全性。 |
| 组件列表/加密解密/RSA算法-grsa | 在GoFrame框架中使用RSA算法进行加密解密操作。grsa组件提供完整的RSA加密支持，包括密钥对生成、公钥加密、私钥解密、多种填充模式（PKCS1、OAEP）和密钥格式（PEM、DER、Base64），适用于安全数据传输和数字签名场景。 |
| 组件列表/加密解密/SHA256算法-gsha256 | 在GoFrame框架中使用SHA256算法进行哈希计算。gsha256组件提供完整的SHA256哈希功能，支持字符串、字节数组、文件的哈希计算，以及HMAC-SHA256签名验证，适用于数据完整性校验、密码存储、数字签名等场景。 |
| 组件列表/单元测试/单元测试-gtest | gtest模块在GoFrame框架下的使用，提供简便和轻量级的单元测试方法。gtest基于标准库testing进行功能扩展，增加了多个测试特性，如测试用例隔离和常用断言方法。适用于大部分的单元测试场景，并在需要更复杂测试时，可结合第三方测试框架如testify和goconvey使用。 |
| 组件列表/实用工具/元数据-gmeta | 在GoFrame框架中使用gmeta包来为用户自定义的结构体添加元数据标签，并通过特定的方法在运行时动态获取这些标签内容，包括如何使用Data方法和Get方法获取指定对象的元数据标签信息。 |
| 组件列表/实用工具/唯一数-gui | 使用GoFrame框架的GUID模块生成高性能且简便使用的全局唯一数。GUID生成的字符串由数字及小写英文字符组成，长度固定为32字节。文档详细说明了GUID的生成机制、使用方式及其在各种场景下的优势。 |
| 组件列表/实用工具/工具方法-gutil | gutil组件是GoFrame框架中用于封装常用开发工具方法的模块，提供了一系列便利的函数，支持数据结构的友好输出，如Dump和DumpWithType。开发者可以通过github库引入gutil组件，以提高Go语言项目开发效率。 |
| 组件列表/实用工具/随机数-gran | GoFrame框架中的grand模块，提供了对随机数操作的优化封装，具备高性能和多样性的随机生成方法，包含整数、字符串及概率性计算。通过实用的方法如Intn、Str等，您可以轻松生成各种类型的随机数据，满足不同的开发需求。 |
| 组件列表/数据结构/字典类型-gmap/字典类型-gmap | 在GoFrame框架中使用gmap字典类型的基本方法和注意事项。gmap模块提供了多种并发安全的map数据结构选项，包括HashMap、TreeMap和ListMap。适用于在Go应用程序中任何涉及并发访问和哈希表操作的场景，并详细描述了每种类型的性能和特性。 |
| 组件列表/数据结构/字典类型-gmap/字典类型-基本使用 | GoFrame框架下gmap模块的基本使用方法，包括并发安全特性的开关操作，键值对的设置、查询和删除，以及数据结构的有序遍历、序列化与反序列化等内容。v2.10版本新增泛型Map支持，提供类型安全的映射操作，并支持自定义nil值检查器，并提供了详细的代码示例与执行结果。 |
| 组件列表/数据结构/字典类型-gmap/字典类型-性能测试 | 针对字典类型的性能进行详细测试和分析。通过对GoFrame框架中的gmap与标准库sync.Map的性能比较，揭示在并发安全与非并发安全不同场景下的效率表现。包括不同类型map的性能基准测试，如HashMap、ListMap和TreeMap，提供开发者优化应用程序的实时参考。 |
| 组件列表/数据结构/字典类型-gmap/字典类型-方法介绍 | GoFrame框架中AnyAnyMap的各种方法，包括创建、克隆、迭代、设置、删除和合并等操作。同时，还提供了代码示例以帮助理解这些方法的使用方式确保代码的并发安全性，更详细内容可参考GoFrame框架文档。 |
| 组件列表/数据结构/安全类型-gtype/安全类型-gtype | GoFrame框架中的安全类型gtype，适用于任何需要并发安全的场景。通过提供对最常用基本数据类型的并发安全支持，gtype具备比互斥锁更高的性能，使用atomic原子操作简化并发控制，方便开发者在复杂场景下进行高效的并发编程。 |
| 组件列表/数据结构/安全类型-gtype/安全类型-基本使用 | 在GoFrame框架中使用gtype模块实现并发安全的基本类型操作。通过示例代码展示了如何创建和操作线程安全的基本类型，如整数类型的增减操作，以及gtype容器类型的JSON序列化和反序列化功能，帮助开发者便捷地管理数据。 |
| 组件列表/数据结构/安全类型-gtype/安全类型-性能测试 | 展示了GoFrame框架中gtype包的安全类型性能基准测试结果，通过详细测试数据对比，分析不同数据类型的方法执行效率，为Go语言的开发者提供参考，提高并发编程中的数据处理能力。 |
| 组件列表/数据结构/对象复用-gpool/对象复用-gpool | GoFrame框架中的对象复用池gpool的基本功能和使用场景，包括提供对象缓存复用、过期时间、创建和销毁方法的定义。gpool设计与sync.Pool的区别在于对过期时间的支持和GC压力缓解功能的不同，是并发安全的。 |
| 组件列表/数据结构/对象复用-gpool/对象复用-基本使用 | 在GoFrame框架中使用gpool进行对象复用。在示例中，我们创建和操作了一个对象池，展示了对象的获取、返回及过期处理方法。此方法对于管理短生命周期的资源非常有效，可以显著提高程序性能和资源利用率。 |
| 组件列表/数据结构/并发安全环-gring/并发安全环-gring | GoFrame框架中的并发安全环gring的基本功能和使用场景，包括环形队列、循环双向链表等特性。gring在底层开发中用于并发锁控制、缓冲区控制等场景，支持固定大小的环形结构，当数据超过容量时新值将覆盖旧值。 |
| 组件列表/数据结构/并发安全环-gring/并发安全环-基本使用 | GoFrame框架中gring并发安全环的基本使用示例，包括约瑟夫问题的经典实现和泛型版本的类型安全实现。 |
| 组件列表/数据结构/并发安全环-gring/并发安全环-方法介绍 | GoFrame框架gring并发安全环的常用方法介绍，包括传统方式和泛型方式的完整API说明。 |
| 组件列表/数据结构/数组类型-garray/数组类型-garray | GoFrame框架中的数组类型garray及其基本功能。通过garray模块，用户能够使用并发安全的数组容器，支持普通数组与排序数组，提供对数据项唯一性矫正、int/string/interface{}数据类型的支持及详细的接口文档等功能。v2.10版本新增泛型数组TArray和SortedTArray，提供类型安全的数组操作。 |
| 组件列表/数据结构/数组类型-garray/数组类型-基本使用 | 在 GoFrame 框架中使用数组类型，包括创建并发安全的数组、排序数组、数组遍历与修改以及数组的随机获取和出栈操作。通过示例代码演示了基本的数组操作，提供了数组的排序、过滤及翻转等高级用法。v2.10版本新增泛型数组TArray和SortedTArray，提供类型安全的数组操作，帮助开发者更好地理解和掌握 GoFrame 框架中的数组处理能力。 |
| 组件列表/数据结构/数组类型-garray/数组类型-方法介绍 | 使用GoFrame框架处理数组类型的方法，包括Append、At、Chunk等常用方法。您将学习如何在数组中添加、访问元素，分割数组，清除数据，克隆数组及判定数组状态的方法。每个方法配有具体示例帮助理解和应用。 |
| 组件列表/数据结构/树形类型-gtree/树形类型-gtree | 该文档介绍了GoFrame框架提供的树形容器组件，包括RedBlackTree、AVLTree和BTree等数据结构。树形容器支持并发安全和有序遍历，适合处理大数据量的存储需求。通过GoFrame框架，开发者可以高效地实现关联数组、排序键值对和大数据量内存CRUD等场景。 |
| 组件列表/数据结构/树形类型-gtree/树形类型-基本使用 | 在GoFrame框架中使用树形类型的数据结构进行基本操作。通过示例代码展示了如何创建和操作RedBlackTree和AVL树，包括节点的添加、删除和遍历等功能，使开发者能够轻松实现高效的数据存储和查找。 |
| 组件列表/数据结构/树形类型-gtree/树形类型-方法介绍 | GoFrame框架中树形结构的多种操作方法，包括NewBTree、Clone、Set、Get等，详细的示例展示了如何使用这些方法进行节点的添加、查找、删除等操作，同时支持并发安全的设置，用户可以通过本文档快速掌握树形结构的使用技巧。 |
| 组件列表/数据结构/泛型类型-gvar/泛型类型-gvar | GoFrame框架中的gvar类型，它是一种运行时泛型实现，旨在提高开发便捷性和效率。gvar支持内置数据类型转换，并可作为interface{}的替代类型，其与并发安全特性使其在需要频繁数据转换的场景下表现出色。此外，还介绍了gvar类型的使用方式和相关接口文档。 |
| 组件列表/数据结构/泛型类型-gvar/泛型类型-基本使用 | 在使用GoFrame框架时，利用gvar.Var容器进行泛型类型的基本使用，包括基本类型转换和slice转换。还展示了如何实现JSON格式的数据序列化和反序列化操作，借助GoFrame框架提供的接口，用户能够轻松操作复杂数据结构，实现高效的数据处理。 |
| 组件列表/数据结构/泛型类型-gvar/泛型类型-方法介绍 | GoFrame框架中的常用方法，包括创建新变量、克隆变量、设置变量、获取变量值等操作。通过示例代码讲解每个方法的使用方式，帮助用户更好地理解和应用这些方法。 |
| 组件列表/数据结构/泛型类型-gvar/泛型类型-注意事项 | 使用GoFrame框架中的泛型类型的注意事项。尽管泛型提高了开发便捷性，但在复杂业务项目中可能影响长期维护。建议在基础组件和中间件项目中使用泛型，同时明确业务模型的数据类型以发挥编译型语言的优势。 |
| 组件列表/数据结构/链表类型-glist/链表类型-glist | GoFrame框架中的glist组件，支持并发安全的双向链表。glist提供了链表的数据结构和并发控制，v2.10版本新增泛型链表TList，提供类型安全的链表操作，适用于需要使用双向链表的场景，从而提高Go语言程序的开发效率和运行性能。 |
| 组件列表/数据结构/链表类型-glist/链表类型-基本使用 | 使用GoFrame框架中的glist容器进行链表操作，包括基本使用、链表遍历、元素入栈与出栈、插入与移动操作、串联与移除操作以及JSON序列化反序列化。v2.10版本新增泛型链表TList，提供类型安全的链表操作。示例代码展示了在非并发安全与并发安全场景下的不同操作，帮助理解Go语言中链表的应用。 |
| 组件列表/数据结构/链表类型-glist/链表类型-性能测试 | 在GoFrame框架下，链表(container/glist)的性能测试结果。通过一系列基准测试，包括PushBack、PushFront、Len、PopFront和PopBack，评估了链表操作的效率和性能，以帮助开发者优化代码性能。 |
| 组件列表/数据结构/队列类型-gqueue/队列类型-gqueue | GoFrame框架中的动态大小并发安全队列gqueue，其支持固定和动态大小队列的功能，与标准库的channel效率相当。v2.10版本新增泛型队列TQueue，提供类型安全的队列操作。gqueue特别适合于多goroutine之间的数据通信，并为开发者提供了简便且强大的并发处理能力。 |
| 组件列表/数据结构/队列类型-gqueue/队列类型-基本使用 | 使用GoFrame框架中的gqueue组件进行基本的队列操作，包括元素的入队和出队、队列长度的获取以及队列的关闭。v2.10版本新增泛型队列TQueue，提供类型安全的队列操作。详细演示了通过Push和Pop方法管理队列元素，并展示了队列与glist链表的关系，确保在GoFrame框架下高效构建并发安全的程序逻辑。 |
| 组件列表/数据结构/队列类型-gqueue/队列类型-性能测试 | 在GoFrame框架中gqueue与标准库channel的性能测试。通过基准测试展示了gqueue在动态存储和弹性容量上的优势，相对于channel的固定内存分配和容量限制，gqueue在创建效率和灵活性表现更佳。 |
| 组件列表/数据结构/集合类型-gset/集合类型-gset | GoFrame框架中的集合类型gset，其特点是不重复元素集合，支持任意类型的元素。gset提供了并发安全的选项，是一种高效的集合操作工具，适合在Go语言中应用。v2.10版本新增泛型集合TSet，提供类型安全的集合操作。提供了详细的使用方式及接口文档链接，便于开发者查阅。 |
| 组件列表/数据结构/集合类型-gset/集合类型-基本使用 | 在GoFrame框架中使用集合类型及其基本操作方法，包括集合的创建、添加、删除、遍历等，并探讨了交集、差集、并集、补集等高级操作。v2.10版本新增泛型集合TSet，提供类型安全的集合操作。此外，文章还详细解释了包含判断、集合项出栈、子集判断、判断性写入等功能，并以代码示例展示了如何进行JSON序列化和反序列化处理。 |
| 组件列表/数据结构/集合类型-gset/集合类型-性能测试 | 在GoFrame框架中集合类型的性能测试结果，包含各种数据类型如整数、任意数据类型和字符串的集合操作的基准测试。这些基准测试展示了不同集合操作的性能指标，帮助开发者优化代码性能并在使用GoFrame框架构建高效应用时提高效率。 |
| 组件列表/数据结构/集合类型-gset/集合类型-方法介绍 | 利用GoFrame库实现集合类型的基本操作方法，包括创建集合、新增元素、集合运算、元素检查与删除、集合迭代等多种功能，还提供了具体的代码示例以帮助理解和应用这些方法。 |
| 组件列表/文本处理/字符串处理-gstr | gstr提供了强大便捷的文本处理组件，包含字符串判断、大小写转换、字符串比较、切分组合、命名转换等多种功能，相较于Golang标准库更加全面丰富。 |
| 组件列表/文本处理/正则表达式-gregex/正则表达式-gregex | GoFrame框架中gregex库的基本功能和用法。gregex是对标准库regexp的封装，提供了简化的正则表达式使用方式，并通过解析缓存设计优化了执行效率，使得正则操作更加高效便捷。 |
| 组件列表/文本处理/正则表达式-gregex/正则表达式-基本使用 | 展示了如何在GoFrame框架中使用正则表达式进行基本的文本匹配操作。通过一个简单的示例代码，您可以了解如何提取和处理字符串中的信息，是开发者进行文本处理的重要参考。 |
| 组件列表/文本处理/正则表达式-gregex/正则表达式-方法介绍 | 使用GoFrame框架进行正则表达式匹配，包括了IsMatch、Match、MatchAll等常用方法，并提供了函数定义和示例。GoFrame框架以其高效的执行性能被用于多种正则处理场景，本文档通过具体示例教学，帮助您更好地理解和应用这些功能。 |
| 组件列表/系统相关/上下文-gctx | GoFrame框架中gctx组件的基本概念及常用方法。gctx用于简化链路跟踪及上下文对象的管理，方便进程初始化和上下文操作。主要涉及的内容包括如何创建和获取支持链路跟踪的上下文对象，以及在进程和init包中的应用。结合示例代码和API文档，可更详细地了解gctx的实际应用。 |
| 组件列表/系统相关/互斥锁-gmutex | GoFrame框架中的gmutex互斥锁，该锁支持并发读写控制，与标准库sync.RWMutex类似。其特点是包含Try方法和Func方法，用于非阻塞锁机制和特定作用域锁控制。通过示例代码展示了其便捷的使用方式，以及与标准库锁的基准测试对比，展示了其性能优势。适用于需要高效锁机制的并发编程场景。 |
| 组件列表/系统相关/内存锁-gmlock | 内存锁模块提供了基于GoFrame框架的动态互斥锁功能，支持给定键名动态生成锁，实现并发安全和TryLock特性。通过GoFrame提供的方法，可以方便地在需要动态创建大量互斥锁的场景中应用，如在多goroutine并发处理中有效管理锁，确保资源安全访问。 |
| 组件列表/系统相关/协程管理-grpool | Go语言中轻量级的协程管理工具grpool，讨论其在高并发下的性能优势和资源复用。通过池化技术，对大量goroutine进行管理，以降低内存占用和优化全局调度，适用于异步任务和内存使用率要求高的场景。 |
| 组件列表/系统相关/定时任务-gcron/定时任务-gcron | GoFrame框架中gcron模块的使用，提供类似crontab的定时任务管理功能，支持秒级管理。介绍了如何创建、添加、管理和删除定时任务，并强调了全局时区对定时任务执行的影响，适用于需要编写定时任务的开发者。 |
| 组件列表/系统相关/定时任务-gcron/定时任务-gcron与gtimer | GoFrame框架中定时任务模块gcron与定时器模块gtimer的区别。gtimer是高性能模块，适用于各种定时任务场景，包括TCP通信和游戏开发。gcron支持crontab语法，基于gtimer实现，为用户提供了便捷的定时任务管理方式。 |
| 组件列表/系统相关/定时任务-gcron/定时任务-基本使用 | 在GoFrame框架中使用gcron来管理定时任务。你将学习如何添加、启动、停止、删除和搜索定时任务。此外，还涵盖了单例定时任务、单次定时任务以及运行指定次数的任务等高级功能。这些功能帮助开发者更高效地管理和调试应用内的定时任务，提高应用的性能和可靠性。 |
| 组件列表/系统相关/定时任务-gcron/定时任务-日志管理 | 在GoFrame框架中的gcron组件中进行日志管理。gcron支持设置日志输出文件和级别，默认记录错误级别日志。通过GoFrame框架的日志组件，用户可以复用日志的所有特性。文章中提供了Go代码示例，展示了如何设置和使用gcron的日志功能。 |
| 组件列表/系统相关/定时任务-gcron/定时任务-表达式 | GoFrame框架中定时任务的cron表达式及其使用技巧。cron表达式由六个字段组成，可实现从秒到周的时间调度。讲解了特殊字符的意义及其在表达式中的应用，通过多种预定义格式和间隔配置，使任务调度更加灵活可靠。 |
| 组件列表/系统相关/定时器-gtimer/定时器-gtimer | gtimer是一个并发安全的高性能定时器，适用于大批量定时任务和延迟任务场景，支持超时控制和频率控制。gtimer提供多种任务管理方法，包括添加单例和运行一次的任务，并可自定义定时器参数。 |
| 组件列表/系统相关/定时器-gtimer/定时器-基本使用 | 在GoFrame框架中使用定时器组件，包括基本使用、单例任务、延迟任务以及通过SetTimeout和SetInterval方法进行定时操作。详细讲解了这些定时任务的实现方式和执行结果，并展示了如何使用Exit方法退出定时任务。 |
| 组件列表/系统相关/对象信息-gstructs | gstructs组件是GoFrame框架中用于获取结构体信息的底层工具。主要用于框架、基础库和中间件编写，支持Fields方法获取结构体字段信息以及TagMapName方法通过标签检索字段。适合开发者在构建Go应用时利用此组件进行字段操作和检索。 |
| 组件列表/系统相关/文件监控-gfsnotify/文件监控-gfsnotify | 使用GoFrame框架中gfsnotify模块来实现文件和目录的监控。gfsnotify能够检测文件的增加、删除、修改、重命名等变动操作，并提供方便的接口函数如Add和Remove进行监控和取消监控操作。适用于*nix系统的inotify机制，在使用时会受到系统内核参数的限制。通过实例代码展示如何设置、移除监控及进行文件操作监控。 |
| 组件列表/系统相关/文件监控-gfsnotify/文件监控-添加监控 | 定义与实现文件监控功能，利用GoFrame框架中的gfsnotify库实现对指定目录下文件的创建、写入、删除、重命名和权限修改等事件进行监控。支持递归监控，自动检测目录及子目录中文件的变化，并灵活设置监控选项，实时输出与目录相关的文件事件信息。 |
| 组件列表/系统相关/文件监控-gfsnotify/文件监控-移除监控 | 本文档详细介绍如何在GoFrame框架中使用Remove方法和RemoveCallback方法来移除对文件和目录的监控回调功能，通过示例代码说明了如何添加和移除监控回调，从而提高系统资源的利用效率，确保文件操作监控的灵活性和可控性。 |
| 组件列表/系统相关/文件监控-gfsnotify/文件监控-系统参数 | 在Linux系统下gfsnotify模块通过inotify特性实现文件和目录监控，受限于系统内核参数如fs.inotify.max_user_instances和fs.inotify.max_user_watches，通过命令行可以查看和修改这些参数以适应不同的监控需求。 |
| 组件列表/系统相关/文件管理-gfile | gfile组件为GoFrame框架提供丰富的文件和目录操作功能，包括文件内容读取、缓存机制、文件复制与移动、目录扫描及文件权限设置等。支持灵活的路径操作与内容替换，优化文件管理与处理效率，是开发者进行文件操作的优选库。 |
| 组件列表/系统相关/时间管理-gtime/时间管理-gtime | gtime模块是GoFrame框架的通用时间管理模块，拓展了Golang标准库time的功能，提供了自定义的日期格式化语法，对PHP的date函数格式有良好兼容性，使PHP开发者在Go中实现时间管理时更加便利。 |
| 组件列表/系统相关/时间管理-gtime/时间管理-工具方法 | 使用GoFrame框架进行时间管理工具方法，包括获取当前时间戳、日期和时间设置的方法，如Timestamp、Date和SetTimeZone，以及如何通过StrToTime解析常见时间格式字符串为gtime.Time对象。通过GoFrame框架，开发者可以便利地进行多种时间格式转换和时区设置。 |
| 组件列表/系统相关/时间管理-gtime/时间管理-方法介绍 | GoFrame框架中与时间管理相关的方法，包括如何创建时间对象、格式化时间、设置时区与获取时间戳等多种功能的实现，可以帮助开发者更加方便地进行时间操作与管理。 |
| 组件列表/系统相关/时间管理-gtime/时间管理-时区设置 | 使用GoFrame框架中的gtime组件进行全局时区设置，解释SetTimeZone方法的使用限制及注意事项，并提供代码示例展示程序中如何正确管理和转换时间，尤其是在涉及多个时区的业务场景中。 |
| 组件列表/系统相关/时间管理-gtime/时间管理-时间对象 | 通过GoFrame创建和管理时间对象，包括通过标准库time.Time对象、Unix时间戳、时间字符串等创建gtime.Time对象的方法。同时讲解了如何使用自定义和标准库格式对时间进行格式化，并展示了时间对象的链式操作示例，帮助开发者更高效地处理时间数据。 |
| 组件列表/系统相关/时间管理-gtime/时间管理-时间格式 | GoFrame框架中的时间管理模块，重点讲解gtime.Time对象的时间格式自定义功能。通过对比标准库time.Time的Format方法，gtime提供了Layout方法以实现标准格式日期转换，同时列出了gtime模块支持的各种时间格式语法的细节，帮助开发者高效管理与转换日期时间。 |
| 组件列表/系统相关/环境变量-genv | GoFrame框架中的genv环境变量管理组件，包括如何批量设置环境变量，以及如何通过命令行选项获取环境变量。当某个环境变量不存在时，支持从命令行选项读取。此外，还涵盖了环境变量的添加、删除、及其命名转换规则等内容。 |
| 组件列表/系统相关/进程管理-gproc/进程管理-gproc | 通过GoFrame框架的gproc模块实现进程管理和进程间通信的方法。gproc使用本地socket机制进行通信，提供了多种接口如Shell、ShellExec、ShellRun以不同方式执行Shell命令，可以借助goroutine实现异步执行。在本文档中，您将了解到如何使用Manager对象进行多子进程管理，以及如何获取和控制特定的进程资源。 |
| 组件列表/系统相关/进程管理-gproc/进程管理-信号监听 | 使用GoFrame框架中的gproc组件实现信号监听和处理，从而解决多个组件冗余的信号处理逻辑及程序无法平滑退出的问题。通过统一的信号注册和回调处理，确保各组件能够有效接收到退出信号并进行析构，使信号处理逻辑更加严谨。 |
| 组件列表/系统相关/进程管理-gproc/进程管理-基本使用 | 在GoFrame框架下进行进程管理，包括如何执行Shell命令、判断主进程与子进程的关系，以及多进程管理的基本用法。通过示例代码演示了gproc包的使用，如创建子进程、管理现有进程，并在Linux环境中实现对特定进程的监控和控制。 |
| 组件列表/系统相关/进程管理-gproc/进程管理-进程通信 | GoFrame框架中的gproc组件用于进程通信的机制，包括常见的进程通信方式如信号、管道、共享内存等。重点说明了gproc通过Socket实现稳定和通用的进程通信方式，解析了使用Send和Receive方法进行消息传递的基本使用示例。 |
| 组件列表/系统相关/进程管理-gproc/进程管理-链路跟踪 | 使用GoFrame框架进行进程管理和链路跟踪的方法。通过使用OpenTelemetry规范，支持跨进程的链路跟踪特性，非常适用于临时运行的进程。示例代码展示了如何在主进程中启动子进程并进行链路信息传递，展示了GoFrame框架在进程管理中的强大功能。 |
| 组件列表/编码解码/URL编解码-gurl | 使用GoFrame框架中的gurl包进行URL编解码操作，包括如何构建URL参数、对URL参数进行编码和解码，以及如何解析URL以获取其不同组件。这些功能对于在Go语言中进行网络编程和数据传输时非常有用，适合有类似需求的开发者参考。 |
| 组件列表/编码解码/二进制编解码-gbinary | GoFrame框架中的gbinary包提供了用于二进制数据与各种数据类型之间转换的编解码功能，广泛应用于网络通信和数据文件操作。支持对整型数据进行按位精准处理，并提供了一系列编码和解码接口，以确保数据在不同类型和平台间的高效转换。 |
| 组件列表/编码解码/字符集转换-gcharset | GoFrame框架中的字符编码转换模块gcharset，支持如GBK、UTF-8等常见字符集的转换，为开发者提供了灵活的字符集兼容性。通过导入相关包，开发者可以实现不同字符集之间的转换，从而满足多语言、多地区用户的需求，提升应用程序的国际化与本地化能力。 |
| 组件列表/编码解码/经典哈希函数-ghash | 经典哈希函数在Go语言中的实现，并提供了用于uint32及uint64类型的哈希函数的使用方式。通过GoFrame框架，用户可以更高效地实现哈希功能，文档中包括了详细的接口文档和基准测试结果，帮助用户优化和理解编码性能。同时，通过简单的重复性测试，展示了不同哈希函数的特性和表现。 |
| 组件列表/编码解码/通用编解码-gjson/通用编解码-FAQ | 在使用GoFrame框架处理JSON数据时可能遇到的大数字精度丢失问题，并提供了具体的解决方案示例代码。通过调整gjson选项，可以避免精度丢失，确保数据的准确性。同时，文中还提供了相关链接供进一步参考。 |
| 组件列表/编码解码/通用编解码-gjson/通用编解码-Struct转换 | 使用GoFrame框架中的Struct方法将JSON数据转换为指定的数据格式或对象。示例展示了如何解析JSON数据并使用gjson库将其扫描为自定义用户结构体。这种数据格式转换在处理复杂数据结构时非常有用，特别是在Go语言编程中。 |
| 组件列表/编码解码/通用编解码-gjson/通用编解码-gjson | GoFrame框架中的gjson模块，它提供了强大的数据编码和解析功能，支持多种数据格式的相互转换，包括JSON、XML、INI、YAML、TOML等。gjson模块特别适合需要进行数据层级检索和动态创建或修改数据对象的场景，同时它还支持运行时的数据修改功能，是构建网站时的理想选择。 |
| 组件列表/编码解码/通用编解码-gjson/通用编解码-动态创建修改 | 使用GoFrame框架中的gjson进行数据的动态创建和修改。gjson不仅可以灵活地解析和检索未知的数据结构，还能够动态地创建和编辑数据内容。通过具体示例，展示了设置数据、创建数组和修改JSON内容的方法，使数据结构的编码和解析更加灵活方便。 |
| 组件列表/编码解码/通用编解码-gjson/通用编解码-对象创建 | 使用GoFrame框架的gjson模块创建Json对象。支持多种数据格式如JSON、XML等，并提供了New和Load*方法供使用者调用。详细展示了通过JSON、XML和结构体对象创建Json对象的方法，并提供了示例代码帮助开发者理解和应用。 |
| 组件列表/编码解码/通用编解码-gjson/通用编解码-层级访问 | 在GoFrame框架中使用gjson进行层级访问，通过灵活的层级分隔符访问未知数据结构。包括设置自定义分隔符号，以及处理键名本身带有层级符号的情况。此外，讨论了涉及Go语言中的引用类型变量修改及其对底层数据的影响。 |
| 组件列表/编码解码/通用编解码-gjson/通用编解码-数据格式转换 | 使用GoFrame框架进行数据格式转换，包括JSON、XML、YAML、TOML等多种格式的相互转换，并提供一个示例代码。使用gjson库，可以利用Must*方法确保数据格式的安全转换。 |
| 组件列表/编码解码/通用编解码-gjson/通用编解码-方法介绍 | 使用GoFrame框架进行通用编解码的多种方法，包括Json对象的创建、数据访问和格式转换等。提供了包括New、Load、Encode、Decode等方法的详细说明和示例代码，有助于理解如何在GoFrame中高效处理各种数据格式。 |
| 组件列表/网络组件/TCP组件/TCP组件-TLS加密 | 使用GoFrame框架的gtcp模块在安全性要求较高的环境中实现TLS加密通信。通过提供的示例代码，我们讲解了如何创建TLS服务端和客户端，如何使用证书进行数据加密传输，以及如何处理可能出现的证书过期问题。这对于需要安全传输数据的开发者来说至关重要。 |
| 组件列表/网络组件/TCP组件/TCP组件-工具方法 | GoFrame框架中的gtcp模块和一些常用的工具方法，通过这些方法可以实现TCP连接的创建、TLS安全加密通信以及数据发送和接收的功能，并提供了一个具体示例展示如何通过TCP访问指定的Web站点。 |
| 组件列表/网络组件/TCP组件/TCP组件-连接对象/TCP组件-连接对象 | 此页面介绍了GoFrame框架中的gtcp模块及其提供的TCP连接对象的使用方法。包括如何使用gtcp.Conn进行可靠的TCP通信，处理数据的发送和接收。文中还描述了超时处理机制以及通过简单示例演示如何使用这些功能，展示如何在GoFrame环境下灵活进行网络编程。 |
| 组件列表/网络组件/TCP组件/TCP组件-连接对象/连接对象-消息包处理 | 使用gtcp模块及其封包解包处理功能解决TCP消息协议的粘包问题。通过使用GoFrame框架的简单轻量级数据交互协议，开发者可以更轻松地进行消息包交互，无需关注复杂的封包解包细节。此外，文档还提供了多个使用示例，以帮助开发者更好理解和实现自定义数据结构的消息传递。 |
| 组件列表/网络组件/TCP组件/TCP组件-连接对象/连接对象-通信开发进阶 | 在GoFrame框架下使用gtcp实现异步全双工通信的高级开发。通过完整示例展示了如何在程序中处理长连接，利用SendPkg和RecvPkg方法进行数据传输，并确保并发安全。 |
| 组件列表/网络组件/TCP组件/TCP组件-连接池特性 | GoFrame框架中的gtcp模块连接池特性，通过gtcp.PoolConn实现的连接池具有600秒的固定存活时间，并具备数据发送时的断开重连机制，适用于频繁短链接操作和高连接并发的场景。文章提供了两个示例，演示了连接池的基础使用及断开重连操作，帮助用户深刻理解连接池在网络编程中的实际应用。 |
| 组件列表/网络组件/TCP组件/TCP组件 | GoFrame框架中的gtcp模块，该模块实现了简便易用、轻量级的TCPServer服务端。通过使用gtcp，用户可以轻松创建和管理TCP服务，并支持高并发连接。文档中提供了简单的代码示例，以演示如何使用gtcp模块创建一个基本的echo服务器。 |
| 组件列表/网络组件/UDP组件/UDP组件-工具方法 | 使用GoFrame框架中的gudp模块进行UDP通信的常用工具方法，包括如何通过NewNetConn创建UDP连接，使用Send和SendRecv方法进行数据传输，以及使用*Pkg方法简化数据包协议传输。 |
| 组件列表/网络组件/UDP组件/UDP组件-连接对象 | 使用GoFrame框架进行UDP组件开发，特别是gudp.Conn连接对象的使用。文中提供了详细的函数接口说明以及一个完整的客户端与服务端通信的示例代码，帮助开发者快速掌握UDP连接对象的具体操作和应用场景。 |
| 组件列表/网络组件/UDP组件/UDP组件 | GoFrame框架中的UDP组件，使用gudp.Server和gudp.Conn实现UDP协议的简单不可靠信息传送服务。通过示例代码展示如何创建和运行UDP服务器，并提供了相关接口文档链接供参考。 |
| 项目部署/代理部署 | 介绍使用Nginx作为反向代理的前端接入层来部署GoFrame框架应用的代理部署方案。通过配置静态文件后缀（gif、jpg、png、js、css等）或目录（public等），有效分离静态和动态请求，提高性能。配置示例展示WebServer请求转发至Golang应用，实现专业性的部署方案，适用于需要多域名配置、负载均衡等复杂场景。 |
| 项目部署/容器部署 | 介绍GoFrame应用的Docker化容器部署方式，包括交叉编译Golang程序（CGO_ENABLED=0 GOOS=linux GOARCH=amd64）、基于alpine镜像构建Docker镜像（约20MB）、镜像运行与分发（Docker Hub、阿里云ACR）以及容器编排（Kubernetes、Docker Swarm）。这是云服务时代最流行且最推荐的部署方式，适用于企业级生产环境。 |
| 项目部署/独立部署 | 介绍如何独立部署使用GoFrame框架开发的应用程序，适用于*nix系列服务器（Linux、MacOS、*BSD）和Windows系统。详细讲解在Ubuntu等Linux系统上使用nohup、tmux、supervisor、systemctl、screen等工具设置后台守护进程和进程管理的方法，以及在Windows系统上使用NSSM工具的相关配置。这种独立部署模式常用于简单的API服务项目，通过各种工具实现应用程序的后台运行、自动重启和状态监控。 |
| 快速开始/Hello Worl | 使用GoFrame框架构建一个简单的Hello World Web Server。GoFrame是一款模块化的Go语言框架，提供方便的Web服务器构建方式。本文详细解析了代码示例，包括Server对象的创建、路由绑定、端口设置及运行结果的解读，为初学者提供了一条快速入门的路径。 |
| 快速开始/What's Next | 快速了解Web Server接口的开发流程和特性，通过查看开发手册章节解决疑惑。GoFrame是低耦合、模块化设计的框架，各模块设计独立，文档独立编写。社区提供入门视频教程，后续将使用GoFrame框架项目脚手架开发完整业务项目。 |
| 快速开始/下载与使用 | GoFrame框架的快速开始指南。GoFrame是一款模块化、低耦合设计的开发框架，包含常用基础组件和开发工具，适用于完整业务项目和独立组件库。内容涵盖GoFrame的下载与安装、运行基本操作，并介绍如何开发简易Web Server接口应用。 |
| 快速开始/中间件初试用 | 在GoFrame框架中使用中间件来拦截请求和返回结果，通过前置和后置中间件实现自定义的处理逻辑。示例代码展示了如何定义错误处理中间件，并在路由中绑定。中间件使得请求错误处理和输出格式统一化变得灵活且强大。 |
| 快速开始/使用规范路由 | 在GoFrame框架中使用规范路由，以简化路由注册，聚焦业务逻辑。通过定义请求和响应的数据结构，标准化路由注册，并使用对象化的方式管理路由，提升代码的可维护性。提供了完整的示例代码和执行结果指导读者在实际项目中应用。 |
| 快速开始/生成接口文档 | 使用GoFrame框架，可以轻松生成标准化的接口文档。本文介绍了如何通过完善接口定义，结合OpenAPIv3协议和Swagger UI，自动生成和展示接口文档。在代码示例中详细讲解了接口的数据结构定义、路由中间件的设置以及如何使用GoFrame框架特性优化接口文档生成过程。 |
| 快速开始/统一返回结构 | 使用GoFrame框架统一接口返回结构，以JSON格式返回数据，定义接口数据结构和路由函数，使用中间件处理执行结果，并提供完整的示例代码。通过这些方法，可以在业务项目中实现统一的数据格式封装，简化接口文档的生成和维护过程。 |
| 快速开始/获取请求参数 | 使用GoFrame框架在Web Server中获取客户端提交的请求参数，重点讲解通过r.Get方法处理Query String、Form和Body等HTTP方法提交的参数。学习内容包括参数默认值处理及参数类型自动识别。通过示例代码详细展示如何在GoFrame中接收和处理参数，并对常见问题进行分析，为后续章节对参数对象的结构化处理奠定基础。 |
| 快速开始/请求数据结构 | 通过数据结构化解决参数名称硬编码问题，介绍了如何定义请求对象以接收客户端参数，通过GoFrame框架实现参数映射与校验，提高代码可维护性。同时，示例程序展示了避免冗余校验逻辑的方法，探讨了更简洁的解决方案。 |
| 项目脚手架/基本介绍 | 使用GoFrame框架的脚手架来构建一个简单且完整的业务项目。内容涵盖框架工具的安装与验证、创建工程项目模板、项目模板的运行以及如何升级框架版本等重要步骤。项目模板默认支持HTTP Web Server，并提供接口文档展示与Swagger页面查看功能。 |
| 项目脚手架/接口开发/Step1 - 设计数据表 | 设计和应用MySQL数据表。我们通过定义用户信息的数据表结构并结合Docker运行MySQL进行数据表的实践操作，包括创建表结构和应用SQL语句，帮助您快速掌握数据库操作技能。 |
| 项目脚手架/接口开发/Step2 - 生成dao_do_entity | 使用GoFrame框架中的脚手架工具进行数据访问对象的自动生成，确保CLI工具配置正确，然后通过命令执行代码生成，创建数据库表后生成相应的dao、do和entity文件，以简化数据表的CRUD操作。展示了具体的文件结构和使用方式，以及不同类型文件的生成原理。 |
| 项目脚手架/接口开发/Step3 - 编写api接口定义 | 在项目的api目录下定义CRUD接口，采用RESTful风格的接口设计，使用HTTP Method来规范接口请求。接口定义中使用g.Meta管理元数据信息，包括路由地址、请求方式和接口描述。请求参数和返回数据结构体定义了详细的参数校验规则。接口版本控制上开始使用v1版本，以便维护未来的兼容性。接口参数采用灵活接收方式，满足接口请求的多样化需求。 |
| 项目脚手架/接口开发/Step4 - 生成controller代码 | 根据API定义生成控制器代码，包括API接口文件、路由对象管理及路由实现代码等内容，利用GoFrame框架的命令工具快速生成相关代码模板，确保接口的完整实现，并展示如何通过一个个文件实现具体业务逻辑。 |
| 项目脚手架/接口开发/Step5 - 完成接口逻辑实现 | 使用GoFrame框架完成接口逻辑实现。通过项目脚手架，预先生成了与项目业务逻辑无关的代码，集中在业务逻辑实现。介绍了CRUD操作的具体实现过程，包括创建、更新、删除和查询接口的实现方法。详细阐述了数据操作过程中对参数的校验、表单数据的插入与更新、数据的智能映射和校验机制，以及如何高效地利用GoFrame框架的功能进行开发。 |
| 项目脚手架/接口开发/Step6 - 配置与路由 | 引入mysql数据库驱动、添加数据库配置和路由注册步骤。详细说明了脚手架项目模板中的配置，包括工具配置和业务配置，以及如何进行配置文件的修改。 |
| 项目脚手架/接口开发/Step7 - 启动与测试 | 通过命令行启动服务，并使用swagger生成接口文档。支持创建用户、查询用户信息、修改用户数据以及删除用户的RESTful API接口。同时支持使用curl命令进行接口测试，提供详细的校验规则和错误码以确保数据的准确性和可靠性。 |
| 项目脚手架/项目启动 | 当您开始第一个项目时，可能对工程目录感到困惑，但通过本章节，您可以了解项目的启动过程及其涉及的目录。主要程序入口为main.go，通过调用internal/cmd包引导程序启动。默认创建的HTTP Server支持多种路由注册，使项目启动简单快捷。具体使用细节可参阅GoFrame框架的相关文档。 |
Quickly understand the development process and features of Web Server interfaces, and resolve doubts by referring to the development manual chapters. GoFrame is a low-coupling, modularly designed framework, with each module designed independently and documents written independently. The community provides introductory video tutorials, and we will use the GoFrame framework project scaffolding to develop complete business projects later.
Go示例代码
Download and Use
| 示例代码 | 示例介绍 |
|---|---|
| balancer/http | 演示如何使用GoFrame框架结合etcd实现HTTP服务的负载均衡功能。本示例展示了基于客户端的负载均衡实现，采用轮询策略进行请求分发，支持自动服务发现和动态路由。主要功能包括：使用etcd进行服务注册与发现、客户端轮询负载均衡策略、多服务实例请求分发、与GoFrame的HTTP服务器和客户端组件无缝集成，适用于构建高可用、可扩展的微服务架构系统。通过本示例可以学习如何在分布式环境中实现服务负载均衡和服务发现机制。 |
| balancer/polaris | 演示如何使用GoFrame框架集成Polaris服务网格平台实现HTTP服务的负载均衡功能。本示例展示了基于Polaris的服务注册与发现机制、客户端轮询负载均衡策略、本地缓存配置优化性能、以及集中式日志管理。主要功能包括:使用Polaris作为服务注册中心、可配置的TTL(存活时间)心跳机制、自动服务发现、动态请求路由、与GoFrame的HTTP服务器和客户端组件无缝集成,适用于构建云原生微服务架构并提供高级流量管理能力。通过本示例可以学习如何在分布式环境中使用Polaris实现服务治理、负载均衡和故障转移等企业级特性。 |
| config/apollo | 演示如何在GoFrame应用程序中无缝集成Apollo配置中心实现集中式配置管理。本示例展示了Apollo客户端的初始化与配置、配置适配器的实现方法、动态配置加载与解析、实时配置更新机制、完善的错误处理和日志记录、以及配置值的获取方式。主要功能包括:通过Apollo实现集中式配置管理、支持多环境和命名空间、自动配置刷新能力、使用GoFrame配置组件进行类型安全的配置访问、生产级错误处理机制。适用于构建需要集中配置管理、无需重启即可动态更新配置、支持配置版本管理和回滚的微服务应用。通过本示例可以学习配置中心在分布式系统中的最佳实践。 |
| config/consul | 演示如何在GoFrame应用程序中全面集成HashiCorp Consul配置中心实现分布式配置管理。本示例展示了Consul客户端的设置与初始化、GoFrame配置组件的适配器实现、动态配置加载与解析、实时配置监听与更新、完善的错误处理和日志记录、以及安全的配置值获取。主要功能包括:通过Consul KV存储实现分布式配置管理、支持多数据中心和命名空间、自动配置同步、健康检查与服务发现集成、类型安全的配置访问、生产级错误处理机制。非常适合构建需要分布式配置管理、服务网格集成、多实例间配置一致性的云原生微服务应用。通过本示例可以学习如何使用Consul实现企业级分布式配置管理和服务治理。 |
| config/kubecm | 演示如何在GoFrame应用程序中全面集成Kubernetes ConfigMap实现云原生配置管理。本示例展示了Pod内部和外部两种配置场景、Kubernetes客户端的初始化与认证、ConfigMap的访问与动态加载、实时配置监听与更新、命名空间和资源管理、完善的错误处理和日志记录、以及安全的配置值获取。主要功能包括:原生Kubernetes ConfigMap集成、支持多种部署场景(集群内和集群外)、ConfigMap变更时自动刷新配置、与GoFrame配置组件无缝集成、符合RBAC规范的访问模式、生产级错误处理机制。非常适合构建部署在Kubernetes上的云原生应用,特别是需要原生配置管理、GitOps工作流、配置即代码实践的场景。通过本示例可以学习如何在Kubernetes环境中实现声明式配置管理和云原生最佳实践。 |
| config/nacos | 演示如何在GoFrame应用程序中无缝集成阿里巴巴Nacos配置中心实现动态配置管理。本示例展示了Nacos客户端的初始化与配置、GoFrame配置组件适配器的实现、动态配置加载与热更新、实时配置监听与变更通知、命名空间和分组管理、完善的错误处理和日志记录、以及安全的配置值获取。主要功能包括:通过Nacos实现集中式配置管理、支持多环境和命名空间隔离、无需重启服务即可自动刷新配置、配置版本管理与回滚能力、类型安全的配置访问、生产级监控能力。非常适合构建阿里云或本地部署的云原生微服务应用,特别是需要动态配置、服务发现、分布式系统间配置共享的场景。通过本示例可以深入学习Nacos在配置管理和服务治理方面的企业级应用实践。 |
| config/polaris | 演示如何在GoFrame应用程序中无缝集成腾讯云Polaris配置中心实现服务网格配置管理。本示例展示了Polaris客户端的设置与初始化、GoFrame配置组件适配器的实现、动态配置加载与热更新、实时配置监听与同步、命名空间和文件分组管理、完善的错误处理和日志记录、以及安全的配置值获取。主要功能包括:通过Polaris实现集中式配置管理、支持多命名空间和配置分组、自动配置刷新能力、与Polaris服务网格集成实现统一服务治理、类型安全的配置访问、生产级监控能力。非常适合构建基于腾讯云或使用Polaris网格的云原生微服务应用,特别是需要动态配置、服务发现、流量管理、统一配置治理的场景。通过本示例可以深入学习Polaris在配置管理和服务网格方面的企业级应用实践。 |
| database/encoded-pass | 演示如何在GoFrame中实现自定义数据库驱动以处理加密的数据库密码，提升应用程序安全性。本示例展示了如何创建带有AES加密和Base64编码的自定义MySQL驱动、连接建立时的自动密码解密机制、配置文件中的安全凭据存储、透明的数据库连接处理、以及与GoFrame数据库组件的无缝集成。主要功能包括:加密密码存储、自定义驱动注册、自动解密中间件、生产级安全模式、对现有数据库操作零影响。非常适合需要增强数据库安全性、符合安全策略合规要求、保护版本控制中的敏感凭据、无需代码更改即可实现安全配置管理的应用程序。通过本示例可以学习如何在不影响开发效率的前提下提升数据库连接的安全性，以及如何实现自定义数据库驱动扩展GoFrame的能力。 |
| grpc/balancer | 演示在GoFrame中实现全面的gRPC负载均衡以构建弹性分布式系统。本示例展示了如何使用多种策略配置gRPC负载均衡器、实现客户端负载均衡以获得最佳性能、与etcd等服务发现机制集成、处理自动故障转移和服务健康检查、在多个服务器实例间分发请求、以及管理连接池。主要功能包括:多种负载均衡算法(轮询、加权、最少连接)、自动服务实例发现、基于健康状态的路由、连接状态管理、重试策略、生产级错误处理。非常适合构建高可用微服务、实现容错分布式系统、水平扩展gRPC服务、确保跨服务实例的最佳资源利用。通过本示例可以学习如何在分布式环境中实现gRPC负载均衡、服务发现与负载均衡的协同工作、以及构建高可用高性能微服务架构的最佳实践。 |
| grpc/basic | 演示GoFrame应用程序中gRPC的基础实现，涵盖协议缓冲区定义、服务创建和客户端-服务器通信。本示例展示了如何使用GoFrame创建gRPC服务器和客户端、定义和编译用于服务契约的协议缓冲区、实现带有业务逻辑的服务处理器、进行同步和异步RPC调用、处理错误和状态码、以及与GoFrame的配置和日志系统集成。主要功能包括:完整的服务器和客户端设置、协议缓冲区集成、服务接口实现、请求-响应模式、错误处理最佳实践、生产级代码结构。非常适合gRPC新手开发者、使用GoFrame构建微服务、学习协议缓冲区使用、实现服务间通信模式的场景。通过本示例可以学习gRPC在GoFrame中的基础用法、微服务通信的最佳实践、以及如何构建高效的RPC服务。 |
| grpc/ctx | 演示在GoFrame的gRPC服务中进行高级上下文和元数据管理，用于请求跟踪和数据传播。本示例展示了如何通过gRPC上下文传递元数据以处理横切关注点、处理上下文值和截止时间以实现请求取消、跨服务边界管理请求上下文、处理和提取上下文元数据、实现分布式追踪集成、以及传播认证令牌和关联ID。主要功能包括:元数据注入和提取、上下文超时和取消处理、自定义元数据键和值、基于拦截器的元数据处理、分布式追踪支持、请求关联模式。非常适合在微服务中实现可观测性、跨分布式系统追踪请求、实现认证和授权、管理请求超时和取消、构建具有适当上下文管理的生产级gRPC服务。通过本示例可以学习gRPC上下文的高级用法、如何在分布式系统中传播请求信息、以及实现微服务间通信的最佳实践和可观测性模式。 |
| grpc/rawgrpc | 演示在GoFrame中不使用框架抽象层直接实现原生gRPC，提供最大的控制力和灵活性。本示例展示了如何直接使用原生gRPC库创建gRPC服务器和客户端、不使用额外封装直接使用协议缓冲区、通过直接gRPC API访问实现服务处理器、进行具有完全控制权的低级RPC调用、处理流式RPC和高级模式、以及有选择地集成GoFrame组件。主要功能包括:直接创建gRPC服务器和客户端、无抽象的协议缓冲区使用、手动连接管理、自定义拦截器和中间件、流式支持(单向、客户端流、服务器流、双向流)、生产级错误处理。非常适合需要细粒度控制的高级用户、实现自定义gRPC模式、优化性能关键应用、以及集成第三方gRPC库。通过本示例可以学习如何在GoFrame中使用原生gRPC、深入理解gRPC工作原理、以及实现高度定制化的RPC通信方案。 |
| grpc/resolver | 演示在GoFrame中实现gRPC服务解析器并集成etcd以实现动态服务发现和解析。本示例展示了如何使用etcd作为服务注册中心配置服务解析器、通过自动心跳向etcd注册gRPC服务、使用解析器API动态发现和解析服务、自动处理服务实例的更新和移除、实现客户端服务发现、以及管理服务健康监控。主要功能包括:基于etcd的服务注册中心、自动服务注册和注销、动态服务解析、健康检查集成、服务变更时的自动故障转移、生产级连接管理。非常适合构建具有动态服务发现的云原生微服务、实现服务网格模式、无需客户端重新配置即可扩展服务、通过自动服务解析确保高可用性。通过本示例可以学习如何在gRPC中实现服务发现和解析、etcd在微服务架构中的应用、以及构建动态可扩展的分布式系统的最佳实践。 |
| httpserver/basic-auth | 演示在GoFrame中实现HTTP基础认证，用于简单的凭据基础访问控制。本示例展示了基础认证中间件的设置和配置、针对配置凭据的用户名和密码验证、Base64凭据编码和解码、用于浏览器提示的WWW-Authenticate头处理、受保护路由实现、自定义认证失败响应、以及与GoFrame中间件系统的集成。主要功能包括:无需外部依赖的简单认证、浏览器兼容的认证对话框、凭据验证模式、安全凭据存储建议、自定义领域配置、生产级错误处理。非常适合内部工具和管理面板、简单API保护、开发和测试环境、遗留系统集成、以及需要轻量级认证且无需复杂基础设施的应用程序。通过本示例可以学习HTTP基础认证的实现方法、如何在GoFrame中实现简单认证保护、以及基础认证的适用场景和注意事项。 |
| httpserver/jwt | 演示在GoFrame HTTP服务器中实现全面的JWT(JSON Web Token)认证，用于安全的API访问控制。本示例展示了带有自定义声明和过期时间的JWT令牌生成、令牌验证和校验中间件、使用HS256/RS256算法进行安全令牌签名、用于延长会话的刷新令牌机制、带有认证中间件的受保护路由实现、对无效或过期令牌的错误处理、以及与GoFrame中间件系统的集成。主要功能包括:用户登录和令牌颁发、无状态认证、令牌刷新模式、基于角色的访问控制(RBAC)集成、安全令牌存储建议、生产级安全实践。非常适合构建带有认证的REST API、实现微服务安全、需要无状态认证的移动应用后端、以及需要可扩展认证且无需服务器端会话的应用程序。通过本示例可以学习JWT认证的最佳实践、如何实现安全的无状态认证、以及构建安全可扩展的Web服务。 |
| httpserver/mcp-http | 演示使用GoFrame和HTTP流式传输实现模型上下文协议(MCP)服务器用于AI模型集成。本示例展示了使用HTTP传输的MCP服务器设置、实时模型输出的流式响应处理、协议消息编码和解码、上下文管理和传播、与AI模型和服务集成、以及MCP操作的错误处理。主要功能包括:基于HTTP的MCP传输、流式API支持、高效消息序列化、请求间上下文共享、可扩展协议处理器、生产级模式。非常适合构建AI代理后端、集成语言模型与应用、实现流式AI响应、以及创建符合MCP协议的模型上下文共享服务。通过本示例可以学习MCP协议的实现、AI模型集成最佳实践、以及构建智能AI应用。 |
| httpserver/mcp-sse | 演示使用GoFrame和服务器发送事件(SSE)实现模型上下文协议(MCP)服务器用于实时AI模型通信。本示例展示了使用SSE传输的MCP服务器设置实现服务器到客户端流式传输、模型输出的实时事件流、持久连接以实现连续通信、事件格式化和客户端重连处理、与AI模型和代理集成、以及高效资源管理。主要功能包括:基于SSE的MCP传输、从服务器到客户端的单向流式传输、自动重连支持、事件驱动架构、相比WebSocket更轻量级、生产级模式。非常适合构建实时AI代理界面、实现无需WebSocket复杂性的流式模型响应、创建聊天和助手应用、以及实现模型更新的服务器推送通知。通过本示例可以学习SSE在AI应用中的使用、MCP协议实现、以及构建实时智能应用。 |
| httpserver/proxy | 演示使用GoFrame实现反向代理服务器以进行请求转发和负载分发。本示例展示了带有目标后端服务器的反向代理设置和配置、带有头保留的HTTP请求和响应转发、自定义头操作和转换、连接池和keepalive管理、错误处理和故障转移逻辑、以及与GoFrame中间件系统集成。主要功能包括:灵活的代理配置、透明请求转发、响应流支持、自定义路由规则、负载均衡集成、生产级模式。适合构建API网关和服务代理、实现微服务路由、添加认证和限流层、实现A/B测试和金丝雀部署、以及创建开发代理服务器。 |
| httpserver/rate-limit | 演示在GoFrame HTTP服务器中实现限流功能用于API保护和流量控制。本示例展示了带有可配置限制的限流中间件配置、令牌桶和滑动窗口算法、按IP和按用户的限流策略、自定义限流响应和头(X-RateLimit-*)、用于可扩展性的基于Redis的分布式限流、以及与GoFrame中间件链集成。主要功能包括:灵活的限流策略、分布式限流支持、每个端点的自定义限制规则、优雅的限流响应、监控和指标集成、生产级模式。非常适合保护API免受滥用和DDoS攻击、实现公平使用策略、确保负载下的服务稳定性、管理API配额和计费、以及启用多层服务级别。通过本示例可以学习限流算法、如何实现高效的流量控制、以及构建安全可靠的API服务。 |
| httpserver/response-json-array | 演示在GoFrame HTTP服务器中处理JSON数组响应用于RESTful API开发。本示例展示了返回JSON数组作为HTTP响应、适当的content-type头配置、带有自定义格式的数组序列化、大型数据集的分页支持、大型数组的高效内存管理、以及与GoFrame响应写入系统集成。主要功能包括:自动JSON序列化、适当的HTTP状态码、空数组处理、大型数据集的流式支持、错误响应格式化、RESTful API模式。非常适合构廻返回集合的REST API、实现列表和搜索端点、处理批量数据响应、确保一致的API响应格式、以及优化JSON序列化性能。通过本示例可以学习JSON数组响应的最佳实践、RESTful API设计、以及高效数据序列化。 |
| httpserver/sse | 演示使用GoFrame实现服务器发送事件(SSE)用于实时服务器到客户端流式传输。本示例展示了带有持久连接的SSE服务器设置、带有数据、事件类型和ID的事件流格式化、带有Last-Event-ID的自动客户端重连处理、发送实时更新和通知、适当的content-type和头配置、以及连接生命周期管理。主要功能包括:从服务器到客户端的单向流式传输、自动重连支持、事件驱动架构、相比WebSocket更轻量级、心跳和keepalive支持、生产级模式。非常适合构建实时通知和更新、实现实时仪表盘和监控、创建聊天和消息功能、无需WebSocket实现服务器推送、以及构建事件驱动应用。通过本示例可以学习SSE的实现原理、与WebSocket的区别、以及构建实时通信应用。 |
| httpserver/swagger-auth | 演示使用GoFrame实现带有基础认证集成的Swagger API文档用于安全的API文档访问。本示例展示了Swagger UI与GoFrame HTTP服务器集成、Swagger端点的基础认证保护、OpenAPI规范生成和服务、文档访问的认证中间件、自定义Swagger UI配置、以及与GoFrame路由系统集成。主要功能包括:受保护的API文档、自动OpenAPI规范生成、带认证的交互式API测试、可自定义的Swagger UI主题、基于凭据的访问控制、开发友好的模式。非常适合保护生产环境中的API文档、提供内部API的认证访问、实现带认证的交互式API测试、记录和保护REST API、以及维护带访问控制的API规范。通过本示例可以学习如何保护Swagger文档、集成OpenAPI规范、以及构建安全的API文档系统。 |
| httpserver/upload-file | 演示在GoFrame HTTP服务器中处理文件上传用于多部分表单数据处理。本示例展示了单文件和多文件上传支持、多部分表单数据解析和处理、文件大小验证和限制、带有MIME类型检查的文件类型验证、带有唯一命名的安全文件存储、以及与GoFrame请求处理集成。主要功能包括:自动文件解析、可配置的上传限制、文件元数据提取、进度跟踪支持、无效上传的错误处理、生产级模式。非常适合构建文件上传API和表单、实现图像和文档上传功能、处理批量文件上传、确保安全的文件处理、以及创建内容管理系统。通过本示例可以学习文件上传的最佳实践、安全文件处理、以及构建安全可靠的文件上传功能。 |
| nosql/mongodb | 演示在GoFrame中全面集成MongoDB用于基于文档的数据存储和检索。本示例展示了使用官方Go驱动的MongoDB连接设置和配置、文档的CRUD操作(创建、读取、更新、删除)、带有过滤器和投影的高级查询、用于数据分析的聚合管道使用、用于性能优化的索引创建和管理、用于数据一致性的事务支持、以及连接池配置。主要功能包括:自动连接管理、错误处理模式、在适用情况下与GoFrame的ORM概念集成、文档序列化/反序列化、分页支持、生产级数据库操作。非常适合构建需要灵活模式设计、面向文档的数据模型、复杂聚合、水平扩展性、以及在微服务架构中集成NoSQL数据库的应用程序。通过本示例可以学习如何在GoFrame中使用MongoDB、NoSQL数据库的最佳实践、以及构建灵活高性能的文档存储系统。 |
| nosql/redis | 演示在GoFrame中全面集成Redis用于缓存、会话存储和数据持久化。本示例展示了使用GoFrame的redis组件进行Redis连接设置和配置、基本操作包括GET/SET/DEL、数据结构操作(字符串、哈希、列表、集合、有序集合)、TTL和过期管理、管道和事务支持、发布/订阅消息模式、以及连接池配置。主要功能包括:支持单机和集群模式、自动连接管理、错误处理和重试逻辑、与GoFrame缓存组件集成、序列化和反序列化助手、生产级模式。非常适合实现应用缓存、会话管理、限流、分布式锁、实时消息、以及在微服务架构中实现高性能数据存储。通过本示例可以学习如何在GoFrame中使用Redis、Redis数据结构的最佳实践、以及构建高性能缓存系统。 |
| observability/metric/basic | 演示在GoFrame中使用OpenTelemetry和Prometheus集成的全面基础指标类型及其用法。本示例展示了用于跟踪事件发生的计数器指标、用于测量分布的直方图指标、用于当前值的仪表指标、以及用于双向计数的UpDownCounter。主要功能包括:指标创建和注册、属性配置和标签、指标值记录和观察、与Prometheus导出器集成、OpenTelemetry指标管道设置、生产级埋点模式。非常适合学习基本指标类型、实现应用可观测性、监控服务性能、构建自定义指标仪表板、以及为GoFrame应用建立基准监控。通过本示例可以学习指标的基础概念、OpenTelemetry指标API、以及如何构建完整的监控系统。 |
| observability/metric/callback | 演示在GoFrame中使用OpenTelemetry和Prometheus实现基于回调的指标收集以进行异步指标更新。本示例展示了指标的回调函数注册、通过回调自动更新指标值、异步指标观察、可观察的计数器和仪表模式、系统资源指标收集、以及定时指标更新。主要功能包括:非阻塞指标收集、周期性回调执行、系统指标集成(CPU、内存、goroutines)、延迟指标评估、自动值刷新、生产级模式。非常适合收集系统指标、监控资源使用、实现异步指标更新、减少指标收集开销、观察计算成本高的值、以及构建对性能影响最小的高效监控系统。通过本示例可以学习异步指标收集、回调模式、以及高效的系统监控实现。 |
| observability/metric/dynamic_attributes | 演示在GoFrame中使用OpenTelemetry和Prometheus管理动态指标属性以实现运行时属性更新。本示例展示了运行时属性修改、基于上下文的属性注入、请求作用域的指标标签、动态属性值解析、每请求指标自定义、以及灵活的标签模式。主要功能包括:在指标记录时更新属性、从请求上下文提取属性、注入用户/租户/会话ID、动态标签值计算、属性值缓存、生产级模式。非常适合实现每请求指标标签、跟踪用户特定指标、支持多租户、使用运行时上下文丰富指标、按动态维度分析行为、以及构建适应应用状态的灵活监控系统。通过本示例可以学习动态属性管理、上下文注入、以及灵活的指标标签实践。 |
| observability/metric/global_attributes | 演示在GoFrame中使用OpenTelemetry和Prometheus管理全局指标属性以实现一致的指标标签。本示例展示了全局属性配置和管理、跨所有指标自动应用属性、服务级元数据(service.name、service.version)、环境识别属性、一致的指标标签、以及属性继承模式。主要功能包括:集中式属性管理、自动属性传播、语义约定支持、多租户标签、部署环境标签、生产级模式。非常适合实现一致的指标标签、管理服务元数据、实现跨服务的指标聚合、支持多环境部署、便于指标过滤和分组、以及建立企业监控标准。通过本示例可以学习全局属性管理、一致性标签实践、以及企业级监控规范。 |
| observability/metric/http_client | 演示在GoFrame中使用OpenTelemetry和Prometheus收集全面的HTTP客户端指标以监控出站HTTP请求。本示例展示了自动HTTP客户端埋点、请求持续时间直方图、按状态码和方法分类的请求计数指标、错误率跟踪、连接池指标、以及重试尝试监控。主要功能包括:无需代码更改的自动指标收集、详细的请求/响应属性、与GoFrame HTTP客户端集成、可自定义的指标标签、Prometheus导出器配置、生产级可观测性模式。非常适合监控外部API调用、跟踪HTTP客户端性能、调试连接问题、分析请求模式、以及确保微服务架构中出站HTTP通信的可靠性。通过本示例可以学习如何监控HTTP客户端、分析外部依赖、以及优化API调用性能。 |
| observability/metric/http_server | 演示在GoFrame中使用OpenTelemetry和Prometheus收集全面的HTTP服务器指标以监控入站HTTP请求。本示例展示了自动HTTP服务器埋点、请求延迟直方图、按端点和方法分类的吞吐量指标、HTTP状态码分布、并发请求跟踪、以及错误率监控。主要功能包括:通过中间件自动收集指标、详细的请求属性(路径、方法、状态)、与GoFrame HTTP服务器集成、可自定义的指标桶、Prometheus端点暴露、生产级监控模式。非常适合监控API性能、跟踪服务健康、分析流量模式、识别性能瓶颈、实现SLA监控、以及确保生产环境中HTTP服务的高可用性。通过本示例可以学习如何监控HTTP服务器、分析请求性能、以及构建完整的服务监控体系。 |
| observability/metric/meter_attributes | 演示在GoFrame中使用OpenTelemetry和Prometheus管理仪表级属性以实现作用域指标标签。本示例展示了仪表特定的属性配置、仪表内的属性作用域、隔离的指标标签、仪表级元数据管理、从仪表到指标的属性继承、以及精细的属性控制。主要功能包括:创建带有自定义属性的仪表、将属性作用域限制在特定指标组、隔离的属性命名空间、自动将属性应用于仪表指标、基于仪表的多租户、生产级模式。非常适合按模块或组件组织指标、实现作用域指标标签、管理多个指标命名空间、隔离指标组之间的属性、构建模块化监控系统、以及为复杂应用建立层次化指标组织。通过本示例可以学习仪表级属性管理、作用域标签、以及层次化指标组织。 |
| observability/metric/prometheus | 演示在GoFrame中不使用OpenTelemetry直接集成Prometheus指标以实现轻量级监控解决方案。本示例展示了原生Prometheus客户端库的使用、直接向Prometheus注册表注册指标、counter、gauge、histogram和summary指标类型、自定义指标收集器、用于/metrics端点暴露的HTTP处理器、以及标签管理。主要功能包括:零OpenTelemetry依赖、简单的指标创建和注册、原生Prometheus指标类型、灵活的指标标签、内置HTTP指标端点、生产级模式。非常适合轻量级监控需求、传统Prometheus设置、简化的指标收集、仅需要Prometheus集成的应用、最小依赖占用、以及不需要或不希望使用OpenTelemetry的环境。通过本示例可以学习Prometheus原生API、简化的监控方案、以及轻量级指标收集。 |
| observability/trace/grpc-with-db | 演示在GoFrame中使用OpenTelemetry实现gRPC服务与数据库操作的全面分布式跟踪。本示例展示了从gRPC调用到数据库查询的端到端trace埋点、自动gRPC方法和数据库操作跟踪、RPC通信中的trace上下文传播、服务调用与数据库操作之间的span关系、与tracing集成的服务发现、以及分布式系统的性能监控。主要功能包括:全栈gRPC trace可见性、自动数据库查询埋点、服务网格可观测性、分布式事务跟踪、跨服务trace关联、生产级模式。非常适合监控微服务架构性能、调试分布式gRPC系统、优化数据库查询性能、确保服务网格环境的可观测性、以及构建企业级监控解决方案。通过本示例可以学习如何实现gRPC全链路跟踪、分布式系统性能优化、以及构建高可观测的微服务架构。 |
| observability/trace/http-with-db | 演示在GoFrame中使用OpenTelemetry实现HTTP服务与数据库操作的全面分布式跟踪。本示例展示了从HTTP请求到数据库查询的端到端trace埋点、包括MySQL和Redis操作的自动数据库操作跟踪、贯穿整个请求生命周期的trace上下文传播、HTTP处理器与数据库调用之间的span关系、数据库查询的性能监控、以及与GoFrame的ORM和缓存组件集成。主要功能包括:全栈trace可见性、自动数据库查询埋点、慢查询检测、连接池监控、缓存操作跟踪、生产级可观测性。非常适合监控全栈应用性能、调试数据库相关问题、优化查询性能、确保数据驱动应用的端到端可观测性、以及构建全面的监控解决方案。通过本示例可以学习如何实现全链路跟踪、数据库性能优化、以及构建高性能可观测的数据应用。 |
| observability/trace/http | 演示在GoFrame中使用OpenTelemetry集成实现HTTP服务的全面分布式链路跟踪。本示例展示了带有自动埋点的HTTP请求和响应跟踪、跨服务边界的trace上下文传播、span创建和属性管理、向OpenTelemetry收集器导出trace数据、与GoFrame HTTP服务器中间件集成、以及分布式trace的可视化。主要功能包括:自动HTTP trace埋点、上下文传播头、自定义span属性、父子span关系、trace采样配置、生产级可观测性模式。非常适合在微服务中实现分布式跟踪、监控HTTP服务性能、调试请求流程、确保云原生应用的可观测性、以及构建生产监控系统。通过本示例可以学习如何在HTTP服务中实现分布式跟踪、OpenTelemetry的最佳实践、以及构建可观测的微服务架构。 |
| observability/trace/inprocess-grpc | 演示在单进程应用中使用GoFrame和高性能gRPC基础的OpenTelemetry导出器实现分布式跟踪。本示例展示了使用gRPC OTLP导出器配置的进程内函数调用跟踪、内部操作的span创建和管理、单进程内的trace上下文传播、高效的基于gRPC的trace数据导出到OpenTelemetry收集器、嵌套函数调用的父子span关系、以及高吞吐量trace数据传输。主要功能包括:高性能gRPC导出器设置、自动span埋点、流式trace导出、高效二进制序列化、生产级性能、企业级模式。非常适合大量trace数据生成、性能关键应用、生产监控系统、需要高效trace导出的应用、以及构建可扩展的可观测性解决方案。通过本示例可以学习如何实现高性能链路跟踪、gRPC导出器的最佳实践、以及构建企业级监控系统。 |
| observability/trace/inprocess | 演示在单进程应用中使用GoFrame和基于HTTP的OpenTelemetry导出器实现分布式跟踪以简化可观测性。本示例展示了使用HTTP OTLP导出器配置的进程内函数调用跟踪、内部操作的span创建和管理、单进程内的trace上下文传播、基于HTTP的trace数据导出到OpenTelemetry收集器、嵌套函数调用的父子span关系、以及无需gRPC依赖的简化部署。主要功能包括:轻量级HTTP导出器设置、自动span埋点、内存trace上下文、防火墙友好的HTTP导出、开发友好的配置、生产级模式。非常适合单体应用可观测性、开发和测试环境、简化trace数据导出、仅支持HTTP基础设施的应用、以及学习分布式跟踪概念。通过本示例可以学习如何实现进程内跟踪、简化的可观测性方案、以及轻量级监控部署。 |
| observability/trace/otlp | 演示在GoFrame中使用OTLP协议通过gRPC和HTTP导出器实现全面的OpenTelemetry链路跟踪数据导出方法。本示例展示了用于trace导出的OTLP（OpenTelemetry协议）配置、gRPC和HTTP导出器的设置与比较、trace数据的序列化和传输、连接管理和重试逻辑、批处理和性能优化、以及与OpenTelemetry收集器的集成。主要功能包括:灵活的导出器配置、高效的trace数据传输、自动批处理和压缩、错误处理和重试机制、生产级导出模式、协议选择指导。非常适合实现生产trace导出、选择合适的导出协议、优化trace数据传输、确保可靠的trace交付、以及构建符合OpenTelemetry标准的企业级可观测性基础设施。通过本示例可以学习OTLP协议的使用、导出器选型、以及构建高效的trace数据导出系统。 |
| observability/trace/processes | 演示使用GoFrame的进程管理方式（包括gcmd和gproc）实现跨多个进程的全面分布式跟踪。本示例展示了进程间的trace上下文传播、带有跟踪的进程生成和生命周期管理、跨进程边界的分布式span关系、多进程架构中的trace关联、带有跟踪支持的不同进程通信模式、以及与GoFrame命令和进程组件的集成。主要功能包括:多进程trace可见性、进程间自动上下文传播、父子进程span关系、进程隔离下trace连续性、生产级多进程模式、企业架构支持。非常适合构建带有可观测性的多进程应用、实现分布式任务处理、监控守护进程和工作进程、确保复杂进程拓扑中的trace连续性、以及创建带有全面跟踪的可扩展多进程系统。通过本示例可以学习多进程链路跟踪、进程间通信与trace传播、以及构建复杂的分布式系统监控。 |
| observability/trace/provider | 演示在GoFrame中配置包括gRPC和HTTP导出器的全面OpenTelemetry链路跟踪provider配置和不同设置模式。本示例展示了trace provider的初始化和配置、用于服务识别的资源属性管理、采样策略配置和选择、基于gRPC和HTTP的导出器设置与比较、用于批处理和简单处理的span处理器配置、以及provider生命周期管理。主要功能包括:灵活的provider配置模式、资源语义约定、多种采样策略(总是、从不、基于父级、基于比例)、导出器协议选择指导、生产级provider设置、企业部署模式。非常适合理解OpenTelemetry provider架构、配置生产trace管道、选择合适的导出器和采样器、优化trace收集性能、以及构建带有适当provider配置的可扩展可观测性基础设施。通过本示例可以学习OpenTelemetry provider的最佳实践、导出器和采样器选型、以及构建企业级链路跟踪系统。 |
| ractices/injection | 演示在GoFrame框架中使用do包实现依赖注入模式的全面示例。展示了如何通过接口抽象实现松耦合架构、使用do包管理依赖关系、注册和解析服务实例、单例模式管理、接口注入与实现替换、以及单元测试Mock实现。包含User服务、Gateway网关等实际应用场景，演示了服务分层、接口定义、实现注册、依赖解析等完整流程。非常适合微服务架构开发、可测试代码编写、模块化系统设计、接口驱动开发、以及需要灵活依赖管理的企业级应用。通过本示例可以学习如何构建高可维护、易测试的Go应用程序。 |
| registry/consul | 演示在GoFrame中全面集成HashiCorp Consul服务注册中心实现企业级服务发现和健康监控。本示例展示了向Consul代理注册服务包括健康检查配置、使用过滤器和基于标签的查询进行服务发现、内置健康监控和自动移除不健康服务、服务元数据和版本管理支持、多数据中心服务发现、以及与GoFrame服务器和客户端组件集成。主要功能包括:企业服务注册中心、自动健康检查执行、DNS和HTTP服务发现接口、负载均衡器集成、服务网格兼容性、生产级模式。适合构建需要强大服务发现的微服务、实现企业服务网格、确保服务健康监控、以及实现跨多数据中心的动态服务注册。 |
| registry/etcd | 演示在GoFrame中全面集成Etcd服务注册中心实现分布式服务发现和注册。本示例展示了使用自动心跳机制向Etcd注册服务、服务发现和监听实时更新、基于TTL的服务健康管理、服务元数据和端点配置、关闭时自动服务注销、以及与GoFrame服务器和客户端组件集成。主要功能包括:分布式服务注册中心、通过watch机制实现实时服务更新、健康检查集成、负载均衡器集成、自动故障转移支持、生产级模式。适合构建需要动态服务发现的云原生微服务、实现服务网格架构、通过自动服务注册确保高可用性、以及实现零停机部署。 |
| registry/file | 演示在GoFrame框架中实现基于文件系统的服务注册与发现机制。本示例展示了如何使用本地文件系统作为轻量级注册中心，支持服务自动注册、服务列表查询、服务实例管理、配置文件存储、以及无需外部依赖的简单部署。主要功能包括:本地文件存储服务信息、JSON/YAML格式服务描述、自动文件监听和刷新、多实例注册管理、简单的配置管理、零外部依赖部署。适合开发环境快速测试、单机或小型应用部署、学习和演示注册中心概念、离线环境的服务管理、以及不需要复杂注册中心的简单应用场景。 |
| registry/nacos | 演示在GoFrame中全面集成阿里巴巴Nacos服务注册中心实现动态服务管理和配置。本示例展示了使用命名空间和分组隔离向Nacos注册服务、使用实例过滤和选择策略进行服务发现、内置健康监控和心跳机制、服务元数据和基于权重的负载均衡、与Nacos配置中心集成、以及无缝的GoFrame组件集成。主要功能包括:集中式服务注册中心、实时服务状态更新、健康检查自动化、加权负载均衡支持、基于命名空间的服务隔离、生产级模式。适合在阿里云上构建云原生微服务、实现带配置管理的动态服务发现、确保服务健康和可用性、以及实现企业级服务治理。 |
| registry/polaris | 演示在GoFrame中全面集成腾讯云Polaris服务注册中心实现服务网格和流量管理。本示例展示了使用高级配置选项向Polaris注册服务、与熔断器和限流集成的服务发现、健康检查配置和自动实例隔离、服务路由和流量管理、与Polaris网格集成实现统一治理、以及无缝的GoFrame组件集成。主要功能包括:服务网格注册中心、流量控制策略、熔断器模式、基于健康的路由、金丝雀部署支持、生产级模式。适合在腾讯云上构建云原生微服务、实现服务网格架构、通过流量管理确保高可用性、以及实现带统一控制面板的高级服务治理。 |
Quick start guide for the GoFrame framework. GoFrame is a modular, low-coupling development framework that includes common basic components and development tools, suitable for complete business projects and independent component libraries. Content covers GoFrame's download and installation, basic operation, and how to develop a simple Web Server interface application.
—
First Try of Middleware
—
Use middleware in the GoFrame framework to intercept requests and return results, implementing custom processing logic through pre and post middleware. The sample code shows how to define an error handling middleware and bind it to routes. Middleware makes request error handling and output format unification flexible and powerful.
—
Using Standard Routes
—
Use standard routes in the GoFrame framework to simplify route registration and focus on business logic. By defining request and response data structures, standardizing route registration, and using object-oriented route management, code maintainability is improved. Provides complete sample code and execution results to guide readers in practical project application.
—
Generating Interface Documentation
—
With the GoFrame framework, you can easily generate standardized interface documents. This document introduces how to automatically generate and display interface documents by improving interface definitions, combining the OpenAPIv3 protocol and Swagger UI. The code example explains in detail the data structure definition of the interface, the setting of route middleware, and how to use GoFrame framework features to optimize the interface document generation process.
—
Unified Return Structure
—
Use the GoFrame framework to unify interface return structures, returning data in JSON format, defining interface data structures and route functions, using middleware to process execution results, and providing complete sample code. Through these methods, you can achieve unified data format encapsulation in business projects, simplifying the generation and maintenance of interface documents.
—
Obtaining Request Parameters
—
Use the GoFrame framework to obtain request parameters submitted by clients in the Web Server, focusing on handling parameters submitted via HTTP methods such as Query String, Form, and Body through the r.Get method. Learning content includes parameter default value handling and automatic parameter type recognition. The sample code shows in detail how to receive and process parameters in GoFrame, and analyzes common problems, laying the foundation for structured processing of parameter objects in subsequent chapters.
—
Request Data Structure
—
Solve the problem of hard-coded parameter names through data structuring, introducing how to define request objects to receive client parameters, implementing parameter mapping and validation through the GoFrame framework, improving code maintainability. At the same time, the sample program shows methods to avoid redundant validation logic and explores more concise solutions.
—
Project Scaffolding
—
Basic Introduction
—
Use the GoFrame framework's scaffolding to build a simple and complete business project. Content covers important steps such as framework tool installation and verification, project template creation, project template operation, and framework version upgrade. The project template supports HTTP Web Server by default, and provides interface document display and Swagger page viewing functions.
—
Interface Development
—
Step1 - Design Data Tables
—
Design and apply MySQL data tables. We define the data table structure for user information and combine Docker to run MySQL for practical data table operations, including creating table structures and applying SQL statements, helping you quickly master database operation skills.
—
Step2 - Generate dao_do_entity
—
Use the scaffolding tool in the GoFrame framework to automatically generate data access objects, ensuring correct CLI tool configuration, then execute code generation via commands, creating corresponding dao, do, and entity files after creating data tables to simplify CRUD operations on data tables. Shows specific file structures and usage methods, as well as the generation principles of different types of files.
—
Step3 - Write API Interface Definitions
—
Define CRUD interfaces in the project's api directory, adopting RESTful-style interface design, using HTTP methods to standardize interface requests. Interface definitions use g.Meta to manage metadata information, including route addresses, request methods, and interface descriptions. Request parameters and return data structures define detailed parameter validation rules. Interface version control starts with version v1 to maintain future compatibility. Interface parameters use flexible receiving methods to meet diverse interface request needs.
—
Step4 - Generate Controller Code
—
Generate controller code based on API definitions, including API interface files, route object management, and route implementation code, using the GoFrame framework's command-line tools to quickly generate relevant code templates, ensuring complete interface implementation, and showing how to implement specific business logic through individual files.
—
Step5 - Complete Interface Logic Implementation
—
Use the GoFrame framework to complete interface logic implementation. Through the project scaffolding, code irrelevant to project business logic is pre-generated, focusing on business logic implementation. Introduces the specific implementation process of CRUD operations, including implementation methods for creation, update, deletion, and query interfaces. Explains in detail parameter validation during data operations, form data insertion and update, intelligent data mapping and validation mechanisms, and how to efficiently use the functions of the GoFrame framework for development.
—
Step6 - Configuration and Routing
—
Introduce MySQL database driver, add database configuration, and route registration steps. Explains in detail the configuration in the scaffolding project template, including tool configuration and business configuration, and how to modify configuration files.
—
Step7 - Startup and Testing
—
Start the service via the command line, and generate interface documents using swagger. Supports RESTful API interfaces for creating users, querying user information, modifying user data, and deleting users. Also supports interface testing using curl commands, providing detailed validation rules and error codes to ensure data accuracy and reliability.
—
Project Startup
—
When you start your first project, you may be confused about the project directory, but through this chapter, you can understand the project startup process and its involved directories. The main program entry is main.go, which guides program startup by calling the internal/cmd package. The default created HTTP Server supports multiple route registrations, making project startup simple and fast. For specific usage details, please refer to the relevant documentation of the GoFrame framework.
—
Go Sample Code
—
| Sample Code | Sample Introduction |
|---|---|
| balancer/http | Demonstrates how to implement HTTP service load balancing using the GoFrame framework combined with etcd. This example shows client-side load balancing implementation using a round-robin strategy for request distribution, supporting automatic service discovery and dynamic routing. Key features include: service registration and discovery using etcd, client-side round-robin load balancing strategy, multi-service instance request distribution, seamless integration with GoFrame's HTTP server and client components, suitable for building highly available and scalable microservice architecture systems. Through this example, you can learn how to implement service load balancing and service discovery mechanisms in a distributed environment. |
| balancer/polaris | Demonstrates how to integrate the Polaris service mesh platform with the GoFrame framework to implement HTTP service load balancing. This example shows Polaris-based service registration and discovery mechanisms, client-side round-robin load balancing strategy, local cache configuration optimization, and centralized log management. Key features include: using Polaris as the service registration center, configurable TTL (time-to-live) heartbeat mechanism, automatic service discovery, dynamic request routing, seamless integration with GoFrame's HTTP server and client components, suitable for building cloud-native microservice architectures and providing advanced traffic management capabilities. Through this example, you can learn how to implement service governance, load balancing, and failover and other enterprise-level features in a distributed environment using Polaris. |
| config/apollo | Demonstrates how to seamlessly integrate the Apollo configuration center into GoFrame applications to implement centralized configuration management. This example shows Apollo client initialization and configuration, configuration adapter implementation methods, dynamic configuration loading and parsing, real-time configuration update mechanisms, complete error handling and logging, and configuration value acquisition methods. Key features include: centralized configuration management via Apollo, support for multiple environments and namespaces, automatic configuration refresh capability, type-safe configuration access using the GoFrame configuration component, production-grade error handling mechanism. Suitable for building microservice applications that require centralized configuration management, dynamic configuration updates without restarting, and support for configuration version management and rollback. Through this example, you can learn best practices for configuration centers in distributed systems. |
| config/consul | Demonstrates how to fully integrate the HashiCorp Consul configuration center into GoFrame applications to implement distributed configuration management. This example shows Consul client setup and initialization, GoFrame configuration component adapter implementation, dynamic configuration loading and parsing, real-time configuration monitoring and update, complete error handling and logging, and secure configuration value acquisition. Key features include: distributed configuration management via Consul KV storage, support for multiple data centers and namespaces, automatic configuration synchronization, health check and service discovery integration, type-safe configuration access, production-grade error handling mechanism. Ideal for building cloud-native microservice applications that require distributed configuration management, service mesh integration, and configuration consistency among multiple instances. Through this example, you can learn how to use Consul to implement enterprise-level distributed configuration management and service governance. |
| config/kubecm | Demonstrates how to fully integrate Kubernetes ConfigMap into GoFrame applications to implement cloud-native configuration management. This example shows two configuration scenarios: inside and outside Pods, Kubernetes client initialization and authentication, ConfigMap access and dynamic loading, real-time configuration monitoring and update, namespace and resource management, complete error handling and logging, and secure configuration value acquisition. Key features include: native Kubernetes ConfigMap integration, support for multiple deployment scenarios (inside and outside clusters), automatic configuration refresh when ConfigMap changes, seamless integration with the GoFrame configuration component, RBAC-compliant access mode, production-grade error handling mechanism. Ideal for building cloud-native applications deployed on Kubernetes, especially scenarios that require native configuration management, GitOps workflows, and configuration-as-code practices. Through this example, you can learn how to implement declarative configuration management and cloud-native best practices in a Kubernetes environment. |
| config/nacos | Demonstrates how to seamlessly integrate Alibaba's Nacos configuration center into GoFrame applications to implement dynamic configuration management. This example shows Nacos client initialization and configuration, GoFrame configuration component adapter implementation, dynamic configuration loading and hot update, real-time configuration monitoring and change notification, namespace and group management, complete error handling and logging, and secure configuration value acquisition. Key features include: centralized configuration management via Nacos, support for multi-environment and namespace isolation, automatic configuration refresh without restarting services, configuration version management and rollback capabilities, type-safe configuration access, production-grade monitoring capabilities. Ideal for building cloud-native microservice applications deployed on Alibaba Cloud or locally, especially scenarios that require dynamic configuration, service discovery, and configuration sharing among distributed systems. Through this example, you can deeply learn enterprise-level application practices of Nacos in configuration management and service governance. |
| config/polaris | Demonstrates how to seamlessly integrate Tencent Cloud's Polaris configuration center into GoFrame applications to implement service mesh configuration management. This example shows Polaris client setup and initialization, GoFrame configuration component adapter implementation, dynamic configuration loading and hot update, real-time configuration monitoring and synchronization, namespace and file group management, complete error handling and logging, and secure configuration value acquisition. Key features include: centralized configuration management via Polaris, support for multiple namespaces and configuration groups, automatic configuration refresh capability, integration with Polaris service mesh to achieve unified service governance, type-safe configuration access, production-grade monitoring capabilities. Ideal for building cloud-native microservice applications based on Tencent Cloud or using Polaris mesh, especially scenarios that require dynamic configuration, service discovery, traffic management, and unified configuration governance. Through this example, you can deeply learn enterprise-level application practices of Polaris in configuration management and service mesh. |
| database/encoded-pass | Demonstrates how to implement a custom database driver in GoFrame to handle encrypted database passwords, improving application security. This example shows how to create a custom MySQL driver with AES encryption and Base64 encoding, automatic password decryption mechanism during connection establishment, secure credential storage in configuration files, transparent database connection handling, and seamless integration with the GoFrame database component. Key features include: encrypted password storage, custom driver registration, automatic decryption middleware, production-grade security mode, zero impact on existing database operations. Ideal for applications that need to enhance database security, comply with security policy requirements, protect sensitive credentials in version control, and implement secure configuration management without code changes. Through this example, you can learn how to improve database connection security without affecting development efficiency, and how to implement custom database drivers to extend GoFrame's capabilities. |
| grpc/balancer | Demonstrates implementing comprehensive gRPC load balancing in GoFrame to build an elastic distributed system. This example shows how to configure gRPC load balancers using multiple strategies, implement client-side load balancing for optimal performance, integrate with service discovery mechanisms such as etcd, handle automatic failover and service health checks, distribute requests among multiple server instances, and manage connection pools. Key features include: multiple load balancing algorithms (round-robin, weighted, least connection), automatic service instance discovery, health-based routing, connection state management, retry strategies, production-grade error handling. Ideal for building highly available microservices, implementing fault-tolerant distributed systems, horizontally scaling gRPC services, and ensuring optimal resource utilization across service instances. Through this example, you can learn how to implement gRPC load balancing in a distributed environment, how service discovery and load balancing work together, and best practices for building highly available and high-performance microservice architectures. |
| grpc/basic | Demonstrates the basic implementation of gRPC in GoFrame applications, covering protocol buffer definition, service creation, and client-server communication. This example shows how to create gRPC servers and clients using GoFrame, define and compile protocol buffers for service contracts, implement service handlers with business logic, perform synchronous and asynchronous RPC calls, handle errors and status codes, and integrate with GoFrame's configuration and logging systems. Key features include: complete server and client setup, protocol buffer integration, service interface implementation, request-response mode, error handling best practices, production-grade code structure. Ideal for gRPC novice developers, building microservices using GoFrame, learning protocol buffer usage, and implementing inter-service communication patterns. Through this example, you can learn the basic usage of gRPC in GoFrame, best practices for microservice communication, and how to build efficient RPC services. |
| grpc/ctx | Demonstrates advanced context and metadata management in GoFrame's gRPC services for request tracking and data propagation. This example shows how to pass metadata through gRPC context to handle cross-cutting concerns, handle context values and deadlines to implement request cancellation, manage request context across service boundaries, handle and extract context metadata, implement distributed tracing integration, and propagate authentication tokens and correlation IDs. Key features include: metadata injection and extraction, context timeout and cancellation handling, custom metadata keys and values, interceptor-based metadata processing, distributed tracing support, request correlation patterns. Ideal for implementing observability in microservices, tracking requests across distributed systems, implementing authentication and authorization, managing request timeouts and cancellations, and building production-grade gRPC services with proper context management. Through this example, you can learn advanced usage of gRPC context, how to propagate request information in distributed systems, and best practices and observability patterns for inter-microservice communication. |
| grpc/rawgrpc | Demonstrates implementing native gRPC directly in GoFrame without using the framework abstraction layer, providing maximum control and flexibility. This example shows how to create gRPC servers and clients directly using the native gRPC library, use protocol buffers directly without additional encapsulation, implement service handlers through direct gRPC API access, perform low-level RPC calls with full control, handle streaming RPC and advanced patterns, and selectively integrate GoFrame components. Key features include: direct creation of gRPC servers and clients, protocol buffer usage without abstraction, manual connection management, custom interceptors and middleware, streaming support (unary, client streaming, server streaming, bidirectional streaming), production-grade error handling. Ideal for advanced users who need fine-grained control, implementing custom gRPC patterns, optimizing performance-critical applications, and integrating third-party gRPC libraries. Through this example, you can learn how to use native gRPC in GoFrame, deeply understand gRPC working principles, and implement highly customized RPC communication solutions. |
| grpc/resolver | Demonstrates implementing a gRPC service resolver in GoFrame and integrating with etcd to achieve dynamic service discovery and resolution. This example shows how to configure a service resolver using etcd as the service registration center, automatically register gRPC services with etcd via automatic heartbeats, dynamically discover and resolve services using the resolver API, automatically handle service instance updates and removals, implement client-side service discovery, and manage service health monitoring. Key features include: etcd-based service registration center, automatic service registration and deregistration, dynamic service resolution, health check integration, automatic failover when services change, production-grade connection management. Ideal for building cloud-native microservices with dynamic service discovery, implementing service mesh patterns, scaling services without client reconfiguration, and ensuring high availability through automatic service resolution. Through this example, you can learn how to implement service discovery and resolution in gRPC, the application of etcd in microservice architectures, and best practices for building dynamically scalable distributed systems. |
| httpserver/basic-auth | Demonstrates implementing HTTP basic authentication in GoFrame for simple credential-based access control. This example shows the setup and configuration of basic authentication middleware, username and password validation against configured credentials, Base64 credential encoding and decoding, WWW-Authenticate header handling for browser prompts, protected route implementation, custom authentication failure responses, and integration with the GoFrame middleware system. Key features include: simple authentication without external dependencies, browser-compatible authentication dialogs, credential validation mode, secure credential storage recommendations, custom realm configuration, production-grade error handling. Ideal for internal tools and admin panels, simple API protection, development and testing environments, legacy system integration, and applications that require lightweight authentication without complex infrastructure. Through this example, you can learn how to implement HTTP basic authentication, how to implement simple authentication protection in GoFrame, and the applicable scenarios and considerations of basic authentication. |
| httpserver/jwt | Demonstrates implementing comprehensive JWT (JSON Web Token) authentication in the GoFrame HTTP server for secure API access control. This example shows JWT token generation with custom claims and expiration time, token validation and verification middleware, secure token signing using HS256/RS256 algorithms, refresh token mechanism for session extension, protected route implementation with authentication middleware, error handling for invalid or expired tokens, and integration with the GoFrame middleware system. Key features include: user login and token issuance, stateless authentication, token refresh mode, role-based access control (RBAC) integration, secure token storage recommendations, production-grade security practices. Ideal for building REST APIs with authentication, implementing microservice security, mobile application backends that require stateless authentication, and applications that require scalable authentication without server-side sessions. Through this example, you can learn best practices for JWT authentication, how to implement secure stateless authentication, and how to build secure and scalable web services. |
| httpserver/mcp-http | Demonstrates implementing a Model Context Protocol (MCP) server using GoFrame and HTTP streaming for AI model integration. This example shows MCP server setup using HTTP transport, streaming response handling for real-time model output, protocol message encoding and decoding, context management and propagation, integration with AI models and services, and error handling for MCP operations. Key features include: HTTP-based MCP transport, streaming API support, efficient message serialization, cross-request context sharing, scalable protocol processors, production-grade patterns. Ideal for building AI agent backends, integrating language models with applications, implementing streaming AI responses, and creating model context sharing services that comply with the MCP protocol. Through this example, you can learn the implementation of the MCP protocol, best practices for AI model integration, and how to build intelligent AI applications. |
| httpserver/mcp-sse | Demonstrates implementing a Model Context Protocol (MCP) server using GoFrame and Server-Sent Events (SSE) for real-time AI model communication. This example shows MCP server setup using SSE transport to achieve server-to-client streaming, real-time event streaming of model output, persistent connections for continuous communication, event formatting and client reconnection handling, integration with AI models and agents, and efficient resource management. Key features include: SSE-based MCP transport, one-way streaming from server to client, automatic reconnection support, event-driven architecture, lighter weight than WebSocket, production-grade patterns. Ideal for building real-time AI agent interfaces, implementing streaming model responses without WebSocket complexity, creating chat and assistant applications, and implementing server push notifications for model updates. Through this example, you can learn the use of SSE in AI applications, MCP protocol implementation, and how to build real-time intelligent applications. |
| httpserver/proxy | Demonstrates implementing a reverse proxy server using GoFrame for request forwarding and load distribution. This example shows reverse proxy setup and configuration with target backend servers, HTTP request and response forwarding with header preservation, custom header operations and transformations, connection pool and keepalive management, error handling and failover logic, and integration with the GoFrame middleware system. Key features include: flexible proxy configuration, transparent request forwarding, response streaming support, custom routing rules, load balancing integration, production-grade patterns. Suitable for building API gateways and service proxies, implementing microservice routing, adding authentication and rate limiting layers, implementing A/B testing and canary deployments, and creating development proxy servers. |
| httpserver/rate-limit | Demonstrates implementing rate limiting in the GoFrame HTTP server for API protection and traffic control. This example shows rate limiting middleware configuration with configurable limits, token bucket and sliding window algorithms, IP-based and user-based rate limiting strategies, custom rate limiting responses and headers (X-RateLimit-*), Redis-based distributed rate limiting for scalability, and integration with the GoFrame middleware chain. Key features include: flexible rate limiting strategies, distributed rate limiting support, custom limit rules per endpoint, graceful rate limiting responses, monitoring and metrics integration, production-grade patterns. Ideal for protecting APIs from abuse and DDoS attacks, implementing fair usage policies, ensuring service stability under load, managing API quotas and billing, and enabling multi-tier service levels. Through this example, you can learn rate limiting algorithms, how to implement efficient traffic control, and how to build secure and reliable API services. |
| httpserver/response-json-array | Demonstrates handling JSON array responses in the GoFrame HTTP server for RESTful API development. This example shows returning JSON arrays as HTTP responses, appropriate content-type header configuration, array serialization with custom formatting, pagination support for large datasets, efficient memory management for large arrays, and integration with the GoFrame response writing system. Key features include: automatic JSON serialization, appropriate HTTP status codes, empty array handling, streaming support for large datasets, error response formatting, RESTful API patterns. Ideal for building REST APIs that return collections, implementing list and search endpoints, handling batch data responses, ensuring consistent API response formats, and optimizing JSON serialization performance. Through this example, you can learn best practices for JSON array responses, RESTful API design, and efficient data serialization. |
| httpserver/sse | Demonstrates implementing Server-Sent Events (SSE) using GoFrame for real-time server-to-client streaming. This example shows SSE server setup with persistent connections, event stream formatting with data, event types, and IDs, automatic client reconnection handling with Last-Event-ID, sending real-time updates and notifications, appropriate content-type and header configuration, and connection lifecycle management. Key features include: one-way streaming from server to client, automatic reconnection support, event-driven architecture, lighter weight than WebSocket, heartbeat and keepalive support, production-grade patterns. Ideal for building real-time notifications and updates, implementing real-time dashboards and monitoring, creating chat and messaging functions, implementing server push without WebSocket, and building event-driven applications. Through this example, you can learn the implementation principles of SSE, the difference from WebSocket, and how to build real-time communication applications. |
| httpserver/swagger-auth | Demonstrates implementing Swagger API documentation with basic authentication integration using GoFrame for secure API document access. This example shows Swagger UI integration with the GoFrame HTTP server, basic authentication protection for Swagger endpoints, automatic OpenAPI specification generation and serving, authentication middleware for document access, custom Swagger UI configuration, and integration with the GoFrame routing system. Key features include: protected API documentation, automatic OpenAPI specification generation, authenticated interactive API testing, customizable Swagger UI themes, credential-based access control, developer-friendly patterns. Ideal for protecting API documentation in production environments, providing authenticated access to internal APIs, implementing authenticated interactive API testing, documenting and protecting REST APIs, and maintaining API specifications with access control. Through this example, you can learn how to protect Swagger documents, integrate OpenAPI specifications, and build secure API document systems. |
| httpserver/upload-file | Demonstrates handling file uploads in the GoFrame HTTP server for multipart form data processing. This example shows single and multiple file upload support, multipart form data parsing and processing, file size validation and limits, file type validation with MIME type checking, secure file storage with unique naming, and integration with the GoFrame request handling system. Key features include: automatic file parsing, configurable upload limits, file metadata extraction, progress tracking support, error handling for invalid uploads, production-grade patterns. Ideal for building file upload APIs and forms, implementing image and document upload functions, handling batch file uploads, ensuring secure file processing, and creating content management systems. Through this example, you can learn best practices for file uploads, secure file handling, and how to build secure and reliable file upload functions. |
| nosql/mongodb | Demonstrates comprehensive integration of MongoDB in GoFrame for document-based data storage and retrieval. This example shows MongoDB connection setup and configuration using the official Go driver, CRUD operations (create, read, update, delete) for documents, advanced queries with filters and projections, use of aggregation pipelines for data analysis, index creation and management for performance optimization, transaction support for data consistency, and connection pool configuration. Key features include: automatic connection management, error handling patterns, integration with GoFrame's ORM concepts where applicable, document serialization/deserialization, pagination support, production-grade database operations. Ideal for building applications that require flexible schema design, document-oriented data models, complex aggregations, horizontal scalability, and integrating NoSQL databases in microservice architectures. Through this example, you can learn how to use MongoDB in GoFrame, best practices for NoSQL databases, and how to build flexible and high-performance document storage systems. |
| nosql/redis | Demonstrates comprehensive integration of Redis in GoFrame for caching, session storage, and data persistence. This example shows Redis connection setup and configuration using GoFrame's redis component, basic operations including GET/SET/DEL, data structure operations (strings, hashes, lists, sets, sorted sets), TTL and expiration management, pipeline and transaction support, publish/subscribe messaging patterns, and connection pool configuration. Key features include: support for standalone and cluster modes, automatic connection management, error handling and retry logic, integration with GoFrame's cache component, serialization and deserialization helpers, production-grade patterns. Ideal for implementing application caching, session management, rate limiting, distributed locks, real-time messaging, and implementing high-performance data storage in microservice architectures. Through this example, you can learn how to use Redis in GoFrame, best practices for Redis data structures, and how to build high-performance caching systems. |
| observability/metric/basic | Demonstrates comprehensive basic metric types and their usage in GoFrame using OpenTelemetry and Prometheus integration. This example shows counter metrics for tracking event occurrences, histogram metrics for measuring distributions, gauge metrics for current values, and UpDownCounter for bidirectional counting. Key features include: metric creation and registration, attribute configuration and labeling, metric value recording and observation, integration with Prometheus exporter, OpenTelemetry metrics pipeline setup, production-grade instrumentation patterns. Ideal for learning basic metric types, implementing application observability, monitoring service performance, building custom metric dashboards, and establishing baseline monitoring for GoFrame applications. Through this example, you can learn basic concepts of metrics, OpenTelemetry metrics API, and how to build a complete monitoring system. |
| observability/metric/callback | Demonstrates implementing callback-based metric collection in GoFrame using OpenTelemetry and Prometheus for asynchronous metric updates. This example shows metric callback function registration, automatic metric value updates via callbacks, asynchronous metric observation, observable counter and gauge patterns, system resource metric collection, and scheduled metric updates. Key features include: non-blocking metric collection, periodic callback execution, system metrics integration (CPU, memory, goroutines), delayed metric evaluation, automatic value refresh, production-grade patterns. Ideal for collecting system metrics, monitoring resource usage, implementing asynchronous metric updates, reducing metric collection overhead, observing computationally expensive values, and building efficient monitoring systems with minimal performance impact. Through this example, you can learn asynchronous metric collection, callback patterns, and efficient system monitoring implementation. |
| observability/metric/dynamic_attributes | Demonstrates managing dynamic metric attributes in GoFrame using OpenTelemetry and Prometheus to implement runtime attribute updates. This example shows runtime attribute modification, context-based attribute injection, request-scoped metric labels, dynamic attribute value resolution, per-request metric customization, and flexible labeling patterns. Key features include: updating attributes during metric recording, extracting attributes from request context, injecting user/tenant/session IDs, dynamic label value calculation, attribute value caching, production-grade patterns. Ideal for implementing per-request metric labels, tracking user-specific metrics, supporting multi-tenancy, enriching metrics with runtime context, analyzing behavior by dynamic dimensions, and building flexible monitoring systems that adapt to application states. Through this example, you can learn dynamic attribute management, context injection, and flexible metric labeling practices. |
| observability/metric/global_attributes | Demonstrates managing global metric attributes in GoFrame using OpenTelemetry and Prometheus to achieve consistent metric labeling. This example shows global attribute configuration and management, automatic application of attributes across all metrics, service-level metadata (service.name, service.version), environment identification attributes, consistent metric labeling, and attribute inheritance patterns. Key features include: centralized attribute management, automatic attribute propagation, semantic convention support, multi-tenant labeling, deployment environment labeling, production-grade patterns. Ideal for achieving consistent metric labeling, managing service metadata, implementing cross-service metric aggregation, supporting multi-environment deployments, facilitating metric filtering and grouping, and establishing enterprise monitoring standards. Through this example, you can learn global attribute management, consistent labeling practices, and enterprise-level monitoring specifications. |
| observability/metric/http_client | Demonstrates collecting comprehensive HTTP client metrics in GoFrame using OpenTelemetry and Prometheus to monitor outbound HTTP requests. This example shows automatic HTTP client instrumentation, request duration histograms, request count metrics categorized by status code and method, error rate tracking, connection pool metrics, and retry attempt monitoring. Key features include: automatic metric collection without code changes, detailed request/response attributes, integration with GoFrame's HTTP client, customizable metric labels, Prometheus exporter configuration, production-grade observability patterns. Ideal for monitoring external API calls, tracking HTTP client performance, debugging connection issues, analyzing request patterns, and ensuring the reliability of outbound HTTP communication in microservice architectures. Through this example, you can learn how to monitor HTTP clients, analyze external dependencies, and optimize API call performance. |
| observability/metric/http_server | Demonstrates collecting comprehensive HTTP server metrics in GoFrame using OpenTelemetry and Prometheus to monitor inbound HTTP requests. This example shows automatic HTTP server instrumentation, request latency histograms, throughput metrics categorized by endpoint and method, HTTP status code distribution, concurrent request tracking, and error rate monitoring. Key features include: automatic metric collection via middleware, detailed request attributes (path, method, status), integration with GoFrame's HTTP server, customizable metric buckets, Prometheus endpoint exposure, production-grade monitoring patterns. Ideal for monitoring API performance, tracking service health, analyzing traffic patterns, identifying performance bottlenecks, implementing SLA monitoring, and ensuring high availability of HTTP services in production environments. Through this example, you can learn how to monitor HTTP servers, analyze request performance, and build a complete service monitoring system. |
| observability/metric/meter_attributes | Demonstrates managing meter-level attributes in GoFrame using OpenTelemetry and Prometheus to implement scoped metric labeling. This example shows meter-specific attribute configuration, attribute scoping within meters, isolated metric labeling, meter-level metadata management, attribute inheritance from meters to metrics, and fine-grained attribute control. Key features include: creating meters with custom attributes, restricting attribute scope to specific metric groups, isolated attribute namespaces, automatic application of attributes to meter metrics, meter-based multi-tenancy, production-grade patterns. Ideal for organizing metrics by module or component, implementing scoped metric labeling, managing multiple metric namespaces, isolating attributes between metric groups, building modular monitoring systems, and establishing hierarchical metric organization for complex applications. Through this example, you can learn meter-level attribute management, scoped labeling, and hierarchical metric organization. |
| observability/metric/prometheus | Demonstrates integrating Prometheus metrics directly in GoFrame without using OpenTelemetry to implement a lightweight monitoring solution. This example shows using the native Prometheus client library, registering metrics directly with the Prometheus registry, counter, gauge, histogram, and summary metric types, custom metric collectors, HTTP handlers for exposing the /metrics endpoint, and label management. Key features include: zero OpenTelemetry dependencies, simple metric creation and registration, native Prometheus metric types, flexible metric labels, built-in HTTP metrics endpoint, production-grade patterns. Ideal for lightweight monitoring needs, traditional Prometheus setups, simplified metric collection, applications that only require Prometheus integration, minimal dependency footprint, and environments where OpenTelemetry is not needed or desired. Through this example, you can learn the Prometheus native API, simplified monitoring solutions, and lightweight metric collection. |
| observability/trace/grpc-with-db | Demonstrates implementing comprehensive distributed tracing for gRPC services and database operations in GoFrame using OpenTelemetry. This example shows end-to-end trace instrumentation from gRPC calls to database queries, automatic gRPC method and database operation tracking, trace context propagation in RPC communication, span relationships between service calls and database operations, service discovery integrated with tracing, and performance monitoring of distributed systems. Key features include: full-stack gRPC trace visibility, automatic database query instrumentation, service mesh observability, distributed transaction tracing, cross-service trace correlation, production-grade patterns. Ideal for monitoring microservice architecture performance, debugging distributed gRPC systems, optimizing database query performance, ensuring observability in service mesh environments, and building enterprise-level monitoring solutions. Through this example, you can learn how to implement full-link tracing for gRPC, distributed system performance optimization, and how to build highly observable microservice architectures. |
| observability/trace/http-with-db | Demonstrates implementing comprehensive distributed tracing for HTTP services and database operations in GoFrame using OpenTelemetry. This example shows end-to-end trace instrumentation from HTTP requests to database queries, automatic database operation tracking including MySQL and Redis operations, trace context propagation throughout the request lifecycle, span relationships between HTTP handlers and database calls, performance monitoring of database queries, and integration with GoFrame's ORM and cache components. Key features include: full-stack trace visibility, automatic database query instrumentation, slow query detection, connection pool monitoring, cache operation tracking, production-grade observability. Ideal for monitoring full-stack application performance, debugging database-related issues, optimizing query performance, ensuring end-to-end observability of data-driven applications, and building comprehensive monitoring solutions. Through this example, you can learn how to implement full-link tracing, database performance optimization, and how to build high-performance and observable data applications. |
| observability/trace/http | Demonstrates implementing comprehensive distributed tracing for HTTP services in GoFrame using OpenTelemetry integration. This example shows automatic instrumentation for HTTP requests and responses, trace context propagation across service boundaries, span creation and attribute management, exporting trace data to the OpenTelemetry collector, integration with the GoFrame HTTP server middleware, and visualization of distributed traces. Key features include: automatic HTTP trace instrumentation, context propagation headers, custom span attributes, parent-child span relationships, trace sampling configuration, production-grade observability patterns. Ideal for implementing distributed tracing in microservices, monitoring HTTP service performance, debugging request flows, ensuring observability of cloud-native applications, and building production monitoring systems. Through this example, you can learn how to implement distributed tracing in HTTP services, best practices for OpenTelemetry, and how to build observable microservice architectures. |
| observability/trace/inprocess-grpc | Demonstrates implementing distributed tracing in a single-process application using GoFrame and a high-performance gRPC-based OpenTelemetry exporter. This example shows in-process function call tracing configured with the gRPC OTLP exporter, span creation and management for internal operations, trace context propagation within a single process, efficient gRPC-based trace data export to the OpenTelemetry collector, parent-child span relationships for nested function calls, and high-throughput trace data transmission. Key features include: high-performance gRPC exporter setup, automatic span instrumentation, streaming trace export, efficient binary serialization, production-grade performance, enterprise-level patterns. Ideal for applications generating large amounts of trace data, performance-critical applications, production monitoring systems, applications requiring efficient trace export, and building scalable observability solutions. Through this example, you can learn how to implement high-performance link tracing, best practices for gRPC exporters, and how to build enterprise-level monitoring systems. |
| observability/trace/inprocess | Demonstrates implementing distributed tracing in a single-process application using GoFrame and an HTTP-based OpenTelemetry exporter to simplify observability. This example shows in-process function call tracing configured with the HTTP OTLP exporter, span creation and management for internal operations, trace context propagation within a single process, HTTP-based trace data export to the OpenTelemetry collector, parent-child span relationships for nested function calls, and simplified deployment without gRPC dependencies. Key features include: lightweight HTTP exporter setup, automatic span instrumentation, in-memory trace context, firewall-friendly HTTP export, developer-friendly configuration, production-grade patterns. Ideal for monolithic application observability, development and testing environments, simplified trace data export, applications that only support HTTP infrastructure, and learning distributed tracing concepts. Through this example, you can learn how to implement in-process tracing, simplified observability solutions, and lightweight monitoring deployment. |
| observability/trace/otlp | Demonstrates implementing comprehensive OpenTelemetry link tracing data export methods in GoFrame using the OTLP protocol via gRPC and HTTP exporters. This example shows OTLP (OpenTelemetry Protocol) configuration for trace export, setup and comparison of gRPC and HTTP exporters, trace data serialization and transmission, connection management and retry logic, batching and performance optimization, and integration with the OpenTelemetry collector. Key features include: flexible exporter configuration, efficient trace data transmission, automatic batching and compression, error handling and retry mechanisms, production-grade export patterns, protocol selection guidance. Ideal for implementing production trace export, selecting the appropriate export protocol, optimizing trace data transmission, ensuring reliable trace delivery, and building enterprise-level observability infrastructure compliant with OpenTelemetry standards. Through this example, you can learn the use of the OTLP protocol, exporter selection, and how to build an efficient trace data export system. |
| observability/trace/processes | Demonstrates implementing comprehensive distributed tracing across multiple processes using GoFrame's process management methods (including gcmd and gproc). This example shows trace context propagation between processes, process generation and lifecycle management with tracing, distributed span relationships across process boundaries, trace correlation in multi-process architectures, different process communication patterns with tracing support, and integration with GoFrame's command and process components. Key features include: multi-process trace visibility, automatic inter-process context propagation, parent-child process span relationships, trace continuity under process isolation, production-grade multi-process patterns, enterprise architecture support. Ideal for building multi-process applications with observability, implementing distributed task processing, monitoring daemon and worker processes, ensuring trace continuity in complex process topologies, and creating scalable multi-process systems with comprehensive tracing. Through this example, you can learn multi-process link tracing, inter-process communication and trace propagation, and how to build complex distributed system monitoring. |
| observability/trace/provider | Demonstrates configuring comprehensive OpenTelemetry link tracing providers including gRPC and HTTP exporters in GoFrame and different setting modes. This example shows trace provider initialization and configuration, resource attribute management for service identification, sampling strategy configuration and selection, setup and comparison of gRPC and HTTP-based exporters, span processor configuration for batching and simple processing, and provider lifecycle management. Key features include: flexible provider configuration modes, resource semantic convention support, multiple sampling strategies (always, never, parent-based, ratio-based), exporter protocol selection guidance, production-grade provider setup, enterprise deployment patterns. Ideal for understanding the OpenTelemetry provider architecture, configuring production trace pipelines, selecting appropriate exporters and samplers, optimizing trace collection performance, and building scalable observability infrastructure with appropriate provider configuration. Through this example, you can learn best practices for OpenTelemetry providers, exporter and sampler selection, and how to build enterprise-level link tracing systems. |
| practices/injection | Demonstrates a comprehensive example of implementing the dependency injection pattern using the do package in the GoFrame framework. Shows how to achieve a loosely coupled architecture through interface abstraction, manage dependencies using the do package, register and resolve service instances, singleton mode management, interface injection and implementation replacement, and unit test Mock implementation. Includes practical application scenarios such as User service, Gateway gateway, demonstrating complete processes such as service layering, interface definition, implementation registration, and dependency resolution. Ideal for microservice architecture development, testable code writing, modular system design, interface-driven development, and enterprise-level applications that require flexible dependency management. Through this example, you can learn how to build highly maintainable and testable Go applications. |
| registry/consul | Demonstrates comprehensive integration of HashiCorp Consul service registration center in GoFrame to implement enterprise-level service discovery and health monitoring. This example shows registering services with the Consul agent including health check configuration, service discovery using filters and tag-based queries, built-in health monitoring and automatic removal of unhealthy services, service metadata and version management support, multi-data center service discovery, and integration with GoFrame server and client components. Key features include: enterprise service registration center, automatic health check execution, DNS and HTTP service discovery interfaces, load balancer integration, service mesh compatibility, production-grade patterns. Suitable for building microservices that require powerful service discovery, implementing enterprise service meshes, ensuring service health monitoring, and implementing dynamic service registration across multiple data centers. |
| registry/etcd | Demonstrates comprehensive integration of Etcd service registration center in GoFrame to implement distributed service discovery and registration. This example shows registering services with Etcd using an automatic heartbeat mechanism, service discovery and listening for real-time updates, TTL-based service health management, service metadata and endpoint configuration, automatic service deregistration on shutdown, and integration with GoFrame server and client components. Key features include: distributed service registration center, real-time service updates via watch mechanism, health check integration, load balancer integration, automatic failover support, production-grade patterns. Suitable for building cloud-native microservices that require dynamic service discovery, implementing service mesh architectures, ensuring high availability through automatic service registration, and implementing zero-downtime deployments. |
| registry/file | Demonstrates implementing a file system-based service registration and discovery mechanism in the GoFrame framework. This example shows how to use the local file system as a lightweight registration center, supporting automatic service registration, service list query, service instance management, configuration file storage, and simple deployment without external dependencies. Key features include: local file system storage of service information, JSON/YAML format service descriptions, automatic file monitoring and refresh, multi-instance registration management, simple configuration management, zero external dependency deployment. Suitable for rapid testing in development environments, single-machine or small application deployments, learning and demonstrating registration center concepts, service management in offline environments, and simple application scenarios that do not require complex registration centers. |
| registry/nacos | Demonstrates comprehensive integration of Alibaba's Nacos service registration center in GoFrame to implement dynamic service management and configuration. This example shows registering services with Nacos using namespace and group isolation, service discovery using instance filtering and selection strategies, built-in health monitoring and heartbeat mechanisms, service metadata and weight-based load balancing, integration with Nacos configuration center, and seamless GoFrame component integration. Key features include: centralized service registration center, real-time service status updates, automated health checks, weighted load balancing support, namespace-based service isolation, production-grade patterns. Suitable for building cloud-native microservices on Alibaba Cloud, implementing dynamic service discovery with configuration management, ensuring service health and availability, and implementing enterprise-level service governance. |
| registry/polaris | Demonstrates comprehensive integration of Tencent Cloud's Polaris service registration center in GoFrame to implement service mesh and traffic management. This example shows registering services with Polaris using advanced configuration options, service discovery integrated with circuit breakers and rate limiting, health check configuration and automatic instance isolation, service routing and traffic management, integration with Polaris mesh to achieve unified governance, and seamless GoFrame component integration. Key features include: service mesh registration center, traffic control strategies, circuit breaker patterns, health-based routing, canary deployment support, production-grade patterns. Suitable for building cloud-native microservices on Tencent Cloud, implementing service mesh architectures, ensuring high availability through traffic management, and implementing advanced service governance with a unified control panel. |