ทำให้เชื่องคลาส 'ฟังก์ชันยูทิลิตี้'

ใน codebase Java ของเราฉันเห็นรูปแบบต่อไปนี้:

/**
 This is a stateless utility class
 that groups useful foo-related operations, often with side effects.
*/
public class FooUtil {
  public int foo(...) {...}
  public void bar(...) {...}
}

/**
 This class does applied foo-related things.
*/
class FooSomething {
  int DoBusinessWithFoo(FooUtil fooUtil, ...) {
    if (fooUtil.foo(...)) fooUtil.bar(...);
  }
}

สิ่งที่รบกวนจิตใจฉันคือฉันต้องส่งตัวอย่างของFooUtilทุกที่เพราะการทดสอบ

• ฉันไม่สามารถทำให้FooUtilวิธีการคงที่เพราะฉันจะไม่สามารถเยาะเย้ยพวกเขาสำหรับการทดสอบทั้งFooUtilชั้นเรียนและลูกค้า
• ฉันไม่สามารถสร้างอินสแตนซ์ของFooUtilสถานที่บริโภคด้วยnewอีกครั้งเพราะฉันจะไม่สามารถเยาะเย้ยมันสำหรับการทดสอบ

ฉันคิดว่าทางออกที่ดีที่สุดของฉันคือการใช้การฉีด (และฉันทำ) แต่มันเพิ่มชุดยุ่งยากของตัวเอง นอกจากนี้การใช้อินสแตนซ์หลายตัวจะขยายขนาดของรายการพารามิเตอร์เมธอด

มีวิธีจัดการกับสิ่งที่ดีกว่าที่ฉันไม่เห็นหรือไม่?

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

ก่อนอื่นให้ฉันบอกว่ามีวิธีการเขียนโปรแกรมที่แตกต่างกันสำหรับปัญหาที่แตกต่างกัน สำหรับงานของฉันฉันชอบการออกแบบ OO ที่แข็งแกร่งสำหรับองค์กรและการบำรุงรักษาและคำตอบของฉันสะท้อนถึงสิ่งนี้ วิธีการทำงานจะมีคำตอบที่แตกต่างกันมาก

ฉันมักจะพบว่าคลาสยูทิลิตี้ส่วนใหญ่จะถูกสร้างขึ้นเพราะวัตถุวิธีการที่ควรจะอยู่ไม่มี นี่มักจะมาจากหนึ่งในสองกรณีไม่ว่าจะมีใครบางคนกำลังส่งคอลเลกชันไปรอบ ๆ หรือใครบางคนกำลังส่งถั่วไปรอบ ๆ (เหล่านี้มักจะเรียกว่า POJOs แต่ฉันเชื่อว่า setters และ getters

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

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

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

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

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

คุณสามารถใช้รูปแบบของผู้ให้บริการและฉีดFooSomethingกับFooUtilProviderวัตถุของคุณ(อาจอยู่ในตัวสร้าง; เพียงครั้งเดียว)

FooUtilProvider จะมีวิธีเดียวเท่านั้น: FooUtils get(); . ชั้นจะใช้FooUtilsอินสแตนซ์อะไรก็ได้ที่มีให้

ตอนนี้เป็นเพียงขั้นตอนเดียวในการใช้กรอบงานการฉีดของ Dependency เมื่อคุณต้องวางสาย DI cointainer สองครั้ง: สำหรับรหัสการผลิตและชุดการทดสอบของคุณ คุณเพียงแค่ผูกFooUtilsอินเตอร์เฟซการอย่างใดอย่างหนึ่งRealFooUtilsหรือMockedFooUtilsและส่วนที่เหลือจะเกิดขึ้นโดยอัตโนมัติ วัตถุที่ขึ้นอยู่กับทุกคนได้รับรุ่นที่ถูกต้องFooUtilsProviderFooUtils