ภาษายอดนิยมอื่นจะหลีกเลี่ยงการใช้รูปแบบจากโรงงานในขณะที่จัดการความซับซ้อนที่คล้ายกันใน Java / Java EE อย่างไร

รูปแบบโรงงาน (หรืออย่างน้อยใช้FactoryFactory..) เป็นก้นของตลกจำนวนมากเช่นที่นี่

นอกเหนือจากการมี verbose และชื่อ "สร้างสรรค์" เช่น RequestProcessorFactoryFactory.RequestProcessorFactoryแล้วมีอะไรผิดปกติกับรูปแบบของโรงงานถ้าคุณต้องโปรแกรมใน Java / C ++ และมี usecase สำหรับAbstract_factory_pattern ?

ภาษายอดนิยมอื่นจะทำอย่างไร (เช่นRubyหรือScala ) จะหลีกเลี่ยงการใช้ภาษาในขณะที่จัดการความซับซ้อนที่คล้ายกันได้อย่างไร

เหตุผลที่ฉันถามคือฉันเห็นคำวิจารณ์ส่วนใหญ่ของโรงงานที่กล่าวถึงในบริบทของระบบนิเวศJava / Java EEแต่พวกเขาไม่เคยอธิบายว่าภาษา / กรอบอื่น ๆ แก้ปัญหาได้อย่างไร

คำถามของคุณถูกแท็กด้วย "Java" ไม่ต้องแปลกใจที่คุณถามว่าทำไมรูปแบบ Factory ถึงถูกเยาะเย้ย: Java เองมาพร้อมกับการละเมิดที่ทำมาอย่างดีของรูปแบบนั้น

ตัวอย่างเช่นลองโหลดเอกสาร XML จากไฟล์และเรียกใช้แบบสอบถาม XPath เทียบกับมัน คุณต้องการโค้ด 10 บรรทัดเพื่อเซ็ตอัพ Factories and Builders:

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

ฉันสงสัยว่าคนที่ออกแบบ API นี้เคยทำงานเป็นนักพัฒนาซอฟต์แวร์หรือไม่หรือเพิ่งอ่านหนังสือและทำสิ่งต่าง ๆ ฉันเข้าใจว่าพวกเขาไม่ต้องการเขียนโปรแกรมแยกวิเคราะห์ตัวเองและออกจากงานให้ผู้อื่น แต่มันก็ยังทำให้การใช้งานน่าเกลียด

เนื่องจากคุณถามว่ามีทางเลือกอื่นอะไรในการโหลดไฟล์ XML ใน C #:

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

ฉันสงสัยว่านักพัฒนา Java ที่เพิ่งแฮ็ตช์เห็นความบ้าคลั่งของ Factory และคิดว่ามันก็โอเคที่จะทำเช่นนั้น - หากอัจฉริยะที่สร้าง Java เองนั้นใช้มันมาก

โรงงานและรูปแบบอื่น ๆ เป็นเครื่องมือแต่ละแบบเหมาะสำหรับงานเฉพาะ หากคุณสมัครงานเหล่านั้นพวกเขาจะไม่เหมาะกับคุณที่คุณจะต้องมีรหัสที่น่าเกลียด

บ่อยครั้งที่ผู้คนเข้าใจผิดว่าเกิดอะไรขึ้น (และนั่นรวมถึงเสียงหัวเราะ)
ไม่ใช่รูปแบบของโรงงานต่อสิ่งที่เลวร้ายมากเท่าที่ผู้คนใช้ (อาจจะมากที่สุด)

และไม่ต้องสงสัยเลยว่าเกิดจากวิธีการสอนการเขียนโปรแกรม (และรูปแบบ) Schoolkids (มักเรียกตัวเองว่า "นักเรียน") ได้รับคำสั่งให้ "สร้าง X โดยใช้รูปแบบ Y" และหลังจากการทำซ้ำสองสามครั้งที่คิดว่านั่นเป็นวิธีการแก้ปัญหาการเขียนโปรแกรมใด ๆ
ดังนั้นพวกเขาจึงเริ่มใช้รูปแบบเฉพาะที่พวกเขาชอบในโรงเรียนกับทุกสิ่งไม่ว่าจะเหมาะสมหรือไม่ก็ตาม

และนั่นรวมถึงอาจารย์มหาวิทยาลัยที่เขียนหนังสือเกี่ยวกับการออกแบบซอฟต์แวร์เศร้า
สุดยอดของสิ่งนี้คือระบบที่ฉันมีความไม่พอใจอย่างชัดเจนในการรักษาซึ่งถูกสร้างขึ้นโดยคนหนึ่ง (ผู้ชายคนนั้นมีหนังสือหลายเล่มเกี่ยวกับการออกแบบเชิงวัตถุให้ชื่อของเขาและตำแหน่งการสอนในแผนก CS ของมหาวิทยาลัยใหญ่ )
มันขึ้นอยู่กับรูปแบบ 3 ระดับโดยแต่ละชั้นมีระบบ 3 ระดับ (ต้องแยก ... ) บนอินเทอร์เฟซระหว่างชุดระดับแต่ละชุดทั้งสองด้านเป็นโรงงานผลิตวัตถุเพื่อถ่ายโอนข้อมูลไปยังชั้นอื่นและโรงงานผลิตวัตถุเพื่อแปลวัตถุที่ได้รับเป็นชั้นที่รับ
สำหรับโรงงานแต่ละแห่งจะมีโรงงานที่เป็นนามธรรม (ใครจะรู้โรงงานอาจต้องเปลี่ยนและคุณไม่ต้องการให้รหัสโทรศัพท์ต้องเปลี่ยน ... )
และความยุ่งเหยิงทั้งหมดนั้นแน่นอนว่าไม่มีเอกสารอย่างสมบูรณ์

ระบบมีฐานข้อมูลที่ทำให้เป็นมาตรฐานในรูปแบบปกติที่ 5 (ฉันไม่ชอบคุณ)

ระบบที่มีความสำคัญมากกว่าสมุดที่อยู่เล็กน้อยที่สามารถใช้บันทึกและติดตามเอกสารขาเข้าและขาออกมีรหัสฐาน 100MB ใน C ++ และกว่า 50 ตารางฐานข้อมูล การพิมพ์จดหมาย 500 ฉบับจะใช้เวลานานถึง 72 ชั่วโมงโดยใช้เครื่องพิมพ์ที่เชื่อมต่อโดยตรงกับคอมพิวเตอร์ที่ใช้ซอฟต์แวร์

นั่นเป็นสาเหตุที่ผู้คนเย้ยหยันรูปแบบและโดยเฉพาะผู้คนที่มุ่งความสนใจไปที่รูปแบบที่เฉพาะเจาะจงอย่างเดียว

โรงงานมีข้อดีหลายประการที่อนุญาตให้มีการออกแบบแอพพลิเคชั่นที่หรูหราในบางสถานการณ์ สิ่งแรกคือคุณสามารถตั้งค่าคุณสมบัติของวัตถุที่คุณต้องการสร้างในภายหลังได้ด้วยการสร้างโรงงานจากนั้นจึงส่งโรงงานนั้นไปรอบ ๆ แต่บ่อยครั้งที่คุณไม่จำเป็นต้องทำเช่นนั้น ในกรณีที่ใช้โรงงานเพียงเพิ่มความซับซ้อนเพิ่มเติมโดยไม่ให้อะไรตอบแทนคุณ ลองมาโรงงานนี้ตัวอย่าง:

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

ทางเลือกหนึ่งสำหรับรูปแบบโรงงานคือรูปแบบตัวสร้างที่คล้ายกันมาก ความแตกต่างที่สำคัญคือคุณสมบัติของวัตถุที่สร้างโดยโรงงานถูกตั้งค่าเมื่อเริ่มต้นจากโรงงานในขณะที่ตัวสร้างจะเริ่มต้นด้วยสถานะเริ่มต้นและคุณสมบัติทั้งหมดจะถูกตั้งค่าในภายหลัง

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

แต่เมื่อมีปัญหาเกี่ยวกับการ overengineering การแทนที่ Factory ด้วย Builder อาจไม่ได้รับการปรับปรุงมากนัก

การแทนที่แบบง่ายที่สุดสำหรับทั้งสองรูปแบบนั้นแน่นอนในการสร้างออบเจ็กต์อินสแตนซ์ด้วย Constructor แบบง่าย ๆ กับnewโอเปอเรเตอร์:

Widget widget = new ColoredWidget(COLOR_RED);

อย่างไรก็ตามคอนสตรัคเตอร์มีข้อเสียเปรียบที่สำคัญในภาษาเชิงวัตถุส่วนใหญ่: พวกมันจะต้องส่งคืนออบเจ็กต์ของคลาสที่แน่นอนนั้นและไม่สามารถส่งคืนชนิดย่อยได้

เมื่อคุณต้องการเลือกประเภทย่อยตอนรันไทม์ แต่ไม่ต้องการหันไปใช้การสร้างทั้ง Builder หรือคลาสใหม่สำหรับคลาสนั้นคุณสามารถใช้วิธีการจากโรงงานแทน นี่เป็นวิธีการคงที่ของคลาสที่ส่งกลับอินสแตนซ์ใหม่ของคลาสนั้นหรือหนึ่งในคลาสย่อย โรงงานที่ไม่รักษาสถานะภายในใด ๆ มักจะถูกแทนที่ด้วยวิธีการจากโรงงานดังกล่าว:

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

คุณลักษณะใหม่ใน Java 8 เป็นการอ้างอิงวิธีการซึ่งช่วยให้คุณผ่านวิธีการต่างๆได้เหมือนกับที่คุณทำกับโรงงานไร้สัญชาติ สะดวกสิ่งใดก็ตามที่ยอมรับการอ้างอิงเมธอดยังยอมรับวัตถุใด ๆ ที่ใช้อินเทอร์เฟซการทำงานเดียวกันซึ่งสามารถเป็นโรงงานที่เต็มเปี่ยมด้วยสถานะภายในเพื่อให้คุณสามารถแนะนำโรงงานได้ในภายหลังเมื่อคุณเห็นเหตุผลในการทำเช่นนั้น

โรงงานประเภทใดประเภทหนึ่งพบได้ในภาษาเชิงวัตถุใด ๆ ภายใต้สถานการณ์ที่เหมาะสม บางครั้งคุณแค่ต้องการวิธีในการเลือกชนิดของวัตถุที่จะสร้างโดยใช้พารามิเตอร์อย่างง่ายเช่นสตริง

บางคนใช้เวลานานเกินไปและพยายามออกแบบรหัสเพื่อไม่ต้องเรียกคอนสตรัคเตอร์ยกเว้นในโรงงาน สิ่งต่างๆเริ่มไร้สาระเมื่อคุณมีโรงงาน

สิ่งที่ทำให้ฉันรู้สึกแย่เมื่อฉันเรียน Scala และฉันไม่รู้ Ruby แต่เชื่อว่ามันเหมือนกันมากคือภาษานั้นมีความหมายมากพอที่โปรแกรมเมอร์ไม่พยายามผลักงาน "ประปา" ไปยังแฟ้มการกำหนดค่าภายนอกเสมอ . แทนที่จะถูกล่อลวงให้สร้างโรงงานในโรงงานเพื่อเชื่อมโยงคลาสของคุณเข้าด้วยกันในรูปแบบที่แตกต่างกันใน Scala คุณใช้วัตถุที่มีลักษณะต่าง ๆ เข้าด้วยกันนอกจากนี้ยังค่อนข้างง่ายในการสร้าง DSLs ภาษาง่าย ๆ สำหรับงานที่บ่อยครั้ง

นอกจากนี้ยังมีความคิดเห็นและคำตอบอื่น ๆ ที่ชี้ให้เห็นการปิดและฟังก์ชั่นชั้นหนึ่งช่วยขจัดความจำเป็นในหลายรูปแบบ ด้วยเหตุนี้ฉันเชื่อว่ารูปแบบการต่อต้านจำนวนมากจะเริ่มหายไปเนื่องจาก C ++ 11 และ Java 8 ได้รับการยอมรับอย่างกว้างขวาง

โดยทั่วไปมีแนวโน้มว่าโปรแกรม Java นี้น่ากลัวเกินกว่าวิศวกรรม การมีโรงงานจำนวนมากเป็นหนึ่งในอาการที่พบได้บ่อยที่สุดของวิศวกรรมมากเกินไป นั่นเป็นสาเหตุที่ทำให้คนสนุกกับสิ่งเหล่านั้น

โดยเฉพาะอย่างยิ่งปัญหาที่ Java มีกับโรงงานคือใน Java a) constructors ไม่ใช่ function และ b) function ไม่ใช่พลเมืองชั้นหนึ่ง

ลองนึกภาพคุณสามารถเขียนสิ่งนี้ (ปล่อยให้Functionเป็นส่วนต่อประสานที่รู้จักกันดีของJRE )

// 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);

ดูไม่มีอินเทอร์เฟซหรือคลาสจากโรงงาน ภาษาไดนามิกจำนวนมากมีฟังก์ชั่นชั้นหนึ่ง อนิจจานี่เป็นไปไม่ได้กับ Java 7 หรือเก่ากว่า (การใช้งานเหมือนกันกับโรงงานถูกทิ้งไว้เป็นแบบฝึกหัดให้ผู้อ่าน)

ดังนั้นทางเลือกไม่มาก "ใช้รูปแบบที่แตกต่างกัน" แต่ "ใช้ภาษาที่มีโมเดลวัตถุที่ดีกว่า" หรือ "ไม่ทำปัญหาง่าย ๆ ให้วิศวกรทำมากเกินไป"