Modello di progettazione dell’Abstract Factory in Java

Benvenuti all’esempio di Design Pattern Factory Astratto in Java. Il design pattern Factory Astratto è uno dei pattern Creazionali. Il pattern Factory Astratto è quasi simile al Pattern Factory eccetto il fatto che è più simile a una fabbrica di fabbriche.

Factory Astratto

Se sei familiare con il pattern factory in Java, noterai che abbiamo una singola classe Factory. Questa classe factory restituisce diverse sottoclassi in base all’input fornito e la classe factory utilizza istruzioni if-else o switch per ottenere questo risultato. Nel pattern Factory Astratto, eliminiamo il blocco if-else e abbiamo una classe factory per ogni sottoclasse. Poi una classe Factory Astratto che restituirà la sottoclasse in base alla classe factory di input. All’inizio, può sembrare confuso, ma una volta che si vede l’implementazione, è davvero facile comprendere la differenza minore tra il pattern Factory e il Factory Astratto. Come nel nostro post sul pattern factory, useremo la stessa superclasse e sottoclassi.

Modello di Progettazione Factory Astratta con Superclasse e Sottoclassi

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;
    }
 
}

Classe Factory per ciascuna sottoclasse

Innanzitutto, è necessario creare un’interfaccia di Factory Astratta o classe astratta. ComputerAbstractFactory.java

package com.journaldev.design.abstractfactory;

import com.journaldev.design.model.Computer;

public interface ComputerAbstractFactory {

	public Computer createComputer();

}

Notare che il metodo createComputer() restituisce un’istanza della superclasse Computer. Ora le nostre classi factory implementeranno questa interfaccia e restituiranno le rispettive sottoclassi. 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);
	}

}

Allo stesso modo, avremo una classe factory per la sottoclasse Server. 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);
	}

}

Ora creeremo una classe consumer che fornirà il punto di ingresso per le classi client per creare sottoclassi. 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();
	}
}

Si noti che è una classe semplice e il metodo getComputer accetta l’argomento ComputerAbstractFactory e restituisce l’oggetto Computer. A questo punto l’implementazione deve diventare chiara. Scriviamo un semplice metodo di test e vediamo come utilizzare la factory astratta per ottenere l’istanza delle sottoclassi. 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);
	}
}

L’output del programma sarà il seguente:

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

Ecco il diagramma delle classi dell’implementazione del pattern di progettazione factory astratta.

Vantaggi del pattern di progettazione factory astratta

• Il pattern di progettazione factory astratta fornisce un approccio per codificare per interfaccia piuttosto che per implementazione.
• Il pattern factory astratta è una “fabbrica di fabbriche” e può essere facilmente esteso per ospitare più prodotti, ad esempio possiamo aggiungere un’altra sottoclasse Laptop e una factory LaptopFactory.
• Il pattern factory astratta è robusto e evita la logica condizionale del pattern Factory.

Esempi del Modello di Progettazione Factory Astratta in JDK

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

Tutorial Video sul Modello di Progettazione Factory Astratta

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

Puoi scaricare il codice degli esempi dal mio Progetto GitHub.