แยกโครงการขนาดใหญ่เพื่อสร้างโครงการ Maven หลายโมดูล

ฉันกำลังทำงานกับแอปพลิเคชัน Spring-MVC ที่เราใช้ Maven สำหรับการจัดการการพึ่งพา เนื่องจากโครงการมีขนาดใหญ่เราจึงคิดแยกโครงการออกเป็นหลายส่วน ฉันมีข้อสงสัยบางอย่างซึ่งฉันหวังว่าจะได้รับคำตอบที่นี่

ขณะนี้เรากำลังปรับใช้ไฟล์ WAR ไฟล์เดียวเช่นเดียวROOT.warกับ Apache tomcat บนเซิร์ฟเวอร์ของเรา เนื่องจากโครงการมีขนาดใหญ่จึงมีบางส่วนในเว็บแอปเช่นการแจ้งเตือนและอีเมลบริการของบุคคลที่สาม PUSH (Cometd) REST API และอื่น ๆ ปัจจุบันทั้งหมดของพวกเขาอยู่ในสโมสรและขึ้นอยู่กับกันและกัน ตัวอย่างเช่นNotificationวัตถุยังขึ้นอยู่กับPersonวัตถุเนื่องจากการแจ้งเตือนนั้นได้รับการปรับแต่งสำหรับผู้ใช้

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

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

ดังที่ฉันได้กล่าวไว้ความตั้งใจคือการทำงานกับแต่ละโมดูลและสามารถปรับใช้ (ดีกว่าร้อนกว่า) ปัจจุบันเรามีไฟล์ WAR ไฟล์เดียวROOT.warเท่านั้น การแยกจะสร้างไฟล์ war หลายไฟล์ซึ่งจะถูกเรียกโดย URL ว่าdomain-name.com/module_name/some_mapping?

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

ขณะนี้ฉันกำลังใช้ POM ผู้ปกครองจากฤดูใบไม้ผลิดังนี้:

<parent>
    <groupId>io.spring.platform</groupId>
    <artifactId>platform-bom</artifactId>
    <version>1.1.3.RELEASE</version>
    <relativePath />
</parent>

มันเป็นไปได้ ?

ใช่แน่นอน ฉันมีโครงสร้างที่ผ่านมาไม่กี่โครงการเช่นนี้ที่นี่ฉันหวังว่าคุณจะเริ่ม

Maven มีสองคุณสมบัติหลักที่คุณจะใช้เพื่อสานสิ่งต่าง ๆ เข้าด้วยกัน:

• การพึ่งพาปกติ
• โมดูล

หารและพิชิต

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

ขึ้นอยู่กับสถานะของแผนภูมิต้นไม้ของคุณสิ่งนี้อาจแสดงถึงการทำงานจำนวนมาก ที่กล่าวว่าคุณไม่ได้ทำมันเพื่อ shoehorn เพื่อ Maven แต่เป็นวิธีการโครงสร้างและฆ่าเชื้อฐานรหัสของคุณ คิดว่ามันเป็นเครื่องมือของคุณง่ายต่อการค้นหาสิ่งต่าง ๆ ที่นี่:

กว่าที่นี่:

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

หากโครงการเหล่านี้สามารถใช้งานได้นอกแอพพลิเคชั่นหลักพวกเขาสามารถใช้ชีวิตในฐานะห้องสมุดที่เป็นอิสระอย่างแท้จริงและรวมถึงการพึ่งพา Maven พวกเขาควรอาศัยอยู่ในพื้นที่เก็บข้อมูลของตัวเอง (ไม่ได้อยู่ในแหล่งที่มาของแอปพลิเคชัน) และไม่ควรขึ้นอยู่กับส่วนใด ๆ ของแอปพลิเคชันหลัก

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

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

การขับรถ

หากคุณเป็นทีมที่มีขนาดใหญ่กว่า 1 ฉันขอแนะนำให้คุณติดตั้งที่เก็บข้อมูลสำหรับการอ้างอิง Maven ของคุณ ดูArtifactory , NexusหรือArchiva คุณสามารถกำหนดค่าไฟล์ POM เพื่อติดตั้งโดยตรงเหล่านี้ดังนั้นเมื่อรันแล้วไม่ควรมีค่าใช้จ่ายมาก แต่จะช่วยให้ทีมของคุณมีเวลามากในการแก้ไขปัญหาการพึ่งพากับ jar ที่ถูกต้องในตำแหน่งที่ถูกต้อง

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

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

ตัวอย่าง

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

ใช้เจนกินส์ตัวอย่างเช่น:

คุณสามารถเห็นPOM แม่ของพวกเขาค่อนข้างกว้างขวาง

พวกมันใช้โมดูลอย่างที่คุณเห็นในส่วนนี้:

<modules>
    <module>core</module>
    <module>war</module>
    <module>test</module>
    <module>cli</module>
</modules>

และแต่ละโมดูลจะสัมพันธ์กับโฟลเดอร์ย่อยด้วยชื่อเดียวกันกับ POM คุณสามารถทำรังได้มากเท่าที่คุณต้องการเช่นนี้แม้ว่าจะอยู่ในระดับสติปัญญา;)

เริ่มเล็ก

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

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

หากสิ่งต่าง ๆ แปลก ๆ คุณสามารถใช้mvn help:effective-pomคำสั่งเพื่อดูว่า Maven เข้าใจจริงหรือไม่

ปลั๊กอิน

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

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

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

ความแตกต่างพื้นฐานระหว่างโมดูลและการพึ่งพาคือ:

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

คุณสามารถค้นหาพระคัมภีร์ที่นี่

หวังว่านี่จะช่วยโชคดี