Tagged articles
Gin
65 articles · Page 1 of 1
This article introduces four popular Go web frameworks—Gin, Beego, Echo, and Iris—providing code examples for each and highlighting key features like routing, middleware, data binding, and MVC architecture to help developers choose the right tool.
BeegoCode ExampleECHO
0 likes · 8 min read

This article introduces a production-ready Go Gin DDD scaffold featuring four-layer architecture, RocketMQ event-driven messaging, dual MySQL/PostgreSQL databases, unified responses, and step-by-step guides for setup and new module development.
DDDGinGo
0 likes · 17 min read

This article evaluates five popular Go web frameworks—Gin, Echo, Fiber, Beego, and Chi—by detailing their ideal use cases, key features, performance characteristics, and drawbacks, helping developers choose the most suitable framework for their specific project requirements.
BackendBeegoChi
0 likes · 12 min read

This step‑by‑step guide walks you through installing Go, configuring the environment, structuring a project, using Gin to create CRUD endpoints, adding middleware, managing configuration, testing, generating Swagger docs, optimizing performance, and deploying the service with Docker or systemd.
DockerGORMGin
0 likes · 21 min read

This tutorial walks through creating a complete Go backend service using Gin and GORM, covering project setup, layered architecture, database initialization, user model definition, JWT‑based registration and login, pagination, middleware, routing, and deployment options, while also suggesting extensible features such as RBAC, Swagger, Redis caching, Docker, and micro‑service frameworks.
APIGORMGin
0 likes · 8 min read


TonyBaiJul 4, 2026 · Backend Development
Manu Martínez‑Almeida explains how Gin’s commitment to ‘Simple over Easy’—rejecting reflection‑based injection, using a minimal routing language with a radix tree, zero‑allocation context pooling, and strict backward‑compatible API design—produced a high‑performance, maintainable Go web framework that now powers hundreds of thousands of projects.
GinGoRouting
0 likes · 11 min read

This guide introduces the high‑performance Go web framework Gin, outlines its eight key features—including routing groups, JSON validation, middleware support, and rendering—and provides step‑by‑step examples for routing, data binding, middleware, session handling, and validation to help developers quickly adopt Gin.
GinGoRendering
0 likes · 3 min read

Gin is a high‑performance, lightweight Go web framework that offers fast routing, flexible middleware, route groups, error handling, and built‑in support for JSON, XML and HTML, with simple installation and clear code examples demonstrating a basic server, grouped routes, custom middleware, and parameter handling.
Example CodeGinGo
0 likes · 9 min read

This article compares four popular Go web frameworks—Beego, Gin, Echo, and Iris—detailing their design inspirations, core features, routing and middleware mechanisms, module systems, and deployment practices, while providing step‑by‑step examples to help developers choose the best fit for their projects.
BeegoECHOGin
0 likes · 8 min read

The article shows how repetitive CRUD code in Gin can be refactored with Go 1.18 generics by defining a Creatable interface, writing a single generic CreateHandler, using factory functions and type constraints, and registering routes in one line, resulting in zero duplicate code and clearer responsibilities.
CRUDGORMGenerics
0 likes · 11 min read

This article introduces four widely used Go web frameworks—Gin, Beego, Echo, and Iris—providing concise overviews, key features such as routing, middleware, and data binding, and complete runnable code examples that help developers quickly evaluate and adopt the right framework for their projects.
BackendBeegoECHO
0 likes · 7 min read

Go’s concise syntax and strong concurrency make it a popular choice for web development, but its standard library lacks a full‑featured framework; this article compares five major Go web frameworks—Gin, Echo, Fiber, Beego, and Chi—detailing their use cases, features, pros, cons, and guidance on selecting the best fit for your project.
BeegoChiECHO
0 likes · 11 min read

This article presents a comprehensive, production‑grade error‑handling framework for Go services using Gin, covering error classification, unified response contracts, middleware ordering, stack trace management, high‑concurrency performance considerations, and practical code examples that integrate logging, tracing, retry, and circuit‑breaker strategies to improve observability and system stability.
GinGoerror handling
0 likes · 33 min read

This comprehensive guide walks through designing, implementing, and operating a production-grade Go microservice using Gin, covering architecture layers, domain modeling, reliable messaging, observability, CI/CD pipelines, GitOps deployment, high‑concurrency safeguards, security measures, and best‑practice testing to ensure stability, scalability, and maintainability in real‑world e‑commerce scenarios.
CI/CDGinGo
0 likes · 58 min read

The article walks through Gin 1.12's new features—including native BSON handling for MongoDB, type‑safe context error methods, custom binding for dates and enums, raw‑path routing, colored latency logs, and automatic Protobuf/JSON negotiation—showing practical code examples and upgrade recommendations for microservice development.
BSONContextGin
0 likes · 10 min read

Gin 1.12 introduces BSON support for direct MongoDB responses, enhanced context error handling, flexible custom binding, raw‑path routing, colored latency logs, and automatic Protobuf/JSON content negotiation, all demonstrated with practical Go code examples and performance tables.
BSONBindingContext
0 likes · 11 min read

This tutorial walks Go developers through building a production‑grade microservice with Gin, covering high‑performance routing, middleware, multi‑format rendering, unit and integration testing, and a complete Semaphore CI/CD pipeline for automated delivery.
BackendCI/CDGin
0 likes · 6 min read

This article introduces four widely used Go web frameworks—Gin, Beego, Echo, and Iris—explaining their main features such as routing, middleware, data binding, and session handling, and provides complete runnable code examples for each to help developers quickly get started.
BeegoECHOGin
0 likes · 7 min read

This article introduces four widely used Go web frameworks—Gin, Beego, Echo, and Iris—explaining their key features, routing styles, middleware handling, data binding, and rendering, and provides complete runnable code examples for each to help developers quickly build robust backend services.
BeegoECHOGin
0 likes · 8 min read

This article walks through the design and implementation of a production‑ready article interaction system—including likes, collections, and reads—using Go, Gin, Redis, MySQL, Kafka, and Vue, covering architecture, data modeling, high‑concurrency handling, idempotency, rate limiting, and reconciliation.
BackendGinKafka
0 likes · 9 min read

This article explains a SIGIR 2025 paper that tackles cold‑start click‑through‑rate prediction in JD's ad system by using a Graph Isomorphism Network‑based cohort modeling framework, detailing its three‑module architecture, extensive experiments on public and industrial datasets, and a live deployment that achieved a 2.13% CTR lift.
CTR predictionGinGraph Neural Network
0 likes · 9 min read

This article introduces four widely used Go web frameworks—Gin, Beego, Echo, and Iris—explaining their key features, routing styles, middleware support, and session handling, and provides complete runnable code examples for each to help developers quickly build robust web services.
BeegoECHOGin
0 likes · 7 min read

This tutorial shows Go developers how to create a Gin web application that supports automatic template hot‑reloading and dynamic multi‑theme switching, covering project structure, core template syntax, configuration, rendering logic, and deployment modes.
GinTemplateTheme Switching
0 likes · 10 min read

This guide walks you through building a Go microservice gateway using Consul for service discovery, Gin for routing, and Go‑Kit middleware, covering project structure, configuration loading, middleware composition, dynamic routing, common pitfalls, startup commands, and extensible features.
GinGo-Kitconsul
0 likes · 6 min read

This article explains how to build a high‑performance asynchronous logging system for Go web services using channels and middleware, covering both gRPC and Gin implementations, a log‑processing engine, performance‑tuning tips, and measured latency and CPU improvements.
ChannelsGinasynchronous logging
0 likes · 7 min read

This tutorial walks you through setting up a Go environment, initializing a project, and using the high‑performance Gin framework to create a complete RESTful API with CRUD operations, middleware for logging and authentication, error handling, project structure optimization, and deployment best practices.
CRUDGinGo
0 likes · 9 min read

This guide walks through two practical examples—creating a Docker image for Nginx with a custom HTML page and packaging a Go Gin‑based web service into a container—covering directory setup, Dockerfile creation, image building, container execution, and verification steps.
DockerDockerfileGin
0 likes · 8 min read

This article compares three Gin observability solutions—manual instrumentation, compile‑time injection, and eBPF automatic tracing—detailing setup steps, code examples, and a feature matrix to help developers choose the most suitable approach for cloud‑native Go applications.
GinGoOpenTelemetry
0 likes · 13 min read

This guide introduces the lightweight Gin framework for Go, outlines its key features, shows how to install and set up the environment, and provides complete code examples for building a basic web service with routing, middleware, JSON handling, and controller organization, culminating in a functional API demonstration.
APIGinGo
0 likes · 10 min read

This article reviews five leading Go frameworks and libraries—Gin, Beego, Echo, Buffalo, and GORM—detailing their core features, typical use cases, and reasons to choose each, helping developers select the most suitable tools for modern backend and full‑stack development in 2024.
BackendBeegoBuffalo
0 likes · 15 min read

This article walks through step‑by‑step how to create a simple CRUD service using Go's Gin framework with Gorm and MySQL, then shows the equivalent implementation with Java Spring Boot, MyBatis‑Plus and MySQL, comparing the two approaches and providing complete source code.
CRUDGORMGin
0 likes · 16 min read

This article explains the browser same‑origin policy, defines cross‑origin requests, details the CORS mechanism—including simple and non‑simple requests and their required HTTP headers—and provides practical Go examples using Gin middleware and Kubernetes to solve CORS issues.
BackendCORSCross-Origin
0 likes · 27 min read

This article compares the most popular Go web frameworks—Beego, Buffalo, Echo, Gin, Iris, and Revel—by popularity, learning curve, and core features, providing repository links and visual rankings to help developers choose the right tool for their projects.
BeegoGinGo
0 likes · 3 min read

This article thoroughly examines the Gin Go web framework, focusing on its compressed radix tree routing mechanism, middleware handling, request lifecycle, and performance‑optimizing techniques, providing code examples and best‑practice recommendations for building high‑throughput backend services.
Compressed Radix TreeGinGo
0 likes · 13 min read


21CTOAug 21, 2024 · Backend Development
This article explains Go's origins, naming, core advantages, and why it excels in backend and infrastructure, then reviews five major Go web frameworks—Gin, Beego, Revel, and Buffalo—detailing their strengths, weaknesses, and sample code to help developers choose the right tool.
BeegoGinWeb Frameworks
0 likes · 12 min read

This article compares five popular Go web frameworks—Gin, Echo, Beego, Revel, and Buffalo—detailing their strengths, weaknesses, and code examples to help developers select the most suitable tool for their project requirements and performance goals.
BeegoECHOGin
0 likes · 10 min read

This article walks through extending a simple Prometheus Exporter into a full-featured API monitoring solution using Gin-Vue-Admin, detailing backend task scheduling, database schema, multi-protocol checks (HTTP, TCP, DNS, ICMP), dynamic cron management, and frontend integration for managing and visualizing health metrics.
API monitoringBackendGin
0 likes · 18 min read

This tutorial introduces the Gin web framework for Go, covering its core features, installation steps, a simple "Hello World" example, request and response handling, parameter binding, route groups, middleware patterns, and useful utilities for building fast RESTful services.
GinGoRESTful API
0 likes · 13 min read

This guide demonstrates how to create a simple Go web API using the Gin framework, define a recipe data model, implement CRUD endpoints backed by MongoDB, add Redis caching for list queries, and provide a complete runnable example with testing scripts.
CRUDGinGo
0 likes · 14 min read

This article walks through creating a distributed instant‑messaging system in Go, covering the full tech stack, Docker‑based and local startup methods, configuration files, the end‑to‑end request flow, and detailed code examples for RPC, Redis queues, WebSocket delivery and the internal bucket architecture.
DockerGinIM
0 likes · 17 min read

This tutorial walks through installing Go, using the Go‑Gin framework, creating a simple cron‑enabled web service, building Docker images with and without multi‑stage builds, pushing them to a registry, deploying on a server, and comparing the final image size with an equivalent Koa implementation.
ContainerizationDockerGin
0 likes · 11 min read

This article explains how to design a unified business error‑code system for RESTful APIs, demonstrates the structure and format of such codes, provides a Go implementation with structs, interfaces and formatting methods, and shows practical usage in a Gin web server including logging and notification strategies.
BackendGinGo
0 likes · 22 min read

This article explains how to apply Dependency Injection in the Go Gin framework to separate routing logic from business services, reducing code coupling, improving testability, and enhancing reusability through concrete interface definitions, a simple DI container, and practical code examples.
BackendGinGo
0 likes · 6 min read

This article compares the Go web frameworks Echo and Gin, detailing their main features, performance, API design, middleware and routing capabilities, community support, and provides side‑by‑side code examples to help developers choose the most suitable framework for their projects.
ECHOGinGo
0 likes · 6 min read

This article explains why high‑concurrency systems need an asynchronous queue, walks through a producer‑consumer design implemented with Go and Gin, shows a complete code demo with configurable workers and capacity, and provides benchmark instructions to evaluate its performance.
BenchmarkEasyQueueGin
0 likes · 13 min read

This article explains Gin's Bind() method, detailing how it detects request content types, selects appropriate binders for JSON, form, and XML data, performs parsing and validation, handles errors, and provides a practical code example for Go web developers.
BINDBackendGin
0 likes · 7 min read

This article explores Gin's request and response converters, detailing their roles, classifications, and practical code examples to help Go developers efficiently handle data binding and rendering in high‑performance web services.
GinGoJSON Rendering
0 likes · 6 min read

Learn how to improve maintainability and scalability in Go web applications by using a layered architecture with explicit data‑conversion between controller, service, and data layers, illustrated through a Gin‑based user‑registration example and practical guidelines for organizing conversion logic.
Data Transfer ObjectGinGo
0 likes · 5 min read

This guide introduces the lightweight Gin framework for Go, covering its key features, installation steps, a complete first‑app example with code snippets, core concepts like Engine and Context, and showcases real‑world projects that leverage Gin for fast, scalable web services.
GinGoTutorial
0 likes · 8 min read

This guide explains the four common HTTP form content types, demonstrates how to retrieve form data with Gin's PostForm methods, shows step‑by‑step examples for single and multiple file uploads, enforces size and type restrictions, and covers route groups and custom 404 handling in Go.
File UploadForm HandlingGin
0 likes · 8 min read

This guide walks through the automatically generated Gin framework project, detailing the directory layout—including API, model, service, config, database, migrations, public assets, routers, runtime, and utils—while providing sample commands and code snippets that illustrate how to initialize, define interfaces, and perform CRUD operations with GORM.
GORMGinproject structure
0 likes · 6 min read


21CTOFeb 20, 2023 · Backend Development
This article explains why Go is ideal for high‑performance web services, clarifies API and REST concepts, outlines criteria for selecting a Go API framework, and reviews the five most popular Go REST frameworks—Gin, Echo, Gorilla Mux, Buffalo, and Goji—along with their strengths, weaknesses, and tips for monitoring and monetizing APIs.
BuffaloECHOGin
0 likes · 13 min read

This article introduces Ginrest, a Go 1.18 generic‑based library that streamlines the conversion of gRPC or other microservice functions into RESTful endpoints by providing request/response wrappers, unified error handling, and context utilities, dramatically reducing repetitive boilerplate code.
GinGoRESTful
0 likes · 9 min read

This guide walks through creating a phone‑number SMS verification login system in Go using Gin, Viper, and Tencent Cloud SMS, covering service registration, configuration loading, client implementation with functional options, code generation, sending, and Redis‑based verification.
BackendGinVerification
0 likes · 8 min read

This article revisits RESTful API design using Go Web, covering twelve practical guidelines such as JSON usage, verb‑free and pluralized paths, hierarchical resources, pagination, unified response formats, proper HTTP status codes, versioning, HTTPS, and documentation to help developers build clear, consistent, and secure APIs.
API DesignBackendGin
0 likes · 9 min read

This article provides a comprehensive analysis of Go's net/http library and the Gin framework, detailing request handling flow, router implementation, middleware chaining, and context management, while presenting key source code excerpts to illustrate how HTTP services are built and extended in Go.
ContextGinGo
0 likes · 18 min read

This comprehensive tutorial walks you through creating a complete web‑based blog using Go and the Gin framework for the backend, React for the frontend, PostgreSQL for persistent storage, JWT for authentication, and Docker for containerized deployment, covering code, configuration, and testing.
GinGoPostgreSQL
0 likes · 54 min read

After mastering Go's net/http and fasthttp client libraries, this article presents six distinct server‑side implementations—ranging from basic net/http handlers to Echo, Gin, and fasthttprouter—highlighting their syntax, readability, and configuration differences for rapid backend development.
BackendECHOGin
0 likes · 7 min read

This article explains what middleware is, why it’s used in Go projects, and demonstrates various implementations—including logging, authentication, method checks, and chaining—through clear code examples for both the standard net/http package and the Gin framework, helping developers enhance their backend services.
Code ExamplesGinHTTP
0 likes · 9 min read

This article introduces Go's Gin framework, compares its performance with other Go web frameworks, and walks through core features such as routing, middleware, data binding, and the underlying engine, providing code examples and visual diagrams for developers seeking efficient backend solutions.
BackendGinGo
0 likes · 7 min read

This article explains what Casbin is, how its PERM model works, and provides a step‑by‑step guide to integrate Casbin’s RBAC authorization into a Go project using Gin, Gorm, and a MySQL adapter, including model configuration, policy storage, middleware enforcement, and verification.
CasbinGORMGin
0 likes · 13 min read

The article explains the challenges of keeping interface model definitions synchronized between development and testing, compares code‑first and doc‑first approaches, introduces the Go‑based GinDoc library for generating Swagger documentation and client code from annotated routes, and provides step‑by‑step usage examples and integration tips.
API DocumentationDoc-firstGin
0 likes · 8 min read

This guide explains how to embed robust unit tests in Go backend services, outlines the AIR testing principles and common pitfalls, and demonstrates three practical mocking techniques—database stubs, interface‑based gomock, and runtime monkey‑patching—plus CI integration and coverage reporting.
CIGinGo
0 likes · 16 min read

This article provides a detailed examination of Gin's routing mechanism in Go, describing the internal prefix‑tree data structures, the algorithms for building and searching the tree, code walkthroughs of key functions such as addRoute and findWildcard, and case studies of typical and edge‑case route configurations.
GinGoPrefix Tree
0 likes · 21 min read

This guide walks you through the challenges of manual API documentation, introduces Swagger as a powerful solution, and provides a step‑by‑step tutorial for integrating Swagger with Go projects using the Swag tool, Gin framework, and custom UI enhancements.
API DocumentationGinGo
0 likes · 9 min read
