토누 개발 일지

안녕하세요!

정보글 작성 겸 스스로 회고 겸 부캠 후기글을 작성하고

지원서 작성과 코테, 면접 까지 지원 과정에 대해서 더 상세히 기록해보고자 합니다.

이번 글도 제 개인적 후기와 느낀 점 등을 중심으로 작성하였습니다 :)

1. 서류 작성

서류 지원 시에 작성해야 하는 자소서는 총 2항목 이었습니다.

1. IT's Your life에 지원하신 동기와 과정 수료 후, 이루고 싶은 취업계획을 작성해 주십시오. (최대 500자 입력가능)

후기글에도 적었듯이

저는 이 항목에서 저에게 부족한 점을 두괄식으로 강조해서 쓰고

부캠이 나의 이 부족한 점을 어떻게 채워줄 수 있는지 어필했습니다.

요즘 취준생들 중에 인턴이나 현장실습 등 실무 경험 갖고 계신 분들이 정말 많은데..

저는 이 경험이 없었어서 '실무 경험 없음'이 나의 부족한 점인데 kb 부캠의 실무형 교육으로 보완하고 싶습니다.

이렇게 강조했습니당 

2. SW 관련 경험 중 어려웠던 과제와 해결 방안에 대해 작성하고, 교육 과정을 통해 향후 어떤 개발자로 성장하고 싶은지 작성해 주십시오. ※SW 관련 경험 : SW 개발, SW 프로젝트 및 경진대회 경험(참여, 수상 등), IT 관련 자격증 취득 등 (최소 1자, 최대 500자 입력가능)

저는 전공자였으므로 이 항목에서는 졸업 작품으로 했던 개인 프로젝트 내용을 적었습니다.

개인 플젝에서 기술적 트러블 슈팅 겪었던 내용을 적었습니다.

=> 총평

두괄식, 간결한 문장 등에 유의해서 적었고

자소서를 엄청 잘 쓰는게 중요하다기보다는 평균 정도만 적으면 서류 합격은 가능한 것 같습니당

---

2. 코테 (전공자 sw적성진단)

전공자 sw진단은 코딩테스트 형식입니다!

6기는 플랫폼이 프로그래머스가 아니라 마이다스로 봤구요

마이다스는 특이한게 한 문제 내에 5가지의 단계로 구성되어 있습니다.

예를 들어 1번문제면

1-1번 a와 b의 최소공배수를 구하시오.

1-2번 a와 b의 최소공배수와 최대공약수를 구하시오.

이런 식으로 앞의 내용을 유지한 채 점점 디벨롭되는 형식입니다.

저는 그 전부터 코테를 계속 공부해오긴 했지만 그렇게 잘하는 건 아니었구요,,ㅎ

총 2문제에서

1번 문제 4단계

2번 문제 3단계

이 정도로 풀었던 것 같습니다.

꼭 한 문제를 5단계까지 맞추지 않아도 두 문제 골고루 푸시면 합격 가능한 것 같아요.

---

3. 대면 면접

마지막으로 대면면접 단계입니다!

전형을 할 때는 몰랐는데 이렇게 글로 적으니 정말.. 부캠 교육 하나 듣는 것도 쉬운 일이 아니네요

대면 면접은 실제 교육을 듣게 될 어린이대공원 교육장에서 진행됩니다!

5층 각 강의실에서 조 별로 대기, 6층으로 올라가서 각 방에서 면접 진행하는 순서이고

음.. 기억나는 내용을 적어보면

1. 복장은 정장 ~ 비즈니스 캐주얼까지 다양

그냥 정장입으면 무난할 것 같아요.

2. 5층 대기실에서 앉아서 대기하다가 모든 짐을 들고 6층으로 이동, 면접장 밖에 짐을 두고 들어갑니다.

3. 면접 구조는 면접관2 : 면접자 4으로 다대다 면접입니다.

4. 답변 순서는 왼쪽부터, 오른쪽부터 번갈아가면서 지목해주셨습니다.

5. 방마다 면접 분위기가 다를 것 같긴한데 저희 방은 꽤 부드럽게 해주셨습니다.

6. 면접 기출 질문

자기소개

교육 커리큘럼을 통해 어떤 개발자가 되고픈지

개인질문(졸업 여부, 이전에 들은 교육, 해본 프로젝트 등)

왜 개발자가 되고싶은지, 좋아하는 언어, 왜

협업할 때 팀장, 팀원, 갈등 해결 경험

교육 후 바로 취업할 건지 다른 교육을 더 들을건지(솔직히 답해달라고 함)

마지막 하고 싶은 말

제가 기억나는 면접 내용은 이 정도인데

교육 들으면서 친구들과 이야기해보니 면접장 마다 분위기도 내용도 달랐던 것 같아요.

저희 조는 기술 질문은 들어오지 않았는데 다른 곳에서는 프로젝트 기술 관련해서도 물어봤다고 들었습니다.

저는 개인질문으로 프론트와 백 중에서 왜 백엔드 개발자로 진로를 정했는가

이 질문을 받았습니다.

정말 이 교육을 수강하고 싶은지를 확인하는 전체적으로 평이한 면접이니 너무 긴장하지마시고 답변하시면

좋은 결과 얻으실 수 있을 것 같습니다.

추가적으로 드릴 팁은

1. 케이비 아이티즈 유얼 라이프 입니다.

잇츠가 아니라 아이티즈로 발음한다는 사실

실제로 저희 면접 조에서는 자기소개 때 제 앞의 3분이 모두 잇츠라고 하셨는데

이거는 지원자 입장에서 헷갈릴 수 있는 부분이니 크게 신경쓰시지 않는 것 같아요ㅎㅎ

(같은 면접 조에 잇츠라고 하신 분도 합격하신 것 같앗어요)

2. 성실히 교육 이수할 의지, 교육 후 취업할 의지

이 두개만 잘 전달되어도 합격 확률이 올라갈 것 같아요.

면접의 마지막쯤에, 여자 면접관 분께서 굉장히 따스하게

"합격하고 교육을 듣게되면 6개월이라는 긴 시간동안 중간에 느슨해지거나 마음이 헤이해질 수 있는데

지금 이 면접장에서 가졌던 열정을 생각하고 힘내주면 좋겠다"

이렇게 말씀해주셨는데

실제로 교육을 듣다보면 중간부터 출석을 자주 빠지는 분, 수업을 하나도 안듣는 분, 프로젝트에 성실히 참여하지 않는 분 등

초기의 열정을 잃어버리는 분들도 꽤 있었습니다.

매니저님들, 강사님들께서는 이 부트캠프 과정을 최대한 백퍼센트 활용해서 누구보다 교육과 취업을 원하는 분들을 수강생으로 맞이하길 원하실테니

열정과 간절함(?), 성실성 등을 초롱초롱하게 어필한다면

좋게 봐주실 것 같아요 :)

화이팅!

1. package org.scoula.security.account.domain;

AuthVO

@Data
public class AuthVO implements GrantedAuthority {
    private String username;
    private String auth;

    @Override
    public String getAuthority() {
        return auth;
    }
}

• GrantedAuthority 인터페이스 구현
  • getAuthority() 로 권한 정보 추출

CustomUser

@Getter @Setter
public class CustomUser extends User {
    //실질적인 사용자 데이터
    private MemberVO member;

    public CustomUser(String username, String password, Collection<? extends GrantedAuthority> authorities) {
        super(username, password, authorities);
    }

    public CustomUser(MemberVO vo) {
        super(vo.getUsername(), vo.getPassword(), vo.getAuthList());
        this.member = vo;
    }
}

• CustomUser(MemberVO vo)
  • MemberVO 를 User로 변환

2.  package org.scoula.security.account.dto;

LoginDTO

public class LoginDTO {
    public String username;
    public String password;

    public static LoginDTO of(HttpServletRequest request) {
        ObjectMapper om = new ObjectMapper();
        try {
            return om.readValue(request.getInputStream(), LoginDTO.class);
        } catch (Exception e) {
            e.printStackTrace();
            throw new BadCredentialsException("username or password is incorrect");
        }
    }
}

• request body에서 username, password 역직렬화(JSON 문자열 → 자바 객체로 변환하는 것)
• username이나 password가 틀리면 여기서 Exception 발생
• JwtUsernamePasswordAuthenticationFilter의 attemptAuthentication에서 사용

3.  package org.scoula.security.account.mapper;

UserDetailsMapper

public interface UserDetailsMapper {
    public MemberVO get(String username);
}

• tbl_member 테이블과 tbl_member_auth 테이블을 Join 처리
• get()은 CustomUserDetailsService에서 username으로 MemberVo를 조회하는데 사용

MemberVO vo = mapper.get(username);

4. package org.scoula.security.filter;

JwtUsernamePasswordAuthenticationFilter

public class JwtUsernamePasswordAuthenticationFilter extends UsernamePasswordAuthenticationFilter {

    public JwtUsernamePasswordAuthenticationFilter(AuthenticationManager authenticationManager, LoginSuccessHandler loginSuccessHandler, LoginFailureHandler loginFailureHandler) {
        super(authenticationManager);

        setFilterProcessesUrl("/api/auth/login");
        setAuthenticationSuccessHandler(loginSuccessHandler);
        setAuthenticationFailureHandler(loginFailureHandler);
    }

    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response) throws AuthenticationException {

        LoginDTO login = LoginDTO.of(request);

        UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(login.getUsername(), login.getPassword());

        return getAuthenticationManager().authenticate(authenticationToken);
    }
}

• 로그인 요청 경로 지정 : /api/auth/login
• 로그인 성공 처리기, 로그인 실패 처리기 등록

• attemptAuthentication() 메서드
  • 등록한 인증 url로 요청이 오면 호출
  • 요청에서 username, password 부분을 추출
  • UsernamePasswordAuthenticationToken 구성
  • AuthenticationManager에게 인증 요청
  • 인증경과 Authentication을 리턴

5. package org.scoula.security.handler, service, util;

🎁 전체 코드 => 깃허브 업로드 예정

🎁 패키지 전체 요약

로그인 처리 전체 흐름

🐻‍❄️ 프론트엔드

const login = async (member) => {
    const { data } = await axios.post('/api/auth/login', member);
    state.value = { ...data };
    localStorage.setItem('auth', JSON.stringify(state.value));
  };

🐻 백엔드

1️⃣ AuthenticationErrorFilter

필터 체인 초입에 위치 / 토큰이 만료되었거나 유효하지 않은 경우 예외 발생, 예외 응답 반환

2️⃣ JwtAuthenticationFilter

요청 헤더에 토큰이 존재하는 지 검사 / 토큰에서 username 추출

3️⃣ JwtUsernamePasswordAuthenticationFilter

약속된 login url 요청 절차 수행

• 요청이 JwtUsernamePasswordAuthenticationFilter.attemptAuthentication()로 전달됨.
• LoginDTO.of(request)를 통해 요청의 username, password를 꺼냄.
• 이 정보로 UsernamePasswordAuthenticationToken을 생성하여 AuthenticationManager에게 전달 → 로그인 인증 시도.
• 인증 성공 → LoginSuccessHandler 동작
• 인증 실패 → LoginFailureHandler 동작

@Override
    public Authentication attemptAuthentication(HttpServletRequest request, HttpServletResponse response)
            throws AuthenticationException {

        // 요청 BODY의 JSON에서 username, password  LoginDTO
        LoginDTO login = LoginDTO.of(request);

        // 인증 토큰(UsernamePasswordAuthenticationToken) 구성
        UsernamePasswordAuthenticationToken authenticationToken =
                new UsernamePasswordAuthenticationToken(login.getUsername(), login.getPassword());

        // AuthenticationManager에게 인증 요청
        return getAuthenticationManager().authenticate(authenticationToken);
    }

4️⃣-1) LoginSuccessHandler

public class LoginSuccessHandler implements AuthenticationSuccessHandler {
    private final JwtProcessor jwtProcessor;

    private AuthResultDTO makeAuthResult(CustomUser user) {
        String username = user.getUsername();
        // 토큰 생성
        String token = jwtProcessor.generateToken(username);
        // 토큰 + 사용자 기본 정보 (사용자명, ...)를 묶어서 AuthResultDTO 구성
        return new AuthResultDTO(token, UserInfoDTO.of(user.getMember()));
    }

    @Override
    public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response,
                                        Authentication authentication) throws IOException, ServletException {
        // 인증 결과 Principal
        CustomUser user = (CustomUser) authentication.getPrincipal();

        // 인증 성공 결과를 JSON으로 직접 응답
        AuthResultDTO result = makeAuthResult(user);
        JsonResponse.send(response, result);
    }

}

public static <T> void send(HttpServletResponse response, T result) throws IOException {
        ObjectMapper om = new ObjectMapper();
        response.setContentType("application/json;charset=UTF-8");
        Writer out = response.getWriter();
        out.write(om.writeValueAsString(result));
        out.flush();
    }

4️⃣-2) LoginFailureHandler

@Override
    public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response,
                                        AuthenticationException exception) throws IOException, ServletException {

        JsonResponse.sendError(response, HttpStatus.UNAUTHORIZED, "사용자 ID 또는 비밀번호가 일치하지 않습니다.");
    }

public static void sendError(HttpServletResponse response, HttpStatus status, String message) throws IOException {
        response.setStatus(status.value());
        response.setContentType("application/json;charset=UTF-8");
        Writer out = response.getWriter();
        out.write(message);
        out.flush();
    }

Spring Security

[등장 배경]

1. 보안 요구 증가

    웹 애플리케이션이 점점 복잡해지고 민감한 정보를 다루게 되면서, 인증 인가에 대한 처리 필요

2. 보안을 직접 구현하기에는 에러 발생 가능성 증가 & 유지보수 어려움 등 문제 다수

3. Spring에 통합되어 동작하면서도 보안 기능을 일관되게 제공할 수 있는 프레임워크 필요

• 필터(Filter) 기반으로 동작하기 때문에 스프링 MVC와 분리되어 관리 및 동작
• 필터(Filter) 는 Dispatcher Servlet으로 가기 전 적용 => 가장 먼저 url 요청을 받음

Spring Security 인증 파트

1. Http Request

• 사용자가 로그인 폼에서 ID/PW 입력 → 서버로 전송

2. AuthenticationFilter (ex: UsernamePasswordAuthenticationFilter)

• 로그인 요청을 감지해, 사용자의 ID/PW로 UsernamePasswordAuthenticationToken 객체 생성

3. AuthenticationManager

• 인증을 시도하는 핵심 인터페이스
• 기본 구현체: ProviderManager

4. AuthenticationProvider

• 실제 인증 로직을 수행하는 인터페이스
• 주로 DaoAuthenticationProvider가 사용됨

5. UserDetailsService

• AuthenticationProvider가 이 인터페이스를 통해 사용자 정보를 불러옴
• 백엔드 개발자가 직접 구현하는 인터페이스 (loadUserByUsername())

6. UserDetails

• 유저 정보를 담는 객체 인터페이스
• 직접 구현한 User 객체가 이를 implements 함

User 와 Member 차이?
스프링에서 제공하는 User & 프로젝트에서 개발자가 직접 만드는 회원 VO( ex : Member)의 차이점이 궁금하다

User : Spring Security 내부 인증/인가용, 로그인 시 UserDetails로 사용됨
Member : DB에 저장되는 사용자 데이터, 회원가입, 조회, 수정 등 도메인 역할

UserDetailsService에서 Member를 조회해서 User로 바꿔주는 역할을 함

public class CustomUserDetailsService implements UserDetailsService {
    private final UserDetailsMapper mapper;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        //mapper를 통해 Member 조회
        MemberVO vo = mapper.get(username);
        
        if (vo == null) {
            throw new UsernameNotFoundException(username + "은 없는 id입니다.");
        }
        
        //Member vo로 UserDetails return
        //업캐스팅(부모 : UserDetails, 자식 : User)
        return new CustomUser(vo);
    }
}​

7. UserDetailsService → UserDetails 반환

• DB 등에서 사용자 조회 후 UserDetails 구현체 반환

8. AuthenticationProvider 인증 수행

• UserDetails를 바탕으로 패스워드 검사 → 인증 성공 여부 판단

9. AuthenticationManager → Authentication 반환

• 인증 성공 시, 인증 정보를 담은 Authentication 객체 반환

10. SecurityContextHolder 저장

• 최종적으로 인증 정보를 SecurityContextHolder에 저장→ 이후 인증된 사용자 정보는 여기서 꺼내 씀

JWT(Json Web Token)

• JSON 포맷을 이용하여 사용자에 대한 속성을 저장하는 Claim 기반의 Web 토큰
• Header.Payload.Signature 세 가지로 구성 / 각 부분은 Base64로 인코딩, .으로 구분

Access Token

: 인증된 사용자가 특정 리소스에 접근할 때 사용되는 토큰

Refresh Token 

: Access Token의 갱신을 위해 사용되는 토큰

최소 공통 조상(LCA: Lowest Common Ancestor)

트리 상의 두 노드 a,b가 있을 때, 두 노드의 가장 가까운 공통 조상 노드 => 최소 공통 조상

풀이 방법

1. 모든 노드의 부모, 깊이 기록(DFS 또는 BFS)

// DFS로 부모와 깊이 채우기
    static void dfs(int current, int d) {
        visited[current] = true;
        depth[current] = d;

        for (int next : tree[current]) {
            if (!visited[next]) {
                parent[next] = current;
                dfs(next, d + 1);
            }
        }
    }
    
    dfs(1,0); //시작 노드 1, 깊이 0

2. 두 노드를 같은 깊이로 맞춤

while (depth[a] > depth[b])   a = parent[a];
while (depth[b] > depth[a])   b = parent[b];

3. 위로 올라가면서 공통 조상 찾기

static int lca(int a, int b) {
        // 깊이를 같게 맞춤
        while (depth[a] > depth[b]) a = parent[a];
        while (depth[b] > depth[a]) b = parent[b];

        // 공통 조상 만날 때까지 위로 이동
        while (a != b) {
            a = parent[a];
            b = parent[b];
        }

        return a;
    }

전체 코드

import java.io.*;
import java.util.*;

public class Main {
    static int N, M;
    static List<Integer>[] tree;
    static int[] parent;
    static int[] depth;
    static boolean[] visited;

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        N = Integer.parseInt(br.readLine());

        tree = new ArrayList[N + 1];
        for (int i = 1; i <= N; i++) tree[i] = new ArrayList<>();

        // 간선 입력 받기
        for (int i = 0; i < N - 1; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int a = Integer.parseInt(st.nextToken());
            int b = Integer.parseInt(st.nextToken());
            tree[a].add(b);
            tree[b].add(a);
        }

        parent = new int[N + 1];
        depth = new int[N + 1];
        visited = new boolean[N + 1];

        // 루트는 1번 노드
        dfs(1, 0);

        M = Integer.parseInt(br.readLine());
        StringBuilder sb = new StringBuilder();

        // 쿼리 처리
        for (int i = 0; i < M; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int u = Integer.parseInt(st.nextToken());
            int v = Integer.parseInt(st.nextToken());
            sb.append(lca(u, v)).append("\n");
        }

        System.out.print(sb);
    }

    // DFS로 부모와 깊이 채우기
    static void dfs(int current, int d) {
        visited[current] = true;
        depth[current] = d;

        for (int next : tree[current]) {
            if (!visited[next]) {
                parent[next] = current;
                dfs(next, d + 1);
            }
        }
    }

    // LCA 찾기
    static int lca(int a, int b) {
        // 깊이를 같게 맞춤
        while (depth[a] > depth[b]) a = parent[a];
        while (depth[b] > depth[a]) b = parent[b];

        // 공통 조상 만날 때까지 위로 이동
        while (a != b) {
            a = parent[a];
            b = parent[b];
        }

        return a;
    }
}

RDBMS

관계형 데이터베이스 관리 시스템

모든 데이터를 2차원의 열과 행(테이블)의 형태로 표현

• 수직 확장 중심(Scale-up)
• 정형 데이터, 복잡한 관계형 모델

장점

✔ 정해진 스키마에 따라 명확한 데이터 구조 보장

✔ 각 데이터를 중복 없이 저장 -> 데이터 무결성 보장

NoSQL(Not Only SQL)

비관계형 데이터베이스

RDBMS가 갖고 있는 특성뿐만 아니라 다른 특성들도 부가적으로 지원

• 수평 확장 중심(Scale-out)
• 비정형 데이터, 빠른 읽기/쓰기, 유연한 구조

장점

✔ 스키마 X, 유연성 -> 언제든 데이터 조정과 새로운 필드 추가 가능

정리

RDBMS는 정형화된 데이터와 관계 중심의 모델에 강하고,
NoSQL은 유연한 구조와 대용량 처리에 최적화된 비관계형 DB

RDBMS 적합 예시

🔹 일반적인 웹 서비스 (쇼핑몰, 블로그, 예약 시스템 등)

• RDBMS 사용 (예: MySQL, PostgreSQL)
• 이유:
  • 고객 ↔ 주문 ↔ 상품 등 명확한 관계가 존재
  • 정확성, 무결성, 트랜잭션이 중요
  • JPA 같은 ORM과 잘 연동

NoSQL 적합 예시

🔹 실시간 채팅, 메신저, 알림 서비스

• NoSQL 사용 (예: MongoDB)
• 이유:
  • 메시지 형식이 다양하고 유연
  • 빠른 쓰기/읽기가 중요
  • RDBMS로 처리 시 JOIN이 많아 느려질 수 있음

문제 탐색

• 좌측 상단 칸에 위치한 말이 알파벳 보드를
• 상하좌우로 이동하면서
• 최대한 몇 칸을 지날 수 있는지 출력 => 칸을 지날때마다 거리 체크
• 새로 이동한 칸의 알파벳은 지나온 모든 칸의 알파벳과 겹치면 안된다 => 알파벳 방문 처리

1. 

public class Main {
    static int r, c, maxLen = 0;  //세로 길이 r, 가로 길이 c, 최대 칸 maxLen
    static char[][] arr;          //알파벳 보드 입력
    static boolean[] visited = new boolean[26];  // 알파벳 A~Z 방문 여부
    static int[] dx = {0, 0, 1, -1};
    static int[] dy = {1, -1, 0, 0};

2.

public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st = new StringTokenizer(br.readLine());
        r = Integer.parseInt(st.nextToken());
        c = Integer.parseInt(st.nextToken());
        arr = new char[r][c];

        for (int i = 0; i < r; i++) {           //알파벳 보드 입력
            String[] s = br.readLine().split("");
            for (int j = 0; j < c; j++) {
                arr[i][j] = s[j].charAt(0);
            }
        }
        dfs(0,0,1);  //말이 위치한다고 했던 가장 왼쪽 0,0 부터 dfs 순회 시작
        System.out.println(maxLen);
    }

public static void dfs(int i, int j, int depth) {
        int alpaIdx = arr[i][j] - 'A';   //알파벳을 인덱스로 방문 관리
        visited[alpaIdx] = true;         //방문처리
        maxLen = Math.max(maxLen, depth);//가장 긴 탐색 칸 수 저장

        for (int k = 0; k < 4; k++) {
            int nx = i + dx[k];
            int ny = j + dy[k];

            if(nx>=0 && nx<r && ny>=0 && ny<c) {  //나아갈 칸이 보드 규격에 속하는지
                int nextAlpaIdx = arr[nx][ny] - 'A';
                if(!visited[nextAlpaIdx]) {       //나아갈 칸의 알파벳이 아직 방문전인지
                    dfs(nx, ny, depth+1);         //칸 전진
                    visited[nextAlpaIdx] = false; //dfs 재귀가 종료되면 방문 반환
                }
            }
        }
    }

백트래킹

깊이 우선 탐색, 더 이상 나아갈 수 없는 상황에서 그 이전 단계로 복귀하는 과정

완전탐색 추천 문제집

https://www.acmicpc.net/workbook/view/2052

SOLID 원칙

좋은 객체 지향 설계를 위한 방법론 SOLID

S - 단일 책임 원칙 (Single Responsibility Principle, SRP)

📌 정의

• 하나의 클래스는 오직 하나의 책임만 가져야 한다.
• 한 클래스에 여러 책임(기능)을 넣으면 변경 이유가 많아지고, 유지보수가 어려워진다.

❌ 잘못된 예

class Report {
    void generateReport() { /* 보고서 생성 */ }
    void printReport() { /* 보고서 출력 */ }  // 출력 책임이 추가됨 ❌
}

✅ 개선

class ReportGenerator {
    void generateReport() { /* 보고서 생성 */ }
}

class ReportPrinter {
    void printReport() { /* 보고서 출력 */ }
}

 O - 개방-폐쇄 원칙 (Open/Closed Principle, OCP)

📌 정의

• 클래스 확장에는 열려있고, 변경에는 닫혀있다.
• 기존 코드를 변경하지 않고, 기능을 확장할 수 있어야 한다.

❌ 잘못된 예

class DiscountService {
    int getDiscount(String grade) {
        if (grade.equals("VIP")) return 20;
        else return 10;
    }
}

✅ 개선

interface DiscountPolicy {
    int getDiscount();
}

class VIPDiscount implements DiscountPolicy {
    public int getDiscount() { return 20; }
}

//기존 코드 변경없이 새로운 기능 추가 가능
class BasicDiscount implements DiscountPolicy {
    public int getDiscount() { return 10; }
}

class DiscountService {
    public int applyDiscount(DiscountPolicy policy) {
        return policy.getDiscount();
    }
}

L - 리스코프 치환 원칙 (Liskov Substitution Principle, LSP)

📌 정의

• 자식 클래스는 언제나 부모 클래스를 대체할 수 있어야 한다.
• 부모의 동작을 자식이 깨지 않고 유지해야 한다.

❌ 잘못된 예

class Bird {
    void fly() {}
}

class Ostrich extends Bird {
    void fly() { throw new UnsupportedOperationException(); }  // 날 수 없음 ❌
}

✅ 개선

interface Flyable {
    void fly();
}

class Sparrow implements Flyable {
    public void fly() { /* 날기 */ }
}

class Ostrich {
    void walk() { /* 걷기 */ }
}

I - 인터페이스 분리 원칙 (Interface Segregation Principle, ISP)

📌 정의

• 하나의 큰 인터페이스보다는 여러 개의 작은 인터페이스가 좋다.
• 역할을 분리하여 유연한 설계 지향

❌ 잘못된 예

interface Worker {
    void work();
    void eat();
}

class Robot implements Worker {
    public void work() {}
    public void eat() {}  // 필요없는 기능 강제 구현은 좋지않다 ❌
}

✅ 개선

interface Workable {
    void work();
}

interface Eatable {
    void eat();
}

class Robot implements Workable {
    public void work() {}
}

D - 의존 역전 원칙 (Dependency Inversion Principle, DIP)

📌 정의

• 구체적인 클래스 구현체에 의존하지 않고, 공통된 추상화(인터페이스)에 의존

❌ 잘못된 예

class MySQLDatabase {
    void save() {}
}

class OrderService {
    MySQLDatabase db = new MySQLDatabase();
    void placeOrder() {
        db.save();
    }
}

✅ 개선

interface Database {
    void save();
}

class MySQLDatabase implements Database {
    public void save() {}
}

class OrderService {
    Database db;
    OrderService(Database db) {  //OrderService는 인터페이스인 Database에 의존
        this.db = db;            //db를 다른 걸로 바꿔도 OrderService에는 수정x
    }
    void placeOrder() {
        db.save();
    }
}

제어의 역전(IoC)

📌 개념

• 일반적으로 객체는 스스로 필요한 의존 객체를 생성하거나 찾아서 사용
• IoC는 이 흐름을 "역전 "시켜서, 객체가 직접 의존 대상을 만들지 않고 외부에서 주입받도록 하는 개념

🎯 핵심 의미

"객체가 제어권을 갖는 게 아니라, 제어권을 외부(프레임워크나 컨테이너)에 넘긴다"

❌ IoC 적용 전: 직접 생성

class OrderService {
    private final PaymentService paymentService = new PaymentService(); // 직접 생성
}

✅ IoC 적용 후: 외부에서 주입

class OrderService {
    private final PaymentService paymentService;

    public OrderService(PaymentService paymentService) {  // 생성자 주입
        this.paymentService = paymentService;
    }
}

의존성 주입(DI)

📌 개념

• IoC를 구현하는 구체적인 방법으로, 객체가 필요한 의존 객체를 외부에서 전달받는 방식

💡 DI 3가지 방법

✅ 생성자 주입 예 (스프링 방식)

* @Autowired는 Spring 4.3 이후 생성자 1개면 생략 가능

@Service
public class OrderService {
    private final PaymentService paymentService;

    @Autowired
    public OrderService(PaymentService paymentService) {  //생성자 주입
        this.paymentService = paymentService;
    }
}

✅ 세터 주입 예 (스프링 방식)

@Service
public class OrderService {

    private PaymentService paymentService;

    @Autowired
    public void setPaymentService(PaymentService paymentService) {  //세터주입
        this.paymentService = paymentService;
    }
}

✅ 필드 주입 예 (스프링 방식)

@Service
public class OrderService {

    @Autowired
    private PaymentService paymentService;  //필드 주입

}