การแนะนำ Gradle อย่างรวดเร็ว

การแนะนำ

หัวข้อของการรีวิวนี้คือระบบสร้างอัตโนมัติ Gradle ในภาษาอังกฤษ build system เรียกว่าBuild Tools เหตุใดสิ่งนี้จึงจำเป็น? การสร้างโปรเจ็กต์ด้วยตนเองใน 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 แบบกำหนดเอง ": คำแนะนำทีละขั้นตอนในการสร้างงาน
• " สร้างสคริปต์เบื้องต้น ": พื้นฐานเกี่ยวกับงานและการใช้งาน

การพึ่งพาอาศัยกัน

งานหลักอย่างหนึ่งของระบบบิลด์คือการจัดการการพึ่งพา ซึ่งก็คือไลบรารี/เฟรมเวิร์กที่โปรเจ็กต์ของเราต้องการ ระบบการสร้างจะต้องตรวจสอบให้แน่ใจว่าพร้อมใช้งานในเวลาที่เหมาะสมและประกอบชิ้นส่วนสุดท้ายของแอปพลิเคชันของเราด้วยวิธีที่ถูกต้อง ตามค่าเริ่มต้น หลังจาก 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:

• Gradle Training (มักฟรี)
• Gradle สำหรับ Android และ Java
• การสร้างแอปพลิเคชันเว็บ Java
• เยฟเกนีย์ โบริซอฟ — Power of Gradle (2013)

#เวียเชสลาฟ