ฤดูใบไม้ผลิมีไว้สำหรับคนขี้เกียจ ความรู้พื้นฐาน แนวคิดพื้นฐาน และตัวอย่างพร้อมโค้ด ส่วนที่ 1

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

Spring Framework คืออะไร?

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

โครงสร้าง

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

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

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

ทำไมต้องเป็นฤดูใบไม้ผลิใน Java?

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

DI/ไอโอซี

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

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

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

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

เมื่อ Spring เรียกวิธีนี้ให้เรา มันก็ส่งผ่าน object ของ cat จากบริบทของมันเข้าไป ตอนนี้เราตัดสินใจว่าวิธีการของเรานอกจากแมวแล้วยังต้องการนกแก้วด้วย การใช้สปริง - ไม่มีอะไรง่ายไปสำหรับเรา! เราเพียงแค่เขียน:

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

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

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

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

1. ใช้ไฟล์ / การกำหนดค่า xml;
2. ใช้การกำหนดค่าจาวา
3. การกำหนดค่าอัตโนมัติ

นักพัฒนา Spring จัดเรียงตามลำดับความสำคัญนี้:

• วิธีที่สำคัญที่สุดที่ควรได้รับการตั้งค่าคือการกำหนดค่าอัตโนมัติ
• หากใช้การกำหนดค่าอัตโนมัติ ไม่สามารถกำหนดค่า bean ที่เป็นไปได้ทั้งหมดได้อย่างถูกต้อง ให้ใช้การกำหนดค่า Java (การสร้างวัตถุโดยใช้โค้ด Java)
• วิธีที่มีลำดับความสำคัญต่ำสุดคือวิธีที่ล้าสมัย โดยใช้การกำหนดค่า xml

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