Awesome

English | 简体中文

</div>

sponge is a powerful Go development framework. Its core concept revolves around reverse-engineering modular code by parsing JSON, SQL, or Protobuf files. The generated code can be flexibly and seamlessly assembled into various types of complete backend services (similar to the characteristics of sponge cells, where disassembled sponge cells can automatically recombine into a new sponge). Sponge provides an all-in-one solution for project development, covering code generation, development, testing, API documentation, and deployment, significantly enhancing development efficiency, reducing complexity, and enabling high-quality projects with a "low-code approach".

Use Cases

Sponge is suitable for quickly developing various high-performance backend services, including but not limited to:

Web services (gin);
gRPC services;
HTTP+gRPC hybrid services;
gRPC Gateway API services.

Additionally, developers can use custom templates to generate various types of code to meet specific business needs.

Core Highlights

One-click generation of complete backend service code
For Web or 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.
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;
- Writing business logic code in the generated templates.
The framework code and CRUD API code are all automatically generated by sponge.
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;
- Configuration files;
- Test code;
- Build and deployment scripts, etc.

Quick Start

Install sponge

Sponge supports installation on Windows, macOS, and Linux. Click to view the sponge installation guide.
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:
 <img width="1500px" src="https://raw.githubusercontent.com/go-dev-frame/sponge/main/assets/en_sponge-ui.png"> 

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. Alternatively, you can run the UI service in Docker to support cross-host access. Click to view the guide on running the sponge UI service in Docker.

Sponge Generates the Code Framework

Sponge supports generating code using both built-in templates and custom templates, as shown in the diagrams below.

The code generation framework based on Sponge's built-in templates is shown below. There are two approaches: SQL and Protobuf.

The code generation framework based on custom templates is shown below. There are three approaches: JSON, SQL, and Protobuf.

Microservice framework

Sponge supports creating six types of backend services, all based on microservice architecture. The diagram below illustrates a typical layered microservice structure, featuring high performance, scalability, and built-in service governance capabilities.

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

grpc-server

Click to view the test code.

Key Features

Web framework gin
RPC framework grpc
Configuration parsing viper
Logging component zap
Database ORM component gorm, mongo-go-driver
Cache component go-redis, ristretto
Automated API documentation swagger, protoc-gen-openapiv2
Authentication jwt
Websocket gorilla/websocket
Crontab cron
Message Queue rabbitmq, kafka
Distributed Transaction Manager dtm
Distributed lock dlock
Parameter validation validator
Adaptive rate limiting ratelimit
Adaptive circuit breaking circuitbreaker
Distributed Tracing opentelemetry
Metrics monitoring prometheus, grafana
Service registration and discovery etcd, consul, nacos
Adaptive collecting profile
Resource statistics gopsutil
Configuration center nacos
Code quality checking golangci-lint
Continuous integration and deployment jenkins, docker, kubernetes
Generate project business architecture diagram spograph
Custom template generation code go template

Project Code Directory Structure

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

Here is the directory structure for the generated monolithic application single repository (monolith) or microservice multi-repository (multi-repo) code:

.
├── 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 business logic code.
│    ├── cache        # Cache directory wrapped around business logic.
│    ├── config       # Directory for Go structure configuration files.
│    ├── dao          # Data access directory.
│    ├── database     # database directory.
│    ├── 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 services, 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.

Here is the directory structure for the generated microservice monolithic repository (mono-repo) code (also known as large repository directory structure):

.
├── 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 Development Documentation

Click to view the detailed documentation for Sponge development project, including code generation, development, configuration, and deployment instructions, and more.

Examples of use

Examples of create services

Examples of develop complete project

Distributed transaction examples

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