Gradle ใน Android Studio คืออะไร

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

คำตอบสั้น ๆ

Gradle เป็นระบบสร้าง

คำตอบยาว ๆ

ก่อนที่ Android Studio คุณจะใช้ Eclipse เพื่อจุดประสงค์ในการพัฒนาของคุณและมีโอกาสที่คุณจะไม่รู้วิธีสร้าง APK Android โดยไม่มี Eclipse

คุณสามารถทำได้ในบรรทัดคำสั่ง แต่คุณต้องเรียนรู้ว่าแต่ละเครื่องมือ (dx, aapt) ทำอะไรใน SDK Eclipse ช่วยเราทุกคนให้อยู่ในระดับต่ำ แต่มีความสำคัญและมีรายละเอียดพื้นฐานโดยให้ระบบการสร้างของเราเอง

ทีนี้คุณเคยสงสัยไหมว่าทำไมresโฟลเดอร์ถึงอยู่ในไดเรกทอรีเดียวกับsrcโฟลเดอร์ของคุณ

นี่คือที่ระบบการสร้างเข้าสู่รูปภาพ ระบบสร้างจะใช้ไฟล์ต้นฉบับทั้งหมด ( .javaหรือ.xml) โดยอัตโนมัติจากนั้นใช้เครื่องมือที่เหมาะสม (เช่นนำjavaไฟล์คลาสและแปลงเป็นdexไฟล์) และจัดกลุ่มไฟล์ทั้งหมดเป็นไฟล์บีบอัดหนึ่งไฟล์ APK ที่รักของเรา

ระบบบิลด์นี้ใช้หลักการบางอย่าง: ตัวอย่างหนึ่งคือการระบุไดเรกทอรีที่มีไฟล์ต้นฉบับ (ใน Eclipse มันเป็น\srcโฟลเดอร์) หรือไฟล์ทรัพยากร (ใน Eclipse มันเป็น\resโฟลเดอร์)

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

Gradle เป็นระบบบิลด์อื่นที่ใช้คุณสมบัติที่ดีที่สุดจากระบบบิลด์อื่น ๆ และรวมเข้าเป็นหนึ่งเดียว มันได้รับการปรับปรุงตามข้อบกพร่องของพวกเขา มันเป็นระบบการสร้างตาม JVMซึ่งหมายความว่าคุณสามารถเขียนสคริปต์ของคุณเองใน Java ซึ่ง Android Studio ใช้

สิ่งดีๆหนึ่งที่เกี่ยวกับ gradle ก็คือว่ามันเป็นระบบปลั๊กอินตาม ซึ่งหมายความว่าหากคุณมีภาษาการเขียนโปรแกรมของคุณเองและคุณต้องการสร้างงานโดยอัตโนมัติในการสร้างแพคเกจ (ผลลัพธ์เช่น JAR สำหรับ Java) จากแหล่งข้อมูลคุณสามารถเขียนปลั๊กอินที่สมบูรณ์ใน Java หรือ Groovy (หรือ Kotlin ดูที่นี่ ) และ แจกจ่ายให้ทั่วโลก

ทำไม Google ถึงใช้มัน

Google เห็นหนึ่งในระบบการสร้างขั้นสูงที่สุดในตลาดและตระหนักว่าคุณสามารถเขียนสคริปต์ของคุณเองด้วยช่วงการเรียนรู้เพียงเล็กน้อยหรือไม่มีเลยและไม่ต้องเรียนรู้ Groovy หรือภาษาใหม่อื่น ๆ ดังนั้นพวกเขาจึงเขียนปลั๊กอิน Android สำหรับ Gradle

คุณต้องเห็นbuild.gradleไฟล์ในโครงการของคุณ ที่นี่คุณสามารถเขียนสคริปต์เพื่อทำให้งานของคุณเป็นแบบอัตโนมัติ รหัสที่คุณเห็นในไฟล์เหล่านี้คือรหัส Groovy ถ้าคุณเขียนSystem.out.println("Hello Gradle!");มันจะพิมพ์บนคอนโซลของคุณ

คุณสามารถทำอะไรในสคริปต์สร้าง?

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

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

คุณสามารถดูการพูดคุยโดย Xavier Ducrohet จากทีมนักพัฒนา Android บนGoogle I / Oที่นี่

นอกจากนี้ยังมีการพูดคุยอีกบน Android สตูดิโอโดยซาเวียร์และทอร์ Norbye ยังระหว่าง Google I / O ที่นี่

Gradleคือการสร้างระบบที่ทำงานบนAndroid สตูดิโอ

ในภาษาอื่นเช่น:

• AntและMavenของJava
• Rake of Ruby
• AAPของC
• NAntของ. NET
• ทำในLinux

นี่คือคำอธิบายโดยละเอียดเกี่ยวกับสิ่งที่Gradleเป็นและวิธีการใช้ใน Android Studio

สำรวจไฟล์ Gradle

1. เมื่อใดก็ตามที่คุณสร้างโครงการใน Android Studio ระบบสร้างจะสร้างไฟล์ Gradle build ที่จำเป็นทั้งหมดโดยอัตโนมัติ

สร้างไฟล์ Gradle

2. ไฟล์ Gradle build ใช้ a Domain Specific Language or DSLเพื่อกำหนดตรรกะบิลด์ที่กำหนดเองและเพื่อโต้ตอบกับองค์ประกอบเฉพาะ Android ของปลั๊กอิน Android สำหรับ Gradle

3. โครงการ Android Studio ประกอบด้วย 1 โมดูลหรือมากกว่าซึ่งเป็นส่วนประกอบที่คุณสามารถสร้างทดสอบและดีบักได้อย่างอิสระ แต่ละโมดูลมีไฟล์บิลด์ของตัวเองดังนั้นทุกโปรเจ็กต์ Android Studio มีไฟล์บิลเดอร์ Gradle 2 ชนิด

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

5. ไฟล์ Build-Level Build:แต่ละโมดูลมีไฟล์บิลด์ Gradle ของตัวเองที่มีการตั้งค่าการสร้างเฉพาะโมดูล คุณจะใช้เวลาส่วนใหญ่ในการแก้ไขไฟล์บิลด์ระดับโมดูลแทนที่จะเป็นไฟล์บิลด์ระดับบนสุดของโครงการ

หากต้องการดูbuild.gradleไฟล์เหล่านี้ให้เปิดแผงโครงการของ Android Studio (โดยเลือกแท็บโครงการ) และขยายโฟลเดอร์ Gradle Scripts สองรายการแรกในโฟลเดอร์ Gradle Scripts คือไฟล์สร้าง Gradle ระดับโครงการและโมดูล

ไฟล์สร้าง Gradle ระดับบนสุด

โครงการ Android Studio ทุกโครงการมีไฟล์ build Gradle build ระดับเดียว build.gradleไฟล์นี้เป็นรายการแรกที่ปรากฏในโฟลเดอร์ Gradle Scripts และมีการทำเครื่องหมายโครงการอย่างชัดเจน

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

ไฟล์สร้าง Gradle ระดับโมดูล

นอกเหนือจากไฟล์ build Gradle ระดับโปรเจ็กต์แต่ละโมดูลมีไฟล์ build Gradle ของมันเอง ด้านล่างเป็นรุ่นที่มีคำอธิบายประกอบของไฟล์สร้าง Gradle พื้นฐานระดับโมดูล

ไฟล์ Gradle อื่น ๆ

นอกเหนือจากไฟล์ build.gradle โฟลเดอร์ Gradle Scripts ของคุณยังมีไฟล์ Gradle อื่น ๆ ส่วนใหญ่คุณจะไม่ต้องแก้ไขไฟล์เหล่านี้ด้วยตนเองเนื่องจากไฟล์เหล่านั้นจะอัปเดตโดยอัตโนมัติเมื่อคุณทำการเปลี่ยนแปลงที่เกี่ยวข้องกับโครงการของคุณ อย่างไรก็ตามเป็นความคิดที่ดีที่จะเข้าใจถึงบทบาทที่ไฟล์เหล่านี้มีอยู่ในโครงการของคุณ

gradle-wrapper.properties (เวอร์ชั่น Gradle)

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

settings.gradle

ไฟล์นี้อ้างอิงโมดูลทั้งหมดที่ประกอบเป็นโครงการของคุณ

gradle.properties (คุณสมบัติโครงการ)

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

local.properties (ตำแหน่ง SDK)

ไฟล์นี้บอกถึงปลั๊กอินของ Android Gradle ซึ่งสามารถหาการติดตั้ง Android SDK ของคุณได้

หมายเหตุ: local.propertiesมีข้อมูลที่เฉพาะสำหรับการติดตั้ง Android SDK ในเครื่อง หมายความว่าคุณไม่ควรเก็บไฟล์นี้ไว้ในแหล่งควบคุม

การอ่านที่แนะนำ - การสอน Tutsplus

ฉันมีความเข้าใจที่ชัดเจนในการไล่ระดับจากนี้

Gradle เป็นเครื่องมือสร้างชนิดหนึ่งที่สร้างซอร์สโค้ดของโปรแกรม ดังนั้นจึงเป็นส่วนสำคัญของ Android Studio และจำเป็นต้องติดตั้งก่อนเริ่มพัฒนาแอปพลิเคชันของคุณ

เราไม่จำเป็นต้องติดตั้งแยกต่างหากเพราะ Android Studio ทำเพื่อเราเมื่อเราสร้างโครงการแรกของเรา

นิยาม :: Gradle สามารถอธิบายกลไกการสร้างโครงสร้างที่จะให้นักพัฒนาเครื่องมือและความยืดหยุ่นในการบริหารจัดการทรัพยากรของโครงการที่จะสร้างสร้างที่เป็นsmaller in size, targeting specific requirementsสำหรับอุปกรณ์บางอย่างของการกำหนดค่าบางอย่าง

การกำหนดค่าพื้นฐาน

1. minimumSdk
2. maximumSdk
3. targettedSdk
4. versionCode
5. versionName

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

การสร้างความหลากหลายของอาคาร

การรวมชนิดบิลด์กับบิลด์การสร้างเพื่อให้ได้วาไรตี้บิลด์บิลด์

 ====================                         ====================
|     BuildTypes     |                       |   ProductFlavours  |
 --------------------  ====================== --------------------
|  Debug,Production  |      ||       ||      | Paid,Free,Demo,Mock|
 ====================       ||       ||       ==================== 
                            ||       ||
                            VV       VV
 =================================================================
|           DebugPaid, DebugFree, DebugDemo, DebugMock            |
|  ProductionPaid, ProductionFree, ProductionDemo, ProductionMock |
 =================================================================

ลดขนาด

Gradle ช่วยในการลดขนาดของการสร้างที่สร้างขึ้นโดยการลบทรัพยากรที่ไม่ได้ใช้สิ่งที่ไม่ได้ใช้ออกจากห้องสมุดแบบบูรณาการ

การจัดการสิทธิ์การใช้งาน

เราสามารถระบุสิทธิ์บางอย่างสำหรับงานสร้างบางอย่างได้โดยเพิ่มสิทธิ์บางอย่างในบางสถานการณ์ตามความต้องการ

สร้างขึ้นเพื่ออุปกรณ์บางอย่าง

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

การอ้างอิงที่ดี

บทแนะนำ Vogella

คุณสามารถค้นหาทุกสิ่งที่คุณจำเป็นต้องรู้เกี่ยวกับ Gradle ได้ที่นี่: คู่มือผู้ใช้ Gradle Plugin

เป้าหมายของระบบ Build ใหม่

เป้าหมายของระบบบิลด์ใหม่คือ:

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

ทำไมต้อง Gradle?

Gradle เป็นระบบสร้างขั้นสูงเช่นเดียวกับชุดเครื่องมือสร้างขั้นสูงที่ช่วยให้การสร้างตรรกะการสร้างที่กำหนดเองผ่านปลั๊กอิน

นี่คือคุณสมบัติบางอย่างที่ทำให้เราเลือก Gradle:

• Domain Specific Language (DSL) เพื่ออธิบายและจัดการตรรกะการสร้าง
• สร้างไฟล์เป็นแบบ Groovy และอนุญาตให้ผสมองค์ประกอบที่ประกาศผ่าน DSL และใช้รหัสเพื่อจัดการองค์ประกอบ DSL เพื่อให้ตรรกะที่กำหนดเอง
• การจัดการการพึ่งพาในตัวผ่าน Maven และ / หรือ Ivy
• ยืดหยุ่นมาก อนุญาตให้ใช้แนวปฏิบัติที่ดีที่สุด แต่ไม่บังคับให้ทำสิ่งต่าง ๆ
• ปลั๊กอินสามารถเปิดเผย DSL และ API ของตัวเองเพื่อสร้างไฟล์เพื่อใช้งาน
• Tooling API ที่ดีช่วยให้การรวม IDE

ผมหมายสองกวดวิชาที่จะเขียนคำตอบ หนึ่ง , สอง

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

Gradle รวมส่วนที่ดีของเครื่องมือทั้งสองและให้คุณสมบัติเพิ่มเติมและใช้ Groovy เป็น Domain Specific Language (DSL) มันมีพลังและความยืดหยุ่นของเครื่องมือ Ant ที่มีคุณสมบัติ Maven เช่นวงจรชีวิตการสร้างและใช้งานง่าย

ทำไมต้อง Gradle? ทำไมตอนนี้?

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

สมมติว่าคุณต้องการคัดลอกไฟล์ไปยังตำแหน่งเฉพาะเมื่อคุณกำลังสร้างรุ่นที่วางจำหน่ายของโครงการของคุณ ในการระบุเวอร์ชันคุณต้องตรวจสอบสตริงในข้อมูลเมตาที่อธิบายถึงโครงการของคุณ หากตรงกับรูปแบบการกำหนดหมายเลขที่เฉพาะเจาะจง (เช่น 1.0-RELEASE) คุณคัดลอกไฟล์จากจุด A ไปยังจุด B จากมุมมองด้านนอกสิ่งนี้อาจฟังดูเป็นเรื่องเล็กน้อย หากคุณต้องพึ่งพา XML ภาษาการสร้างของเครื่องมือแบบดั้งเดิมจำนวนมากการแสดงตรรกะง่ายๆนี้จะค่อนข้างยาก

วิวัฒนาการของเครื่องมือสร้าง Java

ต้องอธิบาย Java build logic ใน XML XML เหมาะอย่างยิ่งสำหรับการอธิบายข้อมูลแบบลำดับชั้น แต่ไม่ย่อท้อในการแสดงการไหลของโปรแกรมและตรรกะตามเงื่อนไข เมื่อสคริปต์การสร้างเติบโตขึ้นในความซับซ้อนการบำรุงรักษารหัสอาคารกลายเป็นฝันร้าย

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

Maven 1ซึ่งวางจำหน่ายในเดือนกรกฎาคม 2004 พยายามทำให้กระบวนการนั้นง่ายขึ้น มันให้โครงการที่ได้มาตรฐานและโครงสร้างไดเรกทอรีเช่นเดียวกับการจัดการการพึ่งพา น่าเสียดายที่ตรรกะที่กำหนดเองนั้นใช้งานยาก

Gradleเหมาะสมกับเครื่องมือสร้างรุ่นนั้นและเป็นไปตามข้อกำหนดต่าง ๆ ของเครื่องมือสร้างที่ทันสมัย ​​(รูปที่ 1) มันให้ DSL ที่แสดงออกวิธีการกำหนดแนวทางและการจัดการการพึ่งพาที่มีประสิทธิภาพ มันทำให้ถูกต้องในการละทิ้ง XML และแนะนำภาษาแบบไดนามิก Groovy เพื่อกำหนดตรรกะการสร้างของคุณ ฟังดูน่าสนใจใช่มั้ย

Gradle รวมคุณสมบัติที่ดีที่สุดของเครื่องมือสร้างอื่น ๆ

ชุดคุณสมบัติที่น่าสนใจของ Gradle

เหตุใดจึงสร้างโครงการ Java ของคุณด้วย Gradle แทนที่จะเป็น Ant หรือ Maven

เครื่องมือสร้างเริ่มต้นสำหรับ Android (และดาวดวงใหม่ของเครื่องมือสร้างบน JVM) ได้รับการออกแบบเพื่อให้ง่ายต่อการเขียนสคริปต์ของการสร้างหลายภาษาที่ซับซ้อน คุณควรเปลี่ยนเป็นอย่างไรถ้าคุณใช้ Ant หรือ Maven

กุญแจสำคัญในการปลดล็อคคุณสมบัติด้านพลังงานของ Gradle ภายในสคริปต์สร้างของคุณอยู่ในการค้นพบและใช้โมเดลโดเมนดังที่แสดงในภาพด้านล่าง

Gradle ไม่สามารถทราบข้อกำหนดทั้งหมดที่เฉพาะเจาะจงสำหรับการสร้างองค์กรของคุณ โดยการแสดง hooks ลงในเฟสวงจรชีวิต, Gradle ช่วยให้สามารถตรวจสอบและกำหนดค่าพฤติกรรมการทำงานของสคริปต์สร้าง

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

อีกตัวอย่างหนึ่งคือวิธีที่คุณสามารถแสดงการขึ้นต่อกันของไลบรารีภายนอกปัญหาที่พบบ่อยมากได้รับการแก้ไขโดยเครื่องมือสร้าง Gradle นอกกรอบให้คุณมีสองบล็อกการกำหนดค่าสำหรับการสร้างสคริปต์ของคุณที่ช่วยให้คุณกำหนดการอ้างอิงและที่เก็บที่คุณต้องการดึงพวกเขาจาก หากองค์ประกอบ DSL มาตรฐานไม่ตรงกับความต้องการของคุณคุณสามารถแนะนำคำศัพท์ของคุณเองผ่านกลไกการขยายของ Gradle

บูรณาการกับเครื่องมือสร้างอื่น ๆ

Gradle เล่นได้ดีกับมดรุ่นก่อน Maven และ Ivy ดังที่แสดงในภาพด้านล่าง

การทำให้โครงการของคุณเป็นอัตโนมัติจาก Build เป็น Deployment

ในภาพ: สเตจของไพพ์ไลน์การปรับใช้

• รวบรวมรหัส

• การทดสอบหน่วยและการรวมการทำงาน

• ทำการวิเคราะห์รหัสแบบคงที่และสร้างความครอบคลุมการทดสอบ

• การสร้างการกระจาย

• การจัดเตรียมสภาพแวดล้อมเป้าหมาย

• การปรับใช้การส่งมอบ

• ทำการทดสอบควันและการทำงานอัตโนมัติ

ผมหมายสองกวดวิชาที่จะเขียนคำตอบ หนึ่ง , สอง

Gradle เป็นสร้างระบบ ระบบ Buildเป็นเครื่องมือซอฟต์แวร์ที่ออกแบบมาเพื่อทำให้กระบวนการรวบรวมโปรแกรมเป็นไปโดยอัตโนมัติ ระบบการสร้างมาในรูปแบบต่าง ๆ และใช้สำหรับงานสร้างซอฟต์แวร์ที่หลากหลาย ในขณะที่เป้าหมายหลักของพวกเขาคือการสร้างปฏิบัติการอย่างมีประสิทธิภาพ

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

ระบบการสร้างที่คล้ายกันไม่กี่ภาษาอื่น ๆ คือ (ดูรายการทั้งหมดที่นี่ ):

1. Apache Ant & Apache Maven - Java
2. sbt (Simple Build Tool) - สำหรับ Scala (กรอบงาน Play และอื่น ๆ )
3. AAP - เครื่องมือสร้างบน Python
4. Rake (Apache Builder) - Ruby
5. Leiningenสำหรับ Clojure

ฉันคิดว่ามันเสี่ยงต่อการถูกมองข้ามว่าเป็นคำถามที่ว่าทำไมประสบการณ์ของ Android Studio / Gradle นั้นแย่มาก

ประสบการณ์ Clojure ทั่วไป:

• ดาวน์โหลดโครงการที่มีรายการอ้างอิงใน project.clj
• Leiningen ได้รับความไว้วางใจจาก Clojars และ Maven
• รวบรวมโครงการ

ประสบการณ์ใช้งาน Android Studio / Gradle โดยทั่วไป:

• "นำเข้าโครงการ Eclipse ของฉัน"
• นำเข้าโครงการตกลง
• Gradle กำลังทำมันอยู่ที่ ... รอ ... รอ ... รอ ... รอ ... Gradle เสร็จสิ้นแล้ว
• คอมไพล์ ... ไม่สามารถคอมไพล์ได้เพราะฉันไม่รู้ว่า X คืออะไร / หาไลบรารี่ Y ไม่ได้

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

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

ในปี 2559 สิ่งต่าง ๆ เช่น Leiningen / Clojars หรือ npm ของโหนดหรือ pip ของ Python หรือ apk Debian (และฉันแน่ใจว่าผู้จัดการแพคเกจที่คล้ายกันจำนวนมากสำหรับภาษาและระบบอื่น ๆ ) ทั้งหมดทำงานได้อย่างสวยงาม ... การพึ่งพาที่ขาดหายไปเป็นเรื่องในอดีต

ยกเว้นกับ Android ตอนนี้ Android Studio เป็นสถานที่เดียวที่ฉันยังคงสัมผัสกับนรกที่พึ่งพายาก

ฉันอยากจะบอกว่านี่เป็นความผิดของ Google พวกเขาทำลายระบบนิเวศของ Android (และหลายพันโครงการ Android ที่มีอยู่ / บทเรียนออนไลน์) เมื่อพวกเขาตัดสินใจที่จะเปลี่ยนจาก Eclipse เป็น Android Studio / Gradle โดยไม่ต้องมีกระบวนการแปลงที่แข็งแกร่ง ผู้ที่มีโครงการที่ทำงานใน Eclipse จะไม่ปรับเป็น AS (สมมุติว่าเป็นความเจ็บปวดสำหรับพวกเขา) และผู้คนที่พยายามใช้โครงการเหล่านั้นใน AS กำลังตีปัญหาเดียวกัน

และถ้า Gradle เป็นระบบการสร้างที่ทรงพลังนี้ทำไมฉันยังคงจัดการการพึ่งพาอื่น ๆ มากมายใน sdk manager? เหตุใดโครงการที่ต้องการจึงไม่สามารถบอกได้ ndk ระบุสิ่งนี้ในไฟล์ Gradle เพื่อให้มันได้รับการติดตั้งและสร้างขึ้นโดยอัตโนมัติเมื่อจำเป็น ทำไม NDK จึงมีความพิเศษ? ในทำนองเดียวกันสำหรับแพลตฟอร์มเป้าหมาย? เหตุใดฉันจึงต้องติดตั้งพวกเขาอย่างชัดเจนใน IDE แทนที่จะตรวจสอบโครงการของฉันกับพวกเขาและให้สิ่งเหล่านี้เรียงลำดับให้ฉันอยู่เบื้องหลัง

Gradle เป็นระบบสร้างขั้นสูงเช่นเดียวกับชุดเครื่องมือสร้างขั้นสูงที่ช่วยให้การสร้างตรรกะการสร้างที่กำหนดเองผ่านปลั๊กอิน!

ข้อดี:

• Dsl - ภาษาเฉพาะโดเมนตาม Groovy
• DAG - กราฟ Acyclic กำกับ
• งานสร้างที่เพิ่มขึ้น
• รูปแบบโดเมนที่ขยายได้
• Gradle อยู่เสมอ
• ก่อนที่งานจะถูกดำเนินการ Gradle จะจับภาพของอินพุตและเอาต์พุตของภารกิจ
• ในกรณีที่สแนปชอตเปลี่ยนไปหรือไม่มีอยู่ Gralde จะดำเนินการงานนี้อีกครั้ง

รายการประกาศ

ผ่าน DSL คุณสามารถกำหนดค่ารายการรายการต่อไปนี้:

สร้างตัวแปร

ตามค่าเริ่มต้นปลั๊กอิน Android จะตั้งค่าโครงการโดยอัตโนมัติเพื่อสร้างทั้งการดีบักและแอปพลิเคชันรุ่นที่วางจำหน่าย

การอ้างอิง

1. อ้างอิงในท้องถิ่น:

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

2. การพึ่งพาระยะไกล:

ก่อนอื่นต้องเพิ่มที่เก็บข้อมูลลงในรายการจากนั้นจะต้องประกาศการพึ่งพาในลักษณะที่ Maven หรือ Ivy ประกาศสิ่งประดิษฐ์

Gradle คือภาษา Groovy JVM ที่ ant คือ Java โดยพื้นฐานแล้วมันเป็นเครื่องมือสร้าง Groovy ซึ่งแตกต่างจาก Ant มันขึ้นอยู่กับภาษา Groovy เต็มรูปแบบ ตัวอย่างเช่นคุณสามารถเขียนโค้ดสคริปต์ Groovy ในสคริปต์ Gradle เพื่อทำสิ่งต่างๆแทนที่จะใช้ภาษาโดเมนที่ระบุ

ฉันไม่ทราบว่าการรวมเฉพาะของ IntelliJ แต่คิดว่าคุณสามารถ "ขยาย" Groovy เพื่อให้คุณสามารถเขียนภาษาดั้งเดิม "build" เฉพาะและพวกเขาเพิ่งกลายเป็นส่วนหนึ่งของภาษา Groovy (metaprogramming ของ Groovy เป็นการพูดคุยกันทั้งหมด) IntelliJ / Google สามารถใช้ Gradle เพื่อสร้างภาษาการสร้างระดับสูงมาก แต่มันเป็นภาษาที่สร้างขึ้นบนมาตรฐานเปิดที่ขยายได้

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

• ปรับแต่งกำหนดค่าและขยายกระบวนการสร้าง

• สร้าง APK หลายรายการสำหรับแอปของคุณด้วยคุณสมบัติที่แตกต่างกันโดยใช้โครงการเดียวกัน

• ใช้รหัสและแหล่งข้อมูลซ้ำ

อ้างถึง

Gradle เป็นชุดเครื่องมือสร้างอัตโนมัติที่สามารถรวมเข้ากับสภาพแวดล้อมที่แตกต่างกันมากมายไม่เพียง แต่สำหรับโครงการ Android

นี่คือบางสิ่งที่คุณสามารถทำได้ด้วยการไล่ระดับสี

• จำเป็นต้องใช้การกำหนดค่าขั้นต่ำสำหรับโครงการใหม่เนื่องจาก Gradle มีการกำหนดค่าเริ่มต้นสำหรับโครงการสตูดิโอ Android ของคุณ

• ประกาศการพึ่งพา คุณสามารถประกาศไฟล์ jar อ้างอิงหรือไฟล์ไลบรารีที่โฮสต์ในเซิร์ฟเวอร์ภายในหรือระยะไกล

• Gradle จะสร้างไดเรกทอรีทดสอบและ APK ทดสอบจากแหล่งที่มาของโครงการของคุณโดยอัตโนมัติ

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

• Gradle สามารถสร้าง APK หลายชุดพร้อมแพ็คเกจที่แตกต่างกันและสร้างการกำหนดค่าจากโมดูลเดียว

ใน Android Studio Gradle เป็นเครื่องมือสร้างที่กำหนดเองที่ใช้สร้างแพ็คเกจ Android (ไฟล์ apk) โดยจัดการการขึ้นต่อกันและสร้างตรรกะการสร้างที่กำหนดเอง

ไฟล์ APK (ชุดแอปพลิเคชัน Android) เป็นไฟล์ซิปที่จัดรูปแบบพิเศษซึ่งมี

• รหัสไบต์
• ทรัพยากร (รูปภาพ, UI, xml ฯลฯ )
• ไฟล์มานิเฟสต์

ไฟล์ apk ได้รับการเซ็นชื่อและส่งไปยังอุปกรณ์โดยใช้ ADB (สะพานแก้จุดบกพร่อง Android) ที่ซึ่งถูกเรียกใช้งาน

Gradle เป็นเครื่องมือสร้างที่กำหนดเองและใช้สำหรับการสร้าง APK หรือที่รู้จักกันในชื่อแพคเกจแอปพลิเคชัน

โดย@Brian Gardner:

Gradle เป็นเครื่องมือสร้างที่กว้างขวางและผู้จัดการการพึ่งพาสำหรับการเขียนโปรแกรมโครงการ มันมีภาษาเฉพาะโดเมนตาม Groovy Gradle ยังให้การสนับสนุนการสร้างตามแบบแผนสำหรับโครงการหลายประเภทเช่น Java, Android และ Scala

คุณสมบัติของ Gradle:

1. การจัดการการพึ่งพา
2. ใช้ Ant จาก Gradle
3. ปลั๊กอิน Gradle
4. ปลั๊กอิน Java
5. ปลั๊กอิน Android
6. การสร้างหลายโครงการ

Gradle เป็นสิ่งที่ทำให้การสร้างโครงการ Android ที่ซับซ้อนโดยอัตโนมัติเกี่ยวข้องกับโค้ดจำนวน 10 พันบรรทัดจากหลาย ๆ แหล่งโครงการห้องสมุดและอื่น ๆ มันสามารถสร้าง APK ที่ปรับเงื่อนไขได้หลายแบบตามเงื่อนไขที่กำหนด - ถ้าคุณเป็น สนใจคำตอบอื่น ๆ ให้รายละเอียดเพิ่มเติมของแง่มุมของ Gradle นี้

อย่างไรก็ตามหากคุณยังใหม่กับการพัฒนา Android Gradle ในกรณี 99% เป็นสิ่งที่หยุดโครงการของคุณจากการสร้าง มันเป็นระบบที่ซับซ้อนที่ไม่สามารถพิสูจน์ได้ซึ่งมีผลทำให้กระบวนการสร้าง Android ยุ่งเหยิงและทำให้ผู้พัฒนาที่ไม่มีประสบการณ์ใช้งานได้อย่างมีประสิทธิภาพกล่าวคือเพื่อสร้างแอป Android ระดับเริ่มต้นที่ง่ายผู้สมัครที่ไม่สงสัยอาจต้องศึกษา เช่น:

• โครงสร้าง Android APK และระบบนิเวศ
• Android Studio
• Java Classpaths และการขึ้นต่อกัน
• Groovy
• สคริปต์การสร้าง Gradle
• เทคโนโลยีที่ซับซ้อนและน่าสนใจอื่น ๆ อีกมากมาย

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

อีกทางเลือกหนึ่งคือการเขียนเชลล์สคริปต์ที่สร้างโครงการของคุณโดยอัตโนมัติเครื่องมือที่มีอยู่ใน Android SDK ข้อดีของวิธีนี้มีมากมายสำหรับผู้เริ่มต้นอาจเป็นวิธีที่ดีที่สุดในการศึกษาและทำความเข้าใจกระบวนการสร้างและระบบนิเวศ Android และช่วยให้คุณควบคุมวิธีสร้างแอปของคุณได้อย่างสมบูรณ์ อย่างไรก็ตามวิธีนี้เหมาะสำหรับหัวเทคโนโลยีที่ไม่สามารถแก้ไขได้อย่างล้ำลึกกว่า noobs ที่ไม่มีประสบการณ์ในการทดลองใช้ Android

สิ่งที่เห็นได้ชัดเจนจากการขาด (โปรดแจ้งให้ฉันทราบหากมีสิ่งนั้น) คือระดับรายการน้ำหนักเบา IDE พร้อมชุดคุณสมบัติที่ลดลงซึ่งช่วยให้กระบวนการสร้างง่ายขึ้นในขณะที่ไม่บดบังมัน ใช้ Gradle (เกิดความผิดปกติกับ Ant) ควรทำให้ง่ายในการสร้าง APK ที่สอดคล้องกับการกำหนดค่าทั่วไปสองสามอย่างและใช้โครงสร้างโครงการที่สามารถพัฒนาเป็นโครงการ Android Studio แบบเต็มหากคุณตัดสินใจที่จะทำเช่นนั้น

ในแง่ธรรมดา Gradle เป็นเครื่องมือที่จัดทำโดย Android Studio เพื่อใช้สองกระบวนการที่สำคัญ:

1. สร้างโครงการของเรา
2. แพ็กเกจ AndroidManifest.xml, โฟลเดอร์ res และรหัสไบนารี่ลงในไฟล์ซิปที่จัดรูปแบบพิเศษที่เรียกว่า APK

ผลลัพธ์การค้นหาวิดีโอแนะนำจากเว็บ Android | สร้าง. gradle Gradle เป็นระบบการสร้าง (โอเพ่นซอร์ส) ซึ่งใช้สำหรับการสร้างอัตโนมัติการทดสอบการใช้งาน ฯลฯ ... ตัวอย่างเช่นงานง่าย ๆ ในการคัดลอกไฟล์บางไฟล์จากไดเรกทอรีหนึ่งไปยังอีกไดเรกทอรีหนึ่งสามารถทำได้โดยสคริปต์การสร้าง Gradle ก่อนการสร้างจริง กระบวนการเกิดขึ้น

ใน Android Studio Gradle ใช้สำหรับสร้างโครงการแอปพลิเคชัน Android ของเราดังนั้นจึงมีบทบาทในการสร้างระบบ ก่อน Android Studio ใน Eclipse เราใช้ในการรวบรวมและสร้างแอปพลิเคชั่นโดยใช้เครื่องมือบรรทัดคำสั่งซึ่งถูกยึดครองโดยขั้นตอนตาม GUI เพื่อสร้างและรันแอปพลิเคชัน Android ใน eclipse โดยใช้ ANT เครื่องมือพัฒนาแอปพลิเคชัน Android ทุกเครื่องต้องรวบรวมทรัพยากรซอร์สโค้ดจาวาไลบรารีภายนอกและรวมเข้ากับ APK สุดท้าย

Gradleเป็นระบบสร้างซึ่งรับผิดชอบในการรวบรวมรหัสการทดสอบการปรับใช้และการแปลงรหัสเป็นไฟล์. dex และดังนั้นจึงเรียกใช้แอปบนอุปกรณ์

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

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

มีสองมีbuild.gradleไฟล์ทุกโครงการสตูดิโอหุ่นยนต์ที่หนึ่งสำหรับการประยุกต์ใช้และอื่น ๆ ที่เป็นโครงการระดับ (ระดับโมดูล)สร้างไฟล์

ในการสร้างกระบวนการคอมไพเลอร์จะใช้เวลารหัสแหล่งทรัพยากรภายนอกไฟล์ JAR ห้องสมุดและAndroidManifest.xml (ซึ่งมี meta ข้อมูลเกี่ยวกับการสมัคร) และแปลงให้เป็น.dex (แฟ้ม Dalvik ปฏิบัติการ)ไฟล์ซึ่งรวมถึงbytecode bytecode นั้นได้รับการสนับสนุนโดยอุปกรณ์ Android ทั้งหมดเพื่อเรียกใช้แอพของคุณ APK Manager จะรวมไฟล์. dexและทรัพยากรอื่น ๆ ทั้งหมดไว้ในไฟล์ apk ไฟล์เดียว APK Packagerลงชื่อ debug หรือ release apkโดยใช้ debug หรือ release keystore ที่เกี่ยวข้อง

Debug apkนั้นใช้สำหรับการทดสอบหรือเราสามารถพูดได้ว่ามันถูกใช้ในขั้นตอนการพัฒนาเท่านั้น เมื่อแอปของคุณพร้อมคุณสมบัติที่ต้องการและคุณพร้อมที่จะเผยแพร่แอปพลิเคชันของคุณสำหรับการใช้งานภายนอกคุณต้องมีapk Release ที่ลงชื่อโดยใช้ keystore

ตอนนี้ให้แสงบางอย่างในไฟล์ gradle

setting.gradle ไฟล์ setting.gradle (Gradle settings) ใช้เพื่อระบุโมดูลทั้งหมดที่ใช้ในแอพของคุณ

build.gradle (ระดับโครงการ) ไฟล์ build.gradle ระดับบนสุด (โมดูล) เป็นไฟล์บิลด์ระดับโครงการซึ่งกำหนดการกำหนดค่าบิลด์ที่ระดับโปรเจ็กต์ ไฟล์นี้ใช้การกำหนดค่ากับโมดูลทั้งหมดในโครงการแอปพลิเคชัน Android

build.gradle (ระดับแอปพลิเคชัน) ไฟล์ build.gradle ระดับแอปพลิเคชันตั้งอยู่ในแต่ละโมดูลของโครงการ Android ไฟล์นี้มีชื่อแพ็กเกจของคุณเป็น applicationID, ชื่อรุ่น (apk เวอร์ชั่น), รหัสเวอร์ชัน, ขั้นต่ำและ sdk เป้าหมายสำหรับโมดูลแอปพลิเคชันที่เฉพาะเจาะจง เมื่อคุณรวมไลบรารีภายนอก (ไม่ใช่ไฟล์ jar) คุณจะต้องพูดถึงมันในไฟล์ gradle ระดับแอพเพื่อรวมไว้ในโครงการของคุณเป็นการอ้างอิงของแอปพลิเคชัน

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

./gradlew build - (
บิลด์โปรเจ็กต์) ./gradlew clean build - (บิลด์โปรเจ็กต์เสร็จสมบูรณ์)
./gradlew clean build - (รันการทดสอบ)
./gradlew wrapper - (เพื่อดูงานที่มีทั้งหมด)

Gradle = Groovy + Cradle Hans Dockter แสดงความคิดเห็น

ความสับสนเล็กน้อยไม่จำเป็นเมื่อมันถูกเรียกว่า "Build" หรือบางอย่างใน Android Studio

เราต้องการทำให้สิ่งต่าง ๆ เป็นเรื่องยากสำหรับตนเองในชุมชนการพัฒนา