민수's 기술 블로그

Java 21 새로운 기능(2) - preview

AlwaysPr — Mon, 28 Aug 2023 08:00:04 +0900

Java

Java 21 새로운 기능(1) - main에 이어 Preview 인 7개의 feature를 알아보자.

String Templates

String을 간단하게 사용하기 위해 이미 많은 언어에서 String Templates을 사용하고 있다. Stirng Templates은 String을 쉽게 표현해서 Java 코드 작성을 간단하게 한다. 이로 인해 text와 expressions의 가독성이 향상된다.

C#             $"{x} plus {y} equals {x + y}"
Visual Basic   $"{x} plus {y} equals {x + y}"
Python         f"{x} plus {y} equals {x + y}"
Scala          s"$x plus $y equals ${x + y}"
Groovy         "$x plus $y equals ${x + y}"
Kotlin         "$x plus $y equals ${x + y}"
JavaScript     `${x} plus ${y} equals ${x + y}`
Ruby           "#{x} plus #{y} equals #{x + y}"
Swift          "\(x) plus \(y) equals \(x + y)"

예제

String name = "Joan";
String info = STR."My name is \{name}";
assert info.equals("My name is Joan");   // true

\{변수명}으로 사용할 수 있다.

// Embedded expressions can be strings
String firstName = "Bill";
String lastName  = "Duck";
String fullName  = STR."\{firstName} \{lastName}";
| "Bill Duck"
String sortName  = STR."\{lastName}, \{firstName}";
| "Duck, Bill"

// Embedded expressions can perform arithmetic
int x = 10, y = 20;
String s = STR."\{x} + \{y} = \{x + y}";
| "10 + 20 = 30"

// Embedded expressions can invoke methods and access fields
String s = STR."You have a \{getOfferType()} waiting for you!";
| "You have a gift waiting for you!"
String t = STR."Access at \{req.date} \{req.time} from \{req.ipAddress}";
| "Access at 2022-03-25 15:34 from 8.8.8.8"

또한 method 호출과 추가적인 연산도 가능하다.

Unnamed Patterns and Variables

사용하지 않는 변수를 이름 없는 변수로 지정하여 Java 언어를 향상시킨다. 불필요한 Nested patterns을 제거하여 Record patterns의 가독성을 개선한다. 또한 선언해야 하지만 사용되지 않는 변수를 식별하여, 코드의 유지보수성을 개선한다.

예제

// type X
... instanceof Point(int x, _)
case Point(int x, _)


// type 명시
... instanceof Point(int x, int _)
case Point(int x, int _)

// Pattern matching 이외에도 자유롭게 사용
int _ = q.remove();

... } catch (NumberFormatException _) { ...

(int x, int _) -> x + x

Unnamed Classes and Instance Main Methods

자바를 동작시키기 위해서는 클래스와 함께 `public static void main(String[] args)`이라는 긴 구절을 외워서 사용해야 한다. 이것을 이름 없는 클래스와 간단한 main method로 동작가능하게 한다. 학생들이 대규모 프로그램을 위해 설계된 언어 기능을 이해하지 않고도 첫 번째 프로그램을 작성할 수 있도록 한다

예제

//as-is
public class HelloWorld { 
    public static void main(String[] args) { 
        System.out.println("Hello, World!");
    }
}

//to-be
class HelloWorld { 
    void main() { 
        System.out.println("Hello, World!");
    }
}

//unnamed classes
void main() {
    System.out.println("Hello, World!");
}

Scoped Values

Scoped Values을 도입하여 Thread 내 또는 Thread 간에 불변 데이터를 공유할 수 있다. 특히 많은 수의 Virtual Thread를 사용할 때 Thread 지역 변수보다 선호된다.

Thread 지역 변수는 몇 가지 설계적 결함이 있다.

제약 없는 변경 가능성 - 가변객체의 단점
무한한 수명 - remove 메소드를 호출하지 않으면, 계속 살아있고 메모리 누출로 이어질 수 있음
값 비싼 상속비용 - 많은 수의 Thread를 사용할 때 값비싼 비용이 발생

이러한 단점을 Scoped Values가 해소해 주며, 안전하고 효율적인 API이다.

예제

final static ScopedValue<...> V = ScopedValue.newInstance();

// In some method
ScopedValue.where(V, <value>)
           .run(() -> { ... V.get() ... call methods ... });

// In a method called directly or indirectly from the lambda expression
... V.get() ...

코드의 구조는 Thread가 ScopedValue의 값을 읽을 수 있는 기간을 나타낸다. 불변성과 결합된 이 제한된 수명은 Thread 동작에 대한 추론을 크게 단순화한다.

class Server {
    final static ScopedValue<Principal> PRINCIPAL
        = ScopedValue.newInstance();                                  // (1)

    void serve(Request request, Response response) {
        var level     = (request.isAdmin() ? ADMIN : GUEST);
        var principal = new Principal(level);
        ScopedValue.where(PRINCIPAL, principal)                       // (2)
                   .run(() -> Application.handle(request, response));
    }
}

class DBAccess {
    DBConnection open() {
        var principal = Server.PRINCIPAL.get();                       // (3)
        if (!principal.canOpen()) throw new  InvalidPrincipalException();
        return newConnection(...);
    }
}

웹 프레임워크를 예로 보면,

인스턴스화한다.
Value를 ScopedValue에 담는다.
사용한다.

Structured Concurrency

동시성은 서로 다른 Thread에서 실행 중인 관련 작업 그룹을 하나의 작업 단위로 처리하여 오류 처리 및 취소를 간소화하고, 안정성을 개선하며, 통합 가시성을 향상한다. Thread 누수 및 취소 지연과 같이 취소/종료로 인해 발생하는 일반적인 위험을 제거할 수 있는 동시 프로그래밍 스타일을 제공한다.

예제

//as-is
Response handle() throws ExecutionException, InterruptedException {
    Future<String>  user  = esvc.submit(() -> findUser());
    Future<Integer> order = esvc.submit(() -> fetchOrder());
    String theUser  = user.get();   // Join findUser
    int    theOrder = order.get();  // Join fetchOrder
    return new Response(theUser, theOrder);
}

//to-be
Response handle() throws ExecutionException, InterruptedException {
    try (var scope = new StructuredTaskScope.ShutdownOnFailure()) {
        Supplier<String>  user  = scope.fork(() -> findUser());
        Supplier<Integer> order = scope.fork(() -> fetchOrder());

        scope.join()            // Join both subtasks
             .throwIfFailed();  // ... and propagate errors

        // Here, both subtasks have succeeded, so compose their results
        return new Response(user.get(), order.get());
    }
}

Vector API

지원되는 CPU 아키텍처에서 최적의 Vector 명령어로 런타임에 안정적으로 컴파일되어 동등한 스칼라 계산보다 뛰어난 성능을 달성하는 벡터 계산을 표현하는 API를 도입한다.

예제

//as-is
void scalarComputation(float[] a, float[] b, float[] c) {
   for (int i = 0; i < a.length; i++) {
        c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f;
   }
}


//to-be
static final VectorSpecies<Float> SPECIES = FloatVector.SPECIES_PREFERRED;

void vectorComputation(float[] a, float[] b, float[] c) {
    int i = 0;
    int upperBound = SPECIES.loopBound(a.length);
    for (; i < upperBound; i += SPECIES.length()) {
        // FloatVector va, vb, vc;
        var va = FloatVector.fromArray(SPECIES, a, i);
        var vb = FloatVector.fromArray(SPECIES, b, i);
        var vc = va.mul(va)
                   .add(vb.mul(vb))
                   .neg();
        vc.intoArray(c, i);
    }
    for (; i < a.length; i++) {
        c[i] = (a[i] * a[i] + b[i] * b[i]) * -1.0f;
    }
}

VetorSpecies를 정적 final 필드에 저장하여 사용하면 런타임 컴파일러가 값을 상수로 취급하여 벡터 계산을 더 잘 최적화할 수 있다.

Foreign Function & Memory API

Java 프로그램이 Java 런타임 외부의 코드 및 데이터와 상호 운용할 수 있는 API이 다. 이 API는 외부 함수(즉, JVM 외부의 코드)를 효율적으로 호출하고 외부 메모리(즉, JVM에서 관리하지 않는 메모리)에 안전하게 액세스함으로써 Java 프로그램이 JNI의 취약성과 위험 없이 네이티브 라이브러리를 호출하고 네이티브 데이터를 처리할 수 있게 해 준다. 해당 API는 java.lang.foreign 패키지에 존재한다.

예제

// Foreign memory access
 MemorySegment segment = Arena.ofAuto().allocate(10 * 4, 1);
 for (int i = 0 ; i < 10 ; i++) {
     segment.setAtIndex(ValueLayout.JAVA_INT, i, i);
 }

// Deterministic deallocationCopy URL
try (Arena arena = Arena.ofConfined()) {
    MemorySegment segment = arena.allocate(10 * 4);
    for (int i = 0 ; i < 10 ; i++) {
        segment.setAtIndex(ValueLayout.JAVA_INT, i, i);
    }
}

// Foreign function access
Linker linker = Linker.nativeLinker();
SymbolLookup stdlib = linker.defaultLookup();
MethodHandle strlen = linker.downcallHandle(
    stdlib.find("strlen").get(),
    FunctionDescriptor.of(ValueLayout.JAVA_LONG, ValueLayout.ADDRESS)
);

try (Arena arena = Arena.ofConfined()) {
    MemorySegment cString = arena.allocateUtf8String("Hello");
    long len = (long)strlen.invoke(cString); // 5
}

Java 21 새로운 기능(1) - main

AlwaysPr — Sun, 13 Aug 2023 12:53:37 +0900

Java

2023.09.19에 LTS 버전인 Java 21이 출시될 예정이다. Preview를 포함해서 총 15개의 feature가 포함된다.

이번 시간에는 정식 릴리즈된 feature들을 살펴보고, 다음 시간엔 Preview를 살펴보도록 하자.

Virtual Threads

Virtual Threads는 높은 처리량의 동시 애플리케이션을 작성, 유지 관리, 모니터링하는데 드는 비용을 획기적으로 줄여주는 경량 스레드이다. Thread Per Reuqest 스타일로 작성된 서버 애플리케이션을 최적의 하드웨어로 확장할 수 있다. 또한 `java.lang.Thread API`를 사용하는 기존 코드를 최소한의 변경으로 가상 스레드를 사용할 수 있게 하위호환성을 잘 유지한다.

예제

// 기본 Thread
new Thread(()  -> System.out.println("Hello World")).start();

// Virtual Thread
Thread.startVirtualThread(() -> System.out.println("Hello World")).start();

위처럼 간단하게 Virtual Thread를 사용할 수 있다.

try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
    IntStream.range(0, 10_000).forEach(i -> {
        executor.submit(() -> {
            Thread.sleep(Duration.ofSeconds(1));
            return i;
        });
    });
}  // executor.close() is called implicitly, and waits

위 코드는 Virtual Thread를 통해서 10,000 번 1초 sleep을 하는 코드이다. 기존의 Thread와는 다르게 소수의 OS Thread를 사용해서 처리할 수 있다. JEP에서는 아마 1개의 OS Thread만을 사용해서 처리할 수 있을 거라고 한다. 만약 Executors.newCachedThreadPool()`를 사용했다면 10,000개의 OS Thread를 생성하려 시도하면서 문제가 생겼을 수도 있다.

Virtual Thread는 일반적인 서버 애플리케이션의 처리량을 개선하는데 도움이 된다. 왜냐하면 대부분의 어플리케이션이 DB, API, Network 호출처럼 Block 된 채 기다리고 있는 작업이 많기 때문이다.

Pattern Matching for switch

switch 문 및 expression에 대한 Pattern Matching으로 Java 프로그래밍 언어를 개선한다. Pattern Matching을 switch로 확장하면 각각 특정 동작이 있는 여러 패턴에 대해 expression을 테스트할 수 있으므로 복잡한 데이터 지향 쿼리를 간결하고 안전하게 표현할 수 있다. case label에 패턴 매칭을 사용하여 switch 문 및 statement의 표현력과 적용성을 확장할 수 있다. 그리고 기존과 다른 점은 case 문에 null을 허용한다.

예제

// Prior to Java 16
if (obj instanceof String) {
    String s = (String)obj;
    ... use s ...
}

// As of Java 16
if (obj instanceof String s) {
    ... use s ...
}

위는 Java 16 전후의 feature이며, Pattern matching 하여 s를 변수로 곧바로 사용할 수 있다.

// Prior to Java 21
static String formatter(Object obj) {
    String formatted = "unknown";
    if (obj instanceof Integer i) {
        formatted = String.format("int %d", i);
    } else if (obj instanceof Long l) {
        formatted = String.format("long %d", l);
    } else if (obj instanceof Double d) {
        formatted = String.format("double %f", d);
    } else if (obj instanceof String s) {
        formatted = String.format("String %s", s);
    }
    return formatted;
}

// As of Java 21
static String formatterPatternSwitch(Object obj) {
    return switch (obj) {
        case Integer i -> String.format("int %d", i);
        case Long l    -> String.format("long %d", l);
        case Double d  -> String.format("double %f", d);
        case String s  -> String.format("String %s", s);
        default        -> obj.toString();
    };
}

Pattern matching + switch 문을 활용하여 코드를 간결하고 안전하게 표현한다.

// Prior to Java 21
static void testFooBarOld(String s) {
    if (s == null) {
        System.out.println("Oops!");
        return;
    }
    switch (s) {
        case "Foo", "Bar" -> System.out.println("Great");
        default           -> System.out.println("Ok");
    }
}

// As of Java 21
static void testFooBarNew(String s) {
    switch (s) {
        case null         -> System.out.println("Oops");
        case "Foo", "Bar" -> System.out.println("Great");
        default           -> System.out.println("Ok");
    }
}

null을 별도로 처리하지않고, case를 통해 활용할 수 있다.

// As of Java 21
static void testStringOld(String response) {
    switch (response) {
        case null -> { }
        case String s -> {
            if (s.equalsIgnoreCase("YES"))
                System.out.println("You got it");
            else if (s.equalsIgnoreCase("NO"))
                System.out.println("Shame");
            else
                System.out.println("Sorry?");
        }
    }
}

// As of Java 21
static void testStringNew(String response) {
    switch (response) {
        case null -> { }
        case String s
        when s.equalsIgnoreCase("YES") -> {
            System.out.println("You got it");
        }
        case String s
        when s.equalsIgnoreCase("NO") -> {
            System.out.println("Shame");
        }
        case String s -> {
            System.out.println("Sorry?");
        }
    }
}

`when` 키워드를 사용하여 Pattern에 대한 세분화된 표현할 수 있다.

Record Patterns

Record Patterns을 사용하여 Record 값을 분해해 Java 프로그래밍 언어를 향상하며, Record Patterns 및 Type Patterns을 활용하여 강력하고 선언적이며 구성 가능한 형식의 데이터 탐색과 처리를 제공한다. Record Class의 인스턴스를 분해하여 Pattern matching을 확장해 보다 정교한 데이터 쿼리로 활용할 수 있고, 더 나아가 중첩된 패턴을 사용하여 보다 세밀하게 데이터 쿼리로 활용할 수 있다.

예제

record Point(int x, int y) {}

// As of Java 16
static void printSum(Object obj) {
    if (obj instanceof Point p) {
        int x = p.x();
        int y = p.y();
        System.out.println(x+y);
    }
}

// As of Java 21
static void printSum(Object obj) {
    if (obj instanceof Point(int x, int y)) {
        System.out.println(x+y);
    }
}

Java 21에서는 Pattern matching 후 Record의 필드를 간단하게 다룰 수 있다.
코드가 간결해지고, 명시적인걸 알 수 있다.

record Point(int x, int y) {}

enum Color { RED, GREEN, BLUE }

record ColoredPoint(Point p, Color c) {}

record Rectangle(ColoredPoint upperLeft, ColoredPoint lowerRight) {}

위 클래스를 가지고 아래를 설명한다.

// As of Java 21
static void printUpperLeftColoredPoint(Rectangle r) {
    if (r instanceof Rectangle(ColoredPoint ul, ColoredPoint lr)) {
         System.out.println(ul.c());
    }
}

첫 번째 예제와 동일한 방식이다.

// As of Java 21
static void printColorOfUpperLeftPoint(Rectangle r) {
    if (r instanceof Rectangle(ColoredPoint(Point p, Color c), ColoredPoint lr)) {
        System.out.println(c);
    }
}

Patterns matching 후 첫번째 `ColoredPoint`를 보면 `Point`를 인자로 가지고 있는 것을 알 수 있다. 이처럼 Record patterns 안에 다른 Patterns을 중첩하여 외부 Record와 내부 Record를 한 번에 분해할 수 있다.

Rectangle r = new Rectangle(new ColoredPoint(new Point(x1, y1), c1), new ColoredPoint(new Point(x2, y2), c2));

static void printXCoordOfUpperLeftPointWithPatterns(Rectangle r) {
    if (r instanceof Rectangle(ColoredPoint(Point(var x, var y), var c), var lr)) {
        System.out.println("Upper-left corner: " + x);
    }
}

중첩된 패턴을 사용하면 중첩된 생성자의 구조를 반영하는 코드로 위처럼 분해하여 제공할 수 있으며, `var` 키워드 또한 사용할 수 있다.

// As of Java 21
record Pair(Object x, Object y) {}

Pair p = new Pair(42, 42);

if (p instanceof Pair(String s, String t)) {
    System.out.println(s + ", " + t);
} else {
    System.out.println("Not a pair of strings");
}

중첩 패턴은 당연히 타입이 일치하지 않을 수 있으며 위처럼 else 문을 통하여 제어가 가능하다.

Sequenced Collections

순서를 가진 Collection을 표현하는 새로운 인터페이스이다. 첫 번째 요소와 마지막 요소에 접근하고 해당 요소를 역순으로 처리하기 위한 일관된 API를 제공한다.

interface SequencedCollection<E> extends Collection<E> {
    // new method
    SequencedCollection<E> reversed();
    // methods promoted from Deque
    void addFirst(E);
    void addLast(E);
    E getFirst();
    E getLast();
    E removeFirst();
    E removeLast();
}

sequenceCollection

Generational ZGC

Z Garbage Collector(ZGC)를 확장하여 young and old object의 세대를 분리하여 유지함으로써 애플리케이션 성능을 개선한다. 이렇게 하면 ZGC가 대체로 빨리 죽는 young object를 더 자주 수집할 수 있다.

예제

$ java -XX:+UseZGC -XX:+ZGenerational ...

Key Encapsulation Mechanism API

공개 키 암호화를 사용하여 대칭 키를 보호하는 암호화 기술인 Key Encapsulation Mechanism(KEM)을 위한 API이다.
Java의 기존 암호화 API 중 어떤 것도 KEM을 자연스럽게 표현할 수 없었고, 타사 보안 제공업체에서 이미 표준 KEM API에 대한 필요성을 증명해 왔기에 KEM 클래스 구현이 필요했다. 또한 KEM은 양자 공격을 방어하는 데 중요한 도구가 될 걸로 보인다.

public final class KEM {

    public static KEM getInstance(String alg)
        throws NoSuchAlgorithmException;
    public static KEM getInstance(String alg, Provider p)
        throws NoSuchAlgorithmException;
    public static KEM getInstance(String alg, String p)
        throws NoSuchAlgorithmException, NoSuchProviderException;

    public static final class Encapsulated {
        public Encapsulated(SecretKey key, byte[] encapsulation, byte[] params);
        public SecretKey key();
        public byte[] encapsulation();
        public byte[] params();
    }

    public static final class Encapsulator {
        String providerName();
        int secretSize();           // Size of the shared secret
        int encapsulationSize();    // Size of the key encapsulation message
        Encapsulated encapsulate();
        Encapsulated encapsulate(int from, int to, String algorithm);
    }

    public Encapsulator newEncapsulator(PublicKey pk)
            throws InvalidKeyException;
    public Encapsulator newEncapsulator(PublicKey pk, SecureRandom sr)
            throws InvalidKeyException;
    public Encapsulator newEncapsulator(PublicKey pk, AlgorithmParameterSpec spec,
                                        SecureRandom sr)
            throws InvalidAlgorithmParameterException, InvalidKeyException;

    public static final class Decapsulator {
        String providerName();
        int secretSize();           // Size of the shared secret
        int encapsulationSize();    // Size of the key encapsulation message
        SecretKey decapsulate(byte[] encapsulation) throws DecapsulateException;
        SecretKey decapsulate(byte[] encapsulation, int from, int to,
                              String algorithm)
                throws DecapsulateException;
    }

    public Decapsulator newDecapsulator(PrivateKey sk)
            throws InvalidKeyException;
    public Decapsulator newDecapsulator(PrivateKey sk, AlgorithmParameterSpec spec)
            throws InvalidAlgorithmParameterException, InvalidKeyException;

}

Deprecate the Windows 32-bit x86 Port for Removal

향후 Release에서 제거를 목적으로 Windows 32비트 x86 포트가 deprecate 된다.

Prepare to Disallow the Dynamic Loading of Agents

Agent가 실행 중인 JVM에 동적으로 로드될 때 경고를 발생시킨다. 이러한 경고는 기본적으로 무결성을 개선하기 위해 기본적으로 Agent의 동적 로드를 허용하지 않는 향후 릴리스에 대해 사용자를 준비시키는 것을 목표로 한다. startup 시 agent를 로드하는 Serviceability tools은 모든 릴리스에서 경고를 발행하지 않는다.

Java 21 새로운 기능(2) - preview

Java 21 new feature (1) - main에 이어 Preview 인 7개의 feature를 알아보자. String Templates String을 간단하게 사용하기 위해 이미 많은 언어에서 String Templates을 사용하고 있다. C# $"{x} plus {y} equals {x + y}" Visual B

alwayspr.tistory.com

Web applications and Project Loom (번역)

AlwaysPr — Sun, 12 Mar 2023 21:52:38 +0900

Web applications and Project Loom를 번역한 글입니다.

소개

Project Loom은 "간편한 사용성(easy-to-use), 높은 처리량(high-throughput), 가벼운 동시성(lightweight concurrency)"을 JRE에 제공하는 것을 목표로 합니다. Project Loom이 도입한 기능 중 하나는 Virtual thread입니다. 이 블로그 게시물에서는 Apache Tomcat에서 배포한 몇 가지 간단한 웹 애플리케이션을 사용하여 Virtual thread가 웹 애플리케이션에 어떤 의미를 주는지 살펴보겠습니다.

높은 처리량 / 경량화

첫 번째 실험은 Tomcat 표준 Thread pool 사용에 따른 overhaed와 Virtual thread(Loom) 사용에 따른 overhead를 비교합니다. 테스트에 사용된 환경은 이 게시물의 마지막에 자세히 설명되어 있습니다. 다양한 크기의 응답과 동시성 요청에 대한 RPS(초당 평균 요청) 성능을 실험했습니다. 결과는 다음 그래프와 같습니다.

요청을 처리하기 위해 새로운 Virtual thread를 생성하는 overhead가 Thread pool에서 Platform thread를 가져오는 overhead보다 낮다는 결과를 보여줍니다.

Thread pool 테스트에서 예상치 못한 결과는 응답 body의 크기가 작고 동시 사용자가 2명일 때가 한 명의 동시 사용자보다 RPS 수가 더 낮다는 점입니다. 확인 결과, Executor에게 전달되는 task과 task의 run() 메서드를 호출하는 Executor 사이에 추가 지연이 발생하는 것으로 확인되었습니다. 동시 사용자가 4명일 때는 이 차이가 줄어들었고, 8명일 때는 거의 사라졌습니다.

사용 가능한 프로세서 코어수보다 더 많은 동시 작업이 있을 때 높은 수준의 동시성에서 Vircual thread Executor의 성능이 다시 향상되는 것으로 나타났습니다. 이는 더 작은 응답 body를 사용한 테스트에서 더욱 두드러졌습니다.

간편한 사용성

두 번째 실험에서는 표준 Thread pool과 함께 Servlet 비동기 I/O를 사용하여 얻은 성능과 Virtual Thread 기반 Executor와 함께 간단한 블로킹 I/O를 사용하여 얻은 성능을 비교했습니다. 여기서 Vircual Thread의 잠재적 이점은 단순성(simplicity)입니다. 블로킹 읽기 / 쓰기는 특히 오류 처리를 고려할 때 같은 조건의 Servlet 비동기 읽기 / 쓰기보다 훨씬 더 간단합니다.

Servlet 비동기 I/O는 응답에 지연이 있는 외부 서비스에 접근하는 데 자주 사용됩니다. 테스트 웹 애플리케이션은 Service 클래스에서 이를 시뮬레이션했습니다. Virtual Thread 기반 Executor와 함께 사용된 Servlet은 블로킹 스타일로 서비스에 액세스 한 반면, 표준 Thread pool과 함께 사용된 Servlet은 Servlet 비동기 API를 사용하여 서비스에 액세스 했습니다. 네트워크 I/O는 포함되지 않았지만 결과에 영향을 미치지는 않았을 것입니다.

초기 테스트에서는 당연히 블로킹 방식과 비동기 방식 간에 측정 가능한 차이가 없었는데, 5초 지연이 대부분을 시간을 차지했기 때문입니다. 지연의 영향이 없는 차이를 살펴보기 위해 지연을 0으로 줄이고 처리량 테스트와 유사한 테스트 세트를 실행했습니다. 결과는 다음 그래프에 나와 있습니다.

다시 우리는 Virtual Thread가 일반적으로 성능이 더 뛰어나다는 것을 알 수 있습니다. 그 차이는 동시성이 낮을 때와 테스트에 사용 가능한 프로세서 코어 수를 초과하는 동시성이 요구될 때 가장 두드러집니다.

분석

Virtual Thread 기반 Executor와 Tomcat 표준 Thread pool의 차이는 위의 그래프에서 보이는 것만큼 뚜렷하지 않습니다. 이 테스트는 각 접근 방식과 관련된 overhead를 측정하기 위해 설계되었으며, 실제 애플리케이션을 대표하지 않습니다. 실제 애플리케이션에서 테스트에 나타난 차이는 요청을 완료하는 데 걸리는 시간과 비교할 때 무시해도 될 정도입니다.

Tomcat 표준 Thread pool과 Virtual Thread 기반 Executor 간 성능 차이의 주요 원인은 Thread pool 사용 시 Queue에서 task를 추가하고 제거할 때 발생하는 경합입니다. 그리고 이는 Tomcat의 구현을 최적화함으로써 Thread pool queue의 경합을 줄여 처리량을 개선할 수 있어보입니다.

상대적 성능에 영향을 미치는 두 번째 요소는 Context switching입니다. Virtual thread의 Context switching 비용이 표준 Thread pool의 Thread보다 저렴합니다. 그래서 사용 가능한 프로세서 코어 수 이상이 요구되는 동시성이 두 번째 실험에서 나타난 성능 차이를 설명할 수 있는 원인일 수 있습니다.

결론

Virtual thread 기반 Executor를 사용하는 것은 Tomcat 표준 Thread pool에 대한 실행 가능한 대안입니다. Virtual thread로 전환하면 컨테이너 overhead 측면에서 얻을 수 있는 이점은 미미합니다.

Servlet 비동기 API, 리액티브 프로그래밍, 기타 비동기 API로 전환하지 않은 웹 애플리케이션인 클래식 Spring MVC와 같은 블로킹 기반의 웹 어플리케이션은 Virtual Thread 기반 Exctuor로 전환하면 확장성(scalability)이 약간 개선될 수 있습니다. 웹 애플리케이션에 따라 웹 애플리케이션 코드의 큰 변경 없이 이러한 개선 사항을 달성할 수 있습니다.

Servlet 비동기 API, 리액티브 프로그래밍, 기타 비동기 API를 사용하도록 전환한 웹 애플리케이션은 Virtual Thread 기반 Executor로 전환해도 유의미한 차이(긍정적이든 부정적이든)를 얻지 못할 가능성이 높습니다.

장기적으로 볼 때 Virtual Thread의 가장 큰 장점은 애플리케이션 코드의 간소화입니다. 현재 Servlet 비동기 API, 리액티브 프로그래밍, 기타 비동기 API를 사용해야 하는 일부 사용 사례는 블로킹 I/O와 Virtual Thread를 사용하여 충족할 수 있을 것입니다. 여기서 주의할 점은 애플리케이션이 다른 외부 서비스를 여러 번 호출해야 하는 경우가 많다는 것입니다. 이 작업은 병렬로 수행하는 것이 가장 효율적이며 Project Reactor와 같은 프레임워크가 이를 최고 수준으로 지원하지만, 이에 상응하는 JRE의 솔루션(구조적 동시성)은 아직 incubator 단계에 있으며 여러 future를 조정하는 것을 목표로 할 뿐 가장 편리한 방식으로 서로를 기준으로 선언하거나 구성하는 것은 아닙니다.

마지막으로, Project Loom은 아직 preview 모드에 있습니다. 프로덕션 환경에서 Virtual Thread 사용을 고려하기에는 아직 이르지만, 지금이 바로 Project Loom과 Virtual Thread 사용 계획을 세워 JRE에서 Virtual Thread를 일반적으로 사용할 수 있게 될 때를 대비해야 합니다.

테스트 환경

테스트 환경은 다음과 같이 구성되었습니다.

Apache Tomcat 11.0.0-M1
The Loom executor from Tomcat's Loom module
OpenJDK 21, early access, build 1
wrk 4.2.0 (built from source)

테스트는 Intel i7-6950X processor, 32GB RAM 최신버전의 Ubuntu 22.04.1 LTS 머신에서 수행되었습니다.

테스트 간의 차이점을 극대화하고, 일반적인 overhead를 최소화하기 위해 기본 설정에서 다음의 구성들을 변경했습니다.

loopback 인터페이스를 사용하며, 하나의 머신에서 테스트를 실행하여 네트워크 overhead를 최소화합니다.
요청량이 많을 때 상당한 Disk I/O의 원인이 되는 액세스 로그를 비활성화합니다.
maxKeepAliveRequests을 -1로 설정하여 TCP 연결 설정 / 해지에 소요되는 시간을 줄입니다.

또한 테스트 웹 애플리케이션은 일반적인 overhead를 최소화하고, 테스트 간의 차이점을 강조하도록 설계되었습니다.

사용된 server.xml 파일은 다음과 같습니다.

<?xml version="1.0" encoding="UTF-8"?>
<Server port="8005" shutdown="SHUTDOWN">
  <Listener className="org.apache.catalina.startup.VersionLoggerListener" />

  <Service name="Catalina">

    <Executor
        className="org.apache.catalina.core.LoomExecutor"
        name="loomExecutor"
        />

    <Connector 
        protocol="org.apache.coyote.http11.Http11NioProtocol"
        port="8080"
        maxKeepAliveRequests="-1"
        />

    <Connector
        executor="loomExecutor"
        protocol="org.apache.coyote.http11.Http11NioProtocol"
        port="8081"
        maxKeepAliveRequests="-1"
        />

    <Engine name="Catalina" defaultHost="localhost">
      <Host name="localhost"  appBase="webapps"
            unpackWARs="true" autoDeploy="true">
      </Host>
    </Engine>
  </Service>
</Server>

사용된 setenv.sh 파일은 다음과 같습니다.

JAVA_OPTS=--enable-preview

lombok.config 옵션

AlwaysPr — Sun, 5 Mar 2023 19:01:39 +0900

lombok.config에서 사용할 수 있는 옵션은 lombok jar를 다운로드한 다음 아래 명령어를 작성하면 얻을 수 있다. ~~문서에 있을 법한데...~~

java -jar lombok.jar config -g --verbose

그러나 직접 jar를 다운로드하고, 위의 명령어까지 치기에는 번거롭기에 정리해보려 한다.

v1.18.26, v1.18.24

위 두 버전은 변경 사항이 없다.

##
## Key : checkerframework
## Type: checkerframework-version
##
## If set with the version of checkerframework.org (in major.minor, or just 'true' for the latest supported version), create relevant checkerframework.org annotations for code lombok generates (default: false).
##
## Examples:
#
# clear checkerframework
# checkerframework = major.minor (example: 3.2 - and no higher than 4.0) or true or false
#

##
## Key : config.stopBubbling
## Type: boolean
##
## Tell the configuration system it should stop looking for other configuration files (default: false).
##
## Examples:
#
# clear config.stopBubbling
# config.stopBubbling = [false | true]
#

##
## Key : lombok.accessors.capitalization
## Type: enum (lombok.core.configuration.CapitalizationStrategy)
##
## Which capitalization strategy to use when converting field names to accessor names and vice versa (default: basic).
##
## Examples:
#
# clear lombok.accessors.capitalization
# lombok.accessors.capitalization = [BASIC | BEANSPEC]
#

##
## Key : lombok.accessors.chain
## Type: boolean
##
## Generate setters that return 'this' instead of 'void' (default: false).
##
## Examples:
#
# clear lombok.accessors.chain
# lombok.accessors.chain = [false | true]
#

##
## Key : lombok.accessors.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Accessors is used.
##
## Examples:
#
# clear lombok.accessors.flagUsage
# lombok.accessors.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.accessors.fluent
## Type: boolean
##
## Generate getters and setters using only the field name (no get/set prefix) (default: false).
##
## Examples:
#
# clear lombok.accessors.fluent
# lombok.accessors.fluent = [false | true]
#

##
## Key : lombok.accessors.makeFinal
## Type: boolean
##
## Generate getters, setters and with-ers with the 'final' modifier (default: false).
##
## Examples:
#
# clear lombok.accessors.makeFinal
# lombok.accessors.makeFinal = [false | true]
#

##
## Key : lombok.accessors.prefix
## Type: list of string
##
## Strip this field prefix, like 'f' or 'm_', from the names of generated getters, setters, and with-ers.
##
## Examples:
#
# clear lombok.accessors.prefix
# lombok.accessors.prefix += <text>
# lombok.accessors.prefix -= <text>
#

##
## Key : lombok.addGeneratedAnnotation
## Type: boolean
##
## Generate @javax.annotation.Generated on all generated code (default: false). Deprecated, use 'lombok.addJavaxGeneratedAnnotation' instead.
##
## Examples:
#
# clear lombok.addGeneratedAnnotation
# lombok.addGeneratedAnnotation = [false | true]
#

##
## Key : lombok.addJavaxGeneratedAnnotation
## Type: boolean
##
## Generate @javax.annotation.Generated on all generated code (default: follow lombok.addGeneratedAnnotation).
##
## Examples:
#
# clear lombok.addJavaxGeneratedAnnotation
# lombok.addJavaxGeneratedAnnotation = [false | true]
#

##
## Key : lombok.addLombokGeneratedAnnotation
## Type: boolean
##
## Generate @lombok.Generated on all generated code (default: false).
##
## Examples:
#
# clear lombok.addLombokGeneratedAnnotation
# lombok.addLombokGeneratedAnnotation = [false | true]
#

##
## Key : lombok.addNullAnnotations
## Type: nullity-annotation-library
##
## Generate some style of null annotation for generated code where this is relevant. (default: none).
##
## Examples:
#
# clear lombok.addNullAnnotations
# lombok.addNullAnnotations = none | javax | eclipse | jetbrains | netbeans | androidx | android.support | checkerframework | findbugs | spring | jml | CUSTOM:com.foo.my.nonnull.annotation:com.foo.my.nullable.annotation
#

##
## Key : lombok.addSuppressWarnings
## Type: boolean
##
## Generate @java.lang.SuppressWarnings("all") on all generated code (default: true).
##
## Examples:
#
# clear lombok.addSuppressWarnings
# lombok.addSuppressWarnings = [false | true]
#

##
## Key : lombok.allArgsConstructor.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @AllArgsConstructor is used.
##
## Examples:
#
# clear lombok.allArgsConstructor.flagUsage
# lombok.allArgsConstructor.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.anyConstructor.addConstructorProperties
## Type: boolean
##
## Generate @ConstructorProperties for generated constructors (default: false).
##
## Examples:
#
# clear lombok.anyConstructor.addConstructorProperties
# lombok.anyConstructor.addConstructorProperties = [false | true]
#

##
## Key : lombok.anyConstructor.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if any of the XxxArgsConstructor annotations are used.
##
## Examples:
#
# clear lombok.anyConstructor.flagUsage
# lombok.anyConstructor.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.anyConstructor.suppressConstructorProperties
## Type: boolean
##
## Suppress the generation of @ConstructorProperties for generated constructors (default: false).
##
## Examples:
#
# clear lombok.anyConstructor.suppressConstructorProperties
# lombok.anyConstructor.suppressConstructorProperties = [false | true]
#

##
## Key : lombok.builder.className
## Type: string
##
## Default name of the generated builder class. A * is replaced with the name of the relevant type (default = *Builder).
##
## Examples:
#
# clear lombok.builder.className
# lombok.builder.className = <text>
#

##
## Key : lombok.builder.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Builder is used.
##
## Examples:
#
# clear lombok.builder.flagUsage
# lombok.builder.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.cleanup.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Cleanup is used.
##
## Examples:
#
# clear lombok.cleanup.flagUsage
# lombok.cleanup.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.copyableAnnotations
## Type: list of type-name
##
## Copy these annotations to getters, setters, with methods, builder-setters, etc.
##
## Examples:
#
# clear lombok.copyableAnnotations
# lombok.copyableAnnotations += <fully.qualified.Type>
# lombok.copyableAnnotations -= <fully.qualified.Type>
#

##
## Key : lombok.data.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Data is used.
##
## Examples:
#
# clear lombok.data.flagUsage
# lombok.data.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.delegate.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Delegate is used.
##
## Examples:
#
# clear lombok.delegate.flagUsage
# lombok.delegate.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.equalsAndHashCode.callSuper
## Type: enum (lombok.core.configuration.CallSuperType)
##
## When generating equals and hashCode for classes that extend something (other than Object), either automatically take into account superclass implementation (call), or don't (skip), or warn and don't (warn). (default = warn).
##
## Examples:
#
# clear lombok.equalsAndHashCode.callSuper
# lombok.equalsAndHashCode.callSuper = [CALL | SKIP | WARN]
#

##
## Key : lombok.equalsAndHashCode.doNotUseGetters
## Type: boolean
##
## Don't call the getters but use the fields directly in the generated equals and hashCode method (default = false).
##
## Examples:
#
# clear lombok.equalsAndHashCode.doNotUseGetters
# lombok.equalsAndHashCode.doNotUseGetters = [false | true]
#

##
## Key : lombok.equalsAndHashCode.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @EqualsAndHashCode is used.
##
## Examples:
#
# clear lombok.equalsAndHashCode.flagUsage
# lombok.equalsAndHashCode.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.experimental.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if an experimental feature is used.
##
## Examples:
#
# clear lombok.experimental.flagUsage
# lombok.experimental.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.extensionMethod.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @ExtensionMethod is used.
##
## Examples:
#
# clear lombok.extensionMethod.flagUsage
# lombok.extensionMethod.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.extern.findbugs.addSuppressFBWarnings
## Type: boolean
##
## Generate @edu.umd.cs.findbugs.annotations.SuppressFBWarnings on all generated code (default: false).
##
## Examples:
#
# clear lombok.extern.findbugs.addSuppressFBWarnings
# lombok.extern.findbugs.addSuppressFBWarnings = [false | true]
#

##
## Key : lombok.fieldDefaults.defaultFinal
## Type: boolean
##
## If true, fields, in any file (lombok annotated or not) are marked as final. Use @NonFinal to override this.
##
## Examples:
#
# clear lombok.fieldDefaults.defaultFinal
# lombok.fieldDefaults.defaultFinal = [false | true]
#

##
## Key : lombok.fieldDefaults.defaultPrivate
## Type: boolean
##
## If true, fields without any access modifier, in any file (lombok annotated or not) are marked as private. Use @PackagePrivate or an explicit modifier to override this.
##
## Examples:
#
# clear lombok.fieldDefaults.defaultPrivate
# lombok.fieldDefaults.defaultPrivate = [false | true]
#

##
## Key : lombok.fieldDefaults.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @FieldDefaults is used.
##
## Examples:
#
# clear lombok.fieldDefaults.flagUsage
# lombok.fieldDefaults.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.fieldNameConstants.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @FieldNameConstants is used.
##
## Examples:
#
# clear lombok.fieldNameConstants.flagUsage
# lombok.fieldNameConstants.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.fieldNameConstants.innerTypeName
## Type: identifier-name
##
## The default name of the inner type generated by @FieldNameConstants. (default: 'Fields').
##
## Examples:
#
# clear lombok.fieldNameConstants.innerTypeName
# lombok.fieldNameConstants.innerTypeName = <javaIdentifier>
#

##
## Key : lombok.fieldNameConstants.uppercase
## Type: boolean
##
## The default name of the constants inside the inner type generated by @FieldNameConstants follow the variable name precisely. If this config key is true, lombok will uppercase them as best it can. (default: false).
##
## Examples:
#
# clear lombok.fieldNameConstants.uppercase
# lombok.fieldNameConstants.uppercase = [false | true]
#

##
## Key : lombok.getter.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Getter is used.
##
## Examples:
#
# clear lombok.getter.flagUsage
# lombok.getter.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.getter.lazy.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Getter(lazy=true) is used.
##
## Examples:
#
# clear lombok.getter.lazy.flagUsage
# lombok.getter.lazy.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.getter.noIsPrefix
## Type: boolean
##
## If true, generate and use getFieldName() for boolean getters instead of isFieldName().
##
## Examples:
#
# clear lombok.getter.noIsPrefix
# lombok.getter.noIsPrefix = [false | true]
#

##
## Key : lombok.helper.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Helper is used.
##
## Examples:
#
# clear lombok.helper.flagUsage
# lombok.helper.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.jacksonized.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Jacksonized is used.
##
## Examples:
#
# clear lombok.jacksonized.flagUsage
# lombok.jacksonized.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.apacheCommons.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @CommonsLog is used.
##
## Examples:
#
# clear lombok.log.apacheCommons.flagUsage
# lombok.log.apacheCommons.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.custom.declaration
## Type: custom-log-declaration
##
## Define the generated custom logger field.
##
## Examples:
#
# clear lombok.log.custom.declaration
# lombok.log.custom.declaration = my.cool.Logger my.cool.LoggerFactory.createLogger()(TOPIC,TYPE)
#

##
## Key : lombok.log.custom.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @CustomLog is used.
##
## Examples:
#
# clear lombok.log.custom.flagUsage
# lombok.log.custom.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.fieldIsStatic
## Type: boolean
##
## Make the generated logger fields static (default: true).
##
## Examples:
#
# clear lombok.log.fieldIsStatic
# lombok.log.fieldIsStatic = [false | true]
#

##
## Key : lombok.log.fieldName
## Type: identifier-name
##
## Use this name for the generated logger fields (default: 'log').
##
## Examples:
#
# clear lombok.log.fieldName
# lombok.log.fieldName = <javaIdentifier>
#

##
## Key : lombok.log.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if any of the log annotations is used.
##
## Examples:
#
# clear lombok.log.flagUsage
# lombok.log.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.flogger.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Flogger is used.
##
## Examples:
#
# clear lombok.log.flogger.flagUsage
# lombok.log.flogger.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.javaUtilLogging.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Log is used.
##
## Examples:
#
# clear lombok.log.javaUtilLogging.flagUsage
# lombok.log.javaUtilLogging.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.jbosslog.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @JBossLog is used.
##
## Examples:
#
# clear lombok.log.jbosslog.flagUsage
# lombok.log.jbosslog.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.log4j.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Log4j is used.
##
## Examples:
#
# clear lombok.log.log4j.flagUsage
# lombok.log.log4j.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.log4j2.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Log4j2 is used.
##
## Examples:
#
# clear lombok.log.log4j2.flagUsage
# lombok.log.log4j2.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.slf4j.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Slf4j is used.
##
## Examples:
#
# clear lombok.log.slf4j.flagUsage
# lombok.log.slf4j.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.xslf4j.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @XSlf4j is used.
##
## Examples:
#
# clear lombok.log.xslf4j.flagUsage
# lombok.log.xslf4j.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.noArgsConstructor.extraPrivate
## Type: boolean
##
## Generate a private no-args constructor for @Data and @Value (default: false).
##
## Examples:
#
# clear lombok.noArgsConstructor.extraPrivate
# lombok.noArgsConstructor.extraPrivate = [false | true]
#

##
## Key : lombok.noArgsConstructor.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @NoArgsConstructor is used.
##
## Examples:
#
# clear lombok.noArgsConstructor.flagUsage
# lombok.noArgsConstructor.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.nonNull.exceptionType
## Type: enum (lombok.core.configuration.NullCheckExceptionType)
##
## The type of the exception to throw if a passed-in argument is null (Default: NullPointerException).
##
## Examples:
#
# clear lombok.nonNull.exceptionType
# lombok.nonNull.exceptionType = [NullPointerException | IllegalArgumentException | Assertion | JDK | Guava]
#

##
## Key : lombok.nonNull.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @NonNull is used.
##
## Examples:
#
# clear lombok.nonNull.flagUsage
# lombok.nonNull.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.onX.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if onX is used.
##
## Examples:
#
# clear lombok.onX.flagUsage
# lombok.onX.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.requiredArgsConstructor.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @RequiredArgsConstructor is used.
##
## Examples:
#
# clear lombok.requiredArgsConstructor.flagUsage
# lombok.requiredArgsConstructor.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.setter.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Setter is used.
##
## Examples:
#
# clear lombok.setter.flagUsage
# lombok.setter.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.singular.auto
## Type: boolean
##
## If true (default): Automatically singularize the assumed-to-be-plural name of your variable/parameter when using @Singular.
##
## Examples:
#
# clear lombok.singular.auto
# lombok.singular.auto = [false | true]
#

##
## Key : lombok.singular.useGuava
## Type: boolean
##
## Generate backing immutable implementations for @Singular on java.util.* types by using guava's ImmutableList, etc. Normally java.util's mutable types are used and wrapped to make them immutable.
##
## Examples:
#
# clear lombok.singular.useGuava
# lombok.singular.useGuava = [false | true]
#

##
## Key : lombok.sneakyThrows.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @SneakyThrows is used.
##
## Examples:
#
# clear lombok.sneakyThrows.flagUsage
# lombok.sneakyThrows.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.standardException.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @StandardException is used.
##
## Examples:
#
# clear lombok.standardException.flagUsage
# lombok.standardException.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.superBuilder.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @SuperBuilder is used.
##
## Examples:
#
# clear lombok.superBuilder.flagUsage
# lombok.superBuilder.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.synchronized.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Synchronized is used.
##
## Examples:
#
# clear lombok.synchronized.flagUsage
# lombok.synchronized.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.toString.callSuper
## Type: enum (lombok.core.configuration.CallSuperType)
##
## When generating toString for classes that extend something (other than Object), either automatically take into account superclass implementation (call), or don't (skip), or warn and don't (warn). (default = skip).
##
## Examples:
#
# clear lombok.toString.callSuper
# lombok.toString.callSuper = [CALL | SKIP | WARN]
#

##
## Key : lombok.toString.doNotUseGetters
## Type: boolean
##
## Don't call the getters but use the fields directly in the generated toString method (default = false).
##
## Examples:
#
# clear lombok.toString.doNotUseGetters
# lombok.toString.doNotUseGetters = [false | true]
#

##
## Key : lombok.toString.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @ToString is used.
##
## Examples:
#
# clear lombok.toString.flagUsage
# lombok.toString.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.toString.includeFieldNames
## Type: boolean
##
## Include the field names in the generated toString method (default = true).
##
## Examples:
#
# clear lombok.toString.includeFieldNames
# lombok.toString.includeFieldNames = [false | true]
#

##
## Key : lombok.toString.onlyExplicitlyIncluded
## Type: boolean
##
## Include only fields/methods explicitly marked with @ToString.Include. Otherwise, include all non-static, non-dollar-named fields (default = false).
##
## Examples:
#
# clear lombok.toString.onlyExplicitlyIncluded
# lombok.toString.onlyExplicitlyIncluded = [false | true]
#

##
## Key : lombok.utilityClass.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @UtilityClass is used.
##
## Examples:
#
# clear lombok.utilityClass.flagUsage
# lombok.utilityClass.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.val.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if 'val' is used.
##
## Examples:
#
# clear lombok.val.flagUsage
# lombok.val.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.value.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Value is used.
##
## Examples:
#
# clear lombok.value.flagUsage
# lombok.value.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.var.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if 'var' is used.
##
## Examples:
#
# clear lombok.var.flagUsage
# lombok.var.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.with.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @With is used.
##
## Examples:
#
# clear lombok.with.flagUsage
# lombok.with.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.withBy.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @WithBy is used.
##
## Examples:
#
# clear lombok.withBy.flagUsage
# lombok.withBy.flagUsage = [WARNING | ERROR | ALLOW]
#

v1.18.22

##
## Key : checkerframework
## Type: checkerframework-version
##
## If set with the version of checkerframework.org (in major.minor, or just 'true' for the latest supported version), create relevant checkerframework.org annotations for code lombok generates (default: false).
##
## Examples:
#
# clear checkerframework
# checkerframework = major.minor (example: 3.2 - and no higher than 4.0) or true or false
#

##
## Key : config.stopBubbling
## Type: boolean
##
## Tell the configuration system it should stop looking for other configuration files (default: false).
##
## Examples:
#
# clear config.stopBubbling
# config.stopBubbling = [false | true]
#

##
## Key : lombok.accessors.chain
## Type: boolean
##
## Generate setters that return 'this' instead of 'void' (default: false).
##
## Examples:
#
# clear lombok.accessors.chain
# lombok.accessors.chain = [false | true]
#

##
## Key : lombok.accessors.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Accessors is used.
##
## Examples:
#
# clear lombok.accessors.flagUsage
# lombok.accessors.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.accessors.fluent
## Type: boolean
##
## Generate getters and setters using only the field name (no get/set prefix) (default: false).
##
## Examples:
#
# clear lombok.accessors.fluent
# lombok.accessors.fluent = [false | true]
#

##
## Key : lombok.accessors.prefix
## Type: list of string
##
## Strip this field prefix, like 'f' or 'm_', from the names of generated getters and setters.
##
## Examples:
#
# clear lombok.accessors.prefix
# lombok.accessors.prefix += <text>
# lombok.accessors.prefix -= <text>
#

##
## Key : lombok.addGeneratedAnnotation
## Type: boolean
##
## Generate @javax.annotation.Generated on all generated code (default: false). Deprecated, use 'lombok.addJavaxGeneratedAnnotation' instead.
##
## Examples:
#
# clear lombok.addGeneratedAnnotation
# lombok.addGeneratedAnnotation = [false | true]
#

##
## Key : lombok.addJavaxGeneratedAnnotation
## Type: boolean
##
## Generate @javax.annotation.Generated on all generated code (default: follow lombok.addGeneratedAnnotation).
##
## Examples:
#
# clear lombok.addJavaxGeneratedAnnotation
# lombok.addJavaxGeneratedAnnotation = [false | true]
#

##
## Key : lombok.addLombokGeneratedAnnotation
## Type: boolean
##
## Generate @lombok.Generated on all generated code (default: false).
##
## Examples:
#
# clear lombok.addLombokGeneratedAnnotation
# lombok.addLombokGeneratedAnnotation = [false | true]
#

##
## Key : lombok.addNullAnnotations
## Type: nullity-annotation-library
##
## Generate some style of null annotation for generated code where this is relevant. (default: none).
##
## Examples:
#
# clear lombok.addNullAnnotations
# lombok.addNullAnnotations = none | javax | eclipse | jetbrains | netbeans | androidx | android.support | checkerframework | findbugs | spring | jml | CUSTOM:com.foo.my.nonnull.annotation:com.foo.my.nullable.annotation
#

##
## Key : lombok.addSuppressWarnings
## Type: boolean
##
## Generate @java.lang.SuppressWarnings("all") on all generated code (default: true).
##
## Examples:
#
# clear lombok.addSuppressWarnings
# lombok.addSuppressWarnings = [false | true]
#

##
## Key : lombok.allArgsConstructor.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @AllArgsConstructor is used.
##
## Examples:
#
# clear lombok.allArgsConstructor.flagUsage
# lombok.allArgsConstructor.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.anyConstructor.addConstructorProperties
## Type: boolean
##
## Generate @ConstructorProperties for generated constructors (default: false).
##
## Examples:
#
# clear lombok.anyConstructor.addConstructorProperties
# lombok.anyConstructor.addConstructorProperties = [false | true]
#

##
## Key : lombok.anyConstructor.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if any of the XxxArgsConstructor annotations are used.
##
## Examples:
#
# clear lombok.anyConstructor.flagUsage
# lombok.anyConstructor.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.anyConstructor.suppressConstructorProperties
## Type: boolean
##
## Suppress the generation of @ConstructorProperties for generated constructors (default: false).
##
## Examples:
#
# clear lombok.anyConstructor.suppressConstructorProperties
# lombok.anyConstructor.suppressConstructorProperties = [false | true]
#

##
## Key : lombok.builder.className
## Type: string
##
## Default name of the generated builder class. A * is replaced with the name of the relevant type (default = *Builder).
##
## Examples:
#
# clear lombok.builder.className
# lombok.builder.className = <text>
#

##
## Key : lombok.builder.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Builder is used.
##
## Examples:
#
# clear lombok.builder.flagUsage
# lombok.builder.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.cleanup.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Cleanup is used.
##
## Examples:
#
# clear lombok.cleanup.flagUsage
# lombok.cleanup.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.copyableAnnotations
## Type: list of type-name
##
## Copy these annotations to getters, setters, with methods, builder-setters, etc.
##
## Examples:
#
# clear lombok.copyableAnnotations
# lombok.copyableAnnotations += <fully.qualified.Type>
# lombok.copyableAnnotations -= <fully.qualified.Type>
#

##
## Key : lombok.data.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Data is used.
##
## Examples:
#
# clear lombok.data.flagUsage
# lombok.data.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.delegate.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Delegate is used.
##
## Examples:
#
# clear lombok.delegate.flagUsage
# lombok.delegate.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.equalsAndHashCode.callSuper
## Type: enum (lombok.core.configuration.CallSuperType)
##
## When generating equals and hashCode for classes that extend something (other than Object), either automatically take into account superclass implementation (call), or don't (skip), or warn and don't (warn). (default = warn).
##
## Examples:
#
# clear lombok.equalsAndHashCode.callSuper
# lombok.equalsAndHashCode.callSuper = [CALL | SKIP | WARN]
#

##
## Key : lombok.equalsAndHashCode.doNotUseGetters
## Type: boolean
##
## Don't call the getters but use the fields directly in the generated equals and hashCode method (default = false).
##
## Examples:
#
# clear lombok.equalsAndHashCode.doNotUseGetters
# lombok.equalsAndHashCode.doNotUseGetters = [false | true]
#

##
## Key : lombok.equalsAndHashCode.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @EqualsAndHashCode is used.
##
## Examples:
#
# clear lombok.equalsAndHashCode.flagUsage
# lombok.equalsAndHashCode.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.experimental.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if an experimental feature is used.
##
## Examples:
#
# clear lombok.experimental.flagUsage
# lombok.experimental.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.extensionMethod.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @ExtensionMethod is used.
##
## Examples:
#
# clear lombok.extensionMethod.flagUsage
# lombok.extensionMethod.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.extern.findbugs.addSuppressFBWarnings
## Type: boolean
##
## Generate @edu.umd.cs.findbugs.annotations.SuppressFBWarnings on all generated code (default: false).
##
## Examples:
#
# clear lombok.extern.findbugs.addSuppressFBWarnings
# lombok.extern.findbugs.addSuppressFBWarnings = [false | true]
#

##
## Key : lombok.fieldDefaults.defaultFinal
## Type: boolean
##
## If true, fields, in any file (lombok annotated or not) are marked as final. Use @NonFinal to override this.
##
## Examples:
#
# clear lombok.fieldDefaults.defaultFinal
# lombok.fieldDefaults.defaultFinal = [false | true]
#

##
## Key : lombok.fieldDefaults.defaultPrivate
## Type: boolean
##
## If true, fields without any access modifier, in any file (lombok annotated or not) are marked as private. Use @PackagePrivate or an explicit modifier to override this.
##
## Examples:
#
# clear lombok.fieldDefaults.defaultPrivate
# lombok.fieldDefaults.defaultPrivate = [false | true]
#

##
## Key : lombok.fieldDefaults.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @FieldDefaults is used.
##
## Examples:
#
# clear lombok.fieldDefaults.flagUsage
# lombok.fieldDefaults.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.fieldNameConstants.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @FieldNameConstants is used.
##
## Examples:
#
# clear lombok.fieldNameConstants.flagUsage
# lombok.fieldNameConstants.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.fieldNameConstants.innerTypeName
## Type: identifier-name
##
## The default name of the inner type generated by @FieldNameConstants. (default: 'Fields').
##
## Examples:
#
# clear lombok.fieldNameConstants.innerTypeName
# lombok.fieldNameConstants.innerTypeName = <javaIdentifier>
#

##
## Key : lombok.fieldNameConstants.uppercase
## Type: boolean
##
## The default name of the constants inside the inner type generated by @FieldNameConstants follow the variable name precisely. If this config key is true, lombok will uppercase them as best it can. (default: false).
##
## Examples:
#
# clear lombok.fieldNameConstants.uppercase
# lombok.fieldNameConstants.uppercase = [false | true]
#

##
## Key : lombok.getter.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Getter is used.
##
## Examples:
#
# clear lombok.getter.flagUsage
# lombok.getter.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.getter.lazy.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Getter(lazy=true) is used.
##
## Examples:
#
# clear lombok.getter.lazy.flagUsage
# lombok.getter.lazy.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.getter.noIsPrefix
## Type: boolean
##
## If true, generate and use getFieldName() for boolean getters instead of isFieldName().
##
## Examples:
#
# clear lombok.getter.noIsPrefix
# lombok.getter.noIsPrefix = [false | true]
#

##
## Key : lombok.helper.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Helper is used.
##
## Examples:
#
# clear lombok.helper.flagUsage
# lombok.helper.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.jacksonized.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Jacksonized is used.
##
## Examples:
#
# clear lombok.jacksonized.flagUsage
# lombok.jacksonized.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.apacheCommons.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @CommonsLog is used.
##
## Examples:
#
# clear lombok.log.apacheCommons.flagUsage
# lombok.log.apacheCommons.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.custom.declaration
## Type: custom-log-declaration
##
## Define the generated custom logger field.
##
## Examples:
#
# clear lombok.log.custom.declaration
# lombok.log.custom.declaration = my.cool.Logger my.cool.LoggerFactory.createLogger()(TOPIC,TYPE)
#

##
## Key : lombok.log.custom.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @CustomLog is used.
##
## Examples:
#
# clear lombok.log.custom.flagUsage
# lombok.log.custom.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.fieldIsStatic
## Type: boolean
##
## Make the generated logger fields static (default: true).
##
## Examples:
#
# clear lombok.log.fieldIsStatic
# lombok.log.fieldIsStatic = [false | true]
#

##
## Key : lombok.log.fieldName
## Type: identifier-name
##
## Use this name for the generated logger fields (default: 'log').
##
## Examples:
#
# clear lombok.log.fieldName
# lombok.log.fieldName = <javaIdentifier>
#

##
## Key : lombok.log.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if any of the log annotations is used.
##
## Examples:
#
# clear lombok.log.flagUsage
# lombok.log.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.flogger.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Flogger is used.
##
## Examples:
#
# clear lombok.log.flogger.flagUsage
# lombok.log.flogger.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.javaUtilLogging.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Log is used.
##
## Examples:
#
# clear lombok.log.javaUtilLogging.flagUsage
# lombok.log.javaUtilLogging.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.jbosslog.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @JBossLog is used.
##
## Examples:
#
# clear lombok.log.jbosslog.flagUsage
# lombok.log.jbosslog.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.log4j.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Log4j is used.
##
## Examples:
#
# clear lombok.log.log4j.flagUsage
# lombok.log.log4j.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.log4j2.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Log4j2 is used.
##
## Examples:
#
# clear lombok.log.log4j2.flagUsage
# lombok.log.log4j2.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.slf4j.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Slf4j is used.
##
## Examples:
#
# clear lombok.log.slf4j.flagUsage
# lombok.log.slf4j.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.xslf4j.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @XSlf4j is used.
##
## Examples:
#
# clear lombok.log.xslf4j.flagUsage
# lombok.log.xslf4j.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.noArgsConstructor.extraPrivate
## Type: boolean
##
## Generate a private no-args constructor for @Data and @Value (default: false).
##
## Examples:
#
# clear lombok.noArgsConstructor.extraPrivate
# lombok.noArgsConstructor.extraPrivate = [false | true]
#

##
## Key : lombok.noArgsConstructor.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @NoArgsConstructor is used.
##
## Examples:
#
# clear lombok.noArgsConstructor.flagUsage
# lombok.noArgsConstructor.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.nonNull.exceptionType
## Type: enum (lombok.core.configuration.NullCheckExceptionType)
##
## The type of the exception to throw if a passed-in argument is null (Default: NullPointerException).
##
## Examples:
#
# clear lombok.nonNull.exceptionType
# lombok.nonNull.exceptionType = [NullPointerException | IllegalArgumentException | Assertion | JDK | Guava]
#

##
## Key : lombok.nonNull.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @NonNull is used.
##
## Examples:
#
# clear lombok.nonNull.flagUsage
# lombok.nonNull.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.onX.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if onX is used.
##
## Examples:
#
# clear lombok.onX.flagUsage
# lombok.onX.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.requiredArgsConstructor.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @RequiredArgsConstructor is used.
##
## Examples:
#
# clear lombok.requiredArgsConstructor.flagUsage
# lombok.requiredArgsConstructor.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.setter.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Setter is used.
##
## Examples:
#
# clear lombok.setter.flagUsage
# lombok.setter.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.singular.auto
## Type: boolean
##
## If true (default): Automatically singularize the assumed-to-be-plural name of your variable/parameter when using @Singular.
##
## Examples:
#
# clear lombok.singular.auto
# lombok.singular.auto = [false | true]
#

##
## Key : lombok.singular.useGuava
## Type: boolean
##
## Generate backing immutable implementations for @Singular on java.util.* types by using guava's ImmutableList, etc. Normally java.util's mutable types are used and wrapped to make them immutable.
##
## Examples:
#
# clear lombok.singular.useGuava
# lombok.singular.useGuava = [false | true]
#

##
## Key : lombok.sneakyThrows.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @SneakyThrows is used.
##
## Examples:
#
# clear lombok.sneakyThrows.flagUsage
# lombok.sneakyThrows.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.standardException.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @StandardException is used.
##
## Examples:
#
# clear lombok.standardException.flagUsage
# lombok.standardException.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.superBuilder.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @SuperBuilder is used.
##
## Examples:
#
# clear lombok.superBuilder.flagUsage
# lombok.superBuilder.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.synchronized.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Synchronized is used.
##
## Examples:
#
# clear lombok.synchronized.flagUsage
# lombok.synchronized.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.toString.callSuper
## Type: enum (lombok.core.configuration.CallSuperType)
##
## When generating toString for classes that extend something (other than Object), either automatically take into account superclass implementation (call), or don't (skip), or warn and don't (warn). (default = skip).
##
## Examples:
#
# clear lombok.toString.callSuper
# lombok.toString.callSuper = [CALL | SKIP | WARN]
#

##
## Key : lombok.toString.doNotUseGetters
## Type: boolean
##
## Don't call the getters but use the fields directly in the generated toString method (default = false).
##
## Examples:
#
# clear lombok.toString.doNotUseGetters
# lombok.toString.doNotUseGetters = [false | true]
#

##
## Key : lombok.toString.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @ToString is used.
##
## Examples:
#
# clear lombok.toString.flagUsage
# lombok.toString.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.toString.includeFieldNames
## Type: boolean
##
## Include the field names in the generated toString method (default = true).
##
## Examples:
#
# clear lombok.toString.includeFieldNames
# lombok.toString.includeFieldNames = [false | true]
#

##
## Key : lombok.utilityClass.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @UtilityClass is used.
##
## Examples:
#
# clear lombok.utilityClass.flagUsage
# lombok.utilityClass.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.val.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if 'val' is used.
##
## Examples:
#
# clear lombok.val.flagUsage
# lombok.val.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.value.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Value is used.
##
## Examples:
#
# clear lombok.value.flagUsage
# lombok.value.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.var.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if 'var' is used.
##
## Examples:
#
# clear lombok.var.flagUsage
# lombok.var.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.with.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @With is used.
##
## Examples:
#
# clear lombok.with.flagUsage
# lombok.with.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.withBy.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @WithBy is used.
##
## Examples:
#
# clear lombok.withBy.flagUsage
# lombok.withBy.flagUsage = [WARNING | ERROR | ALLOW]
#

v1.18.20

##
## Key : checkerframework
## Type: checkerframework-version
##
## If set with the version of checkerframework.org (in major.minor, or just 'true' for the latest supported version), create relevant checkerframework.org annotations for code lombok generates (default: false).
##
## Examples:
#
# clear checkerframework
# checkerframework = major.minor (example: 3.2 - and no higher than 4.0) or true or false
#

##
## Key : config.stopBubbling
## Type: boolean
##
## Tell the configuration system it should stop looking for other configuration files (default: false).
##
## Examples:
#
# clear config.stopBubbling
# config.stopBubbling = [false | true]
#

##
## Key : lombok.accessors.chain
## Type: boolean
##
## Generate setters that return 'this' instead of 'void' (default: false).
##
## Examples:
#
# clear lombok.accessors.chain
# lombok.accessors.chain = [false | true]
#

##
## Key : lombok.accessors.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Accessors is used.
##
## Examples:
#
# clear lombok.accessors.flagUsage
# lombok.accessors.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.accessors.fluent
## Type: boolean
##
## Generate getters and setters using only the field name (no get/set prefix) (default: false).
##
## Examples:
#
# clear lombok.accessors.fluent
# lombok.accessors.fluent = [false | true]
#

##
## Key : lombok.accessors.prefix
## Type: list of string
##
## Strip this field prefix, like 'f' or 'm_', from the names of generated getters and setters.
##
## Examples:
#
# clear lombok.accessors.prefix
# lombok.accessors.prefix += <text>
# lombok.accessors.prefix -= <text>
#

##
## Key : lombok.addGeneratedAnnotation
## Type: boolean
##
## Generate @javax.annotation.Generated on all generated code (default: false). Deprecated, use 'lombok.addJavaxGeneratedAnnotation' instead.
##
## Examples:
#
# clear lombok.addGeneratedAnnotation
# lombok.addGeneratedAnnotation = [false | true]
#

##
## Key : lombok.addJavaxGeneratedAnnotation
## Type: boolean
##
## Generate @javax.annotation.Generated on all generated code (default: follow lombok.addGeneratedAnnotation).
##
## Examples:
#
# clear lombok.addJavaxGeneratedAnnotation
# lombok.addJavaxGeneratedAnnotation = [false | true]
#

##
## Key : lombok.addLombokGeneratedAnnotation
## Type: boolean
##
## Generate @lombok.Generated on all generated code (default: false).
##
## Examples:
#
# clear lombok.addLombokGeneratedAnnotation
# lombok.addLombokGeneratedAnnotation = [false | true]
#

##
## Key : lombok.addNullAnnotations
## Type: nullity-annotation-library
##
## Generate some style of null annotation for generated code where this is relevant. (default: none).
##
## Examples:
#
# clear lombok.addNullAnnotations
# lombok.addNullAnnotations = none | javax | eclipse | jetbrains | netbeans | androidx | android.support | checkerframework | findbugs | spring | jml | CUSTOM:com.foo.my.nonnull.annotation:com.foo.my.nullable.annotation
#

##
## Key : lombok.addSuppressWarnings
## Type: boolean
##
## Generate @java.lang.SuppressWarnings("all") on all generated code (default: true).
##
## Examples:
#
# clear lombok.addSuppressWarnings
# lombok.addSuppressWarnings = [false | true]
#

##
## Key : lombok.allArgsConstructor.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @AllArgsConstructor is used.
##
## Examples:
#
# clear lombok.allArgsConstructor.flagUsage
# lombok.allArgsConstructor.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.anyConstructor.addConstructorProperties
## Type: boolean
##
## Generate @ConstructorProperties for generated constructors (default: false).
##
## Examples:
#
# clear lombok.anyConstructor.addConstructorProperties
# lombok.anyConstructor.addConstructorProperties = [false | true]
#

##
## Key : lombok.anyConstructor.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if any of the XxxArgsConstructor annotations are used.
##
## Examples:
#
# clear lombok.anyConstructor.flagUsage
# lombok.anyConstructor.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.anyConstructor.suppressConstructorProperties
## Type: boolean
##
## Suppress the generation of @ConstructorProperties for generated constructors (default: false).
##
## Examples:
#
# clear lombok.anyConstructor.suppressConstructorProperties
# lombok.anyConstructor.suppressConstructorProperties = [false | true]
#

##
## Key : lombok.builder.className
## Type: string
##
## Default name of the generated builder class. A * is replaced with the name of the relevant type (default = *Builder).
##
## Examples:
#
# clear lombok.builder.className
# lombok.builder.className = <text>
#

##
## Key : lombok.builder.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Builder is used.
##
## Examples:
#
# clear lombok.builder.flagUsage
# lombok.builder.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.cleanup.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Cleanup is used.
##
## Examples:
#
# clear lombok.cleanup.flagUsage
# lombok.cleanup.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.copyableAnnotations
## Type: list of type-name
##
## Copy these annotations to getters, setters, with methods, builder-setters, etc.
##
## Examples:
#
# clear lombok.copyableAnnotations
# lombok.copyableAnnotations += <fully.qualified.Type>
# lombok.copyableAnnotations -= <fully.qualified.Type>
#

##
## Key : lombok.data.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Data is used.
##
## Examples:
#
# clear lombok.data.flagUsage
# lombok.data.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.delegate.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Delegate is used.
##
## Examples:
#
# clear lombok.delegate.flagUsage
# lombok.delegate.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.equalsAndHashCode.callSuper
## Type: enum (lombok.core.configuration.CallSuperType)
##
## When generating equals and hashCode for classes that extend something (other than Object), either automatically take into account superclass implementation (call), or don't (skip), or warn and don't (warn). (default = warn).
##
## Examples:
#
# clear lombok.equalsAndHashCode.callSuper
# lombok.equalsAndHashCode.callSuper = [CALL | SKIP | WARN]
#

##
## Key : lombok.equalsAndHashCode.doNotUseGetters
## Type: boolean
##
## Don't call the getters but use the fields directly in the generated equals and hashCode method (default = false).
##
## Examples:
#
# clear lombok.equalsAndHashCode.doNotUseGetters
# lombok.equalsAndHashCode.doNotUseGetters = [false | true]
#

##
## Key : lombok.equalsAndHashCode.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @EqualsAndHashCode is used.
##
## Examples:
#
# clear lombok.equalsAndHashCode.flagUsage
# lombok.equalsAndHashCode.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.experimental.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if an experimental feature is used.
##
## Examples:
#
# clear lombok.experimental.flagUsage
# lombok.experimental.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.extensionMethod.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @ExtensionMethod is used.
##
## Examples:
#
# clear lombok.extensionMethod.flagUsage
# lombok.extensionMethod.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.extern.findbugs.addSuppressFBWarnings
## Type: boolean
##
## Generate @edu.umd.cs.findbugs.annotations.SuppressFBWarnings on all generated code (default: false).
##
## Examples:
#
# clear lombok.extern.findbugs.addSuppressFBWarnings
# lombok.extern.findbugs.addSuppressFBWarnings = [false | true]
#

##
## Key : lombok.fieldDefaults.defaultFinal
## Type: boolean
##
## If true, fields, in any file (lombok annotated or not) are marked as final. Use @NonFinal to override this.
##
## Examples:
#
# clear lombok.fieldDefaults.defaultFinal
# lombok.fieldDefaults.defaultFinal = [false | true]
#

##
## Key : lombok.fieldDefaults.defaultPrivate
## Type: boolean
##
## If true, fields without any access modifier, in any file (lombok annotated or not) are marked as private. Use @PackagePrivate or an explicit modifier to override this.
##
## Examples:
#
# clear lombok.fieldDefaults.defaultPrivate
# lombok.fieldDefaults.defaultPrivate = [false | true]
#

##
## Key : lombok.fieldDefaults.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @FieldDefaults is used.
##
## Examples:
#
# clear lombok.fieldDefaults.flagUsage
# lombok.fieldDefaults.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.fieldNameConstants.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @FieldNameConstants is used.
##
## Examples:
#
# clear lombok.fieldNameConstants.flagUsage
# lombok.fieldNameConstants.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.fieldNameConstants.innerTypeName
## Type: identifier-name
##
## The default name of the inner type generated by @FieldNameConstants. (default: 'Fields').
##
## Examples:
#
# clear lombok.fieldNameConstants.innerTypeName
# lombok.fieldNameConstants.innerTypeName = <javaIdentifier>
#

##
## Key : lombok.fieldNameConstants.uppercase
## Type: boolean
##
## The default name of the constants inside the inner type generated by @FieldNameConstants follow the variable name precisely. If this config key is true, lombok will uppercase them as best it can. (default: false).
##
## Examples:
#
# clear lombok.fieldNameConstants.uppercase
# lombok.fieldNameConstants.uppercase = [false | true]
#

##
## Key : lombok.getter.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Getter is used.
##
## Examples:
#
# clear lombok.getter.flagUsage
# lombok.getter.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.getter.lazy.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Getter(lazy=true) is used.
##
## Examples:
#
# clear lombok.getter.lazy.flagUsage
# lombok.getter.lazy.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.getter.noIsPrefix
## Type: boolean
##
## If true, generate and use getFieldName() for boolean getters instead of isFieldName().
##
## Examples:
#
# clear lombok.getter.noIsPrefix
# lombok.getter.noIsPrefix = [false | true]
#

##
## Key : lombok.helper.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Helper is used.
##
## Examples:
#
# clear lombok.helper.flagUsage
# lombok.helper.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.jacksonized.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Jacksonized is used.
##
## Examples:
#
# clear lombok.jacksonized.flagUsage
# lombok.jacksonized.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.apacheCommons.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @CommonsLog is used.
##
## Examples:
#
# clear lombok.log.apacheCommons.flagUsage
# lombok.log.apacheCommons.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.custom.declaration
## Type: custom-log-declaration
##
## Define the generated custom logger field.
##
## Examples:
#
# clear lombok.log.custom.declaration
# lombok.log.custom.declaration = my.cool.Logger my.cool.LoggerFactory.createLogger()(TOPIC,TYPE)
#

##
## Key : lombok.log.custom.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @CustomLog is used.
##
## Examples:
#
# clear lombok.log.custom.flagUsage
# lombok.log.custom.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.fieldIsStatic
## Type: boolean
##
## Make the generated logger fields static (default: true).
##
## Examples:
#
# clear lombok.log.fieldIsStatic
# lombok.log.fieldIsStatic = [false | true]
#

##
## Key : lombok.log.fieldName
## Type: identifier-name
##
## Use this name for the generated logger fields (default: 'log').
##
## Examples:
#
# clear lombok.log.fieldName
# lombok.log.fieldName = <javaIdentifier>
#

##
## Key : lombok.log.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if any of the log annotations is used.
##
## Examples:
#
# clear lombok.log.flagUsage
# lombok.log.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.flogger.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Flogger is used.
##
## Examples:
#
# clear lombok.log.flogger.flagUsage
# lombok.log.flogger.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.javaUtilLogging.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Log is used.
##
## Examples:
#
# clear lombok.log.javaUtilLogging.flagUsage
# lombok.log.javaUtilLogging.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.jbosslog.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @JBossLog is used.
##
## Examples:
#
# clear lombok.log.jbosslog.flagUsage
# lombok.log.jbosslog.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.log4j.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Log4j is used.
##
## Examples:
#
# clear lombok.log.log4j.flagUsage
# lombok.log.log4j.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.log4j2.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Log4j2 is used.
##
## Examples:
#
# clear lombok.log.log4j2.flagUsage
# lombok.log.log4j2.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.slf4j.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Slf4j is used.
##
## Examples:
#
# clear lombok.log.slf4j.flagUsage
# lombok.log.slf4j.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.log.xslf4j.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @XSlf4j is used.
##
## Examples:
#
# clear lombok.log.xslf4j.flagUsage
# lombok.log.xslf4j.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.noArgsConstructor.extraPrivate
## Type: boolean
##
## Generate a private no-args constructor for @Data and @Value (default: false).
##
## Examples:
#
# clear lombok.noArgsConstructor.extraPrivate
# lombok.noArgsConstructor.extraPrivate = [false | true]
#

##
## Key : lombok.noArgsConstructor.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @NoArgsConstructor is used.
##
## Examples:
#
# clear lombok.noArgsConstructor.flagUsage
# lombok.noArgsConstructor.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.nonNull.exceptionType
## Type: enum (lombok.core.configuration.NullCheckExceptionType)
##
## The type of the exception to throw if a passed-in argument is null (Default: NullPointerException).
##
## Examples:
#
# clear lombok.nonNull.exceptionType
# lombok.nonNull.exceptionType = [NullPointerException | IllegalArgumentException | Assertion | JDK | Guava]
#

##
## Key : lombok.nonNull.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @NonNull is used.
##
## Examples:
#
# clear lombok.nonNull.flagUsage
# lombok.nonNull.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.onX.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if onX is used.
##
## Examples:
#
# clear lombok.onX.flagUsage
# lombok.onX.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.requiredArgsConstructor.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @RequiredArgsConstructor is used.
##
## Examples:
#
# clear lombok.requiredArgsConstructor.flagUsage
# lombok.requiredArgsConstructor.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.setter.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Setter is used.
##
## Examples:
#
# clear lombok.setter.flagUsage
# lombok.setter.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.singular.auto
## Type: boolean
##
## If true (default): Automatically singularize the assumed-to-be-plural name of your variable/parameter when using @Singular.
##
## Examples:
#
# clear lombok.singular.auto
# lombok.singular.auto = [false | true]
#

##
## Key : lombok.singular.useGuava
## Type: boolean
##
## Generate backing immutable implementations for @Singular on java.util.* types by using guava's ImmutableList, etc. Normally java.util's mutable types are used and wrapped to make them immutable.
##
## Examples:
#
# clear lombok.singular.useGuava
# lombok.singular.useGuava = [false | true]
#

##
## Key : lombok.sneakyThrows.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @SneakyThrows is used.
##
## Examples:
#
# clear lombok.sneakyThrows.flagUsage
# lombok.sneakyThrows.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.superBuilder.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @SuperBuilder is used.
##
## Examples:
#
# clear lombok.superBuilder.flagUsage
# lombok.superBuilder.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.synchronized.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Synchronized is used.
##
## Examples:
#
# clear lombok.synchronized.flagUsage
# lombok.synchronized.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.toString.callSuper
## Type: enum (lombok.core.configuration.CallSuperType)
##
## When generating toString for classes that extend something (other than Object), either automatically take into account superclass implementation (call), or don't (skip), or warn and don't (warn). (default = skip).
##
## Examples:
#
# clear lombok.toString.callSuper
# lombok.toString.callSuper = [CALL | SKIP | WARN]
#

##
## Key : lombok.toString.doNotUseGetters
## Type: boolean
##
## Don't call the getters but use the fields directly in the generated toString method (default = false).
##
## Examples:
#
# clear lombok.toString.doNotUseGetters
# lombok.toString.doNotUseGetters = [false | true]
#

##
## Key : lombok.toString.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @ToString is used.
##
## Examples:
#
# clear lombok.toString.flagUsage
# lombok.toString.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.toString.includeFieldNames
## Type: boolean
##
## Include the field names in the generated toString method (default = true).
##
## Examples:
#
# clear lombok.toString.includeFieldNames
# lombok.toString.includeFieldNames = [false | true]
#

##
## Key : lombok.utilityClass.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @UtilityClass is used.
##
## Examples:
#
# clear lombok.utilityClass.flagUsage
# lombok.utilityClass.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.val.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if 'val' is used.
##
## Examples:
#
# clear lombok.val.flagUsage
# lombok.val.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.value.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @Value is used.
##
## Examples:
#
# clear lombok.value.flagUsage
# lombok.value.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.var.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if 'var' is used.
##
## Examples:
#
# clear lombok.var.flagUsage
# lombok.var.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.with.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @With is used.
##
## Examples:
#
# clear lombok.with.flagUsage
# lombok.with.flagUsage = [WARNING | ERROR | ALLOW]
#

##
## Key : lombok.withBy.flagUsage
## Type: enum (lombok.core.configuration.FlagUsageType)
##
## Emit a warning or error if @WithBy is used.
##
## Examples:
#
# clear lombok.withBy.flagUsage
# lombok.withBy.flagUsage = [WARNING | ERROR | ALLOW]
#

참고

Configuration system

projectlombok.org

Spring Batch 5 뭐가 달라졌나?

AlwaysPr — Sun, 19 Feb 2023 23:24:32 +0900

Spring Batch 4.0에서 약 5년의 세월이 흘러 Spring Batch 5.0으로 메이저 버전이 업데이트되었다.

어떤 기능들이 개선되고, 생겼는지 알아보도록 하자.

의존성

Spring Batch5는 Spring framework 6을 의존하기 때문에 최소 Java 17이 필요하다.

그 외에 3rd Party 의존성은 다음과 같다.

Spring Framework 6
Spring Integration 6
Spring Data 3
Spring AMQP 3
Spring for Apache Kafka 3
Micrometer 1.10

다양한 JobParemeter Type

드디어(?) 다양한 JobParemeter type을 제공한다.

4.x 버전까지는 4개의 Type(Long, Double, String, Date)만을 지원했다. 하지만 5.0부터는 JobParameter를 커스텀해서 사용할 수 있다. 아래는 JobParameter의 변경사항인데, Generic이 들어간 걸 확인할 수 있다.

4.x까지는 아래처럼 jobParameter를 적용했다.

parameterName(parameterType)=parameterValue

5부터는 다음과 같이 적용해야 한다.

parameterName=parameterValue,parameterType,identificationFlag

실예로 들면 다음과 같다.

schedule.date=2022-12-12,java.time.LocalDate

위는 기본적으로 적용된 DefaultJobParametersConverter의 결과물이다.

보다 명시적인 방식을 원한다면 JsonJobParametersConverter를 사용할 수 있다.

parameterName='{"value": "parameterValue", "type":"parameterType", "identifying": "booleanValue"}'

이를 위해 BATCH_JOB_EXECUTION_PARAMS DDL이 수정되었다.

숨겨진 자동 설정 명시적으로 변경

StepBuilderFactory, JobBuilderFactory가 Deprecated 되었다. 해당 Factory를 사용하여 Step과 Job을 구성하는 건 일반적으로 사용하는 방식이다.

@Configuration
@EnableBatchProcessing
public class MyJobConfig {

    @Autowired
    private JobBuilderFactory jobBuilderFactory;

    @Bean
    public Job myJob(Step step) {
        return this.jobBuilderFactory.get("myJob")
                .start(step)
                .build();
    }

}

그러나 이는 사용자가 문서를 읽어 인지하지 않는 한 Builder에서 JobRepository가 생성되고 설정된다는 사실을 숨기고 있다.
그래서 아래와 같이 JobRepository를 명시적으로 제공하는 방식을 사용하길 권장한다.

@Configuration
@EnableBatchProcessing
public class MyJobConfig {

    @Bean
    public Job myJob(JobRepository jobRepository, Step step) {
        return new JobBuilder("myJob", jobRepository)
                .start(step)
                .build();
    }

}

transactionManager 또한 위와 같은 이유로 명시적으로 사용하길 권장하고 있다.

// Sample with v4
@Configuration
@EnableBatchProcessing
public class MyStepConfig {

    @Autowired
    private StepBuilderFactory stepBuilderFactory;

    @Bean
    public Step myStep() {
        return this.stepBuilderFactory.get("myStep")
                .tasklet(..) // or .chunk()
                .build();
    }

}

// Sample with v5
@Configuration
@EnableBatchProcessing
public class MyStepConfig {

    @Bean
    public Tasklet myTasklet() {
       return new MyTasklet();
    }

    @Bean
    public Step myStep(JobRepository jobRepository, Tasklet myTasklet, PlatformTransactionManager transactionManager) {
        return new StepBuilder("myStep", jobRepository)
                .tasklet(myTasklet, transactionManager) // or .chunk(chunkSize, transactionManager)
                .build();
    }

}

Spring Batch 팀에서는 불편함을 감수하더라도 명시적인 코드 작성에 손을 들어줬다. 더보기

DefaultBatchConfiguration 추가

@EnableBatchProcessing가 JobRepository, JobLauncher, StepScope, JobScope 등의 Bean을 등록하고 마법을 부리는 것을 대신할 Configuration class가 추가되었다.

아래처럼 DefaultBatchConfiguration를 상속하여 사용하면 된다.

@Configuration
class MyJobConfiguration extends DefaultBatchConfiguration {

	@Bean
	public Job job(JobRepository jobRepository) {
		return new JobBuilder("myJob", jobRepository)
				//define job flow as needed
				.build();
	}

}

DefaultBatchConfiguration에서는 getDataSource, getTransactionManager, getCharset 등의 다양한 protected method 들을 제공하고 있으며, 자식 클래스에서 이를 Override 하여 간편하게 Batch 설정을 커스터마이즈 할 수 있다.

@Configuration
class MyJobConfiguration extends DefaultBatchConfiguration {

	@Bean
	public Job job(JobRepository jobRepository) {
		return new JobBuilder("job", jobRepository)
				// define job flow as needed
				.build();
	}

	@Override
	protected Charset getCharset() {
		return StandardCharsets.ISO_8859_1;
	}

}

⛔️ 주의할 점은 @EnableBatchProcessing과 DefaultBatchConfiguration를 함께 사용하면 안 된다.

@EnableBatchProcessing

@EnableBatchProcessing Annotation이 4.x버전까지 modular만 제공하는 것에 다양한 옵션을 제공한다.

dataSourceRef
transactionManagerRef
executionContextSerializerRef
charset
tablePrefix
maxVarCharLength
incrementerFactoryRef
lobHandlerRef
clobType
isolationLevelForCreate
taskExecutorRef
conversionServiceRef

GraalVM native 지원

GraalVM을 사용하여 Spring Batch 애플리케이션을 기본적으로 컴파일하는 데 필요한 Ahead-Of-Time process 및 Runtime hint를 제공하여 성능이 크게 개선되었다고 한다.

참고

Spring Batch - Reference Documentation

If a group of Steps share similar configurations, then it may be helpful to define a “parent” Step from which the concrete Steps may inherit properties. Similar to class inheritance in Java, the “child” Step combines its elements and attributes wit

docs.spring.io

Spring | Home

Cloud Your code, any cloud—we’ve got you covered. Connect and scale your services, whatever your platform.

spring.io

Spring Batch 5.0 Migration Guide

Spring Batch is a framework for writing offline and batch applications using Spring and Java - spring-projects/spring-batch

github.com

Deprecate Job/Step builder factories · Issue #4188 · spring-projects/spring-batch

JobBuilderFactory was reported to be of no real added value compared to JobBuilder. In fact, it only sets a single property on the builder it creates, which is the job repository. While this is not...

github.com

10분만에 구현하는 CircuitBreaker

AlwaysPr — Sun, 29 Jan 2023 14:00:21 +0900

Spring AOP를 활용하여 CircuitBreaker를 구현해 보자.

Annotation 기반의 AOP를 활용하기 위해 Annotation과 Aspect를 다음과 같이 만들어주자.

@Target({ ElementType.METHOD, ElementType.TYPE })
@Retention(RetentionPolicy.RUNTIME)
@Documented
public @interface CircuitBreaker {}

@Aspect
@Component
public class CircuitBreakerAspect {

    @Around("@annotation(com.ms.circuitbreaker.CircuitBreaker)")
    public Object round(ProceedingJoinPoint joinPoint) throws Throwable {
    	// TODO 세부구현
        return joinPoint.proceed();
    }

}

CircuitBreaker를 적용할 코드도 하나 만들자

@Service
public class FooService {

    @CircuitBreaker
    public String getFoo() {
        return "foo";
    }

}

실패 개수와 마지막 실패 시간을 가지고 있는 metadata와 Exception을 만들자

class CircuitBreakerMetadata {

        private final AtomicInteger failures = new AtomicInteger();

        private volatile long lastFailure;

        CircuitBreakerMetadata() {
        }

        private long getLastFailure() {
            return this.lastFailure;
        }

        private void setLastFailure(long lastFailure) {
            this.lastFailure = lastFailure;
        }

        private AtomicInteger getFailures() {
            return this.failures;
        }

    }

public final class CircuitBreakerOpenException extends RuntimeException {}

기본적인 뼈대는 만들어졌다.

이제 CircuitBreaker 동작을 Aspect에서 구현해 보자

요구사항은 간단하다.

1. @CircuitBreaker가 선언된 곳에서 에러가 연속으로 5회를 넘게 되면

2. 1초 동안 CircuitBreaker가 발동한다.

3. 에러 없이 성공하면 실패 개수를 초기화한다.

@Aspect
@Component
public class CircuitBreakerAspect {

    private static final int THRESHOLD = 5;
    
    private static final long HALF_OPEN_AFTER = 1000;
    
    private static final ConcurrentMap<Object, CircuitBreakerMetadata> METADATA_MAP = new ConcurrentHashMap<>();

    @Around("@annotation(com.ms.circuitbreaker.CircuitBreaker)")
    public Object round(ProceedingJoinPoint joinPoint) throws Throwable {

        final Object target = joinPoint.getTarget();

        CircuitBreakerMetadata metadata = METADATA_MAP.get(target);

        if (metadata == null) {
            METADATA_MAP.putIfAbsent(target, new CircuitBreakerMetadata());
            metadata = METADATA_MAP.get(target);
        }

        if (metadata.getFailures().get() >= THRESHOLD &&
                System.currentTimeMillis() - metadata.getLastFailure() < HALF_OPEN_AFTER) {
            throw new CircuitBreakerOpenException();
        }

        try {
            final Object result = joinPoint.proceed();
            metadata.getFailures().set(0);
            return result;
        } catch (Exception e) {
            metadata.getFailures().incrementAndGet();
            metadata.setLastFailure(System.currentTimeMillis());
            throw e;
        }

    }
}

CircuitBrekaer를 구현해 보았다.

Spring에서 제공하는 @CircuitBreaker를 사용하다가 어떻게 구현되어있는지 보니 생각에 비해 간단/간결하게 작성되어 있었다.

사실 위에서 작성한 코드는 spring-integration의 RequestHandlerCircuitBreakerAdvice 클래스이다.

프레임워크와 라이브러리가 제공해 준다고 해서 그저 가져다 쓰기보다는 어떻게 구현되었는지 궁금해하고 찾다 보면 더 좋은 개발자가 되리라 생각한다.

WebFlux에서 micrometer로 모니터링 데이터 수집하기

AlwaysPr — Wed, 11 Jan 2023 19:39:11 +0900

환경설정

필자는 gradle을 사용했고, 아래와 같이 webflux, actuator, prometheus 등의 dependency 설정이 필요하다

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-actuator'
    implementation 'org.springframework.boot:spring-boot-starter-webflux'
    runtimeOnly 'io.micrometer:micrometer-registry-prometheus'
    compileOnly 'org.projectlombok:lombok'
    annotationProcessor 'org.projectlombok:lombok'
    testImplementation 'org.springframework.boot:spring-boot-starter-test'
    testImplementation 'io.projectreactor:reactor-test'
}

그리고 application.properties에 아래 코드를 통하여 엔드포인트에 노출시켜 주도록 하자

management.endpoints.web.exposure.include=health,info,metrics,prometheus

micrometer를 사용하면 기본적으로 JVM, Disk, CPU, HTTP 등의 다양한 값들을 측정할 수 있지만 특정 API, Code 들의 속도 측정을 위주로 문서를 작성해보려 한다.

1. HTTP 속도 측정

Server 기준

우선은 아래처럼 간단한 API를 만들었고, 300~2000ms의 sleep을 걸었다.

@RestController
public class FooController {

    @GetMapping("/test")
    public Mono<String> test() throws InterruptedException {
        int millis = ThreadLocalRandom.current().nextInt(300, 2000);
        Thread.sleep(millis);
        return Mono.just("test");

    }
}

Terminal에서 curl localhost:8080/test 을 충분히 호출해 준 뒤

curl localhost:8080/actuator/prometheus 를 호출하여 지표를 보도록 하자.

# HELP http_server_requests_seconds
# TYPE http_server_requests_seconds summary
http_server_requests_seconds_count{exception="None",method="GET",outcome="SUCCESS",status="200",uri="/test",} 5.0
http_server_requests_seconds_sum{exception="None",method="GET",outcome="SUCCESS",status="200",uri="/test",} 3.690574182

# HELP http_server_requests_seconds_max
# TYPE http_server_requests_seconds_max gauge
http_server_requests_seconds_max{exception="None",method="GET",outcome="SUCCESS",status="200",uri="/test",} 1.048827297

기본적으로 http 호출 수, 총 시간, max 시간을 제공해주고 있다. 만약 백분위 지표나 그 외의 지표를 알고 싶다면 application.properties에 코드를 한 줄 추가해 주면 된다.(참고)

해당 지표들은 태그들을 충분히 제공하기 때문에 uri, status, method 별로 데이터를 시각화할 수 있다.

Client 기준

Controller로 들어오는 지표와 반대로 Webclient를 통해 외부로 나가는 데이터도 측정할 수 있다.

우선 아래처럼 Controller, Service를 작성해 보자

@RestController
public class FooController {

    private final FooService fooService;

    @GetMapping("/test")
    public Mono<String> test() throws InterruptedException {
        int millis = ThreadLocalRandom.current().nextInt(300, 2000);
        Thread.sleep(millis);
        return Mono.just("test");
    }

    @GetMapping("/call")
    public Mono<String> call() {
        return fooService.call();
    }

}


@Service
public class FooService {

    private final WebClient webClient;

    public FooService(WebClient.Builder builder) {
        this.webClient = builder
                .baseUrl("http://localhost:8080/test")
                .build();
    }

    public Mono<String> call() {
        return webClient.get()
                .retrieve()
                .bodyToMono(String.class);
    }

}

/call을 호출하게 되면 Webclient로 /test를 호출하게 되는 간단한 구조이다. ( /call -> /test )

Service에서 주의 깊게 봐야 할 코드는 생성자 부분이다. WebClient.Builder는 WebClientAutoConfiguration#webClientBuilder에서 생성된 Prototype Sope의 빈을 DI 받는다.

@Bean
@Scope("prototype")
@ConditionalOnMissingBean
public WebClient.Builder webClientBuilder(ObjectProvider<WebClientCustomizer> customizerProvider) {
   WebClient.Builder builder = WebClient.builder();
   customizerProvider.orderedStream().forEach((customizer) -> customizer.customize(builder));
   return builder;
}

webClientBuilder의 파라미터로는 WebClientMetricsConfiguration#metricsWebClientCustomizer를 DI 받아 WebClient filter로 등록을 해준다.

돌고 돌아왔는데, 한마디로 말하면 WebClient.Builder를 DI 받아서 사용하면 기본적으로 metric을 사용할 수 있다.

WebClient로 호출되면 아래처럼 prometheus에 metric이 수집된다.

# HELP http_client_requests_seconds Timer of WebClient operation
# TYPE http_client_requests_seconds summary
http_client_requests_seconds_count{clientName="localhost",method="GET",outcome="SUCCESS",status="200",uri="/test",} 6.0
http_client_requests_seconds_sum{clientName="localhost",method="GET",outcome="SUCCESS",status="200",uri="/test",} 10.821525809
# HELP http_client_requests_seconds_max Timer of WebClient operation
# TYPE http_client_requests_seconds_max gauge
http_client_requests_seconds_max{clientName="localhost",method="GET",outcome="SUCCESS",status="200",uri="/test",} 1.097316922

2. Annotation을 통한 측정

@Timed(extraTags = {"timedKey", "timedValue"}, percentiles = {0.95, 0.99})
@Counted(extraTags = {"countedKey", "countedValue"})
@GetMapping("/test")
public Mono<String> test() throws InterruptedException {
    int millis = ThreadLocalRandom.current().nextInt(300, 2000);
    Thread.sleep(millis);
    return Mono.just("test");
}

Annotation을 이용하면 method 별로 좀 더 디테일하게 지표를 측정할 수 있다.

extraTags는 key, value로 꼭 이루어져야 하며, 해당 Annotation은 다양한 기능을 제공한다.

이것이 가능한 이유는 WebFluxMetricsAutoConfiguration에서 자동설정된 MetricsWebFilter#record가 동작하기 때문이다.

아래는 측정된 지표들이다.

# HELP http_server_requests_seconds
# TYPE http_server_requests_seconds summary
http_server_requests_seconds{exception="None",method="GET",outcome="SUCCESS",status="200",timedKey="timedValue",uri="/test",quantile="0.95",} 1.811939328
http_server_requests_seconds{exception="None",method="GET",outcome="SUCCESS",status="200",timedKey="timedValue",uri="/test",quantile="0.99",} 1.811939328
http_server_requests_seconds_count{exception="None",method="GET",outcome="SUCCESS",status="200",timedKey="timedValue",uri="/test",} 2.0
http_server_requests_seconds_sum{exception="None",method="GET",outcome="SUCCESS",status="200",timedKey="timedValue",uri="/test",} 3.068237006
# HELP http_server_requests_seconds_max
# TYPE http_server_requests_seconds_max gauge
http_server_requests_seconds_max{exception="None",method="GET",outcome="SUCCESS",status="200",timedKey="timedValue",uri="/test",} 1.849908941

3. 특정 파이프라인의 속도 측정

Reactor에서 제공하는 metircs 메소드를 사용하면 특정 파이프라인의 지표를 측정할 수 있다.

@GetMapping("/test")
public Mono<String> test() throws InterruptedException {
    return Mono.just("test")
            .map(this::sleepAndConcat);
}

private String sleepAndConcat(String it){
    int millis = ThreadLocalRandom.current().nextInt(300, 2000);
    try {
        Thread.sleep(millis);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
    return it + it;
}

Mono에 들어가 있는 String을 더하는 간단한 기능이다.

#sleepAndConcat에는 일부로 다양한 시간을 측정하기 위해 랜덤 하게 시간을 기다리게 했다.

#sleepAndConcat에서 소요되는 시간을 측정하려면 Mono#metrics를 사용해 주면 간단하게 측정할 수 있다.

@GetMapping("/test")
public Mono<String> test() throws InterruptedException {
    return Mono.just("test")
            .map(this::sleepAndConcat)
            .metrics();
}

# HELP reactor_flow_duration_seconds Times the duration elapsed between a subscription and the onComplete termination of a sequence that did emit some elements
# TYPE reactor_flow_duration_seconds summary
reactor_flow_duration_seconds_count{exception="",status="completed",type="Mono",} 5.0
reactor_flow_duration_seconds_sum{exception="",status="completed",type="Mono",} 4.807904757
# HELP reactor_flow_duration_seconds_max Times the duration elapsed between a subscription and the onComplete termination of a sequence that did emit some elements
# TYPE reactor_flow_duration_seconds_max gauge
reactor_flow_duration_seconds_max{exception="",status="completed",type="Mono",} 1.901454296

별도의 name을 주지 않으면 reactor_flow_duration를 default 값으로 보여준다.
이는 Mono#name 을 사용하여 아래처럼 정의할 수 있다.

@GetMapping("/test")
public Mono<String> test() {
    return Mono.just("test")
            .map(this::sleepAndConcat)
            .name("ms_test_metrics")
            .metrics();
}

# HELP ms_test_metrics_flow_duration_seconds_max Times the duration elapsed between a subscription and the onComplete termination of a sequence that did emit some elements
# TYPE ms_test_metrics_flow_duration_seconds_max gauge
ms_test_metrics_flow_duration_seconds_max{exception="",status="completed",type="Mono",} 1.786340917
# HELP ms_test_metrics_flow_duration_seconds Times the duration elapsed between a subscription and the onComplete termination of a sequence that did emit some elements
# TYPE ms_test_metrics_flow_duration_seconds summary
ms_test_metrics_flow_duration_seconds_count{exception="",status="completed",type="Mono",} 7.0
ms_test_metrics_flow_duration_seconds_sum{exception="",status="completed",type="Mono",} 7.508261709

이에 더해 파라미터별로 측정하고 싶다거나 특정 데이터를 기준으로 데이터를 수집하고 싶으면 Mono#tag를 사용하면 된다.

@GetMapping("/test")
public Mono<String> test() {
    return Mono.just("test")
            .map(this::sleepAndConcat)
            .name("ms_test_metrics")
            .tag("KEY", UUID.randomUUID().toString())
            .metrics();
}

# HELP ms_test_metrics_flow_duration_seconds_max Times the duration elapsed between a subscription and the onComplete termination of a sequence that did emit some elements
# TYPE ms_test_metrics_flow_duration_seconds_max gauge
ms_test_metrics_flow_duration_seconds_max{KEY="6d58e54a-f7b7-49ad-974b-c1e18ba7676d",exception="",status="completed",type="Mono",} 0.522620334
ms_test_metrics_flow_duration_seconds_max{KEY="b8d05f99-861d-4253-a59f-582e2e9230ac",exception="",status="completed",type="Mono",} 1.125683875
ms_test_metrics_flow_duration_seconds_max{KEY="be098a82-c39c-4a8e-92d3-87009cfd83c3",exception="",status="completed",type="Mono",} 1.216874791
# HELP ms_test_metrics_flow_duration_seconds Times the duration elapsed between a subscription and the onComplete termination of a sequence that did emit some elements
# TYPE ms_test_metrics_flow_duration_seconds summary
ms_test_metrics_flow_duration_seconds_count{KEY="6d58e54a-f7b7-49ad-974b-c1e18ba7676d",exception="",status="completed",type="Mono",} 1.0
ms_test_metrics_flow_duration_seconds_sum{KEY="6d58e54a-f7b7-49ad-974b-c1e18ba7676d",exception="",status="completed",type="Mono",} 0.522620334
ms_test_metrics_flow_duration_seconds_count{KEY="b8d05f99-861d-4253-a59f-582e2e9230ac",exception="",status="completed",type="Mono",} 1.0
ms_test_metrics_flow_duration_seconds_sum{KEY="b8d05f99-861d-4253-a59f-582e2e9230ac",exception="",status="completed",type="Mono",} 1.125683875
ms_test_metrics_flow_duration_seconds_count{KEY="be098a82-c39c-4a8e-92d3-87009cfd83c3",exception="",status="completed",type="Mono",} 1.0
ms_test_metrics_flow_duration_seconds_sum{KEY="be098a82-c39c-4a8e-92d3-87009cfd83c3",exception="",status="completed",type="Mono",} 1.216874791

2022년 회고

AlwaysPr — Fri, 30 Dec 2022 23:19:10 +0900

오랜만에 쓰는 회고글이다. 2022년을 의미 있게 보냈고, 2023년을 맞이하기 위해 회고글을 작성하기로 했다.

이를 계기로 내년엔 블로그 작성에 좀 더 신경써보려한다.

본인확인기관 라이센스 취득

회사에서 본인확인기관 / 전자서명인정사업자 라이센스를 취득하기 위해 준비가 한창이었고, 팀장님의 소소한 프로젝트라는 말에 속아(?) 서버 개발에 참여하게 되었다. 서버 개발은 나를 포함한 두 명이서 진행하게 되었고, 팀원 한분이 입사한 지 얼마 안 되어 필자가 리딩을 하게 되었다.

막상 참여해보니 코딩 자체가 양이 많거나 난이도가 있다기 보단 전반적인 프로세스를 이해하는데 애를 많이 먹었다. 회원가입, 기기변경, 계좌개설, 회원탈퇴 등의 굵직한 로직에 자연스레 녹아들어 가야 했기 때문이다. 또한 리딩의 경험이 많지 않았기에 부담을 느꼈다. 회사에서 필자가 경험한 선배 개발자들은 같이 일하는 구성원의 성장을 위해 많은 고민과 노력을 하셨다. 그런데 이제 그 역할을 내가 잘할 수 있을까? 란 의구심이 계속 들었다.

그렇게 고군분투하며 심사까지 통과하고 10월에 위의 기사와 함께 라이센스 취득에 성공하였다. 처음엔 필자를 낚은(?) 팀장님 원망도 종종 했지만, 그 덕에 나의 한계선을 돌파했다는 생각도 들었다. 또한 위에서 언급한 굵직한 로직들을 알게 되어 회사의 전반적인 이해도가 상승하여 업무에 도움이 되었다. 무엇보다도 같이 일한 팀원이 많이 배우고 도움이 되었다고 말씀해주셔서 큰 격려가 되었다.

if kakao 발표

2018년에 ifkakao를 참석하면서 큰 무대에서 기술 발표를 하고 싶다는 꿈을 가졌었다. 4년이라는 시간이 흘러 그 기회가 왔다. 사내 게시판에 ifkakao 연사 모집글이 올라왔고, 큰 고민 없이 지원했다. 그런데 갑작스러운 코로나 확진 증가로 인하여 코엑스에서 오프라인으로 진행하던걸 온라인으로 바뀌게 되어 중간에 그만둘까라는 고민도 했지만 어찌 되었든 얻는 게 있을 거라 생각하고 준비를 하게 되었다.

발표 준비를 하면서 깊게 공부하거나 생각하지 못한 부분이 발견되었다. 예를 들면 백엔드 이외의 DB나 Infra 쪽이다. 아무래도 담당팀에서 잘해주시니 관심을 못 가진 것 같다. 그러나 이러한 부분까지도 발표에 필요하니 자연스레 많이 배우고 성장한 것 같다. 담당팀에서도 적극적으로 지원을 해주셔서 양질의 발표자료를 만드는데 큰 도움이 되었다. 이외에도 주변 동료분들이 많이 도움을 주셨다. 발표 내용에 대해서도 좋은 피드백을 주시고, 발표 자료 PPT의 디자인을 봐주시고, 마지막으로 촬영 당일날 화장까지 도와주셨다. (우리 회사엔 좋은 동료가 참 많다.)

회사에서 수십만 원 상당의 1:1 스피치 교육을 지원해 주었다. 준비된 스크립트를 가지고 강사님 앞에서 발표를 하였는데 이때 스크립트, 말투, 전달력 등을 코칭해 주셨다. 큰 기대는 안 했는데, 발표뿐만 아니라 일상생활에서도 활용할만한 부분이 많은 것 같아 큰 도움이 되었다. ~~사투리에 대해서 피드백이 많았는데, 역시나 촬영할 때 까지도 고쳐지지 않았다~~

두 번의 리허설 촬영과 본 촬영을 끝으로 ifkakao 발표를 마쳤다. 배우고 성장한 것도 많지만 아쉬움이 남는 것도 사실이다. ifkakao가 시작이라고 생각한다. 다음 발표엔 좀 더 좋은 주제와 전달력으로 찾아가길 희망한다.

iOS 개발

2022년에 의외의 성과는 iOS 개발을 한 것이다. XCode에서부터 Swift 모든 게 낯설었지만, 그래도 개발 경험이 있어서 그런지 금방 적응해서 앱 하나를 만들었다. 새로운 언어를 배우고 낯선 개발을 경험해본 것이 기존에 사용하던 언어와 개발 방식에 대해 다시 생각해볼 기회를 마련해 줬다.

실용주의 프로그래머라는 책에선가 1년에 한 번은 새로운 언어를 배우라고 했던 기억이 있다. 내년에는 Go를 한번 공부해보고 싶다.

기술 서적

우리 팀은 기술서적 읽는 것을 즐기고, 그에 대한 토론과 논의를 좋아하는 것 같다. 그래서 올해도 다양한 책들을 함께 읽고 의견을 나누는 자리가 많았다.

- 만들면서 배우는 클린 아키텍처
- 구글 엔지니어는 이렇게 일한다
- 도메인 주도 설계 첫걸음

위의 책들을 같이 읽고 나누었고, 3 권 다 선한 영향을 준 책이다.

- 이펙티브 자바 Effective Java 3/E

- 엘레강트 오브젝트

- 에릭 에반스 DDD

- 데이터 중심 애플리케이션 설계

위의 책들은 개인적으로 읽은 책인데, 과거에 비해 많이 못 읽은 듯하다.

2023년에는 쌓아둔 책들을 다 읽는 한 해가 되었으면 좋겠다. 또한 그 책에서 얻는 인사이트를 블로그에 작성할 예정이다.

JPA를 이용하여 cursor 기반 페이징 구현

AlwaysPr — Sun, 29 Dec 2019 17:50:27 +0900

언젠가부터 무한 스크롤을 이용한 페이징 방식이 우리들에 스며들기 시작했다. 이는 과거의 1, 2, 3... 의 페이지를 클릭하여 다음 콘텐츠를 보는 것이 아니라, 페이스북처럼 마지막 콘텐츠를 보게 되면 다음 페이지가 로딩되어 보이는 것을 의미한다. 그러나 SNS에서는 일반적으로 사용하는 Offset 기반의 페이징을 사용하게 되면 문제가 생길 수 있다.

Offset Based Pagination

SELECT * FROM BOARDS ORDER BY ID DESC LIMIT 0, 10;
SELECT * FROM BOARDS ORDER BY ID DESC LIMIT 10, 10;
SELECT * FROM BOARDS ORDER BY ID DESC LIMIT 20, 10;

위의 쿼리를 해석해보면 최신 게시글의 0~10, 10~20, 20~30을 조회한다. 그러나 SNS처럼 실시간으로 많은 글이 올라오는 환경에서는 중복해서 컨텐츠가 노출될 수 있다. 이유는 다음과 같다.

첫번째 쿼리가 실행된 후 그 사이에 콘텐츠 하나가 추가가 되었다면, 두 번째 쿼리를 조회할 때 중복될 수가 있다. 즉 첫 번째 쿼리의 마지막 요소와 두 번째 쿼리의 첫 번째 요소는 동일한 결과가 나타나게 된다. 계속해서 이러한 문제가 생긴다면 사용자에게 부정적인 인식을 심어주게 될 것이다. 이러한 이슈를 Cursor 기반의 페이징으로 풀어나갈 수 있다.

Cursor Based Pagination

Cursor 기반의 페이징은 간단하게 말하자면 리스트를 조회할 때 내가 읽은 마지막 요소를 알려줌으로써 그 뒤의 값을 조회하는 것을 의미한다.

SELECT * FROM BOARDS ORDER BY ID DESC LIMIT 10;

SELECT * FROM BOARDS 
WHERE 
	ID < {이전에 조회한 마지막 id} 
ORDER BY 
	ID DESC LIMIT 10;

위의 쿼리를 해석해보면 최신 10개의 게시글을 조회하고, 이후에는 이전에 조회한 마지막 ID보다 작은 10개를 가져오게 된다.

ID가 1 ~ 30인 30개의 게시글이 있다고 생각해보자.

최초에는 ID가 30 ~ 21 인 게시글이 조회된다. 두번째 조회 시에 where절에 21을 넣게 되어 20~11이 조회된다. 세 번째도 비슷한 원리로 11을 넣게 되면 10~1이 조회된다.

원리는 이해했으니 Java코드로 풀어보자.

@Entity
public class Board {

    @Id
    @GeneratedValue(strategy = GenerationType.AUTO)
    private Long id;

    private String title;

    private String contents;

    private LocalDateTime createAt;
	//...
}

id, 제목, 내용, 생성일이 있는 간략한 게시글이다. 여기서 키포인트는 ID는 순차적이어야 한다는 것이다. 그래야 간편하게 Cursor 구현이 가능하다.

@RestController
@RequestMapping("/boards")
public class BoardController {

    private static final int DEFAULT_SIZE = 10;

    private final BoardService boardService;

    public BoardController(BoardService boardService) {
        this.boardService = boardService;
    }

    @GetMapping
    public CursorResult<Board> getBoards(Long cursorId, Integer size) {
        if (size == null) size = DEFAULT_SIZE;
        return this.boardService.get(cursorId, PageRequest.of(0, size));
    }

}

public class CursorResult<T> {
    private List<T> values;
    private Boolean hasNext;

    public CursorResult(List<T> values, Boolean hasNext) {
        this.values = values;
        this.hasNext = hasNext;
    }
	//...
}

Controller 또한 간단하다. 파라미터로 cursorId와 size를 받게된다. 여기서 주목해야 될 점은 PageRequest.of()의 첫 번째 파라미터는 무조건 0으로, 즉 최초의 페이지로 처리를 해야 한다.

Client 개발자와 소통할 때 다음 조회할 리스트가 존재하는지 내려주면 좀 더 효율적이다. 왜냐하면 불필요하게 한번 더 리스트를 조회할 필요가 없기 때문이다.

그래서 CursorResult에서는 게시글 정보와 다음 리스트가 존재하는지의 여부를 알려주는 hasNext를 내려준다.

@Service
public class BoardService {

    private final BoardRepository boardRepository;

    public BoardService(BoardRepository boardRepository) {
        this.boardRepository = boardRepository;
    }

    CursorResult<Board> get(Long cursorId, Pageable page) {
        final List<Board> boards = getBoards(cursorId, page);
        final Long lastIdOfList = boards.isEmpty() ?
                null : boards.get(boards.size() - 1).getId();

        return new CursorResult<>(boards, hasNext(lastIdOfList));
    }

    private List<Board> getBoards(Long id, Pageable page) {
        return id == null ?
                this.boardRepository.findAllByOrderByIdDesc(page) :
                this.boardRepository.findByIdLessThanOrderByIdDesc(id, page);
    }

    private Boolean hasNext(Long id) {
        if (id == null) return false;
        return this.boardRepository.existsByIdLessThan(id);
    }
}

1. 최초로 조회한 경우(cursorId가 null인 경우)

findAllByOrderByIdDesc()를 통하여 size만큼의 최신 게시글을 조회한다.

2. 최초가 아닌 경우 (유효한 cursorId가 들어오는 경우)

findByIdLessThanOrderByIdDesc()를 통하여 커서보다 낮은 게시글을 조회한다.

3. 다음에 조회될 게시글이 있는지 여부

existsByIdLessThan()를 통하여 판단한다.

혹시 이해가 잘안된다면 Test Code를 작성해 놓았으니 실행하여 확인해보면 좀 더 이해하기 편할 듯하다.

ID가 순차적이지 않으면 어떻게 될까?

어떠한 이유로 ID가 순차적이지 않고 UUID와 같이 비순차적이면 위의 방법은 크게 의미가 없어진다.

그래서 생성일을 기준으로 가져오는 방식을 생각해볼 수 있지만, 동일한 생성일을 가질 경우 데이터가 누락될 가능성이 있다. 그래서 ID값을 활용하여 이를 예방시켜보자.

SELECT * FROM BOARD 
ORDER BY 
	CREATE_AT DESC, ID DESC LIMIT 10;

SELECT * FROM BOARD 
WHERE 
	(CREATE_AT = {CREATE_AT} && ID < {ID}) OR 
	(CREATE_AT < {CREATE_AT}) 
ORDER BY 
	CREATE_AT DESC, ID DESC LIMIT 10;

위의 쿼리를 사용하면 ID가 순차적이지 않은 경우에도 Cursor Based Pagination을 사용할 수 있다.

Spring WebFlux는 어떻게 적은 리소스로 많은 트래픽을 감당할까?

AlwaysPr — Sat, 22 Jun 2019 11:16:29 +0900

위 그림은 DZone 게시글 중 하나인 Spring WebFlux를 이용한 Boot2와 Spring MVC를 이용한 Boot1을 비교한 그래프이다.

해당 그래프에서는 두 가지 특징을 볼 수 있다.

첫 번째로는 유저가 적을 때에는 성능에 별반 차이가 없다. 두 번째로는 유저가 늘어나면 늘어날수록 극명한 성능 차이를 보여주고 있다. 어떻게 이런 차이가 일어날 수 있을까?

본글은 아래의 구성을 가지고 있다.

I/O
Event-Driven
Spring Framework

먼저, 1과 2를 통해서 원리를 알아본 다음 3에서 이를 접목시켜서 위의 그래프가 나올수 있는 이유를 설명할 것이다.

I / O

Why was Spring WebFlux created?

Part of the answer is the need for a non-blocking web stack to handle concurrency with a small number of threads and scale with fewer hardware resources. – Spring Document

핵심만 말하자면 non-blocking을 통해서 적은 수의 리소스로 동시성을 다룬다는 것이다. I/O의 원리부터 시작해서 non-blocking에 대해서도 이해해보도록 하자.

사용자가 I/O 요청을 할 때 CPU가 I/O Controller에 요청을 하고 I/O Controller가 파일을 다 가져오면 그것을 Memory에 적재시키고 CPU에게 완료되었다고 알려준다. 즉 큰 그림은 CPU -> I/O Controller -> CPU의 형태이다.

핵심은 CPU가 I/O를 직접 가져오는 것이 아니라, 작은 CPU라고 불리는 I/O Controller가 수행한다는 이야기이다. 좀 더 나아가면 작업을 단순히 위임시키고 작업이 완료되는 동안에는 다른 일을 수행할 수 있다는 말이다. 이러한 예처럼 I/O를 처리하는데 몇 가지 방법이 있다.

Blocking I/O

가장 기본적인 I/O 모델이며 여러분들이 Spring MVC와 RDBMS를 사용하고 있으면 대부분 이 모델을 사용하고 있을 것으로 예상된다.

Application에서 I/O 요청을 한 후 완료되기 전까지는 Application이 Block이 되어 다른 작업을 수행할 수 없다. 이는 해당 자원이 효율적으로 사용되지 못하고 있음을 의미한다.

그러나 생각을 해보면 여러분들의 Application들은 Blocking 방식임에도 불구하고 마치 Block이 안된듯이 동작하는 것처럼 보인다. 이것은 여러분들이 Single Thread를 기반으로 하는 것이 아닌 Multi Thread를 기반으로 동작하기 때문이다. Block 되는 순간 다른 Thread가 동작함으로써 Block의 문제를 해소하였다. 그러나 Thread 간의 전환(Context Switching)에 드는 비용이 존재하므로 여러 개의 I/O를 처리하기 위해 여러 개의 Thread를 사용하는 것은 비효율적으로 보인다.

Synchronous Non-Blocking I/O

Application에서 I/O를 요청 후 바로 return되어 다른 작업을 수행하다가 특정 시간에 데이터가 준비가 다되었는지 상태를 확인한다. 데이터의 준비가 끝날 때까지 틈틈이 확인을 하다가 완료가 되었으면 종료된다.

여기서 주기적으로 체크하는 방식을 폴링(Polling) 이라고 한다. 그러나 이러한 방식은 작업이 완료되기 전까지 주기적으로 호출하기 때문에 불필요하게 자원을 사용하게 된다.

Asynchronous Non-blocking I/O

I/O 요청을 한 후 Non-Blocking I/O와 마찬가지고 즉시 리턴된다. 허나, 데이터 준비가 완료되면 이벤트가 발생하여 알려주거나, 미리 등록해놓은 callback을 통해서 이후 작업이 진행된다.

이전 두 I/O의 문제였던 Blocking이나 Polling이 없기 때문에 자원을 보다 더 효율적으로 사용할 수 있다.
(이후로는 편의상 Non-Blocking I/O라고 하겠다.)

Java 코드를 통해서 이를 이해해보자.

Blocking I/O

@Test
public void blocking() {
    final RestTemplate restTemplate = new RestTemplate();

    final StopWatch stopWatch = new StopWatch();
    stopWatch.start();

    for (int i = 0; i < 3; i++) {
        final ResponseEntity<String> response =
                restTemplate.exchange(THREE_SECOND_URL, HttpMethod.GET, HttpEntity.EMPTY, String.class);
        assertThat(response.getBody()).contains("success");
    }

    stopWatch.stop();

    System.out.println(stopWatch.getTotalTimeSeconds());
}

Spring의 HTTP 요청 라이브러리인 RestTemplate을 사용하여 3초가 걸리는 API를 3번 호출하였다. 결과는 여러분도 알다시피 9.xx초가 나온다. 이유는 I/O가 요청 중일 때에는 아무 작업도 할 수 없기 때문이다.

Non Blocking I/O

@Test
public void nonBlocking3() throws InterruptedException {
    final StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    for (int i = 0; i < LOOP_COUNT; i++) {
        this.webClient
                .get()
                .uri(THREE_SECOND_URL)
                .retrieve()
                .bodyToMono(String.class)
                .subscribe(it -> {
                    count.countDown();
                    System.out.println(it);
                });
    }

    count.await(10, TimeUnit.SECONDS);
    stopWatch.stop();
    System.out.println(stopWatch.getTotalTimeSeconds());
}

WebFlux에서 제공하는 WebClient를 사용해서 위와 동일하게 3초가 걸리는 API를 호출하였다. for문 안의 변수인 LOOP_COUNT는 100으로 코드상에서 설정되어있다. 3초 걸리는 API를 100번 호출한다 하더라도 3.xx초 밖에 걸리지 않는다. 더 나아가서 LOOP_COUNT를 1000으로 변경하더라도 필자의 컴퓨터에서는 4.xx초 밖에 걸리지 않는다. Blocking I/O와 비교해봤을 때 정말 효율적이라고 볼 수 있다.

만약, Blocking을 위처럼 많은 요청을 동시에 처리하려면 그 만큼의 Thread이 생성되어야 한다. 그러나 이렇게 처리한다 해도 Context Swiching에 의한 오버헤드가 존재할 것이다.

Event-Driven

시장 조사 기관 가트너는 비즈니스 업계가 주목해야 할 2018 10대 전략기술 트렌드를 발표했고, Event-Driven가 포함되어 있다. 또한 Event-Driven을 토대로 많은 프레임워크와 라이브러리가 발전하고 있다. Spring WebFlux, Node.js, Vert.x 등이 그에 따른 예이다. 우리가 자주 접하는 기술들에 어떻게 스며들어 접목이 되었는지에 대해서 살펴보자.

Event-Driven Programming은 프로그램 실행 흐름이 이벤트(ex : 마우스 클릭, 키 누르기 또는 다른 프로그램의 메시지와 같은 사용자 작업)에 의해 결정되는 프로그래밍 패러다임이다. Event가 발생할 때 이를 감지하고 적합한 이벤트 핸들러를 사용하여 이벤트를 처리하도록 설계됐다. 순차적으로 진행되는 과거의 프로그래밍 방식과는 달리 유저에 의해 종잡을 수 없이 진행되는 GUI(Graphical User Interface)가 발전됨에 따라 Event-Driven 방식은 더욱더 많이 쓰이게 되었다.

대표적으로 우리 자주 접할 수 있는 방식은 아래와 같은 Click Event이다.

아래는 Java를 이용하여 Click Event를 구현한 예이다.

JButton button = new JButton();
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("clicked");
    }
});

물론 Lambda Expression 사용하면 아래처럼 간결하게 표현이 가능하다.

JButton button = new JButton();
button.addActionListener(e -> System.out.println("clicked"));

우리는 Java 이외의 타 언어에서도 자연스럽게 Listener에 등록하여 Event를 구현하고 있다. 그런데 Button은 어떻게 유저에 의해 Click이 되었는지 인지할 수 있을까? 단순히 Listener에 등록하기만 하면 자동적으로 인지할까?

그렇지 않다.

과거로 돌아가 C언어로 키보드 Event를 핸들링하는 코드를 작성해보자.

int main(void){
    char key;
    while(1){
        key = getch();      // (1) 

        switch (key) {      // (2)
            case 1 : 실행문; break;
            case 2 : 실행문; break;
            case 3 : 실행문; break;
            case 4 : 실행문; break;
            default : 실행문; break;
        }
    }
    return 0;
}

위 코드는 두 가지 경우로 되어있다.
(1) 무한루프를 돌면서 사용자에 의해 Key가 눌러지는 것을 감지한다.
(2) 감지된 값을 토대로 해야 할 일을 알맞은 곳에서 처리한다.

이를 일반화시켜 말하면 다음과 같다.

Event Loop가 돌면서 Event를 감지한 뒤 Event Handler 또는 Event Listener에게 보내서 작업을 처리한다.

Java Swing에서는 내부적으로 어떻게 Event를 처리할까?

위의 c언어로 작성한 코드와 거의 동일하지 않은가? 단지 Event Queue만 추가되었을 뿐이다. 그러나 코드는 한편 간결해졌다.

JButton button = new JButton();
button.addActionListener(e -> System.out.println("clicked"));

일일이 Event를 제어했던 과거와는 달리 요즘은 이를 단순히 Listener에 행위만 등록해주면 간편하게 Event를 제어할 수 있다. 이는 Event Handle만이 관심의 대상이고 이에 집중할 수 있게 한다. 달리 말하면 Evevt Loop를 돌면서 요청을 감지하고 적합한 Handler에 위임해주는 부수적인 부분은 언어 레벨에서 처리를 해준다는 말이다.

이를 일반화하면 아래와 같은 이미지를 그릴 수 있다.

Event-Driven이라는 키워드가 언급되면 위의 이미지를 기억에서 꺼내면 된다.

그리고 이러한 Event 처리는 Server에도 적합하다. 왜냐하면 HTTP Request라는 Event가 발생하기 때문이다. 그래서 Node.js, Spring WebFlux, Vert.x 등은 Event-Driven 형태로 Architecture가 구현되어있다.

Spring Framework

위 그림처럼 Spring은 Reactive Stack과 Servlet Stack 두 가지 형태를 제공한다. 또한 Reactive Stack은 non-blocking I/O를 이용해서 많은 양의 동시성 연결을 다룰 수 있다고 한다. 과거로 돌아가서 Servlet Stack의 문제점을 파악하고 이를 어떻게 Reactive Stack으로 해결했는지 알아보자.

Spring MVC

위 그림처럼 유저들로부터 HTTP 요청이 들어올 때 요청들은 Queue를 통하게 된다. Thread pool이 수용할 수 있는 수(thread pool size)의 요청까지만 동시적으로 작업이 처리되고 만약 넘게 된다면 큐에서 대기하게 된다. 즉 하나의 요청은 하나의 Thread를 요구한다. (one request per thread model)

Thread pool은 다음과 같다. Thread를 생성하는 비용이 크기 때문에 미리 생성하여 재사용함으로써 효율적으로 사용한다. 그렇다고 과도하게 많은 Thread를 생성하는 것이 아니라 서버 성능에 맞게 Thread의 최대 수치를 제한시킨다. 참고로 tomcat default thread size는 200이다.

그런데 만약 대량의 트래픽이 들어와 thread pool size를 지속적으로 초과하게 된다면 어떻게 될까?

설정해놓은 thread pool size를 넘게 되면 위 그림처럼 작업이 처리될 때까지 Queue에서 계속해서 기다려야 한다. 그래서 전체의 대기시간이 늘어난다. 이런 현상을 Thread pool hell이라고 한다.

아래 사진은 Linkedin의 Thread pool hell 현상에 대한 그래프이다. Thread pool이 감당할 수 있는 요청수를 넘는 순간부터는 평소보다 수배나 많은 지연시간을 보여준다.

Thread pool이 감당할 수 있을 때까진 빠른 처리속도를 보이지만, 넘는 순간부터는 지연시간이 급격하게 늘어난다.

하나의 작업이 늦게 처리되는 부분에 대해서도 우린 고민해 볼 필요가 있다. 독자분들이 만든 코드가 보통 왜 느려지는가? 특수한 경우를 제외하면 DB, Network 등의 I/O가 일어나는 부분에서 아마 시간을 많이 소비했을 것이다.

설명했듯이 I/O 작업은 CPU가 관여하지 않는다. I/O Controller가 데이터를 읽어오고 이를 전달받을 뿐이다. 위에서 I/O를 처리하는 3가지 방식을 소개했는데 가장 효율이 좋은 방법은 마지막에 설명한 Asynchronous Non-blocking I/O이라고 하였다. Blocking 방식은 I/O Controller가 데이터를 읽는 동안 CPU가 아무 일도 할 수가 없고, Non-Blokcing방식은 polling 때문에 불필요하게 CPU를 소비한다고 했다.

Spring에서도 Non-blocking I/O를 이용해서 효율적으로 작업을 처리할 수 있는 방법을 제공한다. 그 수단이 WebFlux이다.

Spring WebFlux

위는 전반적인 WebFlux의 구조이다. 사용자들에 의해 요청이 들어오면 Event Loop를 통해서 작업이 처리가 된다. one request per thread model과의 차이점은 다수의 요청을 적은 Thread로도 커버할 수 있다. worker thread default size는 서버의 core 개수로 설정이 되어있다. 즉 서버의 core가 4개라면 worker thread는 4개라는 말이며 이 적은 Thread를 통해서도 traffic을 감당할 수 있다. 위에서 하나의 Thread로 3초가 걸리는 API 1000개를 호출했음에도 4초밖에 안 걸렸다는 걸 상기시키면 이해에 도움이 될 것이다. 또한 비슷한 Architecture를 가진 Node.js가 이미 증명을 하고 있다.

이렇듯 Non Blocking 방식을 활용하면 좀 더 효율적으로 I/O를 제어할 수 있고 성능에도 좋은 영향을 미친다. 특히나 유행하는 MSA에서는 수많은 Microservice가 거미줄처럼 서로를 네트워크를 통해서 호출하고 있다. 즉 많은 수의 Network I/O가 발생할 텐데 이를 Non Blocking I/O를 통해 좀 더 성능을 끌어올릴 수 있다.

그러나 물론 제한된 점이 있다. WebFlux로 성능을 최대치로 끌어올리려면 모든 I/O 작업이 Non Blocking 기반으로 동작해야 된다. Blocking이 되는 곳이 있다면 안 하느니만 못한 상황이 되어버린다.
예를 들어 멀티코어로 가정을 해보자. 그럼 처리할 수 있는 Thread는 2개인데 Blocking이 걸리는 API를 열명 이서 동시에 호출한다면 결국엔 Spring MVC처럼 8명이 I/O 작업이 끝날 때까지 기다려야 하는 구조가 되어버리기 때문이다.

What if you do need to use a blocking library? Both Reactor and RxJava provide the publishOn operator to continue processing on a different thread. That means there is an easy escape hatch. Keep in mind, however, that blocking APIs are not a good fit for this concurrency model. - Spring Document

대안으로 publicOn()을 사용하라고 하지만 마지막 문장 Blocking은 이 모델에 적합하지 않다고 한다.

Java 진영에는 아쉽게도 DB connection을 non-blokcing으로 지원하는 라이브러리가 널리 보급되어 잘 사용되지는 않고 있다. 다만 R2DBC처럼 개발이 진행 중인 라이브러리, 최근에 release된 jasync sql 등이 있으며, MongoDB, Redis 등의 NoSQL은 지원중이다. (피드백 주신 정상혁님 감사합니다.)

또한 소수의 Thread에 의해서 수많은 요청을 처리하고, 순서대로 작업이 처리되는 것이 아니라 Event에 기반하여 실타래가 엉킨 것처럼 작업이 처리되기 때문에 트래킹 하기에 힘이 들다는 문제가 있다.

그렇다면 성능이 좋으니 무조건 WebFlux를 사용해야 할까?
지금까지 필자의 글에 혹했다면 위의 질문처럼 잘못된 생각을 할 수도 있다.

위 그림은 Spring MVC나 Spring WebFlux 둘 다 성능이 동일한 구간이 있다. 서버의 성능이 좋으면 좋아질수록 해당 구간은 더 늘어날 것이다. 그렇기에 만약 여러분의 환경이 해당 구간이라면 굳이 사용할 필요가 없다. 또한 Spring Document에서는 동기 방식이 코드 작성, 이해, 디버깅하기 더 쉽다고 한다. 이 말은 즉 높은 생산성을 가진다는 말과 같은 것으로 보인다. 그렇기에 이해타산을 잘 따져서 선택해야 할 필요가 있다.

그리고 우리는 이제 왜 성능이 동일한 구간이 생기는 지를 알 수 있다. 저 구간은 바로 Thread Pool이 감당할 수 있을 정도의 요청이었기에 비동기적으로 잘 수행하다가 이후에는 Queue에 쌓여 점점 성능이 느려졌던 것이다.

'Spring WebFlux는 어떻게 적은 리소스로 많은 트래픽을 감당할까?'란 궁금증을 시작으로 여기까지 왔다. 이에 대한 답은 I/O를 Non Blockkng을 이용하여 잘 사용하는 것과 Request를 Event-Driven을 통해서 효율적으로 처리하기 때문에 가능하다.