/goframe-v2

Dependency Injection Example

Introduction

This example demonstrates how to implement dependency injection in a GoFrame application.

Key demonstrations:

1. Using monorepo pattern for code repository management
2. Basic dependency injection setup
3. Service layer implementation with DI
4. Controller layer integration with gRPC
5. Unit testing with mock dependencies

The implementation focuses on making core business logic easily testable:

• Separation of concerns using dependency injection
• Clear interfaces for service dependencies
• Independent unit testing for each layer to ensure code quality

Requirements

• Go 1.22 or higher
• Git
• GoFrame
• MongoDB
• Redis
• github.com/samber/do

Directory Structure

injection/
├── app/
│   ├── gateway/         # API Gateway service, calls user gRPC service for external interfaces
│   │   ├── api/         # API definitions
│   │   ├── internal/    # Internal implementations
│   │   │   ├── cmd/         # Command line tools
│   │   │   ├── controller/  # Controllers
│   │   │   ├── model/       # Data models
│   │   │   └── service/     # Business logic
│   │   └── manifest/   # Configuration files
│   └── user/           # User service
│       ├── api/        # API definitions
│       │   ├── entity/ # Entity definitions
│       │   └── user/   # User API proto
│       ├── internal/   # Internal implementations
│       │   ├── cmd/         # Command line tools
│       │   ├── controller/  # Controllers with DI
│       │   ├── dao/         # Data Access Objects
│       │   ├── model/       # Data models
│       │   └── service/     # Business logic with DI
│       └── manifest/   # Configuration files
├── hack/               # Development tools
└── utility/            # Common utilities
    ├── injection/      # DI utilities
    └── mongohelper/    # MongoDB helper tools

Features

• Dependency injection usage
• MongoDB and Redis integration
• gRPC service implementation
• Complete unit testing
• Resource cleanup handling
• Named dependency support

Installation

1. Clone the repository:

   git clone https://github.com/gogf/examples.git
   cd examples/practices/injection

2. Install dependencies:

   go mod tidy

3. Start required services using Docker:

   # Start MongoDB
   docker run -d --name mongo -p 27017:27017 mongo:latest
   
   # Start Redis
   docker run -d --name redis -p 6379:6379 redis:latest

Usage

1. Run the gRPC Server service:

   cd examples/practices/injection/app/user
   go run main.go server

2. Run the HTTP Server service:

   cd examples/practices/injection/app/gateway
   go run main.go server

3. (Optional) Run async worker, only demonstrates multi-command functionality, no actual logic:

   cd examples/practices/injection/app/gateway
   go run main.go worker

4. (Optional) Run tests:

   go test ./...

Implementation Details

Dependency Injection Setup

• Using github.com/samber/do package for dependency management
• Support for named and unnamed dependency management
• Helper functions for common operations

Service Layer

• Clear separation of concerns
• Interface-based design
• Easy to test with mock implementations

Controller Layer

• gRPC integration with DI support
• Clear error handling
• Proper resource management

Testability

• Complete unit tests for data layer (dao), service layer (service), and interface layer (controller)
• Mock dependencies, database configuration for unit tests managed through manifest/config
• Service addresses or domains for microservice connections managed through configuration files for easy service mocking

Important Notes

• Properly clean up resources in the Shutdown method when registering dependency injection
• Use named dependencies when multiple instances of the same type are needed in dependency injection