Abstract fabriekspatroon in Java

1. Overzicht

In dit artikel bespreken we het ontwerppatroon van Abstract Factory.

In het boek Design Patterns: Elements of Reusable Object-Oriented Software staat dat een Abstract Factory "Biedt een interface voor het maken van families van verwante of afhankelijke objecten zonder hun concrete klassen te specificeren". Met andere woorden: met dit model kunnen we objecten maken die een algemeen patroon volgen.

Een voorbeeld van het Abstract Factory-ontwerppatroon in de JDK is het newInstance () van javax.xml.parsers.DocumentBuilderFactory klasse.

2. Voorbeeld van een abstract fabrieksontwerppatroon

In dit voorbeeld maken we twee implementaties van het Factory Method Design-patroon: AnimalFactory en KleurFabriek.

Daarna beheren we de toegang ertoe met behulp van een Abstract Factory AbstractFabriek:

Eerst maken we een familie van Dier class en zal het later gebruiken in onze Abstract Factory.

Hier is de Dier koppel:

openbare interface Animal {String getAnimal (); String makeSound (); }

en een concrete implementatie Eend:

openbare klasse Duck implementeert Animal {@Override public String getAnimal () {return "Duck"; } @Override public String makeSound () {return "Squeks"; }} 

Bovendien kunnen we meer concrete implementaties van Dier interface (zoals Hond, beer, etc.) precies op deze manier.

The Abstract Factory behandelt families van afhankelijke objecten. Met dat in gedachten gaan we nog een familie introduceren Kleur als interface met enkele implementaties (Wit, bruin, ...).

We slaan de daadwerkelijke code voorlopig over, maar deze is hier te vinden.

Nu we meerdere gezinnen klaar hebben staan, kunnen we een AbstractFactory interface voor hen:

openbare interface AbstractFactory {T create (String animalType); }

Vervolgens implementeren we een AnimalFactory met behulp van het Factory Method-ontwerppatroon dat we in de vorige sectie hebben besproken:

public class AnimalFactory implementeert AbstractFactory {@Override public Animal create (String animalType) {if ("Dog" .equalsIgnoreCase (animalType)) {return new Dog (); } else if ("Duck" .equalsIgnoreCase (animalType)) {return new Duck (); } retourneer null; }} 

Evenzo kunnen we een fabriek voor de Kleur interface met hetzelfde ontwerppatroon.

Als dit allemaal is ingesteld, maken we een Fabrieksprovider class die ons een implementatie van AnimalFactory of ColorFactory afhankelijk van het argument dat we aan de getFactory () methode:

openbare klasse FactoryProvider {openbare statische AbstractFactory getFactory (stringkeuze) {if ("Animal" .equalsIgnoreCase (keuze)) {retourneer nieuwe AnimalFactory (); } else if ("Kleur" .equalsIgnoreCase (keuze)) {retourneer nieuwe ColorFactory (); } retourneer null; }}

3. Wanneer gebruik je een abstract fabriekspatroon:

  • De klant is onafhankelijk van hoe we de objecten in het systeem maken en samenstellen
  • Het systeem bestaat uit meerdere families van objecten en deze families zijn ontworpen om samen te worden gebruikt
  • We hebben een run-time waarde nodig om een ​​bepaalde afhankelijkheid te construeren

Hoewel het patroon geweldig is bij het maken van vooraf gedefinieerde objecten, kan het toevoegen van nieuwe objecten een uitdaging zijn. Om het nieuwe type objecten te ondersteunen, moet de AbstractFactory klasse en al zijn subklassen.

4. Samenvatting

In dit artikel hebben we geleerd over het ontwerppatroon van Abstract Factory.

Eindelijk, zoals altijd, is de implementatie van deze voorbeelden te vinden op GitHub.