제닌의 블로그

[WIL] Redis 분산 락

Jeanin — Sat, 16 Aug 2025 19:18:05 +0900

본 글은 항해플러스 백엔드 9기 교육 과정 수강중 작성된 학습노트입니다.
⚠️개인이 학습한 것을 바탕으로 작성되어 부정확할 수 있으며, 오류가 있다면 알려주시면 감사하겠습니다.

❔WIL(Weekly I Learned)

분산 락(Distributed Lock)이란?

출처: https://mohammedev.hashnode.dev/distributed-locks

분산 시스템에서 서로 다른 서버 인스턴스에 대한 일관된 락을 제공하기 위한 장치이다.

여러 서버가 동시에 공유 자원에 접근할 때, 한 시점에는 오직 하나의 주체만

해당 자원을 변경할 수 있도록 하는 동기화 메커니즘이다.

단일 서버 환경에서는 DB락 같은 방식으로 동시성 제어가 가능하지만,

마이크로서비스(MSA), 멀티 서버 환경, 클러스터 환경에서는

서버 간의 메모리를 공유하지 않기 때문에 이런 방식이 통하지 않는다.

Redis(레디스)

출처: https://namu.wiki/w/Redis

이전 로고( ~2024.04)

분산 락을 구현하기 위해 많이 쓰이는 도구 중 하나가 Redis이다.

메모리 기반의 Key-Value 저장소이다. NoSQL DB.

빠른 속도와 다양한 자료구조 지원 덕분에 분산 락, 캐시, 세션 저장소, 메시지 브로커 등 여러 용도로 쓰인다.

레디스의 Lock 3가지 방식

Simple Lock

lock 획득 실패 시 비즈니스 로직을 수행하지 않음

락 획득 여부 = redis 에서 key 로 확인
if (락 획득) {
	try {
	  로직 실행
	} finally {
	  lock 제거
	}
} else {
  throw Lock 획득 실패 예외
}

항해플러스 발제자료 발췌

Spin Lock

lock 획득 실패 시 일정 횟수 재시도

재시도 횟수 = 0
while (true) {
  락 획득 여부 = redis 에서 key 로 확인 // SETNX key "1"
  if (락 획득) {
		try {
		  로직 실행
		} finally {
		  lock 제거
		}
		break;
  } else {
	  재시도 횟수 ++
	  if (재시도 횟수 == 최대 횟수) throw Lock 획득 실패 예외
	  시간 지연 ( 대기 )
  }
}

항해플러스 발제자료 발췌

Pub/Sub

lock 획득 실패 시 "구독"하고, 차례를 기다림

락 획득 여부 = redis 에서 lock 데이터 에 대한 subscribe 요청 및 획득 시 값 반환
// 특정 시간 동안 Lock 에 대해 구독
if (락 획득) {
	로직 실행
} else {
	// 정해진 시간 내에 Lock 을 획득하지 못한 경우
	throw Lock 획득 실패 예외
}

항해플러스 발제자료 발췌

출처: 같은 팀원이 AI로 생성한 이미지

락과 트랜잭션의 순서

락과 트랜잭션은 데이터의 무결성을 보장하기 위해 아래와 같은 순서로 수행되어야 한다.

락 획득 ➡️ 트랜잭션 시작 ➡️ 비즈니스 로직 수행 ➡️ 트랜잭션 종료 ➡️ 락 해제

아래 이미지 처럼 락 해제를 먼저하고 트랜잭션을 종료하면 어떻게 될까?

출처: https://helloworld.kurly.com/blog/distributed-redisson-lock/

⚠️ 락 해제가 먼저되고 커밋되면, 데이터 정합성에 문제가 있을 수 있다.

재고가 총 8개가 되어야 하는데, 데이터 정합성이 깨져서 재고가 9개가 될 수 있다.

이 처럼 분산 락 구현 시에 순서가 중요하다.

트랜잭션 범위를 락 범위가 감싸야 정상적으로 재고 차감이 이루어질 수 있다.

출처: https://helloworld.kurly.com/blog/distributed-redisson-lock/

과제 피드백 회고

멀티 락 사용의 실수

Redis로 분산 락을 AOP 방식으로 구현해서 주문 및 결제 기능에 적용했다.

그러나 멀티 락 사용을 하는데 있어, 키 전략에서 실수가 있었다.

유저ID 1번, 상품ID 100번
유저ID 100번 상품ID 1번

위 와 같은 상황일 경우에는 유저ID가 100번인 경우 불필요한 대기가 발생

@Service
@RequiredArgsConstructor
public class OrderFacade {

    private final OrderService orderService;
    private final CouponService couponService;
    private final ProductService productService;
    private final UserService userService;

    @DistributedLock(lockType = LockType.ORDER, keys = {
        "#command.userId()",	// ⚠️ 유저ID를 키에 넣은 게 실수!
        "#command.OrderItemCommands().![productId]"
    })
    @Transactional
    public OrderResult placeOrderWithPayment(CreateOrderCommand command) {
        // 1. 쿠폰 처리
        BigDecimal discountRate = BigDecimal.ZERO;
        if (command.couponId() != null){
            discountRate = couponService.applyCouponForOrder(command.couponId());
        }

        // 2. 주문 총액 사전 계산 및 잔액 검증
        BigDecimal totalAmount = productService.calculateTotalAmount(command.OrderItemCommands(), discountRate);
        userService.validateBalance(command.userId(), totalAmount);
        
        // 3. 상품 재고 차감
        List<Product> persistedProducts = productService.decreaseProductStocks(command.OrderItemCommands());
        
        // 4. OrderItem 리스트 변환
        List<OrderItem> orderItems = orderService.createOrderItems(command.OrderItemCommands(), persistedProducts);
        
        // 5. OrderService를 통한 주문 생성
        OrderResult orderResult = orderService.createOrder(command, discountRate, orderItems);

        // 6. 유저 잔액 차감 (이미 검증됨)
        userService.useBalance(command.userId(), orderResult.paidPrice());

        return orderResult;
    }

}

KPT회고

Keep

분산 락 구현만 하고 싶었는데, 캐싱까지 구현했음 (캐싱 구현하려면 인기상품 조회 기능 개발해야했어서..하하)

Problem

MySQL과 Redis를 테스트 컨테이너에서 실행하려는데, 설정이 꼬여서 많이 어려웠음
STEP09-10(이전 과제) 브랜치에서 작업하다가 커밋하는 어메이징한 실수를 저질러서 과제 제출 전에 멘탈이 나갈 뻔했음 :)

Try

피드백 반영하기

[WIL] DB Lock을 이용한 동시성 제어(Java, Spring)

Jeanin — Mon, 11 Aug 2025 00:00:29 +0900

본 글은 항해플러스 백엔드 9기 교육 과정 수강중 작성된 학습노트입니다.
⚠️개인이 학습한 것을 바탕으로 작성되어 부정확할 수 있으며, 오류가 있다면 알려주시면 감사하겠습니다.

❔WIL(Weekly I Learned)

동시성 제어(Concurrency Control)

동시성 제어는 여러 트랜잭션이 동시에 실행될 수 있도록 허용하면서도 데이터의 일관성, 무결성이 유지될 수 있도록 하여 전반적인 데이터 정합성을 보장할 수 있도록 하는 방법이다.

동시성 문제

여러 트랜잭션(또는 스레드)이 DB에 접근하려고 하면 어떻게 될까?

상품 재고를 차감하려는 여러 트랜잭션이 있다면?

트랜잭션(Transaction)이란?
더 이상 나눌 수 없는 하나의 완결된 작업 단위
모든 과정이 완료되어야 의미가 있는 작업의 최소 단위
일반적으로는 데이터베이스의 트랜잭션을 지칭하지만, CS 전반에서 사용되는 개념

상품 재고를 차감하려면 먼저 현재 재고 상태를 `SELECT(조회)` 해와야 한다.

동시의 2개의 트랜잭션이 현재 재고 수량을 10개로 조회했다면, 2개 중 하나의 트랜잭션은 작업 내용을 잃게 된다.

1번: 재고 10개로 조회해서 1개 차감
2번: 재고 10개로 조회해서 1개 차감

⚠️ 재고가 최종적으로 8개여야 하는데, 2번 트랜잭션에 대한 작업 내용 분실됨

출처: 항해플러스 발제 자료

DB Lock

동시성 제어를 위한 여러가지 방법이 있지만, 이번 챕터에서는 DB Lock을 이용해 동시성을 제어하기로 한다.

락의 종류에는 2가지가 있다.

Pessimistic Lock (비관적 락)
Optimistic Lock (낙관적 락)

구분	Pessimistic Lock (비관적 락)	Optimistic Lock (낙관적 락)
핵심 아이디어	“충돌(경합)이 자주 난다” → 먼저 잠그고 진행	“충돌(경합)이 드물다” → 일단 진행, 끝에 충돌 검사
동작 방식	트랜잭션 시작 시점에 DB 레벨 잠금(행/범위)을 획득하고 유지(FOR UPDATE 등)	레코드에 버전(또는 타임스탬프) 필드 유지 → 커밋 전 비교 불일치 시 예외로 재시도
충돌 처리	대기(락 대기 시간/타임아웃) 또는 데드락	예외(OptimisticLockException) 발생 → 애플리케이션 레벨 재시도
데드락 위험	상대적으로 높음(락 순서/범위 설계 필요)	거의 없음(락이 아니라 버전 비교)
스루풋/지연	경쟁 심하면 지연 증가, 스루풋 저하	경쟁이 드물면 고스루풋, 충돌 시 재시도 비용 발생
읽기 처리	공유/배타 락으로 인해 읽기도 지연될 수 있음	읽기는 자유로움(스냅샷 일관성 전제)
롤백/복구	DB가 동기적으로 직렬화에 가깝게 보장	애플리케이션이 재시도·머지 전략 필요
적용에 유리한 경우	재고 차감·좌석/쿠폰 선착순 등 “유일성/수량 소진” 같이 충돌이 빈번·치명적일 때	대다수 조회+소수 업데이트, 폼 편집, 비즈니스가 약간의 재시도 허용할 때
트랜잭션 길이 민감도	매우 민감(짧게 유지 필수)	상대적으로 덜 민감(그래도 짧을수록 좋음)
운영상 주의	락 범위 최소화, 인덱스 설계, 타임아웃/재시도, 락 순서 고정	버전 컬럼 필수, 재시도 백오프·최대 시도 수, 사용성 메시지
모니터링 지표	락 대기 시간, 데드락 수, InnoDB row lock waits	OptimisticLockException 비율, 재시도 성공률
DB 의존성	강한 DB 락 기능에 의존	상대적으로 DB 독립적(ORM 버전 필드)

동시성 제어 보고서

https://github.com/bskjp1004/hhplus-ecommerce-server/blob/STEP09-STEP10/docs/report/STEP09/Concurrency_Controll_Report.md

hhplus-ecommerce-server/docs/report/STEP09/Concurrency_Controll_Report.md at STEP09-STEP10 · bskjp1004/hhplus-ecommerce-server

Contribute to bskjp1004/hhplus-ecommerce-server development by creating an account on GitHub.

github.com

KPT회고

Keep

미구현되어있던 선착순 쿠폰발급 기능을 구현했음
비관적 락으로만 우선 다 구현하고, 낙관적 락은 안하려했는데.. 결국 했음

Problem

최근 3일간 인기상품 조회 기능도 마저 구현하려했는데, 이번 주차 과제에 더 집중하기 위해 구현하지 못한게 아쉬움
낙관적 락을 적용하면서, 기존에 잘 작동하던 통합테스트들이 에러나는 걸 겪으며, 괜히 낙관적 락을 적용하려 시도했나.. 세상이 무너짐을 겪었음.

Try

미구현된 기능 구현

[WIL] JPA와 테스트 컨테이너

Jeanin — Tue, 5 Aug 2025 01:17:12 +0900

본 글은 항해플러스 백엔드 9기 교육 과정 수강중 작성된 학습노트입니다.
⚠️개인이 학습한 것을 바탕으로 작성되어 부정확할 수 있으며, 오류가 있다면 알려주시면 감사하겠습니다.

❔WIL(Weekly I Learned)

JPA(Java Persistence API)

출처: https://albertprofe.dev/springboot/boot-concepts-jpa-2.html

JPA는 Java 진영에서 사용되는 ORM 기술 표준이다.

JPA는 인터페이스이기 때문에 실제적으로 JPA를 구현한 ORM 프레임워크는 Hibernate, OpenJPA, EclipseLink 등이 있다.

ORM 프레임워크 중에서는 Hibernate가 많이 사용된다고 한다.

ORM이란?
데이터베이스의 테이블과 객체를 연결하여, SQL 쿼리 없이 객체 조작만으로 데이터베이스 작업을 가능하게 하는 기술.

JPA - Hibernate 사용 방법

의존성 추가(Gradle 기준)

`build.gradle.kts`파일에 아래 의존성 추가

dependencies {
	// Spring Data JPA
	implementation 'org.springframework.boot:spring-boot-starter-data-jpa'
    // MySQL
	runtimeOnly 'mysql:mysql-connector-java'
}

데이터베이스 연결 설정

`src/main/resources/application.yml`에 접속 정보 작성

spring:
  # DB 접속정보는 {} 안의 정보를 수정
  datasource:
    url: jdbc:mysql://localhost:3306/{your_db_name}?serverTimezone=Asia/Seoul&characterEncoding=UTF-8
    username: {db_user}
    password: {db_password}
  jpa:
    hibernate:
      ddl-auto: update      # 개발 중: update, 배포 전엔 validate 또는 none 권장
    show-sql: true          # 실행되는 SQL 로그 확인
    properties:
      hibernate:
        format_sql: true

엔티티 클래스 정의

@Entity
@Table(name = "orders")
public class OrderJpaEntity {

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

    @Column(nullable = false)
    private Long userId;

    private LocalDateTime orderedAt;

    // ... getter, setter, 생성자 등
}

리포지토리(Repository) 인터페이스 생성

import org.springframework.data.jpa.repository.JpaRepository;
import java.util.List;

public interface OrderRepository extends JpaRepository<OrderJpaEntity, Long> {
    // 메서드 이름으로 쿼리 자동 생성
    List<OrderJpaEntity> findAllByUserId(Long userId);
}

서비스 레이어에서 사용

@Service
public class OrderService {

    private final OrderRepository orderRepository;

    public OrderService(OrderRepository orderRepository) {
        this.orderRepository = orderRepository;
    }

    @Transactional(readOnly = true)
    public List<OrderJpaEntity> getOrdersByUser(Long userId) {
        return orderRepository.findAllByUserId(userId);
    }

    @Transactional
    public OrderJpaEntity createOrder(OrderJpaEntity order) {
        order.setOrderedAt(LocalDateTime.now());
        return orderRepository.save(order); // JpaRepository에서 제공되는 save 메서드
    }
}

테스트 컨테이너(Testcontainers)

JPA를 이용해 인프라스트럭처 계층의 코드를 작성하고, 실제 DB 범위까지의 통합테스트를 작성하기로 한다.

통합테스트에 유용하게 쓰이는 도구로 테스트 컨테이너가 있다.

출처: https://www.devkuma.com/docs/testcontainers/overview/

테스트 컨테이너(Testcontainers)는 도커 컨테이너를 이용해 실제 서비스와의 통합 테스트를 수행하기 위한 경량화된 컨테이너 라이브러리이다.

테스트 환경을 구성하기 귀찮은데, 테스트 컨테이너가 도커를 이용해 DB 환경을 만들고 테스트가 종료되면 도커 컨테이너가 종료되니 테스트 데이터도 같이 지워진다.

테스트 컨테이너(Testcontainers) 사용 방법

도커 데스크탑 설치

https://www.docker.com/products/docker-desktop/

Docker Desktop: The #1 Containerization Tool for Developers | Docker

Docker Desktop is collaborative containerization software for developers. Get started and download Docker Desktop today on Mac, Windows, or Linux.

www.docker.com

의존성 추가(Gradle 기준)

`build.gradle.kts`파일에 아래 의존성 추가

dependencies {
    // Spring Boot Test (JUnit5 포함)
    testImplementation("org.springframework.boot:spring-boot-starter-test")
    // Spring Boot 와 Testcontainers 통합 스타터
    testImplementation("org.springframework.boot:spring-boot-testcontainers")
    // JUnit5용 Testcontainers 어댑터
    testImplementation("org.testcontainers:junit-jupiter")
    // MySQL 컨테이너 모듈
    testImplementation("org.testcontainers:mysql")
}

통합 테스트 코드 작성

`src/test/` 패키지 하위에 테스트 클래스 생성 및 테스트 코드 작성

import org.junit.jupiter.api.Test;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.DynamicPropertyRegistry;
import org.springframework.test.context.DynamicPropertySource;
import org.testcontainers.containers.MySQLContainer;
import org.testcontainers.junit.jupiter.Container;
import org.testcontainers.junit.jupiter.Testcontainers;

@Testcontainers
@SpringBootTest
class OrderIntegrationTest {

    // 1) MySQL 컨테이너 선언 (static이면 테스트 클래스 당 한 번만 띄웁니다)
    @Container
    static MySQLContainer<?> mysql =
        new MySQLContainer<>("mysql:8.0")
            .withDatabaseName("testdb")
            .withUsername("test")
            .withPassword("test");

    // 2) 컨테이너 프로퍼티를 Spring 환경에 등록
    @DynamicPropertySource
    static void registerMysql(DynamicPropertyRegistry registry) {
        registry.add("spring.datasource.url",      mysql::getJdbcUrl);
        registry.add("spring.datasource.username", mysql::getUsername);
        registry.add("spring.datasource.password", mysql::getPassword);
    }

    @Autowired
    private OrderFacade orderFacade;

    @Test
    void placeOrder_success() {
        // given
        CreateOrderCommand cmd = /* ... */;
        // when
        OrderResult result = orderFacade.placeOrderWithPayment(cmd);
        // then
        assertThat(result).isNotNull();
    }
}

KPT회고

Keep

기본 과제만 하고 포기하고 싶었지만 심화 과제까지 도전하였음
3주차 피드백을 반영해 개선한 점. 커밋을 잘 해보려 노력하였음..

Problem

JpaEntity를 작성하고 연관 관계에 있는 도메인끼리 맵핑하는 작업이 어려웠음
핵심 기능 이외의 요구사항에 작성된 기능도 개발하고 싶었지만, 시간이 부족했음

Try

4주차 피드백 반영하기
핵심 기능 이외의 기능 1개 추가 개발하기

[WIL] 레이어드 아키텍처(Layered Architecture)

Jeanin — Mon, 28 Jul 2025 00:52:25 +0900

본 글은 항해플러스 백엔드 9기 교육 과정 수강중 작성된 학습노트입니다.
⚠️개인이 학습한 것을 바탕으로 작성되어 부정확할 수 있으며, 오류가 있다면 알려주시면 감사하겠습니다.

❔WIL(Weekly I Learned)

레이어드 아키텍처(Layered Architecture)

출처: https://www.codzgarage.com/blog/software-architecture-patterns/

레이어드 아키텍처는 가장 일반적인 아키텍처로 대부분의 Java EE 애플리케이션에서 사실상 표준으로 사용되고 있다.

아키텍처 이름 그대로 n개의 계층이 레이어 처럼 구성되어 있는 패턴이며, 보통 4가지의 계층으로 구성된다.

각각의 계층은 애플리케이션 내에서 특정 역할과 책임을 갖는다.

각 계층의 역할과 책임

이렇게 각 계층마다 역할과 책임을 분리하는 이유는 무엇일까?

바로 구성 요소간의 관심사를 분리하기 위해서다.

개인적으로는 객체지향설계 5원칙(SOLID) 중에서 S에 해당하는 '단일 책임 원칙(Single Responsibility Principle)'과 비슷하다고 생각했다.

계층마다 관심사를 분리하면 테스트와 유지보수가 수월해진다.

출처: https://www.oreilly.com/content/software-architecture-patterns/

Presentation Layer(프레젠테이션 계층)
- 사용자 인터페이스 및 브라우저/클라이언트와의 통신 로직을 담당하는 계층
- e.g. `Controller`, `DTO(View 용)`
Business(Application) Layer(비즈니스 계층)
- 핵심 비즈니스 로직을 수행하는 계층
- e.g. `Service`, `Domain Model`, `DTO(내부 전달용)`
Persistence Layer(영속성 계층)
- 데이터베이스와의 상호작용을 전담하는 계층
- e.g. `Repository`, `ORM`, `JpaEntity`
Database Layer(데이터베이스 계층)
- 실제 데이터 저장소의 역할을 하는 계층, 애플리케이션 내부 계층이 아닌 외부 인프라 자원으로 간주됨
- e.f. `MySQL`, `PostgreSQL`, `MongoDB`, `Redis`

상위 계층 → 하위 계층, 의존은 단방향이어야 한다

출처: https://www.oreilly.com/content/software-architecture-patterns/

레이어드 아키텍처의 핵심 개념 중 하나는 '폐쇄형 계층'이다.

이게 무슨 의미일까?

요청 흐름이 계층을 하나씩 통과해야 하며, 특정 계층을 점프하듯 건너뛸 수 없다는 뜻이다.

코드 구조 상 상위 계층(`Conttoller`)은 하위 계층(`Service`)을 참조할 수 있지만, 하위 계층은 그럴 수 없다.

`Controller`에서 `Service`를 건너뛰고 `Repository`를 직접 호출 ➡️ 계층 건너뛰기 금지❌

` Repository `에서 ` Service `를 참조 ➡️ 하위 계층이 상위 계층을 역방향 참조 금지❌

Layered Architecture with DIP, 레이어드 아키텍처의 진화

전통적인 레이어드 아키텍처는 변화에 취약한 의존성 구조를 가지고 있다.

만약 `Service`가 `JpaRepository 구현체`를 직접 참조해서 개발된 코드가 있다면,

ORM을 JPA가 아닌 다른 도구로 바꾸려면 유지보수 비용과 시간이 많이 소요된다.

이를 보완하기 위해 DIP(Dependency Inversion Principle, 의존성 역전 원칙) 개념이 도입되었다.

1차 출처: 《 도메인 주도 개발 시작하기: DDD 핵심 개념 정리부터 구현까지 》, 최범균

2차 출처: 도메인 주도 개발 시작하기 - 2 (아키텍처 개요 - 2장)

DIP를 지키기 위해 도메인 영역(비즈니스 계층)에서 `OrderRepository`와 같이 인터페이스를 작성하고,

인프라스트럭처 영역(영속성 계층)에서 `JpaOrderRepository`로 구현한다.

이렇게 하면 `OrderService`가 `JpaOrderRepository` 구현체를 직접 의존하지 않고, 인터페이스를 통해 의존하기 때문에 JPA가 아닌 다른 ORM으로 바뀐다면 구현체만 바꾸면 되기때문에 변화에 능동적을 대처할 수 있다.

아키텍처를 직접 적용해보자

아키텍처 개요 작성

프로젝트 패키지 구조

KPT회고

Keep

최대한 아키텍처의 의존성 역전 원칙을 지키기 위해 노력한 점
1주차 TDD 피드백을 공부해 `AssertJ`를 활용해 가독성을 높이려 했음

Problem

요청 및 응답 DTO를 활용해 아키텍처 계층 경계에서 요청하고 반환받는 구조를 짜는게 어려웠음
예외 처리도 계층별로 분리하고 싶었으나 제대로 작성한 것 같지는 않음
2주차 설계와 많이 달라지지는 않았지만 시퀀스 다이어그램이나 API 명세서가 아주 약간 지켜지지 않은 것 같음.

Try

요청 및 응답 DTO 활용 방안에 대해 더 심도있게 공부
설계 수정해서 반영하기

레퍼런스

https://www.oreilly.com/content/software-architecture-patterns/

Software architecture patterns

Take a deep dive into several common software architecture patterns

www.oreilly.com

https://velog.io/@gehwan96/%EB%8F%84%EB%A9%94%EC%9D%B8-%EC%A3%BC%EB%8F%84-%EA%B0%9C%EB%B0%9C-%EC%8B%9C%EC%9E%91%ED%95%98%EA%B8%B0-2%EC%9E%A5.-%EC%95%84%ED%82%A4%ED%85%8D%EC%B2%98-%EA%B0%9C%EC%9A%94

도메인 주도 개발 시작하기 - 2 (아키텍처 개요 - 2장)

1. 네 개의 영역 웹 애플리케이션의 표현 영역 HTTP 요청을 응용 역역이 필요로 하는 형식으로 변환해 전달 응용 영역의 응답을 HTTP 응답으로 변환하여 전송 웹 애플리케이션의 응용 영역 표현 영

velog.io

[WIL] 개발의 시작 단계: 설계

Jeanin — Sun, 20 Jul 2025 21:25:05 +0900

본 글은 항해플러스 백엔드 9기 교육 과정 수강중 작성된 학습노트입니다.
⚠️개인이 학습한 것을 바탕으로 작성되어 부정확할 수 있으며, 오류가 있다면 알려주시면 감사하겠습니다.

❔WIL(Weekly I Learned)

분석 및 설계 단계의 산출물들

요구사항 명세서: 프로젝트의 기능과 특징, 설계 및 제한사항들이 담긴 기술 문서
- 기능: 시스템이나 소프트웨어가 수행해야 하는 특정 기능 또는 작업을 정의
- 비기능: 시스템의 품질, 성능, 보안, 유지보수 등과 관련된 요구사항을 정의

시퀀스 다이어그램: 시스템 내에서 객체(또는 서비스)들이 어떻게 상호 작용하는지를 시간 순서대로 표현하는 다이어그램
클래스 다이어그램: 시스템에서 사용되는 객체(Class)들의 구조와 관계를 표현하는 다이어그램
상태 다이어그램: 객체 또는 프로세스가 특정 이벤트에 따라 상태가 어떻게 변하는지를 표현하는 다이어그램
ERD 다이어그램: 데이터베이스의 테이블 간 관계를 표현하는 다이어그램
API 명세서: API 명세서는 API의 동작 방식, 엔드포인트, 요청 및 응답 구조, 인증 방식 등을 설명하는 문서

요구사항 명세서

주어진 과제를 기반으로 요구사항 명세서를 작성했다.

기능보다 비기능 요구사항 작성하는 게 더 어려웠던 것 같다.

시퀀스 다이어그램

중요하다고 생각되는 기능 3가지 정도만 시퀀스 다이어그램을 작성했다.

잔액 충전
주문/결제
쿠폰 발급

아래는 주문/결제에 대한 시퀀스 다이어그램이다.

ERD 다이어그램

핵심이라고 생각되는 테이블만 작성했고, `주문` 테이블의 `user_id`는 실제로 DB 생성 시 `FK`를 설정 안하고, JPA에서만 관계를 설정해주려고 생각중이다.

API 명세서

`yaml` 파일에 API 명세를 작성한 뒤 Swagger UI로 깔끔하게 볼 수 있도록 했다.

Swagger가 뭔지는 알고 있었는데, 이번에 처음 활용해봤다.

Keep

과제를 제출했음
브랜치를 나누어 작업하였음
PR을 알맞게 작성하였음
커밋을 키워드를 붙여 세세하게 작성하였음

Problem

클래스 다이어그램, 상태 다이어그램도 학습을 위해 작성하려했으나, 시간 부족으로 하지 못한게 아쉬움
Mock API 작성에서 yaml 파일을 직접 작성하는 것이 아닌, 컨트롤러를 만들었다면 E2E 테스트까지 할 수 있었을 것 같은데, 못해서 아쉬움

Try

다이어그램 및 설계서 작성을 좀 더 심도있게 공부할 것
RESTful API와 관련된 용어 및 개념을 더 심화 학습 할 것

[WIL] TDD? 들어는 봤는데, 직접 작성해 보라구?!

Jeanin — Sun, 13 Jul 2025 23:07:49 +0900

본 글은 항해플러스 백엔드 9기 교육 과정 수강중 작성된 학습노트입니다.
⚠️개인이 학습한 것을 바탕으로 작성되어 부정확할 수 있으며, 오류가 있다면 알려주시면 감사하겠습니다.

❔WIL(Weekly I Learned)

테스트 코드 작성 첫 도전기

'TDD' 들어는 봤지만, 직접 작성해본 경험이 없어서 굉장히 당황했다.

하루종일 작성한 코드를 몽땅 삭제하고, PR 작성에 서툴러 과제 제출 20분 전에 후다닥 수정하고..

우당탕탕 TDD 학습 주간이었다.

TDD에 대하여

출처: https://namu.wiki/w/%ED%85%8C%EC%8A%A4%ED%8A%B8%20%EC%A3%BC%EB%8F%84%20%EA%B0%9C%EB%B0%9C

TDD(테스트 주도 개발)는 요구사항의 기능을 개발하기 전에 실제적인 구현보다 테스트 코드를 먼저 작성하여, 작은 단위의 테스트 케이스를 통과하는 코드를 작성하는 것을 반복하여 기능을 구현하는 소프트웨어 방법론이다. 2002년 켄트 벡이 자신의 책을 출간하게 되면서 알려졌다고 한다.

테스트 코드 작성 순서는 아래와 같다.

Write a failing test: 실패하는 테스트 코드를 먼저 작성한다.
Make the test pass: 테스트 코드를 성공시키기 위한 실제 코드를 작성한다.
Refactor: 중복 코드 제거, 일반화 등의 리팩토링을 수행한다.

테스트의 범위는?

테스트의 범위는 어떻게 정할까?

가짜 데이터베이스를 만들어 포인트 충전에 대한 서비스에 대해서만?

클라이언트에서 오는 요청부터 서비스와 실제 데이터베이스를 거쳐 서버가 클라이언트에게 응답을 보내주는 것 까지?

테스트에 범위에 따라 다음과 같이 단위 테스트, 통합 테스트, E2E 테스트로 나뉜다.

(처음 입문하면 이 범위가 어디까지 인가에 대해 많이 고민하고, 어려운 부분이다.)

Unit Testing(단위 테스트)	함수, 메서드, 클래스 단위로 개별 동작이 정확한지 확인
Integration Testing(통합 테스트)	여러 모듈이나 서비스 간의 상호작용이 잘 이루어지는지 확인
End-to-End Testing(E2E 테스트)	시스템을 실제 사용자처럼 전체적으로 테스트

테스트 피라미드

테스트 코드를 빠르고 안정적이며 유지 관리가 쉽게 하려면 테스트 피라미드(Test Pyramid)의 개념을 명확히 알아두면 좋다.

출처: https://circleci.com/blog/testing-pyramid/

End-to-end testing(E2E 테스트): 피라미드의 꼭대기에 위치한 E2E 테스트는 사용자 인터페이스, API, 데이터베이스 및 기타 서비스를 포함하여 최종 사용자가 경험하는 방식대로 전체 애플리케이션을 검사하는 것을 포함합니다. 가장 복잡하고 실행 시간이 가장 깁니다.
Integration testing(통합 테스트): 피라미드의 중간 부분을 차지하는 이 테스트는 서로 다른 모듈이나 외부 시스템 간의 상호작용을 확인합니다. 단위 테스트에 비해 개수가 적고, 비용이 많이 들며, 실행 속도가 느립니다.
통합 테스트는 단위 테스트보다 빈도를 줄여야 하며, 일반적으로 개발 주기의 주요 시점, 예를 들어 중요한 기능이나 변경 사항이 프로젝트의 주요 브랜치에 통합된 후에 실행해야 합니다. 이렇게 하면 세부적이고 세부적인 단위 테스트가 모든 작은 변경 사항에 대해 실행되는 반면, 통합 테스트는 주요 단계에서 시스템의 전반적인 일관성과 기능을 검증하여 개발 프로세스의 철저함과 효율성 사이에서 균형을 유지할 수 있습니다.
Unit testing(단위 테스트): 피라미드의 기반을 형성하는 이 테스트는 단일 기능과 작은 코드 단위에 초점을 맞춥니다. 일반적으로 개수가 많지만 작성하고 실행하는 데 시간이 오래 걸리지 않습니다. 단위 테스트는 자주 실행해야 하며, 이상적으로는 자동화된 지속적 통합 프로세스 의 일부로 실행해야 합니다 . 이렇게 하면 새로운 변경 사항이 기존 기능을 손상시키지 않는지 확인하고 개발 라이프사이클 전반에 걸쳐 높은 수준의 코드 품질을 유지할 수 있습니다.

⬇️ 테스트 피라미드 출처 ⬇️

https://circleci.com/blog/testing-pyramid/

The testing pyramid: Strategic software testing for Agile teams

Enhance your development process with the testing pyramid. Learn tips for adding unit, integration, and E2E tests for improved reliability and quality.

circleci.com

Keep

과제 제출을 완료한 점, PASS를 받은 점이 잘했음
테스트 케이스를 여러 경우를 생각해보려는 시도가 좋았음(코치님 리뷰)

Problem

각 계층에 대한 역할과 책임에 대한 고민을 많이 했지만, 아직 부족한 것 같다.
- 잔액이 증가되어야 하는 역할과 책임은 누구에게 있어야 할까?
예외 처리에 대한 고민이 부족했던 것 같다.
- `ApiControllerAdvice`에 더 다양한 에러 처리를 작성했으면 좋았을 것 같다.
Git 커밋과 PR 작성에 서툴렀던 것 같다.

Try

Git 커밋을 기능별로 작성하기(깃 데스트탑 이용), PR을 STEP 별로 브랜치 생성해서 작성하기
도메인에 역할과 책임을 고민해보기(도메인에 작성되어야 할 기능이 무엇인지)
피드백을 반영해서 테스트 코드 수정해보기

[개발자 커리어 회고] 시작하는 마음

Jeanin — Mon, 7 Jul 2025 01:52:17 +0900

지금까지 개발자 커리어 회고

심리학 전공을 그만두고 개발자의 길로 들어서다

고등학생 때부터 목표했던 상담사의 꿈은 대학원 진학 실패와 취직 압박으로 잠시 접어두고, 새로운 진로 '개발자'를 꿈꾸게 되었다.

개발자 부트캠프가 취업 연계를 해준다는 친구의 말에 교육과정에 참여하게 되었다.

빅데이터 서비스 개발자 과정에 참여하면서 `Java`, `Python` 등의 프로그래밍 언어를 익히고, 새로운 지식들을 이해하고 머릿속에 집어넣기 바쁜 나날을 보냈다.

(그 당시 `for문`을 이용해 별 짓기 코드를 짜는 것을 어려워해서 부끄러웠던 기억이 있다.. )

크고 작은 여러 프로젝트를 진행하며, 팀원들과 토의하고 밤 10~11시까지 코딩하며 어떻게든 마무리하려 애를 썼었다.

6개월의 시간이 지나 과정을 무사히 수료했고, 첫 직장으로 MES 솔루션을 서비스하는 SI 회사에 입사하게 되었다.

개발자 새싹 을 틔우기까지

첫 직장에 입사하고 `C#`, `MSSQL` 등의 기술을 배우며 개발자로의 커리어를 시작했다.

`.NET Framework`, 유료 라이브러리 `DevExpress` 등을 이용해 웹 기반 MES 솔루션 개발을 담당했다.

(지금 생각하면 어이없는 일이지만, 입사일에는 사수가 비주얼 스튜디오 IDE에서 디버깅하는 방법부터 가르쳐 주었다.. )

입사할 당시만 해도 회사가 2년밖에 안 돼서 외주 맡겨 받은 프로젝트를 복사하는 방식으로 개발했었고, 하드코딩과 레거시 코드가 많았다.

특정 `Controller`, `Service` 기능을 만드는 것보다는 DB에 데이터를 넣고 수정하기 위해 쿼리문을 작성하는 일이 주로 대부분이었다.

사용자가 누르는 버튼과 직접 연결된 비하인드 코드에 기능을 작성하면 되는 방식인 `.NET Framework WebForms`를 이용한 웹 페이지 개발은 개발자가 빠르게 이해가 가능하고 바로 코드 작성이 용이하지만, 자잘한 코드 실수가 많이 발생했다.

(`.NET Framework WebForms`: 버튼 클릭, 텍스트 입력, 페이지 로딩 등의 사용자 인터랙션을 이벤트로 처리하고, 개발자는 해당 이벤트에 대한 핸들러 메서드만 작성하면 되는 구조)

이에 코딩 천재 동료 개발자가 `Blazor`를 도입해 DI(의존성 주입), Entity, DTO, Controller, Service 등의 개념을 이용해 유지보수가 용이하고 메서드 간의 강결합을 느슨하게 할 수 있도록 개선했다.

(그 당시 2년 차 개발자였지만, 당연한 개념을 이제야 알게 된 것 같아 창피했다.)

새로 맡은 식품업 관련 솔루션은 바로 차세대 프레임워크를 가져다 개발했다.

유저 인증이나 시스템 관리 모듈을 작성하면서 새로 배우는 개념들을 적용했는데, 많이 부딪히고 깨졌다.

활짝 피지못하고 아직 꽃봉오리, 성장이 더욱 고프다..

팀장 직책을 맡고, R&D 부서로 팀 이동이 되면서 개발 업무뿐만 아니라 인건비 사업 관리나 자잘한 회사 업무도 맡게 되었다.

물론 노력과 열정만 있으면 이런 업무를 맡으면서 개발도 같이하는 것이 어렵지 않은 사람도 있겠지만,

나는 조금 과부하가 왔던 것 같다.

사업계획서 작성, 사업 관리, 개발 업무, 프로젝트 서버 배포, 교육 등

프로젝트의 시작과 끝을 모두 해본 경험은 아주 귀중했다.

하지만 이제는 전반적인 모든 업무를 할 줄 아는 것보다,

개발 스킬업과 직무를 더 첨예하게 갈고닦을 필요성을 절실히 느꼈다.

4년 10개월... 연차로 따지면 5년 차 개발자인데

대용량 데이터 처리와 테스트 주도 개발, 하물며 기본 개발 지식이 부족한 건 말이 안 되는 거다.

항해 플러스 참여 계기

백엔드 개발자로 더욱 성장하기 위해, 더 높은 연봉을 받기 위해 이직하기로 결정했다.

이력서와 포트폴리오를 작성하고 여러 대기업 채용공고에 지원했지만, 서류 단계 부터 탈락하기 일쑤였다.

(이력서를 몇십 개씩 지원한다는데, 아직은 열 손가락 안에 꼽을 횟수다..)

'아, 내가 갖추지 못한 자질과 경험이 있다. 좀 더 전문적인 지식을 갈고 닦아야 겠다..'

여기 저기 검색을 하다 항해 플러스 백엔드 교육 과정을 보게 되었다.

'딱 내 이야기인데? '

향후 5년 뒤 커리어 방향성

나의 커리어는 2가지 선택지를 고려 중이다.
항해 플러스의 코치님들처럼 진짜 시니어 개발자가 되고 싶다.
같은 개발자 출신으로서 커뮤니케이션이 잘 통하는, 설계 짱 잘하는 기획자가 되고 싶다.

10주간의 목표

기본 과제 제출 완료하기
팀장 역할 충실히 이행하기(팀원들 중도 탈락 막기, 응원하기)
교육 과정 완주하기

최종 목표 배지

브라운 배지(과제 80%이상 통과)

(조건이 '제출'이 아니라 '통과'인 점에 주목해야한다.)

[사전스터디/Java] Java 언어 강의 학습노트③

Jeanin — Thu, 3 Jul 2025 20:59:13 +0900

본 글은 항해플러스 백엔드 9기 과정의 일환인 개강 전 '사전스터디'의 학습노트입니다.
⚠️개인이 학습한 것을 바탕으로 작성되어 부정확할 수 있으며, 오류가 있다면 알려주시면 감사하겠습니다.

강의 수강 목록

Optional - null을 다루는 법
컬렉션(Collection)
제네릭(Generic)
람다(Lambda)
스트림(Steram)

Optional - null을 다루는 법

왜 Optional이 필요한가?

기본적인 null 체크 방법은 아래와 같다.

String name = getUserName();
if (name != null) {
    System.out.println(name.length());
}

⚠️ 문제점: null 체크를 매번 해야 하고, 실수로 빼먹으면 `NullPointerException`

Optional 기본 사용법

1. Optional 객체 생성

Optional<String> name = Optional.of("ChatGPT"); // 값이 반드시 있어야 함
Optional<String> empty = Optional.empty();       // 비어있는 Optional
Optional<String> nullable = Optional.ofNullable(null); // null도 가능

2. 값 꺼내기

name.get();                    // 값이 없으면 NoSuchElementException 발생
name.orElse("기본값");         // 값이 없으면 기본값 리턴
name.orElseGet(() -> "기본");  // 람다로 기본값 제공
name.orElseThrow();            // 값이 없으면 예외 발생 (기본적으로 NoSuchElementException)

3. 값이 있을 때만 처리

name.ifPresent(value -> System.out.println(value)); // 값이 있으면 실행

컬렉션

분류	인터페이스	주요 구현 클래스	특징	주요 메서드
목록(List)	`List<E>`	`ArrayList`, `LinkedList`, `Vector`	순서 있음, 중복 허용, 인덱스 접근 가능	`add`(추가), `get`(인덱스로 조회), `remove`(삭제), `size`(길이 확인), `contains`(포함 여부)
집합(Set)	`Set<E>`	`HashSet`, `LinkedHashSet`, `TreeSet`	순서 없음 (또는 정렬), 중복 불가	`add`(추가), `remove`(삭제), `contains`(포함 여부), `size`(길이 확인)
맵(Map)	`Map<K, V>`	`HashMap`, `LinkedHashMap`, `TreeMap`	키-값 쌍 저장, 키 중복 불가	`put`(추가/수정), `get`(값 조회), `remove`(삭제), `containsKey`(키 존재 여부), `keySet`(모든 키 조회)
큐/스택	`Queue<E>` / `Deque<E>`	`LinkedList`, `PriorityQueue`, `ArrayDeque`	선입선출(FIFO), 양방향 가능	`add`(추가), `offer`(추가), `poll`(꺼내고 삭제), `peek`(확인만), `isEmpty`(비었는지 확인)

제네릭(Generic)

깊게 생각하지 않고 제네릭을 사용했지만, 아래의 장점이 있다는 사실을 명확하게 알게 되었다.

코드 재사용성
타입 안정성(컴파일러가 자동으로 다운 캐스팅)

⚠️일반메서드와 제네릭 메서드 구분

일반 메서드와 제네릭 메서드의 동작 원리를 명확히 구분할 수 있게 되었다.

public class GenericBox<T> {

    private T item;

    public GenericBox(T item) {
        this.item = item;
    }

    public T getItem() {
        return this.item;
    }

    // ⚠️ 이 메서드는 클래스의 타입 매개변수 <T>를 사용하는 일반 메서드입니다.
    public void printItem(T item) {
        System.out.println(item);
    }
    
    // ✅ 이 메서드는 독립적인 제네릭 타입 <S>를 정의한 제네릭 메서드입니다. 클래스의 <T>와는 관계가 없습니다.
    public <S> void printBoxItem(S item) { 
        System.out.println(item);
    }
}

람다(Lambda)

람다식은 익명 클래스를 간결하게 표현하는 문법이다.

// 익명클래스
Calculator calculator1 = new Calculator() {
		@Override
		public int sum(int a, int b) {
				return a + b;
		}
};

// ✅ 람다 표현식
Calculator calculator1 = (a, b) -> a + b;

스트림(Stream)

데이터의 흐름을 추상화한 것. 컬렉션의 요소를 함수형 방식으로 처리할 수 있게 해준다.

C# LINQ와 비슷한 개념이다.

`stream()`, `map()`, `collect()`

배열의 짝수만 10배 하여 합계 구하기.

// Java
import java.util.Arrays;

public class StreamExample {
    public static void main(String[] args) {
        int[] numbers = { 1, 2, 3, 4, 5 };

        int sum = Arrays.stream(numbers)
            .filter(n -> n % 2 == 0)
            .map(n -> n * 10)
            .sum();

        System.out.println(sum); // 출력: 60
    }
}

// C#
using System;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] numbers = { 1, 2, 3, 4, 5 };

        int sum = numbers
            .Where(n => n % 2 == 0)
            .Select(n => n * 10)
            .Sum();

        Console.WriteLine(sum); // 출력: 60
    }
}

[사전스터디/SprintBoot] 학습노트③ (회원가입, 로그인 API 구현, AWS 배포)

Jeanin — Wed, 2 Jul 2025 23:59:30 +0900

본 글은 항해플러스 백엔드 9기 과정의 일환인 개강 전 '사전스터디'의 학습노트입니다.
⚠️개인이 학습한 것을 바탕으로 작성되어 부정확할 수 있으며, 오류가 있다면 알려주시면 감사하겠습니다.

️3주차 진행

- 여행으로 인한 미참석

4주차 목표

회원가입 및 로그인 API 구현
JWT 토큰 발행
AWS EC2 배포

회원가입 및 로그인 API 구현

`UserService`와 `UserController`를 구현했다.

DTO는 `LoginRequestDto`, `LoginResponseDto` 로그인 요청과 응답

`SignupRequestDto`, `SignupResponseDto` 회원가입 요청과 응답

총 4개를 만들었다.

로그인 요청과 회원가입 요청은 똑같아서 같이 쓸까 하다가, 추가적으로 닉네임이나 이메일 같은 필드가 추가되면 분리하는게 좋다고 해서 분리해서 작성했다.

JWT 토큰 발행

Spring Security, JWT 관련 디펜던시 추가

구분	그룹 ID	아티팩트 ID	버전	scope	설명
Spring Security	`org.springframework.boot`	spring-boot-starter-security	(Spring Boot에 따라 자동 설정)	기본	Spring Security를 사용하기 위한 스타터. 인증/인가 처리, 필터 구성 등을 지원
JJWT - API	`io.jsonwebtoken`	jjwt-api	0.11.5	기본	JWT 토큰 생성/검증을 위한 API
JJWT - 구현체	`io.jsonwebtoken`	jjwt-impl	0.11.5	runtime	JJWT API의 실제 동작 구현체
JJWT - Jackson	`io.jsonwebtoken`	jjwt-jackson	0.11.5	runtime	Jackson을 이용한 JSON 직렬화/역직렬화 지원 (JWT 파싱/생성 시 사용)

`pom.xml`에 디펜던시 추가

		<!-- Spring Boot Starter -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-security</artifactId>
		</dependency>
		<!-- JJWT (JSON Web Token) -->
		<dependency>
			<groupId>io.jsonwebtoken</groupId>
			<artifactId>jjwt-api</artifactId>
			<version>0.11.5</version>
		</dependency>
		<dependency>
			<groupId>io.jsonwebtoken</groupId>
			<artifactId>jjwt-impl</artifactId>
			<version>0.11.5</version>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>io.jsonwebtoken</groupId>
			<artifactId>jjwt-jackson</artifactId>
			<version>0.11.5</version>
			<scope>runtime</scope>
		</dependency>

`JwtUtil`, `JwtFilter`, `SecurityConfig`, `UserService` 작성

AWS EC2 배포

AWS EC2 사이트 접속( https://aws.amazon.com/ko/ec2/ )

아마존 클라우드 서버 호스팅 | Amazon Web Services

Amazon Elastic Compute Cloud(Amazon EC2)는 750개가 넘는 인스턴스, 그리고 최신 프로세서, 스토리지, 네트워킹, 운영 체제 및 구매 모델의 옵션과 함께 워크로드의 요구 사항에 가장 잘 부합할 수 있도록

aws.amazon.com

회원가입 후 로그인 진행

EC2 검색해서 콘솔에 접속

⬇️ 인스턴스 생성 및 설정은 아래 블로그를 참고하였음 ⬇️

https://ttl-blog.tistory.com/1335

[배포 및 인프라] 해보자 배포 [1] - AWS EC2 생성하고 접속하기

어려운 배포 배포는 참 어렵습니다. 저는 지금 정말 너무 어려워서 울 것 같아요. 하지만, 배포를 처음 해보는 모두가 다 저와 같은 감정일 것이라 생각합니다. 그래서 배포를 처음하는 제가,

ttl-blog.tistory.com

⬇️ EC2 배포를 위한 명령어 ⬇️

내 로컬PC ➡️ EC2 `db_backup.sql` 파일 전송하기

// 내 로컬 PC(Window)에서 cmd 혹은 PowerShell에서 실행

<MySQL 백업 sql 파일 '문서'폴더 경로에 만들기>
cd "C:\Program Files\MySQL\MySQL Server 8.0\bin"
.\mysqldump.exe -u root -p [데이터베이스 이름] > "$HOME\Documents\db_backup.sql"

<백업 파일을 EC2로 전송>
scp -i [SSH 파일(.pem) 경로] db_backup.sql ubuntu@[EC 퍼블릭 IP 주소]:/home/ubuntu/

EC2 인스턴스 연결 후 AWS 서버(Ubuntu)에서 실행

<MySQL 설치>
sudo apt update
sudo apt install mysql-server -y

<MySQL 서비스 시작 및 자동 시작 설정>
sudo systemctl enable mysql
sudo systemctl start mysql

<MySQL 복원>
// mysql 실행
sudo mysql

// root 계정 비밀번호 설정
ALTER USER 'root'@'localhost' IDENTIFIED WITH mysql_native_password BY '[root 계정 비밀번호]';
FLUSH PRIVILEGES;
EXIT;

// 데이터베이스 생성
CREATE DATABASE [데이터베이스 명];
CREATE USER '[유저 아이디]'@'%' IDENTIFIED BY '[유저 비밀번호]';
GRANT ALL PRIVILEGES ON mydb.* TO '[유저 아이디]'@'%';
FLUSH PRIVILEGES;
EXIT;

<백업 복원>
mysql -u root -p [데이터베이스 명] < db_backup.sql

<DB 사용자 권한 부여>
GRANT ALL PRIVILEGES ON [데이터베이스 명].* TO '[유저 아이디]'@'%';
FLUSH PRIVILEGES;
EXIT;


<깃 설치>
sudo apt-get install git
git --version

<깃 SSH KEY 생성>
cd ~/.ssh
ssh-keygen -t rsa -C [github계정 메일]

<깃 SSH KEY 확인>
cat id_rsa.pub

<깃허브에 Key 붙여넣기>

<root 로 이동>
cd /root

<SDKMAN 설치>
// uzip, zip 패키지 설치
sudo apt update
sudo apt install unzip -y
sudo apt install zip -y

// SDKMAN 설치
curl -s "https://get.sdkman.io" | bash
source "$HOME/.sdkman/bin/sdkman-init.sh"

// 버전 확인
sdk version

<Java 24 설치 및 버전 확인>
sdk install java 24-open
sdk use java 24-open
java -version

<Maven 설치>
sudo apt update
sudo apt install maven -y

<깃 클론하기>
git clone [레포지토리 주소]
cd [레포지토리 이름]

<프로젝트 빌드>
mvn clean package // 오류나면 아래 명령어로
mvn clean package -DskipTests // 프로젝트 빌드-테스트 코드 오류 시 테스트 건너뛰고 빌드

<Spring Boot JAR 실행>
java -jar target/[릴리즈된 .jar 파일]

EC2 서버에 스프링부트 배포 완료

⬇️ 스프링부트 스터디 깃허브 리포지토리 ⬇️

https://github.com/bskjp1004/SpringBootStudy/tree/master

GitHub - bskjp1004/SpringBootStudy

Contribute to bskjp1004/SpringBootStudy development by creating an account on GitHub.

github.com

⬇️ API 명세서 ⬇️

https://docs.google.com/spreadsheets/d/11hKFllK5-pVJjpwVTErXQ-pZIITKsmeC9Ba8zuty1z8/edit?gid=0#gid=0

[항해플러스] 스프링부트 스터디 API 명세서

ABCDEFGHIJKLMNOPQRSTUVWXYZ기능URLMethodRequest HeaderRequestResponse전체 게시글 목록 조회 API/api/postsGETContent-Type: application/json없음[ { "id": 1, "title": "문의글", "content": "문의 내용", "username": "admin", "createdAt": null,

docs.google.com

[사전스터디/Java] Java 언어 강의 학습노트②

Jeanin — Mon, 30 Jun 2025 16:58:40 +0900

본 글은 항해플러스 백엔드 9기 과정의 일환인 개강 전 '사전스터디'의 학습노트입니다.
⚠️개인이 학습한 것을 바탕으로 작성되어 부정확할 수 있으며, 오류가 있다면 알려주시면 감사하겠습니다.

강의 수강 목록

객체지향 PART 2 - 상속
객체지향 PART 3 - 추상화
객체지향 PART 4 - 다형성
예외(Exception)과 예외처리(try-catch)

상속

상속은 클래스간의 관계를 `부모`, `자식`으로 바라보는 개념

`extends` 키워드를 자식 클래스에 사용해서 상속받음

// 부모
public class Parent {
    public String familyName = "스파르탄";
    public int honor = 10;

    public void introduceFamily() {
        System.out.println("우리 " + this.familyName + " 가문은 대대로 명성을 이어온...");
    }
}

// 자식
class Child extends Parent {
}

`super` 키워드는 부모클래스의 멤버에 접근할 때 사용하는 키워드

// 부모
public class Parent {
    public Parent() {} // 부모 생성자
}

// 자식
public class Child extends Parent {

		...

    public Child() {
        super(); // (1)부모클래스 생성자를 먼저 호출
        // 추가로직 작성
    }
}

`@Override` 키워드를 통해 부모 클래스의 메서드를 재정의 할 수 있음

// 부모
public class Parent {

    // 기존 기능
    public void introduceFamily() {
        System.out.println("우리 " + familyName + " 가문은 대대로 명성을 이어온 가문입니다.");
    }
}

// 자식
class Child extends Parent {
		...
    
    @Override
    void introduceFamily() { // 자식클래스에서 재정의
        System.out.println("오버라이드");
    }
}

추상클래스와 인터페이스 비교

상황	추상클래스(abstract class)	인터페이스(interface)
공통 속성과 구현 코드도 물려주고 싶다	✅ 적합	❌ 부적합
오직 기능의 약속만 필요하다	❌ 불필요	✅ 적합
상태(필드)와 생성자를 가질 수 있어야 한다	✅ 가능	❌ 불가
여러 타입을 구현해야 한다	❌ 단일만 `extends`	✅ 다중 구현 가능 `implements`

// 추상 클래스
class A { }
class B { }

class C extends A, B { } // ❌ 컴파일 오류 발생!

// 인터페이스
interface Flyable { void fly(); }
interface Swimmable { void swim(); }

class Duck implements Flyable, Swimmable {
    public void fly() { System.out.println("오리가 날아요"); }
    public void swim() { System.out.println("오리가 헤엄쳐요"); }
}

C#과 Java 비교

C#에서는 자식클래스를 구현할때 `extends`, `implements`와 같은 키워드 없이 `:`을 사용했었음

// Java
class Dog extends Animal implements Pet { ... }

// C#
class Dog : Animal, IPet { ... }

추상화

추상화란 불필요한 정보를 제거하고 본질적인 특징만 남기는 것

추상화의 계층적 특징을 활용해 유지보수가 용이한 코드를 작성할 수 있음

생명체
  |
동물
  |
고양이

다형성

다형성은 하나의 타입으로 여러 객체를 다룰 수 있는 것

   생명체
     |
    동물
     |
고양이/강아지

예외처리

구분	Exception (Checked Exception)	RuntimeException (Unchecked Exception)
상위 클래스	`java.lang.Exception`	`java.lang.RuntimeException` (→ Exception의 하위)
예외 처리	반드시 처리해야 함 (try-catch 또는 throws)	선택적으로 처리 가능
컴파일 시 검사	✅ (컴파일러가 예외 처리 여부 검사)	❌ (컴파일러 검사 없음)
대표 예외	`IOException`, `SQLException`, `ParseException` 등	`NullPointerException`, `ArrayIndexOutOfBoundsException`, `IllegalArgumentException` 등
주로 발생 상황	외부 환경 관련 예외 (파일, DB, 네트워크 등)	프로그래밍 로직 실수, 버그
실무 처리 방식	반드시 처리 (`try-catch` 또는 `throws`)	상황에 따라 처리하거나 무시하기도 함

❔상속 클래스와 인터페이스를 공부하면서 두 키워드의 차이에 대해 더 궁금해서 상속과 컴포지션의 개념에 대해 더 알아보았다.

상속과 컴포지션

상속은 강한 결합을 만들며, 변경에 취약
컴포지션은 객체 간의 약한 연결로 유연하고 유지보수가 용이
그래서 요즘 트렌드는 "상속보다는 컴포지션을 활용하라(Prefer composition over inheritance)"
다만 GUI 프레임워크과 같은 "is-a" 관계가 뚜렷하고 안정적일 때 상속이 효과적임

항목	상속 (Inheritance)	컴포지션 (Composition)
구조	is-a 관계	has-a 관계
특징	부모 클래스의 기능을 자식 클래스가 물려받음	필요한 기능을 객체로 주입하여 사용
유연성	낮음 (고정된 계층 구조)	높음 (동적으로 기능 변경 가능)
예시	Dog extends Animal	Car has a Engine
트렌드	과도한 사용 지양	유연한 설계로 선호됨

상속 방식

⚠️문제점: 캐릭터가 두 가지 공격을 동시에 해야 한다면?

WarriorArcher 같은 새로운 클래스를 계속 만들어야 함 → 클래스 폭발

abstract class Character {
    abstract void attack();
}

class Warrior extends Character {
    @Override
    void attack() {
        System.out.println("검으로 공격!");
    }
}

class Archer extends Character {
    @Override
    void attack() {
        System.out.println("화살로 공격!");
    }
}

컴포지션 방식

interface AttackStrategy {
    void attack();
}

class SwordAttack implements AttackStrategy {
    public void attack() {
        System.out.println("검으로 공격!");
    }
}

class BowAttack implements AttackStrategy {
    public void attack() {
        System.out.println("화살로 공격!");
    }
}

class Character {
    private AttackStrategy attackStrategy;

    public Character(AttackStrategy attackStrategy) {
        this.attackStrategy = attackStrategy;
    }

    public void performAttack() {
        attackStrategy.attack();
    }

    public void setAttackStrategy(AttackStrategy newStrategy) {
        this.attackStrategy = newStrategy;
    }
}

Character hero = new Character(new SwordAttack());
hero.performAttack();  // 검으로 공격!

hero.setAttackStrategy(new BowAttack());
hero.performAttack();  // 화살로 공격!

⬇️ 상속을 활용해 구현하려다 '리스코프 원칙'을 위반하는 문제에 대해 잘 설명한 블로그글 ⬇️

https://brownbears.tistory.com/579

[SOLID] 리스코프 원칙 법칙이란 (Liskov Substitution Principle, LSP)

리스코프 치환 법칙은 SOLID 원칙에서 L에 해당하는 법칙입니다. 해당 법칙은 상위 타입의 객체를 하위 타입의 객체로 치환해도 동작에 문제가 없어야 합니다. 즉, B가 A의 자식일 때, A 타입을 사

brownbears.tistory.com