Wzorce projektowe - proxy

Wzorzec ten ma na celu zbudowanie klasy będącej odpowiednikiem innej klasy, pozwalając jednocześnie na zarządzanie dostępem do niej:

• gdy chcesz wykonywać pewne zdalne obiekty(remote proxy - pełnomocnik zdalny),
• gdy z pewnych względów nie chcesz tworzyć obiektu danej klasy aż do chwili wywołania jednej z jego metod, np. gdy z góry wiesz, że utworzenie takiego obiektu jest bardzo czasochłonne bądź zasobochłonne (virtual proxy - pełnomocnik wirtualny),
• gdy chcesz kontrolować dostęp do pewnego obiektu twojego systemu (protection proxy - pełnomocnik ochraniający),
• gdy poza akcją wykonywaną przez obiekt danej klasy musisz wykonać także dodatkowe akcje powiązane z jego metodą bądź metodami (smart proxy - sprytny pełnomocnik).

Nie są to wszystkie możliwe użycia wzorca proxy, lecz te najbardziej typowe. Nic jednak nie stoi na przeszkodzie, aby wykorzystać go w innym celu.

Jak działa proxy? Zawsze w sposób analogiczny. Obudujmy więc, korzystając z tego wzorca, przykładową klasę Klient. Klasa ta implementuje interfejs Uzytkownik:

1. interface Uzytkownik {
2.   public function getImie();
3.   public function setImie($strImie);
4.   public function getNazwisko();
5.   public function setNazwisko($strNazwisko);
6.   public function zapisz();
7.   public function usun();
8. }

Listing zwinięty - 8 linii

1. public interface Uzytkownik {
2.   public String getImie();
3.   public void setImie(String imie);
4.   public String getNazwisko();
5.   public void setNazwisko(String nazwisko);
6.   public void zapisz();
7.   public void usun();
8. }

Listing zwinięty - 8 linii

Nasza klasa Klient jest równie prosta (jak zwykle ciała funkcji nie robią nic pożytecznego - przykłady te mają jedynie zaprezentować w możliwie łatwy i przejrzysty sposób samą ideę działania wzorca):

 1. class Klient implements Uzytkownik {
 2.   private $strImie;
 3.   private $strNazwisko;
 4.   public function getImie() {
 5.     return $this->strImie;
 6.   }
 7.   public function setImie($strImie) {
 8.     $this->strImie = $strImie;
 9.   }
10.   public function getNazwisko() {
11.     return $this->strNazwisko;
12.   }
13.   public function setNazwisko($strNazwisko) {
14.     $this->strNazwisko = $strNazwisko;
15.   }
16.   public function zapisz() {
17.     //zapisywanie danych użytkownika
18.   }
19.   public function usun() {
20.     //usuwanie użytkownika
21.   }
22. }

Listing zwinięty - 22 linii

 1. public class Klient implements Uzytkownik
 2. {
 3.   private String imie;
 4.   private String nazwisko;
 5.   public String getImie() {
 6.     return imie;
 7.   }
 8.   public void setImie(String imie) {
 9.     this.imie = imie;
10.   }
11.   public String getNazwisko() {
12.     return nazwisko;
13.   }
14.   public void setNazwisko(String nazwisko) {
15.     this.nazwisko = nazwisko;
16.   }
17.   public void zapisz() {
18.     //zapisywanie danych użytkownika
19.   }
20.   public void usun() {
21.     //usuwanie użytkownika
22.   }
23. }

Listing zwinięty - 23 linii

Nasza klasa Proxy także dziedziczy po interfejsie Użytkwonik, udając tym samym klasę, którą obudowuje:

 1. class Proxy implements Uzytkownik {
 2.   private $objKlient;
 3.   public function __construct() {
 4.     $this->objKlient = new Klient();
 5.     //inne działania proxy w dane metodzie
 6.   }
 7.   public function getImie() {
 8.     return $this->objKlient->getImie();
 9.     //inne działania proxy w dane metodzie
10.   }
11.   public function setImie($strImie) {
12.     $this->objKlient->setImie($strImie);
13.     //inne działania proxy w dane metodzie
14.   }
15.   public function getNazwisko() {
16.     return $this->objKlient->getNazwisko();
17.     //inne działania proxy w dane metodzie
18.   }
19.   public function setNazwisko($strNazwisko) {
20.     $this->objKlient->setNazwisko($strNazwisko);
21.     //inne działania proxy w dane metodzie
22.   }
23.   public function zapisz() {
24.     $this->objKlient->zapisz();
25.     //inne działania proxy w dane metodzie
26.   }
27.   public function usun() {
28.     $this->objKlient->usun();
29.     //inne działania proxy w dane metodzie
30.   }
31. }

Listing zwinięty - 31 linii

 1. public class Proxy implements Uzytkownik {
 2.   private Klient klient;
 3.   public Proxy() {
 4.     klient = new Klient();
 5.   }
 6.   public String getImie() {
 7.     return klient.getImie();
 8.     //inne działania proxy w dane metodzie
 9.   }
10.   public void setImie(String imie) {
11.     klient.setImie(imie);
12.     //inne działania proxy w dane metodzie
13.   }
14.   public String getNazwisko() {
15.     return klient.getNazwisko();
16.     //inne działania proxy w dane metodzie
17.   }
18.   public void setNazwisko(String nazwisko) {
19.     klient.setNazwisko(nazwisko);
20.     //inne działania proxy w dane metodzie
21.   }
22.   public void zapisz() {
23.     klient.zapisz();
24.     //inne działania proxy w dane metodzie
25.   }
26.   public void usun() {
27.     klient.usun();
28.     //inne działania proxy w dane metodzie
29.   }
30. }

Listing zwinięty - 30 linii

Użycie wzorca proxy sprowadza się do użycia naszej nowej klasy Proxy w miejscu klasy Klient. Jako że obie mają ten sam interfejs, nie sprawia to żadnego problemu:

1. $objUzytkownik = new Proxy();
2. $objUzytkownik->setImie('Jan');
3. $objUzytkownik->setNazwisko('Kowalski');
4. $objUzytkownik->zapisz();

Listing zwinięty - 4 linii

1. public class Test {
2.   public static void main(String[] args)
3.   {
4.     Uzytkownik uzytkownik = new Proxy();
5.     uzytkownik.setImie("Jan");
6.     uzytkownik.setNazwisko("Kowalski");
7.     uzytkownik.zapisz();
8.   }
9. }

Listing zwinięty - 9 linii

Podsumowanie

Wzorzec ten jest prawdopodobnie najprostszym z poznanych przez ciebie do tej pory. Możliwe, że już od dawna z niego korzystasz, nie wiedząc nawet, że jest to jeden ze wzorców i jaką nosi nazwę. Jeśli tak, warto jego nazwę zapamiętać.

Pozwoli to na wygodną komunikację z innymi programistami, operującymi terminologią wzorców projektowych.