Now, let's move on to developing the `ExpenseController` class that will expose REST endpoints for our expense tracking application. This controller will handle HTTP requests and interact with the `ExpenseService` layer to perform CRUD operations. ### Implementing ExpenseController The `ExpenseController` class will be responsible for: - Handling HTTP requests and responses - Coordinating with the service layer - Validating request bodies - Managing exception handling Here's the implementation: ```java package com.example.expensetracker.controller; import com.example.expensetracker.dto.ExpenseDTO; import com.example.expensetracker.service.ExpenseService; import io.swagger.v3.oas.annotations.Operation; import io.swagger.v3.oas.annotations.Parameter; import io.swagger.v3.oas.annotations.responses.ApiResponse; import io.swagger.v3.oas.annotations.responses.ApiResponses; import io.swagger.v3.oas.annotations.tags.Tag; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.http.HttpStatus; import org.springframework.http.ResponseEntity; import org.springframework.validation.annotation.Validated; import org.springframework.web.bind.annotation.*; import org.springframework.web.servlet.support.ServletUriComponentsBuilder; import java.net.URI; import java.time.LocalDate; import java.util.List; @Tag(name = "Expense Controller", description = "REST endpoints for managing expenses") @RestController @CrossOrigin(origins = "http://localhost:3000") @RequestMapping("/api/expenses") public class ExpenseController { private final ExpenseService expenseService; @Autowired public ExpenseController(ExpenseService expenseService) { this.expenseService = expenseService; } @Operation(summary = "Create a new expense") @ApiResponses(value = { @ApiResponse(responseCode = "201", description = "Expense created successfully"), @ApiResponse(responseCode = "400", description = "Invalid request data") }) @PostMapping public ResponseEntity createExpense( @Parameter(description = "Expense data to be created") @Valid @RequestBody ExpenseDTO expenseDTO) { ExpenseDTO createdExpense = expenseService.saveExpense(expenseDTO); URI location = ServletUriComponentsBuilder .fromCurrentRequest() .path("/{id}") .buildAndExpand(createdExpense.getId()) .toUri(); return ResponseEntity.status(HttpStatus.CREATED) .location(location) .body(createdExpense); } @Operation(summary = "Get all expenses") @ApiResponse(responseCode = "200", description = "List of all expenses") @GetMapping public ResponseEntity> getAllExpenses() { List expenses = expenseService.getAllExpenses(); return ResponseEntity.ok(expenses); } @Operation(summary = "Get expenses by category ID") @ApiResponses(value = { @ApiResponse(responseCode = "200", description = "Expenses for category found"), @ApiResponse(responseCode = "404", description = "No expenses found for category") }) @GetMapping("/category/{categoryId}") public ResponseEntity> getExpensesByCategory( @Parameter(description = "Category ID to filter expenses") @PathVariable Long categoryId) { List expenses = expenseService.getExpensesByCategoryId(categoryId); return ResponseEntity.ok(expenses); } @Operation(summary = "Get expenses within a date range") @ApiResponse(responseCode = "200", description = "Expenses within the specified date range") @GetMapping("/date-range") public ResponseEntity> getExpensesByDateRange( @Parameter(description = "Start date of the range") @RequestParam LocalDate startDate, @Parameter(description = "End date of the range") @RequestParam LocalDate endDate) { List expenses = expenseService.getExpensesByDateRange(startDate, endDate); return ResponseEntity.ok(expenses); } @Operation(summary = "Get total expenses for a category") @ApiResponse(responseCode = "200", description = "Total expenses for category found") @GetMapping("/total/category/{categoryId}") public ResponseEntity getTotalExpensesByCategory( @Parameter(description = "Category ID to get total expenses") @PathVariable Long categoryId) { BigDecimal totalAmount = expenseService.getTotalExpensesByCategoryId(categoryId); return ResponseEntity.ok(totalAmount); } @Operation(summary = "Update an existing expense") @ApiResponses(value = { @ApiResponse(responseCode = "200", description = "Expense updated successfully"), @ApiResponse(responseCode = "404", description = "Expense not found") }) @PutMapping("/{id}") public ResponseEntity updateExpense( @Parameter(description = "ID of the expense to update") @PathVariable Long id, @Parameter(description = "Updated expense data") @Valid @RequestBody ExpenseDTO expenseDTO) { ExpenseDTO updatedExpense = expenseService.updateExpense(id, expenseDTO); return ResponseEntity.ok(updatedExpense); } @Operation(summary = "Delete an expense") @ApiResponses(value = { @ApiResponse(responseCode = "204", description = "Expense deleted successfully"), @ApiResponse(responseCode = "404", description = "Expense not found") }) @DeleteMapping("/{id}") public ResponseEntity deleteExpense( @Parameter(description = "ID of the expense to delete") @PathVariable Long id) { expenseService.deleteExpense(id); return ResponseEntity.noContent().build(); } } ``` ### Key Features and Best Practices 1. **RESTful Endpoints**: - **POST /api/expenses**: Creates a new expense - **GET /api/expenses**: Retrieves all expenses - **GET /api/expenses/category/{categoryId}**: Gets expenses by category ID - **GET /api/expenses/date-range**: Fetches expenses within a date range - **GET /api/expenses/total/category/{categoryId}**: Returns total expenses for a category - **PUT /api/expenses/{id}**: Updates an existing expense - **DELETE /api/expenses/{id}**: Deletes an expense 2. **Validation**: - Uses `@Valid` annotation on request bodies to ensure data integrity - Performs category ID validation through the service layer 3. **Response Entity**: - Returns appropriate HTTP status codes (201, 200, 404, 204) - Includes location header for newly created resources 4. **Swagger Documentation**: - Uses Swagger annotations for API documentation - Provides clear descriptions of endpoints and expected responses 5. **Cross-Origin Resource Sharing (CORS)**: - Enabled for development purposes with `@CrossOrigin` ### Next Steps 1. **Implement Exception Handling**: - Create global exception handlers using `@ControllerAdvice` - Handle specific exceptions and return appropriate error responses 2. **Develop the UI Layer**: - Create HTML templates for adding and viewing expenses - Implement form validation on the client side - Use JavaScript to make API calls to the backend 3. **Add Logging**: - Implement logging in both service and controller layers - Use Spring Boot's built-in logging capabilities ### What to Read More About - [Spring Web MVC Documentation](https://docs.spring.io/spring-framework/docs/current/reference/html/web.html) - [Swagger OpenAPI Documentation](https://springdoc.github.io/springdoc-openapi-webmvc-core/) - [HTTP Status Codes](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status) - [Cross-Origin Resource Sharing (CORS)](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) This controller implementation provides a robust API layer for our expense tracking application. It follows RESTful principles, includes proper validation, and provides clear documentation through Swagger annotations. The next step is to implement the user interface that will interact with these endpoints.