The project is a currency conversion API based on Spring Boot. It utilizes Domain-Driven Design (DDD) to structure the code, facilitating system maintenance and scalability.
- Provide an API for currency conversion.
- Use software design best practices, such as DDD, to ensure modular and easily extensible code.
The project's architecture is divided into several layers, each with specific responsibilities:
-
Presentation Layer:
- Responsible for handling HTTP requests and returning responses.
- Implemented using Spring Boot controllers.
-
Application Layer:
- Contains the system's use cases.
- Orchestrates application logic but does not contain business logic.
-
Domain Layer:
- The heart of the system, containing business rules and core logic.
- Includes entities, aggregates, repositories, and domain services.
-
Infrastructure Layer:
- Handles data persistence, integration with external services, and other technical concerns.
- Contains repository implementations and database configurations.
Controlador (Controller)
/**
* Controller responsible for currency conversion operations.
* Provides endpoints for converting values between different currencies.
*/
@RestController
@RequestMapping("/api/v1/conversions")
@Api(value = "Currency Conversion Controller", description = "Currency conversion operations")
public class CurrencyConversionController {
@Autowired
private CurrencyConversionService currencyConversionService;
/**
* Converts the source currency to the target currency.
*
* @param source The source currency. Example: USD.
* @param target The target currency. Example: BRL.
* @param amount The amount to be converted. Example: 100.0.
* @return A {@link CurrencyConversionDTO} containing the conversion details.
* @throws BusinessException
*/
@GetMapping("/convert")
@ApiOperation(value = "Converts the source currency to the target currency", notes = "Returns the currency conversion details")
@ApiResponses(value = {
@ApiResponse(code = 200, message = "Successful operation", response = CurrencyConversionDTO.class),
@ApiResponse(code = 400, message = "Invalid input")
})
public CurrencyConversionDTO convertCurrency(
@RequestParam @ApiParam(value = "Source currency", example = "USD") Currency source,
@RequestParam @ApiParam(value = "Target currency", example = "BRL") Currency target,
@RequestParam @ApiParam(value = "Amount to be converted", example = "100.0") double amount) throws BusinessException {
return currencyConversionService.convertCurrency(source, target, amount);
}
}Application Service
@Service
public class CurrencyConversionService {
@Autowired
private CurrencyConversionDomainService domainService;
public CurrencyConversionDTO convert(String source, String target, double amount) {
return domainService.convert(source, target, amount);
}
}Domain Entity
@Entity
@Table(name = "CURRENCY_CONVERSIONS")
public class CurrencyConversion {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
@Enumerated(EnumType.STRING)
@Column(name = "source_currency")
private Currency sourceCurrency;
@Enumerated(EnumType.STRING)
@Column(name = "target_currency")
private Currency targetCurrency;
@Column(name = "conversion_rate")
private double conversionRate;
@Column(name = "query_date")
private LocalDateTime queryDate;
public CurrencyConversion(Currency sourceCurrency, Currency targetCurrency, double conversionRate, LocalDateTime queryDate) {
this.sourceCurrency = sourceCurrency;
this.targetCurrency = targetCurrency;
this.conversionRate = conversionRate;
this.queryDate = queryDate;
}
}Repository
public interface CurrencyConversionRepository extends JpaRepository<CurrencyConversion, Long> {
}Database Configuration
spring:
datasource:
url: jdbc:h2:mem:testdb
driverClassName: org.h2.Driver
username: sa
password: password
h2:
console:
enabled: true
jpa:
hibernate:
ddl-auto: update
show-sql: true
The architecture of this project is designed to be modular and scalable, using DDD practices to organize and structure the code. This approach facilitates system maintenance and allows new features to be added efficiently and in an orderly manner.
- Overview: Presentation of the project, highlighting its purpose and the context in which it is embedded.
- Project Objectives: Enumeration of the main objectives that the project aims to achieve.
- Scope and Functionalities: Description of the main functionalities offered by the project and its scope of operation.
- Initial Configurations: Steps required to set up the development or production environment.
- Installation Instructions: Detailed procedures for installing the project in different environments.
- Docker Configuration: Specifications on how to configure and use Docker for the project.
- Folder Structure: Description of the organization of the project directories.
- Project Architecture.
- Development Flow: Description of the development process adopted, including planning, coding, and review stages.
- Apache Camel Integration: Guide on integrating Apache Camel into the project, including configuration and usage.
- Contributors and Authors: Recognition of the contributors to the project.
- Contributions: Guidelines on how to contribute to the project, including code standards and pull request requirements, tips and best practices.
- Code of Conduct: Behavioral guidelines expected for the project community.
- OpenAPI Specification: Details about the OpenAPI specification used to document the API endpoints.
- API Documentation with Swagger: Information on how to access and use the interactive API documentation generated by Swagger.
- Javadoc Documentation: Information on the Javadoc documentation generated for the project.
- Endpoint Description: Details of the available API endpoints, including methods, parameters, and usage examples.
- Database Management: Strategies and practices for efficient management of the database used by the project.
- Testing Strategies: Approach and methods used to test the software, including unit, integration, and E2E tests.
- Testing Tools: Description of the testing tools used in the project and how to configure them.
- CI/CD Pipeline: Explanation of the continuous integration and delivery pipeline, detailing each stage and its function.
- Automations and Artifact Generation: Description of the automations incorporated into the CI/CD, including documentation generation and build artifacts.
- .gitignore, .editorconfig and project.properties: Utility of these files to maintain code consistency and quality.
- Maven Wrapper and application.properties: Explanation of how these files help standardize the development environment.
- .env File and Travis CI Settings: Use of these files to configure the environment and CI integrations.
- Code Standards and Security: Guidelines for maintaining code quality and security.
- Monitoring and Logging Practices: Recommended techniques for monitoring and logging in the project.
- Licensing: Information about the rights and restrictions associated with the use of the software.
- Terms of Use: Information about the terms and conditions for using the software.
- Future Plans: Discussion on functionalities and improvements considered for future versions of the project.
- Improvement Proposals: Space for the community to suggest and debate improvements and innovations.
- External Links and References: Additional resources and external documentation relevant to the project.
- Security Policy: Details on the supported versions, reporting vulnerabilities, and general security practices.