Añade epígrafe sobre patrones de diseño

Author: sio2sio2

source/01.archivos/01.gestion.rst

@@ -48,14 +48,15 @@ Para acceder a las variables de entorno, *Java* dispone del método estático\
       Map<String, String> entorno = System.getenv();
       entorno.get("HOME");  // /home/usuario, de nuevo.
 
-El **problema** crucial de consultar las variables de entorno es el de que el
-nombre cambia entre los distintos sistemas operativos\ [#]_ y, por tanto, si nos
-limitamos a usarlas tal como acabamos de ver, nuestra aplicación será
-dependiente del sistema en que se ejecute.
+El **problema** de consultar variables de entorno es que su existencia y sus
+nombres dependen del sistema operativo\ [#]_, por lo que, si nos limitamos a
+usarlas como acabamos de ver, la aplicación será dependiente del
+sistema sobre el que se ejecute e incumpliremos nuestro propósito de
+independizar la aplicación de la plataforma.
 
 .. _system-properties:
 
-Una alternativa es consultar las propiedades de nuestro entorno de *Java*,
+Una *alternativa* es consultar las propiedades de nuestro entorno de *Java*,
 algunas de las cuales recogen los valores de las variables de entorno:
 
 ``System.getProperty(String nombre_propiedad)``
@@ -240,6 +241,18 @@ podemos hacer construcciones como esta:
 .. attention:: Con estas herramientas sólo construimos rutas, así que tales rutas
    no tienen por qué existir.
 
+.. admonition:: Conclusión
+
+   Debemos siempre independizar el código de la plataforma subyacente para lo
+   cual debemos:
+
+   a. Construir las rutas con las herramientas proporcionadas por *Java*.
+   #. Intentar utilizar las :ref:`propiedades del sistema
+      <system-properties>` para resolver las particularidades.
+   #. En caso de no que no baste con ellas será necesario obtener la plataforma\
+      [#]_ y crear código condicional que implemente la solución dependiendo
+      cuál sea.
+
 .. _file.files:
 
 Gestión
@@ -321,10 +334,10 @@ dentro de él. Los dos últimos argumentos son opcionales.
 
 Manipulación
 ------------
-Por manipulación entendemos, simplemente, la copia y traslado de archivos o el
-cambio de sus propiedades (permisos, propietarios, etc) y no la alteración del
-contenido, que reservamos para el :ref:`próximo epígrafe sobre manipulación
-<manipulacion-archivos>`.
+Por :dfn:`manipulación` entendemos, simplemente, la copia y traslado de archivos
+o el cambio de sus propiedades (permisos, propietarios, etc) y no la alteración
+del contenido, que reservamos para el :ref:`próximo epígrafe sobre manipulación
+de contenidos <manipulacion-archivos>`.
 
 Para **crear** un archivo:
 
@@ -333,7 +346,7 @@ Para **crear** un archivo:
    Files.createFile(home.resolve("caca.txt"));
 
 lo que creará el archivo vacío :file:`caca.txt` dentro de nuestro directorio
-natural con los permisos que determine la máscara del sistema. Podríamos haber
+personal con los permisos que determine la máscara del sistema. Podríamos haber
 definido otros permisos, pero para ello tendríamos que haber incluido argumentos
 adicionales (véase :java-nio:`FileAttribute <attribute/FileAttribute>`), pero no
 entraremos en tanto detalle. También existe ``Files.createDirectory(Path dir)``
@@ -345,9 +358,9 @@ Podemos también copiar, mover o borrar archivos:
 
    Path tmp = Path.of(System.getProperty("java.io.tmpdir"));
    Path caca = home.resolve("caca.txt");
-   Files.copy(caca, tmp.resolve("caca.txt")); // Copia en /tmp/kk.txt
-   Files.move(caca, tmp.resolve("caca.txt")); // Error, el destino ya existe.
-   Files.move(caca, tmp.resolve("caca.txt"), StandardCopyOption.REPLACE_EXISTING);
+   Files.copy(caca, tmp.resolve("kk.txt")); // Copia en /tmp/kk.txt
+   Files.move(caca, tmp.resolve("kk.txt")); // Error, el destino ya existe.
+   Files.move(caca, tmp.resolve("kk.txt"), StandardCopyOption.REPLACE_EXISTING);
    Files.delete(caca);
 
 .. tip:: También se pueden copiar flujos (:java-io:`InputStream <InputStream>`)
@@ -360,7 +373,8 @@ contenido, pero los dejamos para el siguiente epígrafe.
 
 .. caution:: A diferencia de lo que ocurre al usar en una terminal las órdenes
    :ref:`cp <linux:cp>` o :ref:`mv <linux:mv>`, no basta con poner el directorio
-   de destino, cuando queremos conservar el nombre original.
+   de destino, aunque queramos conservar el nombre original: siempre debe
+   escribirse la ruta completa, incluido el nombre del archivo de destino.
 
 .. warning:: Por supuesto, estas acciones pueden generar excepciones (p.ej. al
    intentar crear un archivo dentro de un directorio en el que no tenemos
@@ -377,6 +391,9 @@ contenido, pero los dejamos para el siguiente epígrafe.
 
       System.getenv("HomeDrive") + System.getenv("HomePath");
 
+.. [#] Por ejemplo, ``System.getProperty("os.name")`` devuelve el nombre del
+   sistema operativo.
+
 .. |API| replace:: :abbr:`API (Application Programming Interface)`
 .. |MIME| replace:: :abbr:`MIME (Multipurpose Internet Mail Extensions)`
 .. |URI| replace:: :abbr:`URI (Uniform Resource Identifier)`

source/98.apendices/05.pattern.rst

@@ -0,0 +1,114 @@
+.. _design-patterns:
+
+Patrones de diseño
+******************
+Un :dfn:`patron de diseño` es una plantilla de codificación que se ha demostrado
+eficaz para resolver un problema habitual. Es útil conocerlos, porque si en
+nuestro programa nos enfrentamos a un problema que ya ha sido resuelto mediante
+uno de estos patrones, podremos ponerlo en práctica.
+
+En este apéndice, explicaremos algunos que 
+
+.. _singleton-pattern:
+
+Singleton
+=========
+Es un patrón que garantiza que de una clase sólo pueda existir una única
+instancia.
+
+Puede sernos muy útil,por ejemplo, si creamos una aplicación constituida por
+diversos paquetes y queremos que la configuración esté disponible en todos ellos
+sin tener que pasar constantemente los parámetros de configuración.
+
+Caso simple
+-----------
+En Java se implementa así:
+
+.. literalinclude:: files/Singleton.java
+   :language: java
+   :start-at: public class
+
+Es decir, básicamente ocultamos el constructor para que la instancia sólo sea
+accesible a través del método estático ``.getInstance``. De este modo, la única
+forma de acceder al constructor es a través de ``.initialize``, pero sólo
+podremos inicializar una vez.
+
+.. tip:: Una variante de este patrón es que queramos crear no una instancia,
+   sino varias, dependiendo del valor de uno de los argumentos. En ese caso, el
+   atributo ``instance`` se puede convertir en un mapa cuyas claves son
+   esos valores.
+
+Programas multihilo
+-------------------
+En caso de que nuestro programa sea multihilo entonces tendremos que complicar
+un poco el código:
+
+.. literalinclude:: files/Singleton-synchro.java
+   :language: java
+   :start-at: public class
+
+
+.. _factory-pattern:
+
+*Factory*
+=========
+El :dfn:`patrón Factory` es un patrón utilizado para creación de objetos que se
+utiliza para poder escoger en tiempo de ejecución qué objeto crear entre varios
+que cumplen con una misma interfaz (o pertenecen a subclases de una misma
+clase).
+
+Implementación
+--------------
+Para ilustrarlo imaginemos que en nuestra aplicación necesitamos traducir datos
+a distintos formatos. En una traducción básicamente hay dos operaciones:
+
+* *Leer*, que consiste en convertir la información que está almacenada en un
+  determinado formato en datos internos del programa.
+* *Escribir*, que consiste transformar los datos internos al formato
+  especificado.
+
+Por tanto, queramos traducir a lo que queramos traducir, la clase reponsable
+de la traducción tendrá que implementar la siguiente interfaz:
+
+.. literalinclude:: files/Traductor.java
+   :language: java
+   :class: toggle
+   :start-at: public interface
+
+en la que hemos supuesto que los datos los almacenamos en memoria en forma de
+una lista. Hemos considerado una lista del ``Object`` genérico, aunque en un
+ejemplo real concreto la lista será de alguna clase que hayamos definido. El
+caso es que ahora definiremos diferentes clases las cuales implementarán esta
+interfaz para distintos formatos (:ref:`XML <xml>`, :ref:`CSV <csv>`, :ref:`JSON
+<json>`, etc.). Imaginemos que las clases se denominan ``TXml``, ``TCvs``,
+``TJson``, etc.
+
+Con todo esto, podemos poner en práctica este patrón así:
+
+.. literalinclude:: files/TraductorFactory.java
+   :language: java
+   :start-at: public class
+
+En definitiva, la clase tiene un método estático que se limita a devolver el
+objeto de traducción apropiado según sea el formato. En el código principal no
+habrá más que hacer lo siguiente:
+
+.. code-block:: java
+
+   // El formato se proporcionará de alguna manera...
+   String formato = "json";
+
+   Traductor traductor = TraductorFactory.crearTraductor(formato);
+
+   // Suponiendo que en "data" estén los datos, esto generará una salida JSON.
+   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
+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
+--------------

source/98.apendices/99.ide.rst

@@ -4,14 +4,18 @@ Visual Studio Code
 ******************
 .. note:: La mayor parte de las instrucciones generales para el |IDE| están
    fusiladas muy indisimuladamente del :ref:`apéndice correspondiente
-   <lm:vscode>` de los :ref:`apuntes para el módulo de Lenguajes de Marcas <lm:mod-lm>`.
+   <lm:vscode>` de los :ref:`apuntes para el módulo de Lenguajes de Marcas <lm:apuntes-lm>`.
 
 Como entorno de desarrollo para el seguimiento del módulo recomendamos `Visual
-Studio Code`_, el cual es un |IDE|, con innumerables extensiones, especialmente
-diseñado para la escritura de código, y con versiones para los principales
-sistemas operativos. Esta disponible para su descarga gratuita en su página web
-y su código fuente en `su página de GitHub
-<https://github.com/microsoft/vscode>`_.
+Studio Code`_, por varios motivos:
+
+* Es *software* libre (`licencia MIT <https://es.wikipedia.org/wiki/Licencia_MIT>`_) y
+  está dispoible para su descarga gratuita en su página web y su código fuente
+  en `su página de GitHub <https://github.com/microsoft/vscode>`_.
+* Está especialmente diseñado para la escritura de código y dispone de
+  innumerables extensión que le dan soporte para muchos lenguajes de
+  programación.
+* Tiene versiones en los principales sistemas operativos.
 
 Generalidades
 =============
@@ -61,7 +65,7 @@ archivos de configuración |JSON|:
       cuales se corresponde con un distinto *perfil de desarrollador*. Esto es
       debido a que, cuando programamos por ejemplo en *Python*, no necesitamos
       exactamente el mismo entorno de desarrollo que cuando programamos en
-      Javascript*. En consecuencia necesitaremos unas extensiones distintas,
+      *Javascript*. En consecuencia necesitaremos unas extensiones distintas,
       unas preferencias distintas, etc. :program:`Visual Studio Code` nos
       permite lidiar con estas diferencias, permitiendo crear distintos
       *perfiles*, que escogeremos a voluntad dependiendo qué pretendamos
@@ -158,7 +162,28 @@ archivos de configuración |JSON|:
    Este tipo de personalización puede hacerse tanto `a nivel de perfil`_
    como de `área de trabajo`_. Como
    alternativa, podemos directamente editar los :file:`settings.json`
-   correspondientes.
+   correspondientes. Para ello puede pulsarse sobre el icono remarcado arriba a
+   la derecha.
+
+   .. _vscode-utf8-term-win:
+
+   Por ejemplo, es común que utilicemos UTF-8 para la codificación de caracteres
+   y, si usamos Windows, nos encontraremos con el inconveniente que la terminal
+   de éste no utilice esta codificación. Para paliarlo podemos añadir:
+
+   .. code-block:: json
+
+      {
+         "terminal.integrated.profiles.windows": {
+             "PowerShell": {
+                "source": "PowerShell",
+                "icon": "terminal-powershell",
+                "args": ["-NoExit", "-Command", "chcp 65001"]
+             },
+         },
+         "terminal.integrated.defaultProfile.windows": "PowerShell"
+      }
+       
 
 .. _vscode-extensions:
 
@@ -374,6 +399,9 @@ aquellas configuraciones que deseemos que sean universales independientemente de
 la herramienta que utilicemos. En particular, nos puede interesar:
 
 + La :ref:`configuración del idioma <vscode-language>`.
++ Si trabajamos en *Windows* y creamos aplicaciones que utilizan como interfaz
+  de usuario la consola, :ref:`configurar la codificación de ésta para que sea
+  UTF-8 <vscode-utf8-term-win>`.
 + Los aspectos relacionados con el editor (tamaño de la fuente, `emulación de
   vim <https://marketplace.visualstudio.com/items?itemName=vscodevim.vim>`_).
 + Los :ref:`atajos generales de teclado <vscode-atajos>`.
@@ -764,7 +792,7 @@ extensión `Maven for Java`_:
 
 Ejecución
 ---------
-Ya hemos dicho que para ejecutar la aplicación podemos pulsar:kbd:`Ctrl`\ +
+Ya hemos dicho que para ejecutar la aplicación podemos pulsar :kbd:`Ctrl`\ +
 :kbd:`F5` (si no queremos atender a los puntos de ruptura que hayamos definido)
 o, simplemente, :kbd:`F5` si sí queremos hacerlo y depurar el programa paso a
 paso. Además, podemos instruir al |IDE| de cómo ejecutar el programa dándole

source/98.apendices/files/02-vscode-conf.png

@@ -0,0 +1,30 @@
+import java.io.ObjectInputFilter.Config;
+import java.util.Map;
+
+public class Singleton {
+    private static volatile Singleton instance;
+
+    // Posiblemente haya atributos de instancia (y sus correspondintes getters)
+
+    private Singleton(Map<String, String> args) {
+        // Utilizamos los argumentos para
+        // definir los valores de los atributos
+    }
+
+    public static Singleton initialize(Map <String, String> args) {
+        if(instance == null) {
+            synchronized (Config.class) {
+                if(instance == null) {
+                    instance = new Singleton(args);
+                    return instance;
+                }
+            }
+        }
+        throw new IllegalStateException("La instancia ya fue inicializada");
+    }
+
+    public static Singleton getInstance() {
+        if(instance == null) throw new IllegalStateException("La instancia no está inicializada: use .initialize");
+        return instance;
+    }
+}

source/98.apendices/files/Singleton-synchro.java

@@ -0,0 +1,25 @@
+import java.util.Map;
+
+public class Singleton {
+    private static Singleton instance;
+
+    // Posiblemente haya atributos de instancia (y sus correspondintes getters)
+
+    private Singleton(Map<String, String> args) {
+        // Utilizamos los argumentos para
+        // definir los valores de los atributos
+    }
+
+    public static Singleton initialize(Map <String, String> args) {
+        if(instance == null) {
+            instance = new Singleton(args);
+            return instance;
+        }
+        throw new IllegalStateException("La instancia ya fue inicializada");
+    }
+
+    public static Singleton getInstance() {
+        if(instance == null) throw new IllegalStateException("La instancia no está inicializada: use .initialize");
+        return instance;
+    }
+}

source/98.apendices/files/Singleton.java

@@ -0,0 +1,5 @@
+public interface Traductor {
+   // Posiblemente sea una lista de un tipo determinado, no el genérico Object.
+   public List<Object> leer(InputStream st) throws IOException;
+   public void escribir(OutputStream st, List<Object> data) throws IOException;
+}

source/98.apendices/files/Traductor.java

@@ -0,0 +1,18 @@
+public class TraductorFactory {
+
+   public static Traductor crearTraductor(String formato)
+         throws IllegalArgumentException, UnsupportedOperationException {
+
+      return switch (formato.toLowerCase()) {
+         // Formatos implementados
+         case "txt" -> new TTxt();
+         case "csv" -> new TCsv();
+         case "json" -> new TJson();
+         case "yaml" -> new TYaml();
+         // Formatos conocidos que no se han implementado
+         case "xml" -> throw new UnsupportedOperationException(String.format("'%s': Formato no soportado.", formato));
+         // Cualquier otra cosa, no es un formato que reconozcamos
+         default -> throw new IllegalArgumentException(String.format("'%s': Formato desconocido.", formato));
+      };
+   }
+}

source/98.apendices/files/TraductorFactory.java

@@ -18,12 +18,13 @@ Acceso a datos
 
 .. rubric:: Normativa específica.
 
-* `Real Decreto 450/2010`_, que establece el título.
-* `Real Decreto 405/2023`_, que modifica el anterior actualizando sus módulos.
+* `Real Decreto 450/2010`_, que establece el título y al cual actualiza el
+  currículo de sus módulos el `Real Decreto 405/2023`_.
 * `Real Decreto 500/2024`_, que compatibiliza el currículo de los ciclos
   formativos de grado superior con el `Real Decreto 659/2023`_ de 18 de julio, que
   desarrolla la `Ley Orgánica 3/2022`_.
-* `Orden de 16 de junio de 2011`_, que transpone en la Comunidad Autónoma de Andalucía el Real Decreto.
+* `Orden de 16 de junio de 2011`_, que transpone en la Comunidad Autónoma de
+  Andalucía el Real Decreto.
 
 .. rubric:: Contenidos del curso