เกิดอะไรขึ้นถ้ากลมทำให้รู้สึก?

ฉันมีคุณค่าที่วัตถุจำนวนมากต้องการ ตัวอย่างเช่นแอปพลิเคชันทางการเงินที่มีการลงทุนต่าง ๆ เป็นวัตถุและส่วนใหญ่ต้องการอัตราดอกเบี้ยปัจจุบัน

ฉันหวังว่าจะห่อหุ้ม "สภาพแวดล้อมทางการเงิน" ของฉันเป็นวัตถุโดยมีอัตราดอกเบี้ยเป็นอสังหาริมทรัพย์ แต่วัตถุพี่น้องที่ต้องการค่านั้นจะไม่สามารถเข้าถึงได้

ดังนั้นฉันจะแบ่งปันค่าระหว่างวัตถุต่าง ๆ โดยไม่ต้องออกแบบของฉันมากเกินไป? เห็นได้ชัดว่าฉันกำลังคิดเกี่ยวกับความผิดนี้

ฉันมีคุณค่าที่วัตถุจำนวนมากต้องการ

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

ดังนั้นฉันจะแบ่งปันค่าระหว่างวัตถุต่าง ๆ โดยไม่ต้องออกแบบของฉันมากเกินไป?

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

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

ตัวอย่างเช่น:

• Service Layer (ไลบรารีคลาส) - สร้างออบเจกต์ FinancialEnvironment ผ่านทางซิงเกิล
• ชั้นตรรกะทางธุรกิจ (ไลบรารีคลาส) - ยอมรับวัตถุ FinancialEnvironment จากชั้นบริการ
• Data Access Layer (ไลบรารีคลาส) - ยอมรับวัตถุ FinancialEnvironment จาก service layer (หรือขึ้นอยู่กับสถาปัตยกรรมของคุณคือ Business Logic Layer) หรือบางที Singleton จะเรียกใช้ Data Access Layer เพื่อรับข้อมูลเช่นอัตราดอกเบี้ยจากพื้นที่เก็บข้อมูล (บริการฐานข้อมูล / เว็บ / บริการ WCF)
• เอนทิตี (หรือ DTOs ถ้าคุณต้องการเรียกมันว่า) ไลบรารีคลาส - ตำแหน่งที่ออบเจ็กต์ FinancialEnvironment อยู่ ไลบรารีคลาสอื่นทั้งหมดมีการอ้างอิงไปยังไลบรารีคลาสของเอนทิตี

คลาสอื่น ๆ จะถูกผูกเข้าด้วยกันผ่านไลบรารีคลาสเอนทิตีเท่านั้นพวกเขายอมรับวัตถุ FinancialEnvironment พวกเขาไม่สนใจว่ามันถูกสร้างขึ้นมาเพียงแค่ชั้นบริการเท่านั้นสิ่งที่พวกเขาต้องการคือข้อมูล ซิงเกิลอาจฉลาดพอที่จะเก็บวัตถุ FinancialEnvironment หลายรายการขึ้นอยู่กับกฎสำหรับโลคัลตามที่ @Telastyn ชี้ให้เห็น

ในหมายเหตุด้านข้างฉันไม่ได้เป็นแฟนตัวยงของรูปแบบซิงเกิลฉันคิดว่ามันเป็นกลิ่นรหัสเพราะสามารถนำไปใช้ในทางที่ผิดได้ง่ายมาก แต่ในบางกรณีคุณต้องการมัน

ปรับปรุง:

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

ถ้าฉันเป็นนักพนันฉันจะเดิมพันอัตราดอกเบี้ยถูกเก็บไว้ที่ใดที่หนึ่งในฐานข้อมูลหรือถูกดึงผ่านบริการเว็บ ในกรณีนั้นแนะนำให้ใช้ Repository (data access layer) เพื่อดึงข้อมูลนั้น เพื่อหลีกเลี่ยงการเดินทางไปยังฐานข้อมูลที่ไม่จำเป็น (ฉันไม่แน่ใจว่าความถี่อัตราการเปลี่ยนแปลงหรือข้อมูลอื่น ๆ ในชั้น FinancialInformation) สามารถใช้แคชได้ ในไลบรารี Caching Application Block ของ Microsoft ใน C # world ทำงานได้ดีมาก

สิ่งเดียวที่จะเปลี่ยนจากตัวอย่างข้างต้นจะเป็นคลาสต่าง ๆ ในบริการเลเยอร์ที่ต้องการ FinancialInformation จะดึงจาก Data Access Layer แทน Singleton instantiating วัตถุ

ไฟล์กำหนดค่า?

หากคุณมีค่าที่ใช้ "ทั่วโลก" โปรดใส่ไว้ในไฟล์กำหนดค่า จากนั้นแต่ละระบบและระบบย่อยสามารถอ้างอิงสิ่งนี้และดึงกุญแจที่จำเป็นทำให้เป็นแบบอ่านอย่างเดียว

ฉันพูดจากประสบการณ์ของคนที่มีประมาณหนึ่งเดือนของการบำรุงรักษาในโครงการขนาดดี (~ 50k LOC) ที่เราเพิ่งเปิดตัว

ฉันสามารถบอกคุณได้ว่าคุณอาจไม่ต้องการวัตถุระดับโลกจริงๆ แนะนำ cruft ประเภทที่ให้โอกาสมากมายสำหรับการละเมิดมากกว่าจะช่วย

ข้อเสนอแนะเบื้องต้นของฉันคือถ้าคุณมีหลายชั้นเรียนที่ต้องการอัตราดอกเบี้ยปัจจุบันคุณอาจต้องการให้พวกเขาใช้IInterestRateConsumerหรืออะไรบางอย่าง ภายในอินเทอร์เฟซนั้นคุณจะมีSetCurrentInterestRate(double rate)(หรืออะไรก็ตามที่สมเหตุสมผล) หรืออาจเป็นแค่คุณสมบัติ

การผ่านอัตราดอกเบี้ยรอบ ๆ นั้นไม่ใช่การมีเพศสัมพันธ์ - หากคลาสของคุณต้องการอัตราดอกเบี้ยนั่นเป็นส่วนหนึ่งของ API มันเป็นเพียงการมีเพศสัมพันธ์ถ้าหนึ่งในชั้นเรียนของคุณเริ่มกังวลเกี่ยวกับวิธีการที่ชนชั้นอื่นใช้อัตราดอกเบี้ยนั้น

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

แน่นอนคุณต้องชั่งน้ำหนักปัญหากับซิงเกิลตัน (แม้แต่ซิงเกิลแทน) กับความเจ็บปวดจากการส่งผ่านวัตถุเดียวกันทุกที่

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

ทำไมไม่ใส่ข้อมูลอัตราดอกเบี้ยลงในแคชกลาง

คุณสามารถใช้หนึ่งในหลาย ๆ แคชของแคชได้แล้วแต่ความต้องการของคุณที่ดีที่สุดเช่น memcached จะช่วยแก้ปัญหาการทำงานพร้อมกันและการจัดการโค้ดของคุณพร้อมกัน

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

ในสถานการณ์เช่นนี้ฉันได้แนะนำ (บริบท) คำว่า "บริบท" ที่มีบางเลเยอร์หลายครั้งสำเร็จแล้ว

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

ร้านค้าอาจเป็นได้ทั้ง:

• พิมพ์อย่างเคร่งครัด: คุณรวมส่วนหัวสำหรับประเภทที่ให้บริการทั้งหมดและเพื่อให้คุณสามารถสร้าง accessors ที่พิมพ์เช่น InterestRate getCurrentInterestRate ();
• or generic: Object getObject (enum obType); และขยาย obType enum ด้วยชนิดใหม่เท่านั้น (obtypeCurrentInterestRate)

ยิ่งระบบมีขนาดใหญ่เท่าใดยิ่งใช้ประโยชน์ได้มากขึ้นเท่านั้น แต่สำหรับความเสี่ยงในการใช้ enum ที่ไม่ถูกต้อง ในทางกลับกันด้วยภาษาที่อนุญาตการประกาศประเภทไปข้างหน้าฉันคิดว่าคุณสามารถใช้ accessors ที่พิมพ์โดยไม่ต้องรวมส่วนหัวทั้งหมดในร้าน

อีกหนึ่งหมายเหตุ: คุณอาจมีประเภทวัตถุเดียวกันหลายครั้งสำหรับการใช้งานที่แตกต่างกันเช่นบางครั้งค่าภาษาที่แตกต่างกันสำหรับ GUI และสำหรับการพิมพ์บันทึกระดับโลกและเซสชั่น ฯลฯ ดังนั้นชื่อ enum / accessor ไม่ควรสะท้อนถึงประเภทจริง แต่บทบาทของอินสแตนซ์ที่ร้องขอ (CurrentInterestRate)

ในการใช้งานร้านค้าคุณต้องจัดการระดับบริบทและการรวบรวมอินสแตนซ์บริบท ตัวอย่างง่ายๆคือเว็บเซอร์วิสที่คุณมีบริบทส่วนกลาง (หนึ่งอินสแตนซ์สำหรับคำขอทั้งหมดสำหรับวัตถุนั้น - เป็นปัญหาเมื่อมีเซิร์ฟเวอร์ฟาร์ม) และบริบทสำหรับแต่ละเซสชันของเว็บ คุณยังสามารถมีบริบทสำหรับผู้ใช้แต่ละคนที่อาจมีหลายเซสชันแบบขนาน ฯลฯ ด้วยเซิร์ฟเวอร์หลายเครื่องคุณควรใช้แคชแบบกระจายสำหรับสิ่งต่าง ๆ

เมื่อคำขอเข้ามาคุณจะต้องตัดสินใจว่าวัตถุที่ร้องขอนั้นอยู่ในระดับบริบทใดรับบริบทนั้นสำหรับการโทร หากวัตถุอยู่ที่นั่นคุณส่งมันกลับมา; ถ้าไม่คุณสร้างและเก็บในระดับบริบทนั้นและส่งคืน แน่นอนประสานส่วนการสร้าง (และเผยแพร่ไปยังแคชกระจาย) การสร้างสามารถกำหนดค่าปลั๊กอินเหมือนได้ดีที่สุดกับภาษาที่อนุญาตให้สร้างอินสแตนซ์ของวัตถุด้วยชื่อคลาส (Java, Objective C, ... ) แต่คุณสามารถทำได้ใน C เช่นกันกับไลบรารีแบบเสียบได้ที่มีฟังก์ชั่นจากโรงงาน

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

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

สำหรับกรณีของคุณนี่คือ overkill ชนิดหนึ่ง (มีเพียงวัตถุเดียวเท่านั้นที่ให้บริการในระดับโลก) แต่สำหรับรหัสพิเศษที่ค่อนข้างเล็กและเรียบง่ายในตอนนี้คุณจะได้รับกลไกสำหรับความต้องการเพิ่มเติมที่ซับซ้อนกว่านี้

ข่าวดีอีกอย่าง: ถ้าคุณอยู่ใน Java คุณจะได้รับบริการนี้จาก Spring โดยไม่ต้องคิดมากฉันอยากอธิบายรายละเอียด

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

• เพื่อคำนวณว่าจะเกิดอะไรขึ้นหากอัตราดอกเบี้ยแตกต่างกัน
• การมีส่วนประกอบบางอย่างขึ้นอยู่กับอัตราดอกเบี้ยของสหรัฐอเมริกาและส่วนประกอบบางอย่างขึ้นอยู่กับอัตราดอกเบี้ยของสหราชอาณาจักร

ฉันจะทำให้อัตราดอกเบี้ยเป็นสมาชิกของคลาส "เครื่องมือทางการเงิน" และยอมรับว่าคุณต้องส่งผ่านไปยังคลาสสมาชิกใด ๆ (ไม่ว่าจะคำนวณต่อหรือให้ตัวชี้ / ขอเกี่ยวกับการก่อสร้าง)

สิ่งที่ควรส่งผ่านข้อความไม่ได้อ่านจากสิ่งของทั่วโลก