아무거나

[Spring] SpringBoot에서 SSE(Server-Sent Events)기반 실시간 알림 구현하기

강방당 — Mon, 14 Jul 2025 02:54:35 +0900

SpringBoot에서
SSE(Server-Sent Events)기반 실시간 알림 구현하기

구현 계기

현재 개발중인 실시간 협업 프로젝트는 노션같이 워크스페이스 기반으로 서비스가 흘러간다.

여기서 워크스페이스 초대를 할 때, 초대 받은 사람에게 초대 알림이 갈 수 있도록 알림기능을 구현해야 했다.

해당 이미지는 현재 개발중인 프로젝트의 알림창 화면이다. 이렇게 사용자에게 워크스페이스 초대들이 가게되고, 개발하는 단계에서 사용자에게 온 초대알림 목록을 조회해야 할 뿐만 아니라, 알림 기능을 구현해야 한다.

알림을 보내는 여러 기술들이 있지만, 해당 프로젝트에서는 SSE(Server-Sent Events)가 가장 적합하다고 느껴 SSE를 선택하게 되었다.

왜 SSE를 선택했는가?

워크스페이스 초대 알림을 실시간으로 전달하기 위해 다음 세가지 기술들을 고려했었다.

WebSocket
SSE (Server-Sent Events)
FCM (Firebase Cloud Messaging)

1. WebSocket

- 클라이언트 ↔ 서버 간 실시간 양방향 메시지 전송 가능
- 연결 유지 및 사용자 세션 관리가 복잡
- 단순 알림에 사용하기에는 구현 부담이 큼

=> 실시간 공동 작업, 채팅, 실시간 대시보드 등에 적합

2. SSE (Server-Sent Events)

- 단방향 푸시에 최적화된 가볍고 안정적인 방식
- 구현이 간단하고 브라우저에서 기본 지원 (EventSource API)
- SSE는 접속 유지 중인 사용자에게 최적화

=> 알림, 서버 상태 업데이트, 단발성 이벤트 전달에 적합

3. FCM (Firebase Cloud Messaging)

- 모바일/웹 푸시 알림에 특화된 메시징 플랫폼
- 푸시 알림 인프라를 Google이 관리 (외부 서비스에 의존)
- 앱이 꺼져 있어도 백그라운드 푸시 가능
- 사용자 토큰 관리, Android/iOS/Web 각각 설정 필요

=> 브라우저 푸시, 마케팅 알림, 백그라운드 푸시에 적합

이번 프로젝트의 워크스페이스 초대 알림은 클라이언트 1명에게만 보내는 단발성 개인 알림이며, 알림 수신 후 UI에서 바로 확인만 하면 되므로 단방향 통신으로 충분했다. 또한 웹 서비스로 모바일 푸시 또한 필요하지 않았다.

결과적으로 이러한 요건에 가장 적합한 기술이 SSE라고 판단했고, 실제로 구현해보니 생각보다 간단하고 확장성이 좋아서 옳은 선택을 한 것 같다는 생각이 들었다.

SSE 개념

SSE (Server-Sent Events)는 서버에서 클라이언트로 데이터를 일방적으로 전송하는 이벤트 기반 기술이다.

HTML5 표준 기술로, HTTP 기반 연결을 유지한 채 서버가 클라이언트에게 실시간으로 데이터를 푸시할 수 있다.

단향향 통신으로 서버 -> 클라이언트로만 데이터 전송이 가능하다.
HTTP/1.1을 기반으로 한다
연결이 끊어지면 브라우저의 EventSource는 자동으로 재연결을 시도하며, 서버는 retry 필드를 통해 재연결 간격을 제어할 수 있다.

위 사진은 SSE 요청과 응답의 흐름을 이미지로 나타낸 것이다.

1) 먼저 클라이언트가 연결 수립 url로 SSE 요청(connection)을 보낸다. (JWT를 포함, GET 방식)

2) 서버는 초대 이벤트 발생 시 해당 클라이언트에게 SseEmiter를 통해 data를 전송한다. 서버는 text/event-stream 콘텐츠 타입으로 응답을 유지하며, 필요한 시점마다 이벤트를 전송한다.(emitter.send())

3) 클라이언트는 이 연결을 통해 전달되는 데이터를 EventSource API로 수신한다.

4) 이벤트 수신 후 UI에 반영한다.

SseEmitter와 SseEmitter 클래스

SseEmitter는 Spring Boot에서 SSE(Server-Sent Events)를 구현할 때 사용하는 핵심 클래스로 클라이언트에게 비동기적으로 데이터를 전송하는 역할을 수행한다.

- 컨트롤러에서 SseEmitter를 반환하면 Spring은 연결을 유지한다.
- SseEmitter 객체를 생성한 뒤, emitter.send() 호출 시 브라우저로 이벤트가 전송된다.
- 기본 타임아웃은 30초 이나, new SseEmitter(Long.MAX_VALUE)로 무제한 설정이 가능하다.
(하지만 무제한 설정은 연결 해제를 별도로 명시적으로 처리하지 않으면 메모리 누수 위험이 있어 주의가 필요하다.)

https://docs.spring.io/spring-framework/docs/current/javadoc-api/org/springframework/web/servlet/mvc/method/annotation/SseEmitter.html

위의 공식문서를 자세히 들여다보면 SseEmitter의 생성자와 메서드들에 대해서 알 수 있다. 주요 생성자와 메서드를 소개하면 아래와 같다.

[ 생성자 ]

public SseEmitter()

기본 생성자로 기본 타임아웃 30초(30,000ms)로 설정된 SseEmitter 객체를 생성한다.

SseEmitter emitter = new SseEmitter();

public SseEmitter(Long timeout)

원하는 타임아웃(ms)을 지정하여 SseEmitter를 생성한다.
ms 단위이다.
타임아웃이 지나면 자동으로 emitter가 종료되며, onTimeout() 콜백이 호출된다.

SseEmitter emitter = new SseEmitter(Long.MAX_VALUE);

[ 메서드 ]

메서드	설명
send(Object object)	클라이언트로 단순한 데이터를 전송
send(Object object, MediaType mediaType)	전송할 데이터 타입 명시와 함께 데이터 전송 (ex. emitter.send(myObject, MediaType.APPLICATION_JSON)
send(SseEventBuilder builder)	이벤트 이름, ID, retry 시간 등을 설정한 커스텀 이벤트 전송
complete()	클라이언트와의 연결을 명시적으로 종료
completeWithError(Throwable t)	오류와 함께 연결 종료
onCompletion(Runnable callback)	연결이 정상적으로 종료될 때 실행할 콜백 등록
onTimeout(Runnable callback)	타임아웃 발생 시 실행할 콜백 등록
onError(Consumer<Throwable> callback)	예외 발생 시 실행할 콜백 등록

send(SseEventBuilder builder)메서드는 아래처럼 이벤트를 커스터마이징 해서 사용자에게 보낼 수 있다.

emitter.send(SseEmitter.event()
    .name("invitation")
    .id("event-id-123")
    .data("워크스페이스 초대 알림")
    .reconnectTime(5000)); // 5초 후 재연결 시도

on~ 관련 메서드들을 정의하여 emitter를 Map에서 제거해야 리소스가 낭비되지 않는다.

emitter.onCompletion(() -> {
    // 연결이 정상적으로 종료될 때
    emitters.remove(userId);
});

emitter.onTimeout(() -> {
    // 연결 타임아웃 발생 시
    emitters.remove(userId);
});

emitter.onError(e -> {
    // 예외 발생 시
    log.error("SSE 전송 오류", e);
});

사용자 개별 알림 전송 구조 (1명에게만 어떻게 알림을 보낼지?)

지금까지의 내용을 통해 SseEmitter 객체의 .send() 메서드로 사용자에게 데이터를 보낼 수 있는 구조에 대해서 이해할 수 있을 것이다.

그렇다면 단 한명 (ex. userId = 12)에게만 알림을 어떻게 보낼 수 있을까?

예시 로직 설계

1. 사용자(userId = 12)가 SSE 구독을 시작함
2. Map에 해당 유저의 SseEmitter 객체를 저장해놓음 => maps.put(userId, emitter)
3. 실제로 알림을 보내야 하는 상황이 오면 Map에 저장되어 있는 해당 사용자(userId = 12)의 SseEmitter 객체를 꺼내옴
=> SseEmitter emitter = maps.get(userId)
4. 보낼 내용 전송 => emitter.send(데이터)

조금 구체적으로 설명하자면, 연결이 수립되었을시에 사용자의 SseEmitter 객체를 만들어두고, 저장해놓는다.

그리고 알림을 보내야 하는 상황이 오면 위에서 Map에 저장한 사용자의 SseEmitter 객체를 꺼낸다.

꺼낸 SseEmitter객체는 해당 사용자의 SseEmitter 객체이므로, .send() 메서드에 데이터를 담으면 해당 사용자에게만 알림이가게 된다.

실제 코드

이제, 위의 개념을 적용하여 사용자가 워크스페이스 초대를 받았을 때 알림을 받을 수 있는 전체 코드를 작성했다.

1. Controller 작성

@RestController
@RequestMapping("/api/workspaces")
@RequiredArgsConstructor
@Tag(name = "SSE 알림 연결 API")
public class SseController {

    private final SseServiceImpl sseService;
    private final JwtProvider jwtProvider;

    //알림 수신 구독 API
    @Operation(summary = "알림 수신 구독 API (swagger로 테스트 불가: 무한로딩)")
    @GetMapping(value = "/notifications", produces = "text/event-stream") //SSE임을 명시
    public ResponseEntity<SseEmitter> subscribe(@RequestParam("token") String token) {
        Long memberId = jwtProvider.getMemberId(token); // 토큰에서 ID 추출
        SseEmitter emitter = sseService.subscribe(memberId);
        return ResponseEntity.ok(emitter);
    }
}

사용자가 알림을 구독하겠다는 요청을 보낼 때의 api url을 설계해주었다.

응답은 기존에 ResponseEntity<CustomResponse<응답DTO>> 이런식으로 CustomResponse에 담아서 보냈는데 SseEmitter는 스트리밍 객체로 CustomResponse의 Json 형태로 변환하는 것이 불가능하다. 따라서 ResponseEntity에 SseEmitter를 감싸서 반환하는 식으로 구성했다.
JWT 토큰을 받는 것은 기존의 @AuthenticationPrincipal에서 받아오는 형식을 사용할 수 없기 때문에 JWT 토큰을 쿼리 파라미터로 받도록 수정하였다. 이것은 프론트엔드 쪽에서 EventSource를 사용하기 때문인데, EventSource 객체는 커스텀헤어 Authorization을 지원하지 않기 때문이다. 보안적으로 권장되는 방식은 아니지만, HTTPS 연결을 사용하고, SSE 구독 요청은 다른 사람이 볼 수 없는 환경에 있으며, 토큰의 짧은 유효 시간 등으로 SSE 구독용 요청만 예외적으로 쿼리 파라미터로 받도록 설정할 수 있다.
@GetMapping(value = "/notifications", produces = "text/event-stream")에서 produces = "text/event-stream"를 통해 HTTP의 Content-Type를 명시해주었다. SSE는 HTTP의 Content-Type이 반드시 " text/event-stream"이어야 브라우저가 이를 스트리밍 응답으로 인식하기 때문이다. 물론 Spring에서 SseEmitter타입이 반환되면 자동으로 text/event-stream으로 설정해주긴한다. 그렇지만 정확하게 명시해주는 것이 명확한 설정 방식이다.
또한 Swagger에서의 테스트가 불가능 하다. 구독 요청을 하고 대기하는 방식이므로 Swagger로 테스트시 무한 로딩에 빠지게 될 수 있다.

2. Service 코드 작성

@Service
@Slf4j
public class SseServiceImpl {
    //단일 브라우저 연결(Map<Long, SseEmitter>) 구조
    private final Map<Long, SseEmitter> emitters = new ConcurrentHashMap<>();

    public SseEmitter subscribe(Long memberId) {
        SseEmitter emitter = new SseEmitter(Long.MAX_VALUE); //타임아웃 설정, 브라우저에서 자동 재연결
        emitters.put(memberId, emitter); //해당 유저의 emitter 객체 저장

        emitter.onCompletion(() -> emitters.remove(memberId));
        emitter.onTimeout(() -> emitters.remove(memberId));
        emitter.onError((e) -> emitters.remove(memberId));

        try {
            emitter.send(SseEmitter.event()
                    .name("connected")
                    .data("SSE 연결 완료"));
        } catch (IOException e) {
            emitter.completeWithError(e);
        }
        return emitter;
    }

    public void sendInvitationAlertToUser(Long memberId, WorkspaceInvitation invitation, Workspace workspace) {
        SseEmitter emitter = emitters.get(memberId);
        if (emitter != null) {
            try {
                // DTO 생성
                SseResponseDto.InvitedNotificationResponseDto dto =
                        SseConverter.toInvitedNotification(invitation, workspace);

                // SSE 알림 전송
                emitter.send(SseEmitter.event()
                        .name("invitation") // 이벤트 이름 명확히 구분
                        .data(dto, MediaType.APPLICATION_JSON));

                log.info("[SSE] Sent invitation notification to user {}", memberId);

            } catch (IOException e) {
                emitter.completeWithError(e);
                // 연결이 동일한 emitter일 때만 삭제
                if (emitters.get(memberId) == emitter) {
                    emitters.remove(memberId);
                    log.info("[SSE] Removed emitter for user {} after failure", memberId);
                }
            }
        }
    }
}

다음으로 서비스 코드를 작성해주었다. 서비스 코드는 최초 구독 요청을 처리하고 사용자의 SseEmitter 객체를 생성해 Map에 저장하는 subscribe() 메서드와 실제 알림을 발송하는 sendInvitationAlertToUser() 메서드 두개로 나뉜다.

subscribe() 메서드에서는 사용자의 SseEmitter 객체를 생성해 Map에 저장하고, onCompletion(), onTimeout(), onError() 메서드를 통해 연결이 끊길 시점에 emitter를 Map에서 제거하도록 코드를 작성해주었다.
sendInvitationAlertToUser() 메서드에서는 보내고자 하는 알림 형태에 맞게 사용자에게 응답을 반환할 DTO를 정의해준 뒤, SseEmitter.event()메서드로 data에 해당 커스텀 응답 DTO를 넣어 send() 메서드로 반환해주었다.

3. 응답 DTO와 Converter

응답 DTO

public class SseResponseDto {
    @Builder
    @Schema(description = "워크스페이스 초대 알림 응답 DTO")
    public record InvitedNotificationResponseDto(
            @Schema(description = "알림 타입", example = "INVITATION")
            String eventType,
            @Schema(description = "워크스페이스 아이디", example = "12")
            Long workspaceId,
            @Schema(description = "워크스페이스 이름", example = "우리팀 프로젝트")
            String workspaceName,
            @Schema(description = "초대한 시간", example = "2025-07-08T15:32:00")
            LocalDateTime invitedAt,
            @Schema(description = "이 이벤트가 수신된 시간", example = "2025-07-08T15:35:10")
            LocalDateTime receivedAt
    ) {}
}

Converter

public class SseConverter {
    public static SseResponseDto.InvitedNotificationResponseDto toInvitedNotification(WorkspaceInvitation invitation, Workspace workspace) {
        return SseResponseDto.InvitedNotificationResponseDto.builder()
                .eventType("INVITATION")
                .workspaceId(workspace.getId())
                .workspaceName(workspace.getWorkspaceName())
                .invitedAt(invitation.getSentAt())
                .receivedAt(LocalDateTime.now())
                .build();
    }
}

4. 실제 알림을 전송하는 Service에서의 활용 코드

위에서 작성한 SseService는 다른 사용할 서비스에서 호출되어 사용하게 된다.

아래 코드는 실제 워크스페이스 초대를 보내는 서비스 메서드의 맨 아래에서 SseService의 sendInvitationAlertToUser()를 호출하는 코드이다.

    @Override
    public WorkspaceResponseDto.InviteWorkspaceResponseDto inviteTeamWorkspace(Long workspaceId, Long inviterId, String email) {
        // 워크 스페이스 조회
        // 워크 스페이스가 팀 워크스페이스가 맞는지 확인
        // 초대한 사용자 조회 (inviter)
        // 초대한 사용자가 해당 워크 스페이스에 속해있는지 확인 (inviter)
        // 초대할 사용자 조회 (invitee)
        // 본인 초대 방지
        // 워크스페이스 멤버인지 여부 확인 (이미 속해있으면 예외)
        // 아직 만료되지 않은 초대가 있는지 확인
            //초대 만료 전 초대가 존재하나, 멤버가 그룹에 포함되어 있지 않으면서 ACCEPT or REJECT 상태라면 재전송 가능
        // 초대 토큰 생성 (invitationMailService 에서 중복 여부 확인)
        // 이메일 전송
        // 초대 엔티티 저장
        
        //--------------여기까지 기존의 코드

        // 초대 대상자에게 SSE 알림 전송
        sseService.sendInvitationAlertToUser(invitee.getId(), invitation, workspace);

        // 응답 반환
        return WorkspaceConverter.toInviteResponse(invitation, invitee.getEmail());
    }

기존에 알림을 보내야하지만, 아직 알림 기능은 구현하지 못했던 초대 메서드의 맨 아랫 부분에 코드 한줄 추가로 알림 기능을 추가할 수 있다.

sseService.sendInvitationAlertToUser(invitee.getId(), invitation, workspace);

정리

이번 SSE(Server-Sent Events) 알림 기능은 핵심 비즈니스 로직을 변경하지 않고도 실시간 기능을 유연하게 붙일 수 있는 구조로 설계되었다. 워크스페이스 초대 로직에서 sseService.sendInvitationAlertToUser() 한 줄만 추가함으로써, 도메인 로직과 알림 로직을 완전히 분리한 채, 실시간 알림을 자연스럽게 통합할 수 있었다.

또한 Map<Long, SseEmitter> 형태의 단일 브라우저 연결 구조를 채택한 이유는 시스템 단순화와 성능 최적화 때문이다. 대부분의 사용자들은 한 기기에서 하나의 브라우저 탭으로 서비스를 사용하기 때문에 유저당 하나의 SseEmitter만 유지해도 실시간 알림 수신에는 큰 문제가 없을 것이라 판단했다. 또한 다중 브라우저구조는 유저별 여러 Emitter를 관리해야 하고, 만료된 Emitter 정리를 위한 스케줄러나 이벤트 큐까지 고려해야 하므로 구조가 복잡해지고, 서버 부하가 증가한다. 따라서 초기 단계에서는 단일 브라우저 구조로 충분하며, 새로운 접속이 이전 연결을 자연스럽게 덮어쓰기 때문에(Map 구조) 만료 정리 로직이 필요하지 않고 전체적으로 리소스를 효율적으로 관리할 수 있기 때문이다. 물론 서비스가 확장 되거나 다중 접속 수요가 명확해지면 Map<Long, List<SseEmitter>>로 전환할 계획이 있다.

참고자료 )

Spring SSE 공식 문서
SSE와 EventSource 소개
https://eunchaan.tistory.com/237

[트러블슈팅] WebSocket - Handshake 403 에러 "WebSocket connection to 'ws://localhost:8080/ws-stomp' failed: Error during WebSocket handshake: Unexpected response code: 403"

강방당 — Sun, 22 Jun 2025 03:05:12 +0900

실시간 협업 기능을 구현하기 위해 WebSocket을 도입해야 했는데 도입에 앞서, 실제 웹소켓이 잘 동작하는지 테스트 해보기 위해 간단한 간단한 채팅 기능을 만든 뒤 JWT 인증까지 연결한 코드를 작성하고, 프론트엔드 연결 예시 코드를 통해 잘 동작하는지 테스트 해보고자 했다.

하지만 개발 중 예상치 못한 문제가 발생했다. 클라이언트에서 WebSocket 연결을 시도할 때마다 403 Forbidden 오류가 발생한 것이다. 로그에는 다음과 같은 메시지가 출력되었다.

WebSocket connection to 'ws://localhost:8080/ws-stomp' failed: Error during WebSocket handshake: Unexpected response code: 403

처음에는 프론트엔드 코드의 문제일 것이라 의심했지만, Postman 등에서 동일한 요청을 보냈을 때는 정상적으로 처리되는 점을 확인하며 서버 측의 보안 설정을 의심하게 되었다. (Postman에서는 Connection이 제대로 이루어지는지만 테스트가 가능하고, STOMP를 테스트해볼 수는 없다.)

WebSocket과 Spring Security의 관계

문제를 해결하기 위해 WebSocket의 작동 방식을 다시 정리해보았다. WebSocket은 처음 연결을 시도할 때 일반적인 HTTP 요청을 통해 handshake 과정을 수행하고, 이후 연결이 수립되면 지속적인 소켓 통신이 이루어진다. 이 초기 handshake 요청도 일반적인 HTTP 요청처럼 Spring Security의 필터 체인을 통과하게 되는데, 문제는 바로 여기에서 발생했다.

프로젝트에서는 JWT를 사용하는 인증 방식을 적용하고 있었고, 모든 요청은 커스텀 JwtFilter를 통해 토큰 검증을 하도록 설정되어 있었다. 그러나 WebSocket의 handshake 요청에는 일반적인 REST 요청처럼 Authorization 헤더를 담을 수 없기 때문에 JwtFilter가 handshake 요청을 처리하지 못하고 403 오류를 반환하고 있었던 것이다.

시도 1. SecurityConfig에서 permitAll 설정

가장 먼저 시도한 해결책은 SecurityFilterChain 안에서 handshake 요청의 경로(/ws-stomp)를 .permitAll() 처리하는 것이었다. 다음과 같이 설정하였다.

allowedUrls에 "/ws-stomp"관련 경로를 추가했고, 기존과 같이

.authorizeHttpRequests(authorize -> authorize
        .requestMatchers(allowedUrls).permitAll()

하지만 이 설정은 소용이 없었다. 이유는 간단했다. .permitAll()은 SecurityFilterChain 내부에서만 동작하는 설정이기 때문에, handshake 요청이 이미 필터에서 거부되고 있다면 이 설정은 도달조차 하지 못한다. 즉, 필터를 통과한 이후의 인가 과정에서만 유효한 것이다.

시도 2. JwtFilter에서 handshake 우회

다음으로는 커스텀 JWT 필터 내에서 WebSocket 요청임을 감지하면 해당 요청만은 필터를 우회하게끔 설정해보았다.

String upgrade = request.getHeader("Upgrade");
if ("websocket".equalsIgnoreCase(upgrade)) {
    log.info("WebSocket 요청 - JwtFilter 우회");
    filterChain.doFilter(request, response);
    return;
}

이 방식도 한번 시도해보았다. 실제로 Upgrade: websocket 헤더는 handshake 요청에 포함되기 때문에 이를 통해 WebSocket 요청을 구분할 수 있다. 하지만 여전히 오류는 해결되지 않았다. 왜냐하면 JWT 필터 자체에 진입하기 전에 이미 필터 체인에서 예외가 발생하고 있었기 때문이다. 즉, 해당 필터까지 도달하지 못하는 상황이었던 것이다.

에러 해결 - WebSecurityCustomizer로 필터 우회

문제의 핵심은 WebSocket handshake 요청이 아예 Spring Security의 필터 체인에 들어가지 않도록 해야 한다는 것이었다. 이 경우에 사용할 수 있는 방법이 바로 WebSecurityCustomizer이다. 이 설정을 통해 특정 요청 경로를 Spring Security 필터 체인 자체에서 제외시킬 수 있다.

@Bean
public WebSecurityCustomizer webSecurityCustomizer() {
    return web -> web.ignoring().requestMatchers("/ws-stomp");
}

이 설정을 추가하자마자 문제가 해결되었다. WebSocket handshake 요청이 더 이상 필터에 걸리지 않았고, 클라이언트는 정상적으로 WebSocket 연결을 수립할 수 있었다.

STOMP CONNECT 단계에서 인증 처리

WebSocket 연결은 성공했지만, 이 연결이 인증되지 않은 사용자에게 열려 있어서는 안 된다. 그래서 실제 인증 처리는 WebSocket 연결 이후의 STOMP CONNECT 프레임을 통해 수행하도록 하였다. 이를 위해 Spring에서는 ChannelInterceptor를 구현하여 StompCommand.CONNECT 요청을 가로채고 JWT 토큰 검증을 진행한다.

@RequiredArgsConstructor
@Component
public class StompHandler implements ChannelInterceptor {
    private final JwtProvider jwtProvider;

    //WebSocket 서버에서 ChannelInterceptor를 사용해 STOMP CONNECT 요청을 가로채고 헤더를 확인
    @Override
    public Message<?> preSend(Message<?> message, MessageChannel channel) {
        StompHeaderAccessor accessor = MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);

        if (StompCommand.CONNECT.equals(accessor.getCommand())) {
            String rawToken = accessor.getFirstNativeHeader("Authorization");

            if (rawToken == null || !rawToken.startsWith("Bearer ")) {
                throw new JwtException(JwtErrorCode.INVALID_TOKEN);
            }

            // "Bearer " 제거
            String token = rawToken.substring(7);

            if (!jwtProvider.isValidToken(token)) {
                throw new JwtException(JwtErrorCode.INVALID_TOKEN);
            }

            Authentication authentication = jwtProvider.getAuthentication(token);
            accessor.setUser(authentication);
        }

        return message;
    }
}

이 과정을 통해 handshake는 누구나 할 수 있지만, 실제 메시지를 주고받기 위해서는 반드시 유효한 JWT 토큰을 포함한 STOMP CONNECT를 성공해야 한다는 구조를 갖추게 되었다.

정리

.permitAll()은 필터 체인을 이미 통과한 요청에만 적용된다.
WebSocket handshake 요청은 일반 HTTP 요청처럼 필터를 거치기 때문에, 필요시 WebSecurityCustomizer로 필터 체인 자체에서 제외해주어야 한다.
handshake 단계에서 필터를 우회하더라도, STOMP CONNECT 단계에서 별도로 인증을 검증할 수 있다.
WebSocket + STOMP + JWT 인증을 함께 사용할 경우, handshake는 열고 실제 메시지 송수신은 STOMP 인증을 통해 통제하는 것이 권장되는 구조이다.

[트러블슈팅] SQL Error: 1364 - Field '컬럼명' doesn't have a default value

강방당 — Tue, 1 Apr 2025 01:40:19 +0900

이미 로컬에서 개발을 마치고 프론트엔드 연동을 위해 서버를 띄워놓은 채로 그냥 기다리고 있었는데

프론트엔드 측에서 스웨거 동작시 Field 'member_club_id' doesn't have a default value [insert into likes (article_id, member_id)] 라는 에러가 뜬다는 메세지를 받았다.

스웨거 내 오류 메세지

SQL Error: 1364, SQLState: HY000
~.SqlExceptionHelper   : Field 'member_club_id' doesn't have a default value
~.GlobalExceptionHandler     : [WARNING] Internal Server Error : could not execute statement [Field 'member_club_id' doesn't have a default value] [insert into likes (article_id,member_id) values (?,?)]

분명히 로컬 및 로컬 스웨거로 동작 및 테스트를 다 해봤는데 배포 서버에서만 이런 에러가 발생하는 것이다...

결론부터 말하자면,

SHOW CREATE TABLE [테이블명]; SQL문을 실행해서 실제 DB의 스키마 구조와 Entity에서 정의한 구조와 같은지 한번 확인해보자!!!

문제 현상

특정 API 요청 (좋아요 토글) 시 다음과 같은 MySQL 오류 발생:

Field 'member_club_id' doesn't have a default value
[insert into likes (article_id, member_id)]

로컬(MariaDB)에서는 동작,
운영환경(MySQL)에서는 실패했다.

그래서 알아본 결과 MariaDB와 MySQL은 같은 쿼리/DDL에 대해 다르게 동작할 수 있고, 특히 NOT NULL + DEFAULT 없음 상황에서 MariaDB가 더 느슨하게 처리하는 경향이 있다고 한다.

먼저 cascade = CascadeType.ALL 제거해보고, 안돼서 orphanRemoval = true도 제거해보았다.

그런데 둘 다 시도해본 결과 그 문제는 아니었다.

다음으로 영속성을 확인해주었다. 좋아요 Likes 테이블을 저장할 때 Member도 함께 연관되어 있고, member과 member_club은 1:n으로 연결되어 있기 때문에 JPA는 Member.memberClubs 도 같이 flush(영속화)하려고 해서 이러한 문제가 발생하는 건 아닐 까 생각이 들어서 아래 4가지를 시도해보았다.

member.getMemberClubs().clear()
Member.builder().id(...) 프록시 사용
@Transactional(readOnly = true) 사용
entityManager.detach(member)

Likes를 저장할 때 Member도 함께 연관되어 있기 때문에

JPA는 Member.memberClubs 도 같이 flush(영속화)하려고 하고,
그 안에서 member_club_id 필드가 NOT NULL인데 값이 없기 때문에 DB 레벨에서 에러가 발생하는 줄 알고 여러가지를 시도해보았으나 전부 되지 않아서 골머리를 앓고 있었다...,,

따라서 의심 대상을 전환 DB 테이블 구조 자체로 이동해보았다. 그래서
SHOW CREATE TABLE likes;를 해보니 로컬 DB와 구조가 달랐다....

배포를 초기에 미리해놓고 ddl-auto를 update로 설정해놓아서 entity가 변경되어도 반영되지 않았던 것이다.
따라서 과거에 사용하던 member_club_id 컬럼이 DB에 남아 있어서 데이터 삽입시 저장에 실패했던 것이다.

ALTER TABLE likes DROP FOREIGN KEY [키];
ALTER TABLE likes DROP COLUMN member_club_id;
이후 Likes insert 시 더 이상 member_club_id가 요구되지 않았고 오류를 완전히 해결할 수 있었다.

교훈)
엔티티 구조를 변경하고 반영 항상 로컬과 운영 서버의 DB에 접근하여 SHOW CREATE TABLE로 실제 반영 여부를 확인해보자..!!!

[CI/CD] 깃허브 액션 사용하기

강방당 — Mon, 3 Feb 2025 01:10:56 +0900

깃허브 액션은 깃허브에서 제공하는 서비스로 코드 원격 저장소에 특정 이벤트가 발생하면 특정 작업을 하거나, 주기적으로 특정 작업을 반복할 수 있게 해준다.

누군가 코드를 작성해서 깃허브에 업데이트하면 해당 코드에 문제가 없는지 자동으로 코드를 빌드, 테스트 한 이후 배포까지 해준다.

<CI>

1. ".github" 폴더를 열어준다. 만약에 없으면 생성해준다.

2. ".github" 폴더 하단에 "workflows" 폴더를 만들어준다.

3. workflows 폴더 하위에 "ci.yml" 파일을 만들어준다.

4. ci.yml 파일에 아래와 같은 코드를 입력해준다

name: CI

on:
  push:
    branches: [ main ]
jobs:
  build:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v3
      - uses: actions/setup-java@v3
        with:
          distribution: 'zulu'
          java-version: '17'
      - name: Grant execute permission for gradlew
        run: chmod +x gradlew
      - name: Build with Gradle
        run: ./gradlew clean build

5. 이렇게 작성한 파일을 main에 푸쉬해준다.

6. main에 잘 올라갔다면, Action에 아래 사진처럼 추가되고, 워크 플로가 성공적으로 동작하면 초록색 체크 모양으로 표시되게 된다.

<CD>

빌드를 진행하면 총 두개의 jar 파일이 생기는데, plain이 붙지않은 jar 파일을 지속적 배포에 사용할 것이므로 plain이 붙어있는 jar 파일은 배포에서 제외하도록 gradle 파일을 설정해주어야 한다.

1. build.gradle 파일에 아래 코드를 추가해준다.

jar {
    enabled = false
}

2. 위에서 만든 ci.yml 파일 이름을 cicd.yml로 변경하고 아래의 코드로 변경해준다.

name: CI/CD

on:
 push:
    branches: [ main ]

jobs:
 build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - uses: actions/setup-java@v3
        with:
          distribution: 'corretto'
          java-version: '17'

      - name: Grant execute permission for gradlew
        run: chmod +x gradlew


      - name: Build with Gradle
        run: ./gradlew clean build

      - name: Get current time
        uses: josStorer/get-current-time@v2.0.2
        id: current-time
        with:
           format: YYYY-MM-DDTHH-mm-ss
           utcOffset: "+09:00"
           
      - name: Set artifact
        run: echo "artifact=$(ls ./build/libs)" >> $GITHUB_ENV

      - name: Beanstalk Deploy
      uses: einaregilsson/beanstalk-deploy@v20
      with:
        aws_access_key: ${{ secrets.AWS_ACCESS_KEY_ID }}
        aws_secret_key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
        application_name: 어플리케이션 이름
        environment_name: 환경 이름
        version_label: github-action-${{steps.current-time.outputs.formattedTime}} region: ap-northeast-2
        deployment_package: ./build/libs/${{env.artifact}}

3. AWS의 IAM 서비스로 접속해준다. 그 다음 사용자를 클릭해준다. 그리고 사용자 생성을 눌러준다.

4. 사용자 이름을 설정해주고, 다음을 눌러준다.

5. 권한 설정은 직접 정책 연결로 선택해준다.

6. 아래의 권한을 선택해주고, 다음을 눌러 사용자를 생성해준다.

7. 생성을 마치고 사용자를 눌러준다. 그리고 액세스 키 만들기를 눌러준다.

8. 서드파티 서비스를 클릭해준다.

9. 설명 태그는 아래와 같이 달아준다.

10. 생성을 완료하면 아래 화면처럼 액세스 키와 비밀번호를 얻을 수 있다.

액세스 키와 비밀 액세스 키는 딱 한번만 확인할 수 있으므로 값을 미리 복사하거나, .csv 파일 다운로드를 통해 보관할 수 있다.

11. 복사한 값을 등록하기 위해 깃허브 리포지토리에 접속한 뒤 Setting -> Secrets and variables -> Action으로 들어가준다. 그리고 New repository secrets 버튼을 눌러 새로운 비밀키를 등록해준다.

12. 이제 설정이 완료되었으므로 cd가 정상적으로 작동하는 것을 확인하기 위해 커밋과 푸시를 차례대로 수행하고 확인한다.

13. build 버튼을 누르면 아래와 같이 진행 상황을 확인해볼 수 있다.

<출처>

https://goldenrabbit.co.kr/2023/07/05/github-actions%EC%9C%BC%EB%A1%9C-%EB%B0%B0%ED%8F%AC-%EC%9E%90%EB%8F%99%ED%99%94%ED%95%B4-%EB%B3%B4%EA%B8%B0a-k-a-ci-cd-2%ED%8E%B8/

[AWS] Elastic Beanstalk를 이용한 서버 배포

강방당 — Fri, 31 Jan 2025 21:09:52 +0900

EC2 : AWS에서 제공하는 원격 서버 -> 가상의 PC/서버 한대를 임대

- 오토 스케일링 그룹: 사용자의 요청 횟수에 따라 EC2를 늘이거나 줄인다.

- 타깃 그룹

- 로드 밸런서: 요청이 한 경로로 많이 들어오면 부하가 발생하므로 요청을 분산시키는 작업을 하고, 어디로 분산시킬지 그룹을 정함.

RDS: AWS에서 제공하는 원격 데이터베이스

Elastic Beanstalk: 위의 서비스들을 한 번에 설정하는 서비스로 일래스틱 빈스토크를 사용하면 서버 업로드용 코드만 작성해도 서버를 쉽게 올릴 수 있고, 그 외의 기능들, 로드 밸런싱, 오토 스케일링, 모니터링, 배포 등을 일래스틱 빈스토크 메뉴 안에 직접 구성하거나 설정 파일로 자동 처리할 수 있다.

Elastic Beanstalk를 사용하는 과정

1. 애플리케이션 생성

2. 버전 업로드(애플리케이션의 소스를 번들 형태 (ex. war 파일)로 업로드)

3. 환경 생성(일래스틱 빈스토크가 자동으로 환경을 실행하고 코드 실행에 필요한 AWS 리소스를 생성하고 구성)

4. 환경 관리(필요한 경우 버전 업데이트를 하거나 새로운 앱 버전을 배포)

1. 리전을 서울로 변경해줍니다.

2. IAM을 검색해 들어가 줍니다. IAM은 AWS 리소스에 접근하는 권한을 관리하는 서비스로 일래스틱 빈즈토크 서비스에 부여할 역할을 IAM에서 만들어 주어야 합니다.

3. 역할 -> 역할 생성을 눌러주세요.

4. 신뢰할 수 있는 엔터티를 AWS 서비스로 선택해주고, 사용 사례를 EC2로 선택해준 뒤 다음을 눌러주세요.

5. 다음 단계로 넘어가서 2단계 권한 추가에서는 아래와 같이 AWSElasticBeanstalkMulticontainerDocker, AWSElasticBeanstalkWebTier, AWSElasticBeanstalkWorkerTier 이렇게 3개를 추가해줍니다. 권한 경계는 선택하지 않고 다음을 눌러서 넘어가줍니다.

6. 다음 3단계에서는 구분할 수 있도록 이름을 지어줍니다, 아래에서는 지금까지 설정한 정보가 잘 설정되었는지 확인할 수 있습니다. 확인되었으면 역할 생성을 눌러 역할을 생성해주시면 됩니다.

1. Elastic Beanstalk를 검색하고 들어가줍니다.

2. 환경에 들어가서 환경 생성을 눌러줍니다

3. 환경 생성에서 애플리케이션 이름을 설정해주고, 플랫폼을 Java로 선택해줍니다. 그 외에는 기본값으로 두고 다음을 눌러줍니다.

4. 서비스 액세스에서는 서비스 역할 - 새 서비스 역할 생성 및 사용을 선택하고, EC2 인스턴스 프로파일에서는 아까 만들었던 IAM을 아래와 같이 설정해줍니다. 그리고 검토 단계로 건너 뛰기를 선택해줍니다.

5. 설정 정보를 확인하고 제출을 선택해서 Elastic Beanstalk 환경 생성을 마쳐주면 됩니다. 조금 기다려주면 생성이 완료됩니다.

6. 프로젝트 생성이 완료되면 화면이 전환되는데, 환경을 눌러서 환경 목록을 봐줍니다.

환경 목록에 방금 생성된 환경의 상태가 OK로 보이는지 확인하고 URL을 클릭해줍니다.

7. URL에 잘 접속이 되는지 확인해줍니다. 아래처럼 Congratulations가 잘 나오면 성공입니다.

<일래스틱 빈스토크내에 RDS 생성하기>

1. 일래스틱 빈스토크 창 내의 환경 -> 내가 만든 환경을 클릭해주고 들어가줍니다.

2. 구성을 누르고 네트워킹 및 데이터베이스 메뉴에서 편집을 눌러주세요.

3. 스크롤을 쭉 내리다보면 데이터베이스 탭이 보입니다. 여기서 데이터베이스 활성화 버튼을 눌러 활성화를 켜주고, 데이터베이스 설정을 mysql, 인스턴스 클래스를 db.t3.micro로(프리티어) 설정해줍니다.

4. 사용자 이름과 암호도 채워줍니다. 암호는 8자 이상이어야 하며, 사용자 이름과 암호는 꼭 외우고 있어야합니다. 여기까지 했으면 오른쪽 아래의 적용을 눌러 데이터베이스를 생성해주세요.

5. RDS를 검색해서 들어가줍니다.

6. 왼쪽 바에서 데이터베이스를 눌러보면 방금 만든 RDS가 생성중인 것을 확인할 수 있습니다. 조금 기다려주면 RDS가 생성됩니다.

7. RDS 생성이 완료된 다음 만들어진 RDS 식별자를 눌러서 새 창에 들어가면 RDS 정보를 확인할 수 있습니다. 여기 있는 이 엔드 포인트는 RDS로 연결할 때 사용되니 미리 복사해두면 됩니다.

8. 다시 일래스틱 빈스토크로 돌아가줍니다. 그리고 환경->구성으로 들어가줍니다. 그리고 스크롤을 내려 업데이트, 모니터링 및 로깅 탭을 찾아서 편집을 눌러줍니다.

9. 편집창에서 스크롤을 내리면 환경 속성을 찾을 수 있습니다. 여기에서 RDS 설정정보를 입력해주어야 합니다.

환경속성을 3개 추가해주고 아래와 같이 설정해주세요.

SPRING_DATASOURCE_URL	jdbc:mysql://아까 복사해두었던 엔드포인트/DB명
SPRING_DATASOURCE_USERNAME	RDS에서 설정한 사용자 이름
SPRING_DATASOURCE_PASSWORD	RDS에서 설정한 비밀번호

10. 설정한 환경 속성값은 application.properties에서 spring.datasource 항목과 동일한 역할을 합니다. springboot 프로젝트 내에서 spring.datasource 항목들을 설정한 환경 속성 값들로 변경해주세요.

<로컬에서 RDS 연결하기>

1. 로컬에서 RDS를 사용하기 위해서는 보안그룹 설정이 필요합니다. 다시 AWS에서 RDS를 검색해서 들어가주고, 데이터베이스 창으로 이동해줍니다.

2. DB 식별자를 누르고, VPC 보안 그룹 링크를 클릭해줍니다.

3. 인바운드 규칙에 들어가서 인바운드 규칙 편집 버튼을 눌러줍니다.

4. 규칙 추가를 누르고, 유형을 MYSQL/Aurora, 소스는 내 IP를 선택하고 규칙 저장을 눌러줍니다. 이렇게하면 로컬에서 일래스틱 빈스토크 데이터베이스에 접근할 수 있습니다.

5. Host에 엔드포인트, User과 Password에 AWS RDS에서 설정해준 값들을 넣고 Test Connection을 해보면 연결이 잘되는 것을 확인할 수 있습니다.

<일래스틱 빈스토크에 서비스 배포>

1. Gradle 탭을 눌러서 Tasks -> build -> build를 더블클릭해 빌드를 진행합니다.

2. 빌드가 끝나면 build->libs에 빌드 완성 파일이 생성됩니다. jar 파일 두개가 생기는데 그 중에서 -plain이 없는 jar파일을 적당한 위치에 저장해주세요.

3. 일래스틱 빈즈토크로 돌아가서 생성된 환경의 이름을 클릭합니다.

4. 업로드 및 배포를 누르고, 아까 따로 복사해둔 jar 파일을 업로드해줍니다.

5. 업로드를 한 뒤에, Elastic Beanstalk의 환경->구성으로 들어간 뒤, 업데이트, 모니터링 및 로깅의 편집을 선택하고 application.properties의 값들 중 덮어 쓸 값들을 입력해줍니다.

6. 설정이 완료되면 이제 배포 url을 타고 들어가면 아래처럼 잘 배포된 것을 확인할 수 있습니다.

[AWS S3] deleteObject 메서드를 통해 삭제 시 버킷에서 삭제되지 않는 오류 해결

강방당 — Thu, 30 Jan 2025 17:47:01 +0900

개발 중인 프로젝트에서 이미지 저장이 필요해서 AWS S3 버킷을 만들어서 연동 중이었다.
업로드 기능은 문제 없이 잘 되어서 이미지 업로드 이후 S3를 새로고침하면 버킷의 수가 업로드 한 이미지 수 만큼 잘 늘어나는 것을 확인할 수 있었는데,

삭제 기능의 경우 DB에 따로 저장해 둔 이미지 url은 잘 삭제 되었으나 버킷을 새로고침해도 버킷에 존재 하는 객체의 수가 계속 그대로였다.

분명히 콘솔에서는 아무런 에러없이 잘 동작해서 에러의 원인을 열심히 찾아보았다.

1. 버전 관리 문제

버전 관리가 활성화되어있으면 deleteObject()가 즉시 삭제하지 않고 "삭제 마커(Deletion Marker)"만 추가하므로 파일이 실제 삭제된 것이 아니라 "숨김 처리"된 것일 가능성이 있다고 한다.

그래서 버전 관리를 활성화해서 한번 시도해보고 비활성화해서 한번 시도해봤는데

아무런 변화가 없었다,,,,,

2. 파일명이 제대로 SubString 되지 않았을 경우

파일명이 버킷내의 객체명과 일치하지 않으면 S3에서는 일치하는 객체를 찾을 수가 없어 객체가 잘 삭제되지 않는다.

private String extractFileNameFromUrl(String imageUrl) {
    try {
        URL url = new URL(imageUrl);
        String filePath = url.getPath(); // 경로 추출
        return filePath.substring(filePath.lastIndexOf("/") + 1); // 파일명만 추출
    } catch (MalformedURLException e) {
        throw new IllegalArgumentException("Invalid S3 URL format: " + imageUrl);
    }
}

당시에 나는 파일명을 추출하는 위의 함수를 하나 정의해서 호출해서 사용하고 있었는데,

이 파일명이 아닐 수도 있을거라고 생각해서 substring도 조정해보고, 아니면 아예 https://버킷명.s3.ap-northeast-2~으로 시작하도록 해서도 시도해봤는데, 실패했다..

파일명은 위처럼 추출하는 것이 맞다.,,

3. 파일명 인코딩 문제

그래서 추가적으로 열심히 찾아본 결과 파일명 인코딩 디코딩 문제일수도 있다고 해서 다시한번 파일명을 유심히 찾아봤는데, 자세히 보니 버킷 내 객체의 파일명과 DB에 저장된 객체의 파일명과 달랐다....!

DB에 저장되어있는 파일명

버킷에 저장되어있는 파일명

그래서 지금까지 객체 삭제에 실패했던 원인은 파일명이 URL 인코딩된 형태로 삭제 요청이 보내졌기 때문이었다!!

따라서 URLDecoder.decode()를 사용하여 원본 파일명으로 변환해주어야 한다

URL 인코딩이란?

특수 문자(공백, 한글, 특수기호 등)를 안전하게 웹에서 전송하기 위해 변환하는 과정
웹 브라우저나 네트워크에서 안전하게 전달하기 위해 사용하는 표준 인코딩 방식
일반적으로 ASCII 문자만 안전하게 사용 가능
- 안전한 문자: A-Z, a-z, 0-9, -, _, .
- 인코딩해야 하는 문자: 공백, 한글, 특수문자 (%20, %EC%95%88%EB%85%95 등)

인코딩된 파일과 디코딩된 파일의 차이

파일 자체에는 차이가 없음!
하지만 S3에서 파일을 저장할 때 키(Key)는 URL 인코딩된 상태일 가능성이 높음
삭제할 때는 반드시 디코딩해서 원래 파일명으로 전달해야 함

따라서 S3 URL에서 파일명 추출하는 extractFileNameFromUrl 메서드를 아래와 같이 수정해주니 정상적으로 객체가 잘 삭제되는 것을 확인할 수 있었다.

// S3 URL에서 파일명 추출
    private String extractFileNameFromUrl(String imageUrl) {
        try {
            URL url = new URL(imageUrl);
            String filePath = url.getPath();
            String fileName = filePath.substring(filePath.lastIndexOf("/") + 1);
            return URLDecoder.decode(fileName, StandardCharsets.UTF_8.name());
        } catch (MalformedURLException | UnsupportedEncodingException e) {
            throw new ImageUploadException(ImageUploadErrorCode.S3_DELETE_FAILED);
        }
    }

[Java to Kotlin] 코틀린에서 객체 생성 & 의존성 주입

강방당 — Mon, 20 Jan 2025 15:12:25 +0900

자바에서 코틀린으로 마이그레이션 하기 위해 객체 생성 & 의존성 주입을 할 경우의 차이점에 대해서 알아보고자 한다.
자바와 코틀린의 차이를 크게 아래와 같이 나눌 수 있다.

1️⃣ 객체 생성 방식의 차이

: 코틀린은 자바보다 객체 생성 방식이 단순하고 간결하여, 불필요한 보일러플레이트 코드가 줄어든다.

2️⃣ lateinit & by lazy를 활용한 객체 초기화

: 코틀린에서 lateinit, by lazy를 활용하면 초기화 및 생명주기 관리가 더욱 쉬워진다.

3️⃣ 싱글톤 객체(object)를 통한 코드 단순화

: 코틀린에서는 object 키워드 하나만으로 간편하게 싱글톤을 구현할 수 있다.

4️⃣ Spring Boot에서 DI 방식 차이

: 코틀린에서는 Spring Boot에서 @Autowired 없이 constructor 주입을 통해 더 간결한 DI 설정이 가능하다.

5️⃣ 코틀린에서 @Autowired 없이 DI 가능

: 코틀린의 val, var 활용법을 잘 이해하면 불필요한 getter/setter를 제거할 수 있다.

1) 객체 생성 방식의 차이

Java vs Kotlin 객체 생성 차이점

기능	Java	Kotlin
기본 객체 생성	new 키워드 필요	new 없이 생성 가능
생성자 선언	class 내에 constructor 선언	class 선언부에서 바로 정의 가능
getter/setter	명시적으로 작성해야 함	자동 생성됨 (val = final)
싱글톤 객체	static 키워드 필요	object 키워드로 간결하게 구현 가능

Java 예시

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() { return name; }
    public int getAge() { return age; }
}

Person person = new Person("홍길동", 25);
System.out.println(person.getName());

Kotlin 예시

class Person(val name: String, val age: Int)

val person = Person("홍길동", 25)
println(person.name)

new 키워드를 생략할 수 있다.
val을 사용하면 자동으로 getter가 제공된다. (var의 경우 getter + setter이 자동 생성 된다.)

2) lateinit & by lazy를 활용한 객체 초기화

자바에서는 필드 초기화를 위해서 null을 사용해야 하는 경우가 많지만, 코틀린에서는 lateinit과 by lazy를 사용하여 객체의 생명주기를 효율적으로 관리할 수 있다.

lateinit 사용 (Spring DI에서 필드 주입 시 사용)

lateinit은 생성자에서 초기화 할 수 없는 var 속성
의존성 주입에서 필드 주입시 사용 가능

Class UserService {
	lateinit var repository: UserRepository
    
    fun initialize(repo: UserRepository) {
    	repositoty = repo
    }
}

by lazy 사용 (비용이 큰 객체의 초기화 지연)

객체가 처음 사용될 때만 초기화 된다.
초기화 비용이 큰 객체 (데이터베이스 연결, 설정 파일 로드 등)에 유용하다.
자바에서는 보통 싱글톤 패턴을 사용해야 하지만 코틀린에서는 lateinit과 by lazy를 활용하여 더 간결하게 구현할 수 있다.

class ConfigLoader {
	val config: Configuration by lazy {
    	configuration()
    }
}

3) 싱글톤 객체(object)를 통한 코드 단순화

자바에서는 싱글톤을 구현하려면 static 필드를 활용해야 하지만 코틀린에서는 object 키워드만으로 간단하게 싱글톤 객체를 생성할 수 있다.

Java 스타일 싱글톤

public class Database {
    private static final Database INSTANCE = new Database();

    private Database() {}

    public static Database getInstance() {
        return INSTANCE;
    }

    public void connect() {
        System.out.println("Connected to Database");
    }
}

Database.getInstance().connect();

Kotlin 스타일 싱글톤

코틀린에서는 object 키워드 하나만으로 간단하게 싱글톤 객체를 구현할 수 있다.
Spring의 @Component, @Service를 사용하는 Bean 관리에도 유용하다.

object Database {
    fun connect() {
        println("Connected to Database")
    }
}
Database.connect()

4) Spring Boot에서 DI 방식 차이

Spring Boot에서는 의존성 주입(DI)을 활용하여 객체를 관리하는데 코틀린에서는 생성자 주입을 기본적으로 사용하고 자바처럼 필드주입을 주로 사용하는 것은 권장되지 않는다.

Java 스타일 DI (생성자 주입)

@Service
public class UserService {
	private final UserRepository userRepository
    
    @Autowired
    public UserService(UserRepository userRepository) {
        this.userRepository = userRepository;
    }
}

Kotlin 스타일 DI (생성자 주입)

코틀린에서는 constructor를 생략할 수 있으며 @Autowired 없이도 의존성 주입이 가능하다.
또한 val을 사용하면 getter가 자동 생성되므로 간결하게 코드를 작성할 수 있다.

@Service
class UserService(private val userRepository: UserRepository) {
	 fun getUser(id: Long) = userRepository.findById(id)
}

5) 코틀린에서 @Autowired 없이 DI 가능

자바에서는 @Autowired 어노테이션을 필수적으로 사용해야 하지만, 코틀린에서는 생성자 주입을 사용할 경우 스프링이 자동으로 의존성을 주입해준다,

Java 스타일 필드 주입

@Service
public class UserService {
	@Autowired
    private UserRepository userRepository;
}

Kotlin 스타일 생성자 주입

@Service
class UserService(private val userRepository: UserRepository)

[Java to Kotlin] 코틀린 : 컬렉션(List, Set, Map)

강방당 — Mon, 20 Jan 2025 12:48:27 +0900

코틀린에서는 List, Set, Map의 컬렉션 프레임 워크를 제공한다. 또한 고차 함수(map, filter, reduce)를 활용한 함수형 프로그래밍을 지원하여 코드를 간결하고 효율적으로 작성할 수 있다.

코틀린의 컬렉션은 크게 불변(Immutable)과 가변(Mutable)로 나눌 수 있는데, 불변 컬렉션은 추가/삭제/수정이 불가능하고, 가변 컬렉션은 가능하다.

컬렉션 유형	불변 컬렉션	가변 컬렉션
리스트 (List)	listOf()	mutableListOf()
세트 (Set)	setOf()	mutableSetOf()
맵 (Map)	mapOf()	mutableMapOf()

1) 리스트 (List)

리스트는 요소를 순서대로 저장하는 컬렉션이고, 중복을 허용한다.

a. 불변 리스트 (listOf)

listOf()로 생성된 리스트는 불변(Immutable) 이므로, 값을 추가하거나 삭제할 수 없다.

val names = listOf("홍길동", "박문식", "이몽룡")
println(names[0]) //홍길동

b. 가변 리스트(mutableListOf)

mutableListOf()를 사용하면 요소를 추가, 삭제, 변경할 수 있다.

val numbers = mutableListOf(1, 2, 3)
numbers.add(4)
numbers.remove(1)
println(numbers) //[2, 3, 4]

c. 리스트의 반복 (forEach, for-in)

forEach

val list = listOf("Kotlin", "Java", "Python")
list.forEach { println(it) }
list.forEach { aa -> println(aa) }

for-in

val list = listOf("Kotlin", "Java", "Python")

for (item in list) {
	println(item)
}

2) 세트 (Set)

Set는 중복을 허용하지 않는 컬렉션이다.

a. 불변 세트 (setOf)

setOf()를 사용하면 중복 요소가 자동으로 제거된다.

val uniqueNum = setOf(1, 2, 3, 3, 2)
println(uniqueNum) //[1, 2, 3]

b. 가변 세트(mutableSetOf)

mutableSetOf()를 사용하면 요소를 추가, 삭제할 수 있다.

val mutableSet = mutableSetOf("Apple", "Banana")
mutableSet.add("Cherry")
mutableSet.remove("Banana")
println(mutableSet) //[Apple, Cherry]

3) 맵 (Map)

맵은 키와 값 쌍으로 이루어진 컬렉션이다.

a. 불변 맵 (mapOf)

mapOf()를 사용하면 키-값 쌍을 불변 컬렉션으로 저장할 수 있다.

val userMap = mapOf("name" to "홍길동", "age" to 25)
println(userMap["name"]) //홍길동

b. 가변 맵 (mutableMapOf)

mutableMapOf()를 사용하면 값을 추가, 수정, 삭제할 수 있다.

val userInfo = mutableMapOf("name" to "Bob", "age" to 30)
userInfo["age"] = 31  // 값 변경
userInfo["city"] = "Seoul" // 새로운 키 추가
println(userInfo) // 출력: {name=Bob, age=31, city=Seoul}

4) 컬렉션 프레임워크의 메서드 (변환, 필터링, 누적)

코틀린에서 함수를 정의하는 기본 구조는 아래와 같다.

a. 컬렉션 변환 함수 (map, flatMap)

map을 사용하면 각 요소를 변환하여 새로운 리스트를 만들 수 있다.

val numbers = listOf(1, 2, 3, 4, 5)
val doubled = numbers.map {it * 2}
println(doubled)

flatMap을 사용하면 중첩 리스트를 단일 리스트로 변환할 수 있다.

val list = listOf(listOf(1, 2), listOf(3, 4))
val flatList = list.flatMap {it}
println(flatList) //[1, 2, 3, 4]

b. 컬렉션 필터링 (filter, find)

filter를 사용하면 조건을 만족하는 요소만 추출할 수 있다.

val numbers = listOf(1, 2, 3, 4, 5)
val evenNumbers = numbers.filter { it % 2 == 0 }
println(evenNumbers) //[2, 4]

find는 첫번째로 조건을 만족하는 요소만 추출할 수 있다.

val names = listOf("Alice", "Bob", "Charlie")
val nameWithB = names.find { it.startsWith("B") }
println(nameWithB) // 출력: Bob

c. 컬렉션 요소 누적 처리 (reduce, fold)

reduce를 활용하면 누적을 합산하는데, 초기값 없이 첫 번째 요소부터 누적 연산을 수행한다.

val numbers = listOf(1, 2, 3, 4, 5)
val sum = numbers.reduce { acc, num -> acc + num }
println(sum) //15

fold의 경우는 reduce와는 다르게 초기값을 지정할 수 있다.

val numbers = listOf(1, 2, 3, 4, 5)
val sumWithInitial = numbers.fold(10) { acc, num -> acc + num }
println(sumWithInitial) // 출력: 25

[Java to Kotlin] 코틀린 : 함수(function)

강방당 — Mon, 20 Jan 2025 12:11:25 +0900

1) 함수 선언과 호출

코틀린에서 함수를 정의하는 기본 구조는 아래와 같다.

fun 함수이름(매개변수: 타입): 반환타입 {
// 함수 본문
return 결과값
}

a. 기본 함수 선언

fun add(a: Int, b: Int): Int {
    return a + b
}

b. 함수 호출

val result = add(3, 5)
println(result) // 출력: 8

2) 단일 표현식 함수

코틀린에서는 함수의 본문이 단 한 줄만 있을 경우 중괄호 { } 없이 = 을 사용하여 더 코드를 간결하게 작성할 수 있다.

fun multiply(a: Int, b: Int) = a * b

println(multiply(4, 5))

3) 반환 타입이 없는 함수 (Unit)

코틀린에서 반환값이 없는 함수는 Unit 타입을 반환한다.

자바에서의 void와 비슷하지만 차이점은, Unit은 실체 객체라는 점이다.

a. 기본 Unit 반환 함수

fun printHello(): Unit {
    println("Hello, Kotlin!")
}

그러나 Unit은 생략할 수 있다. (일반적으로 생략하는 것이 권장된다.)

fun printHello() {
	println("Hello, Kotlin!")
}

b. return 없이 종료되는 함수

Unit을 반환하는 함수는 return을 생략해도 자동으로 return Unit이 적용된다.

fun printMessage(message: String) {
    println("Message: $message")
}

printMessage("Hello")

4) 기본 값이 있는 매개변수

a. 기본값이 있는 매개변수 사용

fun greet(name: String = "Guest") {
	println("Hello, $name")
}

greet()         // 출력: Hello, Guest
greet("홍길동")  // 출력: Hello, 홍길동

기본 값이 여러개 있는 경우

fun orderCoffee(type: String = "Americano", size: String = "Medium") {
    println("Order: $size $type")
}

orderCoffee()                 // 출력: Order: Medium Americano
orderCoffee("Latte")          // 출력: Order: Medium Latte
orderCoffee("Espresso", "Small")  // 출력: Order: Small Espresso

b. 명명된 인자

기본값을 사용하는 함수에서 순서에 상관없이 특정 매개변수만 전달하고 싶을 때 사용한다.

orderCoffee(size = "Large") // 출력: Order: Large Americano

5) 가변 인자 (vararg)

코틀린에서는 vararg 키워드를 사용해서 매개변수의 개수를 동적으로 지정할 수 있다.

a. vararg를 사용한 함수

fun sum(vararg numbers: Int) : Int {
	return numbers.sum()
}

println(sum(1, 2, 3, 4, 5)) // 출력: 15

b. vararg와 일반 매개변수 함께 사용

fun printNumbers(prefis: String, vararg numbers: Int) {
    println("$prefix: ${numbers.joinToString()}")
}

printNumbers("Numbers", 1, 2, 3, 4, 5)

c. 배열을 vararg에 전달하기 (spread operator * )

배열을 vararg에 전달하려면 * 을 사용해야 한다.

val numArray = intArrayOf(10, 20, 30)
println(sum(*numArray))

6) 고차 함수

고차 함수는 다른 함수를 매개변수로 받거나 함수를 반환하는 함수이다.

이 기능을 활용하면 함수형 프로그래밍이 가능해진다.

a. 고차 함수의 기본 표현

fun operate(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
	return operation(a, b)
}

//고차 함수 호출
val result1 = operate(10, 5) { x, y -> x + y }
val result2 = operate(10, 5) { x, y -> x * y }

println(result1) // 출력: 15
println(result2) // 출력: 50

b. 함수를 반환하는 고차 함수

fun getOperation(type: String): (Int, Int) -> Int {
	return when(type) {
    	"add" -> { a, b -> a + b }
        "multiply" -> { a, b -> a * b }
        else -> { _, _ -> 0 }
    }
}

val addFunction = getOperation("add")
println(addFunction(10, 5)) //15

val multiplyFunction = getOperation("multiply")
println(addFunction(10, 5)) //50

7) 람다 표현식 (Lambda)

람다 표현식은 익명 함수를 간결하게 표현하는 방법으로, 코틀린에서는 함수를 변수에 저장하거나, 고차 함수의 인자로 전달할 때 람다 표현식을 자주 사용한다.

a. 람다 표현식의 문법

val 함수이름: (매개변수 타입) -> 반환 타입 = { 매개변수 -> 실행코드 }

val square: (Int) -> Int = {num -> num * num}

b. 여러 줄 람다 표현식

람다 표현식이 여러 줄이면 {} 안에서 여러 줄을 작성할 수 있다.
it 키워드는 람다의 단일 매개변수를 나타낸다.

val printMessage: (String) -> Unit = {
	println("메시지 출력:")
    println(it)
}

8) 확장 함수

확장함수란 기존 클래스에 새로운 함수를 추가하는 것으로, 기존의 클래스 소스 코드에 접근하지 않고 새로운 기능을 추가할 수 있다.

a. 기본적인 확장 함수

fun String.addPrefix(prefix: String): String {
	return "$prefix$this"
}

val result = "Kotlin".addPrefix("Hello ")
println(result) //Hello Kotlin

b. 확장 함수의 활용

확장 함수를 사용하면 객체의 기능을 확장하면서도 기존 코드의 변경 없이 사용할 수 있다.

fun Int.isEven(): Boolean {
	return this%2 == 0
}

println(10.isEven()) //true

c. 확장 함수와 클래스

확장 함수를 사용하면 클래스 내부 코드를 변경하지 않고도 기능을 추가할 수 있다.

class Person(val name: String, val age: Int)

fun Person.introduce() {
	println("name: $name, age: %age")
}

val person = Person("홍길동", 25)
person.introduce()

9) 내부 함수

코틀린에서는 함수 내부에 또 다른 함수를 정의할 수 있다. 내부 함수는 해당 함수 안에서만 사용가능하고, 캡슐화를 강화하는 역할을 한다.

a. 내부 함수의 기본 구조

내부 함수는 외부함수 내부에서만 사용 가능하므로 불필요한 외부 접근을 막을 수 있다.

fun outerFun(x: Int, y: Int): Int {
	fun innerFun(a: Int, b: Int): Int {
    	return a + b
    }
    return innerFun(x, y)
}

println(outerFun(3, 5)) //출력: 8

b. 내부 함수의 활용

ex) 중복되는 할인 로직 적용하기

fun calculateTotalPrice(prices: List<Int>, discount: Int): Int {
    fun applyDiscount(price: Int): Int {
        return price - (price * discount / 100)
    }

    return prices.sumOf { applyDiscount(it) }
}

val prices = listOf(100, 200, 300)
println(calculateTotalPrice(prices, 10)) // 출력: 540

10) 인라인 함수 (inline)

고차 함수는 일반 함수보다 실행 속도가 느리기 때문에 inline 키워드를 사용하면 함수 호출을 줄여 성능을 최적화 할 수 있다.

inline fun executeOperation(a: Int, b: Int, operation: (Int, Int) -> Int): Int {
    return operation(a, b)
}

val result = executeOperation(10, 5) { x, y -> x * y }
println(result) // 출력: 50

[Java to Kotlin] 코틀린 : 클래스와 객체

강방당 — Fri, 17 Jan 2025 12:25:11 +0900

1. 클래스 선언 및 객체 생성

코틀린에서는 자바와 마찬가지로 class 키워드를 사용해서 클래스를 선언할 수 있다.

자바와 비슷하지만 더 간결하고 직관적인 문법을 제공하며, 객체를 생성할 때 new 키워드를 사용하지 않아도 된다.

기본 클래스 선언

class Person {
	var name: String = "홍길동"
    var age: Int = 25
}

new 키워드를 사용하지 않고 Person() 형태로 객체를 생성한다.

val person1 = Person()
person1.name = "박문식"
person1.age = 30

생성자

코틀린에서는 주 생성자와 보조 생성자(constructor)를 사용할 수 있다.

주 생성자

주 생성자는 클래스 헤더에서 선언되고, 자동으로 속성을 초기화할 수 있다.
val 또는 var을 생성자 매개변수에 추가하면 자동으로 멤버 변수로 선언된다.

class Student(val name: String, var age: Int)

val student1 = Student("홍길동", 20)

보조 생성자 (constructor 키워드)

보조 생성자는 constructor 키워드를 사용하여 추가로 정의할 수 있으며 주 생성자 없이도 클래스를 생성할 수 있다.

class Car {
	var brand: String
    var year: Int
    
    constructor(brand: String) {
    	this.brand = brand
        this.year = 2024
    }
    
    constructor(brand: String, year: Int) {
    	this.brand = brand
        this.year = year
    }
}

val car1 = Car("Hyundai")

val car2 = Car("Kia", 2020)

2. 클래스 멤버 (속성과 함수)

코틀린에서 클래스 내부에 선언된 변수를 속성이라고 하고, 클래스 내부에는 속성과 함수를 정의할 수 있다.

속성 (Properties)

프로퍼티는 필드(Field)와 접근자 메서드(getter, setter)를 하나로 합친 것을 의미한다.
val은 읽기 전용 (getter만 생성)
var은 읽기/쓰기 가능 (getter + setter 생성)

커스텀 getter와 setter

코틀린에서는 속성에 대한 커스텀 getter와 setter을 정의할 수 있다.

class Student {
	var score: Int = 0
    	set(value) {
        	field = if (value >= 0) value else 0
        }
    var isPassed: Boolean
    	get() = score >= 50
}

val student = Student()
student.score = -10
println(student.score) // 0

student.score = 70
println(student.isPassed) // true

3. 데이터 클래스 (data class)

코틀린에서는 data class를 사용하면 기본적인 메서드 equals(), hashCode(), toString(), copy()를 자동으로 생성해준다.
자바에서는 위와 같은 기본 메서드를 직접 구현해야 하지만, 코틀린에서는 따로 구현하지 않고 데이터 클래스를 이용하면 되므로 간편하다.

기본 데이터 클래스 vs 데이터 클래스

// 1. 일반 클래스
class Person(val name: String, val age: Int)
val person1 = Person("홍길동", 30)
println(person1) 
// 출력: Person@6d06d69c

data class Person(val name: String, val age: Int)

val person1 = Person("홍길동", 30)
println(person1) 
// 출력: Person(name=홍길동, age=30)

이렇게 데이터 클래스를 이용하면 자동으로 toString()이 적용되는 것을 볼 수 있다.
데이터 클래스는 기본적으로 equals()와 hashCode()를 자동으로 생성하여, 값이 동일하면 true를 반환한다.
(일반 클래스는 메모리 주소를 비교하기 때문에 false가 나옴)

copy() 함수

데이터 클래스는 copy() 함수를 제공하여, 기존 객체를 기반으로 새로운 객체를 쉽게 생성할 수 있다.

val person1 = Person("홍길동", 30)
val person2 = person1.copy(name = "박문식") // 일부 값만 변경 가능

println(person1) // Person(name=홍길동, age=30)
println(person2) // Person(name=박문식, age=30)

data class의 제한 사항

data class는 특정한 조건을 만족해야 한다.

주 생성자에 최소 하나 이상의 속성이 있어야 한다.
abstract, open, sealed, inner 키워드를 사용할 수 없다.
데이터 클래스는 데이터 저장을 위한 클래스로 사용해야 하며, 상속을 지원하지 않는다.

4. 싱글톤 객체 (object)

싱글톤 객체란 애플리케이션에서 단 하나의 인스턴스만 생성되는 객체로, 프로그램 실행동안 한 번만 메모리에 올라가며 어디서든 동일한 인스턴스를 공유할 수 있다.

코틀린에서는 싱글톤 객체(singleton object) 를 쉽게 만들 수 있도록 object 키워드를 제공한다.
자바에서는 Singleton 패턴을 직접 구현해야 하지만, 코틀린에서는 object 키워드만 사용하면 자동으로 싱글톤이 된다.

기본 싱글톤

싱글톤 객체는 object 키워드를 사용하여 선언한다.
자바에서 static과 비슷하지만 더 간결하다.

object Database {
    val name = "MainDB"

    fun connect() {
        println("Connected to $name")
    }
}

Database.connect()

클래스 내부 싱글톤 (companion object)

companion object는 클래스 내부에서 static 멤버처럼 동작하는 싱글톤 객체이다.
companion object를 사용하면 클래스 내부에서 정적 멤버처럼 사용할 수 있다.

class User(val name: String) {
	companion object {
    	fun createGuest(): User {
        	return User("Guest")
        }
    }
}

5. 상속 (open, override)

코틀린에서의 클래스는 자바와 다르게 기본적으로 final이므로 상속을 허용하려면 open 키워드를 사용해야 한다.

기본 상속 (open)

코틀린에서 클래스를 상속하려면, 부모 클래스에 open 키워드를 추가해야 한다.

open class Animal {
	fun eat() {
        println("먹고 있어요")
    }
}

class Dog : Animal() {
    fun bark() {
        println("멍멍!")
    }
}

val dog = Dog()
dog.eat()  // 부모 클래스의 함수 호출
dog.bark() // 자식 클래스의 함수 호출

메서드 오버라이딩

자식 클래스에서 부모 클래스의 메서드를 재정의(Overriding) 하려면 override 키워드를 사용해야 한다.
메서드도 기본적으로 final이므로, 오버라이딩 가능하게 하려면 open을 추가해야 한다.

open class Animal {
    open fun makeSound() {
        println("동물이 소리를 냅니다")
    }
}

class Dog : Animal() {
    override fun makeSound() {
        println("멍멍!")
    }
}

val dog = Dog()
dog.makeSound()  // 출력: 멍멍!

속성 오버라이딩

속성도 메서드 처럼 오버라이딩이 가능하며, override 키워드를 사용해야 한다.
open이 없는 속성은 오버라이딩이 불가능하므로 부모 클래스의 속성도 open 키워드를 추가해야 한다.

open class Animal {
	open val type: String = "동물"
}

class Dog : Animal() {
	override val type: String = "강아지"
}

val dog = Dog()
println(dog.type)

부모 클래스의 메서드 호출 (super)

자식 클래스에서 부모 클래스의 메서드를 호출하려면 super 키워드를 사용하면 된다.

open class Animal {
    open fun makeSound() {
        println("동물이 소리를 냅니다")
    }
}

class Dog : Animal() {
    override fun makeSound() {
        super.makeSound()  // 부모 클래스 메서드 호출
        println("멍멍!")   // 추가 기능
    }
}

val dog = Dog()
dog.makeSound()

추상 클래스 (abstract)

추상 클래스(abstract class)는 인스턴스를 생성할 수 없으며, 자식 클래스에서 반드시 오버라이딩 해야하는 함수를 포함할 수 있다.
추상 클래스는 abstract class로 선언
추상 함수는 abstract fun으로 선언
추상 함수는 구현하지 않고 오버라이딩을 필수로 요구한다.

abstract class Animal {
	abstract fun makeSound() //반드시 오버라이딩 해야 함
    
    fun eat() {
    	printnln("먹고 있어요")
    }
}

class Dog : Animal() {
	override fun makeSound() {
    	println("멍멍")
    }
}

val dog = Dog()
dog.makeSound()
dog.eat()

인터페이스(interface)

코틀린에서는 자바와 마찬가지로 다중 상속을 지원하지 않지만, 인터페이스를 사용하면 가능해진다.

interface Animal {
    fun makeSound() // 구현 없이 선언만 가능
}

interface Pet {
    fun play() {
        println("놀고 있어요")
    }
}

class Dog : Animal, Pet {
    override fun makeSound() {
        println("멍멍!")
    }
}

val dog = Dog()
dog.makeSound() // 멍멍!
dog.play()      // 놀고 있어요

인터페이스는 interface 키워드를 사용하며, class Dog : Animal, Pet 처럼 여러개를 다중으로 구현할 수 있다.