การแนะนำ
หัวข้อของการรีวิวนี้คือระบบสร้างอัตโนมัติ Gradle ในภาษาอังกฤษ build system เรียกว่า
Build Tools
![ข้อมูลเบื้องต้นเกี่ยวกับ Gradle - 1]()
เหตุใดสิ่งนี้จึงจำเป็น? การสร้างโปรเจ็กต์ด้วยตนเองใน Java เป็นกระบวนการที่ค่อนข้างใช้แรงงานมาก จำเป็นต้องระบุไลบรารีและเฟรมเวิร์กที่โปรเจ็กต์ต้องการอย่างถูกต้องและสิ่งที่โปรเจ็กต์ขึ้นอยู่กับ คุณสามารถอ่านบทความดีๆ เกี่ยวกับHabréได้ที่นี่: “
การทำงานกับ Java บนบรรทัดคำสั่ง ” ไม่ช้าก็เร็วคุณจะเริ่มสร้างสคริปต์เพื่อทำให้กระบวนการนี้เป็นไปโดยอัตโนมัติ ทีนี้ ลองจินตนาการว่านักพัฒนาทั่วโลกทำเช่นนี้ และทุกคนก็เขียนอีกครั้งถึงสิ่งที่มีคนเขียนไว้สำหรับโปรเจ็กต์ของตนแล้ว จากนั้นระบบการประกอบโครงการก็ปรากฏขึ้นซึ่งทำให้กระบวนการนี้เป็นไปโดยอัตโนมัติ นอกจากนี้ ในด้านหนึ่ง พวกมันยังช่วยให้คุณสามารถประกอบโปรเจ็กต์ตามที่คุณต้องการได้ ในทางกลับกัน พวกมันก็มอบเครื่องมือที่ได้มาตรฐานไม่มากก็น้อยให้กับคุณ อีกทางเลือกหนึ่งสำหรับ Gradle คือระบบสร้างอัตโนมัติของ Maven ระบบการประกอบทั้งสองนี้มีความแตกต่างกัน แต่ในทางกลับกันก็มีความคล้ายคลึงกันหลายประการ มีเนื้อหาในหัวข้อนี้บนเว็บไซต์ Gradle: "
การโยกย้ายจาก Maven ไปยัง Gradle " ตามที่ระบุไว้ในบทช่วยสอนนี้ Gradle และ Maven มีมุมมองที่แตกต่างกันเกี่ยวกับวิธีการสร้างโปรเจ็กต์ Gradle ขึ้นอยู่กับกราฟของงานซึ่งสามารถพึ่งพาซึ่งกันและกันได้ งานทำงานบางประเภท Maven ใช้แบบจำลองของระยะหนึ่งซึ่งแนบ "เป้าหมาย" บางอย่างไว้ด้วย เป้าหมายเหล่านี้เป็นที่ที่งานบางอย่างเสร็จสิ้น อย่างไรก็ตาม ด้วยแนวทางที่แตกต่างกันเหล่านี้ ระบบ build ทั้งสองเป็นไปตามแบบแผนเดียวกัน และการจัดการการขึ้นต่อกันก็คล้ายกัน ในการเริ่มใช้ Gradle คุณต้องดาวน์โหลด ใน Google หรือ Yandex เราเข้าสู่ "Gradle Build Tool" และในผลลัพธ์แรกเราเห็นเว็บไซต์อย่างเป็นทางการ:
https://gradle.org . ในหน้า Gradle หลักจะมีลิงก์พร้อมข้อความ "Docs" ซึ่งนำไปสู่เอกสาร
Gradle ก่อนอื่น เราต้องติดตั้ง (ติดตั้ง) Gradle ดังนั้นเราจึงสนใจในส่วน "
การติดตั้ง Gradle " ของเอกสารประกอบ มีวิธีการติดตั้งหลายวิธี รวมทั้งวิธี “แบบเก่า” เช่น ด้วยตนเอง (“
การติดตั้งด้วยตนเอง ”) ตามคำแนะนำ ให้ดาวน์โหลดไฟล์ประเภท "
binary-only " ซึ่งจะมีชื่อเช่น gradle-5.1.1-bin.zip ถัดไป คลายไฟล์เก็บถาวรและกำหนดค่าตัวแปรสภาพแวดล้อม PATH ตามคำแนะนำ สิ่งสำคัญคือหลังจากดำเนินการตามคำแนะนำแล้วคำสั่ง
gradle -v
จะแสดงเวอร์ชันของ Gradle ที่ติดตั้งไว้ อาจมีปัญหาว่าเมื่อระบุตำแหน่งแล้วระบบจะพบว่า Gradle ไม่ใช่ตำแหน่งที่คุณต้องการ ดังนั้นบน Windows คุณสามารถทำได้ (บน * nix มีแอนะล็อก):
for %i in (gradle.bat) do @echo. %~$PATH:i
ตอนนี้บางทีเราสามารถเริ่มทำความคุ้นเคยได้แล้ว
การเริ่มต้นโครงการ Gradle
ฉันอยากจะทราบทันทีว่า Gradle เป็นเรื่องเกี่ยวกับการปฏิบัติงานที่เรียกว่า
งาน (ฉันจะเรียกมันว่างาน) งานมีให้โดย
ปลั๊กอิน ต่างๆ ฉันแนะนำให้คุณอ่านเพิ่มเติมเกี่ยวกับปลั๊กอินในเอกสารอย่างเป็นทางการ: "
การใช้ Gradle Plugins " มีชุดของ "Core Plugins" ที่พร้อมใช้งานเสมอเมื่อติดตั้ง Gradle ปลั๊กอินเหล่านี้มีหมวดหมู่ที่แตกต่างกัน แต่เราสนใจในหมวดหมู่ "
ยูทิลิตี้ " ชุดนี้ประกอบด้วยปลั๊กอิน "
Build Init Plugin " ซึ่งมีงานสำหรับการเริ่มต้นโครงการ Gradle เราสนใจที่จะสร้างประเภทโครงการ: "
java-application " มารันงาน Gradle กัน:
gradle init --type java-application
เรามาตอบคำถามระหว่างทางกัน เช่น เราต้องการใช้ Groovy DSL (ภาษาคำอธิบายงานมาตรฐานสำหรับ Gradle) และเฟรมเวิร์กการทดสอบ JUnit (เราจะพูดถึงเรื่องนี้ในการทบทวนอื่น) หลังจากสร้างแล้วเราจะได้รับชุดไฟล์ดังต่อไปนี้:
ประการแรก หลังจากการเริ่มต้น เราได้รับ wrapper พิเศษที่กำหนดค่าไว้ล่วงหน้าสำหรับ Gradle เวอร์ชันของเรา - นี่คือสคริปต์พิเศษ ฉันแนะนำให้คุณอ่านเพิ่มเติมในเอกสารอย่างเป็นทางการ - “
The Gradle Wrapper ” ประการที่สอง เราเห็น Gradle Build Script - ไฟล์ build.gradle นี่คือไฟล์หลัก ซึ่งอธิบายว่าไลบรารีและเฟรมเวิร์กใดที่โปรเจ็กต์ของเราใช้ ปลั๊กอินใดที่ต้องเชื่อมต่อกับโปรเจ็กต์ และอธิบายงานต่างๆ ฉันแนะนำให้คุณอ่านเพิ่มเติมเกี่ยวกับไฟล์นี้ในเอกสารอย่างเป็นทางการ: "
Build Script Basics "
ปลั๊กอินและงาน
หากเราดูเนื้อหาของ Build Script เราจะเห็นส่วนปลั๊กอิน:
plugins {
id 'java'
id 'application'
}
นี่เป็นปลั๊กอินเดียวกับที่เราพูดถึงก่อนหน้านี้ และหากมีปลั๊กอินแสดงว่ามีงานที่เราสามารถใช้ได้ในตอนนี้ เราสามารถรันคำสั่ง gradle jobs และดูว่าเราสามารถทำอะไรกับโปรเจ็กต์นี้ได้บ้าง:
ตัวอย่างเช่น โดยการดำเนินการ
gradle run
เราจะเปิดตัวคลาสหลักของแอปพลิเคชัน java ของเรา:
ดังที่เราเห็นเขียนไว้ข้างล่าง
2 actionable tasks: 1 executed, 1 up-to-date
นี้ หมายความว่าอย่างไร? ซึ่งหมายความว่ามีงานเสร็จสมบูรณ์แล้วทั้งหมด 2 งาน ยิ่งไปกว่านั้น มี 1 งานเสร็จสมบูรณ์จริง และอีก 1 งานยังไม่ได้ดำเนินการ เพราะ... เป็นปัจจุบันคือสถานะเป็นปัจจุบันและยังไม่ได้ทำอะไรเลย เราสามารถดำเนินการสิ่งที่เรียกว่า "Dry Run" ได้:
gradle run -m
เรามารันคำสั่งนี้กัน เราจะดูว่างานใดบ้างที่จะดำเนินการเพื่อรันภารกิจ:
ดังที่เราเห็น งานทั้งหมด 4 งานเสร็จสมบูรณ์: ก่อนที่จะดำเนินการรัน งานจะดำเนินการคลาสงานการพึ่งพา คลาสนั้นมีการขึ้นต่อกัน 2 แบบ ดังนั้นมันจึงดำเนินการคอมไพล์Java และ processResources ด้วย เมื่อเราปฏิบัติงาน เราสามารถดำเนินการในขณะที่ดูบันทึกในระดับหนึ่งได้ (ระดับการบันทึกจะกำหนดว่าข้อความสำคัญที่เราต้องการดู) เช่น เราสามารถ
gradle run -i
ทำได้ นี่จะแสดงข้อความข้อมูลเช่น:
Task :classes UP-TO-DATE
Skipping task ':classes' as it has no actions.
สำหรับข้อมูลเพิ่มเติมเกี่ยวกับการเข้าสู่ระบบใน Gradle ฉันขอแนะนำให้คุณดูเอกสารอย่างเป็นทางการ: "
Gradle Logging " ดังที่เราเห็น งานชั้นเรียนถูกข้ามไปเนื่องจากเป็นงาน
UP-TO-DATEนั่นคือสถานะเป็นปัจจุบัน ไม่ต้องทำอะไร ดังนั้นจึงไม่มีการดำเนินการใดๆ เนื่องจากตามค่าเริ่มต้น Gradle มี "
การตรวจสอบล่าสุด " หรือที่เรียกว่าส่วนเพิ่ม คุณสามารถอ่านเพิ่มเติมเกี่ยวกับกลไกนี้ได้ในเอกสารประกอบของ Gradle: "
การตรวจสอบล่าสุด (AKA Increamental Build) " แต่กลไกนี้สามารถปิดใช้งานได้โดยการดำเนินการงานที่ระบุแฟล็ก --rerun-tasks ตัวอย่างเช่น,
gradle run --rerun-tasks
. จากนั้นเราจะเห็น:
2 งานที่ดำเนินการได้: 2 งานที่ดำเนินการ อย่างที่คุณเห็นจำนวนงานที่ดำเนินการจะพิจารณาเฉพาะระดับแรกของกราฟเท่านั้นนั่นคืองานที่รันนั้นเองและงานที่ขึ้นอยู่กับโดยตรงนั่นคือ , ชั้นเรียน งานที่ขึ้นอยู่กับคลาสจะไม่นับที่นี่ (แม้ว่างานเหล่านั้นจะถูกดำเนินการเมื่อมีการดำเนินการงานคลาสก็ตาม) คุณควรอ่านเกี่ยวกับงานต่างๆ ด้วย:
การพึ่งพาอาศัยกัน
งานหลักอย่างหนึ่งของระบบบิลด์คือการจัดการการพึ่งพา ซึ่งก็คือไลบรารี/เฟรมเวิร์กที่โปรเจ็กต์ของเราต้องการ ระบบการสร้างจะต้องตรวจสอบให้แน่ใจว่าพร้อมใช้งานในเวลาที่เหมาะสมและประกอบชิ้นส่วนสุดท้ายของแอปพลิเคชันของเราด้วยวิธีที่ถูกต้อง ตามค่าเริ่มต้น หลังจาก gradle init สำหรับ java-application เราจะเห็นเนื้อหาต่อไปนี้ใน build script:
dependencies {
implementation 'com.google.guava:guava:26.0-jre'
testImplementation 'junit:junit:4.12'
}
ที่นี่ชัดเจนทันทีว่าเรากำลังเชื่อมต่ออะไรอยู่ แต่หากไม่มีความเข้าใจก็ไม่ชัดเจนว่า Implementation และ TestImplementation คืออะไร? ที่นี่เราต้องกลับมาที่เอกสาร Gradle อีกครั้ง เนื่องจากเอกสารของ Gradle เขียนได้ดี เรียกว่า "
การจัดการการกำหนดค่าการพึ่งพา " ตามที่ระบุไว้ในเอกสารประกอบ แต่ละการขึ้นต่อกันจะถูกประกาศด้วยขอบเขตที่แน่นอน - พื้นที่ที่การขึ้นต่อกันนี้จะพร้อมใช้งาน ขอบเขตนี้ถูกกำหนดโดยการกำหนดค่าบางอย่าง ซึ่งแต่ละค่ามีชื่อไม่ซ้ำกัน สิ่งที่น่าสนใจคือปลั๊กอิน Gradle จำนวนมากเพิ่มการกำหนดค่าที่กำหนดไว้ล่วงหน้า หากต้องการทราบว่าเราสามารถเรียกใช้การกำหนดค่าใดได้บ้าง:
gradle --console plain dependencies
วิธีนี้เราจะเห็นรายการการกำหนดค่าที่มีอยู่ทั้งหมดและการขึ้นต่อกันของการกำหนดค่าเหล่านั้น เราสามารถกรองรายการนี้เพื่อให้เราเห็นเฉพาะการกำหนดค่าที่มีอยู่เท่านั้น:
gradle --console plain dependencies | find " - "
เราจะรู้ได้อย่างไรว่าควรใช้อะไร? คุณจะต้องอ่านที่นี่เล็กน้อย เพราะ เราใช้ปลั๊กอิน "Java" ดังนั้นมาเริ่มกันที่เอกสารประกอบและส่วน "
การจัดการการพึ่งพา " ที่นี่เราจะเห็นว่าเคยมีการกำหนดค่า (ขอบเขตอาคา) ที่เรียกว่า "คอมไพล์" และมันหมายถึง "การพึ่งพาที่จำเป็นในระหว่างการคอมไพล์" แต่แล้วมันก็ถูกแทนที่ (ในภาษาอังกฤษ Superseded) ด้วยการนำไปใช้ คุณสามารถอ่านเพิ่มเติมเกี่ยวกับการแทนที่ได้ในส่วน "
การแยก API และการใช้งาน " ปรากฎว่าการขึ้นต่อกันนี้จะอยู่ใน "คอมไพล์คลาสพาธ" แต่บางครั้งเราต้องการรวมการพึ่งพาของเราไว้ในสิ่งประดิษฐ์สุดท้าย เพื่ออะไร? ตัวอย่างเช่น เราจะมี jar ที่ปฏิบัติการได้ ซึ่งควรมีทุกสิ่งที่จำเป็นในตัวมันเอง แล้วเราควรทำอย่างไร? ประการแรก ไม่มีการสนับสนุนแบบ “นอกกรอบ” (นั่นคือ โดยค่าเริ่มต้น โดยไม่มีการดำเนินการใดๆ เพิ่มเติม) สิ่งนี้อธิบายได้จากข้อเท็จจริงที่ว่าทุกคนต้องการรวบรวมไฟล์เก็บถาวรในแบบของตนเองและ Gradle พยายามที่จะเรียบง่าย นอกจากนี้เรายังไม่สามารถใช้ไฟล์เก็บถาวร jar บน classpath ได้ (โดยไม่มีการปรับแต่งเพิ่มเติมในโค้ด) เพราะ มันไม่ทำงานอย่างนั้น (ดู "
Oracle: การเพิ่มคลาสให้กับ Classpath ของไฟล์ JAR " สำหรับรายละเอียดเพิ่มเติม) ดังนั้นวิธีที่สวยงามที่สุดคือโค้ดต่อไปนี้ในสคริปต์บิลด์:
jar {
manifest {
attributes 'Main-Class': 'jrgradle.App'
}
from configurations.compileClasspath.collect { it.isDirectory() ? it : zipTree(it) }
}
ในการตั้งค่างาน jar เราระบุสิ่งที่จะเพิ่มลงในรายการไฟล์ jar (ดูที่ "
Oracle: การตั้งค่าจุดเข้าใช้งานของแอปพลิเคชัน ") จากนั้นเราก็บอกว่าการพึ่งพาทั้งหมดที่จำเป็นสำหรับการคอมไพล์จะรวมอยู่ใน jar อีกทางเลือกหนึ่งคือใช้ "
Gradle Shadow Plugin " อาจดูซับซ้อน แต่ปลั๊กอินอื่นๆ สามารถทำให้ชีวิตง่ายขึ้นได้ ตัวอย่างเช่น เมื่อสร้างเว็บแอปพลิเคชัน (ซึ่งต่างจากแอปพลิเคชัน Java ที่ทำงานปกติ) เราจะใช้ปลั๊กอินพิเศษ - "
ปลั๊กอิน Gradle War " ซึ่งมีพฤติกรรมที่แตกต่างออกไปและชีวิตของเราจะง่ายขึ้นที่นั่น (การพึ่งพาที่จำเป็นทั้งหมดจะ ถูกใส่ไว้ในไดเร็กทอรีพิเศษแยกต่างหากโดยปลั๊กอินเอง งานดังกล่าวได้รับการควบคุมโดยวิธีการออกแบบเว็บแอปพลิเคชัน แต่นั่นเป็นเรื่องราวที่แตกต่างไปจากเดิมอย่างสิ้นเชิง)
ผลลัพธ์
Gradleเป็นตัวเลือกที่ยอดเยี่ยมสำหรับระบบการสร้างโครงการ สิ่งนี้ได้รับการยืนยันจากข้อเท็จจริงที่ว่านักพัฒนาโครงการที่มีชื่อเสียงเช่น Spring และ Hibernate ใช้งาน เฉพาะสิ่งพื้นฐานที่สุดเท่านั้นที่ถูกกล่าวถึงข้างต้น เบื้องหลังคุณสมบัติและโอกาสมากมายที่นักพัฒนามีซ่อนอยู่ Gradle ยังสนับสนุนการสร้างโปรเจ็กต์หลายโมดูลซึ่งไม่ครอบคลุมในการทบทวนนี้ แต่ Gradle เองก็มีบทช่วยสอนที่ยอดเยี่ยม: “
การสร้างบิวด์หลายโปรเจ็กต์ ” ฉันหวังว่าบทวิจารณ์นี้จะแสดงให้เห็นว่าเอกสารของ Gradle เขียนไว้สำหรับผู้ใช้งานระดับ 5+ และคุณสามารถค้นหาสิ่งที่คุณต้องการได้อย่างง่ายดายหากคุณเข้าใจว่าจะต้องดูที่ไหน และสิ่งนี้จะเกิดขึ้นเมื่อคุณเข้าใจพื้นฐานแล้ว นอกจากนี้ Gradle ยังมีบทช่วยสอนที่ยอดเยี่ยมอีกด้วย ฉันอยากจะจบด้วยรายการเล็กๆ น้อยๆ ของสิ่งอื่นๆ ที่คุณสามารถดูได้โดยใช้ Gradle:
#เวียเชสลาฟ
GO TO FULL VERSION