Nesne yaratma kalıplarından bir diğeri de Abstract Factory’dir. Soyut üretici olarak da dilimize çevrilebilecek olan bu kalıbın amacıyla ilgili GoF’da şu bilgiler bulunmaktadır:

Intent:  Provide an interface for creating families of related or dependent objects without specifying their concrete classes. Factory Method lets a class defer instantiation to subclasses.

Amaç: Birbirleriyle ilgili ya da bağımlı nesne ailelerini, nesnelerin somut sınıflarını belirtmeden yaratmak için bir arayüz sağlamak. Factory Method bir sınıfın nesnesinin yaratılmasını, alt sınıflara ertelemesine izin verir.

Factory Method ile Abstract Factory kalıpları genelde karıştırılır. Factory Method tek nesne, Abstract Factory ise tek nesne yerine, nesne ailesi oluşturmak üzere kullanılan bir kalıptır. Abstract Factory bir sınıftır, Factory Method ise bir metottur. Abstract Factory, birden fazla Factory Method kullanarak oluşturulabilir. Abstract Factory, genelde birbirleriyle ilgili nesne ailelerini ya da gruplarını oluşturmakta kullanılır. Dolayısıyla Abstract Factory üzerinde ailenin her ferdi için ayrı bir Factory Method bulunur.

Yukarıdaki modeldeki kod örneklerine bakarsak, Component arayüzü aşağıdaki gibidir:

package org.javaturk.dp.pattern.gof.creational.abstractFactory.gui;

public interface Component {
	public void paint();
}

Bileşenlerden olan Button sınıfı ise abstract olup aşağıdaki gibidir:

package org.javaturk.dp.pattern.gof.creational.abstractFactory.gui;

public abstract class Button implements Component{
    public abstract void paint();
}

Button‘un bir alt sınıfı olan OSXButton ise şöyledir:

package org.javaturk.dp.pattern.gof.creational.abstractFactory.gui;

public class OSXButton extends Button {
    public void paint() {
        System.out.println("Painting an OSX Button!");
    }
}

Diğer tarafta ise AbstractFactory’nin sınıfları bulunur. İlki bir arayüz olan GUIFactory‘dir:

package org.javaturk.dp.pattern.gof.creational.abstractFactory.gui;

interface GUIFactory {
    public Component createButton();
    
    public Component createList();
    
    public Component createTable();
}

GUIFactory‘nin bir gerçekleştirmesi ise OSXFactory’dir.

package org.javaturk.dp.pattern.gof.creational.abstractFactory.gui;

public class OSXFactory implements GUIFactory {

    public Button createButton() {
        return new OSXButton();
    }

	@Override
	public List createList() {
		return new OSXList();
	}

	@Override
	public Table createTable() {
		return new OSXTable();
	}
}

Bu durumda Client kodumuz da şöyle olacaktır:

package org.javaturk.dp.pattern.gof.creational.abstractFactory.gui;

class Client {
    public Client(GUIFactory factory){
        Component button = factory.createButton();
        button.paint();
        
        Component list = factory.createList();
        list.paint();
        
        Component table = factory.createTable();
        table.paint();
    }
}

Abstract Factory kalıbı, ürün aileleri ve onları üreten nesnelerle ilgili sistematik bir isimlendirme sağlar. Sisteme yeni bir nesnenin (ScrollBar) katılması durumunda hem Abstract Factory’e hem de alt sınıf olan üreticilerine (OSXFactory ve WinFactory) gerekli factory metotlarının (createScrollBar()) eklenmesi gereklidir. Yeni bir aile (XWindows) eklenmesi durumunda ise her nesnenin o aileye ait alt sınıfı (XWindowsButton, …) ile üretici alt sınıfının (XWindowsFactory) sisteme eklenmesi gereklidir.

Java APIlerinde pek çok Abstract Factory kullanımı vardır:

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

Abstract Factory, Factory Method’u sıklıkla kullanılır. Factory Method bir metot iken, Abstract Factory bir sınıftır. Dolayısıyla Abstract Factory bir üst soyutlama yapısı sağlar. Factory Method bir nesne için bir yaratma yöntemi sağlarken, Abstract Factory bir nesne için birden fazla yaratma yöntemi sağlar. 

Ayrıca Abstract Factory, Factory Method yanında Builder ve Prototype da kullanılır.

Toplam görüntülenme sayısı: 2788

Bir önceki yazıda Factory Method kalıbına giriş yapmıştık ve sınıf diyagramı ile tipik bir uygulamasını görmüştük. Şimdi bu uygulamanın kodlarına kısaca göz atalım.

Önce Product yapısına bakalım:

public interface Product {
	
	public void doThis();

}


public class ProductA implements Product {

	private int id;
	private String name;
	
	public ProductA(int id, String name) {
		this.id = id;
		this.name = name;
	}

	@Override
	public void doThis(){
		System.out.println("do() in ProductA");
	}
        ...
}


public class ProductB implements Product {
	
	private int no;
	private String description;
	
	public ProductB(int no, String description) {
		this.no = no;
		this.description = description;
	}

	@Override
	public void doThis(){
		System.out.println("do() in ProductB");
	}
        ...
}

Şimdi de bu Product yapısındaki nesneleri oluşturan üretici metotlara bakalım:

public interface Factory {
	public Product create();
}


public class ProductAFactory implements Factory {

	@Override
	public Product create() {
		ProductA productA = new ProductA(1, "Product-A-1");
		return productA;
	}
}


public class ProductBFactory implements Factory {

	@Override
	public Product create() {
		ProductB productB = new ProductB(2, "Product-B-2");
		return productB;
	}
}

Bu durumda Client ve Test nesneleri de şöyle olur:

public class Client {
	
	private Product productA;
	private Product productB;
	
	private Factory productAFactory;
	private Factory productBFactory;
	
	public Client(Factory productAFactory, Factory productBFactory){
		productA = productAFactory.create();
		productB = productBFactory.create();
	}
	
	public void start(){
		productA.doThis();
		productB.doThis();
	}
}

public class Test {

	public static void main(String[] args) {
		Client client = new Client(new ProductAFactory(), new ProductBFactory());
		client.start();
	}
}

Hem bir önceki yazıda verdiğimiz sınıf diyagramı hem de yukarıdaki kodlardan anladığımıza göre artık  Client’ın Product’ları doğrudan yaratmak yerine, bunu üretici metotlara havale ettiğini ve Product’larla arayüzleri üzerinden haberleştiğini görüyoruz. Bu durum ise Factory arayüzünü yerine getiren ve üretici metotlara sahip üretici sınıflarla başarılır. Bu şekilde Client’ın hem Product’lara hem de onları üreten Factory’lere bağımlılığı arayüz seviyesine iner.

Factory arayüzü sayesinde, uygulamadaki sınıflar, bu sınıfları kullanan client kodlarından olabildiğinde yalıtılmış olur. Bu yaklaşımın en temel problemi, her yeni Product sınıfı için yeni bir Factory alt sınıfa ihtiyaç duyurmasıdır. Yani, yeni bir Product nesnesi olan ProductC için ProductCFactory alt sınıfına ihtiyaç duyulur.

Bu kalıp üzerinde ihtiyaca göre bazı oynamalar tabi olarak yapılabilir. Örneğin Factory tipi arayüz ya da soyut (abstract) sınıf yerine somut (concrete) sınıf da olabilir. Bu durumda create() factory metodu parametre alarak, hangi Product nesnesinin yaratılacağına karar verebilir. Ve her yeni Product nesnesi için yeni bir factory nesnesine ihtiyaç da kalmaz. Bu durumda Factory sınıfı Singleton da olabilir ve istenirse farklı implementationlar için Factory sınıfı hala extend edilebilir. Bu durumdaki Factory sınıfı ile factory metodu ve Client aşağıda olduğu gibidir.

public class Factory {
	
	public Product create(String productType){
		Product product = null;
		if(productType.equalsIgnoreCase("a"))
			product = new ProductA(1, "Product-A-1");
		else if(productType.equalsIgnoreCase("b"))
			product = new ProductB(2, "Product-B-2");
		return product;
	}
}

public class Client {
	
	private Product productA;
	private Product productB;
	
	public Client(Factory factory){
		productA = factory.create("a");
		productB = factory.create("b");
	}
	
	public void start(){
		productA.doThis();
		productB.doThis();
	}
}

Yukarıdaki durumun bir özel hali olarak, client, kullanacağı nesnenin yaratılması için gerekli bazı bilgileri sağlama durumunda olabilir. Bu durumda yukarıdaki örneğe benzer şekilde client, üretici metoda bu bilgileri geçmelidir. Burada dikkat edilmesi gereke husus, clientın geçeceği bu bilgileri hakikatten sadece clientın biliyor olmasıdır. Factory methodun da erişebileceği bilgileri clientın geçmesi hem anlamlı değildir hem gereksiz bağımlılık oluşturarak bu kalıbı kullanmaktan doğan faydayı azaltır.

Bu kalıbın çok sıklıkla, Factory sınıfının üzerindeki factory metotlarını statik yaparak kullanılması da söz konusudur. Bu durumda Client sınıfı Factory sınıfının nesnesini oluşturmak zorunda kalmaz ve Factory sınıfının alt sınıflarını oluşturmaktan da kaçınılmış olur.

public class Factory {
	
	public static Product create(String productType){
		Product product = null;
		if(productType.equalsIgnoreCase("a"))
			product = new ProductA(1, "Product-A-1");
		else if(productType.equalsIgnoreCase("b"))
			product = new ProductB(2, "Product-B-2");
		return product;
	}
}

public class Client {
	
	private Product productA;
	private Product productB;
	
	public Client(){
		productA = Factory.create("a");
		productB = Factory.create("b");
	}
	
	public void start(){
		productA.doThis();
		productB.doThis();
	}
}

Bu yaklaşımın problemi, büyüyebilen (scalable) olmamasıdır. Yani oluşturulacak nesnelerin sayısı arttıkça, iflerin sayısı da artacaktır. Dolayısıyla bu çözüm zaten Open-Closed Principle ( OCP)’a aykırıdır. Hatta bir müddet sonra ilgili-ilgisiz her türlü nesnenin kendisiyle oluşturulduğu devasa bir metota sahip olabilirsiniz. Dolayısıyla bu yaklaşım bir ters-kalıptır (anti-pattern). Eğer birbiriyle ilgili birden fazla nesneyi yaratma probleminiz varsa bu durumda zaten Abstract Factory kullanılabilir.

Factory Method’un her zaman nesne oluşturması gerekmez. Nesne havuzu (object pool) gibi yapılarda Factory Method havuzdan bir nesne de geri döndürebilir.

J. Bloch “Effective Java 2nd Ed.” isimli kitabının ilk maddesinde, yapılandırıcı kullanmak yerine statik factory metotları kullanmayı tavsiye ediyor. Çünkü metotların ismi olmasına karşın yapılandırıcıların ayırt edici isimleri yoktur. Ve özellikle de karmaşık nesnelerde pek çok yapılandırıcı vardır ama hangisinin çağrılacağı çok zaman zaman alan bir kodlama gerektirir.

Sonuçlar

Factory Method kalıbı, nesne yaratma işinin kontrolünü sisteme bırakarak, clientın sadece kullanmak istediği nesneleri istemekle yetinebileceğini göstermektedir. Bir nesneyi kullanmayı bilmek o nesnenin arayüzünü (interface) bilmek anlamına gelmektedir. Yapılandırıcılar çoğu kez karmaşık metotlardır ve çağrılabilmeleri için pek çok bilgiye ihtiyaç duyarlar. Bu bilgileri toparlamanın sorumluluğu olabildiğince client tarafında olmamalıdır. Client, nasıl yaratıldığını bilmeden nenelerle haberleşebilmelidir. Bu kalıp ile bu esneklik sağlanır.

Aynı zamanda client da Product nesnelerinin gerçek tiplerini bilmek zorunda olmadan onlarla haberleşebilmektedir: Polymorphism!

Kullanımlar

Java APIlerinde Factory Method’un pek çok kullanımı vardır.

• java.sql paketinde Connection üzerinde createStatement() metotları farklı Statement nesneleri üretilir.
• Aynı paketteki Statement üzerindeki executeQuery() metodu ile de ResultSet nesnesi üretilir.
• javax.persistence paketinde EntityManagerFactory üzerindeki createEntityManager() metotları EntityManager nesneleri üretir.

Bazen factory metodunun statik olduğu da görülür:

• java.sql.Driver getConnection()
• javax.persistence.Persistence createEntityManagerFactory()
• java.util.Calendar getInstance()
• java.util.ResourceBundle getBundle()
• java.text.NumberFormat getInstance()

Buradaki amaç factory methodunun override, içindeki sınıfın da extend edilmesini önlemektir.

Diğer Kalıplarla İlişkiler

Factory Method, Abstract Factory kalıbında sıklıkla kullanılır. Somut sınıfla gerçekleştirilmesi durumunda Factory Method, bir Singleton içinde bulunabilir.

Toplam görüntülenme sayısı: 2328

Factory method ya da Türkçesiyle üretici metot, muhtemelen programcılık tecrübesi içerisinde programcıların tabi olarak ihtiyacını ilk defa hissettikleri kalıptır. Çünkü bu kalıp, nesnelerin yaratılmalarını soyutlamakta ve üretici metot dediğimiz factory metoduna havale etmektedir.

GoF’da bu kalıbın amacı için şu denmektedir:

Intent: Define an interface for creating an object, but let subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

Amaç: Bir nesne yaratmak için bir arayüz tanımla, fakat hangi sınıfın nesnesinin oluşturulacağına alt sınıflar karar versin. Factory methodu bir sınıfın nesne oluşturmasını alt sınıflarına ertelemesine izin verir.

Problem

Nesne-merkezli programlardaki tabi olarak en temel iş, nesne yaratmaktır. Uygulamalarda farklı karmaşıklıkta pek çok sınıf vardır ve bu sınıfların nesneleri uygulamanın farklı yerlerinde oluşturulur. Bu kalıp, nesnelerin yaratılmalarını soyutlamakta ve bu işi “üretici” ya da “factory” metoda havale etmektedir. Factory method, nesnelerin yaratılmasından sorumlu bir metottur öyle ki bir arayüzün alt sınıfında bulunur.

Client’ın, Product nesnelerinin sadece arayüzlerini değil aynı zamanda nasıl yaratılacaklarını da bilmesi, Client’ın Product’lara olan bağımlılığını arttırır. Çoğu zaman bir nesneyi yaratmak, onu kullanmaktan daha karmaşıktır.

Aşağıdaki diyagramda, Client ile Product nesneleri arasında, doğrudan yaratmaya bağlı ilişki ifade edilmiştir.

Klasik Client-Product ilişkisi.

Bu duruma karşılık gelen ProductA ve ProductB kodları şöyledir:

package org.javaturk.dp.pattern.gof.creational.factoryMethod.product.old;

public class ProductA {
	private int id;
	private String name;
	
	public ProductA(int id, String name) {
		this.id = id;
		this.name = name;
	}

	public void doThis(){
		System.out.println("do() in ProductA");
	}

	public int getId() {
		return id;
	}
        ...
}

ve

package org.javaturk.dp.pattern.gof.creational.factoryMethod.product.old;

public class ProductB {
	private int no;
	private String description;
	
	public ProductB(int no, String description) {
		this.no = no;
		this.description = description;
	}

	public void doThis(){
		System.out.println("do() in ProductB");
	}

	public int getNo() {
		return no;
	}
	...
}

ve Client da:

package org.javaturk.dp.pattern.gof.creational.factoryMethod.product.old;

public class Client {
	
	private ProductA productA;
	private ProductB productB;
	
	public Client(){
		productA = new ProductA(1, "Product-A-1");
		productB = new ProductB(2, "Product-B-2");
	}
	
	public void start(){
		productA.doThis();
		productB.doThis();
	}
}

Çözüm

Bu yüzden Client’ın Product’ları doğrudan yaratmak yerine, bunu üretici metotlara havale etmesi ve Product’larla arayüzleri üzerinden haberleşmesi daha rahattır. Bu ise Factory arayüzünü yerine getiren ve üretici metotlara sahip üretici sınıflarla başarılır. Bu şekilde Client’ın hem Product’lara hem de onları üreten Factory’lere bağımlılığı arayüz seviyesine iner.

Factory method kalıbından sonraki ilişki

Bir sonraki yazıda Factory Method ile geliştirdiğimiz çözümün kodlarına bakacağız.

Toplam görüntülenme sayısı: 3902