Gradle은 Web 어플리케이션의 개발에도 사용할 수 있다. 이에 프로젝트의 생성과 Web 개발용 플러그인 사용법에 대해 설명한다.


Web 어플리케이션 프로젝트

일반적인 Java 어플리케이션은 gradle init으로 생성하였다. 그러면 Web 어플리케이션은 어떻게 생성하고 구성되는지 설명한다.

Web 어플리케이션 생성

Web 어플리케이션은 프로그램의 구성도 또한 실행 방법도 다르다. Java 클래스뿐만 아니라 HTML 및 JSP도 사용하므로, 그 파일들을 하나로 모와서 war 파일을 작성해야 한다. 또한 실행은 서블릿 컨테이너 (이른바 Java 서버)도 필요하다.

이렇게 생각한다면, 일반 Java 어플리케이션 생성 방법으로는 되지 않는다고 생각할 것이다. 그러면 일단 실제 프로젝트를 만들면서 Web 애플리케이션 개발 단계를 설명한다.

우선 프로젝트를 만든다. 명령 프롬프트 또는 터미널을 시작하고 적당한 위치에 프로젝트 디렉토리를 준비한다.

$ mkdir GradleWebApp
$ cd GradleWebApp

여기에서는 "GradleWebApp"라는 디렉토리를 만들고, 그 안으로 이동하고 Gradle의 초기화를 실시한다.

$ gradle init --type java-application

이것으로 생성이 된다. 그런데 보면 알 수 있듯이, 극히 일반 Java 어플리케이션과 같은 방식이다.

$ mkdir GradleWebApp
$ cd GradleWebApp
$ gradle init --type java-application
Starting a Gradle Daemon (subsequent builds will be faster)

BUILD SUCCESSFUL in 16s
2 actionable tasks: 2 executed
$ ls
build.gradle    gradle          gradlew         gradlew.bat     settings.gradle src

사실은 2017년 12월 시점에 Gradle에는 "Web 어플리케이션 전용 타입" 이라고 하는 것은 준비되지 않다. 따라서 java-application 타입을 초기화하고, 나머지는 수동으로 프로젝트를 만들어 갈 수 밖에 없다.

Web 응용 프로그램 폴더 구성

그럼, Web 어플리케이션의 폴더 구성을 준비한다. Web 어플리케이션의 폴더는 다음과 같은 형태로 구성된다.

GradleWebApp 폴더

.
├── build.gradle, 그외 생략
└── src
    └── main
    │   ├── java
    │   ├── resources
    │   └── webapp
    │       └── WEB-INF
    └── test
        └── java
            └── AppTest.java

우선 어플리케이션 프로그램 관련에 대해 정리한다. 'test'등은 직접 관계 없기 때문에 설명은 생략한다.

Web 어플리케이션 및 일반 Java 어플리케이션의 가장 큰 차이점은 main 폴더에 있는 폴더의 구성이다. 여기에는 아래와 같이 3개의 폴더가 있다.

java폴더

익숙한 Java 소스 코드 파일을 배치하기 위한 폴더이다. 서블릿 등은 여기에 소스 코드를 배치한다.

webapp 폴더

이는 Web 어플리케이션의 공개되는 폴더로 정적 웹 자원을 두는 곳이다. JSP 파일이나 HTML 파일 등은 여기에 배치한다. 또한 여기에는 WEB-INF 폴더를 준비하고 그 안에 web.xml을 배치한다.

resources 폴더

Web 어플리케이션의 프로그램에 필요한 자원을 제공한다. 이는 Web 페이지에 표시할 이미지 파일 등은 아니다(그것들은 webapp 이다). 예를 들어, JPA 등을 이용할 때 준비하는 persistence.xml 같은 프로그램이 필요로 하는 리소스 파일이다.

 

그럼, 만든 GradleWebApp 안에 이러한 폴더들을 준비한다. main 안에 새롭게 webapp와 resources를 만들고 webapp에 추가로 WEB-INF를 생성한다.

web.xml

Web 어플리케이션의 각종 정보를 작성하는 web.xml를 준비한다. 여기에서는 최신 버전으로 Servlet 3.1를 사용한다.

<?xml version="1.0" encoding="utf-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_3_1.xsd"
       version="3.1">

</web-app>

서블릿 준비

Web 어플리케이션에서 표시하는 Web 페이지로 간단한 서블릿을 작성한다.

main 폴더에 있는 java 폴더에 com 폴더 그 안에 devkuma 폴더 또는 그 안에 web 폴더를 만든다. 그리고 web 에 SampleServlet.java라는 이름으로 Java 소스 코드 파일을 작성한다. 소스 코드의 내용은 아래와 같다.

package com.devkuma.web;
 
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
 
@WebServlet("/hello")
public class SampleServlet extends HttpServlet {
 
    private static final long serialVersionUID = 1L;
 
    @Override
    protected void doGet(HttpServletRequest request,
            HttpServletResponse response)
            throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();
        out.println("<html><head><title>Servlet</title></head>");
        out.println("<body><h1>Sample Servlet</h1>");
        out.println("<p>Welcome to Sample Servlet page!</p>");
        out.println("</body></html>");
    }
}

여기에서는 @WebServlet 어노테이션을 사용하여 /hello 서블릿을 주소를 설정하고 있다. 이 설정으로 인해 Servlet API 3.0 이상이 필요하다. 서블릿 컨테이너의 버전에 따라 동작하지 않는 경우도 있으므로 잘 확인해야 한다(단, 동작 체크 자체에는 외부의 서블릿 컨테이너는 사용하지 않기 때문에 문제는 일어나지 않을 것이다).

그외에 webapp 폴더에 JSP 파일이나 HTML 파일 등을 배치 해두면 된다.

최종 폴더 및 파일 구조

최종으로 파일을 모두 만들면 같이 된다.

.
├── build.gradle, 그외 생략
└── src
    ├── main
    │   ├── java
    │   │   ├── App.java
    │   │   └── com
    │   │       └── devkuma
    │   │           └── web
    │   │               └── SampleServlet.java
    │   ├── resources
    │   └── webapp
    │       └── WEB-INF
    │           └── web.xml
    └── test
        └── java
            └── AppTest.java



build.gradle 작성

Web 어플리케이션을 위한 build.gradle를 작성한다. 이번에는 일반적인 Java 응용 프로그램과 여러가지가 다른 부분이 있다.

build.gradle

우선 아래에 build.gradle의 전체 소스 코드를 올려 두었다.

apply plugin: 'java'
apply plugin: 'war'
apply plugin: 'gretty'
 
buildscript {
    repositories {
        jcenter()
    }
 
    dependencies {
        classpath group:'org.akhikhl.gretty', name:'gretty-plugin', version:'+'
    }
}
 
repositories {
    jcenter()
}
 
dependencies {
    testCompile group:'junit', name:'junit', version:'4.12'
}

우선, 전체 코드를 작성하면 실제로 동작시켜 본다. 다음과 같이 명령을 실행한다.

$ gradle war

이는 Web 응용 프로그램을 war 파일로 생성하기 위한 것이다. 실행하면 프로젝트의 build 폴더에 있는 libs 폴더에 "GradleWebApp.war"라는 War 파일이 생성된다.

이어 응용 프로그램의 동작 체크를 한다. 다음과 같이 실행한다.

$ gradle run

실행되면 Jetty가 다운로드되고, 바로 기동된다. 그러면 아래 주소에 액세스해 본다. 서블릿에 액세스되고 화면이 나타난다.

http://localhost:8080/GradleWebApp/hello

사용 플러그인

그럼, build.gradle에 플러그인 내용을 확인해 보자. 여기에서는 3개의 플러그인이 포함되어 있다.

apply plugin : 'java'
apply plugin : 'war'
apply plugin : 'gretty'

최초의 "java"는 이미 익숙할 것이다. Java 프로그램에 대한 compileJava 등의 테스크를 제공하는 플러그이다.

"war" 플러그인은 이름 그대로 war 파일로 패키징하기 위한 플러그인이다. 이는 Web 응용 프로그램에서 필수 플러그인이라고 할 수 있다. 앞에서 gradle war는 이 플러그인에서 제공하는 것이다.

"gretty"는 Jetty 서블릿 컨테이너를 이용하기 위한 플러그인이다. 이 Gretty는 Groovy에서 Jetty를 이용하기 위한 것으로, 앞에서 실행했던 gradle run으로 Jetty를 시작하고 이 Web 어플리케이션이 기동된 것이다.

buildscript와 dependencies

build.gradle에는 낯선 문장이 추가되어 있다. 그것은 "buildscript"라는 것이다. 이것은 다음과 같은 형태로 되어 있다.

buildscript {
    repositories {
        ...... 저장소 ......
    }

    dependencies {
        ...... 패키지 지정 ......
    }
}

이 buildscript라는 것은 빌드 스크립트를 위한 것이다. 빌드 스크립트라는 것은 그 이름대로 빌드를 위해 실행되는 스크립트이다. Gradle에 있는 기능 그대로 빌드를 할 경우에는 이 buildscript이 필요없다. 이것은 빌드할 때 외부 라이브러리 등을 사용하는 경우에 필요하다.

이번에는 Gretty 플러그인을 사용하고 있지만, 이것은 Gradle 표준이 아니라 외부 라이브러리이다. 따라서 빌드시 어떤 저장소에서 어떤 라이브러리를 사용할 것인지를 지정해야 한다. 그 부분이 buildsript에 있는 repositories과 dependencies이다. 이전에 이미 설명했던 내용이다.

이 buildscript 이 후에 repositories과 dependencies이 있지만, 이것은 빌드 처리 이외의 곳에서 사용되는 것이다. 여기에서는 JUnit이 dependencies에 준비되어 있다.

 

이것으로 Web 어플리케이션의 프로젝트 빌드 및 실행에 대해 대략 알아 보았다.

'Gradle' 카테고리의 다른 글

[Gradle] Web 어플리케이션 개발  (0) 2017.12.23
[Gradle] DefaultTask 클래스 사용  (0) 2017.12.23
[Gradle] 테스크 생성  (1) 2017.12.23
[Gradle] build.gradle 기본  (0) 2017.12.23
[Gradle] Gradle 프로젝트 생성  (0) 2017.12.23
[Gradle] Java 프로젝트 생성(퀵가이드)  (0) 2017.12.23

Gradle은 표준으로 DefaultTask 클래스가 준비되어 있으며,이를 상속한 Task 클래스가 준비되어 있다. 이러한 목적을 위해 테스크 생성에 대해 설명한다.



DefaultTask 상속 클래스

Gradle은 표준으로 다양한 테스크가 포함되어 있는데, 이것들은 "DefaultTask"라는 클래스를 상속한 클래스로 준비되어 있다. 이 DefaultTask 상속 클래스는 자신의 테스크을 만들어 커스텀 마이징을 할 수 있다.

우선은 "DefaultTask 상속 클래스"가 어떤 것인지 직접 만들어 본다. 이 클래스는 다음과 같은 형태로 정의된다.

class 클래스 extends DefaultTask {
    ...... 필드 ......

    void 메소드(인수) {
        ...... 처리 ......
    }

    @TaskAction
    void 메소드() {
        ...... 처리 ......
    }
}

클래스는 DefaultTask라는 클래스를 상속하여 만든다. 이 클래스 내에 테스크로 수행할 처리를 메소드로 제공한다. 이 메소드에는 @TaskAction 어노테이션을 붙여 둔다. 그러면 테스크로 실행되었을 때, 이 메소드가 호출된다.

테스크로 사용하는 각종의 값은 필드로 사용할 수 있어야 한다. 이것은 그대로 이용해도 되지만, 외부에서 사용하는 경우는 private 필드로 설정하여 접근을 위한 메소드를 따로 제공하는 것이 스마트하다.

다음에 간단한 클래스의 예제를 올려 두었다.

class Calc extends DefaultTask {
    private int num
    private String op
 
    void num(p1){
        num = p1
    }
 
    void op(p1){
        op = p1
    }
 
    @TaskAction 
    void calc() {
        switch(op) {
        case 'total':
            int total = 0
            for(def i in 1..num) {
                total += i
            }
            println("total: ${total}")
        break
 
        case 'count':
            for(def i in 1..num) {
                println("NO, ${i}")
            }
        break
 
        default:
            println('not found operator...')
        }
    }
}

Calc 클래스에는 calc 라는 테스크 액션을 준비하고 있다. 여기에서 num와 op의 값에 따라 총의 계산과 수치 계산을 하고 있다.

Calc 클래스를 지정한 테스크

그럼, DefaultTask 상속 클래스를 이용하는 테스크는 어떻게 작성할 수 있을까? 그 작성법은 아래와 같다.

task 테스크(type : 클래스) {
    ...... 수행할 처리 ......
}

테스크의 ()에는 인수로 'type' 값을 준비하고, 이 type에서 사용하는 클래스를 지정하다.

실제로 수행하는 처리에는 사용하는 클래스에 필드로 준비되어 있는 변수에 값을 할당하는 처리를 준비해 둔다. 이렇게 하면, 클래스의 각 필드의 값을 변경하여 테스크 메소드를 실행할 수 있다.

간단한 사용 예를 아래에 올려 두었다.

task total(type:Calc) {
    group 'devkuma'
    description 'Task for calculating total.'
    num 100
    op 'total'
}
 
task count(type:Calc) {
    group 'devkuma'
    description 'Task for count number.'
    num 10
    op 'count'
}

여기에서는 앞 전에 Calc 클래스를 type에 지정한 total, count라는 두 가지 테스크를 만들었다. gradle total라고 실행하면 100까지의 합계가 계산된다.

$ gradle total

> Task :total
total: 5050


BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

"gradle count"라고 실행하면 1 ~ 10까지의 숫자를 순서대로 출력한다.

$ gradle count

> Task :count
NO, 1
NO, 2
NO, 3
NO, 4
NO, 5
NO, 6
NO, 7
NO, 8
NO, 9
NO, 10


BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

여기에서는 테스크의 인수로 (type:Calc)을 지정하고 있다. 그러면 Calc 클래스의 테스크를 수행하는 테스크으로 정의될 수 있다. 여기에는 다음과 같은 문장이 작성되어 있다.

group 그룹명
description 설명
num 정수
op 조작의 유형

이들은 모두 상속의 Calc 클래스에 있는 메소드를 호출하는 것이다. group과 description은 DefaultTask 클래스에 있는 것으로, 각 그룹명과 설명 텍스트를 설정한다.

그리고 Calc 클래스에 준비되어 있는 num와 op으로 계산의 정수 값와 작업의 유형을 지정하고 있다.

이런 식으로 task로 정의된 가운데, type 지정한 클래스의 메서드를 호출하여 필요한 설정을 한다. 그러면, 그 설정이 된 후에 태스크 액션이 수행된다.



JavaExec 클래스 이용

DefaultTask 상속 클래스를 사용한 테스크 작성의 기본이 알았으니, Gradle에 제공되는 주요 DefaultTask 상속 클래스에 대한 사용법을 살펴보기로 한다.

JavaExec 클래스

JavaExec는 Java 프로그램의 실행을 위한 테스크를 구현하는 클래스이다. 이 클래스에는 실행에 필요한 각종 메소드가 준비되어 있다. 중요한 것을 아래 정리해 두었다.

main "클래스"

실행하는 클래스를 지정하는 메소드이다. 클래스명을 텍스트로 인수로 지정하여 호출한다.

classpath "텍스트"

여기에서는 실행 시에 classpath로 지정하는 텍스트를 설정한다. 디폴트 classpath 로 좋다면, sourceSets.main.runtimeClasspath라는 값을 지정해 둔다.

args "Iterator"
args "값1, 값2, ..."

인수로 전달할 정보를 지정하는 것이다. 이것은 Iterator로 정리하여 준비할 수 있으며, 부정 인수로 필요한 값을 개별적으로 인수에 지정할 수도 있다.

jvmArgs "Iterator"
jvmArgs "값1, 값2, ..."

여기에서는 Java 가상 머신에 전달되는 인수를 지정한다. 이것도 역시 Iterator와 같은 이상한 인수가 준비되어 있다.

workingDir "텍스트"

작업 디렉토리를 지정하는 것이다. 인수에는 설정하고자 하는 디렉토리의 경로를 지정한다. 이것은 프로젝트 폴더에서의 상대 경로로 지정한다.

그럼, 이 JavaExec을 이용한 테스크의 예를 들어 둔다.

task appRun(type: JavaExec) {
    group 'devkuma'
    description 'exec App class.'
    main 'App'
    classpath sourceSets.main.runtimeClasspath
     
    doFirst {
        println()
        println('---------- Start ----------')
        println()
    }
    doLast {
        println()
        println('----------- end -----------')
        println()
    }
}

여기에서는 App 클래스를 실행하는 appRun 작업을 만들었다. gradle appRun라고 실행하면 콘솔에 다음과 같이 출력된다.

$ gradle appRun

> Task :appRun

---------- Start ----------

Hello world.

----------- end -----------

Gradle에서의 실행은 다양한 출력이 있어 실행 결과를 알아보기 어렵기에, doFirst과 doLast으로 텍스트를 출력해서 한눈에 "이것이 실행 내용"이라고 알 수 있도록 해본다. 여기에서는 다음과 같이 ExecJava 설정을 하고 있다.

main 'App'
classpath sourceSets.main.runtimeClasspath

일단 main과 classpath 만 준비한다. 이 2개는 디폴트로 값이 설정되어 있지 않아서 생략할 수도 없다. 그 외의 것은 디폴트인 상태로도 문제가 없을 것이다.



커멘드를 실행하는 Exec 이용

프로젝트에서 작성하고 있는 Java 프로그램이 아닌, 다른 프로그램을 실행하려는 경우도 있다. 이러한 경우에 사용되는 것이 Exec 클래스이다.

Exec 클래스는 커멘드 라인에서 명령을 실행하는 기능을 한다. 이에 몇 가지 메소드가 준비되어 있으며, 명령 실행에 관한 설정을 할 수 있게 되어 있다.

commandLine "실행 명령", "인수"...

실행할 명령의 내용을 지정한다. 첫번째 인수에 커멘드를 작성하고, 그 이후에 옵션 등을 인수로 지정한다.

workingDir "텍스트"

이것은 앞에서 이미 설명 했었다. 작업 디렉토리를 지정하는 것이다.

args "Iterator"
args "값1, 값2, ..."

이것도 앞에서 이미 등장 했었다. 인수로 전달할 정보를 지정하는 것이다. 이것은 Iterator로 정리하여 준비할 수 있으며, 부정 인수로 필요한 값을 개별적으로 인수 지정할 수도 있다.

Windows에서 실행

일단 이것만 알고 있으면 명령의 실행은 충분히 있을 것이다. 그러면 실제로 간단한 예를 들어 보겠다.

task javaVer(type:Exec) {
    group 'devkuma'
    description 'print java version.'
    workingDir '.'
    commandLine 'cmd'
    args '/c', 'java.bat'
    doFirst {
        println()
        println('***** Java Version *****')
    }
}

먼저 실행하는 명령으로 간단한 배치 파일을 만들어 둔다. 여기에서는 Windows에서 실행하기 위한 전제로 설명을 한다. 프로젝트 폴더에 "java.bat"라는 이름으로 파일을 준비한다. 그리고 다음과 같이 작성해 둔다.

java.exe -version

보면 알 수 있듯이 Java 버전을 출력하는 명령을 실행하고 있다. 이 배치 파일을 실행하는 작업을 만들 수 있습니다.

아래에 샘플을 올려 두었다.

> Task :javaVer

***** Java Version *****

C:\dev\GradleApp>java.exe -version
java version "9.0.1"
Java(TM) SE Runtime Environment (build 9.0.1+11)
Java HotSpot(TM) 64-Bit Server VM (build 9.0.1+11, mixed mode)

작성한 후에 gradle javaVer라고 실행해 본다. 다음과 같이 버전이 출력된다.

설치된 JDK를 사용하여 표시는 달라질 것이지만, 대체로 이런 출력이 된다. 여기에서는 다음과 같이 실행 명령 설정을 한다.

workingDir '.'
commandLine 'cmd'
args '/c', 'javaver.bat'

이것으로 cmd /c java.bat라는 명령이 실행된다. 그러면 java.bat에 작성된 java.exe -version가 실행되어 Java 버전 정보가 출력된다.

Mac 및 리눅스 계열에서 실행

Window가 아닌 Mac 및 리눅스 계열에서 실행되는 예제는 아래와 같다.

task javaVer(type:Exec) {
    group 'devkuma'
    description 'print java version.'
    workingDir '.'
    commandLine './javaver'
    doFirst {
        println()
        println('***** Java Version *****')
    }
}

javaver 파일을 생성하여 아래와 같이 파일을 저장하고, chmod로 실행 권한을 부여한다.

java -version

출력은 Window와 동일하다.



파일을 복사하는 Copy 이용

프로그램 실행 관계 외에도, 비교적 기억해 두면 도움이 되는 것으로 파일 관련 클래스를 몇 가지 살펴 보고 설명한다.

Copy 클래스

Copy 클래스는 그 이름과 같이 파일을 복사할 수 있는 기능을 제공한다. 여기에는 다음과 같은 메소드가 준비되어 있다.

from "원본 경로"

복사할 원본 파일와 폴더의 경로를 텍스트로 지정한다.

into "대상 경로"

복사할 파일이나 폴더의 경로를 텍스트로 지정한다.

include "패턴", ...

복사 대상에 포함 할 파일을 ANT 스타일 패턴이라는 형식으로 지정한다. 이것은 와일드 카드로 지정되는 패턴이다.

exclude "패턴", ...

복사 대상에서 제외 파일을 ANT 스타일 패턴에서 지정하는 것이다.

그럼, Copy 간단한 사용 예를 아래에 들어 둔었다.

task copyJava(type: Copy) {
    group 'devkuma'
    description 'backup java files.'
    from 'src/main/java'
    into '../java_backup'
 }

이것은 main 안에 java 폴더를 프로젝트 폴더 외부에 복사한다. gradle copyJava라고 실행해 본다. java 폴더가 프로젝트 폴더와 같은 위치에 "java_backup"라는 이름으로 복사된다.

Delete 클래스

Delete 클래스는 파일과 폴더를 삭제하는 것이다. 여기에는 다음의 메소드가 준비되어 있다.

delete "파일", ...

삭제 대상 파일을 지정한다. 이것은 파일 경로 텍스트이다.



'Gradle' 카테고리의 다른 글

[Gradle] Web 어플리케이션 개발  (0) 2017.12.23
[Gradle] DefaultTask 클래스 사용  (0) 2017.12.23
[Gradle] 테스크 생성  (1) 2017.12.23
[Gradle] build.gradle 기본  (0) 2017.12.23
[Gradle] Gradle 프로젝트 생성  (0) 2017.12.23
[Gradle] Java 프로젝트 생성(퀵가이드)  (0) 2017.12.23

Gradle는 테스크을 준비하고 실행하는 것이 기본이다. 테스크는 Groovy를 사용하여 작성할 수 있다. 테스크의 기본적인 생성 방법에 대해 설명한다.


테스크 정의

Gradle은 명령에 의해 "테스크(task)"을 수행하는 프로그램이다. 지금까지 gradle compileJava라든지 gradle run와 같은 명령을 사용하였는데, 이들도 모두 "compileJava 테스크 수행", "run 테스크 수행"이라는 것이다.

테스크 정의 기본

이 테스크는 사용자가 정의할 수 있다. 빌드 파일(build.gradle)에서 테스크의 처리를 기술해두면, 그것을 gradle 명령으로 호출 실행 시킬 수 있다.

테스크는 다음과 같은 형태로 정의한다.

task 테스크명 {
    ...... 수행할 처리 ......
}

테스크는 "task"라는 키워드를 사용하여 정의한다. 이 후에 테스크명을 작성하고, 그 다음에 {} 내에 테스크의 내용을 작성한다. 테스크 선언는 다른 작성법도 있는데, 다음과 같은 작성도 가능하다.

task (테스크명) {...}
task ('테스크명') {...}

이것으로 {} 안에 기술된 처리를 실행하는 작업을 정의할 수 있다. 그럼 실제로 해 보도록 하자.

build.gradle 아래 부분에, 아래와 같이 코드를 추가한다.

task hello {
    println('이것은 hello 테스크 실행한 것이다')
}

그리고 파일을 저장하고, 명령 프롬프트 또는 터미널에서 다음과 같이 실행한다.

$ gradle hello

이것으로 hello 테스크가 실행된다. 실행해 보면, println으로 출력하는 문장 이외에도 다양한 문장이 출력된다.

Starting a Gradle Daemon (subsequent builds will be faster)

> Configure project :
이것은 hello 테스크 실행한 것이다


BUILD SUCCESSFUL in 16s

이는 "quiet 모드"로 테스크를 수행하면 많은 부분이 사라진다. -q 옵션을 지정하고 아래 같이 실행한다.

$ gradle -q hello

이로 표시되는 출력은 상당히 심플하게 될 것이다.

이것은 hello 테스크 실행한 것이다

doFirst와 doLast

테스크는 이렇게 task 후에 {} 부분에 처리를 쓰는 것만으로 만들 수 있다. 사실 보통은 이런 작성법은 많이 쓰지 않는다.

일반적인 테스크의 형태를 정리하면, 대체로 다음과 같은 형태가 된다.

task 테스크명 {

    doFirst {
         ...... 수행할 처리 ......
    }
    
    doLast {
         ...... 수행할 처리 ......
    }
}

태스크 {} 에는 doFirst, doLast 라는 것이 준비된다. 이것은 일종의 클로저이다. 이들은 각각 다음과 같은 기능을 한다.

  • doFirst : 최초에 수행하는 액션이다.
  • doLast : 최후에 수행 하는 액션이다.

테스크는 준비된 "액션"을 순서대로 실행해 나가는 역할을 한다. 액션이라는 것은 구체적으로 수행하는 처리의 "실행 단위" 같은 것이다. 테스크 중에는 여러 가지 액션이 준비되어 있고, 그것이 순차적으로 실행된다.

doFirst과 doLast는 그 액션의 최초, 최후에 실행한다. 즉, "테스크의 기본적인 처리 등이 있을 때는 그 전에 실행하는 것과 후에 실행하는 것"을 이렇게 준비한다.

이는 2개를 세트로 준비할 필요는 없다. 어느 한쪽만으로도 괜찮다.

그러면 실제로 간단한 예를 움직여 보자.

task hello {
    doLast {
        println('이것은 hello 태스크의 doLast이다.')
    }
    doFirst {
        println('이것은 hello 태스크의 doFirst이다.')
    }
}

아래 목록 아래처럼 hello 작업을 다시 시도한다. 그리고 gradle hello를 실행한다. 그러면 다음과 같이 출력된다.

> Task :hello
이것은 hello 태스크의 doFirst이다.
이것은 hello 태스크의 doLast이다.


BUILD SUCCESSFUL in 0s
1 actionable task: 1 executed

샘플은 doLast 먼저, doFirst가 후에 쓰여져 있지만, 실행 결과를 보면, 우선 doFirst이 실행된 후에 doLast가 실행되고 있는 것을 알 수 있다.



매개 변수 전달

태스크는 수행할 때 필요한 값을 매개 변수로 전달할 수 있다. 단순히 작업 처리 중 변수를 사용하면 된다. 예를 들어, 다음과 같다.

task msg {
    println("you typed: " + x)
}

여기에서는 println으로 변수 x의 값을 표시하고 있다. 이 변수 x에 값을 설정하려면 gradle 명령을 실행시에 다음과 같이 입력한다.

$ gradle msg -Px=값

이렇게 -P 후에 변수명을 지정하고 그 뒤에 등호로 값을 지정한다. 변수 hoge에 123 값을 전달 싶다면 -Phoge=123 식으로 기술하면 된다.

사용 예제를 아래에 올려 두었다. 이는 숫자를 전달하여 그 숫자까지를 더하는 예제이다.

task hello {
    doLast {
        def n = max.toInteger()
        for(def i in 1..n){
            println("No," + i + " count.")
        }
        println("--end.")
    }
}

테스크는 "max"라는 변수를 사용하여 최대 값을 지정한다. 예를 들어,

$ gradle hello -Pmax=5

이렇게 실행하면, 다음과 같이 메시지가 출력된다.

> Task :hello
No,1 count.
No,2 count.
No,3 count.
No,4 count.
No,5 count.
--end.

여기에서는 def n = max.toInteger()와 같이 하여 변수 max를 정수 값으로 변환한 것을 변수 n에 대입하고 있다. 그리고 이 n 값을 이용하여 for으로 반복 계산을 실시하고 있다. 이런 상태로 매개 변수를 사용하여 쉽게 값을 변수로 전달할 수 있다.



다른 테스크 호출 및 종속

다른 테스크 호출

테스크에서 다른 테스크를 호출해야 하는 경우도 있다. 예를 들어 아래와 같은 테스크가 있다고 해보자.

task a {……}
task b {……}

a와 b라는 테스크가 있을 때, 테스크 a에서 테스크 b를 호출하려면 어떻게 해야 하는가? Java적으로 생각한다면 아래와 같이 호출하면 될거라 생각할 것이다.

b()

하지만 이렇게는 작동을 하지 않는다. 그럼 어떻게 해야 하는가? 그것은 "tasks"에 있는 작업 객체 안의 메소드를 호출하여 수행한다.

작업하는 것은 모든 tasks라고 객체에 정리하고 있다. 이것은 예를 들어 a, b라는 테스크가 있다면 tasks.a과 tasks.b로 지정할 수 있다. 이 테스크 객체 안에 있는 "execute"라는 메소드를 호출하여 테스크를 수행할 수 있다.

tasks.a.execute()
tasks.b.execute()

이런 식으로 실행하여 테스크 a, b를 호출한다.

간단한 사용 예를 아래에 올려 두었다.

task hello  {
    doFirst {
        println("*** start:hello task ***")
        tasks.aaa.execute()
     }
    doLast {
        tasks.bbb.execute()
        println("*** end:hello task ***")
    }
}
 
task aaa {
    doLast {
        println("<< This is A task! >>")
    }
}
 
task bbb {
    doLast {
        println("<< I'm task B!! >>")
    }
}

gradle hello와 같이 hello 태스크를 실행해 보면, 아래와 같이 출력이 된다.

> Task :hello
*** start:hello task ***
<< This is A task! >>
<< I'm task B!! >>
*** end:hello task ***

여기에서는 hello의 doFirst 안에서 aaa, doLast에서 bbb를 호출하고 있다. 출력되는 텍스트가 호출되는 순서를 잘 확인한다.

종속 테스크 지정

어떤 테스크를 수행할 때, 다른 작업 수행이 필수적인 경우도 있다. 이러한 경우에는 "dependsOn '라는 기능을 사용할 수 있다. 이는 다음과 같이 작성한다.

task 테스크명 (dependsOn : '테스크') {
    ...... 중략 ......
}

또는 다음과 같은 작성도 가능한다.

task 테스크명 {
    dependsOn : '테스크'
    ...... 중략 ......
}

이와 같이 기술해 두면 작업이 호출될 때, 먼저 dependsOn에 지정된 작업을 수행하고 그것이 끝난 후에 테스크의 본 처리를 수행한다.

여러 테스크를 지정해야 하는 경우는 테스크명을 배열로 지정한다. [ 'a', 'b', 'c']와 같은 식이다. 이 경우 최초에 작성한 테스크부터 실행된다.

아래 목록 필드에 사용할 예제를 올려 두었다.

task hello(dependsOn:['aaa', 'bbb'])  {
    doFirst {
        println("*** start:hello task ***")
    }
    doLast {
        println("*** end:hello task ***")
    }
}
 
task aaa {
    doLast {
        println("<< This is A task! >>")
    }
}
 
task bbb {
    doLast {
        println("<< I'm task B!! >>")
    }
}

이를 "gradle hello"로 실행한다. 다음과 같이 출력이 된다.

> Task :aaa
<< This is A task! >>

> Task :bbb
<< I'm task B!! >>

> Task :hello
*** start:hello task ***
*** end:hello task ***

최초에 aaa 테스크, bbb 테스크이 실행되면, 이후에 hello 태스크가 호출되었는지 알 수 있다. dependsOn에 의해, aaa, bbb가 종속 테스크가 되는 테스크가 실행된 후가 아니면 hello가 실행되지 않게 된다.

'Gradle' 카테고리의 다른 글

[Gradle] Web 어플리케이션 개발  (0) 2017.12.23
[Gradle] DefaultTask 클래스 사용  (0) 2017.12.23
[Gradle] 테스크 생성  (1) 2017.12.23
[Gradle] build.gradle 기본  (0) 2017.12.23
[Gradle] Gradle 프로젝트 생성  (0) 2017.12.23
[Gradle] Java 프로젝트 생성(퀵가이드)  (0) 2017.12.23
  1. Guest007 2019.01.11 17:05

    정리된 글 잘보고갑니다.~

Gradle에는 build.gradle라는 파일에 빌드에 대한 처리를 작성한다. 이 빌드 파일의 기본에 대해 설명한다.



build.gradle 내용 및 플러그인

이전에 Gradle으로 "테스크"라는 것을 지정하고 다양한 작업을 수행했었다. 이러한 Gradle 명령으로 수행하는 처리는 "빌드 파일"라는 파일에 작성된 내용을 바탕으로 실행된다.

그럼, 빌드 파일에 어떤 처리가 적혀있는 것인다. build.gradle 파일을 열고 그 내용을 아래에 올려 두었다.

/*
 * This build file was generated by the Gradle 'init' task.
 *
 * This generated file contains a sample Java project to get you started.
 * For more details take a look at the Java Quickstart chapter in the Gradle
 * user guide available at https://docs.gradle.org/4.1/userguide/tutorial_java_projects.html
 */

// Apply the java plugin to add support for Java
apply plugin: 'java'

// Apply the application plugin to add support for building an application
apply plugin: 'application'

// In this section you declare where to find the dependencies of your project
repositories {
    // Use jcenter for resolving your dependencies.
    // You can declare any Maven/Ivy/file repository here.
    jcenter()
}

dependencies {
    // This dependency is found on compile classpath of this component and consumers.
    compile 'com.google.guava:guava:22.0'

    // Use JUnit test framework
    testCompile 'junit:junit:4.12'
}

// Define the main class for the application
mainClassName = 'App'

이 파일 내용을 보면서 빌드 파일의 내용을 확인한다.

build.gradle는 Groovy로 작성되어 있다. Groovy는 Java와 마찬가지로, //와 / * */으로 주석을 입력할 수 있다. 주석을 제거하면 그다지 어려울 것 같은 처리는 없어 보인다.

java 플러그인 추가

apply plugin: 'java'

처음에 apply plugin:라는 것은 Gradle 플러그인을 사용하기 위한 것이다.

java는 Java 프로그램을 위한 기능을 제공하는 플러그인이다. 앞전에 compileJava이라는 테스크를 사용했는데, 이것은 사실 java 플러그인에서 제공하는 것이다.

application 플러그인 추가

apply plugin: 'application'

또 다른 플러그인이 추가되어 있다. 이 application은 응용 프로그램에 대한 기능을 제공하는 플러그인이다. 앞에서 run 응용 프로그램을 실행했는데, 이것이 application 플러그인에 의해 제공되는 테스크이다.

메인 클래스 이름

mainClassName = 'App'

도중에 조금 넘어와서 마지막에 있는 mainClassName 값을 보자. 이것은 application 플러그인으로 사용되는 것으로, 메인 클래스를 지정한다. run으로 응용 프로그램을 실행할 수 있었던 것도 이 mainClassName 메인 클래스가 지정되어 있었기 때문이다.

java plugin

프로젝트에서 java plugin을 사용하려면 build.gradle 파일에 다음과 같이 설정하면 된다.

apply plugin: 'java'

기본 프로젝트 레이아웃

디렉토리(Directory)설명
src/main/java자바 소스 코드를 관리하는 디렉토리.
src/main/resources리소스을 관리하는 디렉토리.
src/test/java테스트 자바 소스를 관리하기 위한 디렉토리.
src/test/resources테스트 리소스를 관리하기 위한 디렉토리.
src/sourceSet/java자바 소스를 위한 특정한 source set
src/sourceSet/resources자바 리소스를 위한 특정한 source set

여기서 배포 시 테스트 소스 코드가 같이 배포되지 않는다.



저장소 (repositories)

build.gradle에 기술된 내용에는 "종속 라이브러리"에 대한 기술이 있었다. Gradle에는 프로그램으로 필요한 라이브러리를 자동으로 다운로드하고 통합하는 기능이 있다. 따라서 중요해지는 것은 "저장소(repository)"이다.

저장소라는 것은 각종 프로그램들이 저장되는 위치이다. 이 저장소는 "어떤 저장소를 사용하는지"를 빌드 파일에 작성하여 설정할 수 있다.

repositories {
    ...... 저장소 설정 ......
}

이것이 저장소를 지정하기 위한 기술이다. 이 {} 안에 저장소를 설정하는 문장을 작성한다.

온라인으로 액세스하여 사용할 수 있는 저장소로는 Gradle은 대체로 다음 두 개의 저장소 서비스를 이용한다.

Maven 중앙 저장소

mavenCentral()

이것은 Apache Maven 중앙 저장소를 이용하기 위한 것이다. Gradle은 중앙 저장소를 그대로 사용할 수 있다.

JCenter 저장소

jcenter()

이 밖에 JCenter라는 저장소도 사용할 수 있다. 이것은 Maven과 Gradle 등 각종 빌드 도구에서 사용할 수 있는 공개 저장소이다. 이를 이용하려면 jcenter()을 repositories에 기술해 둔다.

mavenCentral()와 jcenter()는 Gradle 메소드이다. 이러한 repositories 안에서 호출하여 지정된 저장소를 사용할 수 있다.



의존 라이브러리 (dependencies)

저장소에서 필요한 라이브러리를 사용하는데 사용할 수 있는 것이 dependencies라는 문이다. 이것은 다음과 같이 기술된다.

dependencies {
    ...... 라이브러리 지정 ......
}

이 {} 안에 종속 라이브러리에 대한 기술을 한다. 여기에서는 2개의 문장이 기술되어 있다.

컴파일시 의존 라이브러리

compile 'com.google.guava:guava:22.0'

이것은 컴파일시에 사용하는 라이브러리를 지정하고 있다. compile ~ 이라고 기술하는 것으로 그 라이브러리가 컴파일 시에 참조되는 것을 나타낸다.

테스트 컴파일시 의존 라이브러리

testCompile 'junit:junit:4.12'

이것은 테스트 컴파일 (단위 테스트의 프로그램을 컴파일)에 사용하는 라이브러리를 지정한다. testCompile ~라고 기술하는 것으로 그 라이브러리가 테스트 컴파일 시에 참조되는 것을 나타낸다.

 

이 외에도 다양한 처리를 수행할 때 참조하는 종속 라이브러리를 지정할 수 있다. 하나 기억해야 할 것은 클래스 패스의 지정이다.

classpath '... 라이브러리 ...'

이렇게 하면 지정된 라이브러리를 클래스 경로에 추가할 수 있다. 컴파일에서 실행시까지 의존하는 라이브러리 지정에 사용한다. 이것도 같이 기억해두면 좋을 것이다.



라이브러리 지정

여기에서는 2개의 라이브러리를 사용하고 있지만, 이것들은 각각 다음과 같이 값을 지정한다.

'com.google.guava:guava:22.0'
'junit:junit:4.12'

이러한 작성법을 정리하면 대략 다음과 같이 된다.

'그룹 : 이름 : 버전'

그룹은 그 라이브러리가 속해 있는 기업 및 단체 등을 나타낸다. 예를 들어 기업에서 만드는 것은 그 기업 그룹을 정해지고, 그것이 지정된다. 이름은 라이브러리의 이름이다.

이상을 바탕으로 하여 여기에서 사용하는 라이브러리가 무엇인지 살펴 보도록 한다.

'com.google.guava:guava:22.0'
그룹 : com.google.guava
이름 : guava
버전 : 22.0
'junit:junit:4.12'
그룹 : junit
이름 : junit
버전 : 4.12

이런 식으로 된다. 이것으로 어떤 라이브러리가 사용되고 있는지 잘 알게 되었다.

개별적으로 지정하는 방법

이와 같이 하나의 텍스트에 라이브러리 정보를 정리한 작성법은 간단하지만, 보기 어려운 것 같은 느낌도 든다. Gradle에는 이 밖에 그룹, 이름, 버전을 각각 분리하여 작성하는 방법도 가능하다.

group:'그룹', name:'이름', version:'버전'

이런 식으로 작성한다. 예를 들어, 샘플로 준비되어 있는 라이브러리의 지정하려면 다음과 같다.

compile 'com.google.guava:guava:22.0'
 ↓
compile group:'com.google.guava', name:'guava', version:'22.0'
testCompile 'junit:junit:4.12'
 ↓
testCompile group:'junit', name:'junit', version:'4.12'

이렇게 작성하는 것이 하나 하나의 값이 명확하게 알아 볼 수 있다. 하나의 텍스트로 정리하는 작성법은 쓰고 틀렸을 때 실수가 찾기 어려운 것이다. 이런 작성 법이 확실하게 하기에는 좋다.

'Gradle' 카테고리의 다른 글

[Gradle] DefaultTask 클래스 사용  (0) 2017.12.23
[Gradle] 테스크 생성  (1) 2017.12.23
[Gradle] build.gradle 기본  (0) 2017.12.23
[Gradle] Gradle 프로젝트 생성  (0) 2017.12.23
[Gradle] Java 프로젝트 생성(퀵가이드)  (0) 2017.12.23
[Gradle] Gradle 준비  (0) 2017.12.23

Gradle을 사용하여 Java 프로젝트를 작성한다. 그리고 프로젝트가 어떻게 구성되어 있는지 살펴 보고 설명한다.



Gradle 프로젝트 초기화

Gradle 프로젝트 구성

생성된 프로젝트가 어떻게 구성되어 있는지, 폴더의 내용을 확인한다. 다음과 같은 것들이 준비되어 있어야 한다.

.
├── build.gradle
├── gradle
│   └── wrapper
│       ├── gradle-wrapper.jar
│       └── gradle-wrapper.properties
├── gradlew
├── gradlew.bat
├── settings.gradle
└── src
    ├── main
    │   └── java
    │       └── App.java
    └── test
        └── java
            └── AppTest.java

.gradle 폴더

Gradle이 사용하는 폴더이다. 작업(task)로 생성된 파일이 저장된다. 이 내용을 편집하는 일은 거의 없다.

gradle 폴더

이것도 Gradle이 필요한 경우 사용할 폴더이다. 기본적으로 Gradle 환경을 정리한 "wrapper 파일"이라는 파일들이 저장되어 있다.

src 폴더

이것이 프로젝트에서 만든 프로그램 관련 폴더이다. 프로젝트에서 사용하는 파일(소스 코드 파일, 각종 리소스 파일 등)은 모두 이 안에 들어간다.

build.gradle

이 Gradle 기본 빌드 설정 파일이다. 이 안에 프로젝트의 빌드 처리에 대해서 내용이 작성되어 있다.

gradlew, gradlew.bat

이 2개는 Gradle의 명령이다. bat가 붙어있는 것이 Windows 용이고, macOS 및 Linux 용이다.

settings.gradle

프로젝트에 대한 설정 정보를 작성한 파일이다.

가장 중요한 것은 src 폴더이다. 이 안에 개발하는 프로그램에서 사용하는 파일이 모두 저장된다.

다음으로 중요한 것은 "build.gradle" 파일이다. 이것은 빌드 파일이고 해서 빌드 처리의 내용을 작성하는 파일이다. 이 파일은 Groovy 언어로 작성되어 있다.

src 폴더

그럼, 개발의 본체 부분이 되는 src"폴더를 열어 본다. 이 폴더에는 이미 여러 폴더와 파일이 준비되어 있다. 폴더의 구성을 정리하면 다음과 같이 되어 있다.

src
├── main
│   └── java
│       └── App.java
└── test
    └── java
        └── AppTest.java

src 폴더에는 main과 test라는 2개의 폴더가 포함된다. 이들은 각각 다음과 같은 역할을 한다.

· main 폴더

이것이 만드는 프로그램 본체의 파일을 모아 두는 폴더이다. 이것을 열면에 java 폴더가 있다. 이는 Java 소스 코드를 넣어두기 위한 폴더이다. 이 안에 샘플로 App.java는 소스 코드 파일이 포함되어 있다.

· test 폴더

이것은 단위 테스트 파일을 모아 두는 폴더이다. 역시 java 폴더가 있고 그 안에 AppTest.java 샘플 파일이 있다.

main와 test에도 그 중에 먼저 언어 이름의 폴더가 있고 거기에 그 언어로 작성된 소스 코드 파일이 배치되는 구조로 되어 있는 것을 알 수 있다. 이것이 Gradle 프로젝트의 기본 폴더 구조이다.

src의 내용은 Maven과 같다?

폴더 구성을 보고 어디 선가 본 적이 있는 사람도 있을 수도 있다.

사실은 src 폴더의 구성은 Apache Maven에 의한 프로젝트와 똑같다. Maven 프로젝트도 프로젝트 폴더에 src 폴더가 있고 그 안에 main과 test가 있고 ...... 등등 똑같은 구성되어 있다.

이러한 빌드 도구는 아무래도 Maven에 의해 일반적으로 영향받았다고 해도 될 것이다. Maven은 좋든 나쁘든 Java 빌드 도구의 표준이 되고 있으며, Gradle도 Maven의 폴더 구조를 그대로 따르고 있는 것이다.




gradle init 명령과 type 종류

Gradle 프로젝트를 만든 gradle init 명령에 대해 설명한다.

이것은 "init"라는 작업을 수행하는 것이다. Gradle은 수행할 작업은 "테스크(task)"라고 한다. gradle 명령은 이 테스크을 지정하고 실행하는 것이다.

init 테스크은 폴더에 프로젝트 파일이나 폴더들을 생성하고 폴더를 초기화한다. 이전 페이지에서는 --type 옵션이 넣었다. 이 옵션에 의해 "어떤 종류의 프로그램 작성을 위한 프로젝트에 초기화 하는지"를 지정할 수 있다. 이 유형은 조금씩 증가하고 있어 2017년 10 월 현재는 다음의 것이 준비되어 있다.

java-application

Java 애플리케이션 프로젝트 작성에 대한 타입이다. 기본적으로 App.java가 제공된다.

java-library

Java 라이브러리 프로젝트 생성을 위한 타입이다. 단순히 샘플로 제공되는 소스 코드 파일이 응용 프로그램의 메인 클래스가 되어 있지 않다는 정도의 차이이다. (그리고, build.gradle도 조금 다르다)

groovy-application

Groovy 애플리케이션 개발을 위한 프로젝트이다. Groovy 개발의 기본 타입이라고 해도 좋을 것이다.

groovy-library

Groovy 라이브러리 개발을 위한 프로젝트이다. 기본적으로 groovy-application과 같고, 샘플 코드가 다른 정도이다.

scala-library

이것은 Java 가상 머신에서 구동되는 언어 Scala의 개발 타입이다. Scala에서는 여전히 응용 프로그램의 타입은 준비되어 있지 않은 것 같다.

basic

기본 타입이다. 이것은 모든 타입의 기반이 되는 것으로 src 는 제공되지 않는다. 또한 빌드 파일도 구체적인 처리 등은 기술되지 않고, build.gradle과 settings.gradle만 생성된다. --type을 붙이지 않고, 단순히 gradle init만 실행하면 이 basic 타입이 지정된다.

pom

Maven의 pom.xml을 바탕으로 build.gradle 을 생성한다.

 

Java 프로그래머는 java-application, java-library만 알고 있으면 충분하다.




컴파일 및 실행


여기서는 만든 프로젝트를 Gradle 명령으로 처리를 설명한다. 여기에서 컴파일, 실행, 패키지 같은 기본 조작 처리를 설명한다.

프로그램 컴파일

$ gradle compileJava

컴파일은 compileJava 라는 테스크로 제공한다. 이것은 Java 소스 코드를 컴파일하기 위한 것이다.

프로그램 실행

$ gradle run

java-application 타입의 프로젝트에는 run 테스크라는 것이 제공되고, 이를 실행하여 메인 클래스를 실행할 수 있다. 디폴트로 App.java가 실행된다.

프로그램 패키지

$ gradle jar

jar 테스크은 그 이름대로 프로그램을 Jar 파일에 모와서 저장한다. 이는 프로젝트에 생성되는 build 폴더의 libs 폴더에 저장된다.

프로젝트 클린

$ gradle clean

프로젝트를 빌드할 때에 build 폴더에 여러 파일이 저장된다. clean 작업은 이 파일들을 제거하고 빌드 이전 상태로 되돌린다.

빌드 및 실행

위에 처리 방법을 알았으니 실제로 명령을 실행해 보자. 명령 프롬프트 또는 터미널은 열어서 cd로 프로젝트 폴더에 이동한다. 그 상태에서 다음과 같이 실행한다.

$ gradle compileJava
$ gradle run
$ gradle jar

프로그램의 컴파일을 실행한다.

$ gradle compileJava

Download https://jcenter.bintray.com/com/google/guava/guava/22.0/guava-22.0.pom
Download https://jcenter.bintray.com/com/google/guava/guava-parent/22.0/guava-parent-22.0.pom
... 중략....
Download https://jcenter.bintray.com/org/codehaus/mojo/animal-sniffer-annotations/1.14/animal-sniffer-annotations-1.14.jar
Download https://jcenter.bintray.com/com/google/guava/guava/22.0/guava-22.0.jar

BUILD SUCCESSFUL in 13s
1 actionable task: 1 executed

프로젝트를 실행한다.

$ gradle run

> Task :run
Hello world.


BUILD SUCCESSFUL in 0s
2 actionable tasks: 1 executed, 1 up-to-date

프로젝트의 jar 파일을 생성한다.

$ gradle jar

BUILD SUCCESSFUL in 0s
2 actionable tasks: 1 executed, 1 up-to-date

프로젝트 실행 시에 "Hello World."라는 메시지가 출력된다. 또한 build 폴더의 libs 폴더에는 GradleApp.jar이라는 Jar 파일이 생성된 것을 확인할 수 있다.

그러나 java -jar GradleApp.jar으로 이 Jar 파일을 실행할 수 없다. 왜냐하면 매니페스트 파일이 포함되어 있지 않아 실행 가능한 Jar 파일로 아니기 때문이다.

jara -classpath GradleApp.jar App와 같은 방식으로 -classpath를 지정하여, 명시적으로 App 클래스를 실행하면 제대로 실행할 수 있다. 조금은 귀찮지만, 일단은 동작하는 것만 확인한다.



'Gradle' 카테고리의 다른 글

[Gradle] DefaultTask 클래스 사용  (0) 2017.12.23
[Gradle] 테스크 생성  (1) 2017.12.23
[Gradle] build.gradle 기본  (0) 2017.12.23
[Gradle] Gradle 프로젝트 생성  (0) 2017.12.23
[Gradle] Java 프로젝트 생성(퀵가이드)  (0) 2017.12.23
[Gradle] Gradle 준비  (0) 2017.12.23

+ Recent posts