Padrão de Projeto Abstract Factory em Java

Bem-vindo ao exemplo de Padrão de Projeto Abstract Factory em Java. O padrão de design Abstract Factory é um dos padrões Criacionais. O padrão Abstract Factory é quase semelhante ao Padrão de Fábrica, exceto pelo fato de ser mais como uma fábrica de fábricas.

Abstract Factory

Se você está familiarizado com o padrão de design de fábrica em Java, notará que temos uma única classe de fábrica. Esta classe de fábrica retorna diferentes subclasses com base na entrada fornecida, e a classe de fábrica usa instruções if-else ou switch para alcançar isso. No padrão Abstract Factory, eliminamos o bloco if-else e temos uma classe de fábrica para cada subclasse. Em seguida, temos uma classe Abstract Factory que retornará a subclasse com base na classe de fábrica de entrada. A princípio, pode parecer confuso, mas assim que você vê a implementação, é realmente fácil entender a pequena diferença entre o padrão de Fábrica e o padrão de Abstract Factory. Assim como em nossa postagem sobre o padrão de Fábrica, usaremos a mesma superclasse e subclasses.

Padrão de Design Abstract Factory para Superclasse e Subclasses

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 de Fábrica para Cada Subclasse

Primeiramente, precisamos criar uma interface de Fábrica Abstrata ou classe abstrata. ComputerAbstractFactory.java

package com.journaldev.design.abstractfactory;

import com.journaldev.design.model.Computer;

public interface ComputerAbstractFactory {

	public Computer createComputer();

}

Observe que o método createComputer() está retornando uma instância da superclasse Computer. Agora, nossas classes de fábrica irão implementar essa interface e retornar suas respectivas sub-classes. 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);
	}

}

Da mesma forma, teremos uma classe de fábrica para a subclasse 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);
	}

}

Agora, vamos criar uma classe consumidora que fornecerá o ponto de entrada para as classes cliente criarem sub-classes. 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();
	}
}

Notado que é uma classe simples e o método getComputer está aceitando o argumento ComputerAbstractFactory e retornando o objeto Computer. Neste ponto, a implementação deve estar ficando clara. Vamos escrever um método de teste simples e ver como usar a fábrica abstrata para obter a instância das subclasses. 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);
	}
}

A saída do programa acima será:

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

Aqui está o diagrama de classes da implementação do padrão de design da fábrica abstrata.

Benefícios do Padrão de Design da Fábrica Abstrata

• O padrão de design da fábrica abstrata fornece uma abordagem para codificar para a interface, em vez da implementação.
• O padrão de design da fábrica abstrata é uma “fábrica de fábricas” e pode ser facilmente estendido para acomodar mais produtos, por exemplo, podemos adicionar outra subclasse, Laptop, e uma fábrica, LaptopFactory.
• O padrão de design da fábrica abstrata é robusto e evita lógica condicional do padrão de fábrica.

Exemplos do Padrão de Projeto de Fábrica Abstrata no JDK

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

Tutorial em Vídeo sobre o Padrão de Projeto de Fábrica Abstrata

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

Você pode baixar os exemplos de código do meu Projeto no GitHub.