Gradle notes

Groovy The closure of ( The key grammar )

• Definition : Be similar to lambda expression , Use when passing Anonymous inner class object The way

• characteristic : You can make a statement first , Then set up the agent to execute

Closure closure = {
    
    sayHello()
}
//  Test preparation 
class Foo {
    
    void sayHello() {
    
        println("Hello!!!")
    }
}
def foo = new Foo()
//  Start testing ,  It can be seen that  delegate  It's a member variable ,  And the type is anonymous interface 
closure.delegate = foo
closure()

• Call features :
  • Can be external ( Closure object in the last parameter )
  • Can be external + Omit parenthesis ( When there is only one parameter and it is a closure )

def running(Closure closure) {
    
  println("start~")
  closure()
  println("end.")
}

running({
     println("running...") })
//  Closures can be post 
running() {
    println("running...")}

def caculate(Closure closure) {
    
	def num1 = 10
  def num2 = 15
  closure(num1, num2)
}

caculate() {
    k,v -> println("$k + $v = ${k+v}")}
//  Brackets can be omitted ,  That is, the most familiar  Gradle  The way 
caculate {
    k,v -> println("$k + $v = ${k+v}") }

Gradle Construction process of

1. Generate a Settings object , perform settings.gradle Configure this object
2. Use Settings Object generation engineering structure , establish Project object
3. For all Project Execute corresponding build.gradle To configure

Script files build.gradle How to execute

To sum up ,build.gradle It's just one. Groovy Script file in format , Build in sequence , But turn it on build.gradle May still be confused , Characters and braces ？ With the longest used dependencies give an example

dependencies {
    
    // This dependency is found on compile classpath of this component and consumers.
    implementation 'com.google.guava:guava:26.0-jre'

    // Use JUnit test framework
    testImplementation 'junit:junit:4.12'
}

meanwhile implementation You can also write like this

implementation('com.google.guava:guava:26.0-jre')

implementation It's actually a function . Groovy Function calls in can be called in the form of spaces plus parameters

void foo(String params1, int param2) {
    
    println("param1 = $params1, param2 = $param2")
}

foo "hello", 996

Gradle and Groovy The relationship between

Gradle Support Kotlin or Groovy Written in two languages , The relationship between the two is Realization relationship . Groovy yes Gradle A kind of DSL ( Domain Specific Language i.e., Domain specific language )

Gradle Of DSL A build dedicated to configuration projects cannot be used for other work . Grammar is still Groovy Its own grammar , But the call can only rely on Gradle Stipulated API Mode or a specific set of specifications . Emphasize one Specific special ( Appointment )

And DSL (HTML、Makefile、LaTeX、AWK) The corresponding is a general language that can do any work (Java 、C/C++)