iluwatar#590 Add explanation for Converter pattern

converter/README.md

@@ -17,6 +17,71 @@ mapping, reducing a boilerplate code to minimum.
 
 ![alt text](./etc/converter.png "Converter Pattern")
 
+## 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 plain words
+
+> Converter pattern makes it easy to map instances of one class into instances of another class.
+
+**Programmatic Example**
+
+We need a generic solution for the mapping problem. To achieve this, let's introduce a generic converter.
+
+```java
+public class Converter<T, U> {
+
+  private final Function<T, U> fromDto;
+  private final Function<U, T> fromEntity;
+
+  public Converter(final Function<T, U> fromDto, final Function<U, T> fromEntity) {
+    this.fromDto = fromDto;
+    this.fromEntity = fromEntity;
+  }
+
+  public final U convertFromDto(final T dto) {
+    return fromDto.apply(dto);
+  }
+
+  public final T convertFromEntity(final U entity) {
+    return fromEntity.apply(entity);
+  }
+
+  public final List<U> createFromDtos(final Collection<T> dtos) {
+    return dtos.stream().map(this::convertFromDto).collect(Collectors.toList());
+  }
+
+  public final List<T> createFromEntities(final Collection<U> entities) {
+    return entities.stream().map(this::convertFromEntity).collect(Collectors.toList());
+  }
+}
+```
+
+The specialized converters inherit from this base class as follows.
+
+```java
+public class UserConverter extends Converter<UserDto, User> {
+
+  public UserConverter() {
+    super(userDto -> new User(userDto.getFirstName(), userDto.getLastName(), userDto.isActive(),
+            userDto.getEmail()),
+        user -> new UserDto(user.getFirstName(), user.getLastName(), user.isActive(),
+            user.getUserId()));
+  }
+}
+```
+
+Now mapping between User and UserDto becomes trivial.
+
+```java
+Converter<UserDto, User> userConverter = new UserConverter();
+UserDto dtoUser = new UserDto("John", "Doe", true, "whatever[at]wherever.com");
+User user = userConverter.convertFromDto(dtoUser);
+```
+
 ## Applicability
 Use the Converter Pattern in the following situations: