Patterns and Singleton - สำหรับทุกคนที่พบเจอครั้งแรก

บทความนี้มุ่งเป้าไปที่ผู้ที่พบแนวคิดเรื่องรูปแบบเป็นครั้งแรก เคยได้ยินเกี่ยวกับSingleton'e หรือสร้างมันขึ้นมา แต่ก็ยังไม่เข้าใจอะไรเลย ยินดีต้อนรับ! นักเรียน JavaRush พบกับรูปแบบเป็นครั้งแรกที่ระดับ 15 เมื่อระดับสูงสุดขอให้ "แก้ไข" และนำรูปแบบไปใช้Singletonโดยไม่ได้ตั้งใจ นักเรียนที่ได้ยินเกี่ยวกับสิ่งนี้เป็นครั้งแรกSingletonจะมีคำถามมากมายทันที: รูปแบบคืออะไร เหตุใดจึงต้องมี รูปแบบประเภทใดSingletonและสุดท้าย การนำไปปฏิบัติแบบขี้เกียจประเภทใด มาเริ่มตอบกันตามลำดับ:

รูปแบบคืออะไรต่อไป?

เพื่อความเข้าใจที่ดีขึ้น ฉันคิดว่าคุ้มค่าที่จะตอบคำถามนี้จากประวัติศาสตร์ ในบรรดาโปรแกรมเมอร์มีนักเขียนชื่อดังสี่คน ได้แก่ Erich Gamma, Richard Helm, Ralph Johnson และ John Vlissides ซึ่งมีแนวคิดที่น่าสนใจ พวกเขาสังเกตเห็นว่าเมื่อเขียนโปรแกรมพวกเขามักจะต้องแก้ไขปัญหาเดียวกันโดยประมาณและเขียนโค้ดประเภทเดียวกันในโครงสร้าง ดังนั้นพวกเขาจึงตัดสินใจอธิบายในรูปแบบของรูปแบบ รูปแบบทั่วไปที่มักใช้ในการเขียนโปรแกรมเชิงวัตถุ หนังสือเล่มนี้ตีพิมพ์ในปี 1995 ภายใต้ชื่อ“เทคนิคของการออกแบบเชิงวัตถุ” รูปแบบการออกแบบ" . ชื่อของหนังสือเล่ม นี้ยาวเกินไป และกลายเป็นที่รู้จักในชื่อThe Book of the Gang of Four ในการพิมพ์ครั้งแรก มีการเผยแพร่รูปแบบ 23 รูปแบบ หลังจากนั้นมีการค้นพบรูปแบบอื่นๆ หลายสิบรูปแบบ ดังนั้น ตอบคำถามในย่อหน้านี้“รูปแบบคืออะไร”ลองสรุปเป็นคำเพียงไม่กี่คำ: และSingletonนี่เป็นเพียงรูปแบบหนึ่งเหล่านี้

ทำไมเราต้องมีรูปแบบ (รูปแบบการออกแบบ)

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

ในที่สุดก็ได้รูปแบบซิงเกิลตัน

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

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


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

ปัญหาทั้งสองนี้แก้ไขได้โดยSingleton: ต้องมีเพียงหนึ่งอ็อบเจ็กต์ในโปรแกรมและต้องมีการเข้าถึงทั่วโลก ในตัวอย่างที่ระดับ 15 cap ขอให้นำรูปแบบนี้ไปใช้สำหรับงานต่อไปนี้ (นี่คือคำอธิบาย): หลังจากอ่านเงื่อนไขอย่างละเอียดแล้ว จะเห็นได้ชัดว่าเหตุใดจึงSingletonต้องใช้ (ซิงเกิล) ที่นี่ ท้ายที่สุดแล้ว โปรแกรมจะขอให้คุณสร้างออบเจ็กต์หนึ่งรายการสำหรับแต่ละคลาส: Sun, Moon, Earth. และมีเหตุผลที่จะสรุปได้ว่าแต่ละคลาสในโปรแกรมควรสร้างดวงอาทิตย์/ดวงจันทร์/โลกไม่เกินหนึ่งดวง ไม่เช่นนั้นมันจะไร้สาระ เว้นแต่ว่าคุณกำลังเขียน Star Wars เวอร์ชันของคุณเอง คุณลักษณะของ การนำSingletonJava ไปใช้งานในสามขั้นตอน พฤติกรรมของ Singleton ใน Java ไม่สามารถนำไปใช้ได้โดยใช้ Constructor ปกติ เนื่องจาก Constructor จะส่งคืนอ็อบเจ็กต์ใหม่เสมอ ดังนั้นการใช้งานทั้งหมดของSingleton'a ลงมาเพื่อซ่อนตัวสร้างและสร้างวิธีการคงที่สาธารณะที่จะควบคุมการมีอยู่ของวัตถุเดียวและ "ทำลาย" วัตถุที่ปรากฏใหม่ทั้งหมด หากSingletonเรียก 'a จะต้องสร้างวัตถุใหม่ (หากยังไม่มีอยู่ในโปรแกรม) หรือส่งคืนวัตถุที่สร้างขึ้นแล้ว เมื่อต้องการทำสิ่งนี้: #1 – คุณต้องเพิ่มฟิลด์คงที่ส่วนตัวให้กับคลาสที่มีวัตถุเดียว:

public class LazyInitializedSingleton {
	private static LazyInitializedSingleton instance; //#1
}

#2. – ทำให้ class Constructor (ตัวสร้างเริ่มต้น) เป็นส่วนตัว (เพื่อให้การเข้าถึงถูกปิดภายนอกคลาส จากนั้นจะไม่สามารถส่งคืนอ็อบเจ็กต์ใหม่ได้):

public class LazyInitializedSingleton {
	private static LazyInitializedSingleton instance;
private LazyInitializedSingleton(){} // #2
}

#3 . – ประกาศวิธีการสร้างแบบคงที่ที่จะใช้เพื่อให้ได้ซิงเกิลตัน:

public class LazyInitializedSingleton {
    private static LazyInitializedSingleton instance;
        private LazyInitializedSingleton(){}
        public static LazyInitializedSingleton getInstance(){ // #3
        if(instance == null){		//if the object has not been created yet
            instance = new LazyInitializedSingleton();	//create a new object
        }
        return instance;		// return the previously created object
    }
}

ตัวอย่างข้างต้นค่อนข้างจะงุ่มง่าม เนื่องจากเราซ่อน Constructor และเตรียมวิธีการของเราเองแทน Constructor มาตรฐาน เนื่องจากบทความนี้มีวัตถุประสงค์เพื่อให้นักเรียน JavaRush ได้สัมผัสกับรูปแบบนี้ (และรูปแบบโดยทั่วไป) เป็นครั้งแรก จึงไม่มีการระบุคุณลักษณะการใช้งานของ Singletons ที่ซับซ้อนกว่านี้ไว้ที่นี่ เราทราบเพียงว่าอาจจำเป็นต้องมีการปรับแต่งรูปแบบนี้โดยละเอียดเพิ่มเติม ทั้งนี้ขึ้นอยู่กับความซับซ้อนของโปรแกรม ตัวอย่างเช่น ในสภาพแวดล้อมแบบมัลติเธรด (ดูหัวข้อ Threads) เธรดต่างๆ จำนวนมากสามารถเรียกใช้เมธอด getter ของ Singleton ได้พร้อมกัน และโค้ดที่อธิบายไว้ข้างต้นจะหยุดทำงาน เนื่องจากแต่ละเธรดแต่ละเธรดจะสามารถสร้างหลายอินสแตนซ์ของคลาสได้ ในครั้งเดียว. ดังนั้นจึงยังมีหลายวิธีในการสร้างซิงเกิลตันที่ปลอดภัยสำหรับเธรดที่ถูกต้อง แต่นั่นเป็นอีกเรื่องหนึ่ง =) และสุดท้าย Lazy Initialization ที่ cap ถามคืออะไร Lazy Initialization เรียกอีกอย่างว่าการเริ่มต้นแบบ Lazy นี่คือเทคนิคการเขียนโปรแกรมที่การดำเนินการที่ใช้ทรัพยากรมาก (และการสร้างอ็อบเจ็กต์เป็นการดำเนินการที่ใช้ทรัพยากรมาก) จะดำเนินการตามความต้องการ แทนที่จะดำเนินการล่วงหน้า ซึ่งโดยพื้นฐานแล้วคือสิ่งที่เกิดขึ้นในโค้ดของเราSingleton'a กล่าวอีกนัยหนึ่ง วัตถุของเราถูกสร้างขึ้นในขณะที่มีการเข้าถึง ไม่ใช่ล่วงหน้า ไม่ควรสันนิษฐานว่าแนวคิดของการเริ่มต้นแบบขี้เกียจนั้นเชื่อมโยงกับSingleton'om อย่างเคร่งครัด การเริ่มต้นแบบ Lazy ยังใช้ในรูปแบบการออกแบบเชิงกำเนิดอื่น ๆ เช่นในวิธี Proxy และ Factory แต่นั่นเป็นอีกเรื่องหนึ่ง =) แหล่งข้อมูลต่อไปนี้ถูกนำมาใช้ในการเตรียมบทความ:

1. แนวทางปฏิบัติที่ดีที่สุดสำหรับรูปแบบการออกแบบ Java Singleton พร้อมตัวอย่าง
2. รูปแบบการออกแบบ
3. แก้ไขซิงเกิลตันใน Java