คำถามติดแท็ก architecture

ฉันพัฒนาแอพพลิเคชั่นซึ่งจะรองรับผู้ใช้หลายคน สิ่งที่ฉันไม่สามารถคิดออกวิธีการตรวจสอบลูกค้า / ผู้ใช้ ฉันกำลังสร้างแอพอย่างhttp://quickblox.com/ที่ฉันจะให้ข้อมูลประจำตัวแก่ผู้ใช้ของฉันและพวกเขาจะใช้แอปเหล่านี้เพื่อสร้างแอปพลิเคชั่นNที่พวกเขาไม่สามารถใส่ชื่อผู้ใช้และรหัสผ่านเพื่อรับรองความถูกต้อง สมมติว่ามันเป็นไปตาม(เหมือน QuickBlox) 1. ผู้ใช้สร้างบัญชีในเว็บไซต์ของฉัน 2. ผู้ใช้สามารถสร้างคีย์ N API และข้อมูลรับรองความลับ (สำหรับหลายแอพ) 3. ผู้ใช้จะใช้ข้อมูลรับรองเหล่านี้ในแอปพลิเคชัน (Android, iOS, Javascript ฯลฯ ... ) เพื่อพูดคุยกับ REST API ของฉัน (REST API มีการเข้าถึงแบบอ่านและเขียน) ความกังวลของฉัน? ผู้ใช้จะใส่ข้อมูลประจำตัว (คีย์ API และคีย์หลั่ง) ในแอปพลิเคชันที่พวกเขาสร้างจะเกิดอะไรขึ้นถ้ามีคนรับคีย์เหล่านี้และพยายามเลียนแบบผู้ใช้ (โดยการแยกข้อมูล APK หรือดูโค้ด JavaScript โดยตรง ฉันผิดตรงไหนเหรอ? ฉันสับสนในการออกแบบกลไกผู้ใช้สามระดับนี้

14 design-patterns  architecture  api-design  authentication  enterprise-architecture 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน4 ปีที่แล้ว ฉันทำงานให้กับ บริษัท ขนาดกลางที่มีนักพัฒนาประมาณ 250 คน น่าเสียดายที่หลายคนติดอยู่ในกระบวนการคิดและบางทีมส่งมอบแอปพลิเคชันสคริปต์ธุรกรรมขนาดใหญ่อย่างต่อเนื่องซึ่งในความเป็นจริงแล้วแอปพลิเคชันมีตรรกะมากมาย พวกเขายังไม่สามารถจัดการการพึ่งพาการออกแบบและจบลงด้วยบริการที่ขึ้นอยู่กับบริการจำนวนมากอีกตัวอย่าง (ตัวอย่างที่ชัดเจนของBig Ball of Mud ) คำถามของฉันคือคุณสามารถแนะนำวิธีกระจายความรู้ประเภทนี้ได้อย่างไร ฉันรู้ว่าพื้นผิวของปัญหาคือแอปพลิเคชันเหล่านี้มีสถาปัตยกรรมและการออกแบบที่ไม่ดี อีกปัญหาคือมีนักพัฒนาบางคนที่ต่อต้านการเขียนการทดสอบใด ๆ บางสิ่งที่ฉันทำเพื่อเปลี่ยนแปลงสิ่งนี้ (แต่ฉันล้มเหลวหรือการเปลี่ยนแปลงเล็กเกินไป) ใช้งานนำเสนอเกี่ยวกับหลักการออกแบบ (SOLID, clean code, ฯลฯ ) การประชุมเชิงปฏิบัติการเกี่ยวกับ TDD และ BDD ทีมการฝึกสอน (ซึ่งรวมถึงการใช้โซนาร์, findbugs, jdepend และเครื่องมืออื่น ๆ ) การพูดถึง IDE & Refactoring …

14 design  learning  object-oriented  architecture 

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

14 architecture  coding-standards  readability  method-chaining 

ในปีที่ผ่านมาฉันสร้างระบบใหม่โดยใช้ Dependency Injection และ IOC container เรื่องนี้สอนฉันมากมายเกี่ยวกับ DI! อย่างไรก็ตามหลังจากเรียนรู้แนวคิดและรูปแบบที่เหมาะสมแล้วฉันคิดว่ามันเป็นความท้าทายในการแยกรหัสและแนะนำคอนเทนเนอร์ IOC ในแอปพลิเคชันรุ่นเก่า แอปพลิเคชันมีขนาดใหญ่พอที่จะนำไปใช้จริง แม้ว่าค่าจะเข้าใจและเวลาที่ได้รับ ใครให้เวลากับอะไรแบบนี้ ?? เป้าหมายของหลักสูตรคือการนำการทดสอบหน่วยมาใช้ในตรรกะทางธุรกิจ! ตรรกะทางธุรกิจที่เกี่ยวพันกับการเรียกการป้องกันฐานข้อมูลการทดสอบ ผมเคยอ่านบทความและผมเข้าใจอันตรายของคนจนพึ่งพาการฉีดตามที่อธิบายไว้ในบทความ Los Techies นี้ ผมเข้าใจว่ามันไม่ได้อย่างแท้จริง decouple อะไร ฉันเข้าใจว่าสามารถมีส่วนร่วมในการปรับโครงสร้างระบบได้มากเนื่องจากการติดตั้งใช้งานต้องอาศัยการพึ่งพาใหม่ ฉันจะไม่พิจารณาใช้กับโปรเจ็กต์ใหม่ที่มีขนาดเท่าใดก็ได้ คำถาม:การใช้ DI ของ Poor Man เพื่อแนะนำการทดสอบกับแอปพลิเคชั่นรุ่นเก่าและเริ่มต้นการหมุนลูกบอลได้หรือไม่? นอกจากนี้การใช้ Poor Man's DI เป็นวิธีรากหญ้าในการฉีด Dependency ที่แท้จริงเป็นวิธีที่มีคุณค่าในการให้ความรู้เกี่ยวกับความต้องการและประโยชน์ของหลักการหรือไม่ คุณสามารถ refactor วิธีการที่มีการอ้างอิงการโทรฐานข้อมูลและนามธรรมที่โทรไปด้านหลังส่วนติดต่อ? เพียงแค่มีสิ่งที่เป็นนามธรรมจะทำให้วิธีการนั้นสามารถทดสอบได้เนื่องจากการใช้งานจำลองอาจถูกส่งผ่านทางตัวสร้างเกินพิกัด เมื่อถึงความพยายามที่ได้รับการสนับสนุนโครงการสามารถปรับปรุงเพื่อใช้คอนเทนเนอร์ IOC และผู้สร้างจะออกไปที่นั่นในนามธรรม

14 architecture  dependency-injection  legacy  inversion-of-control 

สมมติว่าเรามีระบบบันทึกงานเมื่อมีการบันทึกงานผู้ใช้จะระบุหมวดหมู่และค่าเริ่มต้นของงานเป็นสถานะ 'ดีเด่น' สมมติในกรณีนี้ว่าหมวดหมู่และสถานะจะต้องมีการใช้งานเป็นเอนทิตี ปกติฉันจะทำสิ่งนี้: แอพลิเคชันเลเยอร์: public class TaskService { //... public void Add(Guid categoryId, string description) { var category = _categoryRepository.GetById(categoryId); var status = _statusRepository.GetById(Constants.Status.OutstandingId); var task = Task.Create(category, status, description); _taskRepository.Save(task); } } Entity: public class Task { //... public static void Create(Category category, Status status, string description) { …

14 architecture  domain-driven-design  repository  domain-model  entity 

ปิด. คำถามนี้เป็นคำถามปิดหัวข้อ ไม่ยอมรับคำตอบในขณะนี้ ต้องการปรับปรุงคำถามนี้หรือไม่ อัปเดตคำถามเพื่อให้เป็นหัวข้อสำหรับ Software Engineering Stack Exchange ปิดให้บริการใน5 ปีที่ผ่านมา ฉันต้องการทราบว่า Java Certifications (SCJP, SCWCD และอื่น ๆ ) มีความสำคัญต่อตำแหน่งสถาปนิกเพียงใด หากบุคคลมีประสบการณ์ที่ดีในการพัฒนา Java และต้องการไล่ตามอาชีพของเขาในระดับสถาปนิกพวกคุณคิดว่าเขาต้องได้รับการรับรองประวัติส่วนตัวของเขาหรือไม่ หากเขาไม่เคยทำงานในบทบาทผู้พัฒนานำ? หากคุณสัมภาษณ์ตำแหน่งสถาปนิก และฉันได้ทำงานเป็นผู้พัฒนาเว็บ Java ในทีมต่างๆที่มีประสบการณ์ 5 ปี อย่าเป็นผู้นำเลย และฉันมีป้ายรับรองบน ​​CV ของฉัน นักพัฒนาจะทำให้เส้นทางอาชีพของเขาไปสู่การเป็นสถาปนิกในทีมได้อย่างไร

14 java  architecture 

ฉันกำลังสร้างแอปพลิเคชัน WPF โดยใช้รูปแบบ MVVM ในตอนนี้ viewmodels ของฉันเรียกเลเยอร์บริการเพื่อเรียกคืนโมเดล (ความเกี่ยวข้องกับ viewmodel) และแปลงเป็น viewmodels ฉันใช้ตัวสร้างการฉีดเพื่อส่งผ่านบริการที่จำเป็นสำหรับโมเดลวิวเวอร์ มันทดสอบได้ง่ายและทำงานได้ดีสำหรับ viewmodels ที่มีการพึ่งพาน้อย แต่ทันทีที่ฉันพยายามสร้าง viewModels สำหรับรุ่นที่ซับซ้อนฉันมี Constructor ที่มีบริการมากมายแทรกอยู่ (หนึ่งเพื่อดึงการอ้างอิงแต่ละรายการและรายการค่าที่มีทั้งหมด เพื่อผูกกับ itemsSource เป็นต้น) ฉันสงสัยว่าจะจัดการกับบริการหลายอย่างเช่นนั้นได้อย่างไรและยังมีวิวเวอร์โมเดลที่ฉันสามารถทดสอบหน่วยได้อย่างง่ายดาย ฉันกำลังคิดถึงวิธีแก้ปัญหาบางอย่าง: การสร้างบริการแบบซิงเกิล (IServices) ที่มีบริการทั้งหมดที่มีอยู่เป็นส่วนต่อประสาน ตัวอย่าง: Services.Current.XXXService.Retrieve (), Services.Current.YYYService.Retrieve () ด้วยวิธีนี้ฉันไม่มีคอนสตรัคเตอร์ขนาดใหญ่ที่มีพารามิเตอร์บริการจำนวนมากในตัวพวกเขา การสร้างส่วนหน้าสำหรับบริการที่ใช้โดย viewModel และส่งผ่านออบเจ็กต์นี้ใน ctor ของ viewmodel ของฉัน แต่แล้วฉันจะต้องสร้างซุ้มสำหรับแต่ละมุมมองเชิงซ้อนของฉันและมันอาจจะค่อนข้างมาก ... คุณคิดว่าเป็นวิธีที่ "ถูกต้อง" ในการใช้งานสถาปัตยกรรมประเภทนี้?

14 architecture  dependency-injection  mvvm 

ฉันรู้ว่ามันเป็นคำถามกว้าง ๆ ดังนั้นฉันจะพยายามเจาะจงให้มากที่สุดเท่าที่จะทำได้ คำถามนี้เป็นคำถาม "องค์กร" มากกว่าคำถามทางเทคนิค เรามีโครงการหลายด้านที่มีองค์ประกอบหลักเหล่านี้: เซิร์ฟเวอร์ที่โฮสต์ตรรกะทางธุรกิจหลัก (ตัวแบบข้อมูล) BackOffice สำหรับลูกค้าที่ใช้ตรรกะทางธุรกิจหลัก แอปพลิเคชัน API (REST) ​​ซึ่งใช้ตรรกะทางธุรกิจหลักเช่นกัน มีแอพสมาร์ทโฟน (iOS และ Android) โดยใช้แอปพลิเคชัน API มีแอปแท็บเล็ตอีกแอนดรอยด์ที่แตกต่างจากสมาร์ทโฟนที่ใช้แอปพลิเคชัน API เดียวกัน เร็ว ๆ นี้ฉันจะอยู่ในการผลิตกับลูกค้าที่ใช้งานอยู่ และเป็นโครงการใด ๆ ฉันจะต้องบำรุงรักษาส่วนประกอบต่าง ๆ ทั้งหมดในช่วงเวลา นั่นหมายความว่าสามารถอัปเกรดทั้งหมดต่อไปนี้: รหัสของตรรกะทางธุรกิจหลักในเซิร์ฟเวอร์ (ใช้โดย back-office, API และผลข้างเคียงจากแอปมือถือ) API เอง (ใช้ทั้งแอพสมาร์ทโฟนและแท็บเล็ต) แอพมือถือทั้งหมด (ผ่าน appstore / googleplay) แน่นอนส่วนฝั่งเซิร์ฟเวอร์ (รหัสตรรกะทางธุรกิจหลักและรหัส API) สามารถเปลี่ยนแปลงได้ทันทีด้วยตัวเอง …

14 design  architecture  project-management  deployment  release-management 

เรามีสถานการณ์ที่ฉันต้องรับมือกับเหตุการณ์ที่ไหลเข้ามาในเซิร์ฟเวอร์ของเราโดยเฉลี่ยประมาณ 1,000 เหตุการณ์ต่อวินาทีโดยเฉลี่ย ปัญหา ระบบของเราโฮสต์บนHerokuและใช้Heroku Postgres DBที่ค่อนข้างแพงซึ่งอนุญาตการเชื่อมต่อ DB ได้สูงสุด 500 เราใช้การเชื่อมต่อร่วมกันเพื่อเชื่อมต่อจากเซิร์ฟเวอร์ไปยังฐานข้อมูล เหตุการณ์เข้ามาเร็วกว่าการเชื่อมต่อฐานข้อมูลที่สามารถจัดการได้ ปัญหาที่เรามีคือเหตุการณ์เกิดขึ้นเร็วกว่าพูลการเชื่อมต่อที่สามารถจัดการได้ เมื่อถึงเวลาที่การเชื่อมต่อหนึ่งเสร็จสิ้นการส่งสัญญาณเครือข่ายจากเซิร์ฟเวอร์ไปยังฐานข้อมูลดังนั้นจึงสามารถปล่อยกลับไปที่กลุ่มได้มากกว่าnมีเหตุการณ์เพิ่มเติมเข้ามา ในที่สุดเหตุการณ์ต่างๆก็หมดลงรอรับการบันทึกและเนื่องจากไม่มีการเชื่อมต่อที่พร้อมใช้งานในกลุ่มจึงหมดเวลาและระบบทั้งหมดไม่สามารถใช้งานได้ เราได้แก้ไขเหตุฉุกเฉินด้วยการปล่อยเหตุการณ์ความถี่สูงที่ก้าวร้าวช้าลงจากลูกค้า แต่เรายังต้องการทราบวิธีจัดการสถานการณ์นี้ในเหตุการณ์ที่เราต้องจัดการกับเหตุการณ์ความถี่สูงนั้น ข้อ จำกัด ลูกค้ารายอื่นอาจต้องการอ่านเหตุการณ์พร้อมกัน ไคลเอนต์อื่น ๆ ร้องขออย่างต่อเนื่องเพื่ออ่านเหตุการณ์ทั้งหมดที่มีคีย์เฉพาะแม้ว่าพวกเขาจะยังไม่ได้บันทึกในฐานข้อมูล ไคลเอนต์สามารถสอบถามGET api/v1/events?clientId=1และรับเหตุการณ์ทั้งหมดที่ส่งโดยไคลเอนต์ 1 แม้ว่าเหตุการณ์เหล่านั้นจะยังไม่ได้ทำการบันทึกในฐานข้อมูล มีตัวอย่าง "ห้องเรียน" เกี่ยวกับวิธีจัดการกับเรื่องนี้หรือไม่? การแก้ปัญหาที่เป็นไปได้ จัดคิวเหตุการณ์บนเซิร์ฟเวอร์ของเรา เราสามารถจัดคิวเหตุการณ์บนเซิร์ฟเวอร์ (ด้วยคิวที่มีการเกิดพร้อมกันสูงสุด 400 เพื่อให้กลุ่มการเชื่อมต่อไม่หมด) นี่เป็นความคิดที่ไม่ดีเพราะ: มันจะกินหน่วยความจำเซิร์ฟเวอร์ที่มีอยู่ เหตุการณ์ที่จัดคิวเข้าด้วยกันจะใช้ RAM จำนวนมาก เซิร์ฟเวอร์ของเราเริ่มต้นใหม่ครั้งเดียวทุก 24 ชั่วโมง นี่เป็นข้อ จำกัด อย่างหนักจาก Heroku เซิร์ฟเวอร์สามารถรีสตาร์ทในขณะที่เหตุการณ์ถูกจัดคิวทำให้เราสูญเสียเหตุการณ์ที่จัดคิว มันแนะนำสถานะบนเซิร์ฟเวอร์จึงทำร้ายความยืดหยุ่น …

13 architecture  performance  scalability  event-sourcing 

คำถามคืออธิบายตนเองเพียงเพื่อเพิ่มความคิดของฉัน: เท่าที่ฉันได้อ่านเลเยอร์การนำเสนอใน Clean arch มีความรับผิดชอบเช่นเดียวกับใน MV ใน MVP วิธีหนึ่งตัดสินใจเลือกรูปแบบหนึ่งแทนแบบอื่น

13 architecture  mvp 

เริ่มจากตัวอย่างกันก่อน สมมติว่าฉันมีวิธีที่เรียกexportว่าขึ้นอยู่กับ schema DB อย่างมาก และโดย“ พึ่งพาหนัก” ฉันหมายถึงฉันรู้ว่าการเพิ่มคอลัมน์ใหม่ในตารางหนึ่งบ่อยครั้ง (บ่อยครั้งมาก) จะนำไปสู่exportการเปลี่ยนแปลงวิธีการที่สอดคล้องกัน(โดยปกติแล้วคุณควรเพิ่มเขตข้อมูลใหม่ลงในข้อมูลการส่งออกด้วย) โปรแกรมเมอร์มักจะลืมที่จะเปลี่ยนexportวิธีการเพราะมันไม่ชัดเจนจริงๆคุณควรดูที่นี้ เป้าหมายของฉันคือการบังคับให้โปรแกรมเมอร์ตัดสินใจอย่างชัดเจนเพื่อตัดสินว่าเขาลืมดูexportวิธีการหรือไม่ต้องการเพิ่มเขตข้อมูลลงในข้อมูลการส่งออก และฉันกำลังมองหาโซลูชันการออกแบบสำหรับปัญหานี้ ฉันมีสองแนวคิด แต่ทั้งคู่มีข้อบกพร่อง เสื้อคลุม "อ่านทั้งหมด" สมาร์ท ฉันสามารถสร้าง wrapper อัจฉริยะที่ทำให้แน่ใจว่าข้อมูลทั้งหมดอ่านอย่างชัดเจน บางสิ่งเช่นนี้ def export(): checker = AllReadChecker.new(table_row) name = checker.get('name') surname = checker.get('surname') checker.ignore('age') # explicitly ignore the "age" field result = [name, surname] # or whatever checker.check_now() # check …

13 design  design-patterns  architecture  unit-testing 

ฉันมีส่วนหนึ่งของรูปแบบ CQRS ที่นำมาใช้โดยใช้สถาปัตยกรรม S # arpดังนี้: public class MyCommand { public CustomerId { get; set; } // some other fields } public class MyCommandHandler<MyCommand> : ICommandHandler<MyCommand, CommandResult> { Handle(MyCommand command) { // some code for saving Customer entity return CommandResult.Success; } } ฉันสงสัยว่าทำไมไม่เพียงแค่มีคลาสCommandที่มีทั้งข้อมูลและวิธีการจัดการ? มันเป็นข้อดีของการทดสอบที่คุณต้องทดสอบตรรกะการจัดการคำสั่งแยกต่างหากจากคุณสมบัติคำสั่งหรือไม่? หรือมันเป็นบางอย่างที่ต้องการทางธุรกิจบ่อยครั้งที่คุณจำเป็นต้องมีคำสั่งอย่างใดอย่างหนึ่งจัดการโดยการใช้งานที่แตกต่างกันของICommandHandler<MyCommand, CommandResult>?

13 c#  design-patterns  architecture  cqrs 

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

13 architecture  coding-style  management  technical-debt 

คำถามนี้เกี่ยวกับหลักปฏิบัติที่ดีที่สุดในสถาปัตยกรรม สถาปัตยกรรมปัจจุบันของเรา ฉันมีคลาส PHP ที่เข้าถึง MySQL สำหรับข้อมูลผู้ใช้ Userขอเรียกว่า Userมีการเข้าถึงหลายครั้งดังนั้นเราจึงติดตั้งเลเยอร์ของแคชเพื่อลดภาระ เลเยอร์แรกคือสิ่งที่เราเรียกว่าแคช "ต่อคำขอ" หลังจากที่ข้อมูลได้รับการเรียกข้อมูลจาก MySQL, Userเราเก็บข้อมูลในทรัพย์สินส่วนตัวของ การร้องขอใด ๆ ที่ตามมาสำหรับข้อมูลจะส่งคืนคุณสมบัติแทนการร้องขอข้อมูลจาก MySQL อีกครั้ง เนื่องจากคำขอทางเว็บนั้นใช้งานและตายต่อการร้องขอแคชนี้จะป้องกันไม่ให้แอปพลิเคชันเข้าถึง MySQL มากกว่าหนึ่งครั้งในคำขอเดียว ชั้นที่สองของเราคือ Memcached เมื่อคุณสมบัติส่วนตัวว่างเปล่าก่อนอื่นเราตรวจสอบ Memcached สำหรับข้อมูล หาก Memcached ว่างเรา MySQL แบบสอบถามสำหรับข้อมูลที่ปรับปรุง memcached Userและปรับปรุงทรัพย์สินส่วนตัวของ คำถาม แอปพลิเคชันของเราเป็นเกมและบางครั้งจำเป็นที่ข้อมูลบางอย่างจะเป็นข้อมูลล่าสุด ในช่วงเวลาประมาณห้านาทีคำขอการอ่านสำหรับข้อมูลผู้ใช้อาจเกิดขึ้น 10 หรือ 11 ครั้ง; จากนั้นการอัปเดตอาจเกิดขึ้น คำขอการอ่านครั้งต่อไปจะต้องทันสมัยหรือกลไกของเกมล้มเหลว ดังนั้นสิ่งที่เราทำคือการใช้รหัสที่ดำเนินการเมื่อมีการอัพเดทฐานข้อมูล รหัสนี้ตั้งค่าคีย์ใน Memcached พร้อมข้อมูลที่อัปเดตดังนั้นการร้องขอต่อ Memcached ที่ตามมาทั้งหมดเป็นข้อมูลล่าสุด สิ่งนี้ดีที่สุดหรือไม่? …

13 architecture  caching  memcached 

ตอนนี้ฉันมีผลิตภัณฑ์หลายผู้เช่าบนเว็บที่ใหญ่และไม่นานฉันก็เห็นว่าจะมีการปรับแต่งมากมายที่เฉพาะเจาะจงของผู้เช่า เขตข้อมูลพิเศษที่นี่หรือที่นั่นอาจเป็นหน้าพิเศษหรือตรรกะเพิ่มเติมบางส่วนที่อยู่ตรงกลางของเวิร์กโฟลว์ - สิ่งนั้น การปรับแต่งเหล่านี้บางส่วนสามารถรีดเข้าสู่ผลิตภัณฑ์หลักและนั่นยอดเยี่ยม บางคนมีความเฉพาะเจาะจงสูงและจะเข้าไปในทางของคนอื่น ฉันมีความคิดเล็กน้อยในการจัดการสิ่งนี้ แต่ดูเหมือนว่าจะไม่มีใครที่จะปรับขนาดได้ โซลูชันที่ชัดเจนคือการแนะนำการตั้งค่าระดับไคลเอ็นต์มากมายทำให้สามารถเปิดใช้งาน 'คุณสมบัติ' ที่หลากหลายบนพื้นฐานต่อลูกค้า ข้อเสียของสิ่งนั้นคือความซับซ้อนและความยุ่งเหยิง คุณสามารถแนะนำการตั้งค่าจำนวนมากอย่างแท้จริงและเมื่อเวลาผ่านไปหลายประเภทของตรรกะ (งานนำเสนอ, ธุรกิจ) สามารถหลีกเลี่ยงได้ จากนั้นก็มีปัญหาเกี่ยวกับเขตข้อมูลเฉพาะของลูกค้าซึ่งต้องการสิ่งที่สะอาดกว่าเพียงเพิ่มเขตข้อมูลที่ไม่มีค่าลงในตารางที่มีอยู่ แล้วผู้คนกำลังทำอะไรเพื่อจัดการสิ่งนี้ ดูเหมือนว่า Force.com จะเป็นผู้เชี่ยวชาญด้านการเพิ่มความสามารถ เห็นได้ชัดว่าพวกเขาได้สร้างแพลตฟอร์มจากพื้นดินขึ้นมาซึ่งสามารถขยายได้อย่างมาก คุณสามารถเพิ่มเกือบทุกอย่างด้วย UI บนเว็บของพวกเขา FogBugz ทำสิ่งที่คล้ายกันซึ่งพวกเขาสร้างรูปแบบปลั๊กอินที่มีประสิทธิภาพซึ่งคิดว่าอาจได้รับแรงบันดาลใจจากแรงจริง ฉันรู้ว่าพวกเขาใช้เวลาและเงินจำนวนมากกับมันและถ้าฉันไม่เข้าใจผิดความตั้งใจที่จะใช้มันเพื่อการพัฒนาผลิตภัณฑ์ในอนาคต ฟังดูเหมือนเป็นสิ่งที่ฉันอยากจะสร้าง แต่อาจไม่ควร :) การลงทุนครั้งใหญ่ในสถาปัตยกรรมแบบเสียบปลั๊กเป็นหนทางเดียวที่จะไปได้หรือไม่? คุณจัดการกับปัญหาเหล่านี้อย่างไรและคุณเห็นผลลัพธ์แบบใด แก้ไข:ดูเหมือนว่า FogBugz จัดการปัญหาด้วยการสร้างแพลตฟอร์มที่แข็งแกร่งพอสมควรแล้วใช้สิ่งนั้นเพื่อรวบรวมหน้าจอของพวกเขา เมื่อต้องการขยายให้คุณสร้าง DLL ที่มีคลาสที่ใช้อินเทอร์เฟซเช่น ISearchScreenGridColumn และกลายเป็นโมดูล ฉันแน่ใจว่ามันแพงอย่างมากในการสร้างเนื่องจากพวกเขามี devs จำนวนมากและพวกเขาทำงานกันเป็นเวลาหลายเดือนบวกกับพื้นที่ผิวของพวกเขาอาจจะ 5% ของขนาดแอปพลิเคชันของฉัน ตอนนี้ฉันสงสัยอย่างจริงจังว่า Force.com เป็นวิธีที่เหมาะสมในการจัดการกับปัญหานี้หรือไม่ และฉันก็เป็นผู้ชายแกนแข็งของ …

13 asp.net  plugins  architecture