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.

Hoy en día los sistemas de información generan una gran cantidad de información mediante la operación del día a día. Estos sistemas generalmente están comunicados con otros sistemas o módulos para compartir o extraer información.  Esta comunicación entre sistemas es llamado “Integraciones” y son muy importantes ya que de no existir los sistemas no se podrían comunicar y se generaría un caos.

Un ejemplo claro de integración:

Imagínate un sistema de punto de venta en donde se capturan las ventas diarias, se cobra y se consulta inventario. El punto de venta cada vez que realiza una venta tiene que descontar del almacén las unidades vendidas las cuales el Sistema de Almacén resta y lleva la cuenta para hacer los pedidos cuando la existencia esta bajando. Por otra parte las vendedoras consultan el inventario para saber si algún producto lo aun lo tiene en existencia y poder dar cotizaciones a los clientes.

Al finalizar el día todas las ventas se van al sistema de contabilidad para hacer las pólizas contables.

Si nos damos cuenta el sistema de ventas necesita una “Integración” constante con el sistema de Almacén ya que desde allí consulta la existencia pero también la modifica cuando venden.

Al final del día el sistema se tiene que “Integrar” con el sistema de contabilidad para realizar las pólizas.

Hora imaginemos que estas integraciones no existieran!!, Te imaginas como se pudiera operar si esta comunicación con los sistemas no se pudiera dar o no fuera eficiente?

SOA Composite

Bien un composite es donde diseñamos a un alto nivel la integración o Integraciones las cuales serán expuestas como servicios para que los sistemas los consuman y logren la integración.

Una composición SOA se divide en tres secciones:

• Exposed Services: En esta sección describimos la forma en que expondremos los servicios ante los consumidores(Aplicaciones), esta sección podemos exponer WebServices, EJB, Servicios HTTP, Sockets los cuales sirven para que los clientes puedan iniciar la integración bajo demanda, pero también existen métodos que hacen que muestra integración se ejecutaba bajo algún evento en especial como por ejemplo, Colas de mensaje(Queue) JMS, Base de datos(Poolling), B2B. En resumen esta sección representa la entrada de la integración y el inicio de su ejecución.
• External References: En esta sección ponemos los servicios externos que requeriremos para que nuestra integración se pueda realizar. Aquí podemos poner WebServices, Base de datos, HTTP, Colas de mensaje, B2B,etc.
• Components: Aquí es donde se programa las acciones a seguir para que nuestra integración realice lo que esperamos, A qui podemos poner BPEL, Human Task, Business Rules,BPM las cuales son componentes diseñados para atacar diferentes problemáticas.

Un composite para la integración del sistema de punto de ventas y almacén se vería algo a sí

Fig.1: Composite para integrar Punto de venta con Almacén.

En la figura anterior podemos ver que tenemos dos servicios del lado izquierdo los cuales representa los servicios que estamos exponiendo para ser consumidos por el Punto de venta.

En medio vemos dos BPEL(En Azul) los cuales se encargan de Orquestar las acciones necesarias para realizar la operación deseada.

Y del lado derecho tenemos el WebService que expone el almacén, el cual tiene las operaciones consultaExistencia y actualizarExistencia necesarias para realizar la integración.

Por ultimo les dejo esta liga donde donde podrán encontrar mucha mas información de lo que es un Composite

http://docs.oracle.com/cd/E14571_01/integration.1111/e10223/arch_02.htm

The post Oracle SOA Suite – Que es un Composite appeared first on Oscar Blancarte - Software Architecture.

Se le llama Orquestar por que BPEL es el encargado de consumir varios servicios en un orden especificado y realizar una función muy concreta.

Escenario practico.

Agencia de viaje: Imagínate que entras a un pagina de agencia de viaje en la cual puedes comprar un paquete que incluye boletos de avión y hotel. Lo único que tenemos que hacer nosotros es decir a donde queremos con la fecha y la agencia de viaje nos arrojara los paquetes con un precio y solo tenemos que pagar con nuestra tarjeta de crédito para que nuestra reservación quede lista.

Una vez que confirmamos nuestra compra la agencia de viaje tendrá que hacer algunas operaciones que no dependen de ella como seria reservar el boleto de avión con la aerolínea, reservar los día del cuarto directamente con el Hotel, Hacer un cargo por el porcentaje que gana la agencia por realizar la venta y por ultimo guardar en el sistema de la agencia el registro de la venta.

Fig.1: Muestra el proceso a realizar para completar una reservación.

Si nos damos cuenta los pasos 2,3,4 no depende de la agencia de viaje si no de servicios que exponen los proveedores como webservices.

Como encaja BPEL en este escenario.

Con BPEL podemos crear un solo servicio que reciba todos los parámetros necesarios para realizar la operación como los datos de la reservación y los datos de la tarjeta de crédito, con estos primero realizaremos la reservación del avión, luego reservaremos el hotel, cargaremos nuestra utilidad al cliente, Guardaremos el registro de la reservación y finalmente regresaremos al cliente la confirmación al cliente. A este proceso se le conoce como orquestar ya que toma el flujo de la ejecución y realiza las tareas de forma automática y en un orden especificado.

Si bien esto te puede parecer algo que cualquier lenguaje pueda realizar la realidad es que BPEL esta diseñador para estos escenarios lo que permite una programación mucho mas rápida.

The post Que es BPEL appeared first on Oscar Blancarte - Software Architecture.