Wzorzec fabryka

Zasada jednej odpowiedzialności

Wzorce projektowe – wzorzec fabryka.

Współcześnie występuje wiele reguł, wzorców i zasad programowania, którymi kierują się obecni programiści. Żeby ich kod był zrozumiały i jasny dla innych oraz wydajny posługują się oprócz zasad SOLID, tzw. wzorcami projektowymi. Wzorce projektowe to zbiór najlepszych praktyk z gotowymi rozwiązaniami dla wybranych problemów napotykanych w trakcie projektowania rozwiązań zorientowanych obiektowo. Wzorce projektowe składają się przede wszystkim z: nazwy, opisu problemu, który rozwiązuje rozwiązania i konsekwencji jego użytkowania. Jest dużo wzorców projektowych jednym z nich jest wzorzec fabryka. W tym artykule opisze ten wzorzec oraz przedstawię przykład kodu programu przed zastosowaniem tego wzorca jak i po.

Wstęp

Wzorzec fabryka to jeden z częściej wykorzystywanych wzorców projektowych. Wzorzec ten występuje w dwóch wariantach: metoda fabrykująca (ang. Factory Method) i fabryka abstrakcyjna (ang. Abstract Factory). Z pewnością celem zastosowania wzorca jest dostarczenie interfejsu do tworzenia rodzin powiązanych lub wzajemnie zależnych obiektów bez definiowania ich konkretnych klas. Umożliwia jednemu obiektowi tworzenie różnych, powiązanych ze sobą, reprezentacji pod obiektów określając ich typy podczas działania programu. W związku z tym programista zyskuje abstrakcyjną warstwę, odpowiedzialną za tworzenie instancji obiektów w jakiś sposób powiązanych wspólnym interfejsem. Uzyskujemy wtedy kod, który jest bardziej skalowalny, łatwiejszy na rozbudowę. Wzorzec ten spełnia zasadę odwrócenia zależności oraz zasadę otwarte/zamknięte, otwarte na rozbudowę i zamknięte na modyfikację.

Oprócz wymienionych wyżej wariantów fabryk istnieje również inna odmiana fabryki. Jest nią prosta fabryka (ang. Simple Factory), która nie jest pełnoprawnym wzorcem. Z pewnością mnogość odmian sprawia, że są one często ze sobą mylone i błędnie opisywane. Wzorzec fabryka należy do grupy wzorców skatalogowanych przez Gang czworga. Poniżej przedstawię przykład dla wzorca fabryka abstrakcyjna, opisze jego zalety i wady.

Zastosowanie

Niewątpliwie wzorzec fabryka abstrakcyjna ma zastosowanie w wielu aplikacjach np. rozpatrzmy aplikację kliencką, która łączy się ze zdalnym serwerem. Celem projektanta takiej aplikacji jest z pewnością to, aby była ona przenośna. Jednym z rozwiązań takiego problemu jest stworzenie fabryki, która będzie tworzyła odpowiednie obiekty w zależności od tego na jakiej platformie się znajduje. Innym zastosowaniem wzorca fabryka jest stworzenie sieci pizzerii i aplikacji do zamawiania pizzy, gdzie będzie można dodawać nowe pizzę oraz składniki.

Przykład

Idealny przykład do użycia fabryki to kod, który wygląda mniej więcej tak:

  1. IManageArea manageArea;  
  3. Employee employee = employeeService.Load("Managment", 42);  
  4.   
  5. if (employee.isManager)  
  6. {  
  7.     manageArea = new GlobalManageArea();  
  8. }  
  9. else  
  10. {  
  11.     manageArea = new LocalManageArea();  
  12. }  
  13.   
  14. manageArea.FireEmployees(1000);  
  15. // itd. 

Kod 1. Kod programu bez użycia wzorca

Pomijając sensowność kodu, widać tutaj logikę, od której zależy utworzenie instancji klasy. Z pewnością całość powinna zostać zhermetyzowana wewnątrz fabryki.

Spójrzmy na przykładowy kod z użyciem wzorca fabryka:

  1. // kształty  
  2. interface IShape { }  
  3.   
  4. class Square : IShape { }  
  5. class Triangle : IShape { }  
  6.   
  7. // liczby  
  8. interface INumber { }  
  9.   
  10. class RealNumber : INumber { }  
  11. class ComplexNumber : INumber { }  
  12.   
  13. // fabryka abstrakcyjna rodziny obiektów  
  14. abstract class MathTestFactory  
  15. {  
  16.     public abstract IShape CreateShape();  
  17.     public abstract INumber CreateNumber();  
  18. }  
  19.       
  20. // konkretna fabryka rodziny obiektów  
  21. class PrimarySchoolTestFactory : MathTestFactory  
  22. {  
  23.     public override IShape CreateShape()  
  24.     {  
  25.         return new Square();  
  26.     }  
  27.   
  28.     public override INumber CreateNumber()  
  29.     {  
  30.         return new RealNumber();  
  31.     }  
  32. }  
  33.   
  34. // konkretna fabryka rodziny obiektów  
  35. class HighSchoolTestFactory : MathTestFactory  
  36. {  
  37.     public override IShape CreateShape()  
  38.     {  
  39.         return new Triangle();  
  40.     }  
  41.   
  42.     public override INumber CreateNumber()  
  43.     {  
  44.         return new ComplexNumber();  
  45.     }  
  46. }  
  47.   
  48. // klasa klienta (kontekst wykonania fabryki)  
  49. class MathTest  
  50. {  
  51.     private MathTestFactory mathTestFactory;  
  52.   
  53.     public MathTest(MathTestFactory mathTestFactory)  
  54.     {  
  55.         this.mathTestFactory = mathTestFactory;  
  56.     }  
  57.   
  58.     public void GenerateTest()  
  59.     {  
  60.         var shape = this.mathTestFactory.CreateShape();  
  61.         var number = this.mathTestFactory.CreateNumber();  
  62.         System.Console.WriteLine("Test wygenerowany");  
  63.     }  
  64. }  
  65.   
  66. static void Main(string[] args)  
  67. {  
  68.     MathTest mathTest;  
  69.   
  70.     mathTest = new MathTest(new PrimarySchoolTestFactory());  
  71.     mathTest.GenerateTest(); // łatwy test przy użyciu PrimarySchoolTestFactory()  
  72.   
  73.     mathTest = new MathTest(new HighSchoolTestFactory());  
  74.     mathTest.GenerateTest(); // trudny test przy użyciu PrimarySchoolTestFactory()  
  75. } 

Kod 2. Kod programu z użyciem wzorca

Klasa MathTestFactory jest fabryką abstrakcyjną definiującą rodzinę obiektów. Za pomocą kompozycji definiujemy, że obydwa elementy są w jakiś sposób od siebie zależne. Na potrzeby artykułu przyjęliśmy, że tworzą „test”. Następnie tworząc konkretne egzemplarze fabryk, możemy rodzinę obiektów stworzyć na wiele sposób i tak np. PrimarySchoolTestFactory tworzy rodzinę obiektów bardzo prostych (kwadrat i zbiór liczb rzeczywistych). Natomiast HighSchoolTestFactory tworzy rodzinę obiektów trudnych (trójkąt i zbiór liczb zespolonych).

Podsumowanie

Reasumując, wszelkie odmiany fabryki abstrakcyjnej potrafią przysporzyć wiele problemów nawet zaawansowanym programistom. Osobiście wzorzec fabryka uważam za najbardziej skomplikowany wzorzec gangu czworga. Jego niezwykła komplikacja polega na wielu możliwościach implementacji, jednakże wzorzec ten posiada szereg zalet: umożliwia tworzenie rodzin obiektów w jakiś sposób powiązanych ze sobą, zawsze występuje mechanizm dziedziczenia, mechanizm kompozycji oraz dedykowana klasa klienta. Minusem fabryki abstrakcyjnej jest mała skalowalność, dodając nowy produkt trzeba przerobić klasę fabryki abstrakcyjnej oraz konkretnych fabryk. Mam nadzieję, że ten artykuł choć trochę rozjaśnił Wam jak działa wzorzec fabryka i pokazał jak najlepiej go używać.