# 태스크(Task)

Gradle은 태스크(Task) 기반 빌드 시스템으로, 프로젝트를 구성하고 자동화할 수 있는 강력한 기능을 제공한다.

태스크(Task)는 Gradle에서 실행 가능한 단위이며, 프로젝트를 빌드하는 데 필요한 작업(예: 컴파일, 테스트, 패키징 등)을 정의한다. Gradle은 기본적으로 여러 태스크를 제공하지만, 사용자가 직접 정의하여 실행할 수도 있다.  

## 태스크 목록 확인
```bash
./gradlew tasks
```

## 기본적인 태스크 정의와 실행  

Gradle에서는 `build.gradle.kts` 파일에서 태스크를 정의할 수 있다.  

### 간단한 태스크 정의  

Kotlin DSL을 사용하여 기본적인 태스크를 정의하는 방법을 살펴보자.  

```kotlin
tasks.register("hello") {
    doLast {
        println("Hello, Gradle!")
    }
}
```

위 태스크는 `hello`라는 이름으로 등록되며, 실행하면 `"Hello, Gradle!"`이 출력된다.  

#### `tasks.register` vs `tasks.create`  

태스크를 등록하는 방법에는 `tasks.register`와 `tasks.create`가 있다.  

```kotlin
// 지연 평가 방식 (Lazy Evaluation)
val lazyTask = tasks.register("lazyTask") {
    doLast {
        println("이 태스크는 실행 시점에서 평가됩니다.")
    }
}

// 즉시 평가 방식 (Eager Evaluation)
val eagerTask = tasks.create("eagerTask") {
    doLast {
        println("이 태스크는 빌드 스크립트가 로드될 때 즉시 평가됩니다.")
    }
}
```

- `tasks.register`는 **지연 평가(Lazy Evaluation)** 방식으로, 태스크가 실행될 때까지 구성이 지연된다.  
- `tasks.create`는 **즉시 평가(Eager Evaluation)** 방식으로, 스크립트가 로드될 때 바로 실행된다.  

일반적으로 성능상의 이유로 `tasks.register`를 사용하는 것이 권장된다.  

### 태스크 실행 방법  

터미널에서 다음 명령어를 실행하면 정의한 태스크를 실행할 수 있다.  

```sh
./gradlew hello
```

### 여러 액션을 포함한 태스크 

태스크 내에서 여러 개의 액션을 정의할 수도 있다.  

```kotlin
tasks.register("greet") {
    doFirst {
        println("처음 실행되는 액션")
    }
    doLast {
        println("마지막으로 실행되는 액션")
    }
}
```

이 태스크를 실행하면 `"처음 실행되는 액션"`이 먼저 출력되고, `"마지막으로 실행되는 액션"`이 나중에 출력된다.  

### 태스크 종속성(Task Dependencies)  

특정 태스크가 다른 태스크 이후에 실행되도록 설정할 수 있다.  

```kotlin
tasks.register("taskA") {
    doLast {
        println("Task A 실행")
    }
}

tasks.register("taskB") {
    dependsOn("taskA") // taskA가 먼저 실행됨
    doLast {
        println("Task B 실행")
    }
}
```

위 예제에서 `taskB`를 실행하면 `taskA`가 먼저 실행된 후 `taskB`가 실행된다.  

## 사용자 정의 확장 프로퍼티  

Gradle에서는 사용자 정의 확장 프로퍼티를 추가할 수 있다.  

```kotlin
val greeting: String by project

tasks.register("customGreet") {
    doLast {
        println("Greeting message: $greeting")
    }
}
```

그리고 `gradle.properties` 파일에 값을 추가하면 실행 시 사용할 수 있다.  

```properties
greeting=Hello, Kotlin DSL!
```

## 빝트인 태스크
```kotlin
tasks.register<Copy>("copyTask") {
    from("source")
    into("target")
    include("*.war")
}
```
* Copy - Copy is useful to copy files around.
* Delete - Delete is useful to delete files and directories.
* Exec - Exec is useful to execute arbitrary O/S commands.
* Zip - Zip is useful to bundle files.


---

# **Gradle 빌트인 태스크 정리**  

Gradle은 다양한 **빌트인 태스크(Built-in Task)**를 제공하며, 프로젝트 빌드 및 관리를 효율적으로 수행할 수 있도록 돕는다.  
특히 `Copy`, `Zip` 등의 태스크는 파일을 조작하고 패키징하는 데 유용하다.  
아래에서 주요 빌트인 태스크를 정리하고, 사용 예시를 함께 제공한다.  

---

## **1. 주요 빌트인 태스크 목록**  

| **태스크(Task)** | **설명** |
|----------------|----------------------------|
| `Copy` | 파일 및 디렉터리를 복사 |
| `Sync` | `Copy`와 유사하지만, 대상 디렉터리를 동기화 |
| `Zip` | ZIP 압축 파일 생성 |
| `Tar` | TAR 압축 파일 생성 (`.tar`, `.tar.gz` 등) |
| `Delete` | 파일 및 디렉터리 삭제 |
| `Exec` | 외부 프로세스 실행 |
| `JavaExec` | Java 애플리케이션 실행 |
| `Task` | 기본적인 사용자 정의 태스크 생성 |
| `DefaultTask` | 기본적으로 실행할 수 있는 커스텀 태스크 생성 |
| `Wrapper` | Gradle Wrapper 스크립트 생성 |
| `Test` | 테스트 실행 |
| `Jar` | JAR 파일 생성 |
| `War` | WAR(Web Application Archive) 파일 생성 |
| `Ear` | EAR(Enterprise Application Archive) 파일 생성 |
| `GenerateBuildConfig` | Android 프로젝트에서 `BuildConfig` 클래스 생성 |
| `CompileJava` | Java 코드 컴파일 |
| `ProcessResources` | 리소스 처리 |
| `Assemble` | 프로젝트 빌드 결과물을 패키징 |
| `Check` | 프로젝트 검증(테스트 포함) |
| `Build` | 전체 빌드 수행 |
| `Clean` | 빌드 결과물 삭제 |
| `Dependencies` | 의존성 정보 출력 |

---

## **2. 파일 조작 관련 태스크**  

### **(1) Copy 태스크 - 파일 및 디렉터리 복사**  
`Copy` 태스크는 특정 디렉터리나 파일을 다른 위치로 복사하는 데 사용된다.  

**사용 예제:**  
```kotlin
tasks.register<Copy>("copyFiles") {
    from("src/main/resources") // 복사할 원본 디렉터리
    into("build/copied-resources") // 복사 대상 디렉터리
}
```

**고급 예제 (파일 필터링 적용):**  
```kotlin
tasks.register<Copy>("copySpecificFiles") {
    from("src/assets") 
    into("build/assets") 
    include("**/*.png") // PNG 파일만 복사
    exclude("temp/**") // temp 폴더 제외
}
```

---

### **(2) Sync 태스크 - Copy와 유사하지만 대상 디렉터리를 동기화**  
`Sync` 태스크는 `Copy`와 유사하지만, **대상 디렉터리에 없는 파일을 삭제하여 동기화**하는 점이 다르다.  

**사용 예제:**  
```kotlin
tasks.register<Sync>("syncFiles") {
    from("src/main/resources") 
    into("build/synced-resources") 
}
```

---

### **(3) Delete 태스크 - 파일 및 디렉터리 삭제**  
`Delete` 태스크는 특정 파일이나 디렉터리를 삭제하는 데 사용된다.  

**사용 예제:**  
```kotlin
tasks.register<Delete>("cleanOutput") {
    delete("build/output")
}
```

---

## **3. 압축 관련 태스크**  

### **(1) Zip 태스크 - ZIP 압축 파일 생성**  
`Zip` 태스크를 사용하면 특정 파일 및 디렉터리를 `.zip` 파일로 압축할 수 있다.  

**사용 예제:**  
```kotlin
tasks.register<Zip>("zipFiles") {
    from("src/main/resources")
    archiveFileName.set("resources.zip") // 생성할 ZIP 파일 이름
    destinationDirectory.set(file("build/distributions")) // ZIP 저장 위치
}
```

**고급 예제 (파일 선택 및 압축 내 경로 설정):**  
```kotlin
tasks.register<Zip>("zipSelectedFiles") {
    from("src/assets") {
        include("**/*.jpg") // 특정 파일만 포함
    }
    archiveFileName.set("images.zip")
    destinationDirectory.set(file("build/zipped"))
}
```

---

### **(2) Tar 태스크 - TAR 압축 파일 생성**  
TAR 파일(`.tar`, `.tar.gz`, `.tar.bz2`)을 생성하는 데 사용된다.  

**사용 예제:**  
```kotlin
tasks.register<Tar>("tarFiles") {
    from("src/main/resources")
    archiveFileName.set("resources.tar")
    compression = Compression.GZIP // .tar.gz 압축 설정
    destinationDirectory.set(file("build/distributions"))
}
```

---

## **4. 실행 관련 태스크**  

### **(1) Exec 태스크 - 외부 프로세스 실행**  
`Exec` 태스크는 쉘 명령어 또는 외부 프로세스를 실행할 때 사용된다.  

**사용 예제:**  
```kotlin
tasks.register<Exec>("runShellCommand") {
    commandLine("ls", "-l") // 리눅스/macOS에서 파일 목록 출력
}
```

**Windows에서 사용 예제:**  
```kotlin
tasks.register<Exec>("runBatchScript") {
    commandLine("cmd", "/c", "dir") // Windows에서 디렉터리 목록 출력
}
```

---

### **(2) JavaExec 태스크 - Java 애플리케이션 실행**  
Java 실행 가능한 프로그램을 실행할 때 사용한다.  

**사용 예제:**  
```kotlin
tasks.register<JavaExec>("runJavaApp") {
    mainClass.set("com.example.Main") // 실행할 클래스
    classpath = sourceSets.main.get().runtimeClasspath
}
```

---

## **5. 빌드 및 테스트 관련 태스크**  

### **(1) CompileJava 태스크 - Java 코드 컴파일**  
Java 코드를 컴파일하는 데 사용된다.  

**사용 예제:**  
```kotlin
tasks.named<JavaCompile>("compileJava") {
    options.encoding = "UTF-8"
}
```

---

### **(2) Test 태스크 - 테스트 실행**  
JUnit, TestNG 등의 테스트 프레임워크를 실행하는 데 사용된다.  

**사용 예제:**  
```kotlin
tasks.named<Test>("test") {
    useJUnitPlatform() // JUnit 5 사용
}
```

---

### **(3) Assemble 태스크 - 패키징 실행**  
프로젝트의 빌드 결과물을 생성하는 태스크이다.  
기본적으로 `Jar`, `War` 등의 태스크를 포함한다.  

**사용 예제:**  
```kotlin
tasks.named("assemble") {
    dependsOn("jar") // jar 태스크를 먼저 실행
}
```

---

### **(4) Build 태스크 - 전체 빌드 수행**  
`assemble`, `test` 등을 포함하여 프로젝트의 전체 빌드를 수행한다.  

**사용 예제:**  
```kotlin
tasks.named("build") {
    dependsOn("test")
}
```

---

## **결론**  
Gradle의 빌트인 태스크는 파일 복사, 압축, 빌드, 테스트, 실행 등 다양한 작업을 자동화할 수 있도록 돕는다.  
각 태스크의 동작을 이해하고 적절히 활용하면 **빌드 스크립트를 더욱 효율적으로 구성**할 수 있다.