Abstract Factory Ontwerppatroon in Java

Welkom bij het voorbeeld van het abstracte fabrieksontwerppatroon in Java. Het abstracte fabrieksontwerppatroon is een van de creërende patronen. Het abstracte fabrieksontwerppatroon lijkt bijna op het fabrieksontwerppatroon, behalve het feit dat het meer lijkt op een fabriek van fabrieken.

Abstracte fabriek

Als je bekend bent met het fabrieksontwerppatroon in Java, zul je merken dat we een enkele fabrieksklasse hebben. Deze fabrieksklasse retourneert verschillende subklassen op basis van de verstrekte invoer, en de fabrieksklasse gebruikt een if-else of switch-verklaring om dit te bereiken. In het abstracte fabrieksontwerppatroon elimineren we de if-else-blok en hebben we voor elke subklasse een fabrieksklasse. Vervolgens hebben we een abstracte fabrieksklasse die de subklasse retourneert op basis van de invoerfabrieksklasse. In het begin lijkt het verwarrend, maar zodra je de implementatie ziet, is het echt makkelijk te begrijpen en het kleine verschil tussen het fabrieks- en het abstracte fabrieksontwerppatroon te begrijpen. Net als bij ons fabrieksontwerppost gebruiken we dezelfde superklasse en subklassen.

Abstract Factory Ontwerppatroon Superklasse en Subklassen

Computer.java

package com.journaldev.design.model;
 
public abstract class Computer {
     
    public abstract String getRAM();
    public abstract String getHDD();
    public abstract String getCPU();
     
    @Override
    public String toString(){
        return "RAM= "+this.getRAM()+", HDD="+this.getHDD()+", CPU="+this.getCPU();
    }
}

PC.java

package com.journaldev.design.model;
 
public class PC extends Computer {
 
    private String ram;
    private String hdd;
    private String cpu;
     
    public PC(String ram, String hdd, String cpu){
        this.ram=ram;
        this.hdd=hdd;
        this.cpu=cpu;
    }
    @Override
    public String getRAM() {
        return this.ram;
    }
 
    @Override
    public String getHDD() {
        return this.hdd;
    }
 
    @Override
    public String getCPU() {
        return this.cpu;
    }
 
}

Server.java

package com.journaldev.design.model;
 
 
public class Server extends Computer {
 
    private String ram;
    private String hdd;
    private String cpu;
     
    public Server(String ram, String hdd, String cpu){
        this.ram=ram;
        this.hdd=hdd;
        this.cpu=cpu;
    }
    @Override
    public String getRAM() {
        return this.ram;
    }
 
    @Override
    public String getHDD() {
        return this.hdd;
    }
 
    @Override
    public String getCPU() {
        return this.cpu;
    }
 
}

Factoryklasse voor Elk Subklasse

Ten eerste moeten we een Abstract Factory-interface of abstracte klasse maken. ComputerAbstractFactory.java

package com.journaldev.design.abstractfactory;

import com.journaldev.design.model.Computer;

public interface ComputerAbstractFactory {

	public Computer createComputer();

}

Merk op dat de createComputer()-methode een instantie retourneert van de superklasse Computer. Nu zullen onze fabriekklassen deze interface implementeren en hun respectievelijke subklasse retourneren. PCFactory.java

package com.journaldev.design.abstractfactory;

import com.journaldev.design.model.Computer;
import com.journaldev.design.model.PC;

public class PCFactory implements ComputerAbstractFactory {

	private String ram;
	private String hdd;
	private String cpu;
	
	public PCFactory(String ram, String hdd, String cpu){
		this.ram=ram;
		this.hdd=hdd;
		this.cpu=cpu;
	}
	@Override
	public Computer createComputer() {
		return new PC(ram,hdd,cpu);
	}

}

Vergelijkbaar zullen we een fabriekklasse hebben voor de Server-subklasse. ServerFactory.java

package com.journaldev.design.abstractfactory;

import com.journaldev.design.model.Computer;
import com.journaldev.design.model.Server;

public class ServerFactory implements ComputerAbstractFactory {

	private String ram;
	private String hdd;
	private String cpu;
	
	public ServerFactory(String ram, String hdd, String cpu){
		this.ram=ram;
		this.hdd=hdd;
		this.cpu=cpu;
	}
	
	@Override
	public Computer createComputer() {
		return new Server(ram,hdd,cpu);
	}

}

Nu zullen we een consumentenklasse maken die het instappunt zal bieden voor de clientklassen om subklassen te maken. ComputerFactory.java

package com.journaldev.design.abstractfactory;

import com.journaldev.design.model.Computer;

public class ComputerFactory {

	public static Computer getComputer(ComputerAbstractFactory factory){
		return factory.createComputer();
	}
}

Let op dat het een eenvoudige klasse is en de methode \texttt{getComputer} accepteert het argument \texttt{ComputerAbstractFactory} en retourneert een \texttt{Computer}-object. Op dit punt moet de implementatie duidelijk worden. Laten we een eenvoudige testmethode schrijven en zien hoe we de abstracte fabriek kunnen gebruiken om een instantie van subklassen te krijgen. \texttt{TestDesignPatterns.java}

package com.journaldev.design.test;

import com.journaldev.design.abstractfactory.PCFactory;
import com.journaldev.design.abstractfactory.ServerFactory;
import com.journaldev.design.factory.ComputerFactory;
import com.journaldev.design.model.Computer;

public class TestDesignPatterns {

	public static void main(String[] args) {
		testAbstractFactory();
	}

	private static void testAbstractFactory() {
		Computer pc = com.journaldev.design.abstractfactory.ComputerFactory.getComputer(new PCFactory("2 GB","500 GB","2.4 GHz"));
		Computer server = com.journaldev.design.abstractfactory.ComputerFactory.getComputer(new ServerFactory("16 GB","1 TB","2.9 GHz"));
		System.out.println("AbstractFactory PC Config::"+pc);
		System.out.println("AbstractFactory Server Config::"+server);
	}
}

De uitvoer van het bovenstaande programma zal zijn:

AbstractFactory PC Config::RAM= 2 GB, HDD=500 GB, CPU=2.4 GHz
AbstractFactory Server Config::RAM= 16 GB, HDD=1 TB, CPU=2.9 GHz

Hier is het klassendiagram van de implementatie van het abstracte fabrieksontwerppatroon.

Voordelen van het Abstract Factory Design Pattern

• Het Abstract Factory Design Pattern biedt een benadering om code te schrijven voor de interface in plaats van de implementatie.
• Het Abstract Factory-patroon is een “fabriek van fabrieken” en kan eenvoudig worden uitgebreid om meer producten te accommoderen, bijvoorbeeld kunnen we een andere subklasse Laptop en een fabriek LaptopFactory toevoegen.
• Het Abstract Factory-patroon is robuust en vermijdt de voorwaardelijke logica van het Factory-patroon.

Abstract Factory Ontwerppatroon Voorbeelden in JDK

• javax.xml.parsers.DocumentBuilderFactory#newInstance()
• javax.xml.transform.TransformerFactory#newInstance()
• javax.xml.xpath.XPathFactory#newInstance()

Abstract Factory Ontwerppatroon Video Tutorial

I recently uploaded a video on YouTube for abstract factory design pattern. In the video, I discuss when and how to implement an abstract factory pattern. I have also discussed what is the difference between the factory pattern and abstract factory design pattern. https://youtu.be/BPkYkyVWOaw

Je kunt de voorbeeldcode downloaden van mijn GitHub Project.