This project is a template for an enterprise-level backend application with Microservices Architecture using Java.
It serves as a practice project to demonstrate the implementation of microservices using modern Java and Spring Boot and follow some of the best practices in development.
- Automatic Audit Logs Recording: Uses Spring AOP to create Audit Events automatically whenever any API in any of the services are called and uses Kafka to send them to the Audit Service to be recorded, allowing the controllers to be clutter-free and simple.
- Clean and concise Restful API in all services: the API follows the modern best practices in Restful services recommendations like using ResponseEntity and returning ProblemDetails.
- CQRS: Command and Query Separation Principle to implement Business logic.
- ArchUnit: to validate architectural boundaries and verify adherence to best coding standards
- @RestControllerAdvice: to handle specific exceptions and return a unified and standard error response instead of an exception stack trace using Spring ProblemDetail.
- OpenAPI and Swagger Docs: to provide detailed documentation for all endpoints.
- Entity and DTO separation: decouples core business logic from presentation using request and response pojo.
- Core Entity and Jpa separation: core entities have no association with JPA and are never annotated with @Entity.
- Microservices
- Clean Architecture
- Clean Code
- Command-Query Responsibility Separation
- Solid Principles
- Loose Coupling of Components
- Spring Dependency Injection
- Aspect-Oriented Programming (AOP)
- Microservices Architecture.
- Automatic Audit Logs recording: Uses Spring AOP to automatically store audit logs.
- Robust Monitoring: Real-time monitoring with Grafana, Loki, and Tempo.
- Event-Driven Communication: Using Kafka.
- Centralized Logging & Tracing: Using Logback and Tempo.
- Database Migrations: Using Liquibase.
- Dockerized Deployment: Using Docker and Docker Compose.
- Discovery Server
- API Gateway
- Employee Service
- Audit Service
- Java 21
- Spring Boot
- Spring Cloud
- Eureka: Dynamic service registry.
- MySQL: Services data storage.
- MongoDB: Storage for Audit logs.
- Kafka: Event streaming for microservices.
- Docker
- Grafana, Loki, Tempo: Observability stack for metrics, logging, and tracing.
- JUnit & Mockito: Unit testing and Mocking.
- Swagger/OpenAPI: API documentation.
- Liquibase: Database Migrations.
- Lombok: Cleaner code with reduced boilerplate.
- Java 21
- Maven
- Docker & Docker Compose
-
Clone the Repository:
git clone https://github.com/arivan-amin/Clean-Microservices-Template.git cd Clean-Microservices-Template -
Build Core Module:
cd Core mvn clean install cd ..
-
Build and Package the Project:
mvn clean package
-
Set Environment Variables (Linux/MacOS):
export EUREKA_USER=admin export EUREKA_PASSWORD=admin
*(For Windows, use `set` command)* -
Run Services with Docker Compose:
docker compose up -d
-
Access the Services:
- API Gateway: http://localhost:8080
- Eureka Dashboard: http://localhost:8080/eureka/web
- Swagger UI: http://localhost:8080/swagger-ui.html
- Grafana Dashboard: http://localhost:3000/dashboards
-
Grafana Dashboard Setup:
- Import pre-built dashboard JSON configuration from
docker/grafana/folder.
- Import pre-built dashboard JSON configuration from
- Run Unit and Integration Tests:
mvn test
- Discovery Server: Dynamic service discovery and registry.
- API Gateway: Centralized entry point for routing and security.
- Core Module: Shared utilities and functionality.
- Employee Service: Manages employee data.
- Audit Service: Logs events and ensures compliance.
We welcome contributions! Fork the repository, create a new branch, and submit a pull request.
This project is licensed under the MIT License. See the LICENSE file for more details.
For questions or inquiries:
- Name: Arivan Amin
- Email: [email protected]