Java构建工具

  1. Ant：几乎消失

  2. Maven：目前使用最普遍的一种，主要功能有依赖管理、多模块构建、一致的项目结构、一致的构建模型、插件机制。

  3. Gradle：继Maven之后的新一代工具，相比Maven更简洁。

Gradle优势

  1. 依赖管理

  2. 编译打包：可以使用脚本进行打包，修改文件、添加或排除依赖类或资源，打包后自动上传等。

  3. 多项目支持

  4. 多语言支持：java、c++、scala

  5. 跨平台：

安装配置

  1. 官网下载：Gradle | Releases

  2. 解压到自己的目录

  3. 配置环境变量：GRADLE_HOME

  1. 配置系统变量：在系统变量Path中添加：%GRADLE_HOME%

  1. 配置本地仓库路径：GRADEL_USER_HOME，会将jar下载到该路径中

  1. 配置镜像源

在Gradle的安装目录下的 init.d 文件夹下，新建一个 init.gradle 文件

 allprojects {
     repositories {
         //本地存放依赖的路径
         maven { url 'file:///D:\\gradle\\gradle-8.12\\gradle-repository'}
         mavenLocal()
         maven { name "Alibaba" ; url "https://maven.aliyun.com/repository/public" }
         mavenCentral()
     }
 ​
     buildscript { 
         repositories { 
             maven { name "Alibaba" ; url 'https://maven.aliyun.com/repository/public' }
             maven { name "M2" ; url 'https://plugins.gradle.org/m2/' }
         }
     }
 }
 ​

Gradle-Wrapper

为了简化Gradle的安装配置，如果本地没有与wrapper.properties版本相同的环境，idea则会自动下载一个

 # distributionBases与distributionPath配合使用，指定gradle解压后存放的位置
 # GRADLE_USER_HOME表示用户目录，系统配置的环境变量
 ​
 distributionBase=GRADLE_USER_HOME 
 distributionPath=wrapper/dists
 # gradle的下载地址
 distributionUrl=https\://services.gradle.org/distributions/gradle-8.12.1-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 # 指定gradle.zip的存放位置
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
 ​

gradle配置

 # 所使用的插件
 plugins {
     id 'java'
     id 'org.springframework.boot' version '3.4.3'
     id 'io.spring.dependency-management' version '1.1.7'
 }
 ​
 apply plugin: 'java' # 和plugins里面使用是相同的效果
 group = 'com.example'
 version = '0.0.1-SNAPSHOT'
 ​
 java {
     toolchain {
         languageVersion = JavaLanguageVersion.of(21)
     }
 }
 ​
 configurations {
     compileOnly {
         extendsFrom annotationProcessor
     }
 }
 ​
 # 仓库，程序所依赖的jar存放位置
 repositories {
     mavenCentral()
 }
 ​
 # 项目依赖的jar包
 dependencies {
     implementation 'org.springframework.boot:spring-boot-starter-web'
     compileOnly 'org.projectlombok:lombok'
     developmentOnly 'org.springframework.boot:spring-boot-devtools'
     annotationProcessor 'org.projectlombok:lombok'
     testImplementation 'org.springframework.boot:spring-boot-starter-test'
     testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
 }
 ​
 # 声明module的任务
 tasks.named('test') {
     useJUnitPlatform()
 }
 ​

implementation:默认scope，包含编译、运行时，但是不会暴露在类库使用者的编译时。

api:和implementation类似，包含编译、运行时，允许暴露自己的类库依赖给类库的使用者。

compileOnly、runtimeOnly：编译可见，允许可见，与maven的provided接近

testCompileOnly、testRuntimeOnly：测试

Groovy基础

安装

  1. 链接：https://www.apache.org/dyn/closer.lua/groovy/4.0.26/distribution/apache-groovy-binary-4.0.26.zip?action=download

  2. 解压，配置环境变量：%GROOVY_HOME%

语法

基于JVM的动态语言，和java类似，动态脚本语言。

  1. 变量，默认是public

  println("hello world")
  def age = 1
  def name = "zhangsan"

  1. 方法

 class HelloWorld {
 // 方法使用返回类型或者def关键词定义，可以接受任意类型的参数
     static def add(int a,int b){
         println a + b
     }
     def add (a,b){
         println (a - b)
     }
 ​
 static void main(String[] args) {
         add(1,2)
     }
 }
 ​
 ​
 // 也可以直接定义在类外面
 def add (a,b){
         println (a - b)
     }
 println add(1,2)
 ​
 // 如果指定返回值数据类型，可以不用def修饰
 int add (a,b){
         println (a - b)
     }
 println add(1,2)
 ​
 // 如果不使用return，返回值是方法最后一行的执行结果
 int add (a,b){
        a+b
     }

  1. 类

 class Student {
     String name
     Integer age
     def add(int age){
         this.age ++
     }
 }
 ​
 def stu = new Student()
 stu.add(20)
 println(stu.age) // 21
 ​
 // 默认public
 // 没有可见性的修饰符会自动生产getter、setter
 // 类不需要与它的源文件有相同的名称，但是建议采用相同的名称

  1. 断言

 assert 1+2 == 1
 ​
 ​
 ​

输出：

 assert 1+2 == 1
         |  |
         3  false

  1. 循环

 def a = 0
 for (i in 0..3){
     a++
 }
 ​
 def b = 0
 for (i in 0..<10) {
     b++
 }
 ​
 def c = 0
 for (i in [0,1,2]){
     c++
 }
 ​
 def map = ['a':1,'b':2]
 for (i in map.values()){
     println(i)
 }
 for (int i = 0;i<1;i++) {
     
 }
 ​

  1. switch:兼容java，还兼容更多类型的方式

 def res = ""
 switch (a){
     case "a":res = "a" ;break
     case 1..2:res = "1";break
     case String:res = "str";break
     default:res = "..."
 }

  1. 数据类型：java的基础数据类型，Groovy中的容器类，闭包

字符串：单引号不支持插值；双引号支持；三引号可以跨行，但是不支持插值

 def aa = ""
 println('sss')
 println("fff $aa")
 println("fff ${aa}")
 println("""
 a
 b
 """)
 ​

  1. List:默认java的list

 def arr = [1,2]
 // 强制类型转换
 def linkList = arr as LinkedList
 // 追加元素
 arr << 3
 assert arr[0] == 1 
 assert arr[-1] == 2 //2
 println(arr)

  1. Map

 def map = ['1':1,'2':2]
 assert map['1'] == 1
 assert map.'1' == 1
 ​
 def key = 'name'
 def person = [key:'hhh']// 这个键是key这个字符串，而不是name
 println  person.containsKey('name')// false
 println  person.containsKey('key')// true
 person = [(key):'hhh'] // 使用（）代表这是一个变量，而不是字符串
 assert person.containsKey('name')

  1. 闭包：类似箭头函数，可以接受参数和返回值

 def run = {int a -> println(a)}
 run( 1)
 ​
 def test1(Closure aaa){
     aaa() // 调用闭包
 }
 test1 {run(1)}