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

อย่างไรก็ตามนี่เป็นเพียงเล็กน้อยเกี่ยวกับพื้นหลังและแอพของฉัน:

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

แอพของฉันค่อนข้างเรียบง่ายจากมุมมอง CS โครงการขนาดเล็ก 1-2 นักพัฒนาที่จะเริ่มต้นด้วย การดำเนินการประเภท CRUD ส่วนใหญ่ที่มีการค้นหามากมายถูกโยนเข้ามาโดยทั่วไปแล้วเว็บเซอร์วิส RESTful รวมทั้งเว็บฟรอนต์เอนด์และในที่สุดก็มีลูกค้ามือถือบางส่วน ฉันกำลังคิดที่จะทำ front-end ด้วย HTML / CSS / JS / JQuery แบบตรงดังนั้นจึงไม่มีแผนที่จะใช้ JSP การใช้ Hibernate เป็น ORM และ Jersey เพื่อนำเว็บเซอร์ไปใช้

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

ได้โปรด. ให้ความรู้แก่ฉัน ฉันควรใช้สปริงไหม ทำไมหรือทำไมไม่?

Spring Framework ทำอะไรได้บ้าง ฉันควรใช้หรือไม่ ทำไมหรือทำไมไม่?

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

นี่คือสิ่งที่ฉันเข้าใจเสมอว่า "การพึ่งพา"

ฉันขอแนะนำนิยามที่แตกต่าง:

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

เปรียบเทียบกับ: "แต่ละวัตถุรับผิดชอบในการออกไปข้างนอกและค้นหาทุกสิ่งที่ทุกคนต้องการเมื่อมันเริ่มต้นขึ้น"

ดูเหมือนว่าจำเป็นต้องใช้การกำหนดค่า XML ทั้งกลุ่ม

ส่วนใหญ่สิ่ง XML (หรือตามคำอธิบายประกอบ) กำลังบอกเรื่องของ Spring ดังนี้:

• เมื่อมีคนถามถึง "HammerStore" ฉันต้องการให้คุณสร้างตัวอย่างexample.HammerStoreและส่งคืน แคชอินสแตนซ์สำหรับครั้งต่อไปเนื่องจากมีเพียงหนึ่งร้านเท่านั้น
• เมื่อมีคนถามหา "SomeHammer" ฉันต้องการให้คุณถามตัวเอง "HammerStore" และส่งคืนผลลัพธ์ของmakeHammer()วิธีการของร้านค้า อย่าไม่แคชผลนี้
• เมื่อมีคนถามหา "SomeWrench" ฉันต้องการให้คุณสร้างอินสแตนซ์example.WrenchImplให้ใช้การตั้งค่าการกำหนดค่าgaugeAmountและใส่ลงในsetWrenchSize()คุณสมบัติของอินสแตนซ์ อย่าแคชผลลัพธ์
• เมื่อมีคนถามหา "LocalPlumber" example.PlumberImplผมต้องการที่จะให้คุณสร้างตัวอย่างของ ใส่สตริง "Pedro" เป็นsetName()วิธีการใส่ "SomeHammer" ลงในsetHammer()วิธีการแล้วใส่ "SomeWrench" ลงในsetWrench()วิธีการ ส่งคืนผลลัพธ์และแคชผลลัพธ์ในภายหลังเนื่องจากเราต้องการเพียงหนึ่งช่างประปา

ด้วยวิธีนี้สปริงอนุญาตให้ส่วนประกอบการเชื่อมต่อของคุณติดป้ายส่วนประกอบควบคุมวงจรชีวิต / แคชและเปลี่ยนแปลงพฤติกรรมตามการกำหนดค่า

เพื่ออำนวยความสะดวก [การทดสอบ] โดยทั่วไปฉันจะสร้างวิธีการอย่างน้อยสองรุ่น: รุ่นที่ใช้ตัวแปรอินสแตนซ์และรุ่นที่ใช้ตัวแปรที่ส่งผ่านไปยังวิธีการนั้นเท่านั้น

ฟังดูเหมือนค่าใช้จ่ายมากมายสำหรับฉัน แต่ให้ตัวแปรอินสแตนซ์ของคุณมีprotectedหรือมองเห็นแพ็คเกจและค้นหาการทดสอบหน่วยภายในcom.mycompany.whateverแพ็คเกจเดียวกัน ด้วยวิธีนี้คุณสามารถตรวจสอบและเปลี่ยนแปลงตัวแปรอินสแตนซ์เมื่อใดก็ตามที่คุณต้องการในระหว่างการทดสอบ

ครั้งแรกการฉีดพึ่งพาคืออะไร?

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

ประการที่สอง Spring สามารถใช้ได้โดยไม่มี XML (หรือน้อยมาก)

หากคุณดำน้ำด้วย Spring 3.0.5.GA หรือสูงกว่าคุณสามารถใช้การสนับสนุนการฉีดพึ่งพาจาก JDK6 + ซึ่งหมายความว่าคุณสามารถวางสายการอ้างอิงโดยใช้@Componentและ@Resourceหมายเหตุประกอบ

เหตุใดจึงต้องใช้สปริงเลย

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

นอกจากนั้นสปริงยังมีเทมเพลตจำนวนมากซึ่งทำหน้าที่เป็นคลาสพื้นฐานเพื่อให้ใช้เทคโนโลยีมาตรฐาน JEE ได้อย่างสะดวกสบาย ตัวอย่างเช่น JdbcTemplate ทำงานได้ดีกับ JDBC JpaTemplate ทำสิ่งที่ดีกับ JPA ได้ JmsTemplate ทำให้ JMS ตรงไปตรงมา RestTemplate นั้นยอดเยี่ยมในความเรียบง่าย ตัวอย่างเช่น:

RestTemplate restTemplate = new RestTemplate();
MyJaxbObject o = restTemplate.getForObject("https://secure.example.org/results/{param1}?param2={param2}",MyJaxbObject.class,"1","2");

และคุณทำเสร็จแล้ว พารามิเตอร์ถูกฉีดและคุณเพียงแค่ต้องใส่คำอธิบายประกอบ JAXB สำหรับ MyJaxbObject ซึ่งไม่ต้องใช้เวลาเลยหากคุณสร้างโดยอัตโนมัติจาก XSD โดยใช้ปลั๊กอิน Maven JAXB โปรดทราบว่าไม่มีการคัดเลือกนักแสดงและไม่จำเป็นต้องประกาศเจ้าหน้าที่ มันทำเพื่อคุณ

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

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

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

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

สำหรับเหตุผลที่คุณต้องการใช้ Spring คุณสามารถอ่านได้ที่http://www.wrox.com/WileyCDA/Section/Why-Use-the-Spring-Framework-.id-130098.html

สรุป :

• แอปพลิเคชัน J2EE มักจะมีรหัส "plumbing" มากเกินไป การตรวจสอบโค้ดหลายครั้งเผยให้เห็นสัดส่วนที่สูงของรหัสที่ไม่ได้ทำอะไรเลย: รหัสการค้นหา JNDI, การโอนย้ายออบเจ็กต์, ลอง / จับบล็อกเพื่อรับและปล่อยทรัพยากร JDBC . . . การเขียนและการบำรุงรักษารหัสการประปานั้นเป็นการพิสูจน์ให้เห็นถึงการระบายทรัพยากรที่ควรมุ่งเน้นไปที่โดเมนธุรกิจของแอปพลิเคชัน

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

• รูปแบบองค์ประกอบ EJB ซับซ้อนเกินควร EJB รู้สึกว่าเป็นวิธีการลดความซับซ้อนเมื่อใช้ตรรกะทางธุรกิจในแอปพลิเคชัน J2EE; มันไม่ประสบความสำเร็จในการฝึกซ้อมครั้งนี้

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

• "รูปแบบการออกแบบ J2EE" หลายรูปแบบไม่ใช่รูปแบบการออกแบบ แต่เป็นการแก้ไขข้อ จำกัด ทางเทคโนโลยี การกระจายที่มากเกินไปและการใช้ API ที่ซับซ้อนเช่น EJB ได้สร้างรูปแบบการออกแบบที่น่าสงสัยมากมาย มันเป็นสิ่งสำคัญที่จะตรวจสอบสิ่งเหล่านี้อย่างยิ่งและมองหาวิธีที่ง่ายขึ้นมีประสิทธิผลมากขึ้น

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

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

ก่อนหน้านี้เราเคยเขียนแอปพลิเคชั่นที่เรียบง่ายมีประสิทธิภาพรวดเร็วและเว็บเซอร์วิสโดยใช้เพียงแกน Java, Servlets และ JSP, html และ xml, JDBC API มันดีพอ JUnit เป็นเครื่องมือที่ดีในการทดสอบ เราพักง่ายว่ารหัสของเราทำงาน

ไฮเบอร์เนตมาเพื่อทำให้ SQL ง่ายขึ้นและเปิดใช้งานการแมปจริงของตารางฐานข้อมูลด้วยวัตถุ Java ทำให้สามารถแสดงความสัมพันธ์แบบลำดับชั้นในการทำแผนที่ความสัมพันธ์เชิงวัตถุหรือ ORM ที่เราเรียกว่า ฉันชอบมัน. โดยเฉพาะอย่างยิ่งที่เราไม่จำเป็นต้องแมปชุดผลลัพธ์กลับเข้าไปในวัตถุ Java หรือชนิดข้อมูล

Struts เข้ามาเพื่อเพิ่มรูปแบบ Model View Controller ให้กับเว็บแอปของเรามันดีมาก

EJB นั้นเป็นค่าโสหุ้ยและความเจ็บปวดขนาดใหญ่และคำอธิบายประกอบทำให้โค้ดดูเหมือนไก่เกาและตอนนี้ฤดูใบไม้ผลิก็เกิดขึ้นกับพวกเราผู้บริสุทธิ์ มันดูเหมือนว่าหักโหมกับฉัน

ตัวอย่างเช่นตอนนี้เราจัดแพ็คเกจ jdbc url ที่เรียบง่ายของเราผู้ใช้ส่งผ่านไปยัง jdbc.properties ก่อนจากนั้นเข้าสู่คุณสมบัติไฮเบอร์เนตที่สองจากนั้นเข้าสู่ Spring beans ครั้งที่สาม!

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

Connection connection = DriverManager.getConnection(url, user, pass);

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

อีกตัวอย่างหนึ่งคือการอัปเดตแบบกลุ่ม ด้วย Spring มันมีความซับซ้อนที่เกี่ยวข้องกับคลาสค่อนข้างน้อยอินเตอร์เฟสก่อนที่คุณจะสามารถใช้ JdbcTemplate เพื่อทำการอัพเดตแบบแบตช์ ด้วยธรรมดา jdbc มันเพียง:

Statement statement = connection.createStatement();
statement.addBatch(sqlquery);
statement.executeBatch();

ไม่สามารถรับได้ง่ายกว่าหรือเร็วกว่านั้น

ฉันไม่สนับสนุนกรอบงานนี้ ขอโทษ ใครในโลกที่ต้องการฉีดทุกครั้งที่ต้องการอะไร

Spring Framework ทำอะไรได้บ้าง

ฤดูใบไม้ผลิเป็นเหมือนทุกวันนี้สิ่งที่เป็นที่รู้จักกันในชื่อกรอบง่าย ๆ มันเป็นระบบนิเวศสมบูรณ์

หัวข้อที่ครอบคลุมโดยระบบนิเวศในฤดูใบไม้ผลิ:

• Spring Framework (เช่นการพึ่งพาการฉีด AOP ... )

• Spring Cloud

• Spring Data

• Spring Security

• ชุดฤดูใบไม้ผลิ

• Spring Social

ดูที่นี่สำหรับความคุ้มครองเต็มรูปแบบของระบบนิเวศ เป็นไปได้ที่จะเลือกโครงการเชอร์รี่เพื่อให้คุณสามารถใช้Google Guiceสำหรับ DI และเช่น Spring Security เพื่อจัดการกับสิ่งที่เกี่ยวข้องกับความปลอดภัย คุณไม่จำเป็นต้องซื้อระบบนิเวศทั้งหมด

โครงร่างสปริงครอบคลุมวันนี้เป็นส่วนใหญ่

• ฉีดพึ่งพา

• การเขียนโปรแกรมเชิงมุมมองรวมถึงการจัดการการทำธุรกรรมของสปริง

• เว็บแอปพลิเคชัน Spring MVC และเฟรมเวิร์กบริการเว็บสงบ

• การสนับสนุนพื้นฐานสำหรับ JDBC, JPA, JMS

แหล่งที่มาของspring.io

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

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

การฉีดพึ่งพาคืออะไร?

การฉีดพึ่งพาหมายถึงว่าวัตถุของคุณได้รับทุกการพึ่งพาวัตถุอื่นผ่านกลไกภายนอก

สมมติว่าคุณมีรถยนต์วิธีทั่วไปที่นำมาใช้คือ:

public class Car {

    Engine e;

    public Car() { 
        e = new Engine(); 
    }

}

วัตถุรถยนต์ขึ้นอยู่กับเครื่องยนต์ เนื่องจากเครื่องยนต์ถูกนำไปใช้ในฐานะสมาชิกของรถจึงไม่สามารถสลับออกมาได้เช่นเครื่องยนต์ทดสอบ

ตอนนี้การฉีดขึ้นอยู่กับการเล่น:

public class Car {

    Engine e;

    public Car(Engine e) { 
        this.e = e; 
    }

}

หลังจากนั้นคุณสามารถสลับเครื่องยนต์ได้ สิ่งที่คุณเห็นข้างต้นเรียกว่าการฉีดคอนสตรัคเตอร์ มีชนิดอื่น ๆ เช่นsetter -inject หรือmethod -inject สปริงช่วยคุณได้อย่างไร สปริงอนุญาตให้ทำเครื่องหมายส่วนประกอบที่จะฉีดด้วยคำอธิบายประกอบ@Autowiredและทำการเดินสายไฟของวัตถุ injecteed โดยอัตโนมัติ - มีแนวโน้มว่าส่วนประกอบที่คุณต้องการฉีดนั้นมีการพึ่งพาตัวเอง Injectables - to say - มีการทำเครื่องหมายผ่าน@Component

public class Car {

    Engine e;

    @Autowired
    public Car(Engine e) { 
        this.e = e; 
    }

}

แต่นั่นเป็นเพียงหนึ่งในคุณสมบัติที่สปริงมีให้

ฉันควรใช้สปริงไหม ทำไมหรือทำไมไม่?

เนื่องจากสปริงไม่ได้มีการล่วงล้ำมากและมีเครื่องช่วยมากมายคุณควรพิจารณาใช้สปริง โดยเฉพาะอย่างยิ่งสำหรับโครงการใหม่Spring Bootเป็นที่น่าสนใจมาก start.spring.ioนำเสนอpoint'n'click -interface ที่ใช้งานง่ายเพื่อสร้างเทมเพลตโครงการเพื่อเริ่มต้น เป็นไปได้ที่จะใช้curlเพื่อดึงข้อมูลเทมเพลต:

curl start.spring.io

  .   ____          _            __ _ _
 /\\ / ___'_ __ _ _(_)_ __  __ _ \ \ \ \
( ( )\___ | '_ | '_| | '_ \/ _` | \ \ \ \
 \\/  ___)| |_)| | | | | || (_| |  ) ) ) )
  '  |____| .__|_| |_|_| |_\__, | / / / /
 =========|_|==============|___/=/_/_/_/

:: Spring Initializr ::  https://start.spring.io

This service generates quickstart projects that can be easily customized.
Possible customizations include a project's dependencies, Java version, and
build system or build structure. See below for further details.

The services uses a HAL based hypermedia format to expose a set of resources
to interact with. If you access this root resource requesting application/json
as media type the response will contain the following links:
+-----------------+-----------------------------------------+
| Rel             | Description                             |
+-----------------+-----------------------------------------+
| gradle-build    | Generate a Gradle build file            |
| gradle-project  | Generate a Gradle based project archive |
| maven-build     | Generate a Maven pom.xml                |
| maven-project * | Generate a Maven based project archive  |
+-----------------+-----------------------------------------+

...

ในทางกลับกันเฟรมเวิร์กเช่นsparkหรือdropwizardเป็นจุดเริ่มต้นที่ดีสำหรับการสร้างแอปพลิเคชันเว็บอย่างรวดเร็วเช่นกัน

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

หนังสือที่ดีที่จะเรียนรู้เกี่ยวกับ Spring คือ: Expert Spring MVC และ Web Flow