อะไรคือความแตกต่าง / ความสัมพันธ์ระหว่างเป้าหมาย Maven และระยะ? พวกเขาเกี่ยวข้องกันอย่างไร
อะไรคือความแตกต่าง / ความสัมพันธ์ระหว่างเป้าหมาย Maven และระยะ? พวกเขาเกี่ยวข้องกันอย่างไร
คำตอบ:
เป้าหมายจะถูกดำเนินการในขั้นตอนซึ่งช่วยกำหนดเป้าหมายการดำเนินการตามคำสั่งความเข้าใจที่ดีที่สุดของสิ่งนี้คือการดูค่าเริ่มต้นของการผูก Maven วงจรชีวิตซึ่งแสดงให้เห็นว่าเป้าหมายใดที่จะทำงานในเฟสใด ๆ เป้าหมายขั้นตอนการคอมไพล์จะถูกดำเนินการก่อนเป้าหมายขั้นตอนการทดสอบซึ่งจะถูกดำเนินการก่อนเป้าหมายระยะแพคเกจและอื่น ๆ เสมอ
ความสับสนส่วนหนึ่งนั้นมาจากความจริงที่ว่าเมื่อคุณเรียกใช้ Maven คุณสามารถระบุเป้าหมายหรือเฟส ถ้าคุณระบุเฟสแล้ว maven จะรันเฟสทั้งหมดจนถึงเฟสที่คุณระบุตามลำดับ (เช่นถ้าคุณระบุแพ็กเกจมันจะรันครั้งแรกผ่านเฟสคอมไพล์แล้วจากนั้นขั้นตอนการทดสอบและขั้นตอนสุดท้ายของแพ็กเกจ) เรียกใช้เป้าหมายทั้งหมดที่แนบมากับเฟสนั้น
เมื่อคุณสร้างการทำงานของปลั๊กอินในไฟล์ Maven build ของคุณและคุณระบุเป้าหมายเท่านั้นมันจะผูกเป้าหมายนั้นเข้ากับเฟสเริ่มต้นที่กำหนด ตัวอย่างเช่นเป้าหมาย jaxb: xjc ผูกตามค่าเริ่มต้นไปยังขั้นตอนการสร้างทรัพยากร อย่างไรก็ตามเมื่อคุณระบุการดำเนินการคุณสามารถระบุขั้นตอนสำหรับเป้าหมายนั้นได้อย่างชัดเจนเช่นกัน
หากคุณระบุเป้าหมายเมื่อคุณเรียกใช้ Maven เป้าหมายนั้นจะเรียกใช้เป้าหมายนั้นและเป้าหมายนั้นเท่านั้น กล่าวอีกนัยหนึ่งหากคุณระบุเป้าหมาย jar: jar เป้าหมายจะเรียกใช้เป้าหมาย jar: jar เท่านั้นเพื่อรวมรหัสของคุณลงใน jar หากก่อนหน้านี้คุณไม่ได้ใช้งานเป้าหมายการคอมไพล์หรือเตรียมโค้ดที่คอมไพล์ด้วยวิธีอื่นอาจทำให้เกิดความล้มเหลวได้
mvn archetype:generate
และในกรณีนั้น maven เพียงดำเนินการเป้าหมายได้หรือไม่
mvn test
วิ่ง: --- maven-resources-plugin:2.6:resources ... --- maven-compiler-plugin:3.1:compile ... --- maven-resources-plugin:2.6:testResources ... --- maven-compiler-plugin:3.1:testCompile ... --- maven-surefire-plugin:2.12.4:test
ในขณะที่เพียงแค่วิ่งmvn compiler:testCompile
--- maven-compiler-plugin:3.1:testCompile ...
mvn clean compiler:testCompile
ทำงาน--- maven-clean-plugin:2.5:clean ... --- maven-compiler-plugin:3.1:testCompile
ซึ่งล้มเหลวด้วย Failed to execute goal org.apache.maven.plugins:maven-compiler-plugin:3.1:testCompile (default-cli) on project mvnphase: Compilation failure ... cannot find symbol ... symbol: variable MvnPhase
(ซึ่งMvnPhase
เป็นชั้นภายใต้การทดสอบอ้างอิงในชั้นทดสอบ) เห็นได้ชัดว่าระยะไม่ได้ถูกเรียกใช้หากมีการเรียกใช้เป้าหมายอย่างชัดเจน
วงจรชีวิตเป็นลำดับของชื่อขั้นตอน
ขั้นตอนดำเนินการตามลำดับ การดำเนินการเฟสหมายถึงดำเนินการเฟสก่อนหน้าทั้งหมดปลั๊กอินคือชุดของเป้าหมายที่เรียกว่า MOJO ( M Aven O LD J Ava O bject)
การเปรียบเทียบ: ปลั๊กอินเป็นคลาสและเป้าหมายเป็นวิธีการภายในคลาส
Maven จะขึ้นอยู่รอบแนวคิดหลักของวงจรชีวิตรูปร่าง ในแต่ละรูปร่างวงจรชีวิตมีขั้นตอนการสร้างและในแต่ละขั้นตอนการสร้างมีเป้าหมายรูปร่าง
เราสามารถดำเนินการสร้างเฟสหรือสร้างเป้าหมายได้ เมื่อดำเนินการขั้นตอนการสร้างเราจะดำเนินการเป้าหมายการสร้างทั้งหมดภายในขั้นตอนการสร้างนั้น เป้าหมายการสร้างถูกกำหนดให้กับหนึ่งเฟสการบิลด์ นอกจากนี้เรายังสามารถดำเนินการสร้างเป้าหมายได้โดยตรง
มีวงจรชีวิตการสร้างที่สำคัญสามตัว:
แต่ละรอบการประกอบสร้างขึ้นจากแต่ละขั้นตอน
ตัวอย่างdefault
วงจรชีวิตประกอบด้วยBuild Phasesต่อไปนี้:
◾validate - validate the project is correct and all necessary information is available
◾compile - compile the source code of the project
◾test - test the compiled source code using a suitable unit testing framework. These tests should not require the code be packaged or deployed
◾package - take the compiled code and package it in its distributable format, such as a JAR.
◾integration-test - process and deploy the package if necessary into an environment where integration tests can be run
◾verify - run any checks to verify the package is valid and meets quality criteria
◾install - install the package into the local repository, for use as a dependency in other projects locally
◾deploy - done in an integration or release environment, copies the final package to the remote repository for sharing with other developers and projects.
ดังนั้นในการผ่านขั้นตอนข้างต้นเราแค่เรียกคำสั่งเดียว:
mvn <phase> { Ex: mvn install }
สำหรับคำสั่งดังกล่าวเริ่มต้นจากเฟสแรกเฟสทั้งหมดจะถูกดำเนินการตามลำดับจนถึงเฟส 'ติดตั้ง' mvn
สามารถดำเนินการเป้าหมายหรือเฟส (หรือหลายเป้าหมายหรือหลายเฟส) ดังนี้:
mvn clean install plugin:goal
อย่างไรก็ตามหากคุณต้องการปรับแต่งคำนำหน้าที่ใช้เพื่ออ้างอิงปลั๊กอินของคุณคุณสามารถระบุคำนำหน้าโดยตรงผ่านพารามิเตอร์การกำหนดค่าmaven-plugin-plugin
ในPOM ของปลั๊กอิน
เฟสการประกอบสร้างขึ้นจากเป้าหมายปลั๊กอิน
ฟังก์ชันการทำงานส่วนใหญ่ของ Maven อยู่ในปลั๊กอิน ปลั๊กอินจัดเตรียมชุดของเป้าหมายที่สามารถดำเนินการได้โดยใช้ไวยากรณ์ต่อไปนี้:
mvn [plugin-name]:[goal-name]
ตัวอย่างเช่นโครงการ Java mvn compiler:compile
สามารถรวบรวมกับรวบรวมเป้าหมายคอมไพเลอร์ปลั๊กอินโดยการทำงาน
วงจรชีวิตการสร้างเป็นรายการของขั้นตอนที่มีชื่อที่สามารถใช้เพื่อให้คำสั่งเพื่อการดำเนินการเป้าหมาย
เป้าหมายที่มีให้โดยปลั๊กอินสามารถเชื่อมโยงกับขั้นตอนต่างๆของวงจรชีวิต ตัวอย่างเช่นโดยค่าเริ่มต้นเป้าหมาย compiler:compile
จะเชื่อมโยงกับcompile
เฟสในขณะที่เป้าหมาย surefire:test
นั้นเชื่อมโยงกับtest
เฟสนั้น พิจารณาคำสั่งต่อไปนี้:
mvn test
เมื่อรันคำสั่งก่อนหน้า Maven จะรันเป้าหมายทั้งหมดที่เกี่ยวข้องกับแต่ละเฟสจนถึงและรวมถึงtest
เฟส ในกรณีเช่นนี้ Maven จะทำงานตามresources:resources
เป้าหมายที่เกี่ยวข้องกับprocess-resources
ขั้นตอนนั้นcompiler:compile
และต่อ ๆ ไปเรื่อย ๆ จนกว่าจะถึงsurefire:test
เป้าหมายในที่สุด
อย่างไรก็ตามแม้ว่าขั้นตอนการสร้างจะมีหน้าที่รับผิดชอบในขั้นตอนเฉพาะในวงจรชีวิตการสร้างลักษณะที่ใช้ในการทำหน้าที่ความรับผิดชอบเหล่านั้นอาจแตกต่างกันไป และสิ่งนี้ทำได้โดยการประกาศเป้าหมายปลั๊กอินที่เชื่อมโยงกับขั้นตอนการสร้าง
เป้าหมายปลั๊กอินหมายถึงงานเฉพาะ (ละเอียดกว่าขั้นตอนการสร้าง) ซึ่งมีส่วนช่วยในการสร้างและจัดการโครงการ มันอาจจะถูกผูกไว้กับขั้นตอนการสร้างศูนย์หรือมากกว่า เป้าหมายที่ไม่ผูกพันกับเฟสบิลด์ใด ๆ สามารถดำเนินการได้ภายนอกวงจรชีวิตบิลด์โดยการเรียกใช้โดยตรง ลำดับของการดำเนินการขึ้นอยู่กับลำดับที่เป้าหมายและขั้นตอนการสร้างถูกเรียกใช้ ตัวอย่างเช่นพิจารณาคำสั่งด้านล่าง clean
และpackage
ข้อโต้แย้งที่มีการสร้างขั้นตอนในขณะที่dependency:copy-dependencies
เป็นเป้าหมาย (ปลั๊กอิน)
mvn clean dependency:copy-dependencies package
หากสิ่งนี้จะต้องถูกดำเนินการclean
ขั้นตอนจะถูกดำเนินการก่อน (หมายถึงมันจะทำงานทุกขั้นตอนก่อนหน้าของวงจรชีวิตที่สะอาดรวมทั้งclean
เฟสตัวเอง) แล้วdependency:copy-dependencies
เป้าหมายก่อนที่จะดำเนินการpackage
ขั้นตอนสุดท้าย (และขั้นตอนการสร้างก่อนหน้าทั้งหมด วงจรชีวิตเริ่มต้น)
ยิ่งกว่านั้นหากเป้าหมายผูกพันกับเฟสบิลด์ตั้งแต่หนึ่งเฟสขึ้นไปเป้าหมายนั้นจะถูกเรียกในทุกเฟส
นอกจากนี้ขั้นตอนการสร้างยังสามารถมีเป้าหมายเป็นศูนย์หรือมากกว่านั้น หากขั้นตอนการสร้างไม่มีเป้าหมายที่ถูกผูกไว้ขั้นตอนการสร้างนั้นจะไม่ดำเนินการ แต่ถ้ามันมีเป้าหมายอย่างน้อยหนึ่งอย่างมันจะดำเนินการตามเป้าหมายเหล่านั้นทั้งหมด
Built-in Binding ระยะเวลา
บางช่วงมีเป้าหมายผูกติดไว้กับพวกมันตามค่าเริ่มต้น และสำหรับวงจรชีวิตเริ่มต้นการเชื่อมเหล่านี้ขึ้นอยู่กับค่าบรรจุภัณฑ์
สถาปัตยกรรม Maven:
ตัวอย่าง Eclipse สำหรับ Maven Lifecycle Mapping
[plugin-name]
ในตัวอย่างmvn [plugin-name]:[goal-name]
ค่อนข้างปลั๊กอินคำนำหน้า mvn clean install
ไม่เพียง " สามารถใช้ในสถานการณ์หลายโมดูล " โมดูลที่หลากหลายเป็นหัวข้อที่แตกต่างกันโดยสิ้นเชิง
คำตอบที่เลือกนั้นยอดเยี่ยม แต่ฉันยังต้องการเพิ่มสิ่งเล็ก ๆ ในหัวข้อ ภาพประกอบ
มันแสดงให้เห็นอย่างชัดเจนว่าขั้นตอนต่าง ๆ เชื่อมโยงกับปลั๊กอินที่แตกต่างกันอย่างไรและเป้าหมายที่ปลั๊กอินเหล่านั้นเปิดเผย
ดังนั้นขอตรวจสอบกรณีที่มีการเรียกใช้สิ่งที่ต้องการmvn compile
:
mvn compile
มันถูกแมปไปยังเป้าหมายที่เฉพาะเจาะจงเป้าหมายของการรวบรวมmvn compiler:compile
ดังนั้นขั้นตอนที่ถูกสร้างขึ้นจากเป้าหมายปลั๊กอิน
ลิงก์ไปยังการอ้างอิง
mvn test
ชี้ไปpackage
และmvn install
ชี้ไปdeploy
?
jar
ปลั๊กอินทำงานในpackage
เฟสจริง และ pom ในแซนวิชระหว่างเฟสและปลั๊กอินนั้นค่อนข้างสับสน (ฉันถือว่ามันน่าจะหมายความว่าใน pom คุณสามารถกำหนดค่าว่าปลั๊กอินใดที่ทำงานในเฟสใดนอกเหนือจากการผูกค่าเริ่มต้น) หลักการทั่วไปนั้นถูกต้องแล้ว
คำจำกัดความมีรายละเอียดที่หน้าเว็บไซต์ Maven บทนำสู่วงจรชีวิตของ Buildแต่ฉันได้พยายามสรุป :
Maven กำหนดกระบวนการสร้าง 4 รายการ:
วงจรชีวิต
สามตัวในวงจรชีวิต (aka สร้างวงจรชีวิต ): default
, ,clean
site
( อ้างอิงวงจรชีวิต )
ระยะ
วงจรชีวิตของแต่ละคนถูกสร้างขึ้นจากขั้นตอนเช่นสำหรับdefault
วงจรชีวิต: compile
, test
, package
, install
ฯลฯ
เสียบเข้าไป
สิ่งประดิษฐ์ที่มีเป้าหมายอย่างน้อยหนึ่งรายการ
ขึ้นอยู่กับประเภทของบรรจุภัณฑ์ ( jar
, war
และอื่น ๆ ) เป้าหมายของปลั๊กอินจะเชื่อมโยงกับเฟสตามค่าเริ่มต้น ( การเชื่อมโยงวงจรชีวิตในตัว )
เป้าหมาย
งาน (การกระทำ) ที่ดำเนินการ ปลั๊กอินสามารถมีหนึ่งเป้าหมายขึ้นไป
หนึ่งหรือมากกว่าเป้าหมายที่จะต้องมีการระบุไว้เมื่อกำหนดค่าปลั๊กอินใน POM นอกจากนี้ในกรณีที่ปลั๊กอินไม่ได้กำหนดระยะเริ่มต้นเป้าหมายที่ระบุสามารถเชื่อมโยงกับเฟส
Maven สามารถถูกเรียกใช้ด้วย:
clean
, package
)<plugin-prefix>:<goal>
(เช่นdependency:copy-dependencies
)<plugin-group-id>:<plugin-artifact-id>[:<plugin-version>]:<goal>
(เช่นorg.apache.maven.plugins:maven-compiler-plugin:3.7.0:compile
)ด้วยการรวมกันอย่างน้อยหนึ่งอย่างใด ๆ หรือทั้งหมดเช่น:
mvn clean dependency:copy-dependencies package
Build Phase
ฉันคิดว่ามันเป็นอีกช่วงหนึ่งในวงจรชีวิตและมันทำให้ฉันสับสน
ผมเชื่อว่าคำตอบที่ดีที่มีให้อยู่แล้ว แต่ผมต้องการที่จะเพิ่มแผนภาพที่ง่ายต่อการติดตามของที่แตกต่างกัน 3 วงจรชีวิต ( build
, clean
และsite
) และขั้นตอนในแต่ละ
ขั้นตอนในตัวหนา - เป็นขั้นตอนหลักที่ใช้กันทั่วไป
generate-resources
ปรากฏขึ้นสองครั้งและgenerate-sources
หายไป
ขอมอบเครดิตให้แก่ Sandeep Jindal และ Premraj คำอธิบายของพวกเขาช่วยให้ฉันเข้าใจหลังจากสับสนเกี่ยวกับเรื่องนี้ซักพัก
ฉันสร้างตัวอย่างโค้ดบางอย่างเต็มรูปแบบและบางคำอธิบายง่าย ๆ ที่นี่https://www.surasint.com/maven-life-cycle-phase-and-goal-easy-explained/ ฉันคิดว่ามันอาจช่วยให้ผู้อื่นเข้าใจ
ในระยะสั้นจากลิงค์คุณไม่ควรพยายามทำความเข้าใจทั้งสามในครั้งเดียวก่อนอื่นคุณควรเข้าใจความสัมพันธ์ในกลุ่มเหล่านี้:
1. วงจรชีวิตเทียบกับเฟส
วงจรชีวิตคือชุดของขั้นตอนในลำดับดูที่นี่อ้างอิงวงจรชีวิต เมื่อคุณเรียกเฟสมันจะเรียกเฟสทั้งหมดก่อน
ตัวอย่างเช่นวงจรชีวิตที่สะอาดมี 3 ขั้นตอน ( ทำความสะอาดล่วงหน้าสะอาดโพสต์สะอาด )
mvn clean
มันจะเรียกก่อนการทำความสะอาดและทำความสะอาด
2. ปลั๊กอินเทียบกับเป้าหมาย
เป้าหมายเป็นเหมือนการดำเนินการในปลั๊กอิน ดังนั้นหากปลั๊กอินเป็นคลาสเป้าหมายคือวิธีการ
คุณสามารถโทรหาเป้าหมายเช่นนี้:
mvn clean:clean
ซึ่งหมายความว่า "โทรหาเป้าหมายที่สะอาดในปลั๊กอินที่สะอาด" (ไม่มีอะไรเกี่ยวข้องกับขั้นตอนการทำความสะอาดที่นี่อย่าให้คำว่า "สะอาด" ทำให้คุณสับสนเพราะมันไม่เหมือนเดิม!)
3. ตอนนี้ความสัมพันธ์ระหว่างเฟส & เป้าหมาย:
เฟสสามารถ (ก่อนหน้า) ลิงก์ไปยังเป้าหมายได้ตัวอย่างเช่นโดยทั่วไปเฟสแบบคลีนจะเชื่อมโยงไปยังเป้าหมายที่สะอาด ดังนั้นเมื่อคุณเรียกคำสั่งนี้:
mvn clean
มันจะเรียกเฟสก่อนคลีนและเฟสคลีนซึ่งเชื่อมโยงไปยังเป้าหมายคลีน: คลีน
มันเกือบจะเหมือนกับ:
mvn pre-clean clean:clean
รายละเอียดเพิ่มเติมและตัวอย่างเต็มรูปแบบอยู่ในhttps://www.surasint.com/maven-life-cycle-phase-and-goal-easy-explained/
คำศัพท์การทำงาน Maven มีขั้นตอนและเป้าหมาย
Phase: Maven phase เป็นชุดของการกระทำที่เกี่ยวข้องกับเป้าหมาย 2 หรือ 3 เป้าหมาย
exmaple: - ถ้าคุณเรียกใช้ mvn ใหม่ทั้งหมด
นี่คือเฟสที่จะเรียกใช้เป้าหมาย mvn clean: clean
เป้าหมาย: เป้าหมาย Maven ล้อมรอบด้วยเฟส
สำหรับการอ้างอิง http://books.sonatype.com/mvnref-book/reference/lifecycle-sect-structure.html
มีวงจรบิลด์ในตัวสามตัวต่อไปนี้:
ระยะเวลาเริ่มต้นของวงจรชีวิต -> [ตรวจสอบความถูกต้องเริ่มต้นแหล่งกำเนิดกระบวนการแหล่งทรัพยากรสร้างทรัพยากรทรัพยากรกระบวนการรวบรวมระดับกระบวนการสร้างแหล่งทดสอบทดสอบแหล่งทดสอบกระบวนการแหล่งผลิตทดสอบทรัพยากรกระบวนการ - การทดสอบทรัพยากร, การรวบรวมการทดสอบ, กระบวนการทดสอบ - คลาส, การทดสอบ, การเตรียมแพคเกจ, แพคเกจ, การทดสอบก่อนการรวม, การทดสอบการรวม, การทดสอบหลังการรวม, การตรวจสอบ, การติดตั้ง, การปรับใช้]
ระยะเวลาการใช้งานสะอาด -> [ก่อนทำความสะอาดทำความสะอาดโพสต์ใหม่]
ไซต์วงจรชีวิต -> [ไซต์ก่อนหน้าไซต์ไซต์หลังไซต์ปรับใช้]
การไหลเป็นลำดับตัวอย่างเช่นสำหรับวงจรชีวิตเริ่มต้นมันเริ่มต้นด้วยการตรวจสอบแล้วเริ่มต้นและอื่น ๆ ...
คุณสามารถตรวจสอบวงจรชีวิตได้โดยเปิดใช้งานโหมดแก้ไขข้อบกพร่องmvn
คือmvn -X <your_goal>