Dependency Management [How to declare your dependencies]

당신이 선언할 수 있는 몇가지 다른 타입의 dependency들이 있다.

- Dependency types

External module dependency :
몇몇 repository 안의 외부의 module 의 dependency

Project dependency :
같은 build 안에 있는 다른 프로젝트의 dependency

File dependency :
local filesystem 의 file의 set에 있는 dependency

Client module dependency :
외부 모듈에 dependency가 존재하고, 이 artifact는 몇몇 repository안에 존재하지만 local build에 의해 meta-data가 명시되어 있는 상태.
당신은 이러한 dependency를 module을 위한 meta-data를 override를 원할 때 사용할 수 있다.

Gradle API dependency :
현재 Gradle version의 API에 있는 dependency.
당신은 이러한 종류의 dependency를 custom Gradle plugin과 task type들을 개발할 때 사용할 수 있다.

Local Groovy dependency :
현재 Gradle version에 의해 사용되는 Grovvy version의 dependency.
당신은 이러한 종류의 dependency를 custom Gradle plugin과 task type들을 개발할 때 사용할 수 있다.



External module dependencies

External module dependencies 는 가장 보통의 dependency이다.
그들은 외부 repository 안의 module을 참조한다.

ex) Module dependencies

build.gradle

dependencies {
    runtime group: 'org.springframework', name: 'spring-core', version: '2.5'
    runtime 'org.springframework:spring-core:2.5',
            'org.springframework:spring-aop:2.5'
    runtime(
        [group: 'org.springframework', name: 'spring-core', version: '2.5'],
        [group: 'org.springframework', name: 'spring-aop', version: '2.5']
    )
    runtime('org.hibernate:hibernate:3.0.5') {
        transitive = true
    }
    runtime group: 'org.hibernate', name: 'hibernate', version: '3.0.5', transitive: true
    runtime(group: 'org.hibernate', name: 'hibernate', version: '3.0.5') {
        transitive = true
    }
}

더많은 예제와 완벽한 가이드를 위해서 API 문서 내의 DependencyHandler class를 찾아보면 된다.

Gradle은 module dependency를 위한 다른 표기법을 제공한다.
그 중에는 string 표기법과 map 표기법이 있다.
module dependency는 더 많은 설정을 허용하는 API를 가지고 있다.
더 많은 내용을 위해 ExternalModuleDependency를 찾아보면 된다.
이 API는 property 및 configuration method를 제공한다.
string 표기법을 통해서 당신은 properties의 집합을 정의할 수 있다.
map 표기법을 통해서 당신은 모든 property들을 정의할 수 있다.
모든 API에 접근하기 위해서, map 혹은 string 표기법 어떠한 것도 사용할 수 있고, 당신은 single dependency를 closure와 함께 configuration에 할당할 수 있다.

만약 당신이 module dependency를 선언한다면, Gradle은 repository 안에서 module descriptor(pom.xml 혹은 ivy.xml) 를 찾을 것이다.
만약 그러한 module descriptor 파일이 존재한다면, Gradle은 검색할 파일 (예를 들어, hibernate-3.0.5.jar )를 찾을 것이다.
Maven에서 module은 하나만 가질 수 있고, artifact 또한 하나이다.
Gradle과 Ivy에서는, module은 여러개의 artifact를 가질 수 있다.
각각의 artifact는 다른 종류의 dependency들을 가질 수 있다.



Depending on modules with multiple artifacts

이전에 언급하였듯이, Maven은 오직 하나의 module과 artifact를 가진다.
이러한 이유로, 당신의 project가 Maven module에 의존할 때는, artifact가 무엇인지 명확하다.
Gradle과 Ivy를 사용할 때는 얘기가 달라진다.
Ivy의 dependency descriptor(ivy.xml)는 여러 개의 artifact를 선언할 수 있다.
Gradle에서, 당신이 Ivy module의 dependency를 선언하려고 할 때, 당신은 그 module의 기본 configuration의 dependency를 선언하는 것이다.
그래서 당신이 의존하고 있는 실질적인 artifact들은 그 module의 기본 셋팅에 속해져 있는 artifact들인 것이다.
여기 몇몇 상황을 살펴보자.

- 지원되지 않는 artifact들을 포함하고 있는 module의 기본 설정.
전체 설정에 의존하고 있다기 보다는, dependency는 선언되어 있는 존재하는 artifact에 의존.

- default가 아닌 configuration에 속해 있는 지원되는 artifact.
그 설정은 dependency 선언의 한 부분으로써 명시되어 있음.



Artifact only notation

위에서 설명하였듯이, 만약 module descriptor가 존재하지 않는다면, Gradle은 해당 모듈의 기본 jar파일을 다운로드한다.
하지만 가끔씩, repository가 module descriptor를 포함한다하더라도, 당신은 오직 artifact jar만 다운로드받기를 원할 수 있다.
그리고 가끔씩 당신은 module descriptors가 없는 repository로부터 zip 파일을 다운로드 받고 싶을 수 있다.
Gradle은 이러한 상황을 위해 artifact only 표기법을 지원한다.
- 간단히 '@' sign과 함께 사용하면 된다.

ex) Artifact only notation

build.gradle

dependencies {
    runtime "org.groovy:groovy:2.2.0@jar"
    runtime group: 'org.groovy', name: 'groovy', version: '2.2.0', ext: 'jar'
}

artifact only 표기법은 오직 명시된 확장자를 가진 artifact file만 다운로드하여 module dependency를 생성한다.
존재하는 module descriptors는 무시된다.


Classifiers

Maven dependency 관리는 분류의 개념을 가진다.
Gradle은 이것을 지원한다.
Maven repository로부터 분류된 dependency를 검색하기 위해 당신은 아래와 같이 쓸 수 있다.

ex) Dependency with classifier

build.gradle

compile "org.gradle.test.classifiers:service:1.0:jdk15@jar"
otherConf group: 'org.gradle.test.classifiers', name: 'service', version: '1.0', classifier: 'jdk14'

첫번째 라인에서 보이는 것처럼, 분류는 artifact only 표기법과 함께 사용될 수 있다.

설정의 dependency artifacts를 반복처리하는 것 역시 쉽다.

ex) Iterating over a configuration

build.gradle

task listJars << {
    configurations.compile.each { File file -> println file.name }
}

gradle -q listJars 의 실행 결과

> gradle -q listJars
hibernate-core-3.6.7.Final.jar
antlr-2.7.6.jar
commons-collections-3.1.jar
dom4j-1.6.1.jar
hibernate-commons-annotations-3.2.0.Final.jar
hibernate-jpa-2.0-api-1.0.1.Final.jar
jta-1.1.jar
slf4j-api-1.6.1.jar

Project dependencies

Gradle은 외부 dependency와 같은 multi-project build의 부분을 담당하는 project의 dependency를 구분한다.
당신은 이것을 project dependency라고 선언할 수 있다.

ex) Project dependencies

build.gradle

dependencies {
    compile project(':shared')
}

File dependencies

File dependencies는 당신이 file set를 repository에 넣지않고 바로 configuration에 추가하는 것을 허용해준다.
이 것은 당신이 file을 repository에 넣지않기를 원하거나 그럴 수 없을 때 유용하다.

몇몇 파일을 dependency로써 configuration에 넣기 위해, 당신은 간단히 file collection을 dependency로써 넘기기만 하면 된다.

ex) File dependencies

build.gradle

dependencies {
    runtime files('libs/a.jar', 'libs/b.jar')
    runtime fileTree(dir: 'libs', include: '*.jar')
}

File dependencies 는 당신의 프로젝트에서 published dependency descriptor에 포함되지않는다.
하지만, file dependencies 는 같은 build 내에서 transitive proejct dependencies에 포함된다.
이 것은 이 dependency는 같은 빌드 내에서는 사용되지만, 외부의 build에서는 사용되지 못한다는 것을 의미한다.

당신은 file dependency를 위해 어떤 task가 파일을 생성할지 선언할 수 있다.
당신은 아마도 build에 의해 file이 생성되길 원할 때 이 것을 실행할 것이다.

ex) Generated file dependencies

build.gradle

dependencies {
    compile files("$buildDir/classes") {
        builtBy 'compile'
    }
}

task compile << {
    println 'compiling classes'
}

task list(dependsOn: configurations.compile) << {
    println "classpath = ${configurations.compile.collect {File file -> file.name}}"
}

gradle -q list의 실행 결과

> gradle -q list
compiling classes
classpath = [classes]

Gradle API Dependency

당신은 DependencyHandler.gradleApi() method를 이용하여 Gradle의 현재 버전의 API 위에서 dependency를 선언할 수 있다.
이 것은 당신이 custom Gradle task 혹은 plugin을 개발할 때 유용하다.

ex) Gradle API dependencies

build.gradle

dependencies {
    compile gradleApi()
}

Local Groovy Dependency

당신은 DependencyHandler.localGroovy() method를 이용하여 Gralde과 함께 배포된 Groovy 위에서 dependency를 선언할 수 있다.
이 것은 당신이 custom Gradle task 혹은 Groovy plugin을 개발할 때 유용하다.

ex) Gradle's Groovy dependencies

build.gradle

dependencies {
    compile localGroovy()
}

Excluding transitive dependencies

당신은 transitive dependency를 configuration 혹은 dependency를 이용하여 제외시킬 수 있다.

ex) Excluding transitive dependencies

build.gradle

configurations {
    compile.exclude module: 'commons'
    all*.exclude group: 'org.gradle.test.excludes', module: 'reports'
}

dependencies {
    compile("org.gradle.test.excludes:api:1.0") {
        exclude module: 'shared'
    }
}

만약 당신이 특정 설정을 위한 exclude를 정의한다면, 제외된 transitive dependency는 이 설정 혹은 상속된 설정이 결정될 때모든 dependency에 대해 필터링될 것이다.
만약 당신이 모든 당신의 설정으로부터 transitive dependency를 제외하기를 원한다면 당신은 예제에서처럼 Groovy spread-dot operator를 사용할 수 있다.
exclude를 정의할 때, 당신은 그 집합이나 module의 이름 둘중 하나를 반드시 명시하여야 한다.

모든 transitive dependency가 제외될 수 있는 것은 아니다. - 몇몇 transitive dependency는 runtime 때 올바른 동작을 위해 필수적이다.
보통, 해당 dependency가 runtime때 필수적이거나 어떠한 환경에 유용한 것으로 보장되어 있지않다면 제외가 가능하다.

만약 당신은 dependency에 따라 혹은 configuration에 따라 제외가 필요한가?
몇몇 주요한 케이스에서 당신은 이와 같은 기능이 필요할 것이다.
여기에는 당신이 왜 transitive dependency를 제외하기를 원할 것인지 몇가지 이유가 있다.
명심해야 할 것은 몇몇 케이스에서는 제외보다 더 좋은 해결방법이 있다는 것이다!!!

- license 이유로 지원되지않는 dependency
- 어떠한 원격 repository에서 유용하지 않는 dependency
- runtime 때 필요치 않는 dependency
- 원하는 version과 충돌을 일으키는 version을 가진 dependency



Optional attributes

모든 dependency를 위한 속성은 이름을 제외하고는 선택적이다.
실제로 찾는 dependency를 위해 어떠한 속성이 필요한지는 repository 종류에 달려있다.
예를 들어, 만약 당신이 Maven repository로 일한다면, 당신은 group을 정의할 필요가 있다.
만약 당신이 filesystem repository로 일한다면 당신은 이름 혹은 이름과 version이 필요할 것이다.

ex) optional attributes of dependencies

build.gradle

dependencies {
    runtime ":junit:4.12", ":testng"
    runtime name: 'testng'
}

당신은 또한 configuration에 dependency collection 혹은 array 식 표기가 가능하다.

ex) Collections and arrays of dependencies

build.gradle

List groovy = ["org.codehaus.groovy:groovy-all:2.4.4@jar",
               "commons-cli:commons-cli:1.0@jar",
               "org.apache.ant:ant:1.9.6@jar"]
List hibernate = ['org.hibernate:hibernate:3.0.5@jar',
                  'somegroup:someorg:1.0@jar']
dependencies {
    runtime groovy, hibernate
}

Dependency configurations

Gradle에서 dependency는 여러가지 configuration을 가질 수 있다.
만약 당신이 명시적으로 어떠한 것을 표시하지 않았다면, Gradle은 dependency의 기본 configuration을 사용할 것이다.
Maven repository에서 온 dependency를 위해서는, 기본 설정은 단하나의 가능성만 있다.
만약 당신이 Ivy repository로 일하고 기본 설정을 원하지 않는다면 당신은 선언할 때 map 표기법을 사용하여야 한다.

ex) Dependency configurations

build.gradle

dependencies {
    runtime group: 'org.somegroup', name: 'somedependency', version: '1.0', configuration: 'someConfiguration'
}

project dependency를 위해 위와 똑같이 선언하기 위해서는 아래와 같이 선언이 필요하다.

ex) Dependency configurations for project

build.gradle

dependencies {
    compile project(path: ':api', configuration: 'spi')
}

Dependency reports

당신은 command line으로부터 dependency report를 생성할 수 있다.
Project report plugin의 도움으로, 그러한 report는 당신의 빌드에 의해 만들어질 수 있다.

Gradle 1.2 부터 dependency 정보를 접근할 수 있는 API가 있다.
dependency report는 이 API를 사용한다.
이 API는 dependency에 관한 정보와 graph를 제공한다.
이후 이 API는 더 많은 정보를 제공하게 될 것이다.
더 많은 정보를 위해서 ResolvableDependencies.getResolutionResult() 를 참조하면 된다.

원본 출처 : https://docs.gradle.org/current/userguide/dependency_management.html