FACULTAD DE INGENIERA
TEMA:
REQUERIMIENTOS Y PATRONES
CURSO:
ING. DE SOFTWARE
PROFESOR:
CAMILO SUAREZ
INTEGRANTES:
AO:
2016
Requerimientos y Patrones
1. Requerimientos
1.1.
Introduccin
1.2.
o REQUERIMIENTOS NO FUNCIONALES
Son aquellos requerimientos que no se refieren directamente a
las funciones especficas que entrega el sistema, sino a las
propiedades emergentes de ste como la fiabilidad, la respuesta
en el tiempo y la capacidad de almacenamiento. De forma
alternativa, definen las restricciones del sistema como la
capacidad de los dispositivos de entrada/salida y la
representacin de datos que se utiliza en la interface del sistema.
Los requerimientos no funcionales surgen de la necesidad del
usuario, debido a las restricciones en el presupuesto, a las
polticas de la organizacin, a la necesidad de interoperabilidad
con otros sistemas de software o hardware o a factores externos
como los reglamentos de seguridad, las polticas de privacidad,
entre otros.
o SEUDO-REQUERIMIENTOS
Ejemplos
Lenguaje de implementacin.
Plataforma en que el sistema debe ser implementado.
Requerimientos del proceso y documentacin.
o Greenfield
o Ingeniera de Interfaz
1.3.
Esto sirve para definir las fronteras del sistema y para encontrar
todas las perspectivas desde las cuales los desarrolladores
necesitan considerarlo. Cuando el sistema se despliega en una
organizacin existente (como una compaa), por lo general ya
existen la mayora de los actores antes de que se desarrolle el
sistema y corresponden a los papeles dentro de la organizacin.
Documentacin
Consideraciones de hardware
1.4.
Caractersticas de desempeo
Asuntos de calidad
Modificaciones al sistema
Ambiente Fsico
Ambiente Fsico
Cuestiones de Seguridad
Cuestiones de recursos.
Identificacin de procedimientos
Investigacin.
Preparacin.
Sesin.
Durante esta actividad el coordinador JAD gua al equipo
para la creacin de la especificacin del sistema. Una
Documento final.
Prueba de escenario.
Durante esta prueba se presenta un escenario visionario
del sistema ante uno o ms usuarios. Los desarrolladores
identifican qu tan rpido pueden comprender tos usuarios
el escenario, con cunta precisin representa su modelo
de trabajo y qu tan positivamente reaccionan a la
descripcin del nuevo sistema. Los escenarios
seleccionados debern ser lo ms realistas y detallados
posible. Una prueba de escenario permite una retroalimentacin rpida y frecuente del usuario. Las pruebas
de escenario pueden realizarse como maquetas en papel o
con un ambiente prototipo simple, el cual con frecuencia es
ms fcil de aprender que el ambiente de programacin
que se usa para el desarrollo. La ventaja de las pruebas de
escenario es que es barato realizarlas y repetirlas. La
desventaja es que el usuario no puede interactuar en forma
directa con el sistema y que los datos son fijos.
Prueba de prototipo.
Prueba de producto
2. Patrones
2.1.
2.1.1. Definicin
2.1.2. Esquema
Cliente
La clase que llamar a la factora adecuada ya que necesita crear
uno de los objetos que provee la factora, es decir, Cliente lo que
quiere es obtener una instancia de alguno de los productos
(ProductoA, ProductoB).
AbstractFactory
Es la definicin de la interfaces de las factoras. Debe de proveer un
mtodo para la obtencin de cada objeto que pueda crear.
("crearProductoA()" y "crearProductoB()")
Factoras Concretas
Estas son las diferentes familias de productos. Provee de la instancia
concreta de la que se encarga de crear. De esta forma podemos
tener una factora que cree los elementos grficos para Windows y
otra que los cree para Linux, pudiendo poner fcilmente (creando
una nueva) otra que los cree para MacOS, por ejemplo.
Producto abstracto
Definicin de las interfaces para la familia de productos genricos.
En el diagrama son "ProductoA" y "ProductoB". En un ejemplo de
interfaces grficas podran ser todos los elementos: Botn, Ventana,
Cuadro de Texto, Combo... El cliente trabajar directamente sobre
esta interfaz, que ser implementada por los diferentes productos
concretos.
Producto concreto
Implementacin de los diferentes productos. Podra ser por ejemplo
"BotnWindows" y "BotnLinux". Como ambos implementan "Botn"
el cliente no sabr si est en Windows o Linux, puesto que trabajar
directamente sobre la superclase o interfaz.
import java.sql.*;
public class AccessClienteDAO implements ClienteDAO {
...
public Cliente create (String nombre, String nif, String correo, String
usuario, String clave) throws DAOException {
Connection con = null;
try {
con = ds.getConnection();
Statement stmt = con.createStatement();
stmt.executeUpdate(...);
stmt.close(); con.close();
Cliente c = new Cliente();
c.setNombre(nombre);
... return c; }
2.2.
Patrn Estrategy
2.2.1. Definicin
2.2.2. Esquema
/** Salida:
* Estrategia A
* Estrategia B
* Estrategia A
**/
}
}
/* Fichero ConexionOracle.php */
// Estrategia concreta: Oracle
class ConexionOracle implements Conexion {
public function conectar($usuario, $clave) {
return oci_connect($usuario, $clave);
}
}
/* Fichero ConexionMysql.php */
// Estrategia concreta: MySQL
class ConexionMysql implements Conexion {
public function conectar($usuario, $clave) {
return mysql_connect("localhost", $usuario, $clave);
}
}
/* Fichero index.php */
// Contexto
/*
* $_POST['dbms'] proviene de un cuadro desplegable (option select) en
que se da a escoger entre oracle y mysql.
* ucfirst() pone en mayscula la primera letra
*/
$conector = "Conexion" . ucfirst($_POST['dbms']);
$instancia = new $conector;
try {
$recurso = $instancia->conectar($_POST['usuario'],
$_POST['clave']);
} catch (Exception $e) {
echo "Lo sentimos, pero por algn motivo la conexin ha fallado.";
}
2.3.
2.3.1. Definicin
2.3.2. Esquema
import java.sql.*;
public class AccessClienteDAO implements ClienteDAO {
...
public Cliente create (String nombre, String nif, String correo, String
usuario, String clave) throws DAOException {
Connection con = null;
try {
con = ds.getConnection();
Statement stmt = con.createStatement();
stmt.executeUpdate(...);
stmt.close(); con.close();
Cliente c = new Cliente();
c.setNombre(nombre);
... return c; }
2.4.
Patrn Prototype
2.4.1. Definicin
El patrn de diseo Prototype (Prototipo), tiene como finalidad
crear nuevos objetos duplicndolos, clonando una instancia
creada previamente.
Este patrn especifica la clase de objetos a crear mediante la
clonacin de un prototipo que es una instancia ya creada. La
clase de los objetos que servirn de prototipo deber incluir en su
interfaz la manera de solicitar una copia, que ser desarrollada
luego por las clases concretas de prototipos.
2.4.2. Esquema
public FactoriaPrototipo() {
mapaObjetos = new HashMap();
// Se incluyen en el mapa todos los productos prototipo
mapaObjetos.put("producto 1", new UnProducto(1));
}
try {
clone = super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return clone;
}
}
public Rectangle(){
type = "Rectangle";
}
@Override
public void draw() {
System.out.println("Insideangle::draw() method.");
}
}
public class Square extends Shape {
public Square(){
type = "Square";
}
@Override
public void draw() {
System.out.println("Insidere::draw() method.");
}
}
public class Circle extends Shape {
public Circle(){
type = "Circle";
}
@Override
public void draw() {
System.out.println("Insidele::draw() method.");
}
}
A continuacin creamos la clase que nos va a proporcionar su cacheo y evitar
crearlos leyendo de la base de datos.
import java.util.Hashtable;
shapeMap.put(circle.getId(),circle);
shapeMap.put(square.getId(),square);
shapeMap.put(rectangle.getId(), rectangle);
}
}
Tan solo nos queda usarlo
Shape : Circle
Shape : Square
Shape : Rectangle
2.5.
Patrn Singleton
2.5.1. Definicin
2.5.2. Esquema
}
}
2.6.
Patrn Adapter
2.6.1. Definicin
2.6.2. Esquema
package Structural_patterns;
public class AdapterWrapperPattern {
public static void main(String args[]){
Guitar eGuitar = new ElectricGuitar();
eGuitar.onGuitar();
eGuitar.offGuitar();
Guitar eAGuitar = new ElectricAcousticGuitar();
eAGuitar.onGuitar();
eAGuitar.offGuitar();
}
public abstract class Guitar{
abstract public void onGuitar();
abstract public void offGuitar();
}
public class ElectricGuitar extends Guitar{
public void onGuitar() {
System.out.println("Playing Guitar");
}
public void offGuitar() {
System.out.println("I'm tired to play the guitar");
}
}
/**
* Class to Adapter/Wrapper
*/
public class AcousticGuitar{
/**
* we Adapter/Wrapper AcousticGuitar into
* ElectricAcousticGuitar to adapt into the GuitarModel
*/
public class ElectricAcousticGuitar extends Guitar{
AcousticGuitar acoustic = new AcousticGuitar();
de
desarrolladores.
Para
empezar
tenemos
una
Las clases que implementan sta interfaz son Amigo y Familiar, les
recuerdo que las clases sern de lo mas simple, con el fin de enfocarnos
nicamente en la implementacin del patrn:
desarrollar
una
nueva
clase
para
los
contactos
que
2.7.
Patrn Bridge
2.7.1. Definicin
2.7.2. Esquema
interface Implementador {
public abstract void operacion();
}
}
}
2.8.
Patrn Composite
2.8.1. Definicin
2.8.2. Esquema
Component
Es la abstraccin de todos los componentes, incluyendo los compuestos
declara la interfaz de objetos en la composicin (Opcional) define una
interfaz para acceder a los padres de un componente en la estructura
recursiva, y aplica esto si lo considera apropiado
Leaf
Representa objetos hoja en la composicin implementa todos los
mtodos de componentes
Composite
{
private ArrayList<Componente> hijo = new ArrayList<Componente>();
public Compuesto (String name)
{
super(name);
}
@Override
public void agregar(Componente componente)
{
hijo.add(componente);
}
@Override
public void eliminar(Componente componente)
{
hijo.remove(componente);
}
@Override
public void mostrar(int profundidad)
{
System.out.println(nombre + " nivel: " + profundidad);
for (int i = 0; i < hijo.size(); i++)
hijo.get(i).mostrar(profundidad + 1);
}
}
class Hoja extends Componente
{
public Hoja (String nombre)
{
super(nombre);
}
public void agregar(Componente c)
{
System.out.println("no se puede agregar la hoja");
}
public void eliminar(Componente c)
{
System.out.println("no se puede quitar la hoja");
}
public void mostrar(int depth)
{
System.out.println('-' + "" + nombre);
}
}
public class Client
{
public static void main(String[] args)
{
Compuesto raiz = new Compuesto("root");
raiz.agregar(new Hoja("hoja A"));
raiz.agregar(new Hoja("hoja B"));
Compuesto comp = new Compuesto("compuesto X");
comp.agregar(new Hoja("hoja XA"));
comp.agregar(new Hoja("hoja XB"));
raiz.agregar(comp);
raiz.agregar(new Hoja("hoja C"));
Hoja l = new Hoja("hoja D");
raiz.agregar(l);
raiz.eliminar(l);
raiz.mostrar(1);
}
}
package corepatterns.apps.psa.ejb;
import corepatterns.apps.psa.core.*;
import corepatterns.apps.psa.dao.*;
import java.sql.*;
import javax.sql.*;
import java.util.*;
import javax.ejb.*;
import javax.naming.*;
...
} catch(Exception ex) {
throw new EJBException("Reason:" + ...);
}
if(result) {
return primaryKey;
}
else {
throw new ObjectNotFoundException(...);
}
}
return skillSets;
}
...
...
}
} catch (Exception exc) {
throw new EJBException(...);
}
}
...
}
2.9.
Patrn Decorator
2.9.1. Definicin
2.9.2. Esquema
Componente
Dene la interfaz para los objetos que pueden tener
responsabilidades aadidas.
Componente Concreto
Dene un objeto al cual se le puede agregar responsabilidades
adicionales.
Decorador
Decorador Concreto
2.10.1.
Definicin
2.10.2.
Esquema
Fachada (Facade)
2.10.3.
Ejemplo General
package com.genbetadev;
public class Impresora {
private String tipoDocumento;
private String hoja;
private boolean color;
private String texto;
public String getTipoDocumento() {
return tipoDocumento;
}
public void setTipoDocumento(String tipoDocumento) {
this.tipoDocumento = tipoDocumento;
}
public String getHoja() {
return hoja;
}
public void setHoja(String hoja) {
this.hoja = hoja;
}
}
Se trata de una clase sencilla que imprime documentos en uno u otro formato.
El cdigo de la clase cliente nos ayudar a entender mejor su funcionamiento.
package com.genbetadev;
public class PrincipalCliente {
public static void main(String[] args) {
Impresora i = new Impresora();
i.setHoja("a4");
i.setColor(true);
i.setTipoDocumento("pdf");
i.setTexto("texto 1");
i.imprimirDocumento();
Impresora i2 = new Impresora();
i2.setHoja("a4");
i2.setColor(true);
i2.setTipoDocumento("pdf");
i2.setTexto("texto 2");
i2.imprimirDocumento();
Impresora i3 = new Impresora();
i3.setHoja("a3");
i3.setColor(false);
i3.setTipoDocumento("excel");
i3.setTexto("texto 3");
i3.imprimirDocumento();}}
Como podemos ver la clase cliente se encarga de invocar a la impresora, y
configurarla para despus imprimir varios documentos .Ahora bien
prcticamente todos los documentos que escribimos tienen la misma estructura
(formato A4, Color , PDF). Estamos continuamente repitiendo cdigo. Vamos a
construir una nueva clase FachadaImpresoraNormal que simplifique la
impresin de documentos que sean los ms habituales.
package com.genbetadev;
public class FachadaImpresoraNormal {
Impresora impresora;
public FachadaImpresoraNormal(String texto) {
super();
impresora= new Impresora();
impresora.setColor(true);
impresora.setHoja("A4");
impresora.setTipoDocumento("PDF");
impresora.setTexto(texto);
}
public void imprimir() {
impresora.imprimirDocumento();} }
De esta forma el cliente quedar mucho ms sencillo :
package com.genbetadev;
public class PrincipalCliente2 {
public static void main(String[] args) {
FachadaImpresoraNormal fachada1= new
FachadaImpresoraNormal("texto1");
fachada1.imprimir();
FachadaImpresoraNormal fachada2= new
FachadaImpresoraNormal("texto2");
fachada2.imprimir();
Impresora i3 = new Impresora();
i3.setHoja("a4");
i3.setColor(true);
i3.setTipoDocumento("excel");
i3.setTexto("texto 3");
i3.imprimirDocumento();} }
package com.genbetadev;
public class PrincipalCliente {
public static void main(String[] args) {
Impresora i = new Impresora();
i.setHoja("a4");
i.setColor(true);
i.setTipoDocumento("pdf");
i.setTexto("texto 1");
i.imprimirDocumento();
Impresora i2 = new Impresora();
i2.setHoja("a4");
i2.setColor(true);
i2.setTipoDocumento("pdf");
i2.setTexto("texto 2");
i2.imprimirDocumento();
Impresora i3 = new Impresora();
i3.setHoja("a3");
i3.setColor(false);
i3.setTipoDocumento("excel");
i3.setTexto("texto 3");
i3.imprimirDocumento();} }
Como podemos ver la clase cliente se encarga de invocar a la impresora, y
configurarla para despus imprimir varios documentos .Ahora bien
prcticamente todos los documentos que escribimos tienen la misma estructura
(formato A4, Color , PDF). Estamos continuamente repitiendo cdigo. Vamos a
construir una nueva clase FachadaImpresoraNormal que simplifique la
impresin de documentos que sean los ms habituales.
package com.genbetadev;
public class FachadaImpresoraNormal {
Impresora impresora;
public FachadaImpresoraNormal(String texto) {
super();
impresora= new Impresora();
impresora.setColor(true);
impresora.setHoja("A4");
impresora.setTipoDocumento("PDF");
impresora.setTexto(texto); }
public void imprimir() {
impresora.imprimirDocumento();}}
De esta forma el cliente quedar mucho ms sencillo :
package com.genbetadev;
public class PrincipalCliente2 {
public static void main(String[] args) {
FachadaImpresoraNormal fachada1= new
FachadaImpresoraNormal("texto1");
fachada1.imprimir();
FachadaImpresoraNormal fachada2= new
FachadaImpresoraNormal("texto2");
fachada2.imprimir();
Impresora i3 = new Impresora();
i3.setHoja("a4");
i3.setColor(true);
i3.setTipoDocumento("excel");
i3.setTexto("texto 3");
i3.imprimirDocumento();
}package com.ezjamvc.modelo.facade;
import com.ezjamvc.modelo.dao.ArticuloDAO;
import com.ezjamvc.modelo.dto.ArticuloDTO;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
/** @author asuncion */
public class ArticuloFacade {
private Connection cnn;
private ArticuloDAO dao;
package com.ezjamvc.modelo.delegate;
import com.ezjamvc.modelo.dto.ArticuloDTO;
import com.ezjamvc.modelo.facade.ArticuloFacade;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.util.List;
/**
*
* @author asuncion
*/
public class EzjaMVCDelegate {
private Connection cnn;
private ArticuloFacade artFacade;
public EzjaMVCDelegate() {
String user = "root";
String pwd = "admin";
String url = "jdbc:mysql://localhost:3306/EzjaMVC";
String mySqlDriver = "com.mysql.jdbc.Driver";
try {
Class.forName(mySqlDriver);
cnn = DriverManager.getConnection(url, user, pwd);
} catch (Exception e) {
e.printStackTrace();
}
artFacade = new ArticuloFacade(cnn);
}
//Codigo para los Articulos
public void crearArticulo(ArticuloDTO dto) throws SQLException {
artFacade.crear(dto);
}
public List listarArticulos() throws SQLException {
return artFacade.listar();
}
public ArticuloDTO leerArticulo(ArticuloDTO dto) throws SQLException {
return artFacade.leer(dto);
}
public void actualiza(ArticuloDTO dto) throws SQLException {
artFacade.actualiza(dto);
}
public void elimina(ArticuloDTO dto) throws SQLException {
artFacade.elimina(dto);
}
}
Al revisar el codigo, nos podemos dar cuenta que al momento de definir el
constructor, se obtiene una conexion a la base de datos, la cual se pasa como
parametro a la instancia de ArticuloFacade que se crea.
Cabe mencionar que la estructura final de la aplicacion es la siguiente.
Logger.getLogger(PruebaDelegate.class.getName()).log(Level.SEVERE, null,
ex); } }}
Y con esto terminamos con todas las capas del modelo de la aplicacion
propuesta. En la cual se aplican los 4 patrones antes mencionados:
1.
2.
3.
4.
2.11.1.
Definicin
2.11.2.
Esquema
Manejador
Define una interfaz para tratar las peticiones. Opcionalmente,
implementa el enlace al sucesor.
ManejadorConcreto
Cliente
Inicializa la peticin a un Manejador Concreto de la cadena.
2.11.3.
Ejemplo General
System.out.println(rambo.orden());
// rambo ->
rambo.establecerMando(truman);
System.out.println(rambo.orden());
ryan.establecerMando(rambo);
System.out.println(ryan.orden());
}}
public abstract class Unidad {
public Unidad(String nombre) {
_mando = null;
_nombre = nombre; }
public String toString() { return _nombre; }
public void establecerMando(Unidad mando) { _mando = mando; }
public String orden() {
return (_mando != null ? _mando.orden() : "(sin orden)");
}
private Unidad _mando;
private String _nombre;
}
public class Coronel extends Unidad {
public Coronel(String nombre, String orden) {
super(nombre);
_orden = orden;
}
public String orden()
2.11.4.
2.12.1.
Definicin
2.12.2.
Esquema
AbstractCommand.
Clase que ofrece una interfaz para la ejecucin de rdenes.
Define los mtodos do y undo que se implementarn en cada
clase concreta.
ConcreteCommand.
Clase que implementa una orden concreta y sus mtodos do y
undo. Su constructor debe inicializar los parmetros de la orden.
Invoker.
Clase que instancia las rdenes, puede a su vez ejecutarlas
inmediatamente (llamando a do) o dejar que el
CommandManager lo haga.
CommandManager.
Responsable de gestionar una coleccin de objetos orden
creadas por el Invoker. llamar a los mtodos do y unDo.
Gestionar su secuenciacin y reordenacin (sobre la base de
prioridades por ejemplo).
switch (args[0]) {
case "ON":
mySwitch.flipUp();
break;
case "OFF":
mySwitch.flipDown();
break;
default:
System.err.println("Argument \"ON\" or \"OFF\" is required.");
System.exit(-1);
}
}
}
2.12.4.
using Oracle.DataAccess.Client;
public class OracleDatabase : Database
{
public override IDbConnection CreateConnection()
{
return new OracleConnection(connectionString);
}
public override IDbCommand CreateCommand()
{
return new OracleCommand();
}
public override IDbConnection CreateOpenConnection()
{
2.13.1.
Definicin
Este patrn tambin se conoce como el patrn de publicacininscripcin o modelo-patrn. Estos nombres sugieren las ideas
bsicas del patrn, que son: el objeto de datos, que se le puede
llamar Sujeto a partir de ahora, contiene atributos mediante los
cuales cualquier objeto Observador o vista se puede suscribir a l
pasndole una referencia a s mismo. El Sujeto mantiene as una
lista de las referencias a sus observadores. Los observadores a
su vez estn obligados a implementar unos mtodos
determinados mediante los cuales el Sujeto es capaz de notificar
a sus observadores suscritos los cambios que sufre para que
todos ellos tengan la oportunidad de refrescar el contenido
representado. De manera que cuando se produce un cambio en
el Sujeto, ejecutado, por ejemplo, por alguno de los observadores,
el objeto de datos puede recorrer la lista de observadores
avisando a cada uno. Este patrn suele observarse en
los frameworks de interfaces grficas orientados a objetos, en los
que la forma de capturar los eventos es suscribir listeners a los
objetos que pueden disparar eventos.
2.13.2.
Esquema
Sujeto (Subject):
El sujeto proporciona una interfaz para agregar
(attach) y eliminar (detach) observadores. El Sujeto
conoce a todos sus observadores.
Observador (Observer):
2.13.3.
import java.util.*;
Ejemplo General
class MiApp {
public static void main(String[] args) {
out.println("Introducir Texto >");
FuenteEvento fuenteEvento = new FuenteEvento();
new Thread(fuenteEvento).start();
}
}
2.13.4.
import java.util.*;
public Database()
{
observers = new Vector<Observer>();
}
.
}
Cuando se utiliza un vector, hacer el seguimiento de los observadores es
simple. Cuando un observador quiere dar de alta, se llama al mtodo
registerObserver del sujeto, hacindose pasar como un objeto. El sujeto objeto de nuestra clase de base de datos - slo tiene que aadir que el vector
de observador a los observadores en el mtodo registerObserver, utilizando el
mtodo de complemento de la clase Vector.
import java.util.*;
public class Database implements Subject
{
private Vector<Observer> observers;
public Database()
{
observers = new Vector<Observer>();
}
public void registerObserver(Observer o)
{
observers.add(o);
}
.
.
.
}
public Database()
{
observers = new Vector<Observer>();
}
public Database()
{
observers = new Vector<Observer>();
}
.
.
.
public void editRecord(String operation, String record)
{
this.operation = operation;
this.record = record;
notifyObservers();
}
}
Aqu est la carne del cdigo, la parte que notifica a cada observador que ha
habido un cambio: el mtodo notifyObservers. Cada observador implementa la
interfaz de este ejemplo Observador - que significa que tiene un mtodo de
actualizacin - por lo notifyObservers acaba de bucle para todos los
observadores registrados en el vector de observadores, llamando al mtodo de
actualizacin de cada uno con la operacin de base de datos y registro
afectado.
import java.util.*;
public class Database implements Subject
{
private Vector<Observer> observers;
private String operation;
private String record;
.
.
.
public void notifyObservers()
{
for (int loopIndex = 0; loopIndex < observers.size(); loopIndex++) {
Observer observer = (Observer)observers.get(loopIndex);
observer.update(operation, record);
}
}
this.record = record;
notifyObservers();
}
}
2.14.1.
2.14.2.
Definicin
Esquema
//Mediador Abstracto
interface IMediator {
void book();
void view();
void search();
void registerView(BtnView v);
void registerSearch(BtnSearch s);
void registerBook(BtnBook b);
void registerDisplay(LblDisplay d);
}
//Mediador Concreto
class Mediator implements IMediator {
BtnView btnView;
BtnSearch btnSearch;
BtnBook btnBook;
LblDisplay show;
//....
void registerView(BtnView v) {
btnView = v;
}
void registerSearch(BtnSearch s) {
btnSearch = s;
}
void registerBook(BtnBook b) {
btnBook = b;
}
void registerDisplay(LblDisplay d) {
show = d;
}
void book() {
btnBook.setEnabled(false);
btnView.setEnabled(true);
btnSearch.setEnabled(true);
show.setText("booking...");
}
void view() {
btnView.setEnabled(false);
btnSearch.setEnabled(true);
btnBook.setEnabled(true);
show.setText("viewing...");
}
void search() {
btnSearch.setEnabled(false);
btnView.setEnabled(true);
btnBook.setEnabled(true);
show.setText("searching...");
}
IMediator med;
IMediator med;
IMediator med;
IMediator med;
LblDisplay(IMediator m) {
super("Just start...");
med = m;
med.registerDisplay(this);
setFont(new Font("Arial", Font.BOLD, 24));
}
MediatorDemo() {
JPanel p = new JPanel();
p.add(new BtnView(this, med));
p.add(new BtnBook(this, med));
p.add(new BtnSearch(this, med));
getContentPane().add(new LblDisplay(med), "North");
getContentPane().add(p, "South");
setSize(400, 200);
setVisible(true);
}
2.14.4.
class Logger {
logger.initLogger("someLogger");
logger.debug("message");
Implementation:
class Logger {
if ( loggerName == "someLogger" ) {
out.println( message );
} else if ( loggerName == "serverLog" ) {
ObjectOutputStrewam oos =
new ObjectOutputStrewam( client.getOutputStream());
oos.writeObject( message );
} else if( loggerName == "dblog") {
Pstmt pstmt = dbConnection.prepareStatment( LOG_SQL );
pstmt.setParameter(1, message );
pstmt.executeUpdate();
dbConnection.commit();
}
}
}
En este cdigo, el mediador es el que contiene la lgica de negocio para crear
el "canal" para iniciar una sesin y tambin para hacer el registro en ese canal.
l es "crear" la funcionalidad.
Por supuesto, hay mejores formas de implementar esto usando polimorfismo,
pero el punto aqu es mostrar cmo el mediador "agrega" nueva funcionalidad
mediante la combinacin de la funcionalidad existente (en mi muestra no
mostr mucho lo siento), pero se imaginan el mediador, leen a partir de la base
de datos del host remoto para iniciar la sesin en donde, a continuacin, crea
un cliente y finalmente escribir en la impresora del cliente que transmitir los
mensajes de registro. De esta manera el mediador sera "mediar" entre los
diferentes objetos.
Por ltimo, la fachada es un patrn estructural, es decir que describe la
composicin de los objetos, mientras que el mediador es un comportamiento,
es decir, que describe la forma interactan los objetos.
2.15. Patrn Template Method
2.15.1.
Definicin
2.15.2.
Esquema
2.15.3.
Ejemplo General
/* A template method : */
public final void playOneGame(int playersCount) {
this.playersCount = playersCount;
initializeGame();
int j = 0;
while (!endOfGame()) {
makePlay(j);
j = (j + 1) % playersCount;
}
printWinner();
}
}
// ...
}
// ...
}
2.15.4.
DataParser.java
package org.arpit.javapostsforlearning;
abstract public class DataParser {
//Template method
//This method defines a generic structure for parsing data
public void parseDataAndGenerateOutput() {
readData();
processData();
writeData(); }
//This methods will be implemented by its subclass
abstract void readData();
abstract void processData();
//We have to write output in a CSV file so this step will be same for all subclasses
public void writeData() {
System.out.println('Output generated,writing to CSV'); }}
In below class,CSV specific steps are implement in this class
CSVDataParser.java
package org.arpit.javapostsforlearning;
public class CSVDataParser extends DataParser {
void readData() {
System.out.println('Reading data from csv file'); }
void processData() {
System.out.println('Looping through loaded csv file');
}}
DatabaseDataParser.java
package org.arpit.javapostsforlearning;
}}
TemplateMethodMain.java
package org.arpit.javapostsforlearning;
public class TemplateMethodMain {
public static void main(String[] args) {
CSVDataParser csvDataParser=new CSVDataParser();
csvDataParser.parseDataAndGenerateOutput();
System.out.println('**********************');
DatabaseDataParser databaseDataParser=new DatabaseDataParser();
databaseDataParser.parseDataAndGenerateOutput();
}
}
output:
Reading data from csv file
Looping through loaded csv file
Output generated,writing to CSV
**********************
Reading data from database
Looping through datasets
Output generated,writing to CSV
2.16.1.
Definicin
2.16.2.
Esquema
Visitante (Visitor)
Declara una operacin de visita para cada elemento concreto en
la estructura de objetos, que incluye el propio objeto visitado
Elemento (Element)
Define una operacin Accept que toma un visitante como
argumento
package expresion;
public class Constante extends Expresion {
public Constante(int valor) { _valor = valor; }
public void aceptar(VisitanteExpresion v) { v.visitarConstante(this); }
int _valor;
}
package expresion;
package expresion;
public abstract class OpBinaria extends Expresion {
public OpBinaria(Expresion izq, Expresion der) { _izq = izq; _der = der; }
Expresion _izq, _der;
}
package expresion;
public class Suma extends OpBinaria {
public Suma(Expresion izq, Expresion der) { super(izq, der); }
public void aceptar(VisitanteExpresion v) { v.visitarSuma(this); }
}
package expresion;
public class Mult extends OpBinaria {
public Mult(Expresion izq, Expresion der) { super(izq, der); }
public void aceptar(VisitanteExpresion v) { v.visitarMult(this); }
}
/*
* Esta es la clase abstracta que define la interfaz de los visitantes
* de la jerarqua Expresion -- en realidad, utilizamos una interfaz Java
* dado que todos los mtodos son abstractos.
*/
package expresion;
public interface VisitanteExpresion {
public void visitarSuma(Suma s);
public void visitarMult(Mult m);
public void visitarVariable(Variable v);
public void visitarConstante(Constante c);
}
/**
* Uno de los posibles visitantes de las Expresiones es un pretty printer
* que convierte a cadena de caracteres la expresin aritmtica. El algoritmo
* usado no optimiza el uso de parntesis... El resultado se acumula en
* el atributo privado _resultado, pudindose acceder a ste desde el exterior
* mediante el mtodo obtenerResultado()
*/
package expresion;
public class PrettyPrinterExpresion implements VisitanteExpresion {
op._der.aceptar(this);
String pDer = obtenerResultado();
import expresion.*;
class Main {
static public void main(String argv[]) {
// Construccin de una expresin (a+5)*(b+1)
Expresion expresion = new Mult( new Suma( new Variable("a"),
new Constante(5) ),
new Suma( new Variable("b"),
new Constante(1) ));
// Pretty-printing...
PrettyPrinterExpresion pretty = new PrettyPrinterExpresion();
expresion.aceptar(pretty);
// Visualizacion de resultados
System.out.println("Resultado: " + pretty.obtenerResultado());
}
}
2.16.4.
return result;
}
}
Mientras que bindValue por el contrario, sera principalmente cuidar de enlace
variable
class BindValue {
Object value;
public String getSQL() {
return "?";
}
public int bind(PreparedStatement statement, int nextIndex) {
statement.setObject(nextIndex, value);
return nextIndex + 1;
}
}
En combinacin, ahora podemos crear fcilmente las condiciones de esta
forma:? ENTRE ? Y?. Cuando se implementan ms QueryParts, tambin
podramos imaginar cosas como MY_TABLE.MY_FIELD ENTRE? Y (SELECT?
FROM DUAL), cuando las implementaciones de campo apropiados estn
disponibles. Eso es lo que hace que el patrn compuesto tan potente, una API
comn y muchos componentes que encapsulan el comportamiento, delegando
partes del comportamiento de los subcomponentes.
Paso 2 se ocupa de la evolucin de la API
}
public void bind(BindContext context) {
context.bind(field).bind(lower).bind(upper);
}
}
class BindValue {
Object value;