javapoet - GitLite

KO | EN

gitlite — search

#python #hacktoberfest #react #typescript #linux #macos #awesome #cli #awesome-list #vue #pytorch #mcp #openai #open-source

javapoet

(★ 10,845)

`.java` 소스 파일을 생성하기 위한 Java API입니다.

파일 탐색기

최종 버전 다운로드 (.zip)

- - build.yml
  - settings.xml
- CONTRIBUTING.md
.gitignore
CHANGELOG.md
checkstyle.xml
LICENSE.txt
pom.xml
README.md
RELEASING.md
renovate.json

# 설치 가이드

1. 코드 내려받기

git clone https://github.com/square/javapoet

깃허브에서 프로젝트 코드 전체를 내 컴퓨터로 내려받습니다.

cd javapoet

방금 내려받은 프로젝트 폴더 안으로 이동합니다.

2. Maven (Java)

보통 추천

사전 준비물

Git GitHub에서 프로젝트 코드를 내려받으려면 필요합니다.
JDK (Java) Java 프로젝트를 빌드/실행하려면 필요합니다.
Maven mvn 명령어를 쓰기 위한 빌드 도구입니다.

mvn clean install

Maven으로 의존성 설치와 빌드를 진행합니다.

✅ BUILD SUCCESS 메시지가 뜨면 성공입니다. target/ 폴더에 결과물이 생성됩니다.

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

JavaPoet
========
`JavaPoet`은 `.java` 소스 파일을 생성하기 위한 Java API입니다.
소스 파일 생성은 어노테이션 처리나 메타데이터 파일(예: 데이터베이스 스키마, 프로토콜 포맷)과의 상호작용 같은 작업을 수행할 때 유용합니다. 코드를 생성함으로써 상용구 코드를 작성할 필요가 없어지며 메타데이터의 단일 진실 공급원(Single Source of Truth)을 유지할 수 있습니다.

Deprecated
----------
2020년 10월 10일부로 Square의 JavaPoet 프로젝트는 더 이상 사용되지 않습니다(deprecated). 우리의 작업에 자부심을 느끼지만, 지속적인 유지보수를 따라가지 못했습니다.
최신 Java 언어 기능을 지원하는 대안을 찾고 계신다면, [Palantir의 JavaPoet](https://github.com/palantir/javapoet)이 한 가지 옵션입니다.
해당 프로젝트로 전환하려면 새로운 Maven 좌표가 필요합니다:
```diff
- javapoet = { module = "com.squareup:javapoet", version = "1.13.0" }
+ javapoet = { module = "com.palantir.javapoet:javapoet", version = "0.5.0" }
```
그리고 새로운 임포트가 필요합니다:
```
sed -i "" \
's/com.squareup.javapoet.\([A-Za-z]\*\)/com.palantir.javapoet.\1/g' \
`find . -name "\*.kt" -or -name "\*.java"`
```
또한 필드가 함수로 변경된 일부 API 변경 사항을 추적해야 할 수도 있습니다:
```diff
- javaFile.packageName
+ javaFile.packageName()
```

### Example
여기 (지루한) `HelloWorld` 클래스가 있습니다:
```java
package com.example.helloworld;
public final class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, JavaPoet!");
}
}
```
그리고 이것은 JavaPoet을 사용하여 이를 생성하는 (흥미진진한) 코드입니다:
```java
MethodSpec main = MethodSpec.methodBuilder("main")
.addModifiers(Modifier.PUBLIC, Modifier.STATIC)
.returns(void.class)
.addParameter(String[].class, "args")
.addStatement("$T.out.println($S)", System.class, "Hello, JavaPoet!")
.build();
TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
.addModifiers(Modifier.PUBLIC, Modifier.FINAL)
.addMethod(main)
.build();
JavaFile javaFile = JavaFile.builder("com.example.helloworld", helloWorld)
.build();
javaFile.writeTo(System.out);
```
main 메서드를 선언하기 위해 수정자, 반환 타입, 매개변수 및 코드 구문으로 설정된 `MethodSpec` "main"을 만들었습니다. main 메서드를 `HelloWorld` 클래스에 추가한 다음, 이를 `HelloWorld.java` 파일에 추가합니다.
이 경우 파일을 `System.out`에 쓰지만, 문자열로 가져오거나(`JavaFile.toString()`) 파일 시스템에 쓸 수도 있습니다(`JavaFile.writeTo()`).
[Javadoc][javadoc]에는 아래에서 살펴볼 완전한 JavaPoet API가 정리되어 있습니다.

### Code & Control Flow
JavaPoet API의 대부분은 평범하고 오래된 불변 Java 객체를 사용합니다. API를 친숙하게 만들기 위한 빌더, 메서드 체이닝, 가변 인자(varargs)도 제공합니다. JavaPoet은 클래스 및 인터페이스(`TypeSpec`), 필드(`FieldSpec`), 메서드 및 생성자(`MethodSpec`), 매개변수(`ParameterSpec`), 그리고 어노테이션(`AnnotationSpec`)을 위한 모델을 제공합니다.
하지만 메서드와 생성자의 \_본문(body)\_은 모델링되지 않습니다. 표현식 클래스나 구문 클래스, 구문 트리 노드가 없습니다. 대신 JavaPoet은 코드 블록에 문자열을 사용합니다:
```java
MethodSpec main = MethodSpec.methodBuilder("main")
.addCode(""
+ "int total = 0;\n"
+ "for (int i = 0; i < 10; i++) {\n"
+ " total += i;\n"
+ "}\n")
.build();
```
이는 다음을 생성합니다:
```java
void main() {
int total = 0;
for (int i = 0; i < 10; i++) {
total += i;
}
}
```
수동으로 세미콜론, 줄 바꿈, 들여쓰기를 하는 것은 지루하므로 JavaPoet은 이를 더 쉽게 만들어 주는 API를 제공합니다. 세미콜론과 개행을 처리해 주는 `addStatement()`와 중괄호, 개행, 들여쓰기를 위해 함께 사용되는 `beginControlFlow()` + `endControlFlow()`가 있습니다:
```java
MethodSpec main = MethodSpec.methodBuilder("main")
.addStatement("int total = 0")
.beginControlFlow("for (int i = 0; i < 10; i++)")
.addStatement("total += i")
.endControlFlow()
.build();
```
이 예제는 생성된 코드가 상수이기 때문에 별로 감흥이 없습니다! 0부터 10까지 더하는 것 대신, 연산과 범위를 설정 가능하게 만들고 싶다고 가정해 봅시다. 다음은 메서드를 생성하는 메서드입니다:
```java
private MethodSpec computeRange(String name, int from, int to, Strin

g op) {
return MethodSpec.methodBuilder(name)
.returns(int.class)
.addStatement("int result = 1")
.beginControlFlow("for (int i = " + from + "; i < " + to + "; i++)")
.addStatement("result = result " + op + " i")
.endControlFlow()
.addStatement("return result")
.build();
}
```
그리고 `computeRange("multiply10to20", 10, 20, "\*")`를 호출하면 다음과 같은 결과를 얻습니다:
```java
int multiply10to20() {
int result = 1;
for (int i = 10; i < 20; i++) {
result = result \* i;
}
return result;
}
```
메소드를 생성하는 메소드입니다! 게다가 JavaPoet은 바이트코드가 아닌 소스코드를 생성하므로, 코드가 올바른지 직접 읽어가며 확인할 수 있습니다.
`if/else`와 같은 일부 제어 흐름 문장은 무제한의 제어 흐름 가능성을 가질 수 있습니다.
`nextControlFlow()`를 사용하여 이러한 옵션들을 처리할 수 있습니다:
```java
MethodSpec main = MethodSpec.methodBuilder("main")
.addStatement("long now = $T.currentTimeMillis()", System.class)
.beginControlFlow("if ($T.currentTimeMillis() < now)", System.class)
.addStatement("$T.out.println($S)", System.class, "Time travelling, woo hoo!")
.nextControlFlow("else if ($T.currentTimeMillis() == now)", System.class)
.addStatement("$T.out.println($S)", System.class, "Time stood still!")
.nextControlFlow("else")
.addStatement("$T.out.println($S)", System.class, "Ok, time still moving forward")
.endControlFlow()
.build();
```
이는 다음 코드를 생성합니다:
```java
void main() {
long now = System.currentTimeMillis();
if (System.currentTimeMillis() < now) {
System.out.println("Time travelling, woo hoo!");
} else if (System.currentTimeMillis() == now) {
System.out.println("Time stood still!");
} else {
System.out.println("Ok, time still moving forward");
}
}
```
`try/catch`를 사용한 예외 처리 역시 `nextControlFlow()`의 활용 사례 중 하나입니다:
```java
MethodSpec main = MethodSpec.methodBuilder("main")
.beginControlFlow("try")
.addStatement("throw new Exception($S)", "Failed")
.nextControlFlow("catch ($T e)", Exception.class)
.addStatement("throw new $T(e)", RuntimeException.class)
.endControlFlow()
.build();
```
이는 다음 코드를 만들어냅니다:
```java
void main() {
try {
throw new Exception("Failed");
} catch (Exception e) {
throw new RuntimeException(e);
}
}
```
### 리터럴을 위한 $L
`beginControlFlow()`와 `addStatement` 호출 시 문자열 연결(concatenation)을 사용하는 것은 산만하며 연산자가 너무 많아집니다. 이를 해결하기 위해 JavaPoet은 [`String.format()`][formatter]에서 영감을 받았지만 호환되지는 않는 문법을 제공합니다. 이는 출력이 **리터럴(literal)** 값을 내보내도록 **`$L`**을 허용합니다. 이는 정확히 `Formatter`의 `%s`처럼 동작합니다:
```java
private MethodSpec computeRange(String name, int from, int to, String op) {
return MethodSpec.methodBuilder(name)
.returns(int.class)
.addStatement("int result = 0")
.beginControlFlow("for (int i = $L; i < $L; i++)", from, to)
.addStatement("result = result $L i", op)
.endControlFlow()
.addStatement("return result")
.build();
}
```
리터럴은 이스케이프 처리 없이 출력 코드로 직접 내보내집니다. 리터럴에 대한 인자는 문자열, 원시 타입(primitives), 그리고 아래에 설명된 몇 가지 JavaPoet 타입일 수 있습니다.
### 문자열을 위한 $S
문자열 리터럴을 포함하는 코드를 생성할 때, 따옴표로 감싸고 이스케이프 처리까지 완료된 **문자열**을 내보내기 위해 **`$S`**를 사용할 수 있습니다. 다음은 각각 자신의 이름을 반환하는 3개의 메소드를 생성하는 프로그램입니다:
```java
public static void main(String[] args) throws Exception {
TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
.addModifiers(Modifier.PUBLIC, Modifier.FINAL)
.addMethod(whatsMyName("slimShady"))
.addMethod(whatsMyName("eminem"))
.addMethod(whatsMyName("marshallMathers"))
.build();
JavaFile javaFile = JavaFile.builder("com.example.helloworld", helloWorld)
.build();
javaFile.writeTo(System.out);
}
private static MethodSpec whatsMyName(String name) {
return MethodSpec.methodBuilder(name)
.returns(String.class)
.addStatement("return $S", name)
.build();
}
```
이 경우, `$S`를 사용하면 따옴표가 자동으로 추가됩니다:
```java
public final class HelloWorld {
String slimShady() {
return "slimShady";
}
String eminem() {
return "eminem";
}
Str

ing marshallMathers() {
return "marshallMathers";
}
}
```
### 타입용 `$T`
우리 Java 프로그래머들은 타입을 매우 좋아합니다. 타입을 사용하면 코드를 훨씬 쉽게 이해할 수 있기 때문입니다. 그리고 JavaPoet도 이에 동참합니다. `import` 문 자동 생성 기능을 포함하여 타입에 대한 풍부한 내장 지원을 제공합니다. 단순히 **`$T`**를 사용하여 **타입**을 참조하세요:
```java
MethodSpec today = MethodSpec.methodBuilder("today")
.returns(Date.class)
.addStatement("return new $T()", Date.class)
.build();
TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
.addModifiers(Modifier.PUBLIC, Modifier.FINAL)
.addMethod(today)
.build();
JavaFile javaFile = JavaFile.builder("com.example.helloworld", helloWorld)
.build();
javaFile.writeTo(System.out);
```
이렇게 하면 필요한 `import` 문이 모두 포함된 다음과 같은 `.java` 파일이 생성됩니다:
```java
package com.example.helloworld;
import java.util.Date;
public final class HelloWorld {
Date today() {
return new Date();
}
}
```
우리는 코드를 생성할 때 마침 사용할 수 있는 클래스를 참조하기 위해 `Date.class`를 전달했습니다. 하지만 항상 이럴 필요는 없습니다. 다음은 비슷한 예이지만, 아직 존재하지 않는 클래스를 참조하는 경우입니다:
```java
ClassName hoverboard = ClassName.get("com.mattel", "Hoverboard");
MethodSpec today = MethodSpec.methodBuilder("tomorrow")
.returns(hoverboard)
.addStatement("return new $T()", hoverboard)
.build();
```
그리고 아직 존재하지 않는 해당 클래스도 마찬가지로 import 됩니다:
```java
package com.example.helloworld;
import com.mattel.Hoverboard;
public final class HelloWorld {
Hoverboard tomorrow() {
return new Hoverboard();
}
}
```
`ClassName` 타입은 매우 중요하며, JavaPoet을 사용할 때 자주 필요하게 됩니다. 이 타입은 모든 \_선언된\_ 클래스를 식별할 수 있습니다. 선언된 타입은 Java의 풍부한 타입 시스템의 시작일 뿐이며, 배열, 매개변수화된 타입, 와일드카드 타입, 타입 변수도 존재합니다. JavaPoet에는 이러한 각각을 빌드하기 위한 클래스가 있습니다:
```java
ClassName hoverboard = ClassName.get("com.mattel", "Hoverboard");
ClassName list = ClassName.get("java.util", "List");
ClassName arrayList = ClassName.get("java.util", "ArrayList");
TypeName listOfHoverboards = ParameterizedTypeName.get(list, hoverboard);
MethodSpec beyond = MethodSpec.methodBuilder("beyond")
.returns(listOfHoverboards)
.addStatement("$T result = new $T<>()", listOfHoverboards, arrayList)
.addStatement("result.add(new $T())", hoverboard)
.addStatement("result.add(new $T())", hoverboard)
.addStatement("result.add(new $T())", hoverboard)
.addStatement("return result")
.build();
```
JavaPoet은 각 타입을 분해하고 가능한 경우 그 구성 요소들을 import 합니다.
```java
package com.example.helloworld;
import com.mattel.Hoverboard;
import java.util.ArrayList;
import java.util.List;
public final class HelloWorld {
List beyond() {
List result = new ArrayList<>();
result.add(new Hoverboard());
result.add(new Hoverboard());
result.add(new Hoverboard());
return result;
}
}
```
#### Import static
JavaPoet은 `import static`을 지원합니다. 이는 타입 멤버 이름을 명시적으로 수집하는 방식으로 이루어집니다. 정적 구문(static sugar)을 추가하여 이전 예제를 강화해 보겠습니다:
```java
...
ClassName namedBoards = ClassName.get("com.mattel", "Hoverboard", "Boards");
MethodSpec beyond = MethodSpec.methodBuilder("beyond")
.returns(listOfHoverboards)
.addStatement("$T result = new $T<>()", listOfHoverboards, arrayList)
.addStatement("result.add($T.createNimbus(2000))", hoverboard)
.addStatement("result.add($T.createNimbus(\"2001\"))", hoverboard)
.addStatement("result.add($T.createNimbus($T.THUNDERBOLT))", hoverboard, namedBoards)
.addStatement("$T.sort(result)", Collections.class)
.addStatement("return result.isEmpty() ? $T.emptyList() : result", Collections.class)
.build();
TypeSpec hello = TypeSpec.classBuilder("HelloWorld")
.addMethod(beyond)
.build();
JavaFile.builder("com.example.helloworld", hello)
.addStaticImport(hoverboard, "createNimbus")
.addStaticImport(namedBoards, "\*")
.addStaticImport(Collections.class, "\*")
.build();
```
JavaPoet은 먼저 다음을 추가합니다: `import static

configured된 대로 블록을 파일에 추가하고, 그에 맞춰 모든 호출을 일치시키고 변형하며, 필요에 따라 다른 모든 타입도 임포트합니다.
```java
package com.example.helloworld;
import static com.mattel.Hoverboard.Boards.\*;
import static com.mattel.Hoverboard.createNimbus;
import static java.util.Collections.\*;
import com.mattel.Hoverboard;
import java.util.ArrayList;
import java.util.List;
class HelloWorld {
List beyond() {
List result = new ArrayList<>();
result.add(createNimbus(2000));
result.add(createNimbus("2001"));
result.add(createNimbus(THUNDERBOLT));
sort(result);
return result.isEmpty() ? emptyList() : result;
}
}
```
### 이름을 위한 $N
생성된 코드는 종종 자기 참조적입니다. 다른 생성된 선언을 그 이름으로 참조하려면 **`$N`**을 사용하세요. 다음은 다른 메서드를 호출하는 메서드입니다:
```java
public String byteToHex(int b) {
char[] result = new char[2];
result[0] = hexDigit((b >>> 4) & 0xf);
result[1] = hexDigit(b & 0xf);
return new String(result);
}
public char hexDigit(int i) {
return (char) (i < 10 ? i + '0' : i - 10 + 'a');
}
```
위 코드를 생성할 때, `$N`을 사용하여 `hexDigit()` 메서드를 `byteToHex()` 메서드의 인수로 전달합니다:
```java
MethodSpec hexDigit = MethodSpec.methodBuilder("hexDigit")
.addParameter(int.class, "i")
.returns(char.class)
.addStatement("return (char) (i < 10 ? i + '0' : i - 10 + 'a')")
.build();
MethodSpec byteToHex = MethodSpec.methodBuilder("byteToHex")
.addParameter(int.class, "b")
.returns(String.class)
.addStatement("char[] result = new char[2]")
.addStatement("result[0] = $N((b >>> 4) & 0xf)", hexDigit)
.addStatement("result[1] = $N(b & 0xf)", hexDigit)
.addStatement("return new String(result)")
.build();
```
### 코드 블록 포맷 문자열
코드 블록은 몇 가지 방법으로 플레이스홀더의 값을 지정할 수 있습니다. 코드 블록에 대한 각 작업에는 하나의 스타일만 사용할 수 있습니다.
#### 상대적 인수
포맷 문자열의 각 플레이스홀더에 대한 인수 값을 `CodeBlock.add()`에 전달합니다. 각 예제에서는 "I ate 3 tacos"라는 코드를 생성합니다.
```java
CodeBlock.builder().add("I ate $L $L", 3, "tacos")
```
#### 위치 인수
사용할 인수를 지정하기 위해 포맷 문자열의 플레이스홀더 앞에 (1부터 시작하는) 정수 인덱스를 배치합니다.
```java
CodeBlock.builder().add("I ate $2L $1L", "tacos", 3)
```
#### 이름 매칭 인수
`$argumentName:X` 구문을 사용합니다. 여기서 `X`는 포맷 문자이고, 포맷 문자열의 모든 인수 키가 포함된 맵과 함께 `CodeBlock.addNamed()`를 호출합니다. 인수 이름은 `a-z`, `A-Z`, `0-9`, 그리고 `\_`의 문자를 사용하며, 반드시 소문자로 시작해야 합니다.
```java
Map map = new LinkedHashMap<>();
map.put("food", "tacos");
map.put("count", 3);
CodeBlock.builder().addNamed("I ate $count:L $food:L", map)
```
### 메서드
위의 모든 메서드에는 코드 본문이 있습니다. 본문이 없는 메서드를 얻으려면 `Modifiers.ABSTRACT`를 사용하세요. 이는 둘러싸는 클래스가 추상 클래스이거나 인터페이스인 경우에만 유효합니다.
```java
MethodSpec flux = MethodSpec.methodBuilder("flux")
.addModifiers(Modifier.ABSTRACT, Modifier.PROTECTED)
.build();
TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
.addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
.addMethod(flux)
.build();
```
이는 다음 코드를 생성합니다:
```java
public abstract class HelloWorld {
protected abstract void flux();
}
```
다른 한정자들도 허용되는 곳에서 작동합니다. 한정자를 지정할 때 JavaPoet은 안드로이드에서 사용할 수 없는 클래스인 [`javax.lang.model.element.Modifier`][modifier]를 사용한다는 점에 유의하세요. 이 제약은 코드를 생성하는 코드에만 적용되며, 출력된 코드는 JVM, 안드로이드, GWT 등 모든 곳에서 실행됩니다.
메서드에는 매개변수, 예외, 가변 인자, Javadoc, 어노테이션, 타입 변수 및 반환 타입도 있습니다. 이 모든 것은 `MethodSpec.Builder`로 구성됩니다.
### 생성자
`MethodSpec`은 다소 부적절한 이름이지만, 생성자에도 사용할 수 있습니다:
```java
MethodSpec flux = MethodSpec.constructorBuilder()
.addModifiers(Modifier.PUBLIC)
.addParameter(String.class, "greeting")
.addStatement("this.$N = $N", "greeting", "greetin

g")
.build();
TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
.addModifiers(Modifier.PUBLIC)
.addField(String.class, "greeting", Modifier.PRIVATE, Modifier.FINAL)
.addMethod(flux)
.build();
```
이는 다음 코드를 생성합니다:
```java
public class HelloWorld {
private final String greeting;
public HelloWorld(String greeting) {
this.greeting = greeting;
}
}
```
대체로 생성자는 메서드와 정확히 같은 방식으로 작동합니다. 코드를 출력할 때, JavaPoet은 출력 파일에서 메서드보다 생성자를 앞에 배치합니다.
### 매개변수
`ParameterSpec.builder()` 또는 `MethodSpec`의 편리한 `addParameter()` API를 사용하여 메서드와 생성자에 매개변수를 선언하세요:
```java
ParameterSpec android = ParameterSpec.builder(String.class, "android")
.addModifiers(Modifier.FINAL)
.build();
MethodSpec welcomeOverlords = MethodSpec.methodBuilder("welcomeOverlords")
.addParameter(android)
.addParameter(String.class, "robot", Modifier.FINAL)
.build();
```
`android` 및 `robot` 매개변수를 생성하기 위한 위의 코드는 서로 다르지만, 출력 결과는 같습니다:
```java
void welcomeOverlords(final String android, final String robot) {
}
```
매개변수에 어노테이션(`@Nullable` 등)이 있는 경우 확장된 `Builder` 형식이 필요합니다.
### 필드
매개변수와 마찬가지로, 필드도 빌더를 사용하거나 편리한 헬퍼 메서드를 사용하여 생성할 수 있습니다:
```java
FieldSpec android = FieldSpec.builder(String.class, "android")
.addModifiers(Modifier.PRIVATE, Modifier.FINAL)
.build();
TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
.addModifiers(Modifier.PUBLIC)
.addField(android)
.addField(String.class, "robot", Modifier.PRIVATE, Modifier.FINAL)
.build();
```
이는 다음을 생성합니다:
```java
public class HelloWorld {
private final String android;
private final String robot;
}
```
필드에 Javadoc, 어노테이션 또는 필드 초기화 구문이 있는 경우 확장된 `Builder` 형식이 필요합니다. 필드 초기화 구문은 위의 코드 블록과 동일한 [`String.format()`][formatter] 유사 구문을 사용합니다:
```java
FieldSpec android = FieldSpec.builder(String.class, "android")
.addModifiers(Modifier.PRIVATE, Modifier.FINAL)
.initializer("$S + $L", "Lollipop v.", 5.0d)
.build();
```
이는 다음을 생성합니다:
```java
private final String android = "Lollipop v." + 5.0;
```
### 인터페이스
JavaPoet은 인터페이스를 처리하는 데 아무런 문제가 없습니다. 인터페이스 메서드는 항상 `PUBLIC ABSTRACT`여야 하고 인터페이스 필드는 항상 `PUBLIC STATIC FINAL`이어야 합니다. 인터페이스를 정의할 때 이러한 수정자(modifier)들이 필요합니다:
```java
TypeSpec helloWorld = TypeSpec.interfaceBuilder("HelloWorld")
.addModifiers(Modifier.PUBLIC)
.addField(FieldSpec.builder(String.class, "ONLY\_THING\_THAT\_IS\_CONSTANT")
.addModifiers(Modifier.PUBLIC, Modifier.STATIC, Modifier.FINAL)
.initializer("$S", "change")
.build())
.addMethod(MethodSpec.methodBuilder("beep")
.addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
.build())
.build();
```
하지만 코드가 생성될 때는 이러한 수정자들이 생략됩니다. 이것들은 기본값이므로 `javac`를 위해 포함할 필요가 없습니다!
```java
public interface HelloWorld {
String ONLY\_THING\_THAT\_IS\_CONSTANT = "change";
void beep();
}
```
### 열거형 (Enums)
열거형 타입을 생성하려면 `enumBuilder`를 사용하고, 각 값에는 `addEnumConstant()`를 사용하세요:
```java
TypeSpec helloWorld = TypeSpec.enumBuilder("Roshambo")
.addModifiers(Modifier.PUBLIC)
.addEnumConstant("ROCK")
.addEnumConstant("SCISSORS")
.addEnumConstant("PAPER")
.build();
```
이는 다음을 생성합니다:
```java
public enum Roshambo {
ROCK,
SCISSORS,
PAPER
}
```
열거형 값이 메서드를 오버라이드하거나 상위 클래스 생성자를 호출하는 고급 열거형도 지원됩니다. 다음은 포괄적인 예시입니다:
```java
TypeSpec helloWorld = TypeSpec.enumBuilder("Roshambo")
.addModifiers(Modifier.PUBLIC)
.addEnumConstant("ROCK", TypeSpec.anonymousClassBuilder("$S", "fist")
.addMethod(MethodSpec.methodBuilder("toString")
.addAnnotation(Override.class)
.addModifiers(Modifier.PUBLIC)
.addStatement("return $S", "avalanche!")
.returns(String.class)
.build())
.build())
.addEnumConstant("SCISSORS", TypeSpec.a

nonymousClassBuilder("$S", "peace")
.build())
.addEnumConstant("PAPER", TypeSpec.anonymousClassBuilder("$S", "flat")
.build())
.addField(String.class, "handsign", Modifier.PRIVATE, Modifier.FINAL)
.addMethod(MethodSpec.constructorBuilder()
.addParameter(String.class, "handsign")
.addStatement("this.$N = $N", "handsign", "handsign")
.build())
.build();
```
이는 다음 코드를 생성합니다:
```java
public enum Roshambo {
ROCK("fist") {
@Override
public String toString() {
return "avalanche!";
}
},
SCISSORS("peace"),
PAPER("flat");
private final String handsign;
Roshambo(String handsign) {
this.handsign = handsign;
}
}
```
### 익명 내부 클래스 (Anonymous Inner Classes)
이 열거형(enum) 코드에서는 `TypeSpec.anonymousInnerClass()`를 사용했습니다. 익명 내부 클래스는 코드 블록 안에서도 사용할 수 있습니다. 이들은 `$L`로 참조할 수 있는 값들입니다:
```java
TypeSpec comparator = TypeSpec.anonymousClassBuilder("")
.addSuperinterface(ParameterizedTypeName.get(Comparator.class, String.class))
.addMethod(MethodSpec.methodBuilder("compare")
.addAnnotation(Override.class)
.addModifiers(Modifier.PUBLIC)
.addParameter(String.class, "a")
.addParameter(String.class, "b")
.returns(int.class)
.addStatement("return $N.length() - $N.length()", "a", "b")
.build())
.build();
TypeSpec helloWorld = TypeSpec.classBuilder("HelloWorld")
.addMethod(MethodSpec.methodBuilder("sortByLength")
.addParameter(ParameterizedTypeName.get(List.class, String.class), "strings")
.addStatement("$T.sort($N, $L)", Collections.class, "strings", comparator)
.build())
.build();
```
이는 내부에 클래스를 포함하고, 그 클래스 내부에 메서드를 포함하는 메서드를 생성합니다:
```java
void sortByLength(List strings) {
Collections.sort(strings, new Comparator() {
@Override
public int compare(String a, String b) {
return a.length() - b.length();
}
});
}
```
익명 내부 클래스를 정의할 때 특히 까다로운 부분 중 하나는 슈퍼클래스 생성자에 전달하는 인자입니다. 위의 코드에서는 인자가 없을 때 빈 문자열을 전달하고 있습니다:
`TypeSpec.anonymousClassBuilder("")`. 다른 매개변수를 전달하려면 JavaPoet의 코드 블록 구문을 사용하고 콤마로 인자들을 구분하세요.

### 어노테이션 (Annotations)
간단한 어노테이션은 쉽습니다:
```java
MethodSpec toString = MethodSpec.methodBuilder("toString")
.addAnnotation(Override.class)
.returns(String.class)
.addModifiers(Modifier.PUBLIC)
.addStatement("return $S", "Hoverboard")
.build();
```
이는 `@Override` 어노테이션이 포함된 다음 메서드를 생성합니다:
```java
@Override
public String toString() {
return "Hoverboard";
}
```
어노테이션에 속성을 설정하려면 `AnnotationSpec.builder()`를 사용하세요:
```java
MethodSpec logRecord = MethodSpec.methodBuilder("recordEvent")
.addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
.addAnnotation(AnnotationSpec.builder(Headers.class)
.addMember("accept", "$S", "application/json; charset=utf-8")
.addMember("userAgent", "$S", "Square Cash")
.build())
.addParameter(LogRecord.class, "logRecord")
.returns(LogReceipt.class)
.build();
```
이는 `accept`와 `userAgent` 속성을 가진 다음 어노테이션을 생성합니다:
```java
@Headers(
accept = "application/json; charset=utf-8",
userAgent = "Square Cash"
)
LogReceipt recordEvent(LogRecord logRecord);
```
더 복잡한 경우, 어노테이션의 값 자체가 또 다른 어노테이션일 수 있습니다. 내장된 어노테이션에는 `$L`을 사용하세요:
```java
MethodSpec logRecord = MethodSpec.methodBuilder("recordEvent")
.addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
.addAnnotation(AnnotationSpec.builder(HeaderList.class)
.addMember("value", "$L", AnnotationSpec.builder(Header.class)
.addMember("name", "$S", "Accept")
.addMember("value", "$S", "application/json; charset=utf-8")
.build())
.addMember("value", "$L", AnnotationSpec.builder(Header.class)
.addMember("name", "$S", "User-Agent")
.addMember("value", "$S", "Square Cash")
.build())
.build())
.addParameter(LogRecord.class, "logRecord")
.returns(LogReceipt.class)
.build();
```
이는 다음을 생성합니다:
```java
@HeaderList({
@Header(name = "Accept", value = "application/json; charset=utf-8"),
@Header(name = "User-Agent", value = "Square Cash")
})
LogReceipt re

cordEvent(LogRecord logRecord);
```
동일한 속성 이름으로 `addMember()`를 여러 번 호출하여 해당 속성에 대한 값 목록을 채울 수 있습니다.
### Javadoc
필드, 메서드, 타입은 Javadoc을 사용하여 문서화할 수 있습니다:
```java
MethodSpec dismiss = MethodSpec.methodBuilder("dismiss")
.addJavadoc("Hides {@code message} from the caller's history. Other\n"
+ "participants in the conversation will continue to see the\n"
+ "message in their own history unless they also delete it.\n")
.addJavadoc("\n")
.addJavadoc("

Use {@link #delete($T)} to delete the entire\n"
+ "conversation for all participants.\n", Conversation.class)
.addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT)
.addParameter(Message.class, "message")
.build();
```
이 코드는 다음과 같은 결과를 생성합니다:
```java
/\*\*
\* Hides {@code message} from the caller's history. Other
\* participants in the conversation will continue to see the
\* message in their own history unless they also delete it.
\*
\*

Use {@link #delete(Conversation)} to delete the entire
\* conversation for all participants.
\*/
void dismiss(Message message);
```
Javadoc에서 타입을 참조할 때 자동으로 import를 처리하려면 `$T`를 사용하세요.

다운로드
--------
[최신 .jar 파일][dl]을 다운로드하거나 Maven을 통해 의존성을 추가하세요:
```xml
com.squareup
javapoet
1.13.0
```
또는 Gradle을 사용하는 경우:
```groovy
compile 'com.squareup:javapoet:1.13.0'
```
개발 버전의 스냅샷은 [Sonatype의 `snapshots` 저장소][snap]에서 이용할 수 있습니다.

라이선스
-------
Copyright 2015 Square, Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

JavaWriter
==========
JavaPoet은 [JavaWriter][javawriter]의 후속작입니다. 새로운 프로젝트에서는 더 강력한 코드 모델을 제공하는 JavaPoet을 사용하는 것이 좋습니다. JavaPoet은 타입을 이해하고 import를 자동으로 관리할 수 있습니다. 또한 JavaPoet은 컴포지션에 더 적합합니다. `.java` 파일의 내용을 한 번에 위에서 아래로 스트리밍하는 방식 대신, 선언의 트리 형태로 파일을 조립할 수 있습니다.
JavaWriter는 계속해서 [GitHub][javawriter] 및 [Maven Central][javawriter\_maven]에서 이용할 수 있습니다.

[dl]: https://search.maven.org/remote\_content?g=com.squareup&a=javapoet&v=LATEST
[snap]: https://oss.sonatype.org/content/repositories/snapshots/com/squareup/javapoet/
[javadoc]: https://square.github.io/javapoet/1.x/javapoet/
[javawriter]: https://github.com/square/javapoet/tree/javawriter\_2
[javawriter\_maven]: https://search.maven.org/#artifactdetails%7Ccom.squareup%7Cjavawriter%7C2.5.1%7Cjar
[formatter]: https://developer.android.com/reference/java/util/Formatter.html
[modifier]: https://docs.oracle.com/javase/8/docs/api/javax/lang/model/element/Modifier.html