Spring Framework มีไว้เพื่ออะไร? [ปิด]


623

ฉันได้ยินมามากมายเกี่ยวกับSpringผู้คนกำลังพูดกันทั่วทั้งเว็บว่า Spring เป็นกรอบที่ดีสำหรับการพัฒนาเว็บ Spring Framework มีไว้เพื่ออะไร?


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

2
คำถามถูกถามเมื่อ 10 ปีที่แล้วและในเวลานั้น Spring มีขนาดเล็กลงเล็กน้อยจากโครงการย่อยทั้งหมดเช่น Spring Boot, Spring Data, Spring Rest เป็นต้นและที่จริงแล้วนั่นคือเหตุผลที่ว่าทำไมมันถึงใกล้ปีที่แล้วเพราะ ความกว้างของคำถามนี้ ตอนที่ฉันถามคำถามนี้ฉันแค่อยากจะเข้าใจ DI และทำไมมันถึงต้องการ
Maksim

คำตอบ:


713

ฤดูใบไม้ผลิโดยทั่วไปเป็นกรอบสำหรับ ซึ่งเป็นรูปแบบที่ช่วยให้สร้างระบบที่แยกส่วนได้มาก

ปัญหา

ตัวอย่างเช่นสมมติว่าคุณต้องการแสดงรายการผู้ใช้ของระบบและประกาศอินเตอร์เฟสที่เรียกว่า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อินเทอร์เฟซอื่นของคุณ เพียงแค่เปลี่ยน XML
  • ถ้าไม่มีUserListerการนำไปปฏิบัติพร้อม โปรแกรมการใช้งานเยาะเย้ยชั่วคราวUserListerและลดความซับซ้อนของการพัฒนามุมมอง
  • จะทำอย่างไรถ้าฉันไม่ต้องการใช้ Spring อีกต่อไป อย่าใช้มัน! ใบสมัครของคุณไม่ได้อยู่คู่กับมัน สถานะผกผันของการควบคุม : "แอปพลิเคชันควบคุมเฟรมเวิร์กไม่ใช่เฟรมเวิร์กควบคุมแอปพลิเคชัน"

มีตัวเลือกอื่น ๆ สำหรับการพึ่งพาการฉีดในที่นั้นสิ่งที่ฉันคิดว่าทำให้ Spring มีชื่อเสียงนอกเหนือจากความเรียบง่ายความสง่างามและความมั่นคงคือพวก SpringSource ได้ตั้งโปรแกรม POJO จำนวนมากที่ช่วยผสาน Spring กับกรอบทั่วไปอื่น ๆ ล่วงล้ำในใบสมัครของคุณ นอกจากนี้สปริงยังมีโปรเจ็กต์ย่อย ๆ ที่ดีหลายอย่างเช่น Spring MVC, Spring WebFlow, Spring Security และอีกครั้งที่รายการ etceteras

หวังว่านี่จะช่วยได้ อย่างไรก็ตามฉันแนะนำให้คุณอ่านบทความของ Martin Fowlerเกี่ยวกับ Dependency Injection และ Inversion of Control เพราะเขาทำได้ดีกว่าฉัน หลังจากเข้าใจพื้นฐานจะดูที่เอกสารฤดูใบไม้ผลิในความคิดของฉันก็ถูก นำมาใช้เพื่อเป็นหนังสือที่ดีที่สุดที่เคยฤดูใบไม้ผลิ


148
อะไรคือความแตกต่างระหว่างการเปลี่ยนบรรทัดของโค้ดและบรรทัดของ XML? ความพยายามและการบำรุงรักษานั้นเหมือนกันหรือแย่กว่านั้นเนื่องจากไฟล์ xml ภายนอกเพิ่มความซับซ้อนอย่างแน่นอน ขออภัย แต่ฉันไม่เข้าใจเลยฉันไม่เห็นประโยชน์ใด ๆ เลย กรุณากรอกฉันถ้าฉันขาดอะไร
fred

23
@fred - ลองจินตนาการว่าคุณกำลังทำการทดสอบหน่วย หากไม่มีการฉีดพึ่งพา (DI สามารถใช้กับคำอธิบายประกอบหรือกับ XML) คุณไม่สามารถทดสอบได้อย่างถูกต้องเพราะคุณไม่สามารถจำลองการอ้างอิงได้
Petar Minchev

18
@fred - การกำหนดการฉีดทั้งหมดใน XML แน่นอนทำให้รู้สึกน้อย มันเป็นค่าใช้จ่ายมากในการรักษา EJB จึงแนะนำแนวคิดของคำอธิบายประกอบสำหรับจุดฉีด สิ่งเหล่านี้ง่ายกว่ามากและจะมีการฉีดอินสแตนซ์เริ่มต้น (สำหรับการทดสอบหน่วยนี้สามารถเปลี่ยนแปลงได้หนึ่งครั้ง) วิธีนี้ใช้ได้ผลดีจนสปริงคัดลอกวิธีนี้แล้ว โปรดทราบว่าถ้าจำเป็น (แต่ถ้าจำเป็นจริงๆเท่านั้น) หมายเหตุประกอบสามารถยังคงอยู่เหนือ XML ใน EJB
Mike Braun

36
หรือคุณรู้ว่าใช้วิธีการคงที่จากโรงงาน เปลี่ยนประเภทส่งคืนของโรงงานและตอนนี้คลาสทั้งหมดที่ใช้ค่าส่งคืนจะเปลี่ยนไป Presto Spring ไม่จำเป็นต้องใช้อีกต่อไป ...
Qix - MONICA ถูกยกเลิกเมื่อ

16
@ mmcrae ฉันต้องการเรียกการปรับโครงสร้างหนึ่งครั้งใน IDE ของฉันมากกว่าเขียน XML
Qix - MONICA ถูกยกเลิกเมื่อ

63

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


5
Spring ประกอบด้วยกรอบงาน MVC แต่มันเยอะกว่านั้นมาก
skaffman

WebMVC เป็นส่วนหนึ่งของ distro แกนหลักโดยไม่ต้องการ nitpick มากเกินไป Webflow, RCP และ al ไม่ใช่
skaffman

1
เป็นสิ่งที่ดีฉันไม่ทราบว่าคุณสามารถยกตัวอย่างวัตถุประเภทอินเตอร์เฟสใน Java - ซึ่งเป็น @skaffman ที่ผิดกฎหมายช่วยให้ฉันเข้าใจคำตอบนี้ (ดูตัวอย่างของ FourWheel)
Jossie Calderon

47

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

การฉีดพึ่งพาฤดูใบไม้ผลิซึ่งแน่นอนว่าหัวใจของฤดูใบไม้ผลิยังคงมีอยู่ (และคุณสามารถตรวจสอบคำตอบที่ดีอื่น ๆ ได้ที่นี่) แต่ยังมีอีกมากมายจากฤดูใบไม้ผลิ ...

ฤดูใบไม้ผลิตอนนี้มีโครงการมากมายแต่ละโครงการย่อยบางโครงการ ( http://spring.io/projects ) เมื่อมีคนพูดถึงฤดูใบไม้ผลิคุณจะต้องค้นหาว่าฤดูใบไม้ผลิที่เขากำลังพูดถึงโครงการนี้เป็นเพียงแกนกลางของฤดูใบไม้ผลิซึ่งเป็นที่รู้จักกันในชื่อโครงร่างฤดูใบไม้ผลิหรือเป็นอีกหนึ่งโครงการในฤดูใบไม้ผลิ

บางโครงการในฤดูใบไม้ผลิซึ่งมีมูลค่าการกล่าวขวัญคือ:

หากคุณต้องการฟีเจอร์ที่ระบุเพิ่มเติมสำหรับแอปพลิเคชันของคุณคุณสามารถค้นหาได้ที่:

  • กรอบแบตช์ Spring Batchออกแบบมาเพื่อเปิดใช้งานการพัฒนา
    แอปพลิเคชันแบบแบตช์
  • Spring HATEOASสร้าง REST API ได้ง่ายขึ้นอยู่กับหลักการ HATEOAS
  • Spring MobileและSpring Andriodสำหรับการพัฒนาแอปพลิเคชั่นมือถือ
  • Spring Shell สร้างแอปพลิเคชั่นเชลล์ที่มีคุณสมบัติครบถ้วน (หรือที่เรียกว่าบรรทัดคำสั่ง)
  • Spring CloudและSpring Cloud Data Flowสำหรับแอพพลิเคชั่นคลาวด์

นอกจากนี้ยังมีโครงการเล็ก ๆ บางอย่างที่นั่นเช่นspring-social-facebook ( http://projects.spring.io/spring-social-facebook/ )

คุณสามารถใช้สปริงสำหรับการพัฒนาเว็บเนื่องจากมีSpring MVCโมดูลซึ่งเป็นส่วนหนึ่งของโครงการSpring Framework หรือคุณสามารถใช้ในฤดูใบไม้ผลิที่มีกรอบเว็บอื่นเช่นstruts2


1
ฉันอยากเห็น mvc, data, jpa และส่วนอื่น ๆ ของ Spring มีตัวเลือกที่จะไม่ใช้ core DI ของ Spring แต่วาง Dagger ไว้ในใจกลาง Spring แทน
dlamblin

25

สปริงมีไว้ทำอะไร ฉันจะตอบคำถามนั้นในไม่ช้า แต่ก่อนอื่นมาดูตัวอย่างโดยผู้ชนะ 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 คืออะไร มันมีไว้สำหรับ:

  1. นักพัฒนาคนตาบอดที่ติดตามฝูง
  2. นายจ้างที่ไม่ต้องการจ้างโปรแกรมเมอร์ระดับบัณฑิตศึกษาเพราะไม่ได้สอนกรอบดังกล่าวที่ Uni
  3. โครงการที่เริ่มต้นด้วยการออกแบบที่ไม่ดีและต้องการการเย็บปะติดปะต่อกัน (ดังที่แสดงโดยตัวอย่างของผู้ชนะ hugo)

อ่านเพิ่มเติม: http://discuss.joelonsoftware.com/?joel.3.219431.12


11
ด้วยความหงุดหงิดฉันสงสัยเกี่ยวกับข้อโต้แย้งของคุณ ฉันไม่รู้เครื่องมือการเขียนโปรแกรมใด ๆ ที่คุณไม่สามารถใช้ในการออกแบบที่ไม่ดี สิ่งที่คุณมุ่งหวังคือการใช้เฟรมเวิร์กคุณสามารถสร้างโค้ดที่ไม่ดีทำสิ่งต่างๆมากมาย นั่นเป็นเรื่องจริงในระดับสากลและไม่เฉพาะเจาะจงกับฤดูใบไม้ผลิ มิฉะนั้นประเด็นคืออะไร? คุณไม่คิดว่านักพัฒนาที่มีความสามารถสามารถใช้ประโยชน์จากสิ่งที่ Spring มีให้ได้โดยเฉพาะอย่างยิ่งในเครื่องมือใดของกรอบการทำงานที่พวกเขาใช้ อย่างน้อยฉันก็ค่อนข้างแน่ใจว่าคุณไม่ได้บอกเป็นนัยว่าไม่มีนักพัฒนาสปริงเคยได้ยินเรื่องการขยายชั้นเรียน แม้ว่าการอ่านเพิ่มเติมจะเป็นเฮฮา
sthzg

2
นอกจากนี้ตัวอย่างของคุณทำงานเพราะมุมมองความต้องการเพียงหนึ่งฉีดบริการ ( UserLister) แต่ถ้ามันต้องการบริการหลายไม่ได้ใช้ร่วมกันระหว่างที่แตกต่างกันBaseViewของเด็ก? มี (โชคดี) ไม่มีการสืบทอดหลายอย่างใน Java
Edouard Berthe

@EdouardBerthe จุดยุติธรรม คำตอบของฉันไม่ใช่ความพยายามที่จะเพิกเฉยต่อ DI มันแค่ชี้ให้เห็นตัวอย่างที่แสดงในคำตอบที่ยอมรับไม่ใช่สิ่งที่ยิ่งใหญ่ที่สุด; สถานการณ์ที่คุณเสนอจะเป็นไปได้ดีที่สุด ประเด็นที่ฉันพยายามทำจริงๆไม่ใช่ว่าคุณไม่ต้องการ DI แต่คุณไม่ต้องการกรอบทั้งหมดในการทำ
Ash

19

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


15

ฤดูใบไม้ผลิเป็นสามสิ่ง

  1. Spring จัดการกับ Dependency Injection และฉันขอแนะนำให้คุณอ่านคำแนะนำที่ยอดเยี่ยมของ Martin Fowler เกี่ยวกับการฉีดพึ่งพา
  2. สิ่งที่สองที่ Spring ทำคือห่อไลบรารี่ Java ที่ยอดเยี่ยมด้วยวิธีการใช้งานที่หรูหรา สำหรับตัวอย่างที่ดีดูว่า Spring ห่อตัวจัดการงานและตัวกำหนดเวลาของควอตซ์ได้อย่างไร
  3. Thirdly Spring นำเสนอการใช้งานเว็บมากมายเช่น REST, กรอบงานเว็บ MVC และอื่น ๆ พวกเขาคิดว่าคุณกำลังใช้ Spring สำหรับสองคนแรกบางทีคุณอาจใช้มันกับทุกสิ่งที่แอปพลิเคชันเว็บของคุณต้องการ

ปัญหาคือว่า Spring DI นั้นคิดออกมาดีมากการห่อหุ้มสิ่งอื่น ๆ นั้นเป็นสิ่งที่คิดออกมาอย่างดีในเรื่องนั้นสิ่งอื่น ๆ ก็คิดว่าทุกอย่างออกไป การใช้งาน MVC และ REST ของ Spring และสิ่งอื่น ๆ ทั้งหมดนั้นทำได้ไม่ดีเท่าที่ควร (YMMV, IMHO) แต่ก็มีข้อยกเว้น (Spring Security is da bomb) ดังนั้นฉันมักจะใช้ Spring for DI และตัวห่อเย็น ๆ แต่ชอบสิ่งอื่น ๆ สำหรับเว็บ (ฉันชอบ Tapestry มาก), REST (Jersey แข็งแกร่งมาก) ฯลฯ


9
YMMV, IMHO - การสะสมไมล์ของคุณอาจแตกต่างกันในความต่ำต้อยของฉันสำหรับบรรดาผู้ที่ไม่ชำนาญในตัวย่อเช่นฉัน ...
Sakamoto Kazuma

11

สิ่งที่คุณอาจต้องการในเว็บแอปพลิเคชันด้วย Spring -

  • Spring MVC ซึ่งมี 2.5+ ให้คุณใช้ POJO เป็นคลาส Controller ซึ่งหมายความว่าคุณไม่จำเป็นต้องขยายจากเฟรมเวิร์กเฉพาะใด ๆ (เช่นใน Struts หรือ Spring pre-2.5) คลาสตัวควบคุมนั้นตายง่ายต่อการทดสอบขอบคุณในส่วนของการฉีดพึ่งพา
  • Spring Integration กับ Hibernate ซึ่งทำงานได้ดีในการทำให้งานง่ายขึ้นด้วยโซลูชัน ORM นั้น (สำหรับกรณีส่วนใหญ่)
  • การใช้ Spring สำหรับเว็บแอพช่วยให้คุณใช้ Domain Objects ของคุณในทุกระดับของแอปพลิเคชัน - คลาสเดียวกันที่แมปโดยใช้ Hibernate เป็นคลาสที่คุณใช้เป็น "form beans" โดยธรรมชาติสิ่งนี้จะนำไปสู่รูปแบบโดเมนที่มีประสิทธิภาพมากขึ้นส่วนหนึ่งเป็นเพราะมันจะลดจำนวนชั้นเรียนลง
  • แท็กรูปแบบสปริงทำให้การสร้างฟอร์มง่ายขึ้นโดยไม่ยุ่งยาก

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


9

ฉันเห็นสองส่วนนี้:

  1. "สปริงคืออะไรสำหรับ" -> ดูคำตอบที่ยอมรับโดยผู้ชนะ hugo
  2. "[... ] Spring เป็นกรอบที่ดีสำหรับการพัฒนาเว็บ" -> ผู้คนที่พูดแบบนี้กำลังพูดถึง Spring MVC Spring MVC เป็นหนึ่งในหลาย ๆ ส่วนของ Spring และเป็นเว็บเฟรมเวิร์กที่ใช้ประโยชน์จากคุณสมบัติทั่วไปของ Spring เช่นการพึ่งพาการฉีด เป็นกรอบทั่วไปที่ค่อนข้างกำหนดค่าได้มาก: คุณสามารถใช้เลเยอร์ db ที่แตกต่างกัน (Hibernate, iBatis, JDBC ธรรมดา), เลเยอร์มุมมองที่แตกต่างกัน (JSP, Velocity, Freemarker ... )

โปรดทราบว่าคุณสามารถใช้ Spring ในเว็บแอปพลิเคชันได้อย่างสมบูรณ์แบบโดยไม่ต้องใช้ Spring MVC ฉันจะบอกว่าโปรแกรมเว็บ Java ส่วนใหญ่ทำเช่นนี้ในขณะที่ใช้กรอบงานเว็บอื่น ๆ เช่น Wicket, Struts, Seam, ...


8

สปริงเหมาะอย่างยิ่งสำหรับการเข้าชั้นเรียนร่วมกัน คุณรู้ว่าชั้นเรียนไฮเบอร์เนตของคุณจะต้องมีแหล่งข้อมูลอยู่เสมอเชื่อมต่อสายสปริงเข้าด้วยกัน (และมีการนำแหล่งข้อมูลไปใช้ด้วย)

ออบเจ็กต์การเข้าถึงข้อมูลของคุณจะต้องเข้าใช้ไฮเบอร์เนตเสมอเชื่อมต่อสายไฮเบอร์เนตกับคลาส DAO ของคุณให้กับคุณ

นอกจากนี้ Spring ยังให้การกำหนดค่าที่มั่นคงกับไลบรารีจำนวนมากและในนั้นจะให้คำแนะนำคุณเกี่ยวกับ libs ที่คุณควรใช้

สปริงเป็นเครื่องมือที่ยอดเยี่ยมจริงๆ (ฉันไม่ได้พูดถึง Spring MVC เพียงแค่เฟรมเวิร์กพื้นฐาน)


5

คำตอบที่ยอมรับไม่เกี่ยวข้องกับการใช้คำอธิบายประกอบเนื่องจากสปริงแนะนำการสนับสนุนคำอธิบายประกอบต่าง ๆ สำหรับการตั้งค่า

วิธีสปริง (การพึ่งพาการฉีด)

มีอีกวิธีในการโยงคลาสเข้าด้วยกันโดยใช้ไฟล์ 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
Stefano L

@StefanoL: ใช่คุณพูดถูก ฉันสงสัยว่าคนเพิกเฉยต่อความผิดพลาดของฉัน ขอบคุณสำหรับความคิดเห็น
Nikolas

4

ข้อดีคือการพึ่งพาการฉีด (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


แต่ถึงแม้จะเป็นฤดูใบไม้ผลิเราก็ยังคงนิยามถั่วอยู่ และรหัสถั่วจะได้รับในรหัสใช่ไหม ดังนั้นถ้าคุณเปลี่ยนถั่วในวันพรุ่งนี้คุณยังต้องเปลี่ยนรหัสใช่ไหม ดังนั้นสิ่งที่เป็นประโยชน์
Arpan Buch

@Arpanicut ฉันคิดว่าประโยชน์ของฤดูใบไม้ผลิคือคุณสามารถเลือกการใช้งานที่แตกต่างกันได้โดยไม่ต้องคอมไพล์โค้ดใหม่ (ตราบใดที่มีการใช้งานอื่นอยู่แล้ว) ฉันเป็นผู้เริ่มต้นดังนั้นฉันอาจผิด
byxor

4
  • Spring เป็นเฟรมเวิร์คที่มีน้ำหนักเบาและยืดหยุ่นเมื่อเปรียบเทียบกับ J2EE
  • สปริงคอนเทนเนอร์ทำหน้าที่กลับด้านควบคุม
  • Spring ใช้ AOP เช่นพร็อกซีและ Singleton, Factory และ Template Pattern Design
  • สถาปัตยกรรมที่ทำเป็นชั้น: การแยกข้อกังวลและชั้นที่นำกลับมาใช้ใหม่และการบำรุงรักษาง่าย

ป้อนคำอธิบายรูปภาพที่นี่


1
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 !
tomj0101

3

ฤดูใบไม้ผลิเป็นทางเลือกที่ดีขององค์กร JavaBeans (EJB)เทคโนโลยี นอกจากนี้ยังมีเฟรมเวิร์กเว็บและคอมโพเนนต์เฟรมเวิร์กบริการเว็บ


1
ฉันจะแก้ไขได้ไหม? เป็นทางเลือกแทน (น่ากลัว) EJB 2 ... ดูเหมือนว่า "EJB ใหม่" (ในบางส่วน JPA 2 ฯลฯ ) ได้รับการยอมรับจากคนอื่น "ชั่วโมงแห่งความสุข" ของฤดูใบไม้ผลิ "ดูเหมือน EJB" ในอดีต โฆษณา 2015
Jacek Cz

1

ฤดูใบไม้ผลิเริ่มต้นจากการเป็นระบบฉีดพึ่งพาง่าย ตอนนี้มันมีขนาดใหญ่และมีทุกอย่างในนั้น (ยกเว้นอ่างล้างจานสุภาษิต)

แต่ไม่ต้องกลัวมันเป็นแบบแยกส่วนดังนั้นคุณสามารถใช้ชิ้นส่วนที่คุณต้องการ

หากต้องการดูว่าเริ่มต้นจากที่ใด:

http://www.amazon.com/Expert-One-Design-Development-Programmer/dp/0764543857/ref=sr_1_1?ie=UTF8&s=books&qid=1246374863&sr=1-1

มันอาจจะเก่า แต่ก็เป็นหนังสือที่ยอดเยี่ยม

สำหรับหนังสือดีๆอีกเล่มในครั้งนี้ที่ทุ่มเทให้กับ Spring ดู:

http://www.amazon.com/Professional-Java-Development-Spring-Framework/dp/0764574833/ref=sr_1_2?ie=UTF8&s=books&qid=1246374863&sr=1-2

นอกจากนี้ยังอ้างอิงถึง Spring เวอร์ชั่นเก่า แต่ก็คุ้มค่าที่จะดู


1

ฤดูใบไม้ผลิเป็นการฉีดที่ต้องพึ่งพาอาศัยกันในการเริ่มต้นจากนั้นเพิ่มราชาแห่งการห่อหุ้มสำหรับเกือบทุกอย่าง

เรื่องยาว ... ส่วนใหญ่ของโซลูชั่น XML preffer ของ Spring (เครื่องมือสร้างสคริปต์ XML ... brrrr) ดังนั้นสำหรับ DI ฉันใช้ Guice

ห้องสมุดที่ดี แต่ด้วยการเติบโตที่เพิ่มขึ้นเช่นSpring JDBC (อาจเป็นหนึ่งโซลูชัน Java jdbc ที่มีพารามิเตอร์ชื่อจริง) ใช้เวลาตั้งแต่ maven 4-5 ต่อไป

การใช้ Spring MVC (ส่วนหนึ่งของ "บิ๊กสปริง") สำหรับการพัฒนาเว็บ ... เป็นเฟรมเวิร์ก "ตามคำขอ" มีสงครามศักดิ์สิทธิ์ "คำขอ vs องค์ประกอบ" ... ขึ้นอยู่กับคุณ


1
ฉันเชื่อว่าตอนนี้ Spring Framework กำลังพยายามย้ายออกจาก XML ไปยังคำอธิบายประกอบและการกำหนดค่า Java
Maksim

0

ในอดีตฉันคิดเกี่ยวกับกรอบ Spring จากมุมมองทางเทคนิคอย่างหมดจด

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

วิธีนี้นักพัฒนาซอฟต์แวร์สามารถมุ่งเน้นเพิ่มเติมในการพัฒนาแต่ละองค์ประกอบ (beans) ทันทีที่มีการกำหนดอินเตอร์เฟสระหว่างถั่ว

การทดสอบแอปพลิเคชันดังกล่าวนั้นง่าย - ให้ความสำคัญหลักกับถั่วแต่ละตัว พวกเขาสามารถแยกแยะและเยาะเย้ยได้อย่างง่ายดายดังนั้นการทดสอบหน่วยจึงรวดเร็วและมีประสิทธิภาพ

เฟรมเวิร์กสปริงกำหนดถั่วพิเศษหลายรายการเช่น@Controller ( @Restcontroller ), @Repository , @Componentเพื่อตอบสนองวัตถุประสงค์ของเว็บ Spring พร้อมกับ Maven จัดเตรียมโครงสร้างที่ใช้งานง่ายสำหรับนักพัฒนา การทำงานเป็นทีมนั้นง่ายและรวดเร็วเนื่องจากมีองค์ประกอบแยกออกจากกันและสามารถนำกลับมาใช้ใหม่ได้


0

Spring Framework นั้นดีสำหรับการพัฒนาเว็บและจะเฉพาะเจาะจงมากขึ้นสำหรับบริการ API ที่สงบ

เป็นสิ่งที่ดีสำหรับข้างต้นเนื่องจากการฉีดพึ่งพา และบูรณาการกับโมดูลอื่น ๆ เช่นการรักษาความปลอดภัยในฤดูใบไม้ผลิ , aop ฤดูใบไม้ผลิ , กรอบ mvc , microservices

ในทุกแอปพลิเคชันความปลอดภัยอาจเป็นข้อกำหนด
หากคุณต้องการสร้างผลิตภัณฑ์ที่ต้องการการบำรุงรักษาที่ยาวนานคุณจะต้องใช้แนวคิด Aop

หากแอปพลิเคชันของคุณมีปริมาณการใช้งานมากซึ่งเป็นการเพิ่มภาระให้คุณต้องใช้แนวคิด microservices

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

Spring Dataเป็นโครงการหนึ่งที่ให้การทำงานร่วมกับโครงการของคุณ


ดังนั้นสปริงจึงสามารถบรรจุได้เกือบทุกความต้องการ

โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.