Başka bir popüler dil, Java / Java EE'deki ile aynı karmaşıklığı yönetirken fabrika şablonunu kullanmak zorunda kalmayı nasıl önlerdi?

Fabrika desen (veya en azından kullanım FactoryFactory..) gibi birçok alay konusu olmuştur burada .

RequestProcessorFactoryFactory.RequestProcessorFactory gibi ayrıntılı ve "yaratıcı" adlara sahip olmasının yanı sıra, Java / C ++ dilinde programlamak zorundaysanız ve Abstract_factory_pattern için bir usecase varsa, fabrika modelinde temelde yanlış bir şey var mı?

Başka bir popüler dil (örneğin, Ruby veya Scala ) benzer karmaşıklığı yönetirken kullanmak zorunda kalmayı nasıl önlerdi?

Sormamın nedeni çoğunlukla Java / Java EE ekosistemi bağlamında belirtilen fabrikaların eleştirilerini görüyorum , ancak diğer dillerin / çerçevelerin bunları nasıl çözdüklerini asla açıklamıyorlar.

Sorunuz "Java" ile etiketlendi, Fabrika modelinin neden alay edildiğini sorduğunuza şaşırmamak gerek: Java'nın kendisi, bu modelin hoş bir şekilde paketlenmiş suiistimalleriyle geliyor.

Örneğin, bir dosyadan bir XML belgesi yüklemeyi deneyin ve ona karşı bir XPath sorgusu çalıştırın. Sadece Fabrikaları ve İnşaatçıları kurmak için 10 kod satırı gibi bir şeye ihtiyacınız var:

DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
DocumentBuilder builder = builderFactory.newDocumentBuilder(); 

Document xmlDocument = builder.parse(new FileInputStream("c:\\employees.xml"));
XPath xPath =  XPathFactory.newInstance().newXPath();

xPath.compile(expression).evaluate(xmlDocument);

Acaba bu API'yi tasarlayanlar geliştirici olarak çalışmış mıydı yoksa sadece kitap okuyor mu ve etrafa bir şeyler attı mı? Anladığım kadarıyla sadece ayrıştırıcı yazmak istemediler ve görevi başkalarına bıraktılar ama yine de çirkin bir uygulama için yapılıyor.

Alternatifin ne olduğunu sorduğundan beri, XML dosyasını C # 'a yüklüyor:

XDocument xml = XDocument.Load("c:\\employees.xml");
var nodes = xml.XPathSelectElements(expression);

Yeni yumurtadan çıkmış Java geliştiricilerinin Fabrika deliliğini gördüklerinden ve bunu yapmanın uygun olmadığını düşündüğümden şüpheleniyorum.

Fabrika ve diğer kalıplar, her biri belirli bir iş için uygun olan aletlerdir. Onları işlere uygularsanız, çirkin kodunuz olması zorunlu değildir.

Sık sık, insanlar neler olup bittiğini yanlış anlar (ve bu kahkahaların çoğunu içerir).
Her birinin (belki de çoğu) kullandığı kadar kötü olan fabrika düzeni değil.

Ve bu şüphesiz programlama (ve kalıpların) öğretilme biçiminden kaynaklanmaktadır. Okul çocuklarına (genellikle kendilerini “öğrenci” olarak adlandırırlar) “Y deseni kullanarak X yaratmaları” söylenir ve birkaç yinelemeden sonra herhangi bir programlama problemine yaklaşmanın bu olduğunu düşünür.
Böylece okulda olduğu gibi, uygun olup olmadığına bakılmaksızın her şeye ve her şeye karşı olan belirli bir kalıp uygulamaya başlarlar.

Ve ne yazık ki, yazılım tasarımı hakkında kitap yazan üniversite profesörlerini de içeriyor.
Bunun doruk noktası, böyle biri tarafından yaratılmış olması gereken bakımdan hoşnutsuzluk duyduğum bir sistemdi. ).
3 katmanlı bir desene dayanıyordu, her bir katmanın kendisi 3 katmanlı bir sistemdi (ayrıştırmak zorunda kaldı ...). Her bir katman kümesi arasındaki ara yüz üzerinde, her iki tarafta da verileri diğer katmana aktarmak için nesneler üreten bir fabrika ve alınan nesneyi alıcı katmana ait olan birine çevirecek nesneyi üreten bir fabrika vardı.
Her fabrika için soyut bir fabrika vardı (kim bilir, fabrika değişmek zorunda kalabilir ve sonra çağrı kodunun değişmesini istemezsiniz…).
Ve bütün bu karışıklık elbette tamamen belgesizdi.

Sistem 5. normal formda normalize edilmiş bir veritabanına sahipti.

Temelde, gelen ve giden belgeleri kaydetmek ve izlemek için kullanılabilecek bir adres defterinden biraz daha küçük bir sistemde, C ++ ve 50'den fazla veritabanı tablosunda 100 MB'lık bir kod tabanı vardı. 500 form harfin yazdırılması, yazılımı çalıştıran bilgisayara doğrudan bağlı bir yazıcının kullanılması 72 saat kadar sürer.

Bu, insanların neden kalıpları çizdiğini ve özellikle de insanların tek tek belirli bir kalıp üzerine odaklandığını açıklıyor.

Fabrikalar, bazı durumlarda şık uygulama tasarımlarına izin veren birçok avantaja sahiptir. Birincisi, daha sonra bir fabrika oluşturarak bir yerde oluşturmak istediğiniz nesnelerin özelliklerini ayarlayabilmeniz ve daha sonra bu fabrikayı teslim edebilmenizdir. Ancak çoğu zaman bunu gerçekten yapmanız gerekmez. Bu durumda bir Fabrika kullanımı, size karşılığında hiçbir şey vermeden, sadece ek bir karmaşıklık ekler. Bu fabrikayı ele alalım, örneğin:

WidgetFactory redWidgetFactory = new ColoredWidgetFactory(COLOR_RED);
Widget widget = redWidgetFactory.create();

Fabrika modeline bir alternatif, benzer yapı modeline benzer. Temel fark, bir Fabrika tarafından yaratılan nesnelerin özelliklerinin Fabrika başlatıldığında, bir Oluşturucu varsayılan durumla başlatıldığında ve tüm özelliklerin daha sonra ayarlanmasıdır.

WidgetBuilder widgetBuilder = new WidgetBuilder();
widgetBuilder.setColor(COLOR_RED);
Widget widget = widgetBuilder.create();

Ancak aşırı mühendislik yapmak sizin probleminiz olduğunda, bir Fabrika'yı bir Oluşturucu ile değiştirmek muhtemelen bir gelişme değildir.

Her iki model için de en basit alternatif, newoperatörle basit bir kurucu ile nesne örnekleri oluşturmaktır.

Widget widget = new ColoredWidget(COLOR_RED);

Bununla birlikte, inşaatçılar çoğu nesne yönelimli dilde çok önemli bir dezavantaja sahiptir: Bu sınıfın bir nesnesini döndürmeleri gerekir ve bir alt tür döndüremezler.

Çalışma zamanında alt türü seçmeniz gerektiğinde, ancak bunun için tamamen yeni bir Oluşturucu veya Fabrika sınıfı oluşturmaya başvurmak istemiyorsanız, bunun yerine fabrika yöntemini kullanabilirsiniz. Bu, o sınıfın veya alt sınıflarından birinin yeni örneklerini döndüren bir sınıfın statik bir yöntemidir. Herhangi bir iç durumu sağlamayan bir Fabrika genellikle böyle bir fabrika yöntemiyle değiştirilebilir:

 Widget widget = Widget.createColoredWidget(COLOR_RED); // returns an object of class RedColoredWidget

Java 8'deki yeni bir özellik , tıpkı bir vatansız fabrika ile yaptığınız gibi, yöntemleri geçmenize izin veren yöntem referanslarıdır . Bir yöntem referansını kabul eden herhangi bir şey aynı zamanda, aynı işlevsel arayüzü uygulayan herhangi bir nesneyi de kabul eder; bu, aynı zamanda dahili devlete sahip tam teşekküllü bir Fabrika olabilir, böylece bunu yapmak için bir neden gördüğünüzde fabrikaları kolayca tanıtabilirsiniz.

Bir veya diğer tür fabrikalar, uygun koşullar altında hemen hemen herhangi bir nesne yönelimli dilde bulunur. Bazen sadece bir dize gibi basit bir parametreye dayanarak ne tür bir nesne oluşturacağınızı seçmeniz için bir yöntem gerekir.

Bazı insanlar bunu çok ileri götürür ve bir fabrika dışında hiçbir zaman bir inşaatçı çağırmak zorunda kalmamak için kodlarını oluşturmaya çalışır. Fabrika fabrikalarınız olduğunda işler saçma olmaya başlar.

Scala'yı öğrendiğimde beni vuran ve Ruby'yi bilmediğim, ama aynı şekilde olduğuna inanıyorum, dilin programcıların her zaman "sıhhi tesisat" işini dış yapılandırma dosyalarına zorlamaya çalışmadığı kadar açık bir ifade olduğuna inanıyorum. . Sınıflarınızı farklı konfigürasyonlarda bir araya getirmek için fabrika fabrikaları kurmaya istekli olmaktansa, Scala'da özellikleri karışık olan nesneleri kullanırsınız. Java'da genellikle çok fazla işlenen işler için dilde basit DSL'ler oluşturmak nispeten kolaydır.

Ayrıca, diğer yorum ve cevapların da belirttiği gibi, kapanışlar ve birinci sınıf fonksiyonlar birçok paterne olan ihtiyacı ortadan kaldırmaktadır. Bu nedenle, anti-kalıpların birçoğunun C ++ 11 olarak kaybolmaya başlayacağına ve Java 8'in yaygınlaştığını düşünüyorum.

Genel olarak, Java programlarının korkunç derecede fazla mühendislik yaptığı [kaynak belirtilmeli] bu eğilim vardır. Birçok fabrikaya sahip olmak, aşırı mühendisliğin en yaygın belirtilerinden biridir; Bu yüzden insanlar onlarla dalga geçiyor.

Özellikle, Java’nın fabrikalarla ilgili sorunu, Java’da a) yapıcıların işlevsiz olması ve b) işlevlerin birinci sınıf vatandaş olmamasıdır.

Böyle bir şey yazabileceğinizi hayal edin ( JRE'ninFunction iyi bilinen bir arayüzü olsun )

// Framework code
public Node buildTree(Function<BranchNode, Node, Node> branchNodeFactory) {
    Node current = nextNode();
    while (hasNextNode()) {
        current = branchNodeFactory.call(current, nextNode());
    }
    return current
}

// MyDataNode.java
public class MyBranchNode implements BranchNode {

    public MyBranchNode(Node left, Node right) { ... }
}

// Client code
Node root = buildTree(MyBranchNode::new);

Bakın, fabrika arayüzü veya sınıf yok. Birçok dinamik dil birinci sınıf fonksiyonlara sahiptir. Ne yazık ki, bu Java 7 veya daha önceki sürümlerde mümkün değildir (fabrikaların aynısını uygulamak okuyucunun alıştırması olarak bırakılmıştır).

Bu nedenle, alternatif çok fazla "farklı bir kalıp kullan" değil, "daha iyi bir nesne modeline sahip bir dil kullan" ya da "basit problemleri fazla mühendislik yapma" dır.