dependencies {
        classpath "com.android.tools.build:gradle:4.1.3"
     }

  def a=1;

     def b="hello world";

     def int c=1;

     def test(){ //定義方法
        
         println("123");

         return 0;

     }

def a=1;

    a="Hello World"   

    def test(a){

       println(a);

       1; //方法的返回值為1，返回值可以省略return 

    }

    test 1  //調(diào)用方法，可以省略括號

 def int a=1;

    def double b=1.1;

    println(a.class);

    println(b.class);

def a=1;

    String b="Hello ${a}" //字符串結(jié)果為 Hello 1

//定義閉包

     def closure = { println("Hello World") }

     def closure1= { a,b -> a+b  }

     //調(diào)用閉包

     closure();

     closure.call(); //函數(shù)式調(diào)用或者使用call方式調(diào)用,這兩種方式調(diào)用閉包都是可以的

     def a=closure1(1,2);

     def a=closure1.call(1,2);

//先寫一個Java中的語法

    List list=new ArrayList<>();

    list.add(1);

    list.add(2);
    
    //Groovy除了像Java中一樣寫法，還可以這樣來定義List

    def lists=[1,2,3];

    lists.add(4);

    lists.add(5);

    print(lists.class); //我們打印這個lists的class,它就是java.util.ArrayList

 def result=lists.find{
      
      return it%2==0;

    } //這里find查找方法傳入的參數(shù)是一個閉包，返回的是第一個能整除2的元素
    
 def results=lists.findAll {

      return it%2==0;

    } //查找List中所有的能整除2的元素 

 def resList=lists.sort {

        x1,x2->  return x1==x2?0:x1>x2?1:-1

    } //List中sort方法，傳入一個閉包參數(shù)，用于對List排序
    
lists.each{
       
       print(it+",");


    } //each方法遍歷List

 //先寫一個Java中Map的寫法

     Map map=new HashMap<>();
     
     map.put("a",1);
     
     map.put("b",2);

     //Groovy除了像Java中一樣寫法，還可以這樣來定義Map

     def map=["a":1,"b":2];

     prinlt(map.get("a")); //獲取某個鍵對應的值

     prinltn(map.a);//map.key 這種方式也可以獲取map中某個鍵的值

     println(map.getClass()); //這樣定義map,Map的默認數(shù)據(jù)類型是java.util.LinkedHashMap

                              //這里我們是使用map.getClass()來獲取map的類，而不能map.class來獲取

                              //是因為map有map.key這種用法，用來獲取map中鍵為key的值，所以如果寫map.class

                              //會被認為是獲取map中鍵為class的值，所以這里只能用map.getClass()來獲取map的class類型
    

    def v=map.find {

     if (it.getValue()==2){
          return it;
      }

   } //map中的find方法，傳入一個閉包參數(shù),可以查找map中第一個滿足條件的一個Entry(鍵值對實體)

   println(v.key);

   map.each {

     println(it.getKey()+":"+it.getValue());

   } //可以使用map的each方法，參數(shù)是一個閉包，來遍歷map

   map還有一些其他方法，所以這里可不一一列舉了

   def resMap=map.sort {

      e1,e2->

        return e1.key==e2.key?0:e1.key>e2.key?1:-1

  } //map的sort方法傳入一個閉包參數(shù),對map進行排序，返回的是一個排序后的新的map,注意原map并沒有變化

def rang=1..10 //這里相當于定義了一個集合，集合中的元素值從1到10

   println(range.class); //groovy.lang.IntRange

   println(rang[0]) //range[0]為1 

   println(range.getFrom());// 1 range.getFrom() 獲取range的下限值

   println(range.getTo()); //10 range.getTo()獲取range的上限值

   //如果定義的def range=10..1; range.getFrom()和range.getTo()的值還是1,10

   //因為10..1 下限值還是1，上限值還是10  

   def charRange='f'..'a';

   charRange.each {

     println(it)

   } //打印出 f,e,d,c,b,a

   def score=60;

   switch (score){
    case 0..59:
        println("及格");
        break
    case 60..85:
        println("及格");
        break
    case 86..100:
        println("優(yōu)秀");
        break
}

trait MyTrait{

      abstract void test();

      void play(){

         prinlt("play game");

      }

    }  

    class TestClass implement MyTrait{

       @Override 
       void test(){

       }

    }

plugins {  id 'groovy'  }   或者 apply plugin:'groovy'

dependencies {

    implementation 'com.android.tools.build:gradle:4.1.3'
    implementation gradleApi()
 
  }

package com.example.plugin

import com.android.builder.model.SigningConfig
import org.gradle.api.DefaultTask
import org.gradle.api.tasks.TaskAction

class GiaGuTask extends DefaultTask{


    GiaGuBean mGiaGuBean;

    SigningConfig signingConfig;

    File apkFile;

    GiaGuTask() {
        group="jiagu"
    }

    @TaskAction
    void run() {

        project.exec {

            it.commandLine(
                    "java",
                    "-jar",
                    mGiaGuBean.getJiaGuTools(),
                    "-login",
                    mGiaGuBean.getUserName(),
                    mGiaGuBean.getPassword(),

            );

        }

        if (signingConfig) {

            project.exec {

                it.commandLine(
                        "java",
                        "-jar",
                        mGiaGuBean.getJiaGuTools(),
                        "-importsign",
                        signingConfig.storeFile.absolutePath,
                        signingConfig.storePassword,
                        signingConfig.keyAlias,
                        signingConfig.keyPassword
                )

            }
        }

        project.exec {


            it.commandLine("java",

                    "-jar",

                    mGiaGuBean.getJiaGuTools(),

                    "-jiagu",

                    apkFile.absolutePath,

                    apkFile.parent,

                    "-autosign"

            )

        }


    }

}

package com.example.plugin

class GiaGuBean {

    String userName;
    String password;
    String jiaGuTools

    String getUserName() {
        return userName
    }

    void setUserName(String userName) {
        this.userName = userName
    }

    String getPassword() {
        return password
    }

    void setPassword(String password) {
        this.password = password
    }

    String getJiaGuTools() {
        return jiaGuTools
    }

    void setJiaGuTools(String jiaGuTools) {
        this.jiaGuTools = jiaGuTools
    }

}

package com.example.plugin

import com.android.build.gradle.AppExtension
import com.android.build.gradle.api.ApplicationVariant
import com.android.build.gradle.api.BaseVariantOutput
import com.android.builder.model.SigningConfig
import org.gradle.api.Plugin
import org.gradle.api.Project

class GiaGuPlugin implements Plugin<Project>{

    @Override
    void apply(Project project) {
        GiaGuBean giaGuBean = project.extensions.create("jiagu", GiaGuBean.class);

        project.afterEvaluate {

            AppExtension appExtension = project.extensions.android;

            appExtension.applicationVariants.all {
                    //debug/release

                ApplicationVariant variant ->

                    //對應變體(debug/release)的簽名配置
                    SigningConfig signingConfig = variant.signingConfig;

                    variant.outputs.all {

                        BaseVariantOutput baseVariantOutput ->

                            //輸出的APK文件
                            File apkFile = baseVariantOutput.outputFile;

                            //創(chuàng)建加固任務
                            GiaGuTask giaGuTask = project.tasks.create("jiagu${variant.baseName.capitalize()}", GiaGuTask.class);
                            giaGuTask.mGiaGuBean = giaGuBean;
                            giaGuTask.signingConfig = signingConfig;
                            giaGuTask.apkFile =apkFile;

                    }
            }


        }

  implementation-class=com.example.plugin.GiaGuPlugin

apply plugin:'maven-publish'

publishing{

            publications{

            Jiagu(MavenPublication){ //Jiagu 這個名字隨意取

            from components.java  //這個表示要把源碼生成的jar包上傳

            groupId 'com.example' //配置插件的groupId(分組ID)

            artifactId "plugin"   //配置ID

            version "1.0" //配置版本號
        }

     }
     
   } 

repositories {

           ...
           
           mavenLocal()

         }                         

      dependencies {
        ...
        classpath "com.example:plugin:1.0" 

        //就是之前上傳的是偶配置groupId:artifactId:version

      } 

apply plugins:'com.example.plugin' //就是開發(fā)插件的時候resources/META-INF/gradle-plugins/com.example.plugin.properties 這個文件的名字

plugins {

      ...

      id 'com.example.plugin' 

      //就是開發(fā)插件的時候resources/META-INF/gradle-plugins/com.example.plugin.properties 這個文件的名字 

}