How zakariaalla/nice-equipe-football-api works
Project type and purpose
• This is a monolithic RESTful backend service (“Nice Equipe Football API”) built with Spring Boot.
• Purpose: expose endpoints to manage football teams (“équipes”), players, positions, and user authentication/authorization via JWT.
File structure
• Top-level artifacts:
• Dockerfile + docker-compose.yml – containerize the API + PostgreSQL.
• pom.xml – Maven build, Spring Boot dependencies (Web, Data JPA, Security, Validation, Test).
• src/main/java/com/francefootball/niceequipefootballapi:
• config (SwaggerConfig, security, AOP logging, DB initializer)
• controller (AuthenticationController, EquipeController, JoueurController, PositionController + exception handlers)
• metier (DTOs, enums, exceptions, service interfaces + implementations including AuthenticationService, EquipeService, JoueurService, JwtService)
• persistence (JPA entities, repositories)
• src/main/resources/config: profile-specific YAML files for dev/qualif/prod.
• src/test: unit and integration tests per layer.
README
• Tech stack: Java 21, Spring Boot 3.4.4, Spring Data JPA, Spring Security + JWT, Springdoc OpenAPI, PostgreSQL, H2 (tests), Lombok.
• Run modes: Docker Compose brings up API + Postgres; local via Maven with Spring profiles.
• Two public endpoints (GET équipes, GET positions); all others secured by JWT.
• Swagger UI at /nice-foot-api/swagger-ui/index.html, Postman collection included.
Main components
a. Clients
– HTTP clients (Postman, other front-ends)
– Swagger UI (web MVC UI served by Springdoc)
b. API Service (Spring Boot application)
– Security Layer: SecurityConfiguration, JwtAuthenticationFilter
– Logging Aspect: RequestResponseLoggingAspect
– API Layer: Controllers
– Business Layer: Service interfaces + implementations
– Data Layer: Spring Data JPA Repositories + Entities
– Config & Initialization: SwaggerConfig, DataInitializer, profile YAMLs
c. Database
– PostgreSQL container (jdbc:postgresql://…)
d. Infrastructure
– Docker Compose orchestrating API + DB
– Maven Wrapper for build
e. External systems
– (Optional) LDAP/OAuth if added later, monitoring, logging sinks
Relationships and data flow
1. Client → HTTP request → Spring Security filter chain (JwtAuthenticationFilter validates token)
2. Filter passes to Controller
3. Controller calls Service (business logic, validation via annotations)
4. Service calls Repository → Database (via JPA)
5. DataInitializer seeds DB at startup
6. Controller returns HTTP response → Client
7. Swagger UI endpoints served from the same app
Architectural patterns and principles
• Layered architecture (Web → Service → Repository)
• AOP for cross-cutting logging concerns
• Configuration by profiles (dev/qualif/prod)
• JWT stateless authentication
• DTOs to decouple API from persistence models
• Exception handlers for uniform error responses
Technologies & frameworks in context
• Spring Boot starters: Web (embedded Tomcat), Data JPA, Security, Validation, Test
• Springdoc OpenAPI for interactive docs
• jjwt for JWT token generation/validation
• Lombok to reduce boilerplate
• PostgreSQL in Docker, H2 in test scope
• Clearly labeled components and layers
• Call out environment/config profiles and initialization behavior