ฉันได้ยินมามากมายเกี่ยวกับSpringผู้คนกำลังพูดกันทั่วทั้งเว็บว่า Spring เป็นกรอบที่ดีสำหรับการพัฒนาเว็บ Spring Framework มีไว้เพื่ออะไร?
ฉันได้ยินมามากมายเกี่ยวกับSpringผู้คนกำลังพูดกันทั่วทั้งเว็บว่า Spring เป็นกรอบที่ดีสำหรับการพัฒนาเว็บ Spring Framework มีไว้เพื่ออะไร?
คำตอบ:
ฤดูใบไม้ผลิโดยทั่วไปเป็นกรอบสำหรับ การพึ่งพาการฉีด ซึ่งเป็นรูปแบบที่ช่วยให้สร้างระบบที่แยกส่วนได้มาก
ตัวอย่างเช่นสมมติว่าคุณต้องการแสดงรายการผู้ใช้ของระบบและประกาศอินเตอร์เฟสที่เรียกว่าUserLister
:
public interface UserLister {
List<User> getUsers();
}
และอาจเป็นการใช้งานการเข้าถึงฐานข้อมูลเพื่อให้ผู้ใช้ทั้งหมด:
public class UserListerDB implements UserLister {
public List<User> getUsers() {
// DB access code here
}
}
ในมุมมองของคุณคุณจะต้องเข้าถึงอินสแตนซ์ (เพียงจำตัวอย่าง):
public class SomeView {
private UserLister userLister;
public void render() {
List<User> users = userLister.getUsers();
view.render(users);
}
}
userLister
โปรดทราบว่าโค้ดข้างต้นไม่ได้เริ่มต้นตัวแปร เราควรทำอย่างไร ถ้าฉันสร้างอินสแตนซ์ของวัตถุเช่นนี้:
UserLister userLister = new UserListerDB();
... ฉันขอดูการใช้ชั้นเรียนที่เข้าถึงฐานข้อมูล ถ้าฉันต้องการเปลี่ยนจากการใช้ฐานข้อมูลไปเป็นอีกรายการหนึ่งที่ได้รับรายชื่อผู้ใช้จากไฟล์ที่คั่นด้วยเครื่องหมายจุลภาค (โปรดจำไว้ว่ามันเป็นตัวอย่าง) ในกรณีนั้นฉันจะไปที่รหัสของฉันอีกครั้งและเปลี่ยนบรรทัดด้านบนเป็น:
UserLister userLister = new UserListerCommaSeparatedFile();
ไม่มีปัญหากับโปรแกรมขนาดเล็กเช่นนี้ แต่ ... จะเกิดอะไรขึ้นในโปรแกรมที่มีจำนวนการดูนับร้อยและคลาสธุรกิจที่คล้ายกัน การบำรุงรักษากลายเป็นฝันร้าย!
สิ่งที่ Spring ทำคือการโยงคลาสขึ้นโดยใช้ไฟล์ XML หรือคำอธิบายประกอบวิธีนี้วัตถุทั้งหมดจะถูกสร้างและเริ่มต้นโดย Spring และฉีดในตำแหน่งที่ถูกต้อง (Servlets, Web Frameworks, ชั้นธุรกิจ, DAO ฯลฯ ฯลฯ ... )
กลับไปที่ตัวอย่างใน Spring เราแค่ต้องมี setter สำหรับuserLister
ฟิลด์และมีไฟล์ XML อย่างนี้:
<bean id="userLister" class="UserListerDB" />
<bean class="SomeView">
<property name="userLister" ref="userLister" />
</bean>
หรือมากกว่าเพียงแค่ใส่คำอธิบายประกอบในไฟล์ในมุมมองของเราด้วย@Inject
:
@Inject
private UserLister userLister;
วิธีนี้เมื่อมุมมองถูกสร้างขึ้นอย่างน่าอัศจรรย์จะมีความUserLister
พร้อมในการทำงาน
List<User> users = userLister.getUsers(); // This will actually work
// without adding any line of code
มันเยี่ยมมาก! ไม่ใช่เหรอ
UserLister
อินเทอร์เฟซอื่นของคุณ เพียงแค่เปลี่ยน XMLUserLister
การนำไปปฏิบัติพร้อม โปรแกรมการใช้งานเยาะเย้ยชั่วคราวUserLister
และลดความซับซ้อนของการพัฒนามุมมองมีตัวเลือกอื่น ๆ สำหรับการพึ่งพาการฉีดในที่นั้นสิ่งที่ฉันคิดว่าทำให้ Spring มีชื่อเสียงนอกเหนือจากความเรียบง่ายความสง่างามและความมั่นคงคือพวก SpringSource ได้ตั้งโปรแกรม POJO จำนวนมากที่ช่วยผสาน Spring กับกรอบทั่วไปอื่น ๆ ล่วงล้ำในใบสมัครของคุณ นอกจากนี้สปริงยังมีโปรเจ็กต์ย่อย ๆ ที่ดีหลายอย่างเช่น Spring MVC, Spring WebFlow, Spring Security และอีกครั้งที่รายการ etceteras
หวังว่านี่จะช่วยได้ อย่างไรก็ตามฉันแนะนำให้คุณอ่านบทความของ Martin Fowlerเกี่ยวกับ Dependency Injection และ Inversion of Control เพราะเขาทำได้ดีกว่าฉัน หลังจากเข้าใจพื้นฐานจะดูที่เอกสารฤดูใบไม้ผลิในความคิดของฉันก็ถูก นำมาใช้เพื่อเป็นหนังสือที่ดีที่สุดที่เคยฤดูใบไม้ผลิ
Spring บรรจุ ( ตามที่ Skaffman ชี้ให้เห็นอย่างถูกต้อง ) กรอบ MVC เพื่ออธิบายสั้น ๆ นี่คืออินพุตของฉัน Spring รองรับการแยกชั้นบริการชั้นเว็บและชั้นธุรกิจ แต่สิ่งที่ดีที่สุดคือ "การฉีด" ของวัตถุ ดังนั้นเพื่ออธิบายด้วยตัวอย่างลองพิจารณาตัวอย่างด้านล่าง:
public interface FourWheel
{
public void drive();
}
public class Sedan implements FourWheel
{
public void drive()
{
//drive gracefully
}
}
public class SUV implements FourWheel
{
public void drive()
{
//Rule the rough terrain
}
}
ตอนนี้ในรหัสของคุณคุณมีคลาสที่เรียกว่า RoadTrip ดังนี้
public class RoadTrip
{
private FourWheel myCarForTrip;
}
ตอนนี้เมื่อใดก็ตามที่คุณต้องการตัวอย่างของการเดินทาง; บางครั้งคุณอาจต้องการ SUV เพื่อเริ่มต้น FourWheel หรือบางครั้งคุณอาจต้องการซีดาน มันขึ้นอยู่กับสิ่งที่คุณต้องการตามสถานการณ์เฉพาะ
เพื่อแก้ปัญหานี้คุณต้องมีรูปแบบโรงงานเป็นรูปแบบที่สร้างสรรค์ ที่ซึ่งโรงงานส่งคืนอินสแตนซ์ที่ถูกต้อง ดังนั้นในที่สุดคุณก็จะจบลงด้วยรหัสกาวจำนวนมากเพียงเพื่อยกตัวอย่างวัตถุอย่างถูกต้อง Spring ทำงานได้ดีที่สุดของรหัสกาวโดยไม่มีรหัสกาวนั้น คุณประกาศการแมปใน XML และเริ่มต้นวัตถุโดยอัตโนมัติ นอกจากนี้ยังมีการใช้สถาปัตยกรรมซิงเกิลจำนวนมากสำหรับอินสแตนซ์และช่วยในการใช้งานหน่วยความจำให้ได้ประสิทธิภาพสูงสุด
สิ่งนี้เรียกว่า Inversion Of Control กรอบการทำงานอื่น ๆ เช่น Google guice, Pico container เป็นต้น
นอกจากนี้ Spring ยังมีกรอบการตรวจสอบความถูกต้องการสนับสนุนอย่างกว้างขวางสำหรับเลเยอร์ DAO ร่วมกับ JDBC, iBatis และ Hibernate (และอื่น ๆ อีกมากมาย) ให้การควบคุมธุรกรรมที่ยอดเยี่ยมเกี่ยวกับการทำธุรกรรมฐานข้อมูล
มีสปริงมากมายที่สามารถอ่านได้ในหนังสือที่ดีเช่น "Pro Spring"
URL ต่อไปนี้อาจช่วยได้เช่นกัน
http://static.springframework.org/docs/Spring-MVC-step-by-step/
http://en.wikipedia.org/wiki/Spring_Framework
http://www.theserverside.com/tt/articles/article .tss? L = SpringFramework
วันเก่า, ฤดูใบไม้ผลิเป็นกรอบการทำงานที่พึ่งพาการฉีดเท่านั้นเช่น ( Guice , PicoContainer , ... ) แต่ในปัจจุบันมันเป็นโซลูชั่นรวมสำหรับการสร้างของโปรแกรมประยุกต์ขององค์กร
การฉีดพึ่งพาฤดูใบไม้ผลิซึ่งแน่นอนว่าหัวใจของฤดูใบไม้ผลิยังคงมีอยู่ (และคุณสามารถตรวจสอบคำตอบที่ดีอื่น ๆ ได้ที่นี่) แต่ยังมีอีกมากมายจากฤดูใบไม้ผลิ ...
ฤดูใบไม้ผลิตอนนี้มีโครงการมากมายแต่ละโครงการย่อยบางโครงการ ( http://spring.io/projects ) เมื่อมีคนพูดถึงฤดูใบไม้ผลิคุณจะต้องค้นหาว่าฤดูใบไม้ผลิที่เขากำลังพูดถึงโครงการนี้เป็นเพียงแกนกลางของฤดูใบไม้ผลิซึ่งเป็นที่รู้จักกันในชื่อโครงร่างฤดูใบไม้ผลิหรือเป็นอีกหนึ่งโครงการในฤดูใบไม้ผลิ
บางโครงการในฤดูใบไม้ผลิซึ่งมีมูลค่าการกล่าวขวัญคือ:
หากคุณต้องการฟีเจอร์ที่ระบุเพิ่มเติมสำหรับแอปพลิเคชันของคุณคุณสามารถค้นหาได้ที่:
นอกจากนี้ยังมีโครงการเล็ก ๆ บางอย่างที่นั่นเช่นspring-social-facebook ( http://projects.spring.io/spring-social-facebook/ )
คุณสามารถใช้สปริงสำหรับการพัฒนาเว็บเนื่องจากมีSpring MVC
โมดูลซึ่งเป็นส่วนหนึ่งของโครงการSpring Framework หรือคุณสามารถใช้ในฤดูใบไม้ผลิที่มีกรอบเว็บอื่นเช่นstruts2
สปริงมีไว้ทำอะไร ฉันจะตอบคำถามนั้นในไม่ช้า แต่ก่อนอื่นมาดูตัวอย่างโดยผู้ชนะ hugo มันไม่ได้เป็นตัวอย่างที่ดีเพราะไม่ได้แสดงให้เห็นถึงความจำเป็นในการใช้กรอบงานใหม่
public class BaseView {
protected UserLister userLister;
public BaseView() {
userLister = new UserListerDB(); // only line of code that needs changing
}
}
public class SomeView extends BaseView {
public SomeView() {
super();
}
public void render() {
List<User> users = userLister.getUsers();
view.render(users);
}
}
ทำ! ดังนั้นแม้ว่าคุณจะมีมุมมองเป็นร้อยหรือนับพัน แต่คุณก็ยังจำเป็นต้องเปลี่ยนโค้ดหนึ่งบรรทัดดังเช่นในแนวทางของ XML XML แต่การเปลี่ยนบรรทัดของรหัสยังต้องการการคอมไพล์ใหม่ซึ่งต่างจากการแก้ไข XML ที่คุณพูด เพื่อนจุกจิกของฉันใช้ Ant และสคริปต์ไป!
ดังนั้น Spring คืออะไร มันมีไว้สำหรับ:
อ่านเพิ่มเติม: http://discuss.joelonsoftware.com/?joel.3.219431.12
UserLister
) แต่ถ้ามันต้องการบริการหลายไม่ได้ใช้ร่วมกันระหว่างที่แตกต่างกันBaseView
ของเด็ก? มี (โชคดี) ไม่มีการสืบทอดหลายอย่างใน Java
สรุปสั้นมากฉันจะบอกว่าฤดูใบไม้ผลิเป็น "กาว" ในใบสมัครของคุณ มันใช้เพื่อรวมกรอบงานที่แตกต่างกันและรหัสของคุณเอง
ฤดูใบไม้ผลิเป็นสามสิ่ง
ปัญหาคือว่า Spring DI นั้นคิดออกมาดีมากการห่อหุ้มสิ่งอื่น ๆ นั้นเป็นสิ่งที่คิดออกมาอย่างดีในเรื่องนั้นสิ่งอื่น ๆ ก็คิดว่าทุกอย่างออกไป การใช้งาน MVC และ REST ของ Spring และสิ่งอื่น ๆ ทั้งหมดนั้นทำได้ไม่ดีเท่าที่ควร (YMMV, IMHO) แต่ก็มีข้อยกเว้น (Spring Security is da bomb) ดังนั้นฉันมักจะใช้ Spring for DI และตัวห่อเย็น ๆ แต่ชอบสิ่งอื่น ๆ สำหรับเว็บ (ฉันชอบ Tapestry มาก), REST (Jersey แข็งแกร่งมาก) ฯลฯ
สิ่งที่คุณอาจต้องการในเว็บแอปพลิเคชันด้วย Spring -
นอกจากนี้สปริงยังมีขนาดใหญ่มากดังนั้นจึงมีสิ่งอื่น ๆ อีกมากมายที่คุณอาจสนใจใช้ในแอพพลิเคชั่นบนเว็บเช่น Spring AOP หรือ Spring Security แต่สี่สิ่งที่กล่าวข้างต้นอธิบายส่วนประกอบทั่วไปของ Spring ที่ใช้ในเว็บแอป
ฉันเห็นสองส่วนนี้:
โปรดทราบว่าคุณสามารถใช้ Spring ในเว็บแอปพลิเคชันได้อย่างสมบูรณ์แบบโดยไม่ต้องใช้ Spring MVC ฉันจะบอกว่าโปรแกรมเว็บ Java ส่วนใหญ่ทำเช่นนี้ในขณะที่ใช้กรอบงานเว็บอื่น ๆ เช่น Wicket, Struts, Seam, ...
สปริงเหมาะอย่างยิ่งสำหรับการเข้าชั้นเรียนร่วมกัน คุณรู้ว่าชั้นเรียนไฮเบอร์เนตของคุณจะต้องมีแหล่งข้อมูลอยู่เสมอเชื่อมต่อสายสปริงเข้าด้วยกัน (และมีการนำแหล่งข้อมูลไปใช้ด้วย)
ออบเจ็กต์การเข้าถึงข้อมูลของคุณจะต้องเข้าใช้ไฮเบอร์เนตเสมอเชื่อมต่อสายไฮเบอร์เนตกับคลาส DAO ของคุณให้กับคุณ
นอกจากนี้ Spring ยังให้การกำหนดค่าที่มั่นคงกับไลบรารีจำนวนมากและในนั้นจะให้คำแนะนำคุณเกี่ยวกับ libs ที่คุณควรใช้
สปริงเป็นเครื่องมือที่ยอดเยี่ยมจริงๆ (ฉันไม่ได้พูดถึง Spring MVC เพียงแค่เฟรมเวิร์กพื้นฐาน)
คำตอบที่ยอมรับไม่เกี่ยวข้องกับการใช้คำอธิบายประกอบเนื่องจากสปริงแนะนำการสนับสนุนคำอธิบายประกอบต่าง ๆ สำหรับการตั้งค่า
มีอีกวิธีในการโยงคลาสเข้าด้วยกันโดยใช้ไฟล์ XML: คำอธิบายประกอบ ลองใช้ตัวอย่างจากคำตอบที่ได้รับการยอมรับและลงทะเบียนถั่วโดยตรงบนชั้นโดยใช้หนึ่งในคำอธิบายประกอบ@Component
, @Service
, @Repository
หรือ@Configuration
:
@Component
public class UserListerDB implements UserLister {
public List<User> getUsers() {
// DB access code here
}
}
วิธีนี้เมื่อมุมมองถูกสร้างขึ้นอย่างน่าอัศจรรย์จะมี UserLister พร้อมใช้งาน
ข้อความข้างต้นมีผลบังคับใช้กับโบนัสเล็กน้อยโดยไม่จำเป็นต้องมีการใช้งานไฟล์ XML และการเดินสายพร้อมคำอธิบายประกอบอื่น@Autowired
ที่ค้นหาการนำไปใช้งานที่เกี่ยวข้องและแทรกเข้าไป
@Autowired
private UserLister userLister;
ใช้การเพิ่มความคิดเห็น@Bean
ในวิธีที่ใช้เพื่อให้การนำถั่วไปใช้ในการฉีด
@Bean
คำอธิบายประกอบในระดับชั้นเรียนได้ ต้องเป็นหนึ่ง@Component
, @Service
, @Repository
ฯลฯ ส่วนที่เหลือถูกต้อง คุณควรจะชี้ให้เห็นว่า Autowiring อินเทอร์เฟซในลักษณะนี้จะทำงานเฉพาะในกรณีที่มีคลาสผู้สมัครเพียง 1 คลาสใน classpath ที่เหมาะสำหรับการฉีดมิฉะนั้นข้อผิดพลาดของแอปพลิเคชัน Spring
ข้อดีคือการพึ่งพาการฉีด (DI) มันหมายถึงการจ้างงานสร้างวัตถุให้ฉันอธิบายด้วยตัวอย่าง
public interface Lunch
{
public void eat();
}
public class Buffet implements Lunch
{
public void eat()
{
// Eat as much as you can
}
}
public class Plated implements Lunch
{
public void eat()
{
// Eat a limited portion
}
}
ตอนนี้ในรหัสของฉันฉันมีชั้นเรียน LunchDecide ดังนี้
public class LunchDecide {
private Lunch todaysLunch;
public LunchDecide(){
this.todaysLunch = new Buffet(); // choose Buffet -> eat as much as you want
//this.todaysLunch = new Plated(); // choose Plated -> eat a limited portion
}
}
ในชั้นเรียนด้านบนขึ้นอยู่กับอารมณ์ของเราเราเลือกบุฟเฟ่ต์ () หรือชุบ () อย่างไรก็ตามระบบนี้มีการเชื่อมต่ออย่างแน่นหนา ทุกครั้งที่เราต้องการ Object ชนิดอื่นเราจำเป็นต้องเปลี่ยนรหัส ในกรณีนี้แสดงความคิดเห็นออกมาเป็นเส้น! ลองนึกภาพมี 50 คลาสที่แตกต่างกันที่ใช้โดย 50 คนที่แตกต่างกัน มันจะเป็นเรื่องวุ่นวาย ในกรณีนี้เราต้อง Decouple ระบบ มาเขียนคลาส LunchDecide กันใหม่
public class LunchDecide {
private Lunch todaysLunch;
public LunchDecide(Lunch todaysLunch){
this.todaysLunch = todaysLunch
}
}
โปรดสังเกตว่าแทนที่จะสร้างวัตถุโดยใช้คำหลักใหม่เราส่งการอ้างอิงไปยังวัตถุประเภทอาหารกลางวันเป็นพารามิเตอร์ให้กับตัวสร้างของเรา ที่นี่การสร้างวัตถุถูกเอาต์ซอร์ซ รหัสนี้สามารถต่อสายได้ทั้งโดยใช้ไฟล์กำหนดค่า Xml (ดั้งเดิม) หรือหมายเหตุประกอบ Java (ทันสมัย) ไม่ว่าจะด้วยวิธีใดการตัดสินใจว่าจะสร้างวัตถุชนิดใดจะกระทำในช่วงรันไทม์ วัตถุจะถูกฉีดโดย Xml ในรหัสของเรา - รหัสของเราขึ้นอยู่กับ Xml สำหรับงานนั้น ดังนั้นการพึ่งพาการฉีด (DI) DI ไม่เพียง แต่ช่วยในการทำให้ระบบของเราเชื่อมโยงอย่างอิสระเท่านั้น แต่ยังช่วยให้การเขียนแบบทดสอบหน่วยง่ายขึ้นเนื่องจากช่วยให้การอ้างอิงนั้นถูกล้อเลียน สุดท้าย แต่ไม่ท้ายสุด DI ช่วยเพิ่มความคล่องตัวในการเขียนโปรแกรม Aspect Oriented (AOP) ซึ่งจะนำไปสู่การแยกและการเพิ่มขึ้นของโมดูล โปรดทราบว่า DI ด้านบนคือ Constructor Injection
Spring Framework help you with several things like, don't reinvent the wheel. you can connect very easily with some database just using Spring Data, or create schedule tasks like CronJob or Windows Task. amazing !
ฤดูใบไม้ผลิเป็นทางเลือกที่ดีขององค์กร JavaBeans (EJB)เทคโนโลยี นอกจากนี้ยังมีเฟรมเวิร์กเว็บและคอมโพเนนต์เฟรมเวิร์กบริการเว็บ
ฤดูใบไม้ผลิเริ่มต้นจากการเป็นระบบฉีดพึ่งพาง่าย ตอนนี้มันมีขนาดใหญ่และมีทุกอย่างในนั้น (ยกเว้นอ่างล้างจานสุภาษิต)
แต่ไม่ต้องกลัวมันเป็นแบบแยกส่วนดังนั้นคุณสามารถใช้ชิ้นส่วนที่คุณต้องการ
หากต้องการดูว่าเริ่มต้นจากที่ใด:
มันอาจจะเก่า แต่ก็เป็นหนังสือที่ยอดเยี่ยม
สำหรับหนังสือดีๆอีกเล่มในครั้งนี้ที่ทุ่มเทให้กับ Spring ดู:
นอกจากนี้ยังอ้างอิงถึง Spring เวอร์ชั่นเก่า แต่ก็คุ้มค่าที่จะดู
ฤดูใบไม้ผลิเป็นการฉีดที่ต้องพึ่งพาอาศัยกันในการเริ่มต้นจากนั้นเพิ่มราชาแห่งการห่อหุ้มสำหรับเกือบทุกอย่าง
เรื่องยาว ... ส่วนใหญ่ของโซลูชั่น XML preffer ของ Spring (เครื่องมือสร้างสคริปต์ XML ... brrrr) ดังนั้นสำหรับ DI ฉันใช้ Guice
ห้องสมุดที่ดี แต่ด้วยการเติบโตที่เพิ่มขึ้นเช่นSpring JDBC (อาจเป็นหนึ่งโซลูชัน Java jdbc ที่มีพารามิเตอร์ชื่อจริง) ใช้เวลาตั้งแต่ maven 4-5 ต่อไป
การใช้ Spring MVC (ส่วนหนึ่งของ "บิ๊กสปริง") สำหรับการพัฒนาเว็บ ... เป็นเฟรมเวิร์ก "ตามคำขอ" มีสงครามศักดิ์สิทธิ์ "คำขอ vs องค์ประกอบ" ... ขึ้นอยู่กับคุณ
ในอดีตฉันคิดเกี่ยวกับกรอบ Spring จากมุมมองทางเทคนิคอย่างหมดจด
จากประสบการณ์การทำงานเป็นทีมและการพัฒนา Webapps ระดับองค์กร - ฉันจะบอกว่า Spring นั้นสำหรับการพัฒนาแอปพลิเคชั่นที่รวดเร็วขึ้น (เว็บแอปพลิเคชัน) โดยการแยกองค์ประกอบแต่ละตัว (ถั่ว) การพัฒนาที่รวดเร็วยิ่งขึ้นทำให้เป็นที่นิยมมาก สปริงอนุญาตให้เปลี่ยนความรับผิดชอบในการสร้าง (เดินสายขึ้น) แอปพลิเคชันไปยังเฟรมเวิร์กสปริง การฉีดพึ่งพาเฟรมเวิร์กของ Spring รับผิดชอบการเชื่อมต่อ / เดินสายถั่วแต่ละตัวเข้ากับแอปพลิเคชั่นที่ใช้งานได้
วิธีนี้นักพัฒนาซอฟต์แวร์สามารถมุ่งเน้นเพิ่มเติมในการพัฒนาแต่ละองค์ประกอบ (beans) ทันทีที่มีการกำหนดอินเตอร์เฟสระหว่างถั่ว
การทดสอบแอปพลิเคชันดังกล่าวนั้นง่าย - ให้ความสำคัญหลักกับถั่วแต่ละตัว พวกเขาสามารถแยกแยะและเยาะเย้ยได้อย่างง่ายดายดังนั้นการทดสอบหน่วยจึงรวดเร็วและมีประสิทธิภาพ
เฟรมเวิร์กสปริงกำหนดถั่วพิเศษหลายรายการเช่น@Controller ( @Restcontroller ), @Repository , @Componentเพื่อตอบสนองวัตถุประสงค์ของเว็บ Spring พร้อมกับ Maven จัดเตรียมโครงสร้างที่ใช้งานง่ายสำหรับนักพัฒนา การทำงานเป็นทีมนั้นง่ายและรวดเร็วเนื่องจากมีองค์ประกอบแยกออกจากกันและสามารถนำกลับมาใช้ใหม่ได้
Spring Framework นั้นดีสำหรับการพัฒนาเว็บและจะเฉพาะเจาะจงมากขึ้นสำหรับบริการ API ที่สงบ
เป็นสิ่งที่ดีสำหรับข้างต้นเนื่องจากการฉีดพึ่งพา และบูรณาการกับโมดูลอื่น ๆ เช่นการรักษาความปลอดภัยในฤดูใบไม้ผลิ , aop ฤดูใบไม้ผลิ , กรอบ mvc , microservices
ในทุกแอปพลิเคชันความปลอดภัยอาจเป็นข้อกำหนด
หากคุณต้องการสร้างผลิตภัณฑ์ที่ต้องการการบำรุงรักษาที่ยาวนานคุณจะต้องใช้แนวคิด Aop
หากแอปพลิเคชันของคุณมีปริมาณการใช้งานมากซึ่งเป็นการเพิ่มภาระให้คุณต้องใช้แนวคิด microservices
Spring กำลังให้ฟีเจอร์ทั้งหมดเหล่านี้ในแพลตฟอร์มเดียว การสนับสนุนกับโมดูลจำนวนมาก
ที่สำคัญที่สุดฤดูใบไม้ผลิคือโอเพ่นซอร์สและกรอบการทำงานที่กว้างขวางมีเบ็ดทุกที่เพื่อรวมรหัสที่กำหนดเองในวงจรชีวิต
Spring Dataเป็นโครงการหนึ่งที่ให้การทำงานร่วมกับโครงการของคุณ
ดังนั้นสปริงจึงสามารถบรรจุได้เกือบทุกความต้องการ