# 의존성 관리  

의존성이란, 프로젝트가 실행되거나 빌드될 때 필요한 외부 라이브러리를 의미한다. Gradle에서는 `dependencies` 블록을 통해 프로젝트에서 사용할 라이브러리를 선언한다.  

Gradle은 중앙 저장소(Maven Central, JCenter 등)나 로컬 저장소를 활용하여 필요한 라이브러리를 다운로드하고 프로젝트에 추가할 수 있다.  

## `dependencies` 블록 사용법 

Gradle에서는 `dependencies` 블록을 사용하여 필요한 라이브러리를 정의할 수 있다.  

### 기본적인 의존성 추가  
```
group:name:version
```

아래는 Kotlin DSL을 사용하여 `build.gradle.kts`에서 의존성을 추가하는 예제이다.  

```kotlin
dependencies {
    implementation("org.jetbrains.kotlin:kotlin-stdlib:1.8.0")  // Kotlin 표준 라이브러리 추가
    testImplementation("org.junit.jupiter:junit-jupiter:5.9.0")  // JUnit 테스트 라이브러리 추가
}
```

위 코드는 다음과 같은 역할을 한다.  
- `implementation`: 실행과 컴파일 과정에서 필요한 라이브러리 추가  
- `testImplementation`: 테스트 코드에서만 필요한 라이브러리 추가  


## 버전 관리 방법  

### `gradle.properties` 파일을 활용한 버전 관리  

의존성 버전을 `gradle.properties` 파일에서 정의하여 프로젝트 전반에서 일관되게 관리할 수 있다.  

`gradle.properties` 파일:  

```properties
kotlinVersion=1.8.0
junitVersion=5.9.0
```

`build.gradle.kts`에서 참조:  

```kotlin
val kotlinVersion: String by project
val junitVersion: String by project

dependencies {
    implementation("org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion")
    testImplementation("org.junit.jupiter:junit-jupiter:$junitVersion")
}
```

### `versions.gradle.kts` 파일을 활용한 버전 관리  

여러 개의 의존성 버전을 중앙에서 관리하려면 `versions.gradle.kts` 파일을 만들고 버전을 정의할 수도 있다.  

`gradle/versions.gradle.kts` 파일:  

```kotlin
extra["kotlinVersion"] = "1.8.0"
extra["junitVersion"] = "5.9.0"
```

`build.gradle.kts`에서 참조:  

```kotlin
val kotlinVersion: String by extra
val junitVersion: String by extra

dependencies {
    implementation("org.jetbrains.kotlin:kotlin-stdlib:$kotlinVersion")
    testImplementation("org.junit.jupiter:junit-jupiter:$junitVersion")
}
```

### `libs.versions.toml` 파일을 활용한 버전 관리
...

## 원격 및 로컬 저장소 설정  

Gradle은 원격 저장소(Maven Central, JCenter, Google Maven 등)와 로컬 저장소를 지원한다.  

### 원격 저장소 사용  

`repositories` 블록에서 사용할 저장소를 설정할 수 있다.  

```kotlin
repositories {
    mavenCentral()  // Maven Central 저장소 사용
    google()  // Google Maven 저장소 사용 (Android 개발 시 유용)
}
```

### 로컬 저장소 사용  

프로젝트 내부에서 관리하는 라이브러리를 직접 추가할 수도 있다.  

```kotlin
repositories {
    mavenLocal()  // 로컬 Maven 저장소 사용
}
```

또는 특정 디렉터리를 로컬 저장소로 지정할 수도 있다.  

```kotlin
repositories {
    flatDir {
        dirs("libs")
    }
}
```

이렇게 설정한 후, `libs` 폴더에 저장된 JAR 파일을 의존성으로 추가할 수 있다.  

```kotlin
dependencies {
    implementation(files("libs/my-library.jar"))
}
```


## 의존성의 분류  

Gradle에서는 의존성을 프로젝트에서 어떻게 사용할지에 따라 여러 범주로 분류한다.  

### 주요 의존성 유형  

| 의존성 유형(Configuration) | 설명 | 적용 대상 | 전이적(Transitive) |
|-----------------|------------------------------------|------------------|------------------|
| `implementation` | 컴파일 시 접근 불가, 런타임에서만 사용 가능 | 애플리케이션 | O (기본) |
| `api` | 다른 모듈에서도 접근 가능 | 라이브러리 | O (기본) |
| `compileOnly` | 컴파일 시에만 필요, 런타임에는 포함되지 않음 | 애플리케이션 & 라이브러리 | X |
| `runtimeOnly` | 런타임에서만 필요, 컴파일 시에는 사용 불가 | 애플리케이션 & 라이브러리 | O |
| `testImplementation` | 테스트 코드에서만 사용 | 테스트 코드 | O |
| `testCompileOnly` | 테스트 코드에서만 컴파일 시 필요 | 테스트 코드 | X |
| `testRuntimeOnly` | 테스트 실행 시에만 필요 | 테스트 코드 | O |
| `annotationProcessor` | 컴파일 시 애노테이션 프로세서를 실행할 때 사용 | 애노테이션 기반 라이브러리 | X |

### 예제  

```kotlin
dependencies {
    implementation("com.squareup.retrofit2:retrofit:2.9.0")  // Retrofit 라이브러리 추가
    api("org.apache.commons:commons-lang3:3.12.0")  // 다른 모듈에서도 사용 가능
    compileOnly("javax.annotation:javax.annotation-api:1.3.2")  // 컴파일 시에만 필요
    runtimeOnly("org.postgresql:postgresql:42.3.1")  // 실행할 때만 필요
    testImplementation("org.junit.jupiter:junit-jupiter:5.9.0")  // 테스트 코드에서만 필요
}
```

### `api` vs `implementation`  

멀티 모듈 프로젝트에서 `api`와 `implementation`의 차이를 이해하는 것이 중요하다.  

```kotlin
dependencies {
    api("com.example:shared-library:1.0.0")  // 다른 모듈에서도 접근 가능
    implementation("com.example:internal-library:1.0.0")  // 현재 모듈에서만 사용 가능
}
```

- `api`로 추가한 라이브러리는 이 모듈을 의존하는 다른 모듈에서도 사용할 수 있다.  
- `implementation`으로 추가한 라이브러리는 현재 모듈에서만 사용 가능하며, 빌드 성능이 향상된다.