# `maven-publish` 플러그인

Gradle의 `maven-publish` 플러그인은 프로젝트의 빌드 아티팩트(예: JAR, POM 파일)를 **Maven 형식**으로 패키징하고 로컬 또는 원격 저장소(예: Maven Central, Artifactory, Nexus)에 배포할 때 사용된다.  

이 플러그인은 다음과 같은 기능을 제공한다.  

* Maven 저장소에 라이브러리 배포  
* 로컬 및 원격 저장소 지원  
* 자동 POM 파일 생성  
* 다양한 아티팩트 유형(JAR, Sources, Javadoc) 지원  


먼저 `maven-publish` 플러그인을 적용해야 한다.  

`build.gradle.kts`  
```kotlin
plugins {
    `maven-publish`
    `java-library`
    signing
}

group = "com.example"   // 그룹 ID
version = "1.0.0"       // 버전 정보

repositories {
    mavenCentral()
}

dependencies {
    implementation("org.apache.commons:commons-lang3:3.12.0")
}
java {
    withJavadocJar()
    withSourcesJar()
}
publishing {
    publications {
        create<MavenPublication>("mavenJava") {
            from(components["java"]) // Java 라이브러리 컴포넌트 사용
            groupId = "com.example"
            artifactId = "my-library"
            version = "1.0.0"
            pom {
                name = "My Library"
                description = "A concise description of my library"
                url = "http://www.example.com/library"
                properties = mapOf(
                    "myProp" to "value",
                    "prop.with.dots" to "anotherValue"
                )
                licenses {
                    license {
                        name = "The Apache License, Version 2.0"
                        url = "http://www.apache.org/licenses/LICENSE-2.0.txt"
                    }
                }
                developers {
                    developer {
                        id = "johnd"
                        name = "John Doe"
                        email = "john.doe@example.com"
                    }
                }
                scm {
                    connection = "scm:git:git://example.com/my-library.git"
                    developerConnection = "scm:git:ssh://example.com/my-library.git"
                    url = "http://example.com/my-library/"
                }
            }
        }
    }
    repositories {
        maven {
            val releasesRepoUrl = layout.buildDirectory.dir("repos/releases")
            val snapshotsRepoUrl = layout.buildDirectory.dir("repos/snapshots")
            url = uri(if (version.toString().endsWith("SNAPSHOT")) snapshotsRepoUrl else releasesRepoUrl)
        }
    }
}
signing {
    sign(publishing.publications["mavenJava"])
}
tasks.javadoc {
    if (JavaVersion.current().isJava9Compatible) {
        (options as StandardJavadocDocletOptions).addBooleanOption("html5", true)
    }
}
```

- `plugins { maven-publish }` → `maven-publish` 플러그인 적용  
- `publishing { publications { ... } }` → 배포할 아티팩트 설정  
- `from(components["java"])` → `java` 컴포넌트를 기반으로 자동 설정  
- `groupId`, `artifactId`, `version` → Maven 아티팩트 정보 지정  


## 로컬 Maven 저장소에 배포  

Gradle은 기본적으로 **로컬 저장소(`~/.m2/repository`)**를 지원한다.  

`build.gradle.kts` :
```kotlin
publishing {
    publications {
        create<MavenPublication>("mavenJava") {
            from(components["java"])
            groupId = "com.example"
            artifactId = "my-library"
            version = "1.0.0"
        }
    }
    repositories {
        maven {
            url = uri("${buildDir}/repo") // 로컬 저장소 경로
        }
    }
}
```

로컬 저장소에 배포 실행 :
```sh
gradle publish
```
실행하면 `${buildDir}/repo/com/example/my-library/1.0.0/` 경로에 JAR과 POM 파일이 생성된다.  


## 원격 Maven 저장소에 배포  

Maven Central 또는 사설 저장소(Nexus, Artifactory)에 업로드하려면 **인증 정보**를 추가해야 한다.  

`build.gradle.kts` :
```kotlin
publishing {
    publications {
        create<MavenPublication>("mavenJava") {
            from(components["java"])
            groupId = "com.example"
            artifactId = "my-library"
            version = "1.0.0"

            pom {
                name.set("My Library")
                description.set("This is an example library.")
                url.set("https://github.com/example/my-library")
                licenses {
                    license {
                        name.set("MIT License")
                        url.set("https://opensource.org/licenses/MIT")
                    }
                }
                developers {
                    developer {
                        id.set("dev123")
                        name.set("John Doe")
                        email.set("john@example.com")
                    }
                }
            }
        }
    }
    repositories {
        maven {
            name = "myRepo"
            url = uri("https://maven.example.com/repository/releases/")
            credentials {
                username = project.findProperty("mavenUser") as String? ?: "defaultUser"
                password = project.findProperty("mavenPassword") as String? ?: "defaultPassword"
            }
        }
    }
}
```

다음 명령어를 실행하면 원격 저장소에 업로드된다.  

```sh
gradle publish
```

## 추가 아티팩트 (소스 코드, Javadoc)  

라이브러리를 배포할 때 **소스 코드 및 Javadoc JAR**을 함께 제공할 수도 있다.  

`build.gradle.kts`
```kotlin
tasks.register<Jar>("sourcesJar") {
    from(sourceSets.main.get().allSource)
    archiveClassifier.set("sources")
}

tasks.register<Jar>("javadocJar") {
    from(tasks.javadoc)
    archiveClassifier.set("javadoc")
}

publishing {
    publications {
        create<MavenPublication>("mavenJava") {
            from(components["java"])
            artifact(tasks["sourcesJar"]) // 소스 코드 추가
            artifact(tasks["javadocJar"]) // Javadoc 추가

            groupId = "com.example"
            artifactId = "my-library"
            version = "1.0.0"
        }
    }
}
```

배포 후 다음과 같은 파일이 생성된다.  

```
my-library-1.0.0.jar       # 라이브러리 JAR
my-library-1.0.0-sources.jar  # 소스 코드 포함
my-library-1.0.0-javadoc.jar  # Javadoc 포함
my-library-1.0.0.pom       # POM 파일
```