Problemática

Una de las grandes problemáticas al momento de acceder a los datos, es que la implementación y formato de la información puede variar según la fuente de los datos. Implementar la lógica de acceso a datos en la capa de lógica de negocio puedes ser un gran problema, pues tendríamos que lidiar con la lógica de negocio en sí, más la implementación para acceder a los datos, adicional, si tenemos múltiples fuentes de datos o estas pueden variar, tendríamos que implementar las diferentes lógicas para acceder las diferentes fuentes de datos, como podrían ser: bases de datos relacionales, No SQL, XML, archivos planos, Webservices, etc).

Solución

Dado lo anterior, el patrón DAO propone separar por completo la lógica de negocio de la lógica para acceder a los datos, de esta forma, el DAO proporcionará los métodos necesarios para insertar, actualizar, borrar y consultar la información; por otra parte, la capa de negocio solo se preocupa por lógica de negocio y utiliza el DAO para interactuar con la fuente de datos.

Los compones que conforman el patrón son:

• BusinessObject: representa un objeto con la lógica de negocio.
• DataAccessObject: representa una capa de acceso a datos que oculta la fuente y los detalles técnicos para recuperar los datos.
• TransferObject: este es un objeto plano que implementa el patrón Data Transfer Object (DTO), el cual sirve para transmitir la información entre el DAO y el Business Service.
• DataSource: representa de forma abstracta la fuente de datos, la cual puede ser una base de datos, Webservices, LDAP, archivos de texto, etc.

El siguiente diagrama muestra mejor la forma en que funciona el patrón, pues muestra de forma secuencial la forma en que se ejecutaría el patrón.

El diagrama se interpreta de la siguiente manera:

1. El BusinessObject creo u obtiene una referencia al DataAccessObject.
2. El BusinessObject solicita información al DataAccessObject
   • El DataAccessObject solicita la información al DataSource
   • El DataAccessObject crea una instancia del TransferObject con los datos recuperados del DataSource
   • El DataAccessObject response con el TransferObject creado en los pasos anteriores.
3. El BusinessObject actualiza algún valor del TransferObject
   • Más actualizaciones
4. El BusinessObject solicita el guardado de los datos actualizados al DataAccessObject.
   • El DataAccessObject guarda los datos en el DataSource.

Como hemos podido ver, el BusinessService no se preocupa de donde vengan los datos ni cómo deben de ser guardados en el DataSource, el solo se preocupa por conocer el TransferObject. Un error común al implementar este patrón es no utilizar TransferObject y en su lugar, regresar los objetos que regresan las mismas API’s de las fuentes de datos, ya que esto obliga al BusinessService tener una dependencia con estas librerías, además, si la fuente de datos cambia, también cambiarán estas clases, lo que provocaría una afectación directa al BusinessService.

Hace unos días escribir sobre el patrón Data Transfer Object (DTO) por si quieres profundizar en el tema.

DAO y el patrón Abstract Factory

Hasta este punto solo hemos analizado como trabajaríamos si solo tuviéramos una fuente de datos, sin embargo, existe ocasiones donde requerimos obtener datos de más de una fuente, y es allí donde entra el patrón de diseño Abstract Factory el cual explico perfectamente en mi libro “Introducción a los patrones de diseño”.

Mediante el patrón Abstract Factory podemos definir una serie de familias de clases que permitan conectarnos a las diferentes fuentes de datos. Para esto, examinaremos un sistema de autenticación de usuarios, el cual puede leer los usuarios en una base de datos o sobre un XML, adicional, el sistema generara registros de login que podrán ser utilizados para auditorias.

Lo primero sería implementar las clases para acceder de las dos fuentes:

En la imagen anterior podemos apreciar dos familias de clases, con las cuales podemos obtener los Usuarios y los registros de auditoria, sin embargo, estas clases por separado no ayudan mucho, pues no implementan una misma interface que permita la variación entre ellas, por lo que el siguiente paso es crear estas interfaces:

En este punto, los DAO ya implementan una interfaz común, lo que permite intercambiar la implementación sin afectar al Business Object. Sin embargo, ahora solo falta resolver la forma en que el Business Service obtendrá la familiar de interfaces, es por ello que deberemos crear un Factory para cada familia de interfaces:

En esta nueva configuración, podemos ver que tenemos un Factory para cada familia, y los dos factorys implementan una interfaz en común, adicional, tenemos la interface IDAOFactory necesaria para que el factory de cada familia implementen una interface en común.

Analicemos como quedaría la secuencia de ejecución

1. El BusinessObject solicita la creación de un DAOFactory para SQL
   • El DAOFactory crea una instancia de la clase SQLDAOFactory y la retorna
2. El BusinessObject solicita al SQLDAOFactory la creación del SQLUserDAO para interactuar con los usuarios.
   • El SQLDAOFactory crea una nueva instancia del SQLUserDAO
   • El SQLDAOFactory retorna la instancia creada del SQLUserDAO
3. El BusinessObject solicita el listado de todos los usuarios registrados al SQLUserDAO
   • El SQLUserDAO recupera los usuarios del SQLDataSource
   • El SQLUserDAO crea un TransferObject con los datos recuperados del paso anterior.
   • El SQLUserDAO retorna el TransferObject creado en el paso anterior.

Adicional a los pasos que hemos listado aquí, podríamos solicitar al SQLDAOFactory la creación del SQLAuditDAO o incluso, solicitar al DAOFactory la creación del XMLFactory para interactuar con la fuente de datos en XML.

Conclusiones

El patrón DAO es sin lugar a duda, unos de los más utilizados en la actualidad, ya que es fácil de implementar y proporciona claros beneficios, incluso, si solo tenemos una fuente de datos y esta no cambia, pues permite separar por completo la lógica de acceso a datos en una capa separada y así solo nos preocupamos por la lógica de negocio sin preocuparnos de donde viene los datos o los detalles técnicos para consultarlos o actualizarlos.

The post Data Access Object (DAO) Pattern appeared first on Oscar Blancarte - Software Architecture.

La siguiente imagen muestra la estructura del patrón de diseño:

En la imagen podemos apreciar los siguientes elementos:

ICommand: Esta es la pieza más importante del patrón, ya que cada comando deberá implementar esta interface y deberá implementar el método execute, el cual, de forma polimórfica realizara la operación que deseamos. Este componente generalmente es una interface o una clase abstract.

Concrete Command: Para este componente hablaremos en plural, ya que cada Concrete Command que tengamos implementado se convertirá en un comando en nuestro patrón. Este componente tiene que implementar ICommand de forma directa o indirecta y deberá implementar el método execute, en el cual se realizara la operación que deseamos que realice el comando.

Command Manager: Este componente nos servirá para administrar los comandos que tenemos disponibles en tiempo de ejecución, desde aquí podemos ejecutar un Comando o registrar nuevos comandos para que estén disponibles en tiempo de ejecución. Esta clase es importante, ya que de nada sirve tener un conjunto de Concrete Command que implementan ICommand regados por nuestro proyecto si no tenemos un componente que los administre y nos permite ejecutarlos.

Invoker: El invoker representa a la acción que dispara alguno de los comandos, un invoker podría ser un usuario, una aplicación o algún evento generado por nuestra aplicación.

Ya que conocemos los componentes es hora de hablar un poco más del Patrón de diseño, Al comienzo comentamos que nos sirve para realizar operaciones sin conocer realmente que hace la operación. Para lo cual utilizaremos un ejemplo y veremos de qué forma este patrón lo resuelve.

A estas alturas me imagino que todos ya hemos utilizado alguna vez la consola de Windows o Unix. Si observamos la consola, veremos que ella response a base de comandos, estos comandos pueden o no necesitar parámetros para funcionar, lo asombroso aquí es que la consola tiene la característica de saber siempre que operación va a realizar sin tener que decirle que clase o que software utilice para realizar la tarea, ya que la consola es capaz de determinar el comando utilizado y ejecutar el componente o software que realizar la operación deseada.

Otro punto importante es que la consola tiene la característica de agregarle comandos a medida que instalamos nuevo software como es el caso de Java, si intentamos ejecutar el comando java –version, con una computadora la cual no tiene instalado Java veras que te arrojara un mensaje de comando no encontrado, sin embargo si tu ejecutas de nuevo el comando una vez instalado java, entonces obtener un mensaje como el siguiente java version “1.7.0_51″….., En el patrón Command podemos registrar nuevos comandos mediante el componente CommandManager lo cual lo veremos más a delante.

Para analizar mejor este Patrón de diseño analizaremos el ejemplo de la consola y desarrollaremos una mediante el Patrón Command. Para iniciar el ejemplo tendremos que pensar primero en la funcionalidad que le daremos a nuestra consola, en este ejemplo desarrollaremos comandos muy simples pero útiles que ayuden a demostrar la utilidad del patrón, para lo cual les dejo la siguiente imagen:

Podemos identificar a los comandos de forma muy simple ya que son todos aquellos que implementan ICommand de forma directa o indirecta, cada comandos tiene un nombre diferente el cual lo utilizaremos para ejecutarlos desde nuestra consola. La explicación de los comandos está a continuación.

Exit: finaliza la consola y termina con nuestro programa.

Memory: Nos muestra en pantalla la cantidad de memoria total disponible, utilizada y máxima que podemos utilizar.

Batch: Comando que ejecuta en lote un conjunto de comandos definidos en un archivo plano.

Echo: Comando que nos imprime en pantalla lo que escribimos en la consola.

Date: Comando que nos imprime en pantalla la hora y la fecha en el formato que queramos.

File: Comando que nos permite interactuar con archivos, como crear, borrar, escribir, etc.

Dir: Nos permite realizar operaciones con directorios, ya sea crearlos o borrarlos.

WaitHello: Comando que nos permite demostrar la ejecución en segundo plano, este comando al ejecutarse escribe “Hello!” Después de un tiempo determinado.

A demás de los comandos tenemos los Abstract Command, los cuales están representados en el diagrama de color azul, estos comandos no hacen una funcionalidad como tal, sin embargo ayudan a crear otros comandos más complejos, los Abstract Command que tenemos aquí hace lo siguiente:

BaseCommand: Comando que agrega únicamente el método write el cual nos ayuda a escribir en pantalla los eventos generados por nuestros comandos, además de que nos permite tener un método estándar de escritura que podría ser modificado para afectar a todos los comandos, ahorrándonos el problema de modificar cada comando para que escriba de forma distinta.

AsyncCommand: Este comando tiene como finalidad demostrar que también se pueden crear comandos que se ejecuten en segundo plano, este comando tiene la característica que ejecuta la acción en un hilo independiente por lo que podemos seguir trabajando con la consola sin que el comando haya terminado de ejecutarse. Otro punto importante es que implementa el método execute, pero agrega el método abstracto executeOnBackground, en el cual deberemos implementar la función que queremos que realice en segundo plano.

Implementación:

Una vez platicado el escenario podemos pasar a la implementación de la consola.

Clase ICommand: Interface que tiene como propósito definir la estructura mínima de un comando, Esta interface define dos métodos, getCommandName el cual regresa el nombre del comando para uso informativo, También tiene el método execute el cual es implementado por los comandos para realizar la operación deseada, el método recibe un arreglo de String que corresponde a los parámetros del comando y un OutputStream el cual utilizaremos para ir notificando al usuario todas las cosas relevantes como un mensaje o un error.

package javamex.patronesdiseño.command;

import java.io.OutputStream;

public interface ICommand {

    public String getCommandName();

    public void execute(String[] args, OutputStream out);
}

Clase CommanManager: Esta clase es utilizada para gestionar los comandos disponibles en nuestra aplicación, desde esta clase podremos registrar nuevos comandos y recuperar los comandos solicitados por el usuario, La clase contiene los siguientes métodos:

• getCommand: Este método recibe como parámetro un String el cual corresponde al nombre del comando solicitado, El comando es buscado y retornado, pero si un comando no es encontrado se regresa un comando de error el cual explicaremos más a delante.
• registCommand: Método utilizado para registrar los commandos que tendremos disponibles en tiempo de ejecución, para que un comando esté disponible en la aplicación primero tendrá que ser registrado.
• getIntance: Método que nos permite obtener una instancia de la clase CommanManager ya que la esta clase sigue el patrón de diseño Singleton(Hablare de el en otra entrada).

Un punto importante a resaltar el constructor de la clase, en el cual registramos todos los comandos disponibles de forma predefinida para que estén disponibles en tiempo de ejecución, por defecto, cualquier comandos que creemos y que no se encuentre registrados no podrá ser reconocido.

package javamex.patronesdiseño.command;

import java.util.HashMap;
import javamex.patronesdiseño.command.impl.*;

public class CommandManager {

    private static CommandManager commandManager;

    private static final HashMap<String, Class<? extends ICommand>> COMMANDS =
            new HashMap<String, Class<? extends ICommand>>();

    private CommandManager() {
        registCommand(EchoCommand.COMMAN_NAME, EchoCommand.class);
        registCommand(DirCommand.COMMAND_NAME, DirCommand.class);
        registCommand(DateTimeCommand.COMMAND_NAME, DateTimeCommand.class);
        registCommand(MemoryCommand.COMMAN_NAME, MemoryCommand.class);
        registCommand(FileCommand.COMMAND_NAME, FileCommand.class);
        registCommand(ExitCommand.COMMAND_NAME, ExitCommand.class);
        registCommand(BatchCommand.COMMAND_NAME, BatchCommand.class);
        registCommand(WaitAndSayHello.COMMAND_NAME, WaitAndSayHello.class);
    }

    public static synchronized CommandManager getIntance() {
        if (commandManager == null) {
            commandManager = new CommandManager();
        }
        return commandManager;
    }

    public ICommand getCommand(String commandName) {
        if (COMMANDS.containsKey(commandName.toUpperCase())) {
            try {
                return COMMANDS.get(commandName.toUpperCase()).newInstance();
            } catch (Exception e) {
                e.printStackTrace();
                return new ErrorCommand();
            }
        } else {
            return new NotFoundCommand();
        }
    }

    public void registCommand(String commandName, 
            Class<? extends ICommand> command) {
        COMMANDS.put(commandName.toUpperCase(), command);
    }
}

Commandos: Las siguientes clases representan las implementaciones de los comandos que tendremos disponibles en la aplicación, los cuales fueron registrados en el constructor de CommandManager. Las clases siguientes representan los comandos que analizamos en la figura 2.

Clase ExitCommand: Comandos que termina con la aplicación. Este comando implementa ICommand por lo que representa unos de los comandos más simples de la aplicación.

package javamex.patronesdiseño.command.impl;

import java.io.OutputStream;
import javamex.patronesdiseño.command.ICommand;

public class ExitCommand implements ICommand {

    public static final String COMMAND_NAME = "exit";

    @Override
    public String getCommandName() {
        return COMMAND_NAME;
    }

    @Override
    public void execute(String[] args, OutputStream out) {
        System.exit(0);
    }
}

Clase BaseCommand: Esta clase implementa ICommand, sin embargo no es como tal un comando ya que es una Clase Abstracta, Esta clase fue diseñado como ejemplo para servir como una base para los demás comandos que imprimen un mensaje en pantalla, esta clase únicamente agrega el método write, El cual es utilizados para que todos los comandos impriman en pantalla los mensajes de una forma controlada, ya que si decidimos cambiar la forma que se escribe solo tendremos que cambiar este método y todas las clases que la heredan serán afectadas.

package javamex.patronesdiseño.command.impl;

import java.io.OutputStream;
import javamex.patronesdiseño.command.ICommand;

public abstract class BaseCommand implements ICommand {

    @Override
    public abstract String getCommandName();

    @Override
    public abstract void execute(String[] args, OutputStream out);

    public void write(OutputStream out, String message) {
        try {
            out.write(message.getBytes());
            out.flush();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Clase DirCommand: Comando que nos permite crear o borrar una carpeta de nuestro FileSytem, el comando recibe como parámetro la operación a realizar (crear o borrar {-N|-D}) más la ruta de la carpeta.

package javamex.patronesdiseño.command.impl;

import java.io.File;

import java.io.OutputStream;

import java.nio.channels.WritableByteChannel;

public class DirCommand extends BaseCommand {

    public static final String COMMAND_NAME = "dir";

    @Override
    public String getCommandName() {
        return COMMAND_NAME;
    }

    @Override
    public void execute(String[] args, OutputStream out) {
        if (args == null || args.length < 2) {
            write(out, COMMAND_NAME + " argumentos insuficientes");
        }
        String operation = args[0];
        if ("-D".equals(operation.toUpperCase())) {
            write(out, deleteDir(args[1]));
        } else if ("-N".equals(operation.toUpperCase())) {
            write(out, newDir(args[1]));
        } else {
            write(out, "Se esperaba una operación correcta -d | -n");
        }
    }

    private String deleteDir(String url) {
        try {
            File file = new File(url);
            if (!file.exists()) {
                return "El archivo no existe";
            }
            if (!file.canWrite()) {
                return "Privilegios insuficientes";
            }
            file.delete();
            return "";
        } catch (Exception e) {
            return "ERROR: " + e.getMessage();
        }
    }

    private String newDir(String url) {
        try {
            File file = new File(url);
            if (file.exists()) {
                return "El archivo ya existe";
            }
            file.mkdirs();
            return "";
        } catch (Exception e) {
            return "ERROR: " + e.getMessage();
        }
    }
}

FileCommand: Comando que nos permitirá realizar operaciones con archivos, las operaciones son las siguientes:

• WRITE_APPEND = -WA: Permite escribir en un archivo conservando el contenido existente previamente. Recibe dos parámetros, el primero corresponde al path del archivo y el segundo el contenido a escribir
  
• WRITE_OVERRIDE = -WO: Permite escribir en un archive sobrescribiendo su contenido. Recibe dos parámetros, el primero corresponde al path del archivo y el segundo el contenido a escribir.
  
• WRITE_NEW = -WN: Permite crear un archive y luego escribir en él. Recibe dos parámetros, el primero corresponde al path del archivo y el segundo el contenido a escribir.
  
• RENAME_FILE = -R: Permite renombrar un archive existente. Recibe dos parámetros, el primero corresponde al path del archivo y el segundo corresponde al nuevo nombre.
  
• DELETE_FILE = -D: Permite borrar un archive. Recibe únicamente el path del archivo a eliminar.
  

package javamex.patronesdiseño.command.impl;

import java.io.File;
import java.io.FileOutputStream;
import java.io.FileWriter;
import java.io.OutputStream;
import java.util.Arrays;

public class FileCommand extends BaseCommand {

    public static final String COMMAND_NAME = "file";
    private static final String WRITE_APPEND = "-WA";
    private static final String WRITE_OVERRIDE = "-WO";
    private static final String WRITE_NEW = "-WN";
    private static final String RENAME_FILE = "-R";
    private static final String DELETE_FILE = "-D";

    @Override
    public void execute(String[] args, OutputStream out) {
        if (args.length < 2) {
            write(out, "Parametros insuficientes");
            return;
        }
        String operation = args[0].toUpperCase();
        String[] reduce = Arrays.copyOfRange(args, 1, args.length);
        if (WRITE_APPEND.equals(operation)) {
            write(out, writeAppend(reduce));
        } else if (WRITE_NEW.equals(operation)) {
            write(out, writeNew(reduce));
        } else if (WRITE_OVERRIDE.equals(operation)) {
            write(out, writeOverride(reduce));
        } else if (RENAME_FILE.equals(operation)) {
            write(out, renameFile(reduce));
        } else if (DELETE_FILE.equals(operation)) {
            write(out, deleteFile(reduce));
        } else {
            write(out, "No se encontro la operacion {" + WRITE_APPEND + "|" + WRITE_NEW + "|" + WRITE_OVERRIDE + "|" + RENAME_FILE + "|DELETE_FILE}");
        }
    }

    private String renameFile(String[] args) {
        String filePath = args[0];
        String newFileName = args[1];
        try {
            File file = new File(filePath);
            file.renameTo(new File(newFileName));
            return "";
        } catch (Exception e) {
            return "ERROR: " + e.getMessage();
        }
    }

    private String writeOverride(String[] args) {
        String filePath = args[0];
        String fileContent = args[1];
        try {
            File file = new File(filePath);
            if (!file.exists()) {
                if (!file.createNewFile()) {
                    return "ERROR: Error al crear el archivo";
                }
            }
            FileWriter fileW = new FileWriter(file);
            fileW.write(fileContent.toCharArray());
            fileW.flush();
            fileW.close();
            return "";
        } catch (Exception e) {
            return "ERROR: " + e.getMessage();
        }
    }

    private String writeAppend(String[] args) {
        String filePath = args[0];
        String fileContent = args[1];
        try {
            File file = new File(filePath);
            if (!file.exists()) {
                return "ERRRO: El archivo no existe";
            }
            FileWriter fileW = new FileWriter(file, true);
            fileW.append(fileContent);
            fileW.flush();
            fileW.close();
            return "";
        } catch (Exception e) {
            return "ERROR: " + e.getMessage();
        }
    }

    private String writeNew(String[] args) {
        String filePath = args[0];
        String fileContent = args[1];
        try {
            File file = new File(filePath);
            if (file.exists()) {
                return "ERRRO: El archivo ya existe";
            }
            if (!file.createNewFile()) {
                return "ERROR: No fué posible crear el archivo";
            }
            FileWriter fileW = new FileWriter(file);
            fileW.write(fileContent.toCharArray());
            fileW.flush();
            fileW.close();
            return "";
        } catch (Exception e) {
            return "ERROR: " + e.getMessage();
        }
    }

    private String deleteFile(String[] args) {
        String filePath = args[0];
        File file = new File(filePath);
        if (!file.delete()) {
            return "No fué posible eliminar el archivo";
        }
        return "";
    }

    @Override
    public String getCommandName() {
        return COMMAND_NAME;
    }
}

EchoCommand: Comando que únicamente imprime en pantalla lo que se escribe. Como un Eco.

package javamex.patronesdiseño.command.impl;

import java.io.OutputStream;
import java.util.Arrays;

public class EchoCommand extends BaseCommand {

    public static final String COMMAN_NAME = "echo";

    @Override
    public void execute(String[] args, OutputStream out) {
        String message = getCommandName() + " " + Arrays.toString(args);
        write(out, message);
    }

    @Override
    public String getCommandName() {
        return COMMAN_NAME;
    }
}

DateCommand: Comando que nos permite conocer la fecha y hora del sistema en el formato que deseemos. El comando únicamente recibe como entrada el formato en el que queremos ver la fecha y hora.

package javamex.patronesdiseño.command.impl;

import java.io.OutputStream;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateTimeCommand extends BaseCommand {

    public static final String COMMAND_NAME = "date";

    @Override
    public String getCommandName() {
        return COMMAND_NAME;
    }

    @Override
    public void execute(String[] args, OutputStream out) {
        SimpleDateFormat dateFormater = null;
        if (args == null) {
            dateFormater = new SimpleDateFormat("dd/MM/yyyy hh:mm:ss");
        } else {
            try {
                dateFormater = new SimpleDateFormat(args[0]);
            } catch (Exception e) {
                write(out, "formato invalido");
                return;
            }
        }
        String date = dateFormater.format(new Date());
        write(out, date);
    }
}

MemoryCommand: Comando sin parámetros que nos arroja la información de la memoria que utiliza nuestra aplicación.

package javamex.patronesdiseño.command.impl;

import java.io.OutputStream;

public class MemoryCommand extends BaseCommand {

    public static final String COMMAN_NAME = "memory";

    @Override
    public String getCommandName() {
        return COMMAN_NAME;
    }

    @Override
    public void execute(String[] args, OutputStream out) {
        double heap = Runtime.getRuntime().totalMemory() / 1000000d;
        double heapMax = Runtime.getRuntime().maxMemory() / 1000000d;
        double heapFree = Runtime.getRuntime().freeMemory() / 1000000d;
        String salida = "Heap: " + heap + "nMax Heap: " 
                + heapMax + "nFree Heap: " + heapFree;
        write(out, salida);
    }
}

BatchCommand: Commando complejo que nos permite abrir un archivo de comandos, este archivo es parecido a los archivos en batch ya que podemos escribir un conjunto de comandos que serán ejecutados en el orden en el que se encuentran en el archivo(Se asume que cada línea es un comando). El comando únicamente recibe como parámetro el Path del archivo a ejecutar.

package javamex.patronesdiseño.command.impl;

import java.io.File;
import java.io.FileInputStream;
import java.io.OutputStream;
import java.util.Arrays;
import javamex.patronesdiseño.command.CommandManager;
import javamex.patronesdiseño.command.CommandUtil;
import javamex.patronesdiseño.command.ICommand;

public class BatchCommand extends BaseCommand {

    public static final String COMMAND_NAME = "batch";

    @Override
    public String getCommandName() {
        return COMMAND_NAME;
    }

    @Override
    public void execute(String[] args, OutputStream out) {
        if (args == null || args.length < 1) {
            write(out, "Número de parametros invalido");
            return;
        }
        CommandManager manager = CommandManager.getIntance();
        String[] lines = readLinesFromFile(args[0]);
        for (String line : lines) {
            String[] argsCommand = CommandUtil.tokenizerArgs(line);
            ICommand command = manager.getCommand(argsCommand[0]);
            String[] reduce = Arrays.copyOfRange(argsCommand, 1, argsCommand.length);
            command.execute(reduce, out);
            write(out, "n");
        }
        write(out, "Batch executado");
    }

    private String[] readLinesFromFile(String filePath) throws RuntimeException {
        File file = new File(filePath);
        FileInputStream stream = null;
        try {
            if (!file.exists()) {
                throw new RuntimeException("Archivo no encotrado");
            }
            stream = new FileInputStream(file);
            byte[] byteArray = new byte[stream.available()];
            stream.read(byteArray);
            String commands = new String(byteArray);
            String[] lines = commands.split("n");
            return lines;
        } catch (Exception e) {
            throw new RuntimeException(e.getMessage());
        } finally {
            try {
                stream.close();
            } catch (Exception e2) {}
        }
    }
}

AsyncCommand: Esta clase al igual que BaseCommand no es como tal un comando ya que es una Clase Abstract, esta clase tiene como propósito demostrar que podemos implementar comandos que se ejecuten en segundo plano o de forma asíncrona.

Esta clase agrega el método executeOnBackground en el cual deberemos implementar la funcionalidad que deseamos que realice el comando. Ya que el método original execute es sobre escritor para ejecutar el método executeOnBackground en un hilo independiente.

package javamex.patronesdiseño.command.impl;

import java.io.OutputStream;

public abstract class AsyncCommand extends BaseCommand {

    public void execute(final String[] args, final OutputStream out) {
        new Thread(new Runnable() {
            public void run() {
                executeOnBackground(args, out);
            }
        }).start();
    }

    public abstract void executeOnBackground(String[] args, OutputStream out);
}

Clase WaitAndSeyHello: Comando que extiende de AsyncCommand, lo cual lo convierte automáticamente en un comando que se ejecuta en segundo plano. Ha este comando únicamente se le envía un tiempo en milisegundos, el cual lo utilizara para esperar este tiempo antes de decir Hello! .

package javamex.patronesdiseño.command.impl;

import java.io.OutputStream;

public class WaitAndSayHello extends AsyncCommand {

    public static final String COMMAND_NAME = "waithello";

    @Override
    public void executeOnBackground(String[] args, OutputStream out) {
        if (args == null || args.length < 1) {
            write(out, "Parametros insuficientes");
            return;
        }
        Long time = null;
        try {
            time = Long.parseLong(args[0]);
        } catch (Exception e) {
            write(out, "Tiempo inválido");
            return;
        }

        try {
            Thread.sleep(time.longValue());
            write(out, "Hello!!");
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public String getCommandName() {
        return COMMAND_NAME;
    }
}

Clase ErrorCommand: Este comando no esté definido en nuestro diagrama y es utilizado por el CommandManager únicamente para regresar un Error al intentar instanciar un comando. Este comando no puede ser ejecutado por el cliente ya que no es un comando registrado, sin embargo CommandManager lo maneja como un comando propio del sistema para representa un error.

package javamex.patronesdiseño.command.impl;

import java.io.OutputStream;

import java.nio.channels.WritableByteChannel;

public class ErrorCommand extends BaseCommand {

    private static final String COMMAND_NAME = "ERROR";

    @Override
    public String getCommandName() {
        return COMMAND_NAME;
    }

    @Override
    public void execute(String[] args, OutputStream out) {
        String message = "Error al invokar el comando";
        write(out, message);
    }
}

Clase NotFoundCommand: Comando parecido a ErrorCommand pero este es regresado cuando un comando no es encontrado.

package javamex.patronesdiseño.command.impl;

import java.io.OutputStream;

public class NotFoundCommand extends BaseCommand {

    private static final String COMMAND_NAME = "NOT FOUND";

    @Override
    public String getCommandName() {
        return COMMAND_NAME;
    }

    @Override
    public void execute(String[] args, OutputStream out) {
        write(out, "Commando no encontrado");
    }
}

Otra clase que se utiliza es CommandUtil, la cual la utilizamos únicamente para procesar los datos tecleados por el usuario y dividir las instrucciones en tokens, los tokes pueden ser el nombre del comando y los parámetros. La regla que se sigue para dividir los comandos es la siguiente.

Cada palabra separada por un espacio es considera como un token a excepción que se encuentre en medio de comillas dobles, ejemplo “Hola Mundo”, en este caso toda la oración es considera un único token.

package javamex.patronesdiseño.command;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

public class CommandUtil {

    public static String[] tokenizerArgs(String args) {
        List<String> tokens = new ArrayList<String>();
        char[] charArray = args.toCharArray();
        String contact = "";
        boolean inText = false;
        for (char c : charArray) {
            if (c == ' ' && !inText) {
                if (contact.length() != 0) {
                    tokens.add(contact);
                    contact = "";
                }
            } else if (c == '"') {
                if (inText) {
                    tokens.add(contact);
                    contact = "";
                    inText = false;
                } else {
                    inText = true;
                }
            } else {
                contact += c;
            }
        }
        if (contact.trim().length() != 0) {
            tokens.add(contact.trim());
        }
        String[] argsArray = new String[tokens.size()];
        argsArray = tokens.toArray(argsArray);
        return argsArray;

    }
}

Hasta este momento ya tenemos definidos el CommandaManager y todos los comandos que utilizaremos, sin embargo no tenemos un mecanismo que nos ayude interactuar con los comandos, para eso tenemos la clase CommandMain, la cual servirá de invoker, Esta clase se cicla para solicitar al usuario comandos desde la consola.

package javamex.patronesdiseño.command;

import java.util.Arrays;
import java.util.Scanner;

public class CommandMain {

    public static void main(String[] args) {
        System.out.println("Command Line is Start");
        CommandManager manager = CommandManager.getIntance();
        Scanner in = new Scanner(System.in);
        while (true) {
            String line = in.nextLine();
            if ("EXIT".equals(line.toUpperCase())) {
                System.exit(0);
            }
            if (line.trim().length() == 0) {
                continue;
            }
            String[] commands = CommandUtil.tokenizerArgs(line);
            String commandName = commands[0];
            String[] commandArgs = null;
            if (commands.length > 1) {
                commandArgs = Arrays.copyOfRange(commands, 1, commands.length);
            }
            ICommand command = manager.getCommand(commandName);
            command.execute(commandArgs, System.out);
            System.out.println("");
        }
    }
}

Ejecución:

Finalmente, ya tenemos listo todo, por lo que comenzaremos ejecutando la aplicación y tendremos como resultado lo siguiente:

Iniciaremos ejecutando el comando date y le pediremos que nos arroje la fecha en el formato “DD/MM/YYYY”, seguido le pediremos la hora en el formato “HH:MM:SS” y finalmente le pediremos fecha y hora el formato “DDMMYYYY HHMMSS” para lo cual utilizaremos la nomenclatura estándar de java para la fecha y hora la cual podremos apreciar en la siguiente pagina https://docs.oracle.com/javase/6/docs/api/java/text/SimpleDateFormat.html.

Para el siguiente ejemplo, utilizaremos el comando Dir para crear un nuevo directorio y luego lo borraremos.

Para el siguiente ejemplo utilizaremos el comando echo para decir “Hola Mundo”.

Para el siguiente ejemplo utilizaremos el comando File para crear un nuevo archivo de texto y escribir en el “Hola Mundo”

El siguiente comando a utilizar es Memory, El cual nos dará datos acerca de la memoria de la aplicación.

Utilizaremos nuevamente el comando File para renombrar el archivo dummy.txt a helloword.txt

Hasta aquí, solamente hemos ejecutado comandos síncronos, pero en este ejemplo ejecutaremos el comando WaitAndSeyHello, el cual lo ejecutaremos y le diremos que espere 10 segundos antes de decir Hello!.

Después de esperar 10 segundos tenemos el siguiente resultado.

En el siguiente ejemplo ejecutaremos el comando Batch el cual lee un archivo de texto y ejecuta todos los comandos que tenemos en el, para este ejemplo ejecutaremos el comando y le diremos que lea un archivo en la ruta c:/dummy/batch.txt el cual tendrá el siguiente contenido:

date dd/MM/yyyy hh:mm:ss
dir -n "c:/dummy/dummy2"
echo "Se creo el archivo dummy2"
file -wn "c:/dummy/dummy2/dummy.txt" "Hola mundo con el comando file"
memory
file -r "c:/dummy/dummy2/dummy.txt" "c:/dummy/dummy2/dummy2.txt"
date dd/MM/yyyy hh:mm:ss

Lo que esperemos que realice el comando es lo siguiente: imprime la fecha y hora, cree el directorio c:/dummy/dummy2, escriba en pantalla Se creó el archivo dummy2″, cree un archivo en “c:/dummy/dummy2/dummy.txt” con el contenido “Hola mundo con el comando file”, imprima en pantalla los datos de la memoria, renombre el archivo que acabamos de crear y le ponga de nombre dummy2.txt y finalmente imprima nuevamente la fecha y hora.

Otra cosa que podemos intentar es ejecutar un comando que no existe, por ejemplo “java”, el cual nos indicara que no fue encontrado.

Finalmente ejecutamos el comando Exit, el cual terminara con la aplicación.

Hasta este punto ya habremos creado una consola que es capaz de ejecutar comandos, los cuales serán ejecutados sin saber realmente que clase está realizando el trabajo, sin embargo en la vida real no nos interés saber cómo es atendido un comando siempre y cuando realice la tarea que esperamos que realice. Y como ya vimos con el patrón de diseño Command esto es posible.

Ya con esta base tú podrás crear nuevos comandos y registrarlos al CommandManager para que los puedes utilizar en tu consola, también podrías crear un comando que se encargue de registrar nuevos comandos desde algún Jar para que esté disponible desde la consola. O podrías modificar la forma en la carga los comandos al inicio para que lea algún archivo de configuración.

Acabamos de ver uno de los muchos aplicativos que tiene el Patrón de diseño Command, Si tú tienes alguna experiencia con este patrón por favor coméntala.

Ya está a la venta mi nuevo libro “Introducción a los patrones de diseño“, en donde expongo los 25 patrones de diseño más utilizados y explicados desde un enfoque del mundo real, con ejemplos que pueden ser aplicados en tus proyectos. Sin duda es unos de los libros más completos de patrones de diseño en español.

The post Patrón de diseño Command appeared first on Oscar Blancarte - Software Architecture.

Para comprender mejor como funciona este patrón imaginemos una casa de ladrillos, las casas como tal no están hecha de una pieza, si observamos las paredes estas esta echas de pequeñas piezas llamadas ladrillos, entonces, el conjunto de estos ladrillos crea paredes, y un conjunto de paredes crean una casa. este ejemplo puede ser aplicado al patrón Composite, y no digo que vallamos a crear una casa con este patrón, sino más bien nos da una idea de cómo trabaja para poder utilizarlo con otros ejemplos.

El patrón Composite requiere mínimo de tres componentes para poder existir los cuales son Componente, Leaf o Rama y Composite.

Component: Generalmente es una interface o clase abstracta la cual tiene las operaciones mínimas que serán utilizadas, este componente deberá ser extendido por los otros dos componentes Leaf y Composite. En nuestro ejemplo esto podría representar de forma abstracta un ladrillo o toda la casa (Mas adelante comprenderemos porque)

Leaf: El leaf u hoja representa la parte más simple o pequeña de toda la estructura y este extiende o hereda de Component. En nuestro ejemplo, este representaría un ladrillo de nuestra casa.

Composite: Aquí es donde está la magia de este patrón, ya que el composite es una estructura conformada por otros Composite y Leaf, si vemos en la imagen 1, vemos que los Composite tiene los métodos add y remove los cuales nos permiten agregar objetos de tipo Component, Sin embargo como hablamos anteriormente, el Componente es por lo general un Interface o Clase abstracta  por lo que podremos agregamos objetos de tipo Composite o Leaf. Visto desde el punto de vista del ejemplo de la casa el Composite podría representar un conjunto de ladrillos o la casa completa, Esto desde luego sería agregando varias Ladrillo(Leaf) al Composite para crear una Pared.

No te preocupes si no lograste comprender del todo la explicación anterior, para fortalecer la explicación hablaremos de un ejemplo más técnico donde podamos programar un escenario concreto.

Caso de estudio del patrón Composite.

Imaginemos un sistema de punto de venta, en el cual se le pueden vender al cliente una serie de productos, estos productos pueden ser productos simples (Leaf) o paquetes (Composite). El sistema permitirá crear Ordenes de ventas las cuales están compuestas por 1 o muchos productos.

La siguiente imagen ilustra la estructura de un paquete.

La imagen 2 muestra la estructura de una forma conceptual, sin embargo la estructura es un poco más compleja, ya que está formado por una estructura de dato llamada Árbol.

Puntos importantes a tomar en cuenta:

• Un paquete es producto compuesto de varios productos simples y otros paquetes.
• Los paquetes y productos simples deberán ser tratados de la misma forma, por lo que deberán tener un padre en común.
• El precio de un paquete es la suma de todos los productos simples que contenga.
• El sistema deberá mostrar el total de la Orden y los productos que contiene.

Ya conocida la teoría, pasemos a la práctica.

En primero lugar crearemos la clase la cual será nuestro Component

package javamex.patronesdiseño.composite;

/**
 * @author oblancarte
 * 
*/
public abstract class AbstractProduct {

    protected String name;
    protected double price;

    public AbstractProduct(String name, double price) {
        super();
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public double getPrice() {
        return price;
    }

    public void setPrice(double price) {
        this.price = price;
    }
}

Como podemos observar la clase AbstractProduct es una clase abstracta la cual define las características mínimas de un producto, las cuales deben tener todos los productos sin importar que sean productos simples o paquetes. Para este ejemplo, lo minino que un producto debe tener es un nombre y un precio.

En segundo lugar, definimos lo que vendría siendo el Leaf o producto simple.

package javamex.patronesdiseño.composite;

public class SimpleProduct extends AbstractProduct {

    protected String brand;

    public SimpleProduct(String name, double price, String brand) {
        super(name, price);
        this.brand = brand;
    }

    public String getBrand() {
        return brand;
    }

    public void setBrand(String brand) {
        this.brand = brand;
    }
}

Lo primero que observamos es que las clases SimpleProduct extiende de AbstractProduct, luego solo como ejemplo agregamos un atributo que solo un producto simple pueda tener, en este caso, agregamos la marca, aunque en este ejemplo no nos sirve de nada nos da una idea de que podemos personalizar los productos según el tipo.

Otro punto importante es que el método getPrice no lo sobre escribimos por lo que toma el heredado de AbstractProduct el cual solo regresa el precio de la propiedad price.

Para completar el patrón tenemos el Composite, el cual es una agrupación de AbstractProduct.

package javamex.patronesdiseño.composite;

import java.util.ArrayList;
import java.util.List;

public class CompositeProduct extends AbstractProduct {

    private List< AbstractProduct > products = new ArrayList< AbstractProduct >();

    public CompositeProduct(String name) {
        super(name, 0);
    }

    @Override
    public double getPrice() {
        double price = 0d;
        for (AbstractProduct child : products) {
            price += child.getPrice();
        }
        return price;
    }

    @Override
    public void setPrice(double price) {
        throw new UnsupportedOperationException();
    }

    public void addProduct(AbstractProduct product) {
        this.products.add(product);
    }

    public boolean removeProduct(AbstractProduct product) {
        return this.products.remove(product);
    }
}

Lo primero a observar en la clase CompositeProduct es que extiende también la clase AbstractProduct lo cual nos garantiza que tanto el SimpleProduct (Producto Simple) y el CompositeProduct(Paquete) puedan ser tratados de igual manera y nos nos interesa saber en tiempo de ejecución si es un paquete o un producto simple.

En el caso de CompositeProduct veremos que las propiedades que tiene no son las de un producto o paquete, sino que además de tener las que hereda de SimpleProduct, tiene una Lista de AbstractProduct, lo cual nos dice que en esta lista puede tener cualquier objeto que herede de esta clase, y para nuestro ejemplo estas clases serian SimpleProduct y CompositeProduct, Es aquí donde nos damos cuenta que un paquete puede estar compuesto por paquetes y productos simples.

Observemos también el método getPrice y setPrice, el método getPrice es sobre escrito para regresar el precio de todos los productos que contiene y el método setPrice es sobre escrito para que no nos permita establecer un precio, de esta forma cumplimos la regla de que el precio de un paquete es la suma del precio de todos los productos que contiene.

Por último, veamos los métodos addProduct y removeProduct los cuales nos permite agregar y remover productos de un paquete.

Para poder realizar una venta es necesario crear un Orden de venta, por lo que se crear la clase SaleOrder la cual nos permite agregar los productos a vender.

package javamex.patronesdiseño.composite;

import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;

/**
 * @author oblancarte
 * 
*/
public class SaleOrder {

    private long orderId;
    private String customer;
    private Calendar dateTime;
    private List< AbstractProduct > products = new ArrayList< >();

    public SaleOrder(long orderId, String customer) {
        super();
        this.orderId = orderId;
        this.customer = customer;
    }

    public long getOrderId() {
        return orderId;
    }

    public void setOrderId(long orderId) {
        this.orderId = orderId;
    }

    public String getCustomer() {
        return customer;
    }

    public void setCustomer(String customer) {
        this.customer = customer;
    }

    public Calendar getDateTime() {
        return dateTime;
    }

    public void setDateTime(Calendar dateTime) {
        this.dateTime = dateTime;
    }

    public List getProducts() {
        return products;
    }

    public void setProducts(List products) {
        this.products = products;
    }

    public double getPrice() {
        double price = 0d;
        for (AbstractProduct child : products) {
            price += child.getPrice();
        }
        return price;
    }

    public void addProduct(AbstractProduct product) {
        products.add(product);
    }

    public void removeProduct(AbstractProduct product) {
        products.remove(product);
    }

    public void printOrder() {

        NumberFormat formater = new DecimalFormat("###,##0.00");
        System.out.println("\n=============================================nOrden: " + orderId + "nCliente: " + customer + "nProductos:n");
        for (AbstractProduct prod : products) {
            System.out.println(prod.getName() + "ttt$ " + formater.format(prod.getPrice()));

        }
        System.out.println("Total: " + formater.format(getPrice()) + "n=============================================");
    }
}

Veamos que la clase SaleOrden no tiene más que una lista de productos, id, fecha de venta y el nombre del cliente (Datos solo como ejemplo).

Como puntos importantes podemos ver los métodos addProduct y removeProduct, los cuales nos permiten agregar y remover productos a la Orden.

Tenemos el método getPrice, el cual nos regresa el precio total de la Orden.

PrintOrden método que imprime el detalle de la Orden en pantalla.

Ejecución.

Para finalizar este ejemplo veremos la clase Main donde veremos cómo funciona el ejemplo:

package javamex.patronesdiseño.composite;

public class Main {

    public static void main(String[] args) {
        SimpleProduct ram4gb = new SimpleProduct("Memoria RAM 4GB", 750, "KingStone");
        SimpleProduct ram8gb = new SimpleProduct("Memoria RAM 8GB", 1000, "KingStone");

        SimpleProduct disk500gb = new SimpleProduct("Disco Duro 500GB", 1500, "ACME");
        SimpleProduct disk1tb = new SimpleProduct("Disco Duro 1TB", 2000, "ACME");

        SimpleProduct cpuAMD = new SimpleProduct("AMD phenon", 4000, "AMD");
        SimpleProduct cpuIntel = new SimpleProduct("Intel i7", 4500, "Intel");

        SimpleProduct smallCabinete = new SimpleProduct("Gabinete Pequeño", 2000, "ExCom");
        SimpleProduct bigCabinete = new SimpleProduct("Gabinete Grande", 2200, "ExCom");

        SimpleProduct monitor20inch = new SimpleProduct("Monitor 20'", 1500, "HP");
        SimpleProduct monitor30inch = new SimpleProduct("Monitor 30'", 2000, "HP");

        SimpleProduct simpleMouse = new SimpleProduct("Raton Simple", 150, "Genius");
        SimpleProduct gammerMouse = new SimpleProduct("Raton Gammer", 750, "Alien");

//Computadora para Gammer que incluye 8gb de ram,disco de 1tb, procesador Intel i7
//gabinete grande,monitor de 30' y un mouse gammer.
        CompositeProduct gammerPC = new CompositeProduct("Gammer PC");
        gammerPC.addProduct(ram8gb);
        gammerPC.addProduct(disk1tb);
        gammerPC.addProduct(cpuIntel);
        gammerPC.addProduct(bigCabinete);
        gammerPC.addProduct(monitor30inch);
        gammerPC.addProduct(gammerMouse);

//Computadora para Casa que incluye 4gb de ram,disco de 500gb, procesador AMD Phenon
//gabinete chico,monitor de 20' y un mouse simple.
        CompositeProduct homePC = new CompositeProduct("Casa PC");
        homePC.addProduct(ram4gb);//
        homePC.addProduct(disk500gb);
        homePC.addProduct(cpuAMD);
        homePC.addProduct(smallCabinete);
        homePC.addProduct(monitor20inch);
        homePC.addProduct(simpleMouse);

//Paque compuesto de dos paquetes, El paquete Gammer PC y Home PC
        CompositeProduct pc2x1 = new CompositeProduct("Paquete PC Gammer + Casa");
        pc2x1.addProduct(gammerPC);
        pc2x1.addProduct(homePC);

        SaleOrder gammerOrder = new SaleOrder(1, "Juan Perez");
        gammerOrder.addProduct(gammerPC);
        gammerOrder.printOrder();

        SaleOrder homeOrder = new SaleOrder(2, "Marcos Guerra");
        homeOrder.addProduct(homePC);
        homeOrder.printOrder();

        SaleOrder comboOrder = new SaleOrder(3, "Paquete 2x1 en PC");
        comboOrder.addProduct(pc2x1);
        comboOrder.printOrder();

        SaleOrder customOrder = new SaleOrder(4, "Oscar Blancarte");
        customOrder.addProduct(homePC);
        customOrder.addProduct(ram8gb);
        customOrder.addProduct(ram4gb);
        customOrder.addProduct(monitor30inch);
        customOrder.addProduct(gammerMouse);
        customOrder.printOrder();
    }
}

De la linea 5 a la 21 creamos los productos simples. Los cuales únicamente contiene el nombre del producto y el precio de venta.

Estos productos son instancias de SimpleProduct por lo que vendrían siendo el Leaf del patrón de diseño.

En las lineas 23 a la 47 podemos ver como se crean los paquetes o productos compuestos. Estos productos solo son creados con el nombre del paquete y no tiene un precio de venta. Una vez creados se les agregan los productos simples mediante el método addProduct, Si vemos bien los paquetes que creamos, veremos que todos están conformados por productos simples a excepción del paquete pc2x1 el cual es un paquete creado a partir de dos paquetes. Esto provocara que el precio de este paquete sea el precio de los dos paquetes hijos, y el precio de los hijos sera el precio de todos los productos simple que contiene, de esta forma creamos un árbol parecido al que vimos en la figura 3.

Por ultimo de la 48 a la 66 se crean 4 ordenes con productos distintos. En la orden 1 y 2 vemos que solo vendemos un paquete, en la orden 3 vendemos un paquete conformado de dos paquetes y en la orden 4 vendemos un paquete y 4 productos simples.

Resultado de la ejecución:

El resultado de la ejecución del programa nos da el siguiente resultado:

=============================================
Orden: 1
Cliente: Juan Perez
Productos:

Gammer PC $ 12,450.00
Total: 12,450.00
=============================================

=============================================
Orden: 2
Cliente: Marcos Guerra
Productos:

Casa PC $ 9,900.00
Total: 9,900.00
=============================================

=============================================
Orden: 3
Cliente: Paquete 2x1 en PC
Productos:

Paquete PC Gammer + Casa $ 22,350.00
Total: 22,350.00
=============================================

=============================================
Orden: 4
Cliente: Oscar Blancarte
Productos:

Casa PC $ 9,900.00
Memoria RAM 8GB $ 1,000.00
Memoria RAM 4GB $ 750.00
Monitor 30' $ 2,000.00
Raton Gammer $ 750.00
Total: 14,400.00
=============================================

Análisis: 

Veamos que paso.

En la orden no.1 se vendió un paquete llamado PC Gammer con un precio de 12,450 ,¿pero por qué cuesta eso?, si regresamos a la definición del paquete veremos que se le agregaron 6 productos simples: ram8gb($1,000), disk1tb($2,000), cpuIntel($4,500), bigCabinet(2,200), monitor30inch($2,000), gammerMouse($750), Si sumamos el precio de los 6 productos nos dará el total de 12,450 el mismo precio del paquete.

En la orden no.2 pasa lo mismo, se vende un paquete el cual contiene 6 productos simples pero con un precio menor.

La orden no.3 es un poco distinta, esta orden vende al igual que las anteriores un solo paquete, sin embargo, este paquete pc2x1 es un paquete que se creó a partir de otros dos paquetes. En este caso el total de la orden es de 22,350, pero si vemos el precio del paquete, Gammer PC($12,450) y Home PC($9,900), veremos la suma de estos dos da el precio total del paquete pc2x1($22,350).

Por último, tenemos la orden 4, esta orden explota al máximo el poder del patrón de diseño Composite, ya que nos permite vender paquetes y productos simples sin tener que preocuparnos de que tipo de productos es. ya que de forma polimorfica el programa es capaz de calcular el precio de ambos tipos de productos sin necesidad de programar un trato especial.

Esta orden vende una Home PC($9,900), ram8gb($1,000),ram4gb(750),monitor30inch($2,000),gammerMouse(750), de los cuales Home PC es un paquete y el resto de los productos son productos simples. Si sumamos el precio de los productos veremos que el total es de 14,400.

Como veremos, este patrón es muy flexible con estructuras de datos compuestas, en este caso vimos que teníamos paquetes y productos simples, sin embargo, podríamos crear un tercer tipo de producto que extienda de AbstracProduct y darle el comportamiento que queramos. Otro ejemplo que le podríamos dar, es para agrupar las cuentas de un cliente, de esta forma, podríamos saber el saldo de todas las cuentes de un cliente.

Si te gusto este post, por favor dale me gusta y compártelo ya que esto me ayudara a crear más y mejor material.

Ya está a la venta mi nuevo libro “Introducción a los patrones de diseño“, en donde expongo los 25 patrones de diseño más utilizados y explicados desde un enfoque del mundo real, con ejemplos que pueden ser aplicados en tus proyectos. Sin duda es unos de los libros más completos de patrones de diseño en español.

The post Patrón de diseño – Composite appeared first on Oscar Blancarte - Software Architecture.

Para entender bien lo que es un Proxy nos iremos al ámbito de las Redes ya que es un tema casi todos comprendemos, Todos hemos escuchado de los proxy de red o Servidores Proxy los cuales nos impiden que entremos a una determinada pagina como por ejemplo las redes sociales o paginas de vídeos en streaming. Pues bien estos servidores implementa el patrón de diseño proxy, ya que antes de enviar la solicitud a la pagina que queremos entrar primero valida si la pagina no esta en la lista de paginas bloqueadas si no es a sí entonces manda el request a la pagina y el proxy antes de enviarnos la respuesta a nuestro navegador valida por ejemplo que la pagina no tenga contenido prohibido como por ejemplo paginas de adulo o vídeo juegos, Si el proxy detecta que la respuesta de la pagina regresa un contendido de estos entonces el proxy nos manda una pagina distinta a la solicitada diciendo que la pagina tiene contenido indeseado.

Los proxy tiene varias utilidades y podemos utilizarlo para lo que queramos, para este caso hablaremos de ejemplo prácticos los cuales son usados con regularidad.

Proxy de Seguridad: 

Cuando desarrollamos aplicaciones por lo general desarrollamos clases que utilizamos como BusinessService (Clases con operaciones de negocio) estas clases generalmente no requieren autenticación y los usuarios pueden invocar los métodos sin ningún problema, ¿pero que pasa si un día decidimos que estos métodos requieren de privilegios para ser ejecutados? una solución seria modificar los métodos para que recibieran las credenciales o modificar la aplicación para que valide los privilegios antes de mandar llamar los métodos de negocio, Sin embargo estos cambios son radicales ya que implicaría modificar la firma de los BusinessService impactando gran parte del proyecto o modificar cada parte en donde hacíamos un llamada a los BusinessService para agregar la validación antes de la llamada. Estas soluciones producirían un gran cambio en nuestra aplicación y afectaría los componentes ya desarrollados y probados para tener que volver a la etapa  de pruebas y validar nuevamente que la aplicación sigue funcionando correctamente.

Solución: En vez de lo anterior podríamos envolver la ejecución del BusinessService en un Proxy el cual antes de mandar llamar al BusinessService cheque las credenciales del usuario y posteriormente invoque al BusinessService, Pero no solo eso podemos hacer, También podría mandar llamar a otro servicio de Auditoria una vez que el servicio de negocio fue invocado, esto es posible por que un proxy puede hacer algo antes y después de realizar la tarea que realmente el cliente quiere realizar, sin embargo el cliente no es consciente de lo que pasa antes y después de la invocación del BusinessService.

Proxy de invocación remota.

Otro de los escenarios para los cuales se utilizan los proxy son para enmascarar la invocación de métodos remotos.

El procedimiento para realizar esto es creando una interfaz que contenga las operaciones que queremos invocar de forma remota, Luego creamos una un Proxy a través de la interfaz la cual delegue el comportamiento a una clase que se encargue de realizar la comunicación con el servicio remoto y al final regrese lo resultados al cliente de nuestra aplicación, De esta forma la invocación remota es invisible y no se dará cuenta de que detrás del proxy existe una conexión con algún servicio remoto.

Conclusión:

En resumen podríamos decir que un Proxy es un intermediario que puede interceptar una petición y hacer algo con ella antes y después de ejecutar la operación deseada por el usuario e incluso podemos cancelar la invocación como en el caso que no tenga los privilegios.

Es importante remarcar que los Proxy tiene muchas utilidades y estas que planteo a qui solo son alguno de la multitud de utilidades que tiene. Otro escenario para el cual se utilizan es para el Debug de aplicaciones de lo cual hablare en otra entrada.

Ya está a la venta mi nuevo libro “Introducción a los patrones de diseño“, en donde expongo los 25 patrones de diseño más utilizados y explicados desde un enfoque del mundo real, con ejemplos que pueden ser aplicados en tus proyectos. Sin duda es unos de los libros más completos de patrones de diseño en español.

The post Patrón de diseño – Proxy appeared first on Oscar Blancarte - Software Architecture.

Para explicar correctamente este Patrón de diseño le comparto esta imagen:

Imaginemos un escenario de la vida real para comprender mejor esta patrón para lo cual nos ubicamos en el Aeropuerto y estamos esperando a que nos indiquen que podemos abordar el avión por medio de las bocinas que hay en el aeropuerto.

Bien, de seguro no eres el único que esta esperando el vuelo, de seguro existen muchas personas que esperan el abordaje, En este escenario nosotros junto con todas las demas personas que esperan el vuelo son Observers y la bocina es el Tajet Ya que todos estamos atento a que nos indique que ya podemos abordar lo cual es un evento que realiza la bocina y que nosotros estamos esperando(Observando) para realizar una acción(Abordar).

Entonces el mecanismo por el cual el observer trabaja es el siguiente:

1. Existe un componente u Objecto al cual queremos observar(Tarjet)
2. Tenemos algún modulo u otro Objeto(Observer) el cual queremos que sea notificado cuando Tarjet realice una acción.
3. Los Observers deben implementar una Interfaz común que tanto el Target como el Observer conozcan.
4. Los Observers deberán ser registrados en el Tarjet el cual los almacenara en una lista.
5. Cuando el Tarjet realice una acción notificara a todos los Observers los cuales se registraron en el paso anterior.
6. Los Observers recibirán la notificación como un Evento el cual el Observer procesara para hacer una acción.

Si nos damos cuenta es mucho mas simple de lo que parece y muchos de las aplicaciones utilizan este patrón y ni siquiera nos damos cuenta.

En tu experiencia, ¿donde crees que se mas conveniente utilizar esta patrón o como lo implementarías?

Ya está a la venta mi nuevo libro “Introducción a los patrones de diseño“, en donde expongo los 25 patrones de diseño más utilizados y explicados desde un enfoque del mundo real, con ejemplos que pueden ser aplicados en tus proyectos. Sin duda es unos de los libros más completos de patrones de diseño en español.

The post Patrón de diseño Observer appeared first on Oscar Blancarte - Software Architecture.