คำถามติดแท็ก architectural-patterns

ฉันอ่าน / ดูเนื้อหา Robert C. Martin มากมาย ฉันเจอเขาแล้วบอกว่า SQL นั้นไม่จำเป็นเพราะโซลิดสเตตไดรฟ์ เมื่อฉันค้นหาแหล่งข้อมูลอื่น ๆ เพื่อสำรองสิ่งนี้ฉันได้รับบทความสุ่มจำนวนมากที่อธิบายถึงความแตกต่างของประสิทธิภาพการทำงานของ SQL ระหว่างฮาร์ดไดรฟ์และโซลิดสเตทไดรฟ์ (ซึ่งเกี่ยวข้อง แต่ไม่ใช่สิ่งที่ฉันพยายามค้นคว้า) ท้ายที่สุดฉันไม่เข้าใจสิ่งที่เขาพยายามทำ เขากำลังพูดแทนที่ SQL ด้วยเทคโนโลยี No-SQL หรือไม่ เขาบอกว่าเก็บข้อมูลในไฟล์ในระบบไฟล์หรือไม่? หรือเขาต้องการให้คนหยุดใช้ SQL / ฐานข้อมูลเชิงสัมพันธ์เนื่องจากการโจมตีของ SQLi ฉันกลัวว่าฉันพลาดจุดที่เขาพยายามจะทำ ฉันจะให้ลิงก์บางส่วนที่นี่เพื่อให้คุณสามารถอ่านได้โดยตรงจากความคิดของเขา: Bobby Tables การบรรยายสถาปัตยกรรมที่สะอาด อันดับแรกเขาระบุว่าควรลบ SQL ออกจากระบบทั้งหมด การแก้ไขปัญหา. ทางออกเดียว คือการกำจัด SQL ออกจากระบบทั้งหมด หากไม่มีเอ็นจิ้น SQL จะไม่มีการโจมตี SQLi และแม้ว่าเขาจะพูดถึงการแทนที่ SQL ด้วย API …

45 architecture  enterprise-architecture  architectural-patterns  plugin-architecture 

สถาปัตยกรรมสะอาดแนะนำให้ให้โต้ตอบด้วยกรณีใช้เรียกใช้งานจริงของพรีเซนเตอร์ (ซึ่งถูกฉีดต่อไปนี้กรมทรัพย์สินทางปัญญา) เพื่อจัดการการตอบสนอง / จอแสดงผล อย่างไรก็ตามฉันเห็นคนที่ใช้สถาปัตยกรรมนี้ส่งคืนข้อมูลเอาต์พุตจากผู้โต้ตอบจากนั้นปล่อยให้คอนโทรลเลอร์ (ในชั้นอะแดปเตอร์) ตัดสินใจเลือกวิธีจัดการกับมัน โซลูชันที่สองรั่วไหลความรับผิดชอบของแอปพลิเคชันออกจากเลเยอร์แอปพลิเคชันนอกเหนือจากการกำหนดอินพุตและเอาต์พุตพอร์ตให้กับผู้โต้ตอบไม่ชัดเจนหรือไม่ พอร์ตอินพุตและเอาต์พุต เมื่อพิจารณาคำจำกัดความของ Clean Architectureและโดยเฉพาะอย่างยิ่งแผนภาพการไหลขนาดเล็กที่อธิบายความสัมพันธ์ระหว่างตัวควบคุมผู้ใช้เคสผู้โต้ตอบและผู้นำเสนอฉันไม่แน่ใจว่าฉันเข้าใจถูกต้องหรือไม่ว่าควรใช้ "พอร์ตเคสเอาต์พุต" อย่างไร สถาปัตยกรรมแบบคลีนเช่นสถาปัตยกรรมหกเหลี่ยมแยกความแตกต่างระหว่างพอร์ตหลัก (เมธอด) และพอร์ตรอง (อินเทอร์เฟซที่จะใช้งานโดยอะแดปเตอร์) ตามกระแสการสื่อสารฉันคาดหวังว่า "ใช้ Case Input Port" เป็นพอร์ตหลัก (ดังนั้นเป็นเพียงวิธีการ) และ "Use Case Output Port" เป็นอินเตอร์เฟสที่จะใช้งานอาจเป็นอาร์กิวเมนต์ตัวสร้างที่ใช้อะแดปเตอร์จริง เพื่อให้ผู้โต้ตอบสามารถใช้งานได้ ตัวอย่างรหัส ในการสร้างตัวอย่างโค้ดนี่อาจเป็นรหัสคอนโทรลเลอร์: Presenter presenter = new Presenter(); Repository repository = new Repository(); UseCase useCase = new UseCase(presenter, …

42 architecture  architectural-patterns  onion-architecture 

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

33 architecture  microservices  architectural-patterns  dto  pubsub 

ฉันจะบอกได้อย่างไรว่าซอฟต์แวร์ของฉันมีสิ่งที่เป็นนามธรรมมากเกินไปและมีรูปแบบการออกแบบมากเกินไปหรือในทางกลับกันฉันจะรู้ได้อย่างไรว่าควรมีซอฟต์แวร์มากกว่านั้น นักพัฒนาที่ฉันทำงานด้วยกำลังเขียนโปรแกรมต่าง ๆ เกี่ยวกับประเด็นเหล่านี้ บางฟังก์ชั่นเป็นนามธรรมทุกฟังก์ชั่นเล็กน้อยใช้รูปแบบการออกแบบทุกที่ที่เป็นไปได้ คนอื่นรวมถึงฉันพยายามที่จะใช้ประโยชน์ได้มากขึ้นและเขียนโค้ดที่ไม่เหมาะกับทุกรูปแบบการออกแบบ แต่เป็นวิธีที่เข้าใจได้เร็วขึ้นเพราะใช้นามธรรมน้อยกว่า ฉันรู้ว่านี่เป็นการแลกเปลี่ยน ฉันจะบอกได้อย่างไรว่ามีสิ่งที่เป็นนามธรรมเพียงพอในโครงการและฉันจะรู้ได้อย่างไรว่ามันต้องการมาก ตัวอย่างเมื่อเลเยอร์แคชทั่วไปถูกเขียนโดยใช้ Memcache เราจำเป็นต้องจริงๆMemcache, MemcacheAdapter, MemcacheInterface, AbstractCache, CacheFactory, CacheConnector... หรือคือง่ายต่อการรักษาและยังคงรหัสที่ดีเมื่อใช้เพียงครึ่งหนึ่งของชั้นเรียนเหล่านั้นหรือไม่ พบสิ่งนี้ใน Twitter: ( https://twitter.com/rawkode/status/875318003306565633 )

29 design-patterns  architecture  clean-code  abstraction  architectural-patterns 

ฉันกำลังสร้าง API ซึ่งเป็นฟังก์ชันที่อัปโหลดไฟล์ ฟังก์ชั่นนี้จะไม่ส่งคืน / เป็นโมฆะหากไฟล์ถูกอัปโหลดอย่างถูกต้องและส่งข้อยกเว้นเมื่อเกิดปัญหา ทำไมมีข้อยกเว้นและไม่ใช่แค่ของเท็จ? เพราะภายในข้อยกเว้นฉันสามารถระบุสาเหตุของความล้มเหลว (ไม่มีการเชื่อมต่อชื่อไฟล์หายไปรหัสผ่านผิดรายละเอียดไฟล์หายไป ฯลฯ ) ฉันต้องการสร้างข้อยกเว้นที่กำหนดเอง (ด้วย enum บางอย่างเพื่อช่วยผู้ใช้ API ในการจัดการข้อผิดพลาดทั้งหมด) นี่เป็นวิธีปฏิบัติที่ดีหรือเป็นการส่งคืนวัตถุที่ดีกว่า (ภายในบูลีนข้อความแสดงข้อผิดพลาดเพิ่มเติมและ enum สำหรับข้อผิดพลาด) หรือไม่?

22 java  api-design  exceptions  functions  architectural-patterns 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัพเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน4 ปีที่แล้ว การเขียนโปรแกรมที่ขับเคลื่อนด้วยเหตุการณ์แบบไม่บล็อกไม่ตรงกันดูเหมือนว่าจะเป็นความโกรธทั้งหมด ฉันมีความเข้าใจแนวคิดพื้นฐานเกี่ยวกับความหมายทั้งหมดนี้ อย่างไรก็ตามสิ่งที่ฉันไม่แน่ใจคือเมื่อใดและรหัสของฉันจะได้ประโยชน์จากการเป็นแบบอะซิงโครนัสหรือวิธีการบล็อก IO การไม่บล็อก ฉันแน่ใจว่าฉันสามารถใช้ห้องสมุดเพื่อทำสิ่งนี้ได้ แต่ฉันสนใจในแนวคิดเชิงลึกมากขึ้นและวิธีการต่าง ๆ ในการนำมันมาใช้เอง มีหนังสือที่ครอบคลุม / แตกหักหรือแหล่งข้อมูลอื่น ๆ ในเรื่องนี้ (เช่นGoFสำหรับรูปแบบการออกแบบหรือK&Rสำหรับ C, tldpสำหรับสิ่งต่าง ๆ เช่นทุบตี) (หมายเหตุ: ฉันไม่แน่ใจว่านี่เป็นคำถามที่ตรงกับคำถามของฉันในการเขียนโปรแกรมที่ขับเคลื่อนด้วยเหตุการณ์การเรียนรู้หรือไม่ )

21 design-patterns  learning  books  architectural-patterns  asynchronous-programming 

เป็นสถาปัตยกรรมระบบตัวแทน Entityเชิงวัตถุโดยความหมาย? ดูเหมือนว่าฉันหรือขั้นตอนการทำงานมากขึ้น ความคิดเห็นของฉันคือมันไม่ได้ป้องกันคุณจากการใช้งานในภาษา OO แต่มันจะไม่เป็นเรื่องแปลกที่จะทำเช่นนั้นในทาง OO อย่างแข็งขัน ดูเหมือนว่า ECS จะแยกข้อมูล (E & C) ออกจากพฤติกรรม (S) เป็นหลักฐาน : แนวคิดคือไม่มีวิธีการฝังเกมในเอนทิตี และ : ส่วนประกอบประกอบด้วยชุดข้อมูลขั้นต่ำที่จำเป็นสำหรับวัตถุประสงค์เฉพาะ ระบบคือฟังก์ชั่นวัตถุประสงค์เดียวที่ใช้ชุดของเอนทิตีที่มีองค์ประกอบเฉพาะ ฉันคิดว่านี่ไม่ใช่เชิงวัตถุเพราะส่วนใหญ่ของการมุ่งเน้นวัตถุคือการรวมข้อมูลและพฤติกรรมของคุณเข้าด้วยกัน เป็นหลักฐาน : ในทางตรงกันข้ามวิธีการเชิงวัตถุสนับสนุนให้โปรแกรมเมอร์วางข้อมูลที่ไม่สามารถเข้าถึงได้โดยตรงโดยส่วนที่เหลือของโปรแกรม แต่จะเข้าถึงข้อมูลได้โดยการเรียกฟังก์ชั่นที่เขียนขึ้นเป็นพิเศษโดยทั่วไปเรียกว่าเมธอดซึ่งรวมอยู่ในข้อมูล ในทางกลับกัน ECS ดูเหมือนจะเป็นเรื่องเกี่ยวกับการแยกข้อมูลของคุณออกจากพฤติกรรมของคุณ

20 design-patterns  object-oriented  functional-programming  architectural-patterns  entity-component-system 

ฉันได้ดู CQRS / MediatR เมื่อเร็ว ๆ นี้ แต่ยิ่งฉันเจาะลึกยิ่งฉันชอบมากเท่าไร บางทีฉันอาจเข้าใจผิดบางอย่าง / ทุกอย่าง ดังนั้นมันจึงยอดเยี่ยมโดยอ้างว่าลดคอนโทรลเลอร์ของคุณลงไป public async Task<ActionResult> Edit(Edit.Query query) { var model = await _mediator.SendAsync(query); return View(model); } ซึ่งเข้ากันได้อย่างสมบูรณ์แบบกับชุดควบคุมแบบบาง อย่างไรก็ตามจะมีรายละเอียดที่สำคัญออกไปบ้าง ให้ดูที่การLoginกระทำเริ่มต้นจากโครงการ MVC ใหม่ public async Task<IActionResult> Login(LoginViewModel model, string returnUrl = null) { ViewData["ReturnUrl"] = returnUrl; if (ModelState.IsValid) { // This doesn't …

17 c#  asp.net  architectural-patterns 

ชื่อกล่าวว่า "การพึ่งพาหนังสือเวียน" แต่มันไม่ได้เป็นถ้อยคำที่ถูกต้องเพราะสำหรับฉันการออกแบบดูเหมือนจะแข็ง อย่างไรก็ตามให้พิจารณาสถานการณ์ต่อไปนี้ซึ่งชิ้นส่วนสีน้ำเงินได้รับจากคู่ค้าภายนอกและสีส้มคือการนำไปปฏิบัติของฉันเอง นอกจากนี้สมมติว่ามีมากกว่าหนึ่งConcreteMainแต่ฉันต้องการใช้เฉพาะ (ในความเป็นจริงแต่ละชั้นมีการพึ่งพาอาศัยกันมากกว่านี้ แต่ฉันพยายามทำให้มันง่ายขึ้นที่นี่) ฉันต้องการเริ่มต้นทั้งหมดนี้ด้วย Depency Injection (Unity) แต่เห็นได้ชัดว่าฉันได้รับStackOverflowExceptionรหัสต่อไปนี้เนื่องจาก Runner พยายามยกตัวอย่าง ConcreteMain และ ConcreteMain ต้องการนักวิ่ง IUnityContainer ioc = new UnityContainer(); ioc.RegisterType<IMain, ConcreteMain>() .RegisterType<IMainCallback, Runner>(); var runner = ioc.Resolve<Runner>(); ฉันจะหลีกเลี่ยงสิ่งนี้ได้อย่างไร มีวิธีการสร้างโครงสร้างนี้เพื่อให้ฉันสามารถใช้กับ DI? สถานการณ์ที่ฉันทำอยู่ในขณะนี้คือการตั้งค่าทุกอย่างด้วยตนเอง แต่นั่นทำให้การพึ่งพาอย่างหนักConcreteMainในชั้นเรียนที่ทำให้อินสแตนซ์มัน นี่คือสิ่งที่ฉันพยายามหลีกเลี่ยง (ด้วยการลงทะเบียน Unity ในการกำหนดค่า) รหัสแหล่งที่มาทั้งหมดด้านล่าง (ตัวอย่างง่ายมาก!); public class Program { public static void Main(string[] …

15 architecture  dependency-injection  architectural-patterns 

ฉันเป็น coder สามเณร - ish ที่เรียนรู้ด้วยตนเองดังนั้นฉันต้องขออภัยถ้าฉันไม่ตอกโปรแกรมภาษา ฉันกำลังทำงานในโครงการที่ฉันให้ข้อมูลซึ่งจะได้รับการปรับปรุงอย่างต่อเนื่องสำหรับนักพัฒนาที่จะสร้างเครื่องมือเพื่อสร้างรายงานจากแบบสอบถามบนข้อมูล ดูเหมือนว่าทุกคนที่เกี่ยวข้องคิดว่าพวกเขาต้องการค่าข้อมูลรหัสฮาร์ดโค้ด (ไม่ใช่สกีมา แต่เป็นโดเมน / ค่าตัวเอง) ในโปรแกรมสร้างรายงาน ตัวอย่างเช่นสมมติว่าเรากำลังรายงานเกี่ยวกับบุคลากร รายงานจะถูกแบ่งออกเป็นหมวดหมู่โดยมีหัวข้อสำหรับแต่ละแผนกและจากนั้นภายใต้หัวข้อแต่ละแผนกจะเป็นหัวเรื่องย่อยของตำแหน่งงานและจากนั้นหัวข้อย่อยแต่ละหัวข้อจะเป็นรายการของพนักงาน นักพัฒนาต้องการเขียนโค้ดของแผนกและตำแหน่งงานอย่างหนัก ในทางกลับกันฉันคิดว่าพวกเขาสามารถ / จะค้นหาสิ่งเหล่านั้นที่รันไทม์เรียงลำดับระเบียนโดยพวกเขาและสร้างส่วนหัวรายงานแบบไดนามิกโดยยึดตามค่าที่มี เนื่องจากรายการของค่าที่อาจเกิดขึ้นจะมีการเปลี่ยนแปลงเมื่อเวลาผ่านไป (เช่นแผนกจะถูกสร้าง / เปลี่ยนชื่อตำแหน่งงานใหม่จะถูกเพิ่ม) รหัสจะต้องมีการปรับปรุงอย่างต่อเนื่อง สำหรับฉันดูเหมือนว่าเราสามารถข้ามขั้นตอนการบำรุงรักษารหัสและจัดระเบียบรายงานแบบไดนามิก เนื่องจากฉันไม่ใช่นักพัฒนาฉันจึงสงสัยว่าฉันทำอะไรหายไป มีข้อได้เปรียบอะไรบ้างในการเข้ารหัสค่าลงในเครื่องมือเช่นนี้ นี่เป็นวิธีการออกแบบโปรแกรมหรือไม่?

13 design  architecture  architectural-patterns  dynamic-data 

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

11 architectural-patterns 

พิจารณาสองคลาสDogและCatทั้งสองสอดคล้องกับAnimalโปรโตคอล (ในแง่ของภาษาการเขียนโปรแกรม Swift นั่นคืออินเทอร์เฟซใน Java / C #) เรามีหน้าจอที่แสดงรายการสุนัขและแมวที่หลากหลาย มีInteractorคลาสที่จัดการตรรกะเบื้องหลัง ตอนนี้เราต้องการที่จะนำเสนอการแจ้งเตือนการยืนยันให้กับผู้ใช้เมื่อเขาต้องการที่จะลบแมว อย่างไรก็ตามสุนัขจะต้องถูกลบทันทีโดยไม่มีการแจ้งเตือนใด ๆ วิธีที่มีเงื่อนไขจะมีลักษณะเช่นนี้: func tryToDeleteModel(model: Animal) { if let model = model as? Cat { tellSceneToShowConfirmationAlert() } else if let model = model as? Dog { deleteModel(model: model) } } รหัสนี้จะถูก refactored ได้อย่างไร? เห็นได้ชัดว่ามันมีกลิ่น

10 architecture  refactoring  software  architectural-patterns  polymorphism 

ดังนั้นฉันจึงมีโรงงานที่สร้างวัตถุของคลาสที่แตกต่างกัน คลาสที่เป็นไปได้ทั้งหมดมาจากบรรพบุรุษที่เป็นนามธรรม โรงงานมีไฟล์กำหนดค่า (ไวยากรณ์ JSON) และตัดสินใจว่าจะสร้างคลาสใดขึ้นอยู่กับการกำหนดค่าของผู้ใช้ เพื่อให้บรรลุสิ่งนี้โรงงานใช้ boost :: property_tree สำหรับ JSON-parsing เขาเดินผ่านต้นไม้ต้นทรีและตัดสินใจเลือกวัตถุที่เป็นรูปธรรมเพื่อสร้าง อย่างไรก็ตามผลิตภัณฑ์วัตถุมีหลายฟิลด์ (คุณลักษณะ) วัตถุมีคุณสมบัติประมาณ 5-10 ตัวในอนาคตอาจมีมากกว่านี้ขึ้นอยู่กับคลาสที่เป็นรูปธรรม ดังนั้นฉันไม่แน่ใจว่าตัวสร้างของวัตถุควรมีลักษณะอย่างไร ฉันสามารถคิดถึงวิธีแก้ปัญหาสองข้อ: 1) ตัวสร้างของผลิตภัณฑ์คาดว่าทุกแอตทริบิวต์เป็นพารามิเตอร์ดังนั้นตัวสร้างจะลงท้ายด้วยพารามิเตอร์ 10+ สิ่งนี้จะน่าเกลียดและนำไปสู่บรรทัดโค้ดที่ยาวและอ่านไม่ได้ อย่างไรก็ตามข้อดีคือโรงงานสามารถแยกวิเคราะห์ JSON และเรียกใช้ตัวสร้างด้วยพารามิเตอร์ที่ถูกต้อง คลาสผลิตภัณฑ์ไม่จำเป็นต้องรู้ว่าถูกสร้างขึ้นเนื่องจากการกำหนดค่า JSON ไม่จำเป็นต้องรู้ว่ามี JSON หรือการกำหนดค่าที่เกี่ยวข้องเลย 2) คอนสตรัคเตอร์ของผลิตภัณฑ์คาดว่าจะมีอาร์กิวเมนต์เดียวคือออบเจ็กต์ property_tree จากนั้นมันก็สามารถแยกวิเคราะห์ข้อมูลที่จำเป็น หากข้อมูลในการกำหนดค่าขาดหายไปหรือไม่อยู่ในขอบเขตของแต่ละคลาสผลิตภัณฑ์สามารถตอบสนองได้อย่างถูกต้อง โรงงานไม่จำเป็นต้องทราบว่าผลิตภัณฑ์หลายตัวต้องการข้อโต้แย้งใด โรงงานยังไม่จำเป็นต้องรู้วิธีการตอบสนองในกรณีที่มีการกำหนดค่าผิดพลาด และอินเทอร์เฟซตัวสร้างเป็นปึกแผ่นและเล็ก แต่ในฐานะที่เป็นข้อเสียผลิตภัณฑ์จำเป็นต้องดึงข้อมูลที่ต้องการจาก JSON ดังนั้นจึงรู้ได้ว่ามันถูกสร้างขึ้นอย่างไร ฉันมักจะชอบโซลูชัน 2) อย่างไรก็ตามฉันไม่แน่ใจว่านี่เป็นรูปแบบโรงงานที่ดีหรือไม่ รู้สึกผิดอย่างใดอย่างหนึ่งที่ทำให้ผลิตภัณฑ์ทราบว่าสร้างขึ้นด้วยการกำหนดค่า JSON ในอีกด้านหนึ่งผลิตภัณฑ์ใหม่สามารถแนะนำง่ายมาก ความคิดเห็นใด …

10 design-patterns  object-oriented  c++  architectural-patterns  factory-method 

ฉันกำลังมองหารูปแบบหรือคำแนะนำทางสถาปัตยกรรมสำหรับคุณสมบัติที่กำลังจะมาถึงฉันกำลังออกแบบ โดยพื้นฐานแล้วมันเป็นคุณสมบัติการส่งออกที่มีเป้าหมายการส่งออกหลายรายการและฉันกำลังมองหาวิธีที่จะทำให้เป็นเรื่องง่ายพอที่การเสียบเป้าหมายการส่งออกใหม่ไม่ต้องการการเปลี่ยนแปลงหลักมากมาย ตามเป้าหมายการส่งออกฉันเพียงแค่อ้างถึงประเภทต่างๆของการส่งออกไม่ว่าจะเป็น PDF, งานนำเสนอ PowerPoint, เอกสาร Word, RSS, ฯลฯ ฉันมีชุดฐานของข้อมูลซึ่งแสดงใน JSON และ XML ข้อมูลนี้ใช้ในการสร้างภาพ (โดยใช้หมายเลขหรือประเภทการส่งออกใด ๆ [เช่น PNG, JPG, GIF, ฯลฯ ), กราฟ, การแสดงข้อความ, ตารางและอื่น ๆ ฉันพยายามหาวิธีทำให้นามธรรมการเรนเดอร์และเลย์เอาต์ลงในการเรนเดอร์หรือเอ็นจิ้นเลย์เอาต์ที่รองรับการเพิ่มเป้าหมายการส่งออกเพิ่มเติม ความช่วยเหลือ / คำแนะนำ / แหล่งข้อมูลเกี่ยวกับวิธีการเข้าถึงสิ่งนี้จะได้รับการชื่นชมอย่างมาก ขอบคุณล่วงหน้า. สำหรับการแสดงรูปภาพของสิ่งที่ฉันพยายามทำ

10 patterns-and-practices  architectural-patterns 

ขณะนี้เรามีแอปพลิเคชันระดับ n คลาสสิก: DB / บริการเว็บ / ส่วนหน้า มันมีส่วนประกอบอื่น ๆ แต่มันเป็นเค้าโครงพื้นฐาน เราต้องการปรับปรุงความพร้อมใช้งานของแอปพลิเคชันด้วยเหตุผลหลัก 3 ข้อ: โฮสต์ของเราบางครั้งประสบปัญหาขัดข้อง (ตามที่พวกเขาทำทั้งหมด) และเราต้องการลดผลกระทบต่อลูกค้าของเราดังนั้นตัวอย่างเช่นพวกเขาจะเปิดดาต้าเซ็นเตอร์ B หากดาต้าเซ็นเตอร์ A หยุดทำงาน เมื่อเราอัปเกรดเวอร์ชันเราจะปิดเว็บไซต์เพื่อการบำรุงรักษาและโดยปกติจะใช้เวลาสองสามชั่วโมง (สคริปต์การย้ายข้อมูล ฯลฯ ) เราต้องการให้ผู้ใช้มีช่วงการเปลี่ยนภาพที่ราบรื่นยิ่งขึ้นโดยมีเวลาหยุดทำงานน้อยที่สุดเท่าที่จะเป็นไปได้ (พวกเขาใช้เซิร์ฟเวอร์ B ในขณะที่กำลังอัปเกรดเซิร์ฟเวอร์ A) Optionnaly ลูกค้าของเราตั้งอยู่ทั่วโลกและเราต้องการให้พวกเขามีประสบการณ์ที่ดีที่สุดเท่าที่จะเป็นไปได้แม้จะมีการเชื่อมต่อเส็งเคร็ง (ใครก็ตามที่ทำงานกับผู้พัฒนาอินเดียควรรู้ว่าฉันหมายถึงอะไร) ตามหลักการแล้วเราต้องการเชื่อมต่อเซิร์ฟเวอร์ในสำนักงานของพวกเขา (หรือใช้ดาต้าเซ็นเตอร์ใกล้เมือง) และมันจะรวมเข้ากับสถาปัตยกรรมของเราได้อย่างราบรื่น เราไม่ต้องการความพร้อมใช้งานจากระยะไกล 99% หรือแม้แต่ 95% มันเป็นแอพจัดการเอกสาร ไม่มีใครสนใจ. แต่เนื่องจากการย้ายข้อมูลอาจใช้เวลาสักครู่และมีลูกค้าทั่วโลกบางครั้งเราป้องกันไม่ให้ลูกค้าทำงานเกือบตลอดทั้งวัน สำหรับส่วนของ SQL แม้ว่าจะไม่มี DBA ที่ "ถูกต้อง" แต่เรารู้เกี่ยวกับความเป็นไปได้ของ …

10 architecture  architectural-patterns