반응형

JPA를 사용하면서 발생할 수 있는 N+1 문제는 어플리케이션의 성능을 저하시킬 수 있는 문제 이다

이 문제에 대해 발생하는 이유와 해결 방법에 대해 알아보고자 한다

 

N+1 문제 그리고 발생 원인

최초 실행한 한 개의 쿼리 + N개의 쿼리라고하여 N+1 문제라고 한다

 

JPA의 FetchType이 Lazy인 경우 발생 하는 것이다 (기본은 FetchType Eager)

N+1 문제는 하나의 쿼리를 실행 후, 조회된 엔티티에 대한 연관된 엔티티를 조회하기 위해 추가로 N개의 쿼리가 실행되는 것을 말한다

 

FetchType이 Lazy인 것이 자체가 문제가 되는 것은 아니다

Lazy로 연관 엔티티를 조회하는 경우 불필요한 데이터를 조회하지 않아도 되는 이점이 있다

그러나 이를 잘못 사용하여 연관된 데이터가 많은 엔티티에 접근하게 되면 해당 연관 엔티티의 수 만 큼 N번 조회가 발생하게 된다

 

이러한 N번의 조회에 의해 아래와 같은 문제점이 발생하게 되고 어플리케이션의 성능 저하가 발생할 수 있다

1. 쿼리 수가 급격히 증가

    : 연관 엔티티가 100개면 총 101개의 쿼리가 실행된다

2. DB 커넥션 낭비

    : 하나의 커넥션을 오래 점유하기 때문에 커넥션 풀 고갈 위험이 있다

 

N+1 문제가 발생할 수 있는 예시

@Entity
@Table(name = "orders")
@EntityListeners(AuditingEntityListener::class)
class Order(
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long? = null,
	
    .......
    
    @OneToMany(mappedBy = "order", fetch = FetchType.LAZY, cascade = [CascadeType.PERSIST])
    val orderItems: MutableList<OrderItem> = mutableListOf(),
	
    .......
    
    @CreatedDate
    val createdAt: Instant? = null,

    @LastModifiedDate
    val modifiedAt: Instant? = null
)


@Entity
@Table(name = "orderitems")
class OrderItem(
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long? = null,
	
    @Column(nullable = false)
    val productId: Long? = null,
	
    .......
    
    @CreatedDate
    val createdAt: Instant? = null,

    @LastModifiedDate
    val modifiedAt: Instant? = null
)

 

위 예시를 보면 Order 안에 연관 엔티티로 OrderItem이 있는 것을 볼 수 있다

만약 Order에 연관된 OrderItem이 1000개 라고 가정하고 Order 엔티티를 조회한 후 OrderItem 엔티티에 접근하게 되면

총 1000 + 1으로 1001 번의 쿼리가 수행되게 된다

 

해결 방법

1. Fetch Eager 사용

JPA는 기본적으로 연관 관계에 대해 Fetch Eager를 기본으로 한다

Eager를 사용하게 되면 조회할 때 연관 엔티티도 함께 조회를 하게 되는데, 연관 엔티티를 함께 조회하기 때문에 N+1문제가 발생하지 않는다

하지만 실제 필요하지 않은 엔티티도 함께 조회된다

 

2. Fetch Join 활용

Fetch Join을 하게되면 필요한 연관 엔티티를 한 쿼리로 조회할 수 있다

@Query("SELECT o FROM Order o JOIN FETCH o.items")
fun findOrders(): List<Order>

 

3. EntityGraph 활용

Fetch Join 과 비교해서 단순화된 방법이다

명시적으로 Eager로 수행되도록 하는 방식 이다

@EntityGraph(attributePaths = ["items"])
@Query("SELECT o FROM Order o")
fun findOrders(): List<Order>

 

4. DTO Projection 활용

필요한 컬럼의 데이터만 조회하는 방법이다

data class OrderInfoDto (
    val orderId: Long,
    val itemName: String
)

@Query("""
    SELECT new com.example.dto.OrderInfoDto(o.orderId, i.itemName)
    FROM Order o
    JOIN o.items i
""")
fun findOrderItem(): List<OrderInfoDto>

위 코드처럼 필요한 항목의 데이터만 조회할 수 있다

Dto의 package 경로 전체를 기입해야 하기 때문에 작성해야하는 구문이 길어질 수 있다

 

data class OrderInfoDto (
    val orderId: Long,
    val itemNames: List<String>
)

아래와 같은 Dto의 구성으로 List 항목으로 데이터를 조회할 수 는 없다

따라서 단일 항목으로 조회하고 조회 이후에 별도 가공을 해야한다

 

N+1 문제를 해결하기 위한 다양한 방법이 존재하는데 상황에 맞게 적절한 방법을 사용할 필요가 있다

반응형

'공부 > JPA' 카테고리의 다른 글

JPA 조회 함수에서 @Transactional이 필요한 경우(LazyInitializationException)  (1) 2025.07.06
JPA 순환 참조  (1) 2025.06.24
JPA 시작  (0) 2021.04.25
반응형

JPA를 사용하여 개발할 때 Entity간 연관관계를 지정하는 것은 일반적이다

 

이러한 연관관계를 지정하는 경우 N+1문제가 발생하는 경우 때문에 아래와 같이 FetchType을 Lazy로 한다

(물론 JPA에서는 Eager가 기본)

 

연관관계의 FetchType을 Lazy로 한 경우 조회 기능을 개발할 때 아래와 같이 LazyInitializationException 가 발생하는 경우가 있다

LazyInitializationExceptionorg.hibernate.LazyInitializationException: 
failed to lazily initialize a collection of role: 
kr.co.kimga.order.domain.entity.order.Order.orderItems: 
could not initialize proxy - no Session at org.hibernate.collection.spi.AbstractPersistentCollection.throwLazyInitializationException(AbstractPersistentCollection.java:635) 
at org.hibernate.collection.spi.AbstractPersistentCollection.withTemporarySessionIfNeeded(AbstractPersistentCollection.java:219) 
at org.hibernate.collection.spi.AbstractPersistentCollection.readSize(AbstractPersistentCollection.java:150) 
at org.hibernate.collection.spi.PersistentBag.size(PersistentBag.java:353) 
at kotlin.collections.CollectionsKt__IterablesKt.collectionSizeOrDefault(Iterables.kt:39) 
at kr.co.kimga.order.infrastructure.service.order.OrderService.findOrderDetails(OrderService.kt:82) 
at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke0(Native Method) 
at java.base/jdk.internal.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:77) 
at java.base/jdk.internal.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43) 
at java.base/java.lang.reflect.Method.invoke(Method.java:568)

 

 

 

발생 이유

왜 이런 문제가 발생하는 것일까?

LazyInitializationException이 발생하는 코드를 살펴보자

Order (
	.....

    @OneToMany(mappedBy = "order", fetch = FetchType.LAZY, cascade = [CascadeType.PERSIST])
    val orderItems: MutableList<OrderItem> = mutableListOf
    
	.....
) {
	.....
}
fun findOrderDetails(orderId: Long): FindOrderDetailsDto {

    val findOrder = orderRepository.findById(orderId)
        .orElseThrow { throw CanNotFindOrder() }

    return FindOrderDetailsDto(
        orderId = findOrder.id!!,
        orderStatus = findOrder.status,
        orderDate = findOrder.orderDate,
        items = findOrder.orderItems.map {
            FindOrderItemDto(
                productId = it.productId!!,
                productName = it.productName,
                quantity = it.remainQuantity()
            )
        }.toList(),
        payedAmount = findOrder.orderPays.sumOf { it.amount },
        discountAmount = findOrder.orderPays.sumOf { it.discountAmount },
        totalAmount = findOrder.orderPays.sumOf { it.amount + it.discountAmount }
    )
}

 

위 코드는 주문 정보를 조회하고 이를 DTO에 맞춰 가공한 후 전 반환하는 코드이다

코드 자체로만 보면 특별히 문제가 없다고 볼 수 도 있지만, 실행하면 LazyInitializationException이 발생하게 된다

 

그 이유는 FetchType이 Lazy이기 때문이다

 

해당 함수의 트랜잭션 범위는 orderRepository.findById로 조회를 하는 전후 이다

findById로 조회가 끝나는 경우 트랜잭션이 종료가 되는데, DTO객체로 Entity를 가공하는 과정에서 Lazy로 지정된 객체에 접근하게 된다

Lazy로 지정된 객체에 접근하게 되면 JPA는 해당 객체의 값을 데이터베이스로 부터 읽어오게 된다

그러나 이미 트랜잭션의 범위가 끝났기 때문에 조되된 Entity는 영속 상태가 아니게 되고 이 때문에 LazyInitializationException이 발생하게 된다

 

 

 

해결 방법

이를 해결하는 대표적인 두가지 방법은 Eager로 설정하는 방법과 Transaction 범위를 넗히는 것이다

 

1. FetchType Eager

Entity 조회할 때 연관관계의 Entity도 함께 조회하는 방법이다

연관관계의 Entity를 한번에 조회하게 되면 조회 이후에 연관관계 Entity를 추가로 조회할 필요가 없기 때문에 영속 상태가 아니여도 데이터를 활용할 수 있다

Order (
	.....

    @OneToMany(mappedBy = "order", fetch = FetchType.EAGER, cascade = [CascadeType.PERSIST])
    val orderItems: MutableList<OrderItem> = mutableListOf
    
	.....
) {
	.....
}

 

❗️Eager를 사용하게 되면 한번에 많은 데이터를 가져오는 것을 조심해야한다

Entity를 조회할 때 연관관계 Entity를 모두 가져오게 되면 자칫 많은 데이터를 가져올 수 있고, Out Of Memory Exception이 발생할 수 있다

 

2. @Transactional 활용

Fetch Lazy 상태에서 연관관계 Entity의 데이터에 접근하게 되면 해당 Entity의 데이터를 DB로 부터 읽어오게 된다

이를 위해서 Entity가 영속 상태인 것이 중요한데, 영속 상태를 유지하기 위해 Transaction의 범위 확장할 필요가 있다

이를 위해 메소드에 @Transactional 어노테이션을 활용할 수 있다

 

메소드에 @Transactional 어노테이션을 붙이게 되면 트랜잭션 범위를 함수 내로 확장할 수 있다

이를 통해 Entity는 영속 상태를 유지하게 되고 연관관계의 Entity를 조회해올 수 있게 된다

@Transactional(readOnly = true)
fun findOrderDetails(orderId: Long): FindOrderDetailsDto {

    val findOrder = orderRepository.findById(orderId)
        .orElseThrow { throw CanNotFindOrder() }

    return FindOrderDetailsDto(
        orderId = findOrder.id!!,
        orderStatus = findOrder.status,
        orderDate = findOrder.orderDate,
        items = findOrder.orderItems.map {
            FindOrderItemDto(
                productId = it.productId!!,
                productName = it.productName,
                quantity = it.remainQuantity()
            )
        }.toList(),
        payedAmount = findOrder.orderPays.sumOf { it.amount },
        discountAmount = findOrder.orderPays.sumOf { it.discountAmount },
        totalAmount = findOrder.orderPays.sumOf { it.amount + it.discountAmount }
    )
}

 

* Transactional 어노테이션의 readOnly 속성을 true로 지정하게 되면 조회만을 수행하는 함수에 불필요한 동작(flush, drity checking 등)을 수행하지 않아 성능 최적화를 할 수 있다

 

 

반응형

'공부 > JPA' 카테고리의 다른 글

JPA N+1 문제 원인  (0) 2025.07.06
JPA 순환 참조  (1) 2025.06.24
JPA 시작  (0) 2021.04.25
반응형

Zookeeper

Zookeeper는 Broker들을 관리하는 역할을 한다

  • Broker 등록 / 상태 관리
  • 브로커의 상태를 감시
  • Controller 선출
  • 파티션 리더 선출 및 정보 관리
  • 클러스터 메타데이터 관리

주키퍼는 카프카에 종속되지 않은 별개의 시스템으로 브로커 관리를 위해 존재한다

Kafka 2.8 부터 이에 대한 의존성을 제거하고자 KRaft를 통해 이를 대처하려고 하고 있다

Broker

Broker는 메시지 저장 및 메시지 제공 등의 역할 수행하며 Producer/Consumer와 직접 통신하는 주체이다

  • 데이터 저장소
  • 메시지 수신 / 전달
  • 파티션 및 레플리카 관리
  • 파티션 리더 역할 수행
  • Controller 역할 수행

 

Kafka의 Broker들의 모음을 Kafka Cluster라고 한다

Zookeeper는 Kafka Cluster 내 Controller를 선출하는 역할, Broker들을 관리하는 역할을 하며 Broker들의 상태를 감시하고 브로커의 상태를 Controller에게 전달하여 Controller가 Failover를 할 수 있도록 한다

반응형

'공부 > Kafka' 카테고리의 다른 글

[Kafka] Kafka의 특징  (0) 2021.06.13
[Kafka: 카프카] Kafka란?  (0) 2021.06.07
반응형

getParameter() 그리고 getReader() 사용

HttpServletRequest 객체의 getParameter()를 통해 요청으로부터 파라미터 값을 가져와 작업을 하는 경우 주의가 필요하다.

만약 getParameter()를 통해 요청 파라미터 값을 받게 되는 경우 후속 작업에서 getReader를 통해 요청 값을 처리하는 경우가 생길 때 문제가 될 수 있다.

그 이유는 Servlet Spec에 있는데, Servlet Spec에 명시된 get Parameter에 대한 설명은 다음과 같다.

 

Parameter를 이용할 수 있는 상황에 대해 정의한 부분이다.

  1. 요청이 HTTP, HTTPS 인 경우
  2. HTTP POST 메소드 인 경우
  3. Content-Type 이 application/x-www-form-urlencoded 인 경우
  4. Servlet이 getPrarmeter 유형의 메소드를 최초 호출한 경우

위 조건이 만족하지 않아 사용할 수 없는 경우에는 요청 객체의 input stream을 통해 post data를 이용할 수 있다.

 

다만, 위 조건이 충족한 경우에는 요청 객체에 대한 input stream을 직접 이용할 수 없다.

 

getParameter함수와 getReader 함수를 같이 써야하는 경우 주의가 필요하다.

일반적으로 함수를 사용하거나 할 때 해당 함수의 스펙이나 자세한 문서를 찾아보지 않고 그냥 쓰는 경우가 많은데 그럴 경우 문제가 될 수 있다.

이러한 문제를 극복하기 위해 Wapper 클래스를 상속하여 Reusable하게 만든 HttpServletRequest 클래스를 사용하고 있다.

하지만 was 마다 해당 부분에 대한 처리가 다를 수 있기 때문에 관련 부분을 확인해본 후 사용할 필요가 있다.

 

JEUS의 겨우 : jeus.servlet.engine.WebtoBServletRequest

Tomcat의 경우 : org.apache.catalina.connector.RequestFacade

반응형

'공부 > Java' 카테고리의 다른 글

Java SSL 인증서 검증 흐름 및 확인  (0) 2025.06.17
Out Of Memory 문제 분석  (0) 2025.05.31
[Java] HashMap get 메서드에 관하여  (0) 2021.09.13
JavaAgnet  (0) 2021.05.09
Java Virtual Machine(JVM)  (0) 2021.05.08
반응형

JPA를 사용하면서 자칫하면 순환참조가 발생하는 경우가 있다

그렇다면 왜 JPA를 사용할 때 이러한 일이 발생할까

1. 원인

일반적으로 JPA에서 순환참조가 발생하는 이유는 양방향 연관관계가 존재하는 경우 이다

/* 양방향 연관관계 */
@Entity
data class Customer(
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long? = null,
    val name: String,

    @OneToMany(mappedBy = "customer")
    val orders: List<Order> = mutableListOf()
)

@Entity
data class Order(
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    val id: Long? = null,
    val orderDate: String,

    @ManyToOne
    @JoinColumn(name = "customer_id")
    val customer: Customer
)

이 처럼 Customer(고객)가 여러 Order(주문)을 가지는 경우에 대해 필요 시 양방향 연관 관계를 설정할 수 있다

 

그렇다면 이러한 상황에서 Customer의 정보를 조회하여 조회된 결과를 그냥 반환한다고 하면 순환 참조가 발생할 수 있게 된다

@Service
class CustomerService(
    private val customerRepository: CustomerRepository
) {
	fun getCustomerById(id: Long): Customer? = 
		customerRepository.findById(id).orElseThrow(EntityNotFoundException("Customer not found"))
}

@Repository
interface CustomerRepository : JpaRepository<Customer, Long>

이렇게 조회된 Customer를 별도의 DTO 객체로 변환하거나 하지 않고 Service를 지나 Controller에서 반환된다면 JSON으로 변환될 때 순환 참조를 맛볼 수 있다

 

그렇다면 왜 JSON으로 변환하는 과정에서 순환 참조가 발생하게 되는 걸까?

 

2. 이유

그 이유를 알아보기 위해서는 객체를 JSON으로 변환해주는 라이브러리를 살펴볼 필요가 있다

Spring에서는 @RestController가 있는 Controller에서 객체를 반환하면 JSON 형식으로 변환되어 응답이 나가게 된다

이러한 것은 Spring 내부에 있는 Message Converter(HttpMessageConverter)가 우리의 객체를 Http 메시지로 변환하는 과정을 통해 이루어 진다

Controller에서 반환된 객체는 ReturnValue Handler에 의해 처리가 되고,

반환된 객체는 Jackson Message Coverter에 의해 처리가 되고 내부에 ObjectMapper에 의해 객체가 json으로 serialize 되는 과정에서 객체 내부의 필드에 대해 재귀 호출이 발생하고 이 과정에서 양방향 연관관계가 있는 객체에 대해 순환 참조가 발생하게 되고 StackOverFlow Exception이 발생하게된다

3. 해결 방법

1) @JsonIgnore

@Entity
class Child(
	@Id
	@GenerateValue
	val id: Long? = null,
	
	@ManyToOne
	@JoinColumn(name = "parent_id")
	@JsonIgnore
	val parent: Parent
)

JsonIgnore 어노테이션을 사용하면 직렬화를 할 때 해당 변수에 대한 직렬화를 제외하게 되고 순환 참조가 일어나지 않는다

단, 이러한 경우 해당 변수에 대한 값은 직렬화 되지 못하여 반환된 값에서 제외 된다

 

2) DTO활용 (가장 적절한 방법)

데이터를 반환할 때는 DTO를 통해 의미 있는 값만 전달 반환하는 것이 바람직하다

data class ParentDto(
    val id: Long?,
    val children: List<ChildDto>
)

data class ChildDto(
    val id: Long?,
    val parentId: Long?
)

fun Parent.toDto(): ParentDto = ParentDto(
    id = this.id,
    children = this.children.map {it.toDto()}
)

fun Child.toDto(): ChildDto = ChildDto(
    id = this.id,
    parentId = this.parent.id
)

이 처럼 원하는 데이터만 DTO에 포함하여 반환하면 순환참조를 제어할 수 있고, 진짜 필요한 값만 반환할 수 있기 때문에 가장 추천되는 방법이다

 

위에서 설명한 것 외에도 순환 참조가 발생하는 케이스들이 존재하기 때문에 JPA를 사용하는 경우 이를 유의하며 코드를 작성해야 한다

반응형

'공부 > JPA' 카테고리의 다른 글

JPA N+1 문제 원인  (0) 2025.07.06
JPA 조회 함수에서 @Transactional이 필요한 경우(LazyInitializationException)  (1) 2025.07.06
JPA 시작  (0) 2021.04.25
반응형

1. S(Shared) Lock, 공유 락

  • 데이터를 읽는 동안 쓰기에 대한 제한을 두기 위한 락
  • 여러 트랜잭션에서 동시에 공유락 획득 가능
  • X락이 설정된 경우는 공유락 획득 불가
/* 오라클 */
SELECT * FROM TEST FOR SHARE;

일반적인 SELECT SQL 수행 시 마지막에 FOR SHARE 구문을 붙이게 되면 S락을 설정할 수 있다

! 중요

공유락에 대해서 SELECT 조회를 하면 공유락이 걸린다는 오해를 하는 경우가 있다

일반적으로 SELECT를 하게 되면 공유락이 걸린다고 생각하는데 FOR SHARE을 붙여서 SELECT를 하지 않으면 공유락이 획득되지 않는다

이는 오라클이 MVCC(Multi Version Concurrency Control)로 동작하기 때문이다

오라클 기준으로 일반적으로 조회를 하는 경우에는 실제 데이터를 읽는 것이 아닌 스냅샷을 통해서 데이터를 데이터를 읽기 때문에 락의 영향을 받지 않고 데이터를 읽을 수 있다

다만 이런 경우 조회하는 시간이 오래걸리거나 하는 경우 스냅샷으로 부터 읽은 데이터가 변경되면 Ora-01555: Snapshot Too Old ****가 발생할 수 있다

 

2. X(Exclusive) Lock, 베타 락

  • 데이터 쓰기를 하는 트랜잭션에서 설정하는 락
  • 데이터를 쓰는 동안 다른 락을 허용하지 않음
  • X 락이 설정 되어있으면 S 락 또는 X 락을 설정할 수 없음
  • 베타락이 걸려있으면 데이터를 읽는 것 또한 차단
  • 동시성은 감소하나 데이터 무결성 보장
/* 오라클 */
SELECT * FROM TEST FOR UPDATE;

/* DML 시에도 X락 설정됨 */
UPDATE, DELETE

베타락은 데이터 또는 테이블에 대한 변경이 발생할 때, 그리고 SELECT 시 FOR UPDATE 구문을 붙인 경우 설정된다

반응형
반응형

3개 이상의 주문 채널이 존재하고 각 주문 채널별 모놀리식 시스템과 단일 DB로 구성된 환경에서 특정 시간 동시 주문 발생 간 데드락이 발생하였고 이에 대한 해결 방법에 대한 사고 실험을 해보고자 한다

 

문제 상황

한개 이상의 상품을 포함하는 주문이 여러 판매 채널로 부터 발생하는 과정에서 상품의 재고 차감 중 데드락이 발생

 

발생 예시

주문1(상품 A, C) 주문2 (상품 B, C, A)
상품 A Lock 상품 B Lock
상품 C Lock 대기 상품 C Lock
  상품 A Lock 대기

 

이처럼 여러 상품을 포함하고 있는 주문 건에 대해 재고 차감 시 데드락이 발생할 수 있다

 

 

락의 종류

1. Optimistic Lock(낙관적 락)

낙관적 락은 version 컬럼을 추가로 두고 업데이트 시 버전을 조건으로 넣어 데이터를 변경하는 방식

조건절에 있는 버전 정보가 맞지 않으면 업데이트가 실패하게 됨으로써 정합성을 보장하는 방법이다

UPDATE ..... WHERE PRODUCT_ID = ? AND VERSION = ?;

 

락을 점유하지 않아 데드락 발생에서 자유롭다

버전 정보가 맞지 않아 업데이트가 실패하는 경우에 대한 재수행 로직이 추가로 구현될 필요가 있다

또한, 충돌이 빈번하게 발생하는 상황(주문이 대량으로 들어오는 상황)에서 반복적인 재수행에 따라 성능 저하가 발생할 수 있다

 

 

2. Pessimistic Lock(비관적 락)

비관적 락은 충돌이 발생할 수 있는 데이터에 접근할 때 해당 데이터에 대한 락을 설정하여 다른 트랜잭션에서 해당 데이터에 대한 변경을 차단하는 방식(행에 대한 락 설정)

SELECT * FROM INVENTORY WHERE PRODUCT_ID = ? FOR UPDATE;
SELECT * FROM INVENTORY WHERE PRODUCT_ID IN (?, ?, ?...) ORDER BY PRODUCT_ID FOR UPDATE;

* 여러 행에 대해 락을 설정하는 경우 ORDER  BY 설정이 중요하다. ORDER BY 설정을 하지 않은 경우 락을 설정하는 행의 순서에 따라 데드락이 발생할 수 있기 때문이다

 

출돌이 발생하기 전에 락을 걸어 차단하기 때문에 충돌 상황에서 안전하게 처리가 가능하다

하지만 트랜잭션 시간이 길거나 상품 수가 많은 경우 성능 저하가 발생할 수 있다

 

3. Distributed Lock(분산 락)

분산 락은 여러 서버들 간의 리소스에 대한 잠금이 필요한 경우 사용하는 것으로 Redis나 Zookeeper 등의 미들웨어를 통해 잠금을 수행한다

 

분산 시스템에 대한 락을 설정할 수 있는 장점이 있으나 미들웨어에 의존하기 때문에 미들웨어의 장애 시 락의 안정성을 보장하기 어렵다(미들웨어의 FailOver 설정 중요)

네트워크 지연이나 TTL 만료 등 고려하지 않으면 중복 실행될 수 있다

 

 

고찰

위와 같은 문제가 발생한 상황과 현재 운영 중인 시스템의 관점에서 보면 낙관적 락을 선택하는게 바람직해 보인다

 

1. 단일 DB이므로 분산 환경 X

2. 동시 발생하는 주문이 많지 않다

3. 데드락 회피 필요

위와 같은 이유로 현재 주어진 상황 속에서 적용할 수 있는 락을 선택하였다

 

!다만, 낙관적 락을 위해서는 변경 실패에 대한 재시도 로직에 대한 추가적인 구현과 기존 코드나 쿼리에 대한 변경이 필요하고, 재시도 횟수에 대한 정책 또한 수립이 필요하다

 

 

사고 실험을 하면서 서비스의 현재 상황과 시스템의 구성 등을 고려하여 가장 적합한 방법을 고민해볼 수 있었다

반응형

'공부' 카테고리의 다른 글

Kotlin 기본 문법 정리 - 함수  (0) 2025.07.18
Kotlin 기본 문법 정리 - 타입과 변수  (0) 2025.07.17
Gradle 개념과 역할  (0) 2025.07.15
Redis 개념 정리 및 Spring 활용  (0) 2025.07.15
[DB] S/X Lock  (0) 2025.06.24
반응형

 

외부와 통신하는 기능에 대해 외부 서비스의 SSL이 2세대 인증서로 변경되면서 이에 대해 확인하는 과정을 기록한 것이다

 

어플리케이션에서 외부 서비스와의 통신을 하는 경우 RestTemplate를 통해 통신을 하는 등 java 단에서 통신을 하는 경우가 있다

이러한 경우 통신의 과정에서 SSL 인증서의 검증은 어떻게 이루어 지는지에 대해 알아보았다

 

일반적으로 웹사이트에 접속을 하게 되면 SSL 인증서에 대한 검증은 브라우저에서 수행하게 되어있는데

Java 어플리케이션 내에서 https 프로토콜로 통신 하는 경우 SSL 인증서에 대한 검증은 JVM 내에서 이루어지게 되어있다

 

Java의 SSL 인증서 검증 흐름

Java 어플리케이션 내에서 SSL 인증서의 검증 흐름은 다음과 같다

  HttpsURLConnection
         ↓
     SSLContext
         ↓
 TrustManagerFactory
         ↓
  X509TrustManager (실제 검증 수행)
         ↓
 checkServerTrusted

 

HttpsURLConnection은 네트워크 통신 레벨의 API로 SSL 핸드셰이크를 수행

SSLContext는 SSL 세션의 구성요소에 대한 초기화 및 관리르 수행하고 해당 객체에서 암호화 방식이나 TrustManager를 결정

TrustManagerFactory SSLContext에서 사용할 TrustManager 리스트를 생성하는 역할 수행한다 이 때, JVM "cacerts" 또는 사용자 keyStore를 통해 TrustManager 생성

X509TrustManager는 실제 서버 인증서 체인을 검증하는 역할을 수행하며 "checkServerTrusted" 메소드를 통해 서버가 제공한 인증서 체인을 검증

 

(RestTemplate도 내부적으로 HttpURLConnection을 사용하고 있어 인증 흐름은 동일)

 

 

Java 내 cacerts 확인 방법

cd $JAVA_HOME (JAVA가 설치된 디렉토리로 이동)

cd jre/lib/security (cacerts가 있는 위치로 이동)

# 아래 명령을 수행하면 해당 되는 alias에 대한 CA 인증서 정보를 볼 수 있다
keytool -list -v -keystore ./cacerts -storepass [password, 기본 "changeit"] -alias '[alias 명]'

 

해당 CA인증서를 확인함으로써 인증서의 세대 교체 등이 발생했을 때 신규 인증서를 어플리케이션에서 검증할 수 있는지 확인할 수 있다

 

추가

어플리케이션 실행할 때 jvm 옵션으로 아래 옵션을 추가하면 HTTPS 요청이 발생할 때 인증서, TLS 버전, 루트 인증서에 대한 정보를 로그로 확인할 수 있다

-Djavax.net.debug=ssl,handshake,certpath

 

반응형

'공부 > Java' 카테고리의 다른 글

getParameter, getReader 값 못 읽는 문제  (0) 2025.06.25
Out Of Memory 문제 분석  (0) 2025.05.31
[Java] HashMap get 메서드에 관하여  (0) 2021.09.13
JavaAgnet  (0) 2021.05.09
Java Virtual Machine(JVM)  (0) 2021.05.08

+ Recent posts