sponge

README

English | 简体中文

Sponge is a powerful and easy-to-use Go development framework. Its core concept is to reverse-generate modular code by parsing SQL, Protobuf, and JSON files. These modular components can be flexibly combined into various types of complete backend services.

Sponge provides a one-stop project development solution. It covers code generation, development, testing, API documentation, and deployment, enabling developers to effortlessly build stable, reliable, and high-performance backend service systems (including RESTful API, gRPC, HTTP+gRPC, and gRPC Gateway, etc.) with a low-code approach.

Applicable Scenarios

Sponge is ideal for rapidly building various types of high-performance backend services. Applicable scenarios include:

• Developing RESTful API services
• Building microservices projects
• Cloud-native development
• Refactoring old projects
• Serving as a starting point for Go beginners or teams to learn Go project structure and best practices

In addition, developers can generate business-specific code by customizing templates.

Key Features

1. One-click generation of complete backend service code
   For Web, gRPC or HTTP+gRPC services that only require CRUD APIs, no Go code needs to be written. Simply connect to a database (e.g., MySQL, MongoDB, PostgreSQL, SQLite) to one-click generate complete backend service code and easily deploy it to Linux servers, Docker, or Kubernetes.

2. Efficient development of general-purpose services
   When developing general-purpose Web, gRPC, HTTP+gRPC, or gRPC Gateway services, you only need to focus on three aspects:

   • Defining database tables;
   • Defining API descriptions in Protobuf files;
   • In the generated templates, use built-in AI assistants or manually write business logic code.

   The framework code and CRUD API code are all automatically generated by sponge.

3. Support for custom templates, offering flexible extensibility
   Sponge supports generating various types of project-specific code using custom templates, not limited to the Go language. For example backend code, frontend code, test code, build and deployment scripts, etc.

4. Generate code on the page, simple and easy to use
   Sponge provides code generation on the page, avoiding complex command-line operations, simply filling in parameters on the page to generate code with one click.

5. Sponge and AI Assistant Collaborative Development to Form a Closed-Loop Workflow
   Sponge, combined with built-in AI assistants (DeepSeek, ChatGPT, Gemini), forms a complete and efficient development solution:

   • Sponge: Responsible for infrastructure code generation, including service framework, CRUD API, custom API (lacking business logic), etc.
   • AI assistant: Focuses on business logic implementation, including table structure DDL design, custom API design, business logic, etc.

Getting Started

1. Install sponge

   Sponge supports installation on Windows, macOS, Linux and Docker. Click to view the sponge installation guide.

2. Open the code generation UI

   After installation, run the following command to open the sponge UI:

   sponge run
   

   Access http://localhost:24631 in a local browser to generate code through the UI interface, as shown below:

   

   To access from a browser on a different host, specify the host IP or domain when starting the UI, e.g., sponge run -a http://your_host_ip:24631.

Components

Sponge has built-in rich components (for on-demand use):

Components	Examples
Web framework gin	gin example gin middleware examples
RPC framework gRPC	gRPC example gRPC interceptor examples
Configuration parsing viper	example
Logging zap	example
ORM gorm, mongo-go-driver	gorm example mongodb example
Cache go-redis, ristretto	go-redis example ristretto example
Automated API documentation swagger, protoc-gen-openapiv2	-
Authentication jwt	jwt example gin example gRPC example
Parameter validator, protoc-gen-validate	validator example protoc-gen-validate example
Websocket gorilla/websocket	example
SSE	example
Crontab cron	example
Message Queue rabbitmq, kafka	rabbitmq example kafka example
Distributed transaction manager dtm	dtm service discovery example dtm flash sale example
Distributed lock dlock	example
Adaptive rate limiting ratelimit	gin example gRPC example
Adaptive circuit breaking circuitbreaker	gin example gRPC example
Distributed tracing opentelemetry	gin example gRPC example cross-service tracing example
Metrics monitoring prometheus, grafana	gin example gRPC example web and gRPC monitor example
Service registration and discovery etcd, consul, nacos	service registration example service discovery example
Adaptive collecting profile	example
Resource statistics gopsutil	example
Configuration center nacos	example
Code quality checking golangci-lint	-
Continuous integration and deployment CI/CD kubernetes, docker, jenkins	example
Generate project business architecture diagram spograph	example
Custom template generation code go template	json example sql example protobuf example
AI assistant DeepSeek, ChatGPT, Gemini	example

Code Generation Engine

Sponge provides powerful code generation capabilities, supporting both built-in templates and custom templates to quickly generate the code required for your project. It also integrates an AI assistant to help generate business logic code.

1. Sponge generates a code framework based on built-in templates, as shown in the diagram below:

1. Sponge generates a code framework based on custom templates, as shown in the diagram below:

1. Sponge generates a business logic code framework based on functions and comments, as shown in the diagram below:

Microservice framework

Sponge is a modern Go microservice framework that adopts a typical layered microservice architecture. It comes with a rich set of built-in service governance features, enabling developers to quickly build and maintain complex microservice systems. The structure of the framework is shown in the diagram below:

Performance testing of http and grpc service code created by the microservices framework: 50 concurrent, 1 million total requests.

Click to view the test code.

Project Code Directory Structure

The project code directory structure created by sponge follows the project-layout.

Sponge supports creating three types of project code structures: Monolithic application monorepo (monolith), Microservices multi-repo (multi-repo), and Microservices monorepo (mono-repo).

1. The code directory structure for creating a Monolithic application monorepo (monolith) or Microservices multi-repo (multi-repo) is as follows:

   .
   ├── api            # Protobuf files and generated * pb.go directory
   ├── assets         # Store various static resources, such as images, markdown files, etc.
   ├── cmd            # Program entry directory
   ├── configs        # Directory for configuration files
   ├── deployments    # Bare metal, docker, k8s deployment script directory.
   ├── docs           # Directory for API interface Swagger documentation.
   ├── internal       # Directory for project internal code.
   │    ├── cache        # Cache directory wrapped around business logic.
   │    ├── config       # Directory for Go structure configuration files.
   │    ├── dao          # Data access directory.
   │    ├── database     # Directory for database initialization and migration.
   │    ├── ecode        # Directory for system error codes and custom business error codes.
   │    ├── handler      # Directory for implementing HTTP business functionality (specific to web services).
   │    ├── model        # Database model directory.
   │    ├── routers      # HTTP routing directory.
   │    ├── rpcclient    # Directory for client-side code that connects to grpc services.
   │    ├── server       # Directory for creating servers, including HTTP and grpc.
   │    ├── service      # Directory for implementing grpc business functionality (specific to grpc services).
   │    └── types        # Directory for defining request and response parameter structures for HTTP.
   ├── pkg            # Directory for shared libraries.
   ├── scripts        # Directory for scripts.
   ├── test           # Directory for scripts required for testing services  and test SQL.
   ├── third_party    # Directory for third-party protobuf files or external helper programs.
   ├── Makefile       # Develop, test, deploy related command sets .
   ├── go.mod         # Go module dependencies and version control file.
   └── go.sum         # Go module dependencies key and checksum file.
   

1. The code directory structure for creating a Microservices monorepo (mono-repo) (large repository code directory structure) is as follows:

   .
   ├── api
   │    ├── server1       # Protobuf files and generated *pb.go directory for service 1.
   │    ├── server2       # Protobuf files and generated *pb.go directory for service 2.
   │    ├── server3       # Protobuf files and generated *pb.go directory for service 3.
   │    └── ...
   ├── server1        # Code directory for Service 1, it has a similar structure to the microservice multi repo directory.
   ├── server2        # Code directory for Service 2, it has a similar structure to the microservice multi repo directory.
   ├── server3        # Code directory for Service 3, it has a similar structure to the microservice multi repo directory.
   ├── ...
   ├── third_party    # Third-party protobuf files.
   ├── go.mod         # Go module dependencies and version control file.
   └── go.sum         # Go module dependencies' checksums and hash keys.
   

Sponge Documentation

Click to view Sponge Documentation, which covers core content such as code generation, development process, system configuration and deployment plan in detail.

Examples

Sponge Create Server Code Examples

• Create web service based on sql (including CRUD)
• Create grpc service based on sql (including CRUD)
• Create web service based on protobuf
• Create grpc service based on protobuf
• Create grpc gateway service based on protobuf
• Create grpc+http service based on protobuf

Sponge+DTM Distributed Transaction Examples

• Simple distributed order system
• Flash sale
• E-Commerce system

Sponge+AI Assistant Collaborative Development Examples

• Home appliance retail management

Sponge Development Project Examples

• Community backend services
• Monolithic service split into microservices

If it's help to you, give it a star ⭐.

Documentation

Overview

Package sponge is a powerful Go development framework, it's easy to develop web and microservice projects. Repo: https://github.com/go-dev-frame/sponge Docs: https://go-sponge.com

Usage:

sponge [command]

Available Commands:

assistant   AI assistants, support generation and merging of Go code, chat, and more
completion  Generate the autocompletion script for the specified shell
config      Generate go config code from yaml file
graph       Draw a business architecture diagram based on the project created by sponge
help        Help about any command
init        Initialize sponge
merge       Merge the generated code into local go file
micro       Generate protobuf, model, cache, dao, service, grpc, grpc-gw, grpc+http, grpc-cli code
patch       Patch the generated code
plugins     Manage sponge dependency plugins
run         Run code generation engine service, generate code in UI interface
template    Generate code based on custom templates
upgrade     Upgrade sponge version
web         Generate model, cache, dao, handler, http code

Flags:

-h, --help      help for sponge
-v, --version   version for sponge

Use "sponge [command] --help" for more information about a command.