translation: Translated all creational patterns category to Spanish (Task of issue #2277) (#2813)

* Typo corrections

* bridge pattern translated to spanish

* builder pattern translated to spanish

* context-object pattern translated to spanish

* converter pattern translated to spanish

* dependency injection pattern translated to spanish

* factory pattern translated to spanish

* factory-kit pattern translated to spanish

* factory-method pattern translated to spanish

* monostate pattern translated to spanish

* multiton pattern translated to spanish

* object mother pattern translated to spanish

* object pool pattern translated to spanish

* property pattern translated to spanish

* prototype pattern translated to spanish

* registry pattern translated to spanish

* step builder pattern translated to spanish

* value object pattern translated to spanish

* typo corrections and resources urls refactor

* grammar corrections

* Add image to each pattern

---------

Co-authored-by: luismateoh <luismateohm@gmail.com>
Co-authored-by: luis.hincapie <luis.hincapie@blankfactor.com>

localization/es/converter/README.md

@@ -0,0 +1,105 @@
+---
+title: Converter
+category: Creational
+language: es
+tag:
+  - Decoupling
+---
+
+## Propósito
+
+El propósito del patrón Conversor (Converter) es proporcionar una forma genérica y común de conversión bidireccional
+entre tipos correspondientes, permitiendo una implementación limpia en la que los tipos no
+tienen que conocerse entre sí. Además, el patrón Converter introduce la asignación bidireccional de colecciones
+bidireccional, reduciendo al mínimo el código repetitivo.
+
+## Explicación
+
+Ejemplo del mundo real
+
+> En las aplicaciones del mundo real, a menudo se da el caso de que la capa de base de datos consta de entidades que
+> necesitan ser mapeadas en DTO para su uso en la capa de lógica de negocio. Un mapeo similar se realiza para
+> potencialmente enorme cantidad de clases y necesitamos una forma genérica de lograrlo.
+
+En palabras sencillas
+
+> El patrón de conversión (Converter) facilita la asignación de instancias de una clase a instancias de otra clase.
+
+**Ejemplo programático**
+
+Necesitamos una solución genérica para el problema del mapeo. Para ello, introduzcamos un convertidor genérico.
+
+```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());
+  }
+}
+```
+
+Los convertidores especializados heredan de esta clase base de la siguiente manera.
+
+```java
+public class UserConverter extends Converter<UserDto, User> {
+
+  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());
+  }
+
+}
+```
+
+Ahora el mapeo entre `User` y `UserDto` se vuelve trivial.
+
+```java
+var userConverter = new UserConverter();
+var dtoUser = new UserDto("John", "Doe", true, "whatever[at]wherever.com");
+var user = userConverter.convertFromDto(dtoUser);
+```
+
+## Diagrama de Clases
+
+![alt text](./etc/converter.png "Converter Pattern")
+
+## Aplicabilidad
+
+Utilice el patrón de conversión en las siguientes situaciones:
+
+* Cuando tiene tipos que lógicamente se corresponden entre sí y necesita convertir entidades
+  entre ellos.
+* Cuando quieras proporcionar diferentes formas de conversión de tipos dependiendo del contexto.
+* Siempre que introduzca un DTO (Data transfer object), probablemente necesitará convertirlo en la
+  equivalencia de dominio.
+
+## Créditos
+
+* [Converter Pattern in Java 8](http://www.xsolve.pl/blog/converter-pattern-in-java-8/)