From 8f777cdc981877545194e513ac87f336f2e6fc00 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ilkka=20Sepp=C3=A4l=C3=A4?= Date: Sat, 6 Apr 2024 10:43:40 +0300 Subject: [PATCH] refactor: converter pattern docs and refactoring --- converter/README.md | 120 +++++++++++------- .../java/com/iluwatar/converter/User.java | 18 +-- .../com/iluwatar/converter/UserConverter.java | 5 +- .../java/com/iluwatar/converter/UserDto.java | 20 +-- .../java/com/iluwatar/converter/AppTest.java | 1 - .../com/iluwatar/converter/ConverterTest.java | 16 +-- 6 files changed, 87 insertions(+), 93 deletions(-) diff --git a/converter/README.md b/converter/README.md index f5d9921d5..aa782f37d 100644 --- a/converter/README.md +++ b/converter/README.md @@ -1,25 +1,27 @@ --- title: Converter -category: Creational +category: Structural language: en tag: - - Decoupling + - Compatibility + - Data transformation + - Object mapping --- +## Also known as + +* Mapper +* Translator + ## Intent -The purpose of the Converter pattern is to provide a generic, common way of bidirectional -conversion between corresponding types, allowing a clean implementation in which the types do not -need to be aware of each other. Moreover, the Converter pattern introduces bidirectional collection -mapping, reducing a boilerplate code to minimum. +The purpose of the Converter pattern is to provide a generic, common way of bidirectional conversion between corresponding types, allowing a clean implementation in which the types do not need to be aware of each other. Moreover, the Converter pattern introduces bidirectional collection mapping, reducing a boilerplate code to minimum. ## Explanation Real world example -> In real world applications it is often the case that database layer consists of entities that need -> to be mapped into DTOs for use on the business logic layer. Similar mapping is done for -> potentially huge amount of classes and we need a generic way to achieve this. +> In real world applications it is often the case that database layer consists of entities that need to be mapped into DTOs for use on the business logic layer. Similar mapping is done for potentially huge amount of classes, and we need a generic way to achieve this. In plain words @@ -27,35 +29,34 @@ In plain words **Programmatic Example** -We need a generic solution for the mapping problem. To achieve this, let's introduce a generic -converter. +We need a generic solution for the mapping problem. To achieve this, let's introduce a generic converter. ```java public class Converter { - private final Function fromDto; - private final Function fromEntity; + private final Function fromDto; + private final Function fromEntity; - public Converter(final Function fromDto, final Function fromEntity) { - this.fromDto = fromDto; - this.fromEntity = fromEntity; - } + public Converter(final Function fromDto, final Function fromEntity) { + this.fromDto = fromDto; + this.fromEntity = fromEntity; + } - public final U convertFromDto(final T dto) { - return fromDto.apply(dto); - } + public final U convertFromDto(final T dto) { + return fromDto.apply(dto); + } - public final T convertFromEntity(final U entity) { - return fromEntity.apply(entity); - } + public final T convertFromEntity(final U entity) { + return fromEntity.apply(entity); + } - public final List createFromDtos(final Collection dtos) { - return dtos.stream().map(this::convertFromDto).collect(Collectors.toList()); - } + public final List createFromDtos(final Collection dtos) { + return dtos.stream().map(this::convertFromDto).collect(Collectors.toList()); + } - public final List createFromEntities(final Collection entities) { - return entities.stream().map(this::convertFromEntity).collect(Collectors.toList()); - } + public final List createFromEntities(final Collection entities) { + return entities.stream().map(this::convertFromEntity).collect(Collectors.toList()); + } } ``` @@ -64,27 +65,26 @@ The specialized converters inherit from this base class as follows. ```java public class UserConverter extends Converter { - public UserConverter() { - super(UserConverter::convertToEntity, UserConverter::convertToDto); - } + public UserConverter() { + super(UserConverter::convertToEntity, UserConverter::convertToDto); + } - private static UserDto convertToDto(User user) { - return new UserDto(user.getFirstName(), user.getLastName(), user.isActive(), user.getUserId()); - } - - private static User convertToEntity(UserDto dto) { - return new User(dto.getFirstName(), dto.getLastName(), dto.isActive(), dto.getEmail()); - } + private static UserDto convertToDto(User user) { + return new UserDto(user.firstName(), user.lastName(), user.active(), user.userId()); + } + private static User convertToEntity(UserDto dto) { + return new User(dto.firstName(), dto.lastName(), dto.active(), dto.email()); + } } ``` Now mapping between `User` and `UserDto` becomes trivial. ```java -var userConverter = new UserConverter(); -var dtoUser = new UserDto("John", "Doe", true, "whatever[at]wherever.com"); -var user = userConverter.convertFromDto(dtoUser); +var userConverter=new UserConverter(); + var dtoUser=new UserDto("John","Doe",true,"whatever[at]wherever.com"); + var user=userConverter.convertFromDto(dtoUser); ``` ## Class diagram @@ -95,11 +95,37 @@ var user = userConverter.convertFromDto(dtoUser); Use the Converter Pattern in the following situations: -* When you have types that logically correspond with each other and you need to convert entities -between them. -* When you want to provide different ways of types conversions depending on the context. -* Whenever you introduce a DTO (Data transfer object), you will probably need to convert it into the -domain equivalence. +* When there are types that logically correspond with each other, and there is a need to convert between them. +* In applications that interact with external systems or services that require data in a specific format. +* For legacy systems integration where data models differ significantly from newer systems. +* When aiming to encapsulate conversion logic to promote single responsibility and cleaner code. + +## Known Uses + +* Data Transfer Objects (DTOs) conversions in multi-layered applications. +* Adapting third-party data structures or API responses to internal models. +* ORM (Object-Relational Mapping) frameworks for mapping between database records and domain objects. +* Microservices architecture for data exchange between different services. + +## Consequences + +Benefits: + +* Separation of Concerns: Encapsulates conversion logic in a single component, keeping the rest of the application unaware of the conversion details. +* Reusability: Converter components can be reused across the application or even in different applications. +* Flexibility: Makes it easy to add new conversions without impacting existing code, adhering to the [Open/Closed Principle](https://java-design-patterns.com/principles/#open-closed-principle). +* Interoperability: Facilitates communication between different systems or application layers by translating data formats. + +Trade-offs: + +* Overhead: Introducing converters can add complexity and potential performance overhead, especially in systems with numerous data formats. +* Duplication: There's a risk of duplicating model definitions if not carefully managed, leading to increased maintenance. + +## Related Patterns + +* [Adapter](https://java-design-patterns.com/patterns/adapter/): Similar in intent to adapting interfaces, but Converter focuses on data models. +* [Facade](https://java-design-patterns.com/patterns/facade/): Provides a simplified interface to a complex system, which might involve data conversion. +* [Strategy](https://java-design-patterns.com/patterns/strategy/): Converters can use different strategies for conversion, especially when multiple formats are involved. ## Credits diff --git a/converter/src/main/java/com/iluwatar/converter/User.java b/converter/src/main/java/com/iluwatar/converter/User.java index ab6a878cb..a8287af76 100644 --- a/converter/src/main/java/com/iluwatar/converter/User.java +++ b/converter/src/main/java/com/iluwatar/converter/User.java @@ -24,21 +24,7 @@ */ package com.iluwatar.converter; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.RequiredArgsConstructor; -import lombok.ToString; - /** - * User class. + * User record. */ -@ToString -@EqualsAndHashCode -@Getter -@RequiredArgsConstructor -public class User { - private final String firstName; - private final String lastName; - private final boolean active; - private final String userId; -} +public record User(String firstName, String lastName, boolean active, String userId) {} diff --git a/converter/src/main/java/com/iluwatar/converter/UserConverter.java b/converter/src/main/java/com/iluwatar/converter/UserConverter.java index 862b684ec..4ded63712 100644 --- a/converter/src/main/java/com/iluwatar/converter/UserConverter.java +++ b/converter/src/main/java/com/iluwatar/converter/UserConverter.java @@ -34,11 +34,10 @@ public class UserConverter extends Converter { } private static UserDto convertToDto(User user) { - return new UserDto(user.getFirstName(), user.getLastName(), user.isActive(), user.getUserId()); + return new UserDto(user.firstName(), user.lastName(), user.active(), user.userId()); } private static User convertToEntity(UserDto dto) { - return new User(dto.getFirstName(), dto.getLastName(), dto.isActive(), dto.getEmail()); + return new User(dto.firstName(), dto.lastName(), dto.active(), dto.email()); } - } diff --git a/converter/src/main/java/com/iluwatar/converter/UserDto.java b/converter/src/main/java/com/iluwatar/converter/UserDto.java index ba028ca9d..9703292b7 100644 --- a/converter/src/main/java/com/iluwatar/converter/UserDto.java +++ b/converter/src/main/java/com/iluwatar/converter/UserDto.java @@ -24,23 +24,7 @@ */ package com.iluwatar.converter; -import lombok.EqualsAndHashCode; -import lombok.Getter; -import lombok.RequiredArgsConstructor; -import lombok.ToString; - /** - * User DTO class. + * UserDto record. */ -@RequiredArgsConstructor -@Getter -@EqualsAndHashCode -@ToString -public class UserDto { - - private final String firstName; - private final String lastName; - private final boolean active; - private final String email; - -} +public record UserDto(String firstName, String lastName, boolean active, String email) {} diff --git a/converter/src/test/java/com/iluwatar/converter/AppTest.java b/converter/src/test/java/com/iluwatar/converter/AppTest.java index 164e8a9bb..c22a0e7d6 100644 --- a/converter/src/test/java/com/iluwatar/converter/AppTest.java +++ b/converter/src/test/java/com/iluwatar/converter/AppTest.java @@ -35,7 +35,6 @@ class AppTest { /** * Issue: Add at least one assertion to this test case. - * * Solution: Inserted assertion to check whether the execution of the main method in {@link App#main(String[])} * throws an exception. */ diff --git a/converter/src/test/java/com/iluwatar/converter/ConverterTest.java b/converter/src/test/java/com/iluwatar/converter/ConverterTest.java index df0b85736..d2f9c6a85 100644 --- a/converter/src/test/java/com/iluwatar/converter/ConverterTest.java +++ b/converter/src/test/java/com/iluwatar/converter/ConverterTest.java @@ -65,20 +65,20 @@ class ConverterTest { void testCustomConverter() { var converter = new Converter( userDto -> new User( - userDto.getFirstName(), - userDto.getLastName(), - userDto.isActive(), + userDto.firstName(), + userDto.lastName(), + userDto.active(), String.valueOf(new Random().nextInt()) ), user -> new UserDto( - user.getFirstName(), - user.getLastName(), - user.isActive(), - user.getFirstName().toLowerCase() + user.getLastName().toLowerCase() + "@whatever.com") + user.firstName(), + user.lastName(), + user.active(), + user.firstName().toLowerCase() + user.lastName().toLowerCase() + "@whatever.com") ); var u1 = new User("John", "Doe", false, "12324"); var userDto = converter.convertFromEntity(u1); - assertEquals("johndoe@whatever.com", userDto.getEmail()); + assertEquals("johndoe@whatever.com", userDto.email()); } /**