spring boot & webflux & devOps

Toby + Spring Boot 4 + Claude Code 1

바람을타고2 — Sun, 5 Apr 2026 09:36:35 +0900

Toby 님이 Claude Code 와 Spring boot4 와 Nex.js 를 이용하여 apple reminder app 을 만드는 live 강좌 메모 입니다

github : https://github.com/tobyilee/tobyreminder

GitHub - tobyilee/tobyreminder

Contribute to tobyilee/tobyreminder development by creating an account on GitHub.

github.com

토비의 스프링 : 클로드 코드를 이용해 스프링 앱 개발하기 - Live 1

https://www.youtube.com/watch?v=gdg4DBcakIg

주제

~/.cluade 초기화

Apple Reminder App 개발

Baceknd : Spring Boot 4.0.x

Frontend : Nextjs

Mobile : RN(React Native)

Ghostty 고스티 터미널

brew install --cask ghostty

default font 가 구려서 변경

mkdir -p ~/.config/ghostty
sudo vi ~/.config/ghostty/config

font-family = JetBrainsMono Nerd Font
font-size = 14
font-feature = liga
font-family-fallback = Noto Sans CJK KR

Ghostty Terminal 의 장단점

장점

압도적인 성능 (GPU 가속): GPU를 사용하여 렌더링하기 때문에 대량의 텍스트가 출력되거나 복잡한 애니메이션이 실행될 때도 CPU 점유율이 낮고 반응 속도가 매우 빠릅니다.
내장된 멀티플렉싱: 별도의 tmux 없이도 탭과 분할 화면(Split Pane) 기능을 강력하게 지원합니다.
설정의 유연성: 텍스트 기반 설정 파일을 지원하여 버전 관리가 용이하며, 세밀한 커스터마이징이 가능합니다.

단점

Windows 미지원: 현재는 macOS와 Linux 위주로 개발되고 있어 Windows 사용자는 WSL 등을 통한 우회 사용이 필요합니다.

아래처럼 gemini cli 와 일반 터미널을 split 하여 사용할 수 있습니다

아래처럼 질문하여, build 툴을 정함

Java 는 아직 25가 없음

토비님왈 claude opus 4.6 model 이 java 25 를 학습하지 않아 이런것 같다고 추측 -> Java 17 (Recommended) 상태 임

그 외 패키지명도 물어보고, 샘플 엔티티/API 도 포함할 것인지 물어봄

취소하고, instrucation 을 변경

spring initializr 를 이용하여

Spring Boot 최신버전

JPA/H2/Lombok을 사용하는 프로젝트를 생성해줘

- Gradle Kotlin DSL

- package : toby.ai.tobyreminder

- project name : tobyreminder

-> 프로젝트 생성은 자주 하니, skills 를 만들어 재사용

## Skill

전에 했던 작업을 똑같이 반복할 때, 만들어 놓고 사용

spring initializr 이용하여 프로젝트 생성 등..

Java 21 을 사용하여, Java 25 를 사용하도록 다시 수정하도록 수정

Context7 은 이제 잘 안씀

build 해서 loading 해 보는데 port 8080 충돌로 실패함. ai 가 알아서 기존 사용하던 process 죽여도 되는지 물어봄

claude code cli 에서 idea . 으로 ide 를 실행함 신기...

accept edits on : project 내 파일은 ai 가 수정가능 끄면, 물어봄

/ide 명령어

파일 수정 후 diff 별 accept 를 ide 에서 할 수 있음

ai 개발 방법

prompt -> 개발 ( 간단한거에 사용)

prompt -> (code) plan -> 개발

promt -> prd.md (기능, 아키텍처, 데이터구조...) -> 개발

prompt -> spec (기능) -> (implmentation) plan -> task -> 단계적 개발 ( SDD )

JEP 485: Stream Gatherers

바람을타고2 — Mon, 29 Dec 2025 14:11:27 +0900

1. Gatherer란?

Gatherer는 스트림의 요소를 “수집(gather)”하여, 상태(state)를 유지하면서 0개 이상 결과를 방출하는 중간 연산 구성요소 입니다.

즉,

map보다 강력
collect보다 유연
중간 연산이지만 상태를 가질 수 있습니다

2. Stream Gatherers란 무엇인가?

2-1. 기존 Stream API의 한계

기존 Stream API는 다음 두 가지 연산만 제공했습니다.

중간 연산 (intermediate)
map, filter, flatMap 등 → 1:1 변환
종단 연산 (terminal)
forEach, reduce, collect 등 → Stream 종료

하지만 다음과 같은 패턴은 표현하기 어려웠습니다.

N개의 요소를 묶어서 처리 (windowing, batching)
이전 요소의 상태를 기억하며 다음 요소 처리
1개의 입력 → 0개 또는 여러 개 출력
flatMap + mutable state 조합 없이 상태 기반 변환

이 공백을 메우기 위해 등장한 것이 Stream Gatherers입니다.

Stream Pipeline 에서 활용

source → intermediate(map/filter) → gather(gatherer) → intermediate → terminal

3. Stream Gathers 를 image 와 diagram 으로 표현

https://medium.com/@umeshcapg/the-gathering-revolution-jdk-24s-stream-gatherers-explained-e8727dee6877

generated by Gemni

연산자 사용 예

Gatherers.windowFixed() example

Input:   [1]---[2]---[3]---[4]---[5]---[6]---[7]---[8]---[9]--->
          |     |     |     |     |     |     |     |     |
          v     v     v     v     v     v     v     v     v
Gatherer: [--- windowFixed(3) ---]
          |     |     |     |     |     |     |     |     |
          v     v     v     v     v     v     v     v     v
Output:  [1,2,3]------[4,5,6]------[7,8,9]------------------>

// windowFixed(3)
List<List<Integer>> windows = Stream.of(1, 2, 3, 4, 5, 6, 7, 8)
  .gather(Gatherers.windowFixed(3))
  .toList();

// 결과: [[1, 2, 3], [4, 5, 6], [7, 8]]

Gatherers.windowSliding() example

Input:   [1]---[2]---[3]---[4]---[5]---[6]---[7]---[8]---[9]--->
          |     |     |     |     |     |     |     |     |
          v     v     v     v     v     v     v     v     v
Gatherer: [--- windowSliding(3) ---]
          |     |     |     |     |     |     |     |     |
          v     v     v     v     v     v     v     v     v
Output:  [1,2,3]--[2,3,4]--[3,4,5]--[4,5,6]--[5,6,7]--[6,7,8]...

연속된 숫자가 overlap 되는 차이가 있음 windowSliding(3) vs windowFixed(3)

// windowSliding(3)
List<List<Integer>> slidingWindows = Stream.of(1, 2, 3, 4, 5)
  .gather(Gatherers.windowSliding(3))
  .toList();

// 결과: [[1, 2, 3], [2, 3, 4], [3, 4, 5]]

Gatherers.scan(Integer::sum) example

Input:   [1]---[2]---[3]---[4]---[5]---[6]--->
          |     |     |     |     |     |
          v     v     v     v     v     v
Gatherer: [--- scan(Integer::sum) ---]
          |     |     |     |     |     |
          v     v     v     v     v     v
Output:  [1]---[3]---[6]---[10]--[15]--[21]-->

1st : 1

2nd : 1+2 = 3

3rd : 1+2+3 = 6

4th : 1+2+3+4 = 10

...

  List<Integer> cumulativeSum = Stream.of(1, 2, 3, 4, 5, 6)
      .gather(Gatherers.scan(() -> 0, Integer::sum))
      .toList();

  System.out.println("출력: " + cumulativeSum);
  // 결과: [1, 3, 6, 10, 15, 21]

Gatherers.doubler example

// Gatherer doubler 정의
public class doubler {
  public static final Gatherer<Integer, Void, Integer> doubler =
      ofSequential(
          (state, element, downstream) -> downstream.push(element * 2)
      ); // state 는 불필요하여 사용하지 않음
}


// doubler 사용
List<Integer> doublerList =
      Stream.of(1, 2, 3)
          .gather(doubler)
          .toList();

System.out.println("doubler : 출력: " + doublerList);
// doubler : 출력: [2, 4, 6]

Gatherer distinctBy 예

Input Stream:  [foo]---[bar]---[baz]---[quux]--->
                |       |       |       |
                v       v       v       v
Gatherer:      [--- distinctBy(String::length) ---]
                |       |       |       |
                v       v       v       v
Output Stream: [foo]-----------------[quux]------->

코드 예1, distinct 정의

public class distinctby {
  static <T, U> Gatherer<T, ?, T> distinctBy(Function<? super T, ? extends U> keyExtractor) {
    Objects.requireNonNull(keyExtractor, "keyExtractor must not be null");

    return Gatherer.ofSequential(
        () -> new HashSet<U>(),
        Gatherer.Integrator.ofGreedy((seen, element, downstream) -> {
          U key = keyExtractor.apply(element); // 키 추출
          if (seen.add(key)) { // 처음 보는 키인가?
            return downstream.push(element); // 처음 이면 출력
          }
          return true;
        })
    );
  }
}

사용 예

// 사용 예 1
var distinctList = Stream.of("foo", "bar", "baz", "quux")
      .gather(distinctBy(String::length))
      .toList();

System.out.println("distinctBy : 출력: " + distinctList);
// distinctBy : 출력: [foo, quux]

사용 예2, 나이별 1명 씩 distinct

// 사용 예2 : 나이별 1명 씩 distinct
record User(String id, String name, int age) {}

List<User> users = List.of(
    new User("1", "Alice", 25),
    new User("2", "Bob", 30),
    new User("3", "Charlie", 25),
    new User("4", "Diana", 35)
);

List<User> uniqueByAge = users.stream()
    .gather(distinctBy(User::age))
    .toList();

System.out.println("uniqueByAge : 출력: " + uniqueByAge);
// uniqueByAge : 출력: [User[id=1, name=Alice, age=25], 
//                     User[id=2, name=Bob, age=30], 
//                     User[id=4, name=Diana, age=35]]

위의 예제를 확인할 수 있는 github repository 입니다.

github : https://github.com/gwagdalf/gather-example

GitHub - gwagdalf/gather-example: Code example of Java 24’s Gather Stream API

Code example of Java 24’s Gather Stream API. Contribute to gwagdalf/gather-example development by creating an account on GitHub.

github.com

Visualizing the Gatherer Process

제공되는 메소드들

카테고리메소드

Category	Method
Windowing	windowFixed, windowSliding
Folding	fold, scan
Filtering	filtering, takeWhile, dropWhile
Mapping	mapConcurrent
Control	step 기반 sliding

official docs : https://docs.oracle.com/en/java/javase/24/docs/api/java.base/java/util/stream/Gatherers.html

Gatherers (Java SE 24 & JDK 24)

Returns a Gatherer that performs an ordered, reduction-like, transformation for scenarios where no combiner-function can be implemented, or for reductions which are intrinsically order-dependent. Returns a Gatherer that gathers elements into windows -- enc

docs.oracle.com

발전 단계

JEP 번호	JDK 버전	제목	주요 변경 사항
JEP 461	JDK 22	Stream Gatherers (Preview)	Stream API에 사용자 정의 중간 연산 기능 도입 https://openjdk.org/jeps/461
JEP 473	JDK 23	Stream Gatherers (Second Preview)	피드백 반영 및 API 조정 https://openjdk.org/jeps/473
JEP 485	JDK 24	Stream Gatherers	최종. API 변경 없이 기능 확정 https://openjdk.org/jeps/485

JEP 510: Key Derivation Function API

바람을타고2 — Mon, 29 Dec 2025 12:29:18 +0900

암호화 키 생성하기 위한 표준 API

KeyDerivationFunction(KDF) 란

: 하나의 비밀값(입력 키 재료, IKM)을 받아, 규칙에 따라 새로운 암호 키를 파생하는 함수

기존 문제점
기존 Java 암호 API에서
PBKDF2, HKDF, TLS KDF 등 KDF 종류별 API가 제각각
SecretKeyFactory, Mac, MessageDigest를 조합해야 함
알고리즘마다 입력 파라미터 구조가 달라 실수하기 쉬움
최신 표준(KDF in TLS 1.3, PQC 등)과의 연계가 복잡

추가로, 양자 컴퓨팅의 출현으로 기존 암호화 알고리즘이 공격에 취약해짐에 따라, Java 플랫폼이 양자 공격에 저항하는 Post-Quantum Cryptography(PQC)를 지원하는 것이 필수적입니다. JEP 510의 KDF API는 Hybrid Public Key Encryption(HPKE) 구현을 위한 핵심 빌딩 블록 중 하나

JEP 478 / 510의 목표
모든 KDF를 하나의 일관된 API로 제공

개념/역할/코드예

개념	역할	코드 예
KeyDerivationFunction	KDF 알고리즘 엔진	KDF hkdf = KDF.getInstance("HKDF")
KDFParameterSpec	알고리즘별 파라미터	HKDFParameterSpec spec = HKDFParameterSpec.ofExtract() .addSalt("some salt".getBytes()) .thenExpand("context info".getBytes(), 32);
SecretKey	최종 파생 키	SecretKey key = hkdf.deriveKey(ikm, spec);

코드 예

HKDF ( HMAC-based Extract-and-Expand Key Derivation Function )

import javax.crypto.KDF;
import javax.crypto.SecretKey;
import javax.crypto.spec.HKDFParameterSpec;
import javax.crypto.spec.SecretKeySpec;

byte[] ikmBytes = "shared secret".getBytes();
SecretKey ikm = new SecretKeySpec(ikmBytes, "HKDF");
KDF hkdf = KDF.getInstance("HKDF");

HKDFParameterSpec spec =
  HKDFParameterSpec.ofExtract()
    .addSalt("some salt".getBytes())
    .thenExpand("context info".getBytes(), 32);

SecretKey key = hkdf.deriveKey(ikm, spec);

* HMAC : Hash-based Message Authentication Code ; 해시 함수와 비밀 키를 결합해 메시지의 무결성과 인증을 검증하는 암호학적 알고리즘

PBKDF2 ( Password-Based Key Derivation Function 2)

import javax.crypto.KDF;
import javax.crypto.SecretKey;
import javax.crypto.spec.PBKDF2ParameterSpec;
import javax.crypto.spec.SecretKeySpec;

char[] password = "password".toCharArray();
byte[] salt = "salt".getBytes();

SecretKey baseKey = 
  new SecretKeySpec(new String(password).getBytes(),"PBKDF2");

PBKDF2ParameterSpec spec =
  new PBKDF2ParameterSpec(salt,100_000,256,"HmacSHA256");

KDF pbkdf2 = KDF.getInstance("PBKDF2");

SecretKey derivedKey = pbkdf2.deriveKey(baseKey, spec);

JEP 번호	JDK 버전	제목	설명
JEP 478	JDK 24	Key Derivation Function API (Preview)	Preview https://openjdk.org/jeps/478
JEP 510	JDK 25	Key Derivation Function API	Standard https://openjdk.org/jeps/510

JEP 497: Quantum-Resistant Module-Lattice-Based Digital Signature Algorithm (ML-DSA)

바람을타고2 — Sun, 28 Dec 2025 18:10:42 +0900

Java 24에 도입되었으며, 양자컴퓨터 시대에도 안전한 디지털 서명을 위한 Module-Lattice-Based Digital Signature Algorithm (ML-DSA)을 JDK 표준 API로 제공합니다

JEP 497은 이 알고리즘을 Java의

KeyPairGenerator
Signature
KeyFactory

API로 네이티브 제공함으로써 외부 라이브러리 없이도 안전한 서명을 가능하게 합니다

대표 적인 사용 예

도메인 공인 인증서가 아닌, 사설 인증서를 사용하고, 그 사설 인증서가 MS-DSA 를 사용하는 경우

만약 사내 용도의(Fusion) API 를 호출해야 하고, 그 사이트의 Internal 인증서가 ML-DSA 를 사용하는 경우

cf : 도메인 공인된 인증서 CA 발급기관 ( DigiCert, Sectgo, GeoTrust, Thawte)

관련 : https://ride-wind.tistory.com/161

JEP 496: Quantum-Resistant Module-Lattice-Based Key Encapsulation Mechanism

양자 컴퓨터의 발전은 기존의 RSA나 ECC 같은 공개키 암호화 체계를 무력화할 수 있는 잠재적 위협이 되고 있습니다.이에 대응하기 위해 JDK 24 에서 양자 내성 암호(Post-Quantum Cryptography, PQC) 기술인

ride-wind.tistory.com

1. 코드 예

KeyPair 생성

import java.security.KeyPair;
import java.security.KeyPairGenerator;
import java.security.spec.NamedParameterSpec;

public class MLDSAKeyGen {
  public static void main(String[] args) throws Exception {
    // 1) KeyPairGenerator 인스턴스 생성: 파라미터 세트 명시
    KeyPairGenerator kpg = KeyPairGenerator.getInstance("ML-DSA");
    kpg.initialize(NamedParameterSpec.ML_DSA_65); // ML-DSA-65 (기본 수준)

    // 2) 키 쌍 생성
    KeyPair kp = kpg.generateKeyPair();

    System.out.println("Generated keys:");
    System.out.println("  Public  : " + kp.getPublic());
    System.out.println("  Private : " + kp.getPrivate());
  }
}

ML-DSA-44
ML-DSA-65 (기본)
ML-DSA-87

메시지에 서명(Sign)

import java.security.PrivateKey;
import java.security.Signature;
import java.nio.charset.StandardCharsets;

public class MLDSASign {
  public static byte[] signMessage(PrivateKey priv, String message) throws Exception {
    // 1) Signature 인스턴스 생성
    Signature signer = Signature.getInstance("ML-DSA");

    // 2) PrivateKey로 서명 초기화
    signer.initSign(priv);

    // 3) 메시지를 바이트로 제공
    byte[] msgBytes = message.getBytes(StandardCharsets.UTF_8);
    signer.update(msgBytes);

    // 4) 실제 서명 생성
    return signer.sign();
  }
}

서명 검증(Verify)

import java.security.PublicKey;
import java.security.Signature;

public class MLDSAVerify {
  public static boolean verifySignature(PublicKey pub, byte[] signature, String message) throws Exception {
    Signature verifier = Signature.getInstance("ML-DSA");

    // public key로 검증 초기화
    verifier.initVerify(pub);

    // 메시지를 다시 공급
    verifier.update(message.getBytes(StandardCharsets.UTF_8));

    // 서명 검증
    return verifier.verify(signature);
  }
}

키 인코딩/디코딩(Optional)

import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.spec.PKCS8EncodedKeySpec;

public class MLDSAKeyFactory {
  public static PrivateKey decodePrivate(byte[] encoded) throws Exception {
    KeyFactory factory = KeyFactory.getInstance("ML-DSA");
    PKCS8EncodedKeySpec p8spec = new PKCS8EncodedKeySpec(encoded);
    return factory.generatePrivate(p8spec);
  }
}

JEP 496 vs JEP 497

항목	JEP 496 (ML-KEM)	JEP 497 (ML-DSA)
이름	Key Encapsulation	Digital Signature
목적	대칭 키 안전 교환	디지털 서명 및 검증
표준	NIST FIPS 203	NIST FIPS 204
주요 API	KeyPairGenerator, KEM, KeyFactory	KeyPairGenerator, Signature, KeyFactory
Parameter Sets	ML-KEM-512/768/1024	ML-DSA-44/65/87
양자 저항성	✔	✔
TLS 지원	향후 도입 예정	향후 도입 예정
Java 버전	JDK 24	JDK 24
기본 키	비대칭 키 래핑	서명 생성/검증
link	https://openjdk.org/jeps/496	https://openjdk.org/jeps/497

JEP 496: Quantum-Resistant Module-Lattice-Based Key Encapsulation Mechanism

바람을타고2 — Sun, 28 Dec 2025 10:42:33 +0900

양자 컴퓨터의 발전은 기존의 RSA나 ECC 같은 공개키 암호화 체계를 무력화할 수 있는 잠재적 위협이 되고 있습니다.

이에 대응하기 위해 JDK 24 에서 양자 내성 암호(Post-Quantum Cryptography, PQC) 기술인 ML-KEM과 ML-DSA를 도입했습니다

01. 코드 예

Key pair 생성

import java.security.*;
import java.security.spec.NamedParameterSpec;

public class MLKEMKeyGen {
  public static void main(String[] args) throws Exception {
    // ① 기본 ML-KEM-768 파라미터로 KeyPair 생성
    KeyPairGenerator g1 = KeyPairGenerator.getInstance("ML-KEM");
    KeyPair kp1 = g1.generateKeyPair();

    // ② ML-KEM-512 파라미터 지정
    KeyPairGenerator g2 = KeyPairGenerator.getInstance("ML-KEM");
    g2.initialize(NamedParameterSpec.ML_KEM_512);
    KeyPair kp2 = g2.generateKeyPair();

    // ③ ML-KEM-1024 직접 지정
    KeyPairGenerator g3 = KeyPairGenerator.getInstance("ML-KEM-1024");
    KeyPair kp3 = g3.generateKeyPair();

    System.out.println("Generated ML-KEM public keys:");
    System.out.println(kp1.getPublic());
    System.out.println(kp2.getPublic());
    System.out.println(kp3.getPublic());
  }
}

default 768 이며, TLS 등 일반 서버-클라이언트용, 1024 가 가장 높은 보안 강도

Key Encapsulation , 송신측

import javax.crypto.KEM;
import javax.crypto.SecretKey;

public class MLKEMEncapsulate {
  public static void main(String[] args) throws Exception {
    KeyPairGenerator g = KeyPairGenerator.getInstance("ML-KEM");
    KeyPair kp = g.generateKeyPair();

    // KEM 객체 가져오기 (기본 ML-KEM-768)
    KEM kemSend = KEM.getInstance("ML-KEM");

    // 공개키를 이용하여 Encapsulator 생성
    KEM.Encapsulator enc = kemSend.newEncapsulator(kp.getPublic());

    // 캡슐화: 공유 비밀키와 메시지 획득
    KEM.Encapsulated result = enc.encapsulate();

    byte[] encapsulationMessage = result.encapsulation();
    SecretKey sharedKeySender = result.key();

    System.out.println("Encapsulated message length: " + encapsulationMessage.length);
    System.out.println("Sender's shared secret: " + sharedKeySender);
  }
}

Key Decapsulation, 수신측

import javax.crypto.KEM;
import javax.crypto.SecretKey;

public class MLKEMDecapsulate {
    public static void main(String[] args) throws Exception {
        // 캡슐화 메시지가 sender에서 넘어왔다고 가정
        byte[] encapsulatedMessage = /* received bytes */;

        // 비밀키를 알고 있는 수신자 KEM 객체 생성
        KEM kemRecv = KEM.getInstance("ML-KEM");
        KEM.Decapsulator dec = kemRecv.newDecapsulator(privateKeyFromSender);

        SecretKey sharedKeyReceiver = dec.decapsulate(encapsulatedMessage);

        System.out.println("Receiver's shared secret: " + sharedKeyReceiver);
    }
}

Encoding/Decoding Key

import java.security.*;
import java.security.spec.*;

public class MLKEMKeyEncoding {
  public static void main(String[] args) throws Exception {
    KeyPairGenerator g = KeyPairGenerator.getInstance("ML-KEM");
    KeyPair kp = g.generateKeyPair();

    KeyFactory keyFactory = KeyFactory.getInstance("ML-KEM");

    // PrivateKey → PKCS#8 (표준 바이트 포맷,Encoding)
    PKCS8EncodedKeySpec pkcs8 = keyFactory.getKeySpec(kp.getPrivate(), PKCS8EncodedKeySpec.class);

    // PKCS#8 → PrivateKey ( Decoding )
    PrivateKey privateKey2 = keyFactory.generatePrivate(pkcs8);

    // PublicKey → X.509 ; X.509 표준포멧 으로 변환
    X509EncodedKeySpec x509 = keyFactory.getKeySpec(kp.getPublic(), X509EncodedKeySpec.class);

    // X.509 → PublicKey : Decoding
    PublicKey publicKey2 = keyFactory.generatePublic(x509);

    System.out.println("Encoded PrivateKey size: " + pkcs8.getEncoded().length);
    System.out.println("Encoded PublicKey size: " + x509.getEncoded().length);
  }
}

Encapsulation/Decapsulation vs Encoding/Decoding

구분	Key Encapsulation/Decapsulation	Key Encoding/Decoding
목적	안전한 채널에서 비밀 키 교환	키를 저장하거나 전송하기 위한 직렬화
참여자	송신자 + 수신자 (2명 이상)	단일 사용자 (1명)
결과물	공유 비밀 키 (Shared Secret)	바이트 배열 (Byte Array)
사용 시점	통신 시작 시 키 교환 단계	키를 파일에 저장하거나 네트워크로 전송할 때
보안 강도	양자 저항성 (Quantum-Resistant)	단순한 인코딩 형식(X.509, PKCS#8) 또는 Base64
API	`KEM` 클래스 사용	`KeyFactory` 클래스 사용

Encoding/Decoding 은 왜하나?

생성한 Key 를 Vault/DB 에 저장하거나, Network 전송 하기 위해, 객체 상태의 Key 를 표준 Byte Array(PKCS#8, X.509)를 사용하여 Encoding 함

2. 배경: 왜 양자 내성 암호가 필요한가요?

현재 우리가 사용하는 RSA나 Elliptic Curve(EC) 암호 체계는 거대한 정수의 소인수분해나 이산 로그 문제에 기반합니다.

하지만 충분한 성능을 가진 양자 컴퓨터가 등장하면 쇼어 알고리즘(Shor's algorithm)을 통해 이 암호들을 순식간에 풀 수 있게 됩니다.

이를 방지하기 위해 NIST(미국 국립표준기술연구소)에서 선정한 차세대 알고리즘들을 Java에 구현한 것이 바로 JEP 496과 497입니다.

중첩(Superposition)을 통한 동시 탐색

디지털 컴퓨터(비트): 그림의 왼쪽처럼 0 또는 1의 확정된 상태만을 가집니다. 3비트 데이터(000~111, N8) 중 하나를 찾으려면 최악의 경우 8번의 연산을 통해 하나하나 확인해야 합니다.
양자 컴퓨터(큐비트): 0과 1의 상태를 동시에 가질 수 있는 중첩 상태를 이용합니다. 3개의 큐비트가 있다면, 연산이 시작되는 시점에 이미 $2^3 = 8$가지의 모든 가능성을 동시에 가지고 있습니다.

양자 간섭(Quantum Interference)을 이용한 확률 조절

이미지의 오른쪽 하단 표를 보면 '상태'와 '확률' 변화가 핵심입니다. 양자 컴퓨터는 단순히 모든 답을 나열하는 것이 아니라, 연산을 반복할수록 정답일 확률은 높이고 오답일 확률은 낮추는 과정을 거칩니다.

초기 상태: 모든 상태(000~111)가 동일한 확률을 가지고 섞여 있습니다.
1회 양자 연산: 특정 알고리즘(예: 그로버 알고리즘)을 적용하여 정답인 '110' 상태의 확률 폭(진폭)을 증폭시킵니다. 이미지 표에서 1회 연산 후 '110'의 확률이 0.77로 급격히 상승한 것을 볼 수 있습니다.
2회 양자 연산: 같은 과정을 한 번 더 반복하면 정답 '110'의 확률이 0.95까지 올라갑니다.

검색에 특화된 그로버(Grover) 알고리즘의 원리에 따르면, 찾고자 하는 데이터의 전체 개수가 $N$개일 때 약 $\sqrt{N}$번의 연산만으로 정답을 찾을 수 있습니다

3. JEP 496: ML-KEM (키 메커니즘)

ML-KEM(Module-Lattice-Based Key-Encapsulation Mechanism)은 격자 기반(Lattice-based) 암호화 알고리즘입니다.

양자 컴퓨터의 위협에 대응하기 위해 설계된 양자 내성 암호(Post-Quantum Cryptography, PQC) 표준 알고리즘입니다

격자 기반 암호(Lattice-based)

ML-KEM은 격자 이론의 난제 중 하나인 MLWE(Module Learning With Errors) 문제에 기반합니다.

LWE(Learning With Errors): 행렬 $A$와 벡터 $s$, 그리고 아주 작은 오차(noise) 벡터 $e$가 있을 때, $b = As + e$ 결과값만 보고 비밀 값인 $s$를 찾아내는 문제입니다. 오차가 없다면 단순 연산으로 풀리지만, 오차가 섞이는 순간 계산 복잡도가 기하급수적으로 증가합니다.
Module-LWE: 일반 LWE보다 효율성을 높인 버전입니다. 데이터를 '모듈'이라는 구조로 묶어 처리함으로써, 보안성을 유지하면서도 키의 크기를 줄이고 연산 속도를 획기적으로 높였습니다.

격자(Lattice)란 공간에서 점들이 규칙적으로 반복 배치된 구조입니다

수학적으로는 몇 개의 기저 벡터(basis vectors) 를 정수 배로 조합해 만들 수 있는 모든 점들의 집합

위의 그림은 2개의 기저 벡터 b1, b2

모든 점들을 아래처럼 기저 벡터 b1 과 b2 로 표현가능

2·b₁ + 3·b₂
-1·b₁ + 4·b₂

b3는

b₃ = a·b₁ + c·b₂  (a, c는 정수)

노이즈(오차) x 를 살짝 섞어 주는 방식

격자에 매우 가까운점 x 가 주어졌을 때 x 와 가장 가까운 격자점 b3 를 찾아라

x = b₃ + e

알고리즘이 변경된 것이므로 동작방식은 기존의 비대칭키 암호화 방식과 동일합니다

알고리즘 작동 방식 (KEM)

ML-KEM은 데이터를 직접 암호화하는 방식이 아니라, 대칭 키 암호(AES 등)에 사용할 공유 비밀키(Shared Secret)를 안전하게 전달하는 '키 캡슐화 매커니즘'입니다.

키 생성 (KeyGen): 수신자가 공개키와 비밀키를 생성합니다.
캡슐화 (Encapsulate): 송신자가 수신자의 공개키를 사용하여 임의의 '공유 비밀키'를 생성하고, 이를 암호화(캡슐화)하여 보냅니다.
역캡슐화 (Decapsulate): 수신자가 자신의 비밀키로 캡슐을 풀어 동일한 '공유 비밀키'를 얻습니다.

이후 양측은 이 공유된 키를 사용해 AES 등으로 본문을 암호화합니다.

Public Key: 공개되어도 OK
Ciphertext: 공개되어도 OK
Shared Secret Key: 절대 공개 ❌

4. 국가사이버보안센터, 마스터플랜

양자 大전환 시대 대비, 관계부처 합동 마스터플랜 발표

https://www.ncsc.go.kr:4018/main/cop/bbs/selectBoardArticle.do?bbsId=Notification_main&nttId=59449&pageIndex=5&searchCnd2=%EB%B3%B4%EB%8F%84%EC%9E%90%EB%A3%8C

국가사이버안보센터

국제 및 국가배후 해킹 조직 관련 사이버위협 예방·대응, 보안적합성·암호모듈 검증제도 등 정보수록

www.ncsc.go.kr:4018

양자내성암호 전환 추진 로드맵

JEP 496 vs JEP 497

항목	JEP 496 (ML-KEM)	JEP 497 (ML-DSA)
이름	Key Encapsulation	Digital Signature
목적	대칭 키 안전 교환	디지털 서명 및 검증
표준	NIST FIPS 203	NIST FIPS 204
주요 API	KeyPairGenerator, KEM, KeyFactory	KeyPairGenerator, Signature, KeyFactory
Parameter Sets	ML-KEM-512/768/1024	ML-DSA-44/65/87
양자 저항성	✔	✔
TLS 지원	향후 도입 예정	향후 도입 예정
Java 버전	JDK 24	JDK 24
기본 키	비대칭 키 래핑	서명 생성/검증
link	https://openjdk.org/jeps/496	https://openjdk.org/jeps/497

JEP 511: Module Import Declarations

바람을타고2 — Sat, 27 Dec 2025 11:15:33 +0900

모듈 전체를 한 줄로 가져오는 import 구문

import module ModuleName;

코드 사용 예

// 변경 전
import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;

String[] fruits = new String[] { "apple", "berry", "citrus" };
Map<String, String> m =
    Stream.of(fruits)
        .collect(Collectors.toMap(s -> s.toUpperCase().substring(0,1),
                Function.identity()));
                
// 변경 후, module import
import module java.base;

String[] fruits = new String[] { "apple", "berry", "citrus" };
Map<String, String> m =
    Stream.of(fruits)
        .collect(Collectors.toMap(s -> s.toUpperCase().substring(0,1),
                Function.identity()));

java.base 모듈에 Map, Function, Collectors, Stream 등 54개의 패키지를 import 하는 효과가 있습니다

https://docs.oracle.com/en/java/javase/25/docs/api/java.base/module-summary.html

java.base (Java SE 25 & JDK 25)

Defines channels, which represent connections to entities that are capable of performing I/O operations, such as files and sockets; defines selectors, for multiplexed, non-blocking I/O operations. Defines charsets, decoders, and encoders, for translating b

docs.oracle.com

코드 예, 중복되는 경우

중복되는 모듈은 명확하게 표시해야 합니다

import module java.base;      // java.util.List 인터페이스 포함
import module java.desktop;   // java.awt.List 클래스 포함
import java.util.List;         // java.util.List를 명시적으로 임포트하여 충돌 해결

List<String> myList = new ArrayList<>(); // java.util.List로 결정됨

주요 module 들

https://docs.oracle.com/en/java/javase/21/docs/api/

Overview (Java SE 21 & JDK 21)

This document is divided into two sections: Java SE The Java Platform, Standard Edition (Java SE) APIs define the core Java platform for general-purpose computing. These APIs are in modules whose names start with java. JDK The Java Development Kit (JDK) AP

docs.oracle.com

발전단계

JEP 번호	JDK 버전	제목
JEP 476	JDK 23	Module Import Declarations (Preview) https://openjdk.org/jeps/476
JEP 494	JDK 24	Module Import Declarations (Second Preview) https://openjdk.org/jeps/494
JEP 511	JDK 25	Module Import Declarations https://openjdk.org/jeps/511

Lingma - Alicloud coding Assitant

바람을타고2 — Tue, 23 Dec 2025 16:08:14 +0900

Alicloud - AI Coding Assistant Lingma

https://www.alibabacloud.com/en/product/lingma?_p_lc=1

Lingma: AI Coding Assistant - Alibaba Cloud

An AI coding assistant that helps developers code faster and more easily

www.alibabacloud.com

Jetbrain plugin

https://plugins.jetbrains.com/plugin/17809-lingma--alibaba-cloud-ai-coding-assistant

visual studio code plugin

https://marketplace.visualstudio.com/items?itemName=Alibaba-Cloud.tongyi-lingma

Lingma - Alibaba Cloud AI Coding Assistant - Visual Studio Marketplace

Extension for Visual Studio Code - Type Less, Code More

marketplace.visualstudio.com

뜻

Qwen Tongyi Lingma

通义灵码 통이링마

통의 범용적 지식, 통할통

옳을의

영리할 리

마 : 코드 마

Visual Studio code plugin 설치 시 English 지원

Jetbrain 설치 시 언어를 변경할 수 있음

기본 설정은 중국어

설정 > 기타설정 > Lingma 에서 언어 변경

English 로 변경 됨

Opt out

Alibaba Cloud의 기본 원칙
Enterprise / Logged-in 계정 사용 시고객 코드 및 입력 데이터는 모델 학습에 사용하지 않음이 기본 정책

https://www.alibabacloud.com/help/en/legal/latest/alibaba-cloud-international-website-privacy-policy

Alibaba Cloud International Website Privacy Policy - Legal - Alibaba Cloud Documentation Center

This Privacy Policy applies to the access and use of the Alibaba Cloud International Website currently located at www.alibabacloud.comand the Alibaba Cloud International Marketplace Platform currently located at https://marketplace.alibabacloud.com/(the

www.alibabacloud.com

그래도 불안하다면,

Enable Cloud Model 을 꺼서, 정보를 보내지 않는다

Ask / Agent Mode 에서 웹 도구 차단

Web tools: Ask every time
MCP tools in Agent mode: Ask every time
Terminal in Agent mode: Ask every time

~/.lingma/config.json 에서 추가

{
  "telemetry": false,
  "enableDataCollection": false
}

Java 25 Performance Improvement

바람을타고2 — Sun, 21 Dec 2025 11:18:25 +0900

출처 : https://www.youtube.com/watch?v=223_7r0H6OE

JDK 21 -> JDK 25 upgrade 시

Latency 10% 향상

Throughtput 5% 향상

Critical JOPS: 시스템의 지연 시간(Latency)을 나타내는 수치
Max JOPS: 시스템의 전체적인 처리량(Throughput)을 나타내는 수치

SPECjbb(Standard Performance Evaluation Corporation Java Business Benchmark)는 자바 비즈니스 로직 성능을 평가하기 위한 도구
SPECjbb2015 : 2015년에 성능 평가도구가 개발되었음

아래 그림에서 보듯이 JDK 17 -> 21 때는 성능 개선이 미미 했으나,

JDK 21 -> 25 는 괄목한 성과가 있었음

성능 개선 이유

01. 컴팩트 객체 헤더 (Compact Object Headers): 자바 객체가 차지하는 메모리 공간을 줄여 CPU 캐시 효율을 높이고 가비지 컬렉션(GC) 부담을 줄였습니다.

02. 가상 스레드 및 스케줄러 개선: JDK 21에서 정식 도입된 가상 스레드의 관리 효율이 JDK 25에서 더욱 정교해졌습니다.

03. Stable Values 도입: 변하지 않는 값을 더 빠르게 읽을 수 있도록 하는 내부 최적화가 적용되어 전체적인 실행 속도가 빨라졌습니다.

성능 항상 JEP lists

HotSpot JVM

JFR Java Flight Recorder

518: JFR Cooperative Sampling (25)

- JFR 스택 추적 샘플링 방식은 스레드에 신호를 보내 강제로 멈추게 하는 방식(Signal-Base)였으나 이를 Cooperative 방식으로 전환

- 신호 overhead 감소

509: JFR CPU-Time Profiling (Experimental) (25)

- JFR profiling 은 실제 경과 시간(Wall-clock time) 기준이였으나, 실제 CPU 를 점유한 순수 CPU 사용 시간 추가

- 병목 지점 파악에 유리

520: JFR Method Timing & Tracing (25)

- 얼마나 자주 실행되고, 각 실행에 얼마나 시간이 걸리는지 매우 낮은 비용으로 추적할 수 있음

Garbage Collectors

521: Generational Shenandoah (25)

- 기존 단일 세대(Non-generational) 로 운영되던 Shenedoah GC 에 세대별 수집(Generation)모드 추가

- Old 보다 Young Generation 이 생성과 소멸이 많으므로 이를 나누어 수집하여, 메모리 사용과 처리량을 높임

475: Late Barrier Expansion for G1 (24)

- G1 GC 의 Barrier code 생성 시점을 C2 JIT 마지막 단계로 지연 -> GC 구현이 단순해지고, 유지보수 개선 효과

423: Region Pinning for G1 (22)

- G1 GC 에서 메모리 영역을 고정(Pinning)할 수 있는 기능

- GC 대기 시간 지연을 획기적으로 줄이고, OOM 오류를 방지

474: ZGC: Generational Mode by Default (23)

- ZGC default 실행 모드를 Generational 로 변경, 비세대 모드는 중단(deprecated)

- 개발팀이 세대별 모드에만 집중

490: ZGC: Remove the Non-Generational Mode (24)

- 위의 비세대 모드(Non-generational) ZGC 코드 제거

JIT Compilers

515: Ahead-of-Time Method Profiling (25)

- Project Leyden 용

- JIT compiler 는 code 가 얼마나 자주 실행되는지 profiling 한 뒤 최적하 합니다.

- 이 JEP 는 이전 실행에서 얻는 profiling 정보를 저장했다가 다음 실행에 즉시 사용하여, warm-up 시간을 획기적으로 단축

Run-Time System

483: Ahead-of-Time Class Loading & Linking (24)

- Project Leyden 용

- 기존 Java 는 클래스를 실행 시점(필요할 대) 읽어오고 연결함

- 이 JEP 는 App 실행 전 (CDS Archive생성단계)에 미리 처리함

514: Ahead-of-Time Command-Line Ergonomics (25)

- Project Leyden 용

- JVM 은 실행될 때마다 현재 메모리 상황에 맞춰 힙 크기등을 계산합니다.

- 이JEP는 계산 결과까지 미리 Archive 에 저장합니다. 시작 시 발생하는 미세한 지연 시간까지 최소화 합니다

519: Compact Object Headers (25)

- Project Lilliput (걸리버 여행기에 나오는 난쟁이 나라)

- Java Object 의 Header 에 Meta data 를 128 bit -> 64 bit 로 압축

- 전체 Heap Memory 사용량이 10~20% 감소,

- Java Object 크기가 줄어들어 실행 속도도 개선됨

주의 : preview feature

491: Synchronize Virtual Threads without Pinning (24)

- Project Loom 용

- Virtual Thread 는 synchronized block 안에서 I/O 작업을 만다면 실제 운영체제 스레드(Carrier Thread)에 고정되어 버리는 Pinning 문제가 있었습니다

- 이 JEP 는 synchronized 안에서도 가상 스레드가 자유롭게 Unmount/Yield 할 수 있게 합니다

- synchronized 를 사용하는 JDBC등의 라이브러리에서 수정 없이 Virtual Thred 를 고성능으로 사용할 수 있습니다.

Helidon SE

Oracle 의 프레임워크인 Helidon SE 을 사용하면 1.7 배(73%)의 성능 개선이 있다

Helidon SE는 오라클(Oracle)에서 개발한 마이크로서비스용 오픈소스 경량형 자바 프레임워크 ( cf, spring boot )

- Netty 기반의 비동기 I/O 사용

ETC

The Circle of Life for Java Code

Java 의 특징 Tiered Compilation : Interpreter -> C1 -> C2 로 처음엔 빨리 실행하고(C1), 나중에 최적하 하여 아주 빠르게 실행(C2) 하는 전략을 취한다

C1 : 자주 쓰이는 코드를 대상으로 하는 최적화 단계(빠른 컴파일 속도와 적절한 성능 향상 사이의 균형)
C2 : 프로그램 실행 패턴을 붆석하여 공격적인 최적화 수행, cpu/memory 를 많이 소모하지만, 결과물인 기계어의 실행 속도는 가장 빠름

C2 최적화를 위한 Trick 을 위하여 아래 전략을 택할 수 있는데, 일반적이지 않고, 특화된 영역이므로 생략한다

inlining
Loop unrolling
Hoisting
Dead Code Elimination
AutoVectorization - SuperWorld

Reference

From JDK 21 to JDK 25 - Java Performance Update 2025
Per-Ake Minborg on October 18, 2025

https://inside.java/2025/10/18/devoxxbelgium-java-performance-update/

From JDK 21 to JDK 25 - Java Performance Update 2025 – Inside.java

JDK 25 has just been released and is packed with performance improvements compared to JDK 21, allowing your unchanged application code to run even faster.In this talk, we will take a closer look at 13 concrete performance improvements made between J…

inside.java

JEP 513 Flexible Constructor Bodies

바람을타고2 — Sat, 20 Dec 2025 13:14:43 +0900

생성자(Constructor)의 본문(body)에서 super(...) 또는 this(...) 호출 전에 임의의 안전한 코드; 를 작성할 수 있도록 허용하는 기능입니다.
생성자에서 인자 검증, 정제(trim), 계산, 필드 선 초기화를 superclass 호출보다 앞서 작성 가능 합니다.

기존 Java는 생성자에서 다른 생성자(super/this) 호출이 첫 번째 문장이어야 했다(필수!)는 제약이 있었지만, JEP 513은 이 제약을 완화합니다.

첫 문장은 반드시 super() 규칙을 깨고, 실질적으로 안전한 범위 내에서 자유도(유연성)가 부여 되었습니다.

Code Example

// 변경 전
public class Sub extends Super {
    public Sub(int x) {
        super(x);   // 반드시 첫 번째여야 함
        // 그 이후에 코드
    }
}


// 변경 후
public class PositiveBigInteger extends BigInteger {
    
    public PositiveBigInteger(long value) {
        // validation check 를 super 앞(pre-construction context)로  추가 가능
        if (value <= 0) {
            throw new IllegalArgumentException("non-positive value");
        }
        super(Long.toString(value));
    }
}

하지만, pre-construction context 에서는 객체가 완전히 초기화 되지 않았기 때문에

→ this, 인스턴스 필드 참조, 인스턴스 메서드 호출은 금지됩니다

public class X {
    private int value;

    X() {
        this.value++;     // ❌ 'this' 접근 불가
        System.out.println(value);  // ❌ 인스턴스 접근
        super();
    }
}

Code Example 2 ; Enum

대소문자 변경 후 생성자 호출 가능

public enum Currency {
    USD("usd"), KRW("  krw  "), EUR("Eur");

    private final String code;

    // 보조 생성자
    Currency(String rawCode) {
        // 1. JEP 513 덕분에 this() 호출 전 로직 수행 가능
        if (rawCode == null || rawCode.isBlank()) {
            throw new IllegalArgumentException("코드 입력 필수");
        }
        String cleanedCode = rawCode.trim().toUpperCase();
        
        // 2. 가공된 데이터를 가지고 메인 생성자 호출
        this(cleanedCode); 
    }

    // 메인 생성자
    Currency(String code) {
        this.code = code;
    }
}

History

버전	JEP 번호	주요 변경 사항
Final (JDK 25)	JEP 513	정식 기능 확정. 구문 변경 및 안전성 보장 https://openjdk.org/jeps/513
3rd Preview (JDK 24)	JEP 492	세 번째 프리뷰. 변경 사항 없음, 추가 피드백 수집 https://openjdk.org/jeps/492
2nd Preview (JDK 23)	JEP 482	두 번째 프리뷰. Early Construction Context 개념 명확화 https://openjdk.org/jeps/482
1st Preview (JDK 22)	JEP 447	첫 번째 프리뷰. "Unnamed Classes and Instance Main Methods"에서 다른 제목으로 제안 https://openjdk.org/jeps/447

JEP 512 Compact Source File & Instance Main Method

바람을타고2 — Sat, 20 Dec 2025 09:48:07 +0900

초보자가 자바 프로그래밍을 시작할 때 겪는 복잡한 절차(Boilerplate code)를 줄이고,

소규모 프로그램이나 스크립트를 더 쉽고 간결하게 작성할 수 있도록 지원하는 기능

Code Example

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


// 변경 후
void main() {
    IO.println("Hello, World!");
}

intellij 2025.3 으로 java25 클래스 처음 생성하면 만들어 주는 코드 예

01. Compact Source files

public class HelloWorld {...} 없이도 필드와 메서드를 파일로 바로 작성 가능합니다

암시적 선언 클래스(implicitly Declared Class) 로 간주하여 처리합니다.

02. Instant Main Methods

public static void main(String[] args) 대신, 더 단순한 형태의 메인 메서드를 허용합니다.

03. Automatic Import

java.base module 전체 import, java.util.List, java.io.File 등 자주 사용되는 클래스들을 별도의 import 문 없이 사용할 수 있습니다

History

버전	JEP 번호	주요 변경 사항
Final (JDK 25)	JEP 512	정식 기능 확정. "Simple" 대신 "Compact"로 명칭 변경 https://openjdk.org/jeps/512
4th Preview (JDK 24)	JEP 495	java.lang.IO 도입 및 java.base 자동 임포트 강화 https://openjdk.org/jeps/495
3rd Preview (JDK 23)	JEP 477	java.io.IO를 통한 간소화된 I/O 도입 (나중에 java.lang으로 이동) https://openjdk.org/jeps/477
2nd Preview (JDK 22)	JEP 463	"Unnamed Classes"에서 "Implicitly Declared Classes"로 개념 재정의 https://openjdk.org/jeps/494
1st Preview (JDK 21)	JEP 445	최초 도입. 이름 없는 클래스와 인스턴스 메인 메서드 개념 제안 https://openjdk.org/jeps/445