Spring for lazy people รากฐาน แนวคิดพื้นฐาน และตัวอย่างพร้อมโค้ด ส่วนที่ 1

ในบทความนี้ฉันจะไม่บอกคุณถึงวิธีทำให้ Spring Project ทำงานและทำงานใน 5 นาทีโดยใช้รหัสของฉัน ฉันจะเขียนแค่พื้นฐานเท่านั้น — สิ่งที่คุณอาจไม่รู้และยังสร้างโปรเจกต์อยู่ แต่ในบทความนี้ คุณจะยังไม่เข้าใจว่าเกิดอะไรขึ้น และที่สำคัญกว่านั้นคือทำไม

Spring Framework คืออะไร

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

โครงสร้าง

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

https://docs.spring.io/spring/docs/4.3.26.RELEASE/spring-framework-reference/htmlsingle/
รูปที่ 2.1 ภาพรวมของ Spring Framework

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

• การเข้าถึงข้อมูล
• เว็บ
• แกน
• และอื่น ๆ

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

เหตุใด Java จึงมี Spring Framework

นอกจากข้อเท็จจริงที่ว่ามันทันสมัย ​​ลื่นไหล และสดใหม่แล้ว ฉันบอกได้เลยว่าทันทีที่คุณมีทักษะเพียงเล็กน้อยในการใช้ Spring คุณจะเข้าใจว่ามีงานทุกประเภทที่คุณไม่มีอีกต่อไป ต้องทำและสปริงต้องทำงานหนักแค่ไหน คุณสามารถเขียนการตั้งค่าคอนฟิกูเรชันสองสามบรรทัดและเขียนคลาสสองสามคลาส และจบลงด้วยโปรเจ็กต์การทำงาน แต่ทันทีที่คุณเริ่มสงสัยว่ามีอะไรอีกมากที่อยู่ภายใต้ประทุน งานที่ทำเสร็จแล้ว และจำนวนโค้ดที่คุณต้องเขียนหากคุณกำลังจะนำโปรเจกต์เดียวกันไปใช้โดยอิงจากเซิร์ฟเล็ตหรือซ็อกเก็ตธรรมดาและจาวาบริสุทธิ์ ผมของคุณจะตั้งตรงจนสุด :) ฤดูใบไม้ผลิถูกอธิบายว่าเป็นเวทมนตร์ชนิดหนึ่ง คุณจะพบกับสิ่งนี้เมื่อคุณเห็นว่าทุกอย่างได้ผล แต่คุณยังมีแนวคิดคร่าว ๆ ว่าเบื้องหลังการทำงานเกิดขึ้นได้อย่างไรและมากน้อยเพียงใด ดังนั้นดูเหมือนว่ามีเวทมนตร์อยู่จริง ๆ :) การเรียกมันว่าเวทมนตร์นั้นง่ายกว่าการพยายามอธิบายว่ามันเชื่อมโยงกันอย่างไร :) ข้อโต้แย้งที่สองที่สนับสนุนการเรียน Spring คือประมาณ 90% ของตำแหน่งงานว่างสำหรับนักพัฒนารุ่นเยาว์ (จากการสังเกตส่วนตัวของฉัน) ต้องการความรู้หรืออย่างน้อยแนวคิดทั่วไปเกี่ยวกับสิ่งที่ SpringData, Web MVC, และSecurityโมดูลให้นักพัฒนาที่เชี่ยวชาญ :) แต่วันนี้เป็นเพียงพื้นฐานเท่านั้น

DI/ไอโอซี

หากคุณเคยพยายามอ่านเกี่ยวกับ Spring สิ่งแรกที่คุณพบน่าจะเป็นคำย่อเหล่านี้: DI/IoC ตอนนี้ฉันขอแนะนำให้คุณหยุดพักจากบทความนี้และอ่านบทความ DZone นี้ ! IoCหมายถึงการผกผันของการควบคุม ฉันได้พูดถึงสิ่งนี้ไปแล้วเมื่อฉันเขียนว่าการใช้ไลบรารีนั้นเกี่ยวข้องกับคุณด้วยตัวคุณเองในการระบุรหัสของคุณว่าจะเรียกเมธอดใดในออบเจกต์ใด แต่โดยทั่วไปแล้วการใช้เฟรมเวิร์กหมายความว่าเฟรมเวิร์กจะเรียกใช้โค้ดของคุณในเวลาที่เหมาะสม กล่าวอีกนัยหนึ่ง ในกรณีหลังนี้ คุณไม่ได้จัดการกระบวนการรันโค้ด/โปรแกรมอีกต่อไป — เฟรมเวิร์กจัดการสิ่งนี้ให้คุณ คุณส่งผ่านการควบคุมไปยังเฟรมเวิร์ก (การผกผันของการควบคุม) DIหมายถึงการฉีดพึ่งพา. ด้วยการฉีดการพึ่งพา คุณไม่ต้องสร้างวัตถุ cat ในวิธีการหลักแล้วส่งต่อไปยังวิธีการของคุณ Spring Framework จะสร้างให้คุณแทน คุณเพียงแค่พูดบางอย่างเช่น "ฉันต้องการรับแมวที่นี่" และเฟรมเวิร์กจะส่งแมวตัวหนึ่งมาให้คุณตามวิธีการของคุณ เราจะเห็นตัวย่อนี้ในบทความต่อๆ ไป

ถั่วและบริบท

หนึ่งในแนวคิดหลักในฤดูใบไม้ผลิคือถั่ว ในความเป็นจริงนี่เป็นเพียงวัตถุของบางคลาส สมมติว่าเรามีโปรแกรมที่ต้องการวัตถุ 3 อย่าง แมว สุนัข และนกแก้ว และเรามีคลาสมากมายพร้อมเมธอดมากมาย บางครั้งเราต้องการแมวเป็นวิธีการ บางครั้งเราต้องการสุนัขสำหรับวิธีการอื่น และบางครั้งวิธีการของเราก็ต้องการทั้งแมวและนกแก้ว (เช่น วิธีการให้อาหารแมว ฮ่าฮ่า) สำหรับวิธีการอื่น ๆ จำเป็นต้องมีวัตถุทั้งสาม ได้ ก่อนอื่นเราสามารถสร้างออบเจกต์ทั้งสามนี้ในเมธอดหลัก แล้วจึงส่งต่อไปยังคลาสของเรา จากนั้นในคลาสเหล่านี้จึงส่งต่อไปยังเมธอดที่เกี่ยวข้อง... และต่อไปเรื่อยๆ ตลอดทั้งโปรแกรม แต่ถ้าเราสมมุติว่าบางครั้งเราต้องการเปลี่ยนรายการพารามิเตอร์อินพุตสำหรับเมธอดของเรา (ตัวอย่างเช่น เราตัดสินใจที่จะเขียนบางอย่างใหม่หรือเพิ่มฟังก์ชันใหม่) จากนั้นเราจะต้องทำการเปลี่ยนแปลงโค้ดเล็กน้อย และตอนนี้ลองนึกภาพว่าเราไม่มี 3 แต่มี 300 วัตถุดังกล่าว ทางเลือกหนึ่งคือการรวบรวมวัตถุทั้งหมดของเราไว้ในรายการเดียว (List<Object>) ส่งผ่านไปยังทุกเมธอด จากนั้นรับออบเจกต์ที่จำเป็นขณะอยู่ในเมธอด แต่ในขณะที่โปรแกรมทำงาน จะเกิดอะไรขึ้นถ้ามีการเพิ่มวัตถุบางอย่างในรายการนี้ หรือแย่กว่านั้น จะเกิดอะไรขึ้นถ้าวัตถุนั้นถูกลบออก สิ่งนี้มีศักยภาพที่จะทำลายทุกวิธีที่เราใช้ดัชนีเพื่อรับวัตถุจากรายการ เพื่อหลีกเลี่ยงปัญหานี้ เราตัดสินใจจัดเก็บอ็อบเจ็กต์ของเราโดยไม่อยู่ในรายการ แต่อยู่ในแผนที่ โดยที่คีย์คือชื่อของอ็อบเจ็กต์และค่าคือตัวอ็อบเจ็กต์เอง สิ่งนี้ช่วยให้เราสามารถดึงวัตถุที่เราต้องการได้ง่ายๆ โดยใช้ชื่อของมัน เช่น get("นกแก้ว") และเราได้รับวัตถุนกแก้วเพื่อตอบสนอง หรือคีย์อาจเป็นคลาสของวัตถุ และค่าอาจเป็นตัววัตถุเอง ในกรณีนี้แทนที่จะระบุชื่อของวัตถุ แต่สามารถระบุคลาสของวัตถุที่เราต้องการได้ นอกจากนี้ยังสะดวก หรือเราอาจเขียน wrapper บางอย่างสำหรับแผนที่ โดยที่บางเมธอดจะรับออบเจกต์ตามชื่อ และเมธอดอื่นๆ จะรับอ็อบเจกต์ตามคลาส สิ่งที่เรามาถึงที่นี่เรียกว่าบริบทของแอปพลิเคชันใน Spring Framework บริบทคือชุดของถั่ว (วัตถุ) เราเข้าถึงบริบทเพื่อรับ bean (วัตถุ) ที่เราต้องการตามชื่อ ประเภท หรือด้วยวิธีอื่น นอกจากนี้ เราสามารถขอให้ Spring ไปดูในบริบทของตัวเองสำหรับ bean ที่เราต้องการและส่งต่อไปยังวิธีการของเรา ตัวอย่างเช่น สมมติว่าเรามีวิธีการดังนี้:

public void doSomething(Cat cat) {
    ...
}

เมื่อ Spring เรียกเมธอดนี้ มันจะดึงวัตถุ cat ของเราจากบริบทของมันและส่งต่อไปยังเมธอด แต่ตอนนี้เราได้ตัดสินใจแล้วว่า นอกจากแมวแล้ว วิธีการของเรายังต้องการนกแก้วด้วย ด้วย Spring ไม่มีอะไรจะง่ายไปกว่านี้แล้ว! เราเพียงแค่เขียน:

public void doSomething(Cat cat, Parrot parrot) {
    ...
}

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

วิธีกำหนดค่าแอปพลิเคชัน

มีสามวิธีหลักในการกำหนดค่าแอปพลิเคชัน นั่นคือวิธีบอก Spring ว่าเราต้องการวัตถุใด:

1. ไฟล์คอนฟิกูเรชัน XML
2. การกำหนดค่าตามจาวา
3. การกำหนดค่าอัตโนมัติ

ผู้สร้างของ Spring จัดลำดับความสำคัญตามลำดับนี้:

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

Spring ยังช่วยให้เรารวมวิธีการเหล่านี้เข้าด้วยกัน ตัวอย่างเช่น ให้ Spring กำหนดค่าทุกอย่างที่สามารถกำหนดค่าได้โดยอัตโนมัติ ใช้การกำหนดค่าตาม Java ทุกที่ที่คุณต้องการพารามิเตอร์พิเศษ และใช้ XML สำหรับการกำหนดค่าแบบดั้งเดิม ทั้งหมดนี้ใช้งานได้ค่อนข้างยืดหยุ่น หากทุกอย่างสามารถกำหนดค่าได้โดยอัตโนมัติ ให้เลือกตัวเลือกนั้น ฉันจะพิจารณาการกำหนดค่าอัตโนมัติและการกำหนดค่าตาม Java เท่านั้น การกำหนดค่า XML ใช้ในเกือบทุกตัวอย่างของ Spring บนอินเทอร์เน็ต ยิ่งไปกว่านั้น เมื่อคุณเข้าใจวิธีการทำงานของการกำหนดค่าบน Java แล้ว คุณจะไม่มีปัญหาในการอ่านไฟล์ XML ที่ทำสิ่งเดียวกัน การกำหนดค่าอัตโนมัติจะใช้เมื่อเราต้องการทำงานกับออบเจกต์ของคลาสที่เราเขียน หากการสร้างออบเจกต์ของเราต้องใช้ตรรกะบางอย่างที่เฉพาะเจาะจงมาก หรือหากเราไม่สามารถสร้างคลาสที่มีคำอธิบายประกอบที่จำเป็นสำหรับการกำหนดค่าอัตโนมัติ เราก็สามารถใช้การกำหนดค่าตาม Java เพื่อทำสิ่งที่ต้องทำ ในส่วนต่อไปเราจะสร้างโปรเจ็กต์ Maven เชื่อมต่อโมดูล Spring หลักสองสามโมดูล และสร้าง bean แรกของเรา