Gradle 学习 ----Gradle 与Idea整合

package com.atguigu.demo

class Demo01BasicNotice {
/**---------------------------------------------------------------
  1.groovy中使用def 定义属性、方法,def支持动态类型声明
  2.单行注释：// 多行注释: /**
  3.gradle语句最后的;(分号)是可以省略的
  4.groovy可以为属性自动生成getter、setter方法
  5.方法声明时： 参数类型、返回值类型、return关键字可以省略,方法调用时,在不引起歧义的地方，可以省略()
  6.变量引用时： 在不引起歧义的前提下{}也可以省略,在容易引起歧义的地方就不能省略{}
  7.对象属性赋值：
       方式1: 对象.属性名=
       方式2: 对象["属性名"]=
       方式3: 对象.属性setter方法()
       方式4: 具名构造器的方式
    读取属性值：
       方式1: 对象.属性名
       方式2: 对象["属性名"]
       方式3: 对象.属性getter方法()
 */


    def  description="描述信息"

    def bookname="斗破苍穹"

    def sale(price){
       "the book is  $price"
    }

    def sum(price1,price2){
       "$price1 + $price2 = ${price1+price2}"
    }
}

def num1=1; 
def num2= 2;
println "$num1 + $num2 = ${num1+num2}"

def num1=1; 
def num2=2;
def str1="1d"; //双引号
def str2='dsd'; //单引号
//双引号运算能力,单引号用于常量字符串,三引号相当于模板字符串，可以支持换行
println "$num1 + $num2 = ${num1 + num2}"
//基本数据类型也可以作为对象使用,可以调用对象的方法
println(num1.getClass().toString()) 
println(str1.getClass().toString()) 
println(str2.getClass().toString())

package com.atguigu.demo

//--------------------------------字符串----------------------------------------
def desc="测试";

def str1='单引号,不支持变量引用，不支持换行操作 ${desc}';
println(str1)

def str2="双引号,支持变量引用，不支持换行操作 ${desc}";
println(str2)

def str3='''模板字符串,不支持变量引用，支持换
                  行操作 ${desc}''';
println(str3)


//基本数据类型也可以作为对象使用,可以调用对象的方法
println(str1.getClass().toString())
println(str2.getClass().toString())
println(str3.getClass().toString())

单引号,不支持变量引用，不支持换行操作 ${desc}
双引号,支持变量引用，不支持换行操作 测试
模板字符串,不支持变量引用，支持换
                  行操作 ${desc}
class java.lang.String
class org.codehaus.groovy.runtime.GStringImpl
class java.lang.String

Process finished with exit code 0

package com.atguigu.demo

//--------------------------------------list增删改查操作-----------------------
//--------------------------------增------------------------
//1.增:在集合中添加元素
def list = [5, 6, 7, 8]
assert list instanceof java.util.List
list.add(12)
println list.size()
//2.增:集合与集合相加
def list2 = [1,2,3,4]
println list.plus(list2) //将list2添加在list之后

//--------------------------------删------------------------
//2.删:删除下标为2的元素
list.remove(2)
println(list)

//2.删:删除集合中指定的元素
list.removeElement(12)
println(list)

//2.删:从list集合中移除list3集合中的元素
def list3 = [6,8]
list.removeAll(list3)
println(list)

//2.删：从list表中弹出最后一个元素
println list.pop()
println(list)
//--------------------------------改------------------------


list.putAt(2, 10) //等效于 list[2] = 10
println(list)

//--------------------------------------list增删改查操作-----------------------
[1, 2, 3].each({
    println "Item: $it"//it是对应于当前元素的隐式参数
})
//size():获取此列表中的元素数。
//contains(): 如果此列表包含指定的值，则返回 true。

//--------------------------------------map的增删改查操作--------------------------------

// 键 Key 可以不使用引号 , 可以使用单引号 '' , 也可以使用双引号 ""
def map = [J:"Java", "K":"Kotlin", 'G':"Groovy"]
//------------------------------------map的增--------------------------
map.put("P","Python")
//map.putAll():增加一个map
println(map)
//------------------------------------map的删--------------------------
map.remove("P")   //根据某个键做移除
map.remove("J","Java")//移除某个键值对
println "删:"+map
//------------------------------------map的改--------------------------
// "-" "+" 操作符重载
map2 = map - [K:"Kotlin"]
println map2

map3 = map + [G:"Gradle"] //键相同会产生覆盖
println map3
//------------------------------------map的查--------------------------
map.each { key, value ->
    println "key:$key  value:$value"
}

map.each { entry ->
    println "key: $entry.key value: $entry.value"
}

5
[5, 6, 7, 8, 12, 1, 2, 3, 4]
[5, 6, 8, 12]
[5, 6, 8]
[5]
5
[]
[null, null, 10]
Item: 1
Item: 2
Item: 3
[J:Java, K:Kotlin, G:Groovy, P:Python]
删:[K:Kotlin, G:Groovy]

import groovy.xml.MarkupBuilder 
def xml = new MarkupBuilder() 
assert xml != null

import java.lang.* 
import java.util.* 
import java.io.* 
import java.net.* 
import groovy.lang.* 
import groovy.util.*
import java.math.BigInteger
import java.math.BigDecimal

package com.atguigu.demo

import groovy.xml.MarkupBuilder
import java.text.SimpleDateFormat

def xml = new MarkupBuilder()
assert xml != null


def sdf =new SimpleDateFormat("yyyy-MM-dd");
println(sdf.format(new Date()))

2022-07-29

def z 
try {
    def i = 7, j = 0 
    try {
        def k = i / j 
        assert false
    } finally {
        z = 'reached here'
    }
} catch ( e ) {
    assert e in ArithmeticException 
    assert z == 'reached here'
}

//闭包体完成变量自增操作
{ item++ }
//闭包使用 空参数列表 明确规定这是无参的
{ -> item++ }
//闭包中有一个默认的参数[it]，写不写无所谓
{ println it }
{ it -> println it }
//如果不想使用默认的闭包参数it,那需要显示自定义参数的名称
{ name -> println name }
//闭包也可以接受多个参数
{ String x, int y ->
    println "hey ${x} the value is ${y}"
}
//闭包参数也可是一个对象
{ reader ->
    def line = reader.readLine() 
    line.trim()
}

def isOdd = { int i -> i%2 != 0 } 
assert isOdd(3) == true
assert isOdd.call(2) == false

def isEven = { it%2 == 0 } 
assert isEven(3) == false 
assert isEven.call(2) == true

//无参闭包
def run(Closure closure){ 
    println("run start...")
    closure() println("run end...")
}

run {
    println "running......"
}

//有参闭包
def caculate(Closure closure){
    def num1=1;
    def num2=3; 
    println("caculate start...")
    closure(num1,num2) 
    println("caculate end...")
}
caculate {x,y -> println "计算结果为：$x+$y=${x+y}"} //在build.gradle文件中我们见到的很多都是闭包格式的。

package com.atguigu.demo;

/*====================================================
      闭包：{}
        定义：是一个开放的、匿名的代码块，它可以接受参数、也可以有返回值。闭包可以引用其周围作用域中声明的变量。
        语法：{ [closureParameters -> ] statements }
        调用：
            第一步：将闭包赋值给一个变量
            第二步: 变量名()、变量名.call()

        闭包在实际开发中的使用：作为方法的参数使用
======================================================*/

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

running({println("running........")})


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

//闭包作为方法的最后一个参数，那么闭包可以写在方法外边
caculate{k,v->println("$k + $v = ${k+v}")}

running start...
running........
running end...
10 + 15 = 25

plugins{
id‘war’
id'org.gretty'version' 2. 2. 0 '
}

repositories {
// 指定 jcenter 仓库，一定要放在前面
jcenter()
mavenCentral()
}

gretty {
    httpPort = 8888
    contextPath = "/web"
    debugPort = 5005	// default 
    debugSuspend = true // default  
    httpsEnabled = true
    managedClassReload=true // 修改了类之后重新加载
    //servletContainer = 'tomcat8' //如果不指定默认的servlet容器，支持tomcat7/8，默认是使用的是Jetty服务器
    httpsPort = 4431
}

gradle appRun

dependencies {
    testImplementation group: 'junit' ,name: 'junit', version: '4.12'
}
test {
    useJUnit()
}

dependencies {
    testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.1' 
    testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.1'
}
test {
    useJUnitPlatform()
}

test {
    enabled true 
    useJUnit() 
    include 'com/**'
    exclude 'com/abc/**'
}