Bridge (patrón de deseño)

Na Galipedia, a Wikipedia en galego.

O patrón Ponte, tamén coñecido como Bridge, é un patrón, pertencente á categoría de patróns estruturais, empregado na enxeñaría do software. Con él pretendese separar unha abstracción da súa implementación, desta forma poderanse empregar implementacións alternativas.

O patrón Ponte pode ser moi útil cando as implementacións varian a miúdo. Nese caso, as características da programación orientada a obxetos, tórnanse moi útiles, podendo facer cambios no código cun mínimo coñecemento previo do programa.

Obxectivos[editar | editar a fonte]

  • Desacoplar unha abstracción da súa implementación de forma que ambas poidan variar independentemente.
  • Illamento mais aló da encapsulación.

Aplicabilidade[editar | editar a fonte]

Podemos empregar o patrón Ponte cando:

  • Queremos evitar unha ligazón permanente entre a abstracción e a súa implementación, podendo ser debido a que a implementación debe ser seleccionada ou cambiada en tempo de execución.
  • Tanto as abstracción coma as súas implementación deben ser extensibles por medio de subclases. Neste caso, o patrón Ponte permite combinar abstracción e implementación diferentes e estendelas independentemente.
  • Os cambios na implementación dunha abstracción non deben impactar nos clientes,o seu código non ten que ser recompilado.
  • Queremos ocultar a implementación dunha abstracción completamente ós clientes.
  • Deséxase compartir unha implementación entre múltiples obxectos, e isto é ocultado ós clientes.

Participantes[editar | editar a fonte]

  • Abstracción (Abstraction): define a clase interface. Mantén unha referencia ó obxecto implementador.
  • Abstracción refinada (RefinedAbstraction): estende e implementa a interface Abtracción.
  • Implementador (Implementor): define a interface para as clases implementación. Esta interface non ten que corresponderse exactamente coa interface de Abstraction, as das interfaces poden ser bastante diferentes. Tipicamente a interface Implementor provee só operacións primitivas, e Abstraction define operacións de alto nivel baseadas nestas primitivas.
  • Implementador Concreto (ConcreteImplementor): as clases implementadas

Consecuencias[editar | editar a fonte]

  • Desacoplamento do obxecto interface e implementación: una implementación non é limitada permanentemente a unha interface. A implementación dunha abstracción pode configurarse en tempo de execución. Ademais, un obxecto, ten a posibilidade de cambiar a súa implementación en tempo de execución. Desacopla Abstraction e Implementor tamén elimina as dependencias sobre a implementación en tempo de compilación. Cambiar unha clase de implementación non require recompilar a clase Abstraction nin os seus clientes. Esta propiedade é esencial cando hai que asegurar a compatibilidade binaria entre diferentes versións dunha biblioteca de clases, fomentando as capas, que nos leven a un nivel mellor estruturado.
  • Mellorar a estensibilidade: Pódese estender as xerarquías de abstracción e implementación de forma independente.

Estrutura[editar | editar a fonte]

O cliente non quere lidiar cos detalles dependentes da plataforma. O patrón Ponte encapsula estas complexidades tras unha capa abstracta.

Ponte enfatiza identificar e desacoplar a abstracción de interface da abstracción da implementación.

px 500

Implementación[editar | editar a fonte]

  • Só un Implementador: en situación onde existe só unha implementación, non é preciso crear una clase Implementor abstracta, sendo este, un caso especial do patrón no que hai unha relación un-a-un entre Abstraction e Implementor. Non obstante, esta separación é moi útil cando un cambio na implementación dunha clase non debe afectar os seus clientes.
  • Implemementador: Sendo esta unha das principais diferenzas có patrón estratexia, se a abstracción coñece a xerarquía de implementadores pode crear o implementador no construtor, podendo decidir cal instanciar dependendo dos parámetros do construtor. O inconveniente ven dado pola dependencia da xerarquía, se aparece un novo teremos que modificar a abstracción.

Outra aproximación é delegar noutro obxecto (singleton), este encargarase de proporciona o implementador concreto da abstracción.

  • Compartir implementadores.
  • Empregando herdanza múltiple.

Ponte con outros patróns[editar | editar a fonte]

  • Adaptador fai que as cousas funcionen despois de ser deseñadas, Ponte fai que as cousas funcionen antes de ser deseñadas.
  • Ponte é deseñado para permitir que a abstracción e a implementación varíen de forma independente.Adaptador é deseñado para que clases non relacionadas traballen xuntas.
  • Estado, Estratexia, Ponte (e algúns casos de Adaptador) teñen solucións estruturais semellantes. Diferéncianse na intención, resolven diferentes problemas.A estrutura de Estado e de Ponte é idéntica (excepto que Ponte admite xerarquías de herdanza envolventes, mentres que Estado só permite unha). Os dous patróns usan a mesma estrutura para resolver diferentes problemas: Estado permite cambiar o comportamento dun obxecto o cambiar o seu estado, mentres que Ponte pretende desacoplar a abstracción da súa implementación, podendo variar estas dúas de forma independiente.
  • Se a clase interface delega a creación a clase implementación, entón o deseño usualmente emprega o patrón Fábrica Abstracta para crear os obxectos implementación.
  • Ponte semella o patrón adaptador , pero mentres que o patrón Adaptador intenta que as interfaces dunha ou mais clases sexa a mesma que para unha clase particular, Ponte está deseñado para separar as clases interfaces da súa implementación, desta forma poder variar e reemplazar as súas implementacions sen cambiar o código cliente.

Exemplo[editar | editar a fonte]

/*
 * Memoria que permite o intercambio dos datos almacenados na mesma
 * 
 */

class MemoriaIntercambio extends Memoria{
	
  public MemoriaIntercambio(ImplementacionMemoria memoria){
    super(memoria);
  }

  // Intercambia o dato almacenado na posición i, co almacenado na posición j
  public void intercambiar(Integer i, Integer j){
    String aux = super.obtener(i);
    super.guardar(i, super.obtener(j));
    super.guardar(j, aux);

  }
}
/*
 * Memoria que unicamente permite obter e gardar datos.
 * 
 */

class Memoria {
	
  public Memoria(ImplementacionMemoria memoria){
    _imp = memoria;
  }

  //Obtén o dato da posición i
  public String obtener(Integer i) { 
    return _imp.obtener(i);
  }

  // Garda o dato na posición i
  public void guardar(Integer i, String dato){ 
    _imp.guardar(i, dato);
  }

  // atributo privado coa implementación específica da memoria
  private ImplementacionMemoria _imp;
}
/**
 * Clase Main do exemplo do patrón Ponte (Bridge)
 *
 */
public class main {

	/**
	 * @param args
	 */
	static public void main(String argv[]) {
		
		ImplementacionMemoria mhash = new ImplementacionHash();
		ImplementacionMemoria mvector = new ImplementacionVector();
		
		Memoria m = new Memoria(mhash);
		MemoriaIntercambio mi = new MemoriaIntercambio(mvector);
		
		m.guardar(0, "0xfa21");
		m.guardar(1, "0x8732");
		m.guardar(2, "0x329f");
		
		mi.guardar(0, "0xfa21");
		mi.guardar(1, "0x8732");
		mi.intercambiar(0, 1);
		
		System.out.println(m.obtener(1));
		
		System.out.println(mi.obtener(0));
	}

}
/*
 * Implementación de Memoria usando Vector.
 * 
 */

import java.util.Vector;

class ImplementacionVector implements ImplementacionMemoria {

  public ImplementacionVector() {
    _mem = new Vector<String>();
  }
  //Obtén o dato da posición i
  public String obtener(Integer i) {
    return _mem.get(i.intValue());
  }

  // Garda o dato na posición i
  public void guardar(Integer i, String dato) {
	if (_mem.size() <= i){
		while (_mem.size() <= i){
			_mem.add("nil");
		}
	}
    _mem.set(i.intValue(), dato);
  }


  private Vector<String> _mem;
}
/*
 * Interface que debe de ser implementada, polas implementacións específicas da memoria
 * 
 */

interface ImplementacionMemoria {

  //Obtén o dato da posición i
  public String obtener(Integer i);

  // Guarda el dato en la posición i
  public void guardar(Integer i, String dato);

}
/*
 * Implementación de Memoria usando HashMap.
 * 
 */

import java.util.HashMap;

class ImplementacionHash implements ImplementacionMemoria {

  public ImplementacionHash() {
    _mem = new HashMap<Integer, String>();
  }
  //Obtén o dato da posición i
  public String obtener(Integer i) {
    return _mem.get(i);
  }

  // Garda o dato na posición i
  public void guardar(Integer i, String dato) { 
    _mem.put(i, dato);
  }


  private HashMap<Integer, String> _mem;
}