Pattern ng Disenyo ng Tulay

Hi! Nagpapatuloy kami ngayon sa pagsasaliksik sa isang malawak at sobrang mahalagang kapaki-pakinabang na paksa: mga pattern ng disenyo. Ngayon pag-usapan natin ang pattern ng tulay. Tulad ng ibang mga pattern, nagsisilbi ang tulay na pattern upang malutas ang mga tipikal na problema na nararanasan ng isang developer kapag nagdidisenyo ng arkitektura ng software. Ngayon pag-aralan natin ang mga tampok ng pattern na ito at alamin kung paano ito gamitin.

Ano ang pattern ng tulay?

Ang pattern ng tulay ay isang pattern ng disenyo ng istruktura. Sa madaling salita, ang pangunahing trabaho nito ay lumikha ng isang ganap na istraktura mula sa mga klase at bagay. Ginagawa ito ng tulay sa pamamagitan ng paghahati ng isa o higit pang mga klase sa magkakahiwalay na hierarchy: abstraction at pagpapatupad . Ang pagbabago sa functionality sa isang hierarchy ay hindi nangangailangan ng pagbabago sa isa pa. Iyan ay mabuti at mabuti, ngunit ang kahulugan na ito ay napakalawak at hindi sumasagot sa pinakamahalagang tanong: "Ano ang pattern ng tulay?" Sa tingin ko magiging mas madali para sa iyo na maunawaan ang praktikal na aplikasyon nito. Kaya kaagad, gumawa tayo ng klasikong senaryo para sa pattern ng tulay. Mayroon kaming abstract Shapeclass, na kumakatawan sa isang generic na geometric figure:

Shape.java
```
public abstract class Shape {
   public abstract void draw();
}
```
Kapag nagpasya kaming magdagdag ng mga hugis tulad ng mga tatsulok at parihaba, gagawin namin silang magmana ng Shapeklase:

Rectangle.java:


public class Rectangle extends Shape {
   @Override
   public void draw() {
       System.out.println("Drawing rectangle");
   }
}

Triangle.java:


public class Triangle extends Shape {
   @Override
   public void draw() {
       System.out.println("Drawing triangle");
   }
}

Ang lahat ay mukhang simple hanggang sa sandaling ipinakilala namin ang konsepto ng kulay. Iyon ay, ang bawat hugis ay magkakaroon ng sarili nitong kulay, at ang pag-andar ng draw()pamamaraan ay depende sa kulay na ito. Upang magkaroon ng iba't ibang pagpapatupad ng draw()pamamaraan, kailangan nating lumikha ng isang klase para sa bawat kumbinasyon ng hugis-kulay. Kung mayroon tayong tatlong kulay, kailangan natin ng anim na klase: TriangleBlack, TriangleGreen, TriangleRed, RectangleBlack, RectangleGreenat RectangleRed. Ang anim na klase ay hindi isang malaking problema. Ngunit! Kung kailangan nating magdagdag ng bagong hugis o kulay, kung gayon ang bilang ng mga klase ay lumalaki nang husto. Paano makaalis sa ganitong sitwasyon? Ang pag-imbak ng kulay sa isang field at pag-enumerate ng lahat ng opsyon gamit ang mga conditional statement ay hindi ang pinakamahusay na solusyon. Ang isang magandang solusyon ay ang paglipat ng kulay sa isang hiwalay na interface. Wala pang maagang sinabi kaysa tapos na: gumawa tayo ng Colorinterface na may tatlong pagpapatupad: BlackColor, GreenColorat RedColor:

Color.java:


public interface Color {
   void fillColor();
}

BlackColor.java:


public class BlackColor implements Color {
   @Override
   public void fillColor() {
       System.out.println("Filling in black color");
   }
}

GreenColor.java


public class GreenColor implements Color {
   @Override
   public void fillColor() {
       System.out.println("Filling in green color");
   }
}

RedColor.java


public class RedColor implements Color {
   @Override
   public void fillColor() {
       System.out.println("Filling in red color");
   }
}

Ngayon ay nagdaragdag kami ng isang Colorpatlang sa Shapeklase. Makukuha natin ang halaga nito sa constructor.

Shape.java:


public abstract class Shape {
   protected Color color;
  
   public Shape(Color color) {
       this.color = color;
   }

   public abstract void draw();
}

Gagamitin namin ang colorvariable sa Shapemga pagpapatupad. Nangangahulugan ito na magagamit na ng mga hugis ang functionality ng Colorinterface.

Rectangle.java


public class Rectangle extends Shape {

   public Rectangle(Color color) {
       super(color);
   }

   @Override
   public void draw() {
       System.out.println("Drawing rectangle");
       color.fillColor();
   }
}

Ta-da! Ngayon ay maaari na tayong lumikha ng iba't ibang kulay at hugis ng ad infinitum, at ang bilang ng mga klase ay tataas lamang nang linearly. Ang Color colorfield ay isang tulay na nag-uugnay sa dalawang magkahiwalay na hierarchy ng klase.

Paano bumuo ng isang tulay: abstraction at pagpapatupad

Tingnan natin ang isang class diagram na naglalarawan sa pattern ng tulay: Ipinapakilala ang pattern ng disenyo ng tulay - 2

Dito makikita mo ang dalawang independiyenteng istruktura na maaaring baguhin nang hindi naaapektuhan ang paggana ng isa't isa. Sa kaso natin:

Ang abstraction ay ang Shapeklase
Ang RefinedAbstraction ay ang Triangleat Rectanglemga klase
Ang tagapagpatupad ay ang Colorinterface
Ang ConcreteImplementor ay ang BlackColor, GreenColorat RedColormga klase.

Ang Shapeklase ay isang abstraction — isang mekanismo para sa pamamahala ng pagpuno ng mga hugis na may iba't ibang kulay, na nagde-delegate sa Colorinterface (Implementor). Ang Triangleat Rectanglemga klase ay mga kongkretong klase na gumagamit ng mekanismong ginawang available ng Shapeklase. BlackColor, GreenColorat RedColormga konkretong pagpapatupad sa hierarchy ng Pagpapatupad.

Kung saan gagamitin ang pattern ng tulay

Ang isang malaking benepisyo ng paggamit ng pattern na ito ay na maaari kang gumawa ng mga pagbabago sa mga functional na klase sa isang hierarchy nang hindi sinisira ang lohika ng isa pa. Gayundin, nakakatulong ang diskarteng ito upang mabawasan ang pagsasama sa pagitan ng mga klase. Ang pangunahing kinakailangan kapag ginagamit ang pattern na ito ay "sundin ang mga tagubilin" — huwag balewalain ang alinman sa mga ito! Sa layuning iyon, alamin natin ang mga sitwasyon kung kailan dapat mong gamitin ang pattern ng tulay:

Kung kailangan mong palawakin ang bilang ng mga entity batay sa mga kumbinasyon ng dalawang konsepto (hal. mga hugis at kulay).
Kung gusto mong hatiin ang isang malaking klase na hindi nakakatugon sa prinsipyo ng single-responsibility sa mas maliliit na klase na may makitid na functionality.
Kung kinakailangan na gumawa ng mga pagbabago sa lohika ng ilang mga entity habang tumatakbo ang programa.
Kung kinakailangan upang itago ang isang pagpapatupad mula sa mga kliyente ng klase o library.

Kapag ginamit mo ang pattern na ito, laging tandaan na nagdaragdag ito ng mga karagdagang entity sa iyong code — maaaring hindi makatuwirang gamitin ito sa isang proyekto kung saan mayroon lamang isang hugis at isa o dalawang posibleng kulay.

Mga kalamangan at kahinaan ng pattern

Tulad ng iba pang mga pattern, ang tulay ay may parehong mga pakinabang at disadvantages. Mga kalamangan ng pattern ng tulay:

Pinapabuti nito ang scalability ng code — maaari kang magdagdag ng functionality nang walang takot na masira ang isang bagay sa ibang bahagi ng program.
Binabawasan nito ang bilang ng mga subclass kapag ibatay ang bilang ng mga entity sa mga kumbinasyon ng dalawang konsepto (halimbawa, mga hugis at kulay).
Ginagawa nitong posible na magkahiwalay na magtrabaho sa dalawang magkahiwalay na hierarchy — Abstraction at Implementation. Dalawang magkaibang developer ang maaaring gumawa ng mga pagbabago nang hindi sinisiyasat ang mga detalye ng code ng bawat isa.
Binabawasan nito ang pagkakabit sa pagitan ng mga klase — ang tanging lugar kung saan pinagsasama ang dalawang klase ay ang tulay (ibig sabihin, ang Color colorfield).

Mga disadvantages ng pattern ng tulay:

Depende sa partikular na sitwasyon at sa pangkalahatang istraktura ng isang proyekto, maaari itong negatibong makaapekto sa pagganap ng isang programa (halimbawa, kung kailangan mong simulan ang higit pang mga bagay).
Ginagawa nitong hindi gaanong nababasa ang code dahil sa pangangailangang lumipat sa pagitan ng dalawang klase.

Pagkakaiba sa pattern ng diskarte

Ang pattern ng tulay ay madalas na nalilito sa isa pang pattern ng disenyo — diskarte. Pareho silang gumagamit ng komposisyon (bagama't ginamit namin ang pagsasama-sama sa halimbawa na may mga figure at kulay, ang pattern ng Bridge ay maaari ding gumamit ng komposisyon), na nagde-delegate ng trabaho sa iba pang mga bagay. Ngunit may pagkakaiba sa pagitan nila, at ito ay napakalaki. Ang pattern ng diskarte ay isang pattern ng pag-uugali: nalulutas nito ang ganap na magkakaibang mga problema. Ang diskarte ay nagpapahintulot sa mga algorithm na mapalitan, habang ang tulay ay naghihiwalay ng abstraction mula sa mga pagpapatupad upang pumili sa pagitan ng iba't ibang mga pagpapatupad. Sa madaling salita, hindi tulad ng isang diskarte, ang isang tulay ay nalalapat sa buong entity o hierarchical na istruktura. Ang pattern ng tulay ay maaaring maging isang magandang sandata sa arsenal ng isang developer. Ang pangunahing bagay ay upang matukoy ang mga sitwasyon kung saan ito ay nagkakahalaga ng paggamit nito at kilalanin kung ang ilang iba pang pattern ay angkop.