![Contoh Abstract Factory Design Pattern](http://images.ctfassets.net/7wjlcr9d5ii8/4pHN69fEImGWpDCg3Iu53D/86303f1ffae6962a777b231069f88233/depositphotos_32880113-stock-illustration-industrial-factory-buildings-icons-set.jpg?w=600&h=600&fl=progressive&q=75&fm=jpg)
Sebelumnya kita udah membahas Factory Method Design Pattern. Sekarang kita bahas versi upgrade-nya, yaitu Abstract Factory Design Pattern. Keduanya memang mirip, yaitu memberikan user kebebasan memilih implementasi objek apa yang dipakai secara runtime lewat input. Bedanya Abstract Factory Design Pattern ga hanya memberikan implementasi objeknya saja, tapi juga satu set family objek terkait. Makanya bisa dibilang ini adalah Factory Method versi upgrade. Oh ya, jika masih ambigu tentang terminologi "Factory" dalam programming, bisa baca artikel Macam-macam Factory terlebih dahulu.
Abstract Factory Design Pattern adalah Creational Design Pattern yang memberikan implementasi objek beserta family objek terkait berdasarkan input.
Design Pattern
Use Case
Untuk mempermudah pembahasan, kita masih menggunakan use case yang sama seperti Factory Method dengan beberapa requirement tambahan:
- Terdapat 2 jenis laptop, Asus dan Dell;
- Masing-masing laptop memiliki Gaming Laptop dan Office Laptop;
- Gaming Laptop menggunakan Nvidia Graphic Card dan RGB Keyboard;
- Office Laptop menggunakan Intel Graphic Card dan Standard Keyboard;
- Ketika user menginginkan Gaming Laptop dengan input "asus" maka yang didapatkan adalah Asus Rog;
- Ketika user menginginkan Gaming Laptop dengan input "dell" maka yang didapatkan adalah Dell Alienware;
- Ketika user menginginkan Office Laptop dengan input "asus" maka yang didapatkan adalah Asus Vivobook;
- Ketika user menginginkan Office Laptop dengan input "dell" maka yang didapatkan adalah Dell Latitude;
- Ketika user memberikan input yang salah maka tampilkan error;
Contoh Code
Contoh code-nya kurang lebih sama seperti contoh pada Factory Method Design Pattern sebelumnya, karena menggunakan use case yang mirip. Jadi untuk menghemat tulisan code Laptop dan implementasinya ga gw tulis. Gw hanya menuliskan class tambahannya beserta contoh method dan contoh penggunaannya aja ya😅.
Interface LaptopGraphicCard
public interface LaptopGraphicCard{
String getGraphic();
}
Class GamingGraphicCard
public class GamingGraphicCard implements LaptopGraphicCard{
@Override
public String getGraphic(){
return "NVIDIA";
}
}
Class OfficeGraphicCard
public class OfficeGraphicCard implements LaptopGraphicCard{
@Override
public String getGraphic(){
return "Intel";
}
}
Interface LaptopKeyboard
public interface LaptopKeyboard{
String getKeyboard();
}
Class GamingKeyboard
public class GamingKeyboard implements LaptopKeyboard{
@Override
public String getKeyboard(){
return "RGB";
}
}
Class OfficeKeyboard
public class OfficeKeyboard implements LaptopKeyboard{
@Override
public String getKeyboard(){
return "Standard";
}
}
Method buildLaptop()
public static Laptop buildLaptop(String laptop){
if("asus-gaming".equals(laptop)){
return new AsusRog(new GamingGraphicCard(), new GamingKeyboard());
}
if("dell-gaming".equals(laptop)){
return new DellAlienware(new GamingLaptopProperty(), new GamingKeyboard());
}
if("asus-office".equals(laptop)){
return new AsusVivoBook(new OfficeGraphicCard(), new OfficeKeyboard());
}
if("dell-office".equals(laptop)){
return new DellLatitude(new OfficeGraphicCard(), new OfficeKeyboard());
}
throw new IllegalArgumentException("not found");
}
Contoh penggunaan
public static void main(String[] args){
Laptop laptop = buildLaptop("dell-gaming");
System.out.println("dell.getLaptopName() = " + laptop.getLaptopName());
}
Untuk mempersingkat tulisan, gw menulis parameternya menggunakan String, tapi baiknya case seperti di atas menggunakan Enum parameter pada Factory.
Masalah
Seperti yang pernah dibahas sebelumnya, jika dibuat tanpa Design Pattern maka method buildLaptop() akan semakin gendut seiring bertambahnya requirement seperti jenis laptop. Lalu maintenance property seperti Keyboard dan Graphic Card juga akan semakin kompleks kedepannya apabila ada penambahan property lainnya seperti Processor, RAM, Monitor, dan lainnya.
Solusi
Sekarang kita improve menggunakan Abstract Factory Design Pattern😎.
Interface Laptop
interface Laptop{
String getLaptopName();
String getKeyboardType();
String getGraphicType();
}
Abstract Class Laptop
public abstract class AbstractLaptop implements Laptop{
protected final LaptopProperty property;
protected AbstractLaptop(LaptopProperty property){
this.property = property;
}
}
Class AsusRog
public class AsusRog extends AbstractLaptop{
public AsusRog(LaptopProperty property){
super(property);
}
@Override
public String getLaptopName(){
return "Asus ROG Zephyrus";
}
@Override
public String getKeyboardType(){
return property.getLaptopKeyboard().getKeyboard();
}
@Override
public String getGraphicType(){
return property.getLaptopGraphicCard().getGraphic();
}
}
Class DellAlienware
public class DellAlienware extends AbstractLaptop{
public DellAlienware(LaptopProperty property){
super(property);
}
@Override
public String getLaptopName(){
return "Dell AlienWare M15";
}
@Override
public String getKeyboardType(){
return property.getLaptopKeyboard().getKeyboard();
}
@Override
public String getGraphicType(){
return property.getLaptopGraphicCard().getGraphic();
}
}
Class AsusVivobook
public class AsusVivobook extends AbstractLaptop{
public AsusVivobook(LaptopProperty property){
super(property);
}
@Override
public String getLaptopName(){
return "Asus Vivobook 14";
}
@Override
public String getKeyboardType(){
return property.getLaptopKeyboard().getKeyboard();
}
@Override
public String getGraphicType(){
return property.getLaptopGraphicCard().getGraphic();
}
}
Class DellLatitude
public class DellLatitude extends AbstractLaptop{
public DellLatitude(LaptopProperty property){
super(property);
}
@Override
public String getLaptopName(){
return "Dell Latitude 7490";
}
@Override
public String getKeyboardType(){
return property.getLaptopKeyboard().getKeyboard();
}
@Override
public String getGraphicType(){
return property.getLaptopGraphicCard().getGraphic();
}
}
Interface LaptopProperty
public interface LaptopProperty{
LaptopGraphicCard getLaptopGraphicCard();
LaptopKeyboard getLaptopKeyboard();
}
Class GamingLaptopProperty
public class GamingLaptopProperty implements LaptopProperty{
@Override
public LaptopGraphicCard getLaptopGraphicCard(){
return new GamingGraphicCard();
}
@Override
public LaptopKeyboard getLaptopKeyboard(){
return new GamingKeyboard();
}
}
Class OfficeLaptopProperty
public class OfficeLaptopProperty implements LaptopProperty{
@Override
public LaptopGraphicCard getLaptopGraphicCard(){
return new OfficeGraphicCard();
}
@Override
public LaptopKeyboard getLaptopKeyboard(){
return new OfficeKeyboard();
}
}
Interface LaptopFactory
public interface LaptopFactory{
Laptop buildLaptop(String laptop);
}
Class GamingLaptopFactory
public class GamingLaptopFactory implements LaptopFactory{
@Override
public Laptop buildLaptop(String laptop){
LaptopProperty property = new GamingLaptopProperty();
if("asus".equals(laptop)){
return new AsusRog(property);
}
if("dell".equals(laptop)){
return new DellAlienware(property);
}
throw new IllegalArgumentException("not found");
}
}
Class OfficeLaptopFactory
public class OfficeLaptopFactory implements LaptopFactory{
@Override
public Laptop buildLaptop(String laptop){
LaptopProperty property = new OfficeLaptopProperty();
if("asus".equals(laptop)){
return new AsusVivobook(property);
}
if("dell".equals(laptop)){
return new DellLatitude(property);
}
throw new IllegalArgumentException("not found");
}
}
Contoh penggunaan
public static void main(String[] args){
LaptopFactory laptopFactory = new OfficeLaptopFactory();
Laptop laptop = laptopFactory.buildLaptop("asus");
System.out.println("laptop.getLaptopName() = " + laptop.getLaptopName());
System.out.println("laptop.getGraphicType() = " + laptop.getGraphicType());
System.out.println("laptop.getKeyboardType() = " + laptop.getKeyboardType());
}
Setelah kita apply Abstract Factory Design Pattern, semuanya jadi lebih independent dan fleksibel, baik itu Laptop, LaptopFactory, hingga LaptopProperty. Method sebelumnya dipecah menjadi beberapa class Factory, yaitu GamingLaptopFactory dan OfficeLaptopFactory. Graphic Card dan Keyboard dibungkus ke dalam LaptopProperty yang digunakan oleh Laptop secara komposisi. Untuk "memaksa" turunan Laptop menggunakan LaptopProperty sebagai komposisi, kita perlu membuat AbstractLaptop dan menambahkan constructor yang menampung LaptopProperty. LaptopProperty dapat di-inject lewat masing-masing factory sesuai family objek terkait, dalam hal ini GamingLaptopProperty ke GamingLaptopFactory, dan OfficeLaptopProperty ke OfficeLaptopFactory.
Kenapa menggunakan Abstract Factory Design Pattern?
Secara pemakaian biasanya seorang software engineer menggunakan pendekatan Factory Method terlebih dahulu. Jika ditemukan case yang kompleks dan diselesaikan menggunakan komposisi, barulah menggunakan AbstractFactory. Biasanya ditandai dengan adanya beberapa komposisi yang mirip, seperti pada contoh di atas adalah Graphic Card dan Keyboard, sehingga family objek tersebut bisa dipecah. Gaming Graphic Card & Gaming Keyboard untuk Gaming Laptop, dan Office Graphic Card & Office Keyboard untuk Office Laptop. Dengan begitu masing-masing objek jadi lebih spesifik beserta satu set komposisi family objek terkait.
Verdict
Abstract Factory Design Pattern merupakan versi upgrade dari Factory Method Design Pattern. Keduanya memiliki tujuan yang sama, yaitu memberikan implementasi objek sesuai input user. Bedanya, jika Factory Method hanya berfokus pada inheritance, maka Abstract Factory juga berfokus pada composition. Makanya Abstract Factory lebih rumit daripada Factory Method😵. Biasanya design pattern ini baru dipertimbangkan setelah Factory Method Design Pattern sudah terlalu kompleks dan berkembang memiliki beberapa composition yang mempunyai kemiripan sehingga dapat dipecah sesuai family objek terkait. Makanya Abstract Factory ini tidak sepopuler saudaranya, Factory Method.