Introducing Go‑Spring: A Spring‑like Application Framework for Go

Go‑Spring is a Go language application framework that imitates the Java Spring ecosystem (Spring Framework, Spring Boot, Spring Cloud). It follows the principle of "convention over configuration" and provides features such as dependency injection, auto‑configuration, out‑of‑the‑box components, and rich third‑party library integration, helping developers reduce boilerplate code.

Background: The author’s team switched from a PHP+Java stack to Golang+Java, found Golang’s syntax unfamiliar and missed a mature development framework. After exploring, they realized that a Spring‑like solution could be built for Go, leading to the creation of Go‑Spring.

Key technical comparison: Java’s bytecode, reflection, annotations, and package scanning enable Spring’s core capabilities (AOP, DI, declarative transactions, module auto‑loading). Golang lacks bytecode (so no native AOP) but offers tags, reflection, init functions, and imports, which can be used to implement DI and module auto‑loading. Middleware can replace AOP functionality.

Features of Go‑Spring (five major points):

▍ Extensible starter framework for elegant code organization

The starter framework encapsulates long initialization functions into separate files, improving readability and cohesion. Images illustrate a typical RTMP server start‑up function and its refactored version.

▍ Interface‑based design + dependency injection for flexible implementation swapping

Go‑Spring provides a unified API for services such as Redis, allowing developers to switch underlying implementations with a single line of code. Diagrams show the registration of Redis services and the ease of swapping implementations.

▍ Automatic configuration binding

Variables can be bound to configuration items by name; Go‑Spring automatically loads the values from configuration files. It also supports environment‑specific configuration files (e.g., application-test.properties for testing, application-online.properties for production).

▍ Effective dependency management

Each module exposes an abstract interface, isolating users from implementation details and simplifying dependency upgrades. Go‑Spring guarantees consistent dependency versions across releases.

▍ Simplified unit testing

Projects built with Go‑Spring can run real HTTP servers during tests, avoiding mocks or fakes. This enables full‑stack testing with break‑point debugging.

Modules: Go‑Spring consists of four core projects – go-spring (IoC container and DI), go-spring-boot (auto‑configuration and application start‑up), go-spring-cloud (microservice framework), and go-spring-didi (internal Didi microservice extensions).

Example tutorial: The article walks through creating a simple HTTP service using Go‑Spring:

Create main.go and specify the configuration directory.

Import the Echo HTTP server.

Create example.go with a controller and register routes in InitController() .

Register the example service in the IoC container.

Import the example package in main.go so the framework loads it at start‑up.

Running go run main.go starts the service, which can be tested with curl http://localhost:8080/ . The response is shown as a JSON error object:

{"code":900001,"msg":"biz error"}

Unit testing steps are also demonstrated: a TestMain function launches a real HTTP server, and test functions send actual requests without mocks.

Summary: Beyond HTTP services and unit tests, Go‑Spring already supports MySQL, Redis, Kafka, DDMQ, service registration/discovery, and various RPC protocols. New components are continuously added, making Go‑Spring a comprehensive and evolving backend solution.

Final note: The author views Go‑Spring as a new programming paradigm that boosts productivity and encourages developers to enjoy coding while freeing time for personal life.