Completa la exposición sobre el patrón Factory

Author: sio2sio2

source/98.apendices/05.pattern.rst

@@ -73,6 +73,7 @@ de la traducción tendrá que implementar la siguiente interfaz:
 .. literalinclude:: files/Traductor.java
    :language: java
    :class: toggle
+   :caption: Interface Traductor
    :start-at: public interface
 
 en la que hemos supuesto que los datos los almacenamos en memoria en forma de
@@ -104,11 +105,81 @@ habrá más que hacer lo siguiente:
    traductor.escribir(System.out, data);
 
 Obsérvese que el código de ``TraductorFactory`` depende de qué clases
-traductoras hallamos creado realmente; y, si se crea una nueva (o se elimina una
+traductoras hayamos creado realmente; y, si se crea una nueva (o se elimina una
 ya creada por algún motivo), habrá que editar la clase para que se refleje este
 cambio. El siguiente apartado complica un poco la implementación, pero permite
 escribir una clase sin esta dependencia, de manera que podemos reaprovecharla,
 sea cual sea el caso.
 
 Automatización
 --------------
+La idea es evitar que tengamos que escribir y reescribir la clase que
+implementa el patrón Factory constantemente; y además crear un código que nos
+sirva en cualquier aplicación:
+
+.. literalinclude:: files/Factory.java
+   :language: java
+   :class: toggle
+   :caption: Clase Factory
+   :start-at: public class
+
+La principal diferencia (además de ser mucho más complicado que el anterior) es
+que esta clase sí se instancia con el constructor ``Factory(String packageName,
+Class<I> interfaceClass)`` para indicar en qué paquete se encuentran las clases
+que implementan la interfaz y cuál es esta. En el ejemplo de nuestros
+traductores:
+
+.. code-block:: java
+
+   Factory<Traductor> trFactory = new Factory<>("edu.acceso.ejemplo.traductor", Traductor.class);
+
+La creación de este objeto *Factory* provoca que gracias a la reflexión se
+analice el paquete y se localicen las clases que implementan la interfaz
+(``Traductor`` en este caso). El objetivo es relacionar estas clases con su
+nombre y, en su caso, con los nombres alternativos contenidos en el atributo
+``aliases``. Por ejemplo:
+
+.. code-block:: java
+
+   public class TYaml implements Traductor {
+      // También podría ser String si sólo hay una alternativa
+      private static final String[] = {"yml", "yaml"};
+
+      // Implementación de la traducción para YAML...
+   }
+
+
+Esta definición relacionaría las cadenas "`tyaml`", "`yml`" y "`yaml`" con la
+clase ``TYaml``, por lo que, cuando quisiéramos crear el objeto adecuado de
+traducción, nos bastaría con hacer:
+
+.. code-block:: java
+
+   String formato = "yml"; // Por ejemplo.
+
+   Factory<Traductor> trFactory = new Factory<>("edu.acceso.ejemplo.traductor", Traductor.class);
+   Traductor traductor = trFactory.getObject(formato);
+
+La clase tiene, además, dos métodos adicionales que sirven básicamente para
+brindar información:
+
+``getClasses()``
+   que devuelve un mapa en que las claves son las cadenas y los valores las
+   clases correspondientes.
+
+``getAliasesByClass()``
+   que devuelve un mapa en que cada clave es una clase y los valores un array
+   con todos los nombres con los que está relacionada.
+
+.. warning:: El ćodigo tiene una limitación: el constructor de las clases no
+   puede tener argumentos. En caso de que debiera tenerlos, no obstante, es
+   fácil soslayar la limitación: bastaría con incluir en la interfaz un método
+   inicializador. Por ejemplo:
+
+   .. code-block:: java
+
+      public interface Foobar {
+
+         public void initialize( /* Los argumentos que sea */ );
+         // Resto de métodos que definen la interfaz.
+      }

source/98.apendices/files/Factory.java

@@ -0,0 +1,130 @@
+package edu.acceso.almacenestudiantes.core;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
+import java.util.AbstractMap;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+import org.reflections.Reflections;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * Implementa el patrón Factory para escoger un objeto adecuado
+ */
+public class Factory<I> {
+    private static final Logger logger = LoggerFactory.getLogger(Factory.class);
+    private final static String alias = "alias";
+    /*
+     * Mapa cuyas claves son los nombres asociados a una clase
+     * que implementa la interfaz {@link I} y cuyos valores son las propias clases
+     * que implementan dicha interfaz.
+     */
+    private final Map<String, Class<? extends I>> classes;
+
+    /**
+     * Escanea un paquete para obtener clases.
+     * @param <I> El tipo de la interfaz.
+     * @param packageName El nombre del paquete.
+     * @param interfaceClass La interfaz que implementan todas las clases que se quieren encontrar.
+     */
+    public Factory(String packageName, Class<I> interfaceClass) {
+        Reflections reflections = new Reflections(packageName);
+
+        classes = reflections.getSubTypesOf(interfaceClass)
+            .stream()
+            .flatMap(clazz -> getAliases(clazz).stream().map(alias -> new AbstractMap.SimpleEntry<>(alias, clazz)))
+            .collect(Collectors.toMap(
+                Map.Entry::getKey,
+                Map.Entry::getValue,
+                (existing, replacement) -> existing,
+                HashMap::new
+            ));
+    }
+
+    /**
+     * Lista los nombres por los que se puede referir una clase (el propio nombre
+     * de la clase más todos los que contenga el atributo alias)
+     * @param clazz La clase que se inspecciona
+     * @return El listado de clases.
+     */
+    private static List<String> getAliases(Class<?> clazz) {
+        List<String> aliases = new ArrayList<>(List.of(clazz.getSimpleName()));
+
+        try {
+            Field field = clazz.getDeclaredField(alias);
+            if(!field.canAccess(null)) field.setAccessible(true);
+
+            Object value = field.get(null);
+
+            if(value instanceof String && !((String) value).isBlank()) {
+                aliases.add((String) value);
+            }
+            else if(value instanceof String[]) {
+                aliases.addAll(Arrays.asList((String[]) value));
+            }
+        }
+        catch(NoSuchFieldException | IllegalAccessException err) {}
+
+        return aliases.stream()
+            .filter(alias -> alias != null)
+            .map(alias -> alias.trim().toLowerCase())
+            .filter(alias -> !alias.isBlank())
+            .distinct()
+            .toList();
+    }
+
+    /**
+     * Obtiene el traductor.
+     * @param formato El formato en el que se quiere traducir.
+     * @return El objeto traductor.
+     */
+    @SuppressWarnings("null")
+    public I getObject(String formato) {
+        Class<? extends I> clazz = classes.get(formato.toLowerCase());
+
+        if(clazz == null) {
+            String formatos = classes.keySet().stream().collect(Collectors.joining("\n - "));
+            logger.error("'{}': Formato desconocido. Disponibles:\n - {}", formato, formatos);
+            System.exit(2);
+        }
+        try {
+            return clazz.getDeclaredConstructor().newInstance();
+        } catch (InstantiationException | IllegalAccessException | IllegalArgumentException | InvocationTargetException
+                | NoSuchMethodException | SecurityException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Obtiene un mapa que asocia cada clases con su lista de alias a partir del mapa que relaciona cada alias con su clase corrspondiente
+     * @param <T> El tipo de la interfaz
+     * @return Otro mapa en que cada clase está relacionada con todos los alias que tiene.
+     */
+    public Map<Class<? extends I>, String[]> getAliasesByClass() {
+        return classes.entrySet().stream()
+            .collect(Collectors.groupingBy(
+                Map.Entry::getValue,
+                Collectors.mapping(
+                    Map.Entry::getKey,
+                    Collectors.collectingAndThen(
+                        Collectors.toList(),
+                        list -> {
+                            Collections.sort(list);
+                            return list.toArray(String[]::new);
+                        }
+                    )
+                )
+            ));
+    }
+
+    public Map<String, Class<? extends I>> getClasses() {
+        return classes;
+    }
+}