Pink Spider Pink-Spider

Java Spring에서 “reflection(리플렉션)“은 Java의 런타임 시점에 클래스, 메서드, 필드 등에 접근하고 조작할 수 있는 기능을 의미합니다. 일반적인 컴파일 시점이 아닌, 실행 중인 애플리케이션의 구조를 동적으로 분석하거나 변경하는 데 활용됩니다.

💡 리플렉션이란?

Java 리플렉션 API는 java.lang.reflect 패키지를 통해 제공되며, 다음과 같은 기능을 제공합니다:

• 클래스 이름으로 Class 객체를 얻기
• 클래스의 생성자, 메서드, 필드 정보 조회
• 메서드 호출, 필드 값 읽기/쓰기 등 동적 조작
• 접근 제한자(private 등) 무시하고 접근 (setAccessible(true))

🛠 Spring에서 리플렉션이 쓰이는 주요 예

Spring 프레임워크는 내부적으로 리플렉션을 매우 광범위하게 사용합니다:

Spring Boot 3 + JPA + MySQL 환경에서 특정 테이블에 대해 find 및 save 작업 시 row-level lock만 사용하고 table-level lock을 피하고 싶을 경우, 다음과 같은 전략을 사용할 수 있습니다.

✅ 핵심 개념 요약

• MySQL InnoDB 스토리지 엔진은 기본적으로 row-level lock을 지원하며, JPA의 기본 동작은 row-level lock을 사용합니다.

• 그러나 다음 조건을 만족하지 않으면 innoDB라도 table lock이 발생할 수 있습니다:

  • WHERE 절에 인덱스를 잘 사용하지 못하거나
  • 락 모드가 명시되지 않았거나
  • UPDATE나 SELECT ... FOR UPDATE에서 범위 검색을 제대로 구성하지 않았거나

✅ 전제 조건: 테이블이 InnoDB 엔진인지 확인

SHOW TABLE STATUS WHERE Name = 'your_table_name';

• Engine 컬럼이 InnoDB여야 row-level lock이 적용됩니다.
• 만약 MyISAM이면 row-level lock이 불가능하므로 반드시 InnoDB로 변경해야 합니다:

ALTER TABLE your_table_name ENGINE = InnoDB;

✅ JPA에서 row-level locking만 적용하기

1. @Lock(LockModeType.PESSIMISTIC_WRITE) 또는 @Lock(LockModeType.PESSIMISTIC_READ)

@Repository
public interface OrderRepository extends JpaRepository<Order, Long> {

    @Lock(LockModeType.PESSIMISTIC_WRITE)
    @Query("SELECT o FROM Order o WHERE o.id = :id")
    Optional<Order> findByIdForUpdate(@Param("id") Long id);
}

• PESSIMISTIC_WRITE는 SELECT ... FOR UPDATE를 실행하여 row-level exclusive lock을 겁니다.
• 이 쿼리는 해당 row를 다른 트랜잭션에서 변경하지 못하게 막습니다.
• PESSIMISTIC_READ는 공유락을 걸며 읽기는 허용하되 쓰기는 막습니다.

⚠️ 주의: 이 방법은 반드시 트랜잭션(@Transactional) 안에서 사용되어야 실제로 락이 적용됩니다.

아래에 Java Pathfinder (JPF) 사용하는 방법을 자세히 안내드립니다. Java Pathfinder는 자바 프로그램의 모델 체킹(model checking) 도구로, 프로그램의 상태 공간을 탐색하여 버그나 데드락 등을 찾는 데 활용됩니다.

아래 내용을 단계별로 설명드릴게요.

🧭 1. Java Pathfinder(JPF)란?

**Java Pathfinder (JPF)**는 자바 프로그램을 실행하며 상태공간을 체계적으로 탐색하는 툴입니다.

주요 기능

• 멀티스레딩 버그 탐지
• Assertion 위반 검출
• Deadlock 탐지
• Non-deterministic 동작 검증
• Symbolic execution (jpf-symbc) 지원

⚙️ 2. 설치

JPF는 GitHub 저장소에서 직접 빌드하는 것이 일반적입니다.

아래에 Java에서 PIT (Pitest) Mutation Testing을 사용하는 방법을 단계별로 정리해 드립니다. PIT는 자바 코드의 테스트 커버리지를 실제로 검증하는 강력한 도구로, 잘못된(변이된) 코드를 테스트가 얼마나 잘 잡아내는지를 측정합니다.

📌 1. PIT(Pitest) 소개

• Mutation Testing이란?

  • 기존 코드를 일부러 “변이(mutant)” 시켜서 테스트를 돌려보는 기법입니다.
  • 테스트가 이 변이를 검출하지 못하면, 테스트에 허점이 있다는 뜻입니다.
  • 단순한 라인 커버리지보다 더 신뢰성 있는 테스트 품질 지표를 제공합니다.

• PIT의 특징

  • JUnit 기반 테스트와 잘 통합됩니다.
  • Maven, Gradle, Ant에서 쉽게 사용 가능합니다.
  • HTML 및 XML 리포트를 생성합니다.

⚙️ 2. Maven 프로젝트에 PIT 적용

2.1 Maven 플러그인 추가

pom.xml에 다음 플러그인을 설정합니다:

Spring Boot 3에서 SSH 터널을 통한 PostgreSQL 연결을 위한 설정 방법을 알려드리겠습니다.

1. application.yml 설정

spring:
  datasource:
    url: jdbc:postgresql://localhost:5433/your_database_name
    username: your_db_username
    password: your_db_password
    driver-class-name: org.postgresql.Driver
  
  jpa:
    hibernate:
      ddl-auto: validate
    show-sql: true
    properties:
      hibernate:
        dialect: org.hibernate.dialect.PostgreSQLDialect
        format_sql: true

# SSH 터널 설정 (커스텀 프로퍼티)
app:
    ssh:
      tunnel:
        host: your-ssh-server.com
        port: 22
        username: ssh_username
        private-key-path: ~/.ssh/id_rsa
        local-port: 5433
        remote-host: localhost  # SSH 서버에서 본 DB 호스트
        remote-port: 5432       # 실제 PostgreSQL 포트

2. SSH 터널 자동 연결을 위한 Configuration 클래스## 3. 필요한 의존성 추가 (build.gradle)

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    implementation 'org.postgresql:postgresql'
    implementation 'com.github.mwiede:jsch:0.2.17'
    
    // 기타 필요한 의존성들...
}

3. ssh key 만들기 예시

ssh-keygen -t rsa -b 4096 -m PEM -f ~/.ssh/id_rsa -C "ceo@pink-spider.io"

• DB가 설치된 서버에 ~/.ssh 등에 authorized_keys (권한 644) 파일에 id_rsa.pub 내용 추가해야 됩니다.
• rsa가 아닌 OpenSSh로 keygen 했을 경우 com.github.mwiede:jsch 가 아닌 다른 라이브러리를 써야 됩니다.

SshTunnelConfig

@Configuration
@Slf4j
@Profile({"local", "dev", "stage", "prod"})
public class SshTunnelConfig {

    @Value("${app.ssh.tunnel.host}")
    private String sshHost;

    @Value("${app.ssh.tunnel.port}")
    private int sshPort;

    @Value("${app.ssh.tunnel.username}")
    private String sshUsername;

    @Value("${app.ssh.tunnel.private-key-path}")
    private String privateKeyPath;

    @Value("${app.ssh.tunnel.local-port}")
    private int localPort;

    @Value("${app.ssh.tunnel.remote-host}")
    private String remoteHost;

    @Value("${app.ssh.tunnel.remote-port}")
    private int remotePort;

    @Value("${app.ssh.tunnel.passphrase:}")
    private String passphrase;

    private Session session;

    @PostConstruct
    public void createSshTunnel() {
        try {
            log.info("JSch SSH 터널 연결 시작...");

            // 로컬 포트가 사용 가능한지 확인
            if (!isPortAvailable(localPort)) {
                throw new RuntimeException("로컬 포트 " + localPort + "가 이미 사용 중입니다.");
            }

            JSch jsch = new JSch();

            // 개인키 파일 경로 처리
            String keyPath = privateKeyPath;
            if (keyPath.startsWith("~/")) {
                keyPath = System.getProperty("user.home") + keyPath.substring(1);
            }

            // 파일 존재 및 읽기 권한 확인
            File keyFile = new File(keyPath);
            if (!keyFile.exists()) {
                throw new RuntimeException("SSH 개인키 파일을 찾을 수 없습니다: " + keyPath);
            }

            if (!keyFile.canRead()) {
                throw new RuntimeException("SSH 개인키 파일을 읽을 수 없습니다. 파일 권한을 확인하세요: " + keyPath);
            }

            log.info("SSH 개인키 파일: {}", keyPath);

            // 키 형식 확인 (RSA 형식인지 체크)
            try (java.io.BufferedReader reader = new java.io.BufferedReader(new java.io.FileReader(keyFile))) {
                String firstLine = reader.readLine();
                log.info("키 파일 형식: {}", firstLine);

                if (firstLine != null && !firstLine.contains("BEGIN RSA PRIVATE KEY")) {
                    log.warn("RSA 형식이 아닌 키가 감지되었습니다: {}", firstLine);
                    log.warn("RSA 형식 키를 생성하려면: ssh-keygen -t rsa -b 4096 -m PEM -f {}", keyPath);
                }
            }

            // 개인키 추가
            if (passphrase != null && !passphrase.trim().isEmpty()) {
                jsch.addIdentity(keyPath, passphrase);
                log.info("패스프레이즈와 함께 개인키 로드 완료");
            } else {
                jsch.addIdentity(keyPath);
                log.info("개인키 로드 완료");
            }

            // SSH 세션 생성
            session = jsch.getSession(sshUsername, sshHost, sshPort);
            session.setConfig("StrictHostKeyChecking", "no");
            session.setConfig("PreferredAuthentications", "publickey");
            session.setTimeout(30000);

            log.info("SSH 서버 연결 시도: {}@{}:{}", sshUsername, sshHost, sshPort);
            session.connect();
            log.info("SSH 연결 성공");

            // 포트 포워딩 설정
            session.setPortForwardingL(localPort, remoteHost, remotePort);

            // 포트가 열릴 때까지 대기
            waitForPortToOpen(localPort, 10000);

            log.info("SSH 터널이 성공적으로 생성되었습니다: localhost:{} -> {}:{}:{}",
                localPort, sshHost, remoteHost, remotePort);

        } catch (JSchException e) {
            log.error("SSH 터널 생성 실패: {}", e.getMessage(), e);

            // 구체적인 에러 메시지 제공
            if (e.getMessage().contains("invalid privatekey")) {
                log.error("개인키 형식이 잘못되었습니다. RSA 형식 키를 사용하세요.");
                log.error("새 RSA 키 생성: ssh-keygen -t rsa -b 4096 -m PEM -f ~/.ssh/level_up_rsa");
            } else if (e.getMessage().contains("Auth fail")) {
                log.error("인증에 실패했습니다. 공개키가 서버에 등록되어 있는지 확인하세요.");
                log.error("공개키 등록: ssh-copy-id -i {} {}@{}", privateKeyPath + ".pub", sshUsername, sshHost);
            } else if (e.getMessage().contains("Connection refused")) {
                log.error("서버 연결이 거부되었습니다. 호스트와 포트를 확인하세요.");
            }

            cleanupResources();
            throw new RuntimeException("SSH 터널 연결에 실패했습니다: " + e.getMessage(), e);
        } catch (Exception e) {
            log.error("예상치 못한 오류: {}", e.getMessage(), e);
            cleanupResources();
            throw new RuntimeException("SSH 터널 설정 중 오류가 발생했습니다: " + e.getMessage(), e);
        }
    }

    @PreDestroy
    @EventListener(ContextClosedEvent.class)
    public void closeSshTunnel() {
        log.info("SSH 터널 종료 시작...");
        cleanupResources();
        log.info("SSH 터널 종료 완료");
    }

    private void cleanupResources() {
        if (session != null && session.isConnected()) {
            try {
                session.disconnect();
                log.info("SSH 세션이 종료되었습니다.");
            } catch (Exception e) {
                log.warn("SSH 세션 종료 중 오류: {}", e.getMessage());
            }
        }
    }

    private boolean isPortAvailable(int port) {
        try (ServerSocket serverSocket = new ServerSocket(port)) {
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    private void waitForPortToOpen(int port, long timeoutMillis) throws InterruptedException {
        long startTime = System.currentTimeMillis();
        while (System.currentTimeMillis() - startTime < timeoutMillis) {
            try (java.net.Socket socket = new java.net.Socket()) {
                socket.connect(new java.net.InetSocketAddress("localhost", port), 1000);
                log.info("포트 {}가 성공적으로 열렸습니다.", port);
                return;
            } catch (Exception e) {
                // 포트가 아직 열리지 않음, 재시도
                Thread.sleep(500);
            }
        }
        log.warn("포트 {}가 {}ms 내에 열리지 않았습니다.", port, timeoutMillis);
    }
}

**Property-Based Testing(PBT)**은 입력과 결과 간의 **일반적인 속성(Property)**을 정의하고, 테스트 프레임워크가 그 속성을 충족하는지를 무작위로 생성된 다양한 입력값에 대해 확인하는 방식의 테스트입니다. 단위 테스트처럼 특정 입력값만 확인하는 것이 아니라, 수천 개의 입력 조합을 자동으로 검사할 수 있다는 점에서 매우 강력합니다.

🔍 Property-Based Testing이란?

✅ 핵심 개념

• 속성(Property): 테스트 대상 함수나 로직이 항상 만족해야 하는 일반적인 법칙 또는 규칙.
• 입력값 자동 생성: PBT 프레임워크가 다양한 입력값을 무작위로 생성.
• Fail case 축소(Shrinking): 실패한 입력값이 발생했을 때, 실패를 재현할 수 있는 최소 입력값으로 줄여서 디버깅을 쉽게 함.

🆚 단위 테스트와의 비교

🧪 Spring Boot에서 Property-Based Test 사용하는 방법

Spring Boot 자체는 JUnit을 기반으로 한 단위 테스트가 기본이며, PBT는 외부 라이브러리를 사용해서 통합하는 것이 일반적입니다. 가장 널리 쓰이는 Java 기반 라이브러리는 다음과 같습니다: