정보보호 서약에 따라 자세한 내용이나 문제가 될 수 있는 사항은 언급할 수 없는 점 양해 부탁드립니다.

내 인생 처음으로 회사에 지원했고, 생각지도 못하게 서류와 코딩테스트를 통과했다. 최선을 다해 2주 동안 1차 면접을 준비했고, 그 과정에서 어떤 성장이 있었는지를 담아보려고 한다. 나는 팀네이버의 Tech-Backend Developer 신입 직군에 지원했다. 아직 6학기가 남아 있었지만, 특이하게 해당 공고는 졸업을 하지 않은 경우에도 일정 조율을 통해 졸업 후 업무를 시작할 수 있어 지원할 수 있었다.

💻 시작은, 서류

처음 지원서를 보고 가장 놀랐던 점은 내 생각보다 써야 할 글자 수가 적었다는 것이다. 다양한 개발 동아리 지원서를 작성하면서 꽤 고생했던 나는(글자 수 제한이 없어 최대한 많이 써야 했던 곳도 있었다) 이번엔 제한된 글자 수 안에서 나를 최대한 표현해야 한다는 점이 가장 어려웠다. 먼저 팀네이버에는 어떤 계열사가 있는지, 그들이 원하는 인재상은 무엇인지 조사했다. 인터넷에서 찾을 수 있는 모든 팀네이버 Tech 면접 후기를 찾아보고, 각 회사의 공식 홈페이지, 유튜브 영상, 기술 블로그 등을 살펴보았다. 팀네이버는 네이버, 네이버 클라우드, 스노우, 네이버 파이낸셜을 포함하는 지칭이다. 그중 가장 인상 깊었던 신입 공채 영상 속 말은 다음과 같았다.

팀네이버는 기술에 대한 애정을 가지고 매 순간 도전하는 곳. 기술에 대한 열정, 호기심, 배움의 즐거움을 가진 사람과 함께 성장하고 싶다.

이 메시지를 보여주기 위해 노력했다. 또한, 지원서 질문 전반에 ‘도전’이라는 단어가 반복적으로 등장해, 내가 개발을 공부하며 겪었던 도전적인 경험을 중심으로 글을 작성했다. 구체적으로는 [정답이 아니라 최적의 답을 찾는 개발자]처럼 각 질문마다 소제목을 달아 두괄식으로 작성했다. 면접 스터디에서 다른 지원자들의 지원서를 보니 대부분 이런 식으로 두괄식으로 작성한 것을 확인할 수 있었다. 한 질문 안에 여러 소제목을 넣은 분도 있었고, 나처럼 질문 하나에 하나의 소제목을 넣은 분도 있었다.

서류에서는 자기소개서뿐만 아니라 포트폴리오도 제출해야 했는데, 이때 제출했던 포트폴리오를 면접 준비하면서 많이 후회했다. 나는 무작정 내가 많이 했다는 걸 보여주는 게 중요하다고 생각해 모든 프로젝트와 이력들을 다 넣었다. 그중에는 개발을 처음 시작할 때 했던 프로젝트나 깃허브도 있었고, 개발과는 무관한 수상 내역도 있었다. 이 부분은 ‘면접’ 파트에서 더 자세히 이야기하겠지만, 많은 이력이 서류 합격에는 도움이 됐을지 몰라도 면접 준비 과정에서는 오히려 힘들었다. 다른 분들의 포트폴리오를 보면, 내가 프로젝트를 가장 많이 넣은 축에 속했다. 이때 배운 점은, 자신 있는 프로젝트 2~3개만 넣어도 충분하고, 각각의 프로젝트에 대해 내용 요약, 서버 아키텍처, 본인이 맡은 부분, 어려웠던 점을 깔끔하게 정리하는 것이 중요하다는 것이다.

이런 포트폴리오의 장점은 크게 두 가지다:

1. 내가 의도한 방향으로 질문을 유도할 수 있다.
2. 면접관이 프로젝트를 쉽게 이해할 수 있고, 내가 자신 있는 부분만 강조할 수 있다.

따라서 꼭 포트폴리오는 깔끔하게 정리하길 추천한다. 또한, 자기소개서의 모든 문장을 의미 없는 형용사로 채우지 말고, 모든 문장에 질문 거리를 남긴다는 마음으로 의미를 담아 퇴고하는 것이 중요하다.

🧩 그리고, 코딩테스트

팀네이버는 특이하게 서류와 코딩테스트 결과를 함께 평가해 1차 합격 여부를 결정한다. 즉, 모두가 코테를 봐야 했다. 나는 코딩테스트 준비를 거의 해본 적 없었고, 졸업을 위한 약간의 알고리즘 수업이 전부였다. 그래서 서류 제출과 동시에 급히 코테 공부를 시작했다. 프로그래머스를 통해 시작했고, 처음에는 level 1 문제들을 풀며 문법에 익숙해지려고 했다. 이후 ‘알고리즘 고득점 Kit’를 풀었는데 이게 꽤 도움이 됐다. 출제 빈도 순으로 ‘해시’, ‘완전탐색’, ‘힙’, ‘스택/큐’를 집중적으로 공부했다. 특히 빡구현 위주의 문제가 많다는 이야기를 듣고, 끝까지 혼자 구현하는 데 집중하며 연습했다.

코테는 총 3문제였고, 한 문제만 풀어도 합격할 수 있다는 말이 있어서 목표는 1문제 해결이었다. 1번을 풀다가 어려워서 2번부터 풀었고, 생각보다 수월하게 풀려서 결국 1번도 풀고 3번도 살짝 손댈 수 있었다. 여기서 팁은, 부분 점수가 있기 때문에 문제를 완전히 해결하지 못하더라도 해당 조건까지는 구현하는 것이 좋다는 점이다. 체감상 2.5문제 정도를 해결했다고 느꼈다. 하지만 코테 준비한 지 일주일도 안 된 내가 붙을 리 없다고 생각해, 이후 네이버에 지원한 사실조차 잊고 있었다.

이후 조직 적합도 검사도 있었는데, 특별한 준비 없이 MBTI 검사와 유사한 느낌이었다. 솔직하게 답하면 괜찮을 것 같다!

🎤 내가 1차 면접을?!

그러다 정말로 1차 면접에 붙었다는 소식을 받게 되었다.

생각지도 못한 선물을 받은 기분이라 정말 행복했다. 하지만 면접은 중간고사 기간 한가운데였고, 첫 면접 준비라 정말 준비할 게 산더미였다. 오픈채팅방과 학교 커뮤니티에서 면접 스터디를 구해 함께 준비했다.

기술역량 면접이기 때문에 CS, 수리/논리 문제, 손코딩, 자기소개서 기반 질문, 1분 자기소개 등 다양한 질문이 나올 수 있다고 해서 전부를 준비했다. 가장 도움이 되었던 책은

• 『개발자 기술 면접 노트』
• 『이것이 취업을 위한 컴퓨터 과학이다 with CS 기술 면접』 두 권이었다. 직접적으로 면접 문제와 일치하진 않았지만, 전반적인 CS 이해도와 답변 고도화에 큰 도움이 되었다.

스터디를 통해 내 자소서를 객관적으로 검토하고, 예상치 못한 질문에 대응하는 연습을 했다. 노션에 예상 질문을 토글로 정리하고 답변 → 꼬리질문 → 다시 답변을 반복하며 준비했다. 중간에 PDF로 뽑아봤는데 무려 244페이지였다...

여기서 아쉬운 점은 마지막에 더 압축해서 여러 번 회독했어야 했다는 것이다. 내용이 너무 많아 머릿속 정리가 잘 안 됐고, 중간고사 2개와 졸업 프로젝트 발표까지 겹쳐 면접 직전 일주일은 거의 준비를 못해 공부한 내용을 많이 잊었다. 이 부분이 가장 아쉽다.

면접 준비를 하면서 가장 심적으로 힘들었던 부분은, 내가 잘 준비하고 있는지 모르겠고 공부를 할수록 내가 너무 부족해보인다는 것이었다. 면접을 처음 준비해보기도 하고, 면접에서 구체적으로 어떤 게 출제되는지에 대한 내용이 너무나 광범위하고 모호해서 하면서도 내가 공부하는 방향성에 대한 확신이 들지 않았다. 또한, CS 공부를 해가면서 내 프로젝트와 포폴을 다시 보면 너무나 부족해보였다... 그래서 이 부분이 가장 힘들었다. 그러나 지금 생각해보면, 그런 깨달음이야말로 성장의 증거였던 것 같다. 완벽하다고 생각했던 자소서와 포트폴리오가 부족해 보인다는 건, 내가 성장했고 보는 눈이 높아졌다는 뜻이니까.

면접은 정말 예상하지 못한 방향으로 흘러갔다. 내가 예상하지도 못한 것들을 형식에, 내가 준비하지 않은 것들을 잔뜩 물어보셔서 특히 두번째 세션을 진행하면서 '아 떨어지겠다'라는 생각이 머리에 가득찼다. 면접은 자신감이 있어야 되는데, 이 자신감이 있으려면 내가 뱉은 말들, 내가 한 것들에 대해 확실히 알고 있어야 한다는 걸 뼈저리게 느꼈다. 면접관분들은 너무나 친절하시고, 마지막에 내 포트폴리오에 대한 피드백을 들을 수 있어서 정말 유익했던 시간이었다.

면접 직후 바로 작성한 노트.

아쉽게도 1차 면접은 떨어졌지만, 그 어떤 2주보다 많은 것을 배웠고 앞으로 어떤 방향으로 개발 공부를 해야 할지 알 수 있었다. 무엇보다 소중했던 건, 내가 백엔드 개발자가 되고 싶다는 확신을 갖게 된 것이다. 사실 이전까지는 대학원을 갈지, 백엔드 개발자가 되고 싶은 게 맞는지 고민이 많았다. 지원서 작성할 때까지만 해도 그랬다. 그런데 이번 면접 준비를 통해 알게 된 건, 내가 개발을 꽤 좋아한다는 사실이었다. 공부 방법을 몰라 헤맸던 것이다. 리팩토링을 해서 성능 개선을 하면 재밌고, 내가 만든 서비스가 실제로 쓰일 걸 생각하면 설렌다.

앞으로는 기존 프로젝트를 리팩토링하고, 오픈소스에도 기여해보며 다음 면접을 준비하고 싶다. 그럼 팀네이버 지원 회고 끝!

1. 스프링 시큐리티를 활용한 간단한 로그인 및 회원가입 기능 구현하기
2. 카카오톡 소셜 로그인 구현하기

📑 10주차 주제:

이번 주차에서는 스프링 부트를 이용하여 로그인 및 회원가입 기능을 직접 구현합니다. 또한 카카오톡 소셜 로그인을 추가하여 OAuth2를 활용한 인증 기능도 학습합니다.

스프링 시큐리티(Spring Security)는 인증(Authentication)과 인가(Authorization)을 효과적으로 처리할 수 있는 프레임워크로, 간단한 설정으로 보안 기능을 제공하며 복잡한 보안 로직도 손쉽게 확장할 수 있습니다.

0. 들어가기 전

Spring Security 의존성 추가

로그인 및 회원가입 기능 구현을 위해 기본적으로 Spring Security를 설정해야 합니다. 아래와 같이 build.gradle에 의존성을 추가합니다:

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-security'
    testImplementation 'org.springframework.security:spring-security-test'
}

의존성을 추가하면 Spring Security는 기본적으로 자동 설정(Auto-Configuration)을 통해 프로젝트에 기본 보안 기능을 적용합니다.

애플리케이션 실행 시 기본 계정과 비밀번호가 자동으로 생성되며, 이를 이용해 제공된 계정으로 로그인할 수 있습니다. 하지만 실제 애플리케이션에서는 사용자 정의 계정과 권한 설정이 필요합니다.

1. Spring Security 개요 및 주요 흐름

1️⃣ Spring Security란?

Spring Security는 Spring 기반 애플리케이션에서 보안을 담당하는 프레임워크로, 다음과 같은 주요 기능을 제공합니다:

1. 인증(Authentication): 사용자의 신원을 확인하는 과정
2. 인가(Authorization): 사용자의 리소스 접근 권한을 검증하는 과정
3. 보안 위협 방어: CSRF, XSS, 세션 고정 공격 등 다양한 보안 위협에 대한 방어

2️⃣ Spring Security의 주요 컴포넌트

AuthenticationManager

• 사용자의 자격 증명을 관리하며, 인증 로직을 처리하는 중심 컴포넌트입니다.

AuthenticationProvider

• 실제 인증 로직을 수행하며, 다양한 인증 방식을 지원합니다.

UserDetailsService

• 사용자 정보를 데이터베이스나 저장소에서 불러와 인증 과정을 지원합니다.

SecurityContext

• 인증된 사용자 정보를 저장하며, 애플리케이션 전반에서 공유됩니다.

3️⃣ Spring Security의 인증과 인가 흐름

[인증(Authentication) 흐름]

인증은 사용자의 신원을 확인하는 과정입니다. Spring Security에서의 인증 흐름은 다음과 같습니다:

1. 사용자 로그인 요청

   • 사용자가 로그인 폼에 credentials(예: 이메일, 비밀번호)을 입력하고 제출합니다.

2. AuthenticationFilter

   • UsernamePasswordAuthenticationFilter가 요청을 가로채고 Authentication 객체를 생성합니다.

3. AuthenticationManager

   • AuthenticationManager는 적절한 AuthenticationProvider를 선택하여 인증을 위임합니다.

4. AuthenticationProvider

   • 선택된 AuthenticationProvider는 UserDetailsService를 사용하여 사용자 정보를 로드하고 비밀번호를 검증합니다.

5. UserDetailsService

   • 데이터베이스나 저장소에서 사용자 정보를 조회합니다.

6. SecurityContext

   • 인증이 성공하면, Authentication 객체가 SecurityContext에 저장됩니다.

[인가(Authorization) 흐름]

인가는 인증된 사용자가 특정 리소스에 접근할 권한이 있는지 확인하는 과정입니다:

1. 리소스 접근 요청

   • 인증된 사용자가 보호된 리소스에 접근을 시도합니다.

2. FilterSecurityInterceptor

   • FilterSecurityInterceptor가 요청을 가로채고 권한 검사를 시작합니다.

3. AccessDecisionManager

   • AccessDecisionManager는 현재 사용자의 권한과 요청된 리소스의 필요 권한을 비교합니다.

4. 권한 확인

   • SecurityContext에서 현재 인증된 사용자의 권한 정보를 조회합니다.

5. 접근 결정

   • 사용자의 권한이 충분하면 리소스 접근이 허용됩니다.
   • 권한이 부족하면 AccessDeniedException이 발생하고 접근이 거부됩니다.

2. 로그인 및 회원가입 구현

0️⃣ 들어가기 전

이번 실습은 9주차까지 진행한 프로젝트를 그대로 이어서 진행합니다. 또한 Thymeleaf라는 템플릿 엔진을 이용해 결과를 화면에 출력할 예정입니다.

Thymeleaf란?

Thymeleaf는 Spring Boot에서 HTML을 렌더링하기 위한 템플릿 엔진으로, 백엔드 개발자가 뷰(View)를 구성하는 데 유용한 도구입니다.

실제 협업 시 사용 방식

실제 프로젝트에서는 프론트엔드 개발자와 REST API를 통해 데이터를 주고받는 방식으로 구현합니다. 그러나 이번 실습에서는 백엔드 로직에 집중하기 위해 Thymeleaf로 간단한 HTML 페이지를 만들어 결과를 확인하는 방식을 사용합니다.

1️⃣ Thymeleaf 의존성 추가하기

build.gradle 파일에 다음 내용을 추가하여 Thymeleaf 의존성을 추가합니다:

implementation 'org.springframework.boot:spring-boot-starter-thymeleaf'

2️⃣ HTML 파일 추가하기

실습에 필요한 HTML 파일을 추가합니다. src/main/resources/templates 폴더를 생성하고 필요한 HTML 파일을 추가해주세요. => admin.html, home.html, login.html, signup.html

3️⃣ View Controller 추가하기

src/main/java/web/controller 패키지에 MemberViewController 클래스를 생성하고 다음 코드를 작성합니다:

@Controller
public class MemberViewController {

    @GetMapping("/login")
    public String loginPage() {
        return "login";
    }

    @GetMapping("/signup")
    public String signupPage(Model model) {
        model.addAttribute("memberJoinDto", new MemberRequestDTO.JoinDto());
        return "signup";
    }

    @GetMapping("/home")
    public String home() {
        return "home";
    }

    @GetMapping("/admin")
    public String admin() {
        return "admin";
    }
}

Controller 역할

1. /login → login.html 반환
2. /signup → signup.html 반환, 회원가입 폼에 필요한 빈 DTO 객체 추가
3. /home → home.html 반환
4. /admin → admin.html 반환

1. Spring Security 설정 및 구현

1️⃣ Security 의존성 추가하기

build.gradle 파일에 다음 의존성을 추가하여 Spring Security를 활성화합니다:

implementation 'org.springframework.boot:spring-boot-starter-security'
testImplementation 'org.springframework.security:spring-security-test'
implementation 'org.thymeleaf.extras:thymeleaf-extras-springsecurity6:3.1.1.RELEASE'

2️⃣ Security 설정하기

src/main/java/umc/study/config/security 디렉토리에 SecurityConfig 클래스를 생성하고 아래와 같이 작성합니다:

@EnableWebSecurity
@Configuration
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests((requests) -> requests
                .requestMatchers("/", "/home", "/signup", "/members/signup", "/css/**").permitAll()
                .requestMatchers("/admin/**").hasRole("ADMIN")
                .anyRequest().authenticated()
            )
            .formLogin((form) -> form
                .loginPage("/login")
                .defaultSuccessUrl("/home", true)
                .permitAll()
            )
            .logout((logout) -> logout
                .logoutUrl("/logout")
                .logoutSuccessUrl("/login?logout")
                .permitAll()
            );

        return http.build();
    }

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }
}

3️⃣ 회원가입에 보안 추가하기

Role 열거형 추가

Role 열거형을 생성하여 사용자 역할을 정의합니다:

public enum Role {
    ADMIN, USER
}

Member 엔티티 수정

Member 엔티티에 보안 관련 필드와 비밀번호 설정 메서드를 추가합니다:

@Entity
public class Member extends BaseEntity {
    @Column(nullable = false, unique = true)
    private String email;

    @Column(nullable = false)
    private String password;

    @Enumerated(EnumType.STRING)
    private Role role;

    public void encodePassword(String password) {
        this.password = password;
    }
}

DTO와 Converter 수정

1. MemberRequestDTO.JoinDto 수정:

   public class MemberRequestDTO {
       public static class JoinDto {
           @NotBlank
           private String name;
           @NotBlank
           @Email
           private String email;
           @NotBlank
           private String password;
           @NotNull
           private Role role;
       }
   }

2. MemberConverter 수정:

   public class MemberConverter {
       public static Member toMember(MemberRequestDTO.JoinDto request) {
           return Member.builder()
               .name(request.getName())
               .email(request.getEmail())
               .password(request.getPassword())
               .role(request.getRole())
               .build();
       }
   }

Command Service 수정

MemberCommandServiceImpl에 비밀번호 암호화 로직 추가:

@Service
public class MemberCommandServiceImpl implements MemberCommandService {
    private final PasswordEncoder passwordEncoder;

    @Override
    @Transactional
    public Member joinMember(MemberRequestDTO.JoinDto request) {
        Member newMember = MemberConverter.toMember(request);
        newMember.encodePassword(passwordEncoder.encode(request.getPassword()));
        return memberRepository.save(newMember);
    }
}

** 2.회원가입 구현**

로그인 구현

이제 회원가입이 정상적으로 동작하므로, 로그인 기능을 구현해보겠습니다. Spring Security는 기본적으로 로그인 로직을 처리해주지만, 이를 위해 우리는 사용자 정보를 처리하는 CustomUserDetailsService를 만들어야 합니다.

특정 이메일을 사용하는 유저가 DB에 존재하는지 확인하기 위한 함수를 추가해줍니다.

MemberRepository 에 다음 함수를 추가합니다,

public interface MemberRepository extends JpaRepository<Member, Long> {

    // ... 기존 함수 ...

    Optional<Member> findByEmail(String email);
}

src/main/java/umc/study/config/security 위치에 CustomUserDetailsService 클래스를 생성한 후, 아래의 코드를 작성해주시면 됩니다!!

@Service
@RequiredArgsConstructor
public class CustomUserDetailsService implements UserDetailsService {

    private final MemberRepository memberRepository;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {
        Member member = memberRepository.findByEmail(username)
            .orElseThrow(() -> new UsernameNotFoundException("해당 이메일을 가진 유저가 존재하지 않습니다: " + username));

        return org.springframework.security.core.userdetails.User
            .withUsername(member.getEmail())
            .password(member.getPassword())
            .roles(member.getRole().name())
            .build();
    }
}

동작 과정:

1. 사용자가 로그인 폼에서 이메일과 비밀번호를 입력하고 제출합니다.
2. Spring Security가 CustomUserDetailsService의 loadUserByUsername 메소드를 호출합니다.
3. 이 메소드는 입력받은 이메일(username)으로 데이터베이스에서 사용자를 조회합니다.
4. 사용자가 존재하면 Spring Security의 User 객체로 변환하여 반환합니다.
5. Spring Security는 반환된 User 객체의 정보를 사용하여 인증을 수행합니다.

🔐 보안 강화 팁 🔐 실제 애플리케이션에서는 로그인 시도 횟수 제한, 2단계 인증 등의 추가적인 보안 기능을 구현하는 것이 좋습니다.

회원가입 로직

MemberCommandService에서 비밀번호를 암호화하여 저장합니다:

@Service
@RequiredArgsConstructor
public class MemberCommandService {
    private final MemberRepository memberRepository;
    private final PasswordEncoder passwordEncoder;

    public void joinMember(MemberRequestDto request) {
        Member member = new Member();
        member.setEmail(request.getEmail());
        member.encodePassword(passwordEncoder.encode(request.getPassword()));
        member.setRole(Role.USER);

        memberRepository.save(member);
    }
}

3.OAuth2를 활용한 카카오 소셜 로그인 구현

OAuth2란 무엇인가요?

OAuth2는 제3자 애플리케이션이 사용자 대신 안전하게 리소스에 접근할 수 있도록 허용하는 인증 프로토콜입니다. 이를 통해 사용자는 비밀번호를 공유하지 않고도 애플리케이션에 접근 권한을 부여할 수 있습니다.

이 프로토콜의 주요 장점은 다음과 같습니다!!!

1. 사용자는 비밀번호를 직접 입력하지 않아도 됩니다.
2. 앱은 사용자의 소셜 계정 정보를 안전하게 받아올 수 있습니다.
3. 사용자는 언제든 앱의 접근 권한을 취소할 수 있습니다.

따라서 소셜 로그인을 구현할 때, OAuth2는 주로 사용자의 소셜 계정 정보를 애플리케이션이 안전하게 받아올 수 있게 해줍니다. 카카오톡, 구글, 페이스북 등의 서비스는 이 OAuth2 프로토콜을 통해 로그인 및 권한 관리를 처리합니다.

1️⃣ OAuth2 설정

build.gradle에 OAuth2 클라이언트 의존성을 추가합니다:

dependencies {
    implementation 'org.springframework.boot:spring-boot-starter-oauth2-client'
}

2️⃣ 카카오톡 개발자 계정 생성 및 애플리케이션 등록

카카오 로그인을 구현하려면 먼저 카카오 개발자 계정을 만들고 애플리케이션을 등록해야 합니다.

따라서 다음 단계를 따라해 주세요

1. 카카오 디벨로퍼스에 접속해 카카오 계정으로 로그인합니다.
2. 상단의 [내 애플리케이션] 탭에서 [애플리케이션 추가하기]를 클릭합니다.
3. 앱 이름을 입력하고 사업자 정보를 기입합니다. (개인 프로젝트라면 개인으로 설정하세요)
4. 애플리케이션을 생성한 후, [플랫폼] 설정으로 이동합니다.
5. [Web 플랫폼 등록] 섹션에서 우리 앱의 도메인을 등록합니다.
   • 이번 실습에서는 로컬에서 테스트하기 때문에 http://localhost:8080을 입력하세요.
6. [카카오 로그인] 설정으로 이동해 카카오 로그인을 활성화하고, Redirect URI를 등록합니다.
   • Redirect URI는 http://localhost:8080/login/oauth2/code/kakao로 설정하세요.

>**Redirect URI란?**
OAuth2 인증이 성공한 후 사용자가 돌아올 주소입니다. 로컬 테스트 시에는 localhost를 사용하지만, 실제 서비스 배포 시에는 여러분의 서비스 도메인으로 변경해야 합니다!

7. [동의항목] 설정에서 필요한 정보 항목을 선택합니다. 이번 실습에서는 닉네임을 필수로 설정해주세요.

application.yml 파일에 카카오 API 정보를 추가합니다:

spring:
  security:
    oauth2:
      client:
        registration:
          kakao:
            client-id: {YOUR_CLIENT_ID}
            client-secret: {YOUR_CLIENT_SECRET}
            redirect-uri: http://localhost:8080/login/oauth2/code/kakao
            authorization-grant-type: authorization_code
            scope: profile_nickname

2️⃣ CustomOAuth2UserService 구현

카카오 로그인 후 사용자 정보를 처리하는 CustomOAuth2UserService를 작성합니다:

@Service
public class CustomOAuth2UserService extends DefaultOAuth2UserService {

    @Override
    public OAuth2User loadUser(OAuth2UserRequest userRequest) throws OAuth2AuthenticationException {
        OAuth2User oAuth2User = super.loadUser(userRequest);

        String email = (String) oAuth2User.getAttributes().get("email");
        String nickname = (String) oAuth2User.getAttributes().get("nickname");

        // 사용자 정보 저장 로직 추가

        return oAuth2User;
    }
}

2. 사용자 정보 저장을 위한 CustomOAuth2UserService 구현

이제 카카오 로그인 후 받은 사용자 정보를 우리 데이터베이스에 저장하는 CustomOAuth2UserService를 만들어볼게요.

src/main/java/umc/study/config/security 폴더에 CustomOAuth2UserService 클래스를 새로 만들고 다음 코드를 작성해주세요:

@Service
@RequiredArgsConstructor
public class CustomOAuth2UserService extends DefaultOAuth2UserService {

    private final MemberRepository memberRepository;
    private final PasswordEncoder passwordEncoder;

    @Override
    public OAuth2User loadUser(OAuth2UserRequest userRequest) throws OAuth2AuthenticationException {
        OAuth2User oAuth2User = super.loadUser(userRequest);

        Map<String, Object> attributes = oAuth2User.getAttributes();
        Map<String, Object> properties = (Map<String, Object>) attributes.get("properties");

        String nickname = (String) properties.get("nickname");
        String email = nickname + "@kakao.com"; // 임시 이메일 생성

        // 사용자 정보 저장 또는 업데이트
        Member member = saveOrUpdateUser(email, nickname);

            // 이메일을 Principal로 사용하기 위해 attributes 수정
        Map<String, Object> modifiedAttributes = new HashMap<>(attributes);
        modifiedAttributes.put("email", email);

        return new DefaultOAuth2User(
            oAuth2User.getAuthorities(),
            modifiedAttributes,
            "email"  // email Principal로 설정
        );
    }

    private Member saveOrUpdateUser(String email, String nickname) {
        Member member = memberRepository.findByEmail(email)
            .orElse(Member.builder()
                .email(email)
                .name(nickname)
                .password(passwordEncoder.encode("OAUTH_USER_" + UUID.randomUUID()))
                .gender(Gender.NONE)  // 기본값 설정
                .address("소셜로그인")  // 기본값 설정
                .specAddress("소셜로그인")  // 기본값 설정
                .role(Role.USER)
                .build());

        return memberRepository.save(member);
    }
}

CustomOAuth2UserService 클래스는 카카오 로그인 후 받은 사용자 정보를 처리하고 데이터베이스에 저장하는 역할을 합니다. 주요 기능을 다음과 같이 설명할 수 있습니다:

1. OAuth2User 정보 로드
   • super.loadUser(userRequest)를 통해 카카오에서 제공하는 사용자 정보를 OAuth2User 객체로 받아옵니다.
   • 이 객체의 attributes에는 사용자의 닉네임 등 기본 정보가 포함되어 있습니다.
2. 사용자 정보 추출
   • 카카오 API에서 제공하는 사용자 정보 중 nickname을 추출합니다.
   • 이메일 정보를 받기 위한 따로 설정하지 않았기 때문에, 닉네임을 이용해 임시 이메일 주소(예: nickname@kakao.com)를 생성합니다.
3. 사용자 정보 저장 및 업데이트
   • saveOrUpdateUser 메소드를 통해 사용자 정보를 데이터베이스에 저장하거나 업데이트합니다.
   • 임시 이메일을 기준으로 기존 사용자를 찾거나 새 사용자를 생성합니다.
   • 카카오에서 제공하지 않는 정보(성별, 주소 등)는 기본값으로 설정합니다.
4. Spring Security용 OAuth2User 반환
   • DefaultOAuth2User 객체를 생성하여 반환합니다.
   • 사용자의 권한, 속성, 그리고 주요 식별자(email)를 설정합니다.
   • 이를 통해 Spring Security가 인증된 사용자를 올바르게 식별하고 처리할 수 있습니다.

주의사항

• 실제 서비스에서는 닉네임 대신 고유한 식별자(예: 이메일, 카카오 고유 ID)를 사용하는 것이 더 안정적입니다.
• 소셜 로그인 후 추가 정보 입력 페이지를 통해 필요한 사용자 정보를 수집하는 것이 좋습니다.

3. Spring Security에 OAuth2 설정 추가

이제 SecurityConfig에 OAuth2 관련 설정을 추가해볼게요.

SecurityConfig 클래스를 열고 다음과 같이 수정해주세요:

@EnableWebSecurity
@Configuration
public class SecurityConfig {

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http
                        // ... 기존 설정 ...
            .oauth2Login(oauth2 -> oauth2
                .loginPage("/login")
                .defaultSuccessUrl("/home", true)
                .permitAll()
            );

        return http.build();
    }

    // 기존 빈 설정...
}

다음으로, 로그인 페이지에서 카카오 소셜 로그인 버튼을 추가하겠습니다.

src/main/resources/templates 폴더에 잇는 기존 login.html 파일을 다음과 같이 변경해주세요.

<!DOCTYPE html>
<html xmlns:th="http://www.thymeleaf.org">
<head>
    <title>Login</title>
</head>
<body>
<!-- 기존 코드 -->

<a th:href="@{/oauth2/authorization/kakao}">카카오로 로그인</a>

</body>
</html>

JWT란?

JWT(Json Web Token)는 JSON 포맷을 사용하여 정보를 안전하게 주고받기 위한 토큰 기반 인증 방식입니다. JWT는 세션을 유지할 필요 없이 인증과 권한 부여를 수행할 수 있는 세션리스(stateless) 인증 메커니즘으로, 클라이언트와 서버 간의 데이터 무결성을 보장합니다.

JWT의 구조

JWT는 세 부분으로 구성된 문자열이며, 각각 .으로 구분됩니다.

1. Header: 토큰 타입과 해싱 알고리즘 정보를 포함합니다.
2. Payload: 실제 데이터(예: 사용자 ID, 권한 등)를 포함합니다.
3. Signature: 토큰의 무결성을 검증하기 위한 서명으로, 비밀 키를 사용해 생성됩니다.

예시:
eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJ1c2VyMSIsInJvbGUiOiJVU0VSIiwiaWF0IjoxNjk2MTM2MDAwfQ.X4Jz5P8EExkEMHiNn9TlF6Wx51QBOUM7LzCW0mEDlqw

JWT가 왜 필요한가?

1. 세션리스 인증

   • JWT는 서버에 상태 정보를 저장하지 않아도 됩니다. 서버 확장성이 좋아지고, 분산 시스템에서 유용합니다.

2. 확장성

   • 서버 간의 상태 동기화가 필요 없으므로, 마이크로서비스 아키텍처에서 유리합니다.

3. 유연한 데이터 포함

   • 토큰에 사용자 정보, 권한, 만료 시간 등의 정보를 포함할 수 있어 추가 요청 없이 인증 및 권한 부여를 처리할 수 있습니다.

4. 보안

   • 서버는 JWT의 서명을 통해 토큰이 변조되지 않았음을 확인할 수 있습니다.

JWT의 동작 흐름

1. 클라이언트 인증 요청:
   • 클라이언트가 서버에 사용자 자격 증명(예: ID, 비밀번호)을 보냅니다.
2. 서버에서 토큰 발급:
   • 서버가 사용자 인증에 성공하면, JWT를 생성하여 클라이언트에 반환합니다.
3. 클라이언트가 JWT 포함 요청:
   • 클라이언트는 이후 요청의 Authorization 헤더에 JWT를 포함하여 서버로 보냅니다.
4. 서버에서 토큰 검증:
   • 서버는 토큰의 서명을 검증하고, 토큰에 포함된 정보를 기반으로 요청을 처리합니다.

JWT 간단 구현 예제

1. 의존성 추가

build.gradle에 JWT 관련 의존성을 추가합니다.

implementation 'io.jsonwebtoken:jjwt-api:0.11.5'
runtimeOnly 'io.jsonwebtoken:jjwt-impl:0.11.5'
runtimeOnly 'io.jsonwebtoken:jjwt-jackson:0.11.5'

2. JWT 생성 및 검증 유틸리티 작성

import io.jsonwebtoken.*;
import io.jsonwebtoken.security.Keys;
import org.springframework.stereotype.Component;

import java.security.Key;
import java.util.Date;

@Component
public class JwtUtil {

    private final Key key = Keys.secretKeyFor(SignatureAlgorithm.HS256);
    private final long validity = 3600000; // 1시간

    // JWT 생성
    public String createToken(String username, String role) {
        return Jwts.builder()
                .setSubject(username)
                .claim("role", role)
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + validity))
                .signWith(key)
                .compact();
    }

    // JWT 검증
    public boolean validateToken(String token) {
        try {
            Jwts.parserBuilder().setSigningKey(key).build().parseClaimsJws(token);
            return true;
        } catch (JwtException | IllegalArgumentException e) {
            return false;
        }
    }

    // JWT에서 사용자 이름 추출
    public String getUsername(String token) {
        return Jwts.parserBuilder()
                .setSigningKey(key)
                .build()
                .parseClaimsJws(token)
                .getBody()
                .getSubject();
    }
}

3. 로그인 API에서 JWT 발급

사용자 인증 후 JWT를 발급합니다.

import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/auth")
public class AuthController {

    private final JwtUtil jwtUtil;

    public AuthController(JwtUtil jwtUtil) {
        this.jwtUtil = jwtUtil;
    }

    @PostMapping("/login")
    public String login(@RequestBody LoginRequest request) {
        // 실제 인증 로직은 생략
        return jwtUtil.createToken(request.getUsername(), "ROLE_USER");
    }
}

class LoginRequest {
    private String username;
    private String password;

    // Getters and Setters
}

4. JWT 인증 필터 추가

Spring Security에서 JWT를 검증하도록 필터를 설정합니다.

import jakarta.servlet.FilterChain;
import jakarta.servlet.ServletException;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;

import java.io.IOException;

public class JwtAuthenticationFilter extends UsernamePasswordAuthenticationFilter {

    private final JwtUtil jwtUtil;

    public JwtAuthenticationFilter(JwtUtil jwtUtil) {
        this.jwtUtil = jwtUtil;
    }

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain chain)
            throws ServletException, IOException {
        String token = request.getHeader("Authorization");
        if (token != null && jwtUtil.validateToken(token)) {
            String username = jwtUtil.getUsername(token);
            SecurityContextHolder.getContext().setAuthentication(new JwtAuthentication(username));
        }
        chain.doFilter(request, response);
    }
}

5. SecurityConfig에 필터 등록

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    private final JwtUtil jwtUtil;

    public SecurityConfig(JwtUtil jwtUtil) {
        this.jwtUtil = jwtUtil;
    }

    @Bean
    public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
        http.csrf().disable()
            .addFilterBefore(new JwtAuthenticationFilter(jwtUtil), UsernamePasswordAuthenticationFilter.class)
            .authorizeHttpRequests()
            .requestMatchers("/auth/login").permitAll()
            .anyRequest().authenticated();
        return http.build();
    }
}

JWT 사용 시 주의점

1. 비밀 키 관리

   • 비밀 키는 안전하게 보호해야 하며, 외부에 노출되지 않도록 주의합니다.

2. 토큰 만료 시간

   • Access Token의 만료 시간을 짧게 설정하고, Refresh Token을 추가로 구현해 보안을 강화합니다.

3. HTTPS 사용

   • 토큰이 네트워크를 통해 전달되므로 HTTPS를 사용하여 암호화해야 합니다.

이 과정을 통해 JWT를 사용한 인증 시스템을 구현할 수 있습니다. JWT는 세션리스 인증 방식으로 확장성과 보안성을 동시에 제공합니다.

🎯 핵심 키워드

• Spring Security: 인증과 인가를 통합 관리하는 프레임워크
• Authentication: 사용자 신원 확인
• Authorization: 리소스 접근 권한 부여
• OAuth2: 제3자 애플리케이션 인증 프로토콜

이제 로그인까지 모두 배웠내요!! 길었던 10주차의 스터디가 드디어 끝이 났습니다..... 저도 많은 스프링 내용을 한번에 배우느라 진짜 힘들었던 거 같아요. 그래도 정말 많은 걸 배웠던 시간인 거 같습니다. 남은 2주차에는 CI/CD와 AWS에 대해서 살펴보겠습니다!! 여기까지 같이 따라오셨으면 정말 수고 많으셨어요😊

1. 효율적인 목록 조회 API 설계 방법을 탐구하고, 페이징 처리의 원리를 이해한다.
2. Spring Data JPA를 활용하여 데이터 양이 많은 환경에서 성능 최적화 방법을 학습한다.

1. 왜 목록 조회 API가 중요할까?

🌟 목록 조회 API의 중요성

1. 성능 최적화의 핵심:
   • 조회 API는 시스템 부하의 주요 원인 중 하나입니다. 데이터 양이 많을수록 효율적인 처리가 중요합니다.
2. 사용자 경험 개선:
   • 클라이언트가 한 번에 모든 데이터를 로드할 필요 없이 필요한 만큼의 데이터를 요청할 수 있어야 합니다.
3. 데이터 전송 비용 감소:
   • 불필요한 데이터를 줄이고 네트워크 전송량을 최소화합니다.

⚠️ 문제: 데이터가 많아질수록 발생하는 성능 문제

• 예시 상황:
  리뷰 데이터가 10만 건일 때, 클라이언트가 한 번의 요청으로 모든 데이터를 요청한다면:
  1. 네트워크 부하: 전송량이 기하급수적으로 증가.
  2. 메모리 문제: 클라이언트와 서버에서 데이터 처리 용량 초과.
  3. 응답 지연: 사용자 경험 저하.

이를 해결하기 위해 페이징(Paging)과 같은 기법이 필요합니다.

2. 설계 원리와 구현 프로세스

자 이제 차근차근 API를 만들어 봅시다.
보통 API를 만들 때 아래의 순서를 따르면 우왕좌왕 하지 않고 만들 수 있습니다.

🧭 전제 조건: API URL은 설계가 되었다는 전제입니다!

1. API 시그니처를 만든다!
   • 응답과 요청 DTO를 만든다.
   • 컨트롤러에서 어떤 형태를 리턴하는지, 어떤 파라미터가 필요한지, URI는 무엇인지 HTTP Method는 무엇인지만 정해둔다.
   • 컨버터 정의만 해둔다.
2. API 시그니처를 바탕으로 Swagger에 명세를 해준다.
3. 데이터베이스와 연결하는 부분을 만든다.
4. 비즈니스 로직을 만든다.
5. 컨트롤러를 완성한다.
6. Validation 처리를 한다.

2.1. API 시그니처 설계

API 시그니처란?

API 시그니처는 API의 기본 설계 정보로, 클라이언트와 서버 간에 어떤 데이터를 주고받을지 정의한 약속입니다. API가 어떤 역할을 하고, 어떤 데이터를 입력받고 출력하는지 명확히 알려주는 가이드라고 볼 수 있습니다.

주요 구성 요소

1. URI: API의 주소 (예: /stores/{storeId}/reviews)
2. HTTP Method: 작업 유형 (예: GET, POST)
3. 요청 데이터:
   • Path Variable: URL 경로에 포함된 데이터 (예: {storeId})
   • Query Parameter: URL 쿼리 스트링 데이터 (예: ?page=1)
   • Body: 요청 본문 데이터 (예: JSON 형식)
4. 응답 데이터: 서버가 반환하는 데이터의 구조 (예: JSON)
5. 상태 코드: 요청 결과를 나타내는 코드 (예: 200 OK, 400 Bad Request)

간단한 예: 특정 가게의 리뷰 목록을 조회하는 API

• URI: /stores/{storeId}/reviews
• HTTP Method: GET
• 요청 데이터:
  • Path Variable: storeId (가게 ID)
  • Query Parameter: page (페이지 번호)
• 응답 데이터:

  {
      "reviewList": [...],
      "totalElements": 100,
      "isLast": false
  }

• 상태 코드: 200 OK, 401 Unauthorized

해당 글에서 API 시그니처를 만든다는 말은 아래와 같습니다.

1. 응답과 요청 DTO를 만든다.
2. 컨트롤러에서 어떤 형태를 리턴하는지, 어떤 파라미터가 필요한지, URI는 무엇인지 HTTP Method는 무엇인지만 정해둔다.
3. 컨버터 정의만 해둔다.

📘 DTO 구현 코드

public class StoreResponseDTO {

    @Builder
    @Getter
    @NoArgsConstructor
    @AllArgsConstructor
    public static class ReviewPreViewListDTO {
        List<ReviewPreViewDTO> reviewList;
        Integer listSize;
        Integer totalPage;
        Long totalElements;
        Boolean isFirst;
        Boolean isLast;
    }

    @Builder
    @Getter
    @NoArgsConstructor
    @AllArgsConstructor
    public static class ReviewPreViewDTO {
        String ownerNickname;
        Float score;
        String body;
        LocalDate createdAt;
    }
}

✅ 설계 원칙

• ReviewPreViewDTO는 단일 리뷰 정보를 담고, 이를 리스트 형태로 묶은 ReviewPreViewListDTO를 반환.
• Builder 패턴을 사용해 불변성을 보장하고 코드 가독성을 향상.

2.2. Convertor 겉 모양(정의만) 설계

public class StoreConverter {

    public static StoreResponseDTO.ReviewPreViewDTO reviewPreViewDTO(Review review) {
        return null;
    }

    public static StoreResponseDTO.ReviewPreViewListDTO reviewPreViewListDTO(List<Review> reviewList) {
        return null;
    }
}

2.3. Swagger를 이용한 API 명세 작성

@RestController
@RequiredArgsConstructor
@Validated
@RequestMapping("/stores")
public class StoreRestController {

    private final StoreQueryService storeQueryService;

    @GetMapping("/{storeId}/reviews")
    @Operation(summary = "특정 가게의 리뷰 목록 조회 API", description = "특정 가게의 리뷰들의 목록을 조회하는 API이며, 페이징을 포함합니다. Query String으로 페이지 번호를 제공합니다.")
    @ApiResponses({
        @io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "COMMON200", description = "OK, 성공"),
        @io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "AUTH003", description = "access 토큰을 제공해 주세요!", content = @Content(schema = @Schema(implementation = ApiResponse.class))),
        @io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "AUTH004", description = "access 토큰 만료", content = @Content(schema = @Schema(implementation = ApiResponse.class))),
        @io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "AUTH006", description = "access 토큰 형식 오류", content = @Content(schema = @Schema(implementation = ApiResponse.class))),
    })
    @Parameters({
        @Parameter(name = "storeId", description = "가게의 ID입니다 (Path Variable)"),
        @Parameter(name = "page", description = "페이지 번호입니다 (Query Parameter)")
    })
    public ApiResponse<StoreResponseDTO.ReviewPreViewListDTO> getReviewList(
            @ExistStore @PathVariable(name = "storeId") Long storeId,
            @RequestParam(name = "page") Integer page) {
        storeQueryService.getReviewList(storeId, page);
        return null;
    }
}

• @Operation: API 설명을 정의(summary와 description 사용).
• @ApiResponses: API 응답에 대한 설명 포함.
  • 에러 상황에는 content를 통해 오류 응답의 스키마를 정의.
  • 성공 응답은 스키마 없이 ApiResponse<T>를 보여줌.
• @Parameters: 프론트엔드에서 전달해야 하는 파라미터를 명시.

2.4. 서비스 메서드 로직 작성

📘 서비스 인터페이스

public interface StoreQueryService {

    Page<Review> getReviewList(Long storeId, Integer page);
}

📘 리포지토리 인터페이스

public interface ReviewRepository extends JpaRepository<Review, Long> {

    Page<Review> findAllByStore(Store store, PageRequest pageRequest);
}

📘 서비스 구현

@Service
@RequiredArgsConstructor
public class StoreQueryServiceImpl implements StoreQueryService {

    private final StoreRepository storeRepository;
    private final ReviewRepository reviewRepository;

    @Override
    public Page<Review> getReviewList(Long storeId, Integer page) {
        Store store = storeRepository.findById(storeId).orElseThrow();
        return reviewRepository.findAllByStore(store, PageRequest.of(page, 10));
    }
}

serviceImpl

@Service
@RequiredArgsConstructor
public class StoreQueryServiceImpl implements StoreQueryService{

    private final StoreRepository storeRepository;

    private final ReviewRepository reviewRepository;

    // ... 다른 코드들

    @Override
    public Page<Review> getReviewList(Long StoreId, Integer page) {

        Store store = storeRepository.findById(StoreId).get();

        Page<Review> StorePage = reviewRepository.findAllByStore(store, PageRequest.of(page, 10));
        return StorePage;
    }
}

controller

@RestController
@RequiredArgsConstructor
@Validated
@RequestMapping("/stores")
public class StoreRestController {

    private final StoreQueryService storeQueryService;

    @GetMapping("/{storeId}/reviews")
    @Operation(summary = "특정 가게의 리뷰 목록 조회 API",description = "특정 가게의 리뷰들의 목록을 조회하는 API이며, 페이징을 포함합니다. query String 으로 page 번호를 주세요")
    @ApiResponses({
            @io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "COMMON200",description = "OK, 성공"),
            @io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "AUTH003", description = "access 토큰을 주세요!",content = @Content(schema = @Schema(implementation = ApiResponse.class))),
            @io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "AUTH004", description = "acess 토큰 만료",content = @Content(schema = @Schema(implementation = ApiResponse.class))),
            @io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "AUTH006", description = "acess 토큰 모양이 이상함",content = @Content(schema = @Schema(implementation = ApiResponse.class))),
    })
    @Parameters({
            @Parameter(name = "storeId", description = "가게의 아이디, path variable 입니다!")
    })
    public ApiResponse<StoreResponseDTO.ReviewPreViewListDTO> getReviewList(@ExistStore @PathVariable(name = "storeId") Long storeId,@RequestParam(name = "page") Integer page){
        storeQueryService.getReviewList(storeId,page);
        return null;
    }
}

converter

여기서 converter를 보면, ListDTO를 위해 리스트에 들어갈 DTO를 다른 Converter에서 제작해서 이를 Java stream을 통해 DTO의 List를 만드는 것을 알 수 있습니다.

public class StoreConverter {

    public static StoreResponseDTO.ReviewPreViewDTO reviewPreViewDTO(Review review){
        return StoreResponseDTO.ReviewPreViewDTO.builder()
                **.ownerNickname(review.getMember().getName()) // 객체그래프 탐색**
                .score(review.getScore())
                .createdAt(review.getCreatedAt().toLocalDate())
                .body(review.getBody())
                .build();
    }
    public static StoreResponseDTO.ReviewPreViewListDTO reviewPreViewListDTO(**Page**<Review> reviewList){

        List<StoreResponseDTO.ReviewPreViewDTO> reviewPreViewDTOList = reviewList.stream()
                .map(StoreConverter::reviewPreViewDTO).collect(Collectors.toList());

        return StoreResponseDTO.ReviewPreViewListDTO.builder()
                .isLast(reviewList.isLast())
                .isFirst(reviewList.isFirst())
                .totalPage(reviewList.getTotalPages())
                .totalElements(reviewList.getTotalElements())
                .listSize(reviewPreViewDTOList.size())
                .reviewList(reviewPreViewDTOList)
                .build();
    }
}

그리고 .ownerNickname(review.getMember().getName())

이 코드를 통해 review에 @MantyToOne으로 지정해둔 Member를 통해 아주 편하게 데이터를 가져오는 것을 확인 할 수 있습니다.

이는 객체 그래프 탐색 이라는 Spring Data JPA에서 사용 가능한 아주 강력한 기능입니다.

이제 컨트롤러를 controller를 converter에 맞게 바꾸고

@RestController
@RequiredArgsConstructor
@Validated
@RequestMapping("/stores")
public class StoreRestController {

    private final StoreQueryService storeQueryService;

    @GetMapping("/{storeId}/reviews")
    @Operation(summary = "특정 가게의 리뷰 목록 조회 API",description = "특정 가게의 리뷰들의 목록을 조회하는 API이며, 페이징을 포함합니다. query String 으로 page 번호를 주세요")
    @ApiResponses({
            @io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "COMMON200",description = "OK, 성공"),
            @io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "AUTH003", description = "access 토큰을 주세요!",content = @Content(schema = @Schema(implementation = ApiResponse.class))),
            @io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "AUTH004", description = "acess 토큰 만료",content = @Content(schema = @Schema(implementation = ApiResponse.class))),
            @io.swagger.v3.oas.annotations.responses.ApiResponse(responseCode = "AUTH006", description = "acess 토큰 모양이 이상함",content = @Content(schema = @Schema(implementation = ApiResponse.class))),
    })
    @Parameters({
            @Parameter(name = "storeId", description = "가게의 아이디, path variable 입니다!")
    })
    public ApiResponse<StoreResponseDTO.ReviewPreViewListDTO> getReviewList(@ExistStore @PathVariable(name = "storeId") Long storeId,@RequestParam(name = "page") Integer page){
        storeQueryService.getReviewList(storeId,page);
        return ApiResponse.onSuccess(StoreConverter.reviewPreViewListDTO(reviewList));
    }
}

3. CQRS 설계 원칙

CQRS (Command Query Responsibility Segregation)란?

CQRS는 데이터 변경 작업 (Command)과 조회 작업 (Query)을 분리하여 각 작업의 책임을 명확히 하는 설계 원칙입니다.

4. 객체 그래프 탐색과 Spring Data JPA

🌟 객체 그래프 탐색

Spring Data JPA에서 객체 그래프 탐색은 연관 관계에 있는 엔티티를 함께 조회하는 방법을 의미합니다. 보통 연관 관계 매핑(@OneToMany, @ManyToOne 등)된 엔티티를 처리할 때 사용됩니다.

주요 기법

• JPQL 및 Fetch Join 사용

  • 특징

    • JPQL에서 JOIN FETCH 키워드를 사용하여 연관 데이터를 한 번에 로드합니다.
    • EAGER와 유사하지만, 개발자가 명시적으로 특정 상황에서만 데이터를 로드하도록 설계할 수 있습니다.
    • Fetch Join을 사용하면 즉시 로딩(EAGER)이 이루어지며, N+1 문제를 방지할 수 있습니다.

  • 장점

    • 한 번의 쿼리로 연관 데이터를 로드하므로 성능이 최적화됩니다.
    • 특정 조건이나 필터를 JPQL로 지정할 수 있어 유연합니다.

  • 단점

    • 복잡한 JPQL 작성이 필요하며, 쿼리가 길어질 수 있습니다.
    • 데이터가 많을 경우, 한 번의 쿼리로 많은 데이터를 로드해 메모리 문제를 일으킬 수 있습니다.
    • JPQL을 직접 작성해야 하므로 코드 유지보수가 어려울 수 있습니다.

  • 사용 예

      @Query("SELECT u FROM User u JOIN FETCH u.orders WHERE u.id = :id")
      User findUserWithOrders(@Param("id") Long id);

• EntityGraph 사용

  • JPQL을 사용하지 않고, @EntityGraph를 통해 연관 데이터를 로드할 수 있습니다.

  • 특징

    • @EntityGraph를 사용해 JPQL 없이 객체 그래프 탐색을 정의할 수 있습니다.
    • 선언적으로 연관 엔티티를 함께 로드할 경로(attributePaths)를 지정합니다.
    • EntityGraph는 JPA Repository에서 바로 활용 가능하며, Lazy Loading 엔티티를 명시적으로 Fetch Join 형태로 로드합니다.

  • 장점

    • JPQL 작성 없이 선언적으로 연관 데이터를 로드할 수 있어 유지보수가 용이합니다.
    • 비즈니스 로직과 탐색 경로 설정이 분리되어 코드 가독성이 높아집니다.
    • 특정 메서드에만 적용 가능하므로 성능을 세밀하게 조정할 수 있습니다.

  • 단점

    • 설정된 경로(attributePaths) 이외의 데이터는 로드되지 않으므로 추가 데이터가 필요할 경우 다시 쿼리가 발생할 수 있습니다.
    • 복잡한 객체 그래프 탐색이 필요한 경우에는 사용이 제한적입니다.

  • 예제

      @EntityGraph(attributePaths = {"orders"})
      @Query("SELECT u FROM User u WHERE u.id = :id")
      User findUserWithOrders(@Param("id") Long id);

• Hibernate 초기화 강제화

  • Lazy 로딩된 데이터를 강제로 초기화합니다.

  • 특징

    • Hibernate.initialize()를 사용해 지연 로딩된 데이터를 강제로 초기화합니다.
    • 특정 비즈니스 로직에 필요한 경우, Lazy 로딩된 연관 엔티티를 조회 시점에 로드합니다.

  • 장점

    • 매우 유연하며, Lazy 로딩된 데이터를 필요할 때만 초기화할 수 있습니다.
    • 로딩 시점과 방법을 완전히 제어할 수 있습니다.

  • 단점

    • 데이터를 강제로 초기화하기 때문에 추가적인 쿼리가 발생합니다.
    • 잘못 사용하면 N+1 문제가 심화될 수 있습니다.
    • 코드에서 명시적으로 초기화를 작성해야 하므로 코드가 복잡해질 수 있습니다.

  • 예제

      User user = userRepository.findById(1L).get();
      Hibernate.initialize(user.getOrders()); // Lazy 로딩된 orders를 강제 초기화

• Batch Fetching

  • N+1 문제를 해결하기 위해 여러 연관 데이터를 한 번에 가져옵니다.

  • 특징

    • Hibernate의 @BatchSize 또는 hibernate.default_batch_fetch_size 설정을 통해 연관된 엔티티를 한 번에 로드합니다.
    • Lazy 로딩된 데이터를 배치(batch) 방식으로 가져와, 여러 엔티티에 대해 한 번의 쿼리를 실행합니다.
    • 기본적으로 SELECT 쿼리를 최적화하여 N+1 문제를 완화합니다.

  • 장점

    • N+1 문제를 방지하면서도 데이터의 필요 여부에 따라 Lazy 로딩을 유지합니다.
    • 데이터 양이 많아도 메모리를 과도하게 사용하지 않고, 일정 크기로 나누어 로드합니다.

  • 단점

    • 잘못된 Batch 크기 설정은 오히려 성능에 부정적인 영향을 미칠 수 있습니다.
    • 모든 경우에 최적화되지 않으며, 데이터 로드 크기를 세밀하게 조정해야 합니다.

  • 사용 예

      @BatchSize(size = 10)
      @OneToMany(mappedBy = "user", fetch = FetchType.LAZY)
      private List<Order> orders;

  • 전역 설정

      properties
    
      spring.jpa.properties.hibernate.default_batch_fetch_size=10

주요 기법 비교

마무리

이번 글을 통해 성능 최적화와 유지보수성을 고려한 목록 조회 API의 핵심 원칙을 학습했습니다. 거의 다 이 시리즈에 끝에 와갑니다!😁

1. Database와 상호작용하는 API의 전체 과정을 익힌다.
2. Swagger 세팅을 학습한다.
3. 어노테이션을 활용한 데이터 검증 방법을 익힌다.

8주차 주제 및 진행

주요 내용은 Database와 상호작용하는 API의 흐름을 이해하는 것입니다.
지난 포스팅의 내용을 기반으로 구체적인 예제를 다룹니다.

또한, Service와 Controller 단에서 데이터 검증 처리를 코드가 아닌 어노테이션으로 수행하는 방법을 통해 단일 책임 원칙을 준수하고, 더 깔끔한 코드 작성 방법을 배웁니다.

1. 회원 가입 API 구현

GitHub 이슈 및 브랜치 만들기

1. GitHub에서 이슈를 생성합니다.
   라벨은 깃모지(gitmoji)를 활용해 꾸며보세요.
   예시:
   • 🐛 :bug:
   • 📝 :memo:
   • ✨ :sparkles:
2. 브랜치 생성
   • 브랜치 이름 예시: feature/#이슈번호
   • 예를 들어, feature/#3
3. 브랜치 작업 시 주의사항
   • 항상 작업할 브랜치가 최신 상태인지 확인 후 작업을 시작하세요.

1) DTO 생성

회원 가입에 필요한 Request와 Response DTO를 생성합니다.

// Request DTO
public class MemberRequestDTO {
    @Getter
    public static class JoinDto {
        String name;
        Integer gender;
        Integer birthYear;
        Integer birthMonth;
        Integer birthDay;
        String address;
        String specAddress;
        List<Long> preferCategory;
    }
}

// Response DTO
public class MemberResponseDTO {
    @Builder
    @Getter
    @NoArgsConstructor
    @AllArgsConstructor
    public static class JoinResultDTO {
        Long memberId;
        LocalDateTime createdAt;
    }
}

2) Converter 생성

엔티티와 DTO 간 변환을 위한 Converter를 생성합니다.

public class MemberConverter {
    public static MemberResponseDTO.JoinResultDTO toJoinResultDTO(Member member) {
        return MemberResponseDTO.JoinResultDTO.builder()
            .memberId(member.getId())
            .createdAt(LocalDateTime.now())
            .build();
    }

    public static Member toMember(MemberRequestDTO.JoinDto request) {
        Gender gender = switch (request.getGender()) {
            case 1 -> Gender.MALE;
            case 2 -> Gender.FEMALE;
            default -> Gender.NONE;
        };

        return Member.builder()
            .name(request.getName())
            .gender(gender)
            .address(request.getAddress())
            .specAddress(request.getSpecAddress())
            .build();
    }
}

3) Controller 생성

클라이언트 요청을 처리하는 Controller를 작성합니다.

@RestController
@RequiredArgsConstructor
@RequestMapping("/members")
public class MemberRestController {

    private final MemberCommandService memberCommandService;

    @PostMapping("/")
    public ApiResponse<MemberResponseDTO.JoinResultDTO> join(@RequestBody @Valid MemberRequestDTO.JoinDto request) {
        Member member = memberCommandService.joinMember(request);
        return ApiResponse.onSuccess(MemberConverter.toJoinResultDTO(member));
    }
}

4) Service 생성

비즈니스 로직을 처리하는 Service를 작성합니다.

@Service
@RequiredArgsConstructor
public class MemberCommandServiceImpl implements MemberCommandService {
    private final MemberRepository memberRepository;
    private final FoodCategoryRepository foodCategoryRepository;

    @Transactional
    @Override
    public Member joinMember(MemberRequestDTO.JoinDto request) {
        Member newMember = MemberConverter.toMember(request);

        // 선호 카테고리 처리
        List<FoodCategory> foodCategoryList = request.getPreferCategory().stream()
            .map(categoryId -> foodCategoryRepository.findById(categoryId)
                .orElseThrow(() -> new IllegalArgumentException("카테고리 없음")))
            .toList();

        foodCategoryList.forEach(category -> {
            MemberPrefer prefer = MemberPrefer.builder()
                .member(newMember)
                .foodCategory(category)
                .build();
            newMember.getMemberPreferList().add(prefer);
        });

        return memberRepository.save(newMember);
    }
}

5) Repository 생성

Spring Data JPA를 사용해 Repository를 작성합니다.

public interface MemberRepository extends JpaRepository<Member, Long> {}
public interface FoodCategoryRepository extends JpaRepository<FoodCategory, Long> {}

6) Swagger 세팅

1. build.gradle에 의존성 추가:

    implementation 'org.springdoc:springdoc-openapi-starter-webmvc-ui:2.3.0'

2. Swagger 설정 클래스 생성:

    @Configuration
    public class SwaggerConfig {
        @Bean
        public OpenAPI umcStudyAPI() {
            return new OpenAPI()
                .addServersItem(new Server().url("/"))
                .info(new Info().title("UMC API").version("1.0.0").description("API 명세서"));
        }
    }

3. Swagger 확인:
   http://localhost:8080/swagger-ui/index.html#/로 접속합니다.

7) 어노테이션 기반 Validation

1. Request DTO에 어노테이션 추가:

    public class MemberRequestDTO {
        @Getter
        public static class JoinDto {
            @NotBlank
            String name;
            @NotNull
            Integer gender;
            @Size(min = 5, max = 12)
            String address;
            @ExistCategories
            List<Long> preferCategory;
        }
    }

2. 커스텀 어노테이션 정의:

    @Documented
    @Constraint(validatedBy = CategoriesExistValidator.class)
    @Target({ElementType.FIELD})
    @Retention(RetentionPolicy.RUNTIME)
    public @interface ExistCategories {
        String message() default "카테고리 존재하지 않음";
        Class<?>[] groups() default {};
        Class<? extends Payload>[] payload() default {};
    }

3. Validator 작성:

    @Component
    @RequiredArgsConstructor
    public class CategoriesExistValidator implements ConstraintValidator<ExistCategories, List<Long>> {
        private final FoodCategoryRepository foodCategoryRepository;
   
        @Override
        public boolean isValid(List<Long> value, ConstraintValidatorContext context) {
            return value.stream().allMatch(foodCategoryRepository::existsById);
        }
    }

그러면 아래 과정을 통해 완성이 되게 됩니다.

결론 및 회고

이번 주 학습에서는 Database와 상호작용하는 API의 기본 흐름을 학습했습니다. 특히 Swagger와 Validation 어노테이션을 통해 개발자 경험(DX)을 개선하는 방법을 배우는 것이 핵심이었습니다. 다음 포스팅에서는 목록 조회가 아닌 API를 만들어보면서, 페이징을 적용해보겠습니다!

🏁 이번 주차 목표

• API 응답의 일관성을 유지하는 방법을 학습합니다.
• 에러 핸들링의 원리를 이해하고, 효율적인 구현 방식을 알아봅니다.

🌱 1. API 응답 통일이란?

API란 애플리케이션들 간의 대화하는 통로 역할을 하는 것이었는데요.

그렇다면, 왜 API 응답을 통일해야 할까요?

API 개발 시 응답 형식이 통일되지 않으면 협업과 유지보수에 큰 문제가 생깁니다. 특히 프론트엔드와 대화를 해야하는 수단인 API에서 응답의 형태가 제각각이면, 이를 파악하기가 어렵겠죠?

따라서 API의 응답을 통일 하는 것은 프로젝트 진행에 있어 매우 필요한 작업입니다.

1-1. 통일된 API 응답의 구조

API의 형태는 프로젝트마다 다르지만, 응답 형식은 대개 다음과 같은 형태를 가집니다:

{
  "isSuccess": true,
  "code": "200",
  "message": "Request Successful",
  "result": {
    "data": "Your Data Here"
  }
}

각 필드의 의미

• isSuccess: 요청 성공 여부 (true 또는 false)
• code: 상태 코드를 나타내는 값. HTTP 상태코드로는 너무 제한적인 정보만 줄 수 있어서 조금 더 세부적인 응답 상황을 알려주기 위한 필드
• message: 상태 코드(code)에 추가적으로 내용 설명
• result: 요청 결과 데이터를 포함 (null로 설정 가능, DTO와 같은 것) 실제로 클라이언트에게 필요한 데이터가 담깁니다. 보통 에러 상황에는 null을 담지만, 아닌 경우도 있음

🪄 HTTP 상태 코드?

HTTP 상태 코드는 여러가지가 있지만 200번 대, 400번 대, 500번 대만 알아봅시다. 아래에 작성한 상태 코드 정도만 알아도 충분합니다만, 궁금하시면 더 찾아보세요!

1. 200번 대 : 문제 없음
   1. 200 : OK 성공임
   2. 201 : Created: 네가 준 데이터를 가지고 적절한 과정을 거쳐 새로운 리소스를 만들었어
2. 400번 대 : 클라이언트 측 잘못으로 인한 에러
   1. 400 : Bad Request : 요청 이상하게 함, 필요한 정보 누락됨..
   2. 401 : Unauthorized : 인증이 안됨 (로그인이 되어야 하는데 안된 상황)
   3. 403 : Forbidden : 권한 없음 (로그인은 되었으나 접근이 안됨, 관리자 페이지 등등)
   4. 404 : NotFound : 요청한 정보가 그냥 없음
3. 500번 대 : 서버 측 잘못으로 인한 에러(안돼…….😱)
   1. 500 : Internal Server Error : 서버 터짐…….
   2. 504 : Gateway Timeout : 서버가 응답을 안 줌 (그냥 터진거긴 함..)

🌟 1-2. API 응답 통일하는 방법 알아보기

이제 실제로 차근차근 API 응답을 어떻게 통일하는지 살펴봅시다. 응답의 경우 enum으로 그 형태를 관리합니다.

이 때, 성공 응답과 실패 응답을 하나의 enum으로 관리할 수도 있고, 분리할 수도 있습니다. 이번에는 분리해서 관리하는 걸 같이 봐봅시다.

1. 디렉토리 구조 생성

먼저, apiPayload라는 디렉토리를 만들고 그 아래에 API 응답 통일을 위한 ApiResponse 클래스를 만들어주세요. 그리고 code라는 패키지도 디렉토리 내에 만들어주세요

2. ApiResponse 기본 틀 생성

이 클래스는 모든 API 응답의 기본 구조를 제공합니다.

@Getter
@AllArgsConstructor
@JsonPropertyOrder({"isSuccess", "code", "message", "result"})
public class ApiResponse<T> {
    private final Boolean isSuccess; // 성공 여부
    private final String code;       // 상태 코드
    private final String message;    // 응답 메시지
    @JsonInclude(JsonInclude.Include.NON_NULL)
    private final T result;          // 실제 데이터

    // 성공 응답 생성 메서드
    public static <T> ApiResponse<T> onSuccess(T result) {
        return new ApiResponse<>(true, "2000", "Request Successful", result);
    }

    // 실패 응답 생성 메서드
    public static <T> ApiResponse<T> onFailure(String code, String message) {
        return new ApiResponse<>(false, code, message, null);
    }
}

result는 어떤 형태의 값이 올지 모르기에 Generic으로 만들어 줍니다.

3. API 응답에 들어갈 code와 message의 형식 생성

아까 만든 폴더 아래에 아래와 같은 폴더 형태를 만들어주세요

3-1) 응답을 해주는 ErrorReasonDTO와 ReasonDTO의 코드를 적어주기

이 코드는 단순히 데이터를 담는 컨테이너 역할으로, 프로젝트가 확장될수록 DTO는 응답 구조를 구체화하는 데 활용될 것입니다.

@Getter
@Builder
public class ErrorReasonDTO {

    private HttpStatus httpStatus;

    private final boolean isSuccess;
    private final String code;
    private final String message;

    public boolean getIsSuccess(){return isSuccess;}
}

@Getter
@Builder
public class ReasonDTO {

    private HttpStatus httpStatus;

    private final boolean isSuccess;
    private final String code;
    private final String message;

    public boolean getIsSuccess(){return isSuccess;}
}

둘의 코드가 같은데 왜 따로 만들지? 두 클래스가 현재는 동일한 코드를 가지고 있지만, 구체적인 용도와 의미를 구분하기 위해 따로 정의된 것 => 이러한 구조는 확장성과 유지보수성을 고려한 설계입니다!

3-2) BaseCode와 BaseErrorCode 작성

두 코드는 code 내용을 구체화 하는 Status에서 두 개의 메소드를 반드시 Override할 것을 강제하는 역할을 합니다. 상태 코드, 메시지 등의 구조를 정의하고, 이를 Enum과 결합하여 일관된 상태 코드 관리를 가능하게 하는 것이죠.

public interface BaseCode {

    Reason getReason();

    Reason getReasonHttpStatus();
}

public interface BaseErrorCode {

    ErrorReason getReason();

    ErrorReason getReasonHttpStatus();
}

Q. DTO와 BaseCode는 어떻게 활용되는 건가요? 사용 흐름 예시

1. BaseCode / BaseErrorCode 에서 상태 코드와 메시지를 정의.
2. 컨트롤러에서 상태 코드와 메시지를 가져와 ReasonDTO/ReasonErrorDTO를 생성.
3. DTO를 클라이언트에게 응답으로 전달.

3-3) 성공 응답을 나타내는 SuccessStatus 작성

@Getter
@AllArgsConstructor
public enum SuccessStatus implements BaseCode {

    // 일반적인 응답
    _OK(HttpStatus.OK, "COMMON200", "성공입니다.");

    private final HttpStatus httpStatus;
    private final String code;
    private final String message;

    @Override
    public ReasonDTO getReason() {
        return ReasonDTO.builder()
                .message(message)
                .code(code)
                .isSuccess(true)
                .build();
    }

    @Override
    public ReasonDTO getReasonHttpStatus() {
        return ReasonDTO.builder()
                .message(message)
                .code(code)
                .isSuccess(true)
                .httpStatus(httpStatus)
                .build()
                ;
    }
}

코드를 자세히 보면, enum 자신의 값으로 가지고 있던 message, code, httpStatus값을 interface의 메소드 오버라이딩을 통하여 DTO를 만드는 것을 확인할 수 있습니다.

1-3. Spring Boot로 임시 API 만들어보기

1. API 설계

API 정보

• HTTP 메서드: GET
• URL: /temp/test
• Query String, Request Body, Request Header: 없음
• Response: 아래와 같은 JSON 형식 반환

  {
      "isSuccess": true,
      "code": "2000",
      "message": "OK",
      "result": {
          "testString": "This is test!"
      }
  }

2. DTO(Data Transfer Object) 작성

DTO는 데이터를 전달하기 위한 객체입니다.
이번 API에서는 TempResponse 클래스를 작성하여 응답 데이터 구조를 정의합니다. RequestBody에 담겨오는 값은 없으므로, 응답용 DTO만 작성합니다.

TempResponse 코드

public class TempResponse {

    @Builder
    @Getter
    @NoArgsConstructor
    @AllArgsConstructor
    public static class TempTestDTO {
        String testString;
    }
}

코드 분석

1. @Builder

   • 객체를 빌더 패턴으로 생성하도록 지원.
   • 가독성과 유연성을 제공하며, 생성자 대신 직관적으로 객체를 생성할 수 있음.
   2. @Getter
   • DTO 클래스의 모든 필드에 대해 getter 메서드를 자동 생성.
   • 코드 간결화와 캡슐화 유지에 도움.

2. @NoArgsConstructor

   • 매개변수가 없는 기본 생성자를 자동 생성.

3. @AllArgsConstructor

   • 모든 필드를 초기화하는 생성자를 제공.
   • 테스트 코드 작성 시나 특정 상황에서 객체를 한 번에 초기화할 때 유용.

4. Static Class 사용

   • DTO를 큰 묶음으로 관리할 수 있도록 설계.
   • 여러 관련 DTO를 하나의 클래스 내부에서 관리하여 코드 구조를 간소화하고 재사용성을 높임.

   추가 설명 빌더 패턴이란? 빌더 패턴(Builder Pattern)은 객체 생성 패턴 중 하나로, 복잡한 객체를 단계별로 구성할 수 있도록 설계된 디자인 패턴입니다.

   • 주로 객체 생성 과정이 복잡하거나, 동일한 생성 프로세스를 통해 다양한 객체 구성을 제공해야 할 때 사용.
   • 객체 생성 시 생성자 대신 @Builder를 활용하여 직관적이고 가독성이 높은 코드 작성이 가능.
   • 필드가 많거나 선택적 필드가 있는 객체를 생성할 때 유리.
   • 빌더 패턴 사용 예시*

     TempResponse.TempTestDTO dto = TempResponse.TempTestDTO.builder()
        .testString("This is Test!")
        .build();

   • 빌더 패턴의 장점*
   • 필드 순서에 상관없이 원하는 값만 설정 가능.
   • 코드 가독성과 유지보수성 향상.

   왜 public static class를 사용할까?

   • DTO는 여러 곳에서 사용될 수 있으므로 범용적인 사용을 위해 내부 static 클래스로 정의.
   • 장점:
     • 별도의 DTO 파일을 만들지 않아도 됨.
     • 관련된 DTO들을 하나의 클래스로 묶어 관리 가능.

3. Converter 작성

Converter는 데이터 변환을 담당하는 클래스입니다.
여기서는 TempConverter 클래스를 작성해 TempResponse.TempTestDTO 객체를 생성합니다.

TempConverter 코드

public class TempConverter {

    public static TempResponse.TempTestDTO toTempTestDTO() {
        return TempResponse.TempTestDTO.builder()
                .testString("This is Test!")
                .build();
    }
}

코드 분석

1. toTempTestDTO(): TempTestDTO 객체를 생성하고 반환하는 정적 메서드.
2. 빌더 패턴을 활용하여 가독성과 유연성을 높임.

4. Controller 작성

Controller는 클라이언트 요청을 처리하고 응답을 반환하는 역할을 담당합니다.
이번 API는 비즈니스 로직이나 DB 연동이 없으므로 Service와 Repository 계층을 생략하고 작성합니다.

TempRestController 코드

@RestController
@RequestMapping("/temp")
@RequiredArgsConstructor
public class TempRestController {

    @GetMapping("/test")
    public ApiResponse<TempResponse.TempTestDTO> testAPI() {
        return ApiResponse.onSuccess(TempConverter.toTempTestDTO());
    }
}

코드 분석

1. @RestController: RESTful 웹 서비스 컨트롤러를 나타냄. JSON 응답 자동 반환.
2. @RequestMapping("/temp"): 모든 엔드포인트에 /temp URL prefix를 설정.
3. @GetMapping("/test"): /temp/test 경로의 GET 요청을 처리.
4. ApiResponse.onSuccess(): 성공적인 응답 구조를 표준화하여 생성.

5. API 실행 결과

로컬 환경에서 API 호출 localhost:8080/temp/test로 GET 요청을 보내면 다음과 같은 JSON 응답을 반환합니다.

{
    "isSuccess": true,
    "code": "2000",
    "message": "OK",
    "result": {
        "testString": "This is test!"
    }
}

지금은 로컬호스트이지만, 원격 서버 Nginx에 Spring Boot을 연동했다면...

1. 클라이언트 요청은 Nginx에 도달.
2. Nginx는 요청을 Spring Boot 애플리케이션으로 전달(리버스 프록시).
3. Spring Boot에서 처리한 결과를 Nginx가 클라이언트에 반환. 이 순서로 작동되게 됩니다.

로컬서버 vs Ngnix

• 로컬 서버: 내 컴퓨터 안에서만 작동. 예를 들어, localhost:3000 같은 주소를 브라우저에 입력하면, 내 컴퓨터가 서버처럼 작동해서 결과를 보여줌.
• Nginx: 인터넷에 연결된 컴퓨터(서버)에 설치됨. 다른 사람들이 내 웹사이트 주소(www.mywebsite.com)에 접속하면, Nginx가 "어! 여기에 파일 있네!" 하고 데이터를 전달해줌. 추가로, 내가 만든 프로그램(예: Django, Spring 같은 백엔드)도 연결해서 사용자 요청을 처리할 수 있게 도와줌.

🌱 2.에러 핸들링의 중요성

에러를 관리해야 하는 이유

• 사용자 경험 개선: 명확한 에러 메시지를 제공하면 사용자가 문제를 이해하고 해결하기 쉬워집니다.
• 디버깅 용이성: 통일된 에러 구조는 개발자가 문제를 빠르게 파악하고 수정하는 데 도움을 줍니다.

** Enum으로 에러 코드 관리하기 **- 추천 방식

1. common 에러는 COMMON000 으로 둔다. <- 잘 안쓰지만 마땅하지 않을 때 사용
2. 관련된 경우마다 code에 명시적으로 표현한다.
   • 예를 들어 멤버 관련이면 MEMBER001 이런 식으로
3. 2번에 이어서 4000번대를 붙인다. 서버측 잘못은 그냥 COMMON 에러의 서버 에러를 쓰면 됨.
   • MEMBER400_1 아니면 MEMBER4001 이런 식으로

2-2. Spring Boot 에러 핸들링 구현 과정

Spring Boot에서는 @RestControllerAdvice를 사용하여 전역적으로 발생하는 예외를 처리하고, 표준화된 응답을 반환할 수 있습니다.

1) ErrorStatus 작성하기

ErrorStatus는 애플리케이션에서 발생하는 다양한 에러를 관리하는 에러 상태 코드 클래스입니다.

@Getter
@AllArgsConstructor
public enum ErrorStatus implements BaseErrorCode {

    // 공통 에러
    _INTERNAL_SERVER_ERROR(HttpStatus.INTERNAL_SERVER_ERROR, "COMMON500", "서버 에러, 관리자에게 문의 바랍니다."),
    _BAD_REQUEST(HttpStatus.BAD_REQUEST, "COMMON400", "잘못된 요청입니다."),
    _UNAUTHORIZED(HttpStatus.UNAUTHORIZED, "COMMON401", "인증이 필요합니다."),
    _FORBIDDEN(HttpStatus.FORBIDDEN, "COMMON403", "금지된 요청입니다."),

    // 사용자 관련 에러
    MEMBER_NOT_FOUND(HttpStatus.BAD_REQUEST, "MEMBER4001", "사용자가 없습니다."),
    NICKNAME_NOT_EXIST(HttpStatus.BAD_REQUEST, "MEMBER4002", "닉네임은 필수입니다."),

    // 기타 에러
    ARTICLE_NOT_FOUND(HttpStatus.NOT_FOUND, "ARTICLE4001", "게시글이 없습니다.");

    private final HttpStatus httpStatus;
    private final String code;
    private final String message;

    @Override
    public ErrorReasonDTO getReason() {
        return ErrorReasonDTO.builder()
                .message(message)
                .code(code)
                .isSuccess(false)
                .build();
    }

    @Override
    public ErrorReasonDTO getReasonHttpStatus() {
        return ErrorReasonDTO.builder()
                .message(message)
                .code(code)
                .isSuccess(false)
                .httpStatus(httpStatus)
                .build();
    }
}

ErrorStatus가 필요한 이유

• 에러 코드를 중앙에서 관리할 수 있어, 일관성 있고 읽기 쉬운 에러 처리가 가능합니다.
• 클라이언트에게 명확한 에러 메시지와 상태 코드를 제공할 수 있습니다.

2) GeneralException 추가하기

GeneralException은 특정 조건에서 발생하는 커스텀 에러를 처리하기 위해 작성된 사용자 정의 예외 클래스입니다.

@Getter
@AllArgsConstructor
public class GeneralException extends RuntimeException {

    private BaseErrorCode code;

    public ErrorReasonDTO getErrorReason() {
        return this.code.getReason();
    }

    public ErrorReasonDTO getErrorReasonHttpStatus() {
        return this.code.getReasonHttpStatus();
    }
}

GeneralException이 필요한 이유

• 개발자가 원하는 대로 커스텀 예외를 생성하고 처리할 수 있습니다.
• 비즈니스 로직에 따라 발생하는 특정 에러를 명확히 처리할 수 있습니다.

3) 에러 핸들러 만들기 (ExceptionAdvice)

ExceptionAdvice 클래스는 애플리케이션의 모든 예외를 처리하고 표준화된 JSON 응답을 반환합니다.

build.gradle에 의존성 추가

유효성 검사 예외를 처리하려면 validation 관련 라이브러리를 추가해야 합니다.

implementation 'org.springframework.boot:spring-boot-starter-validation'

ExceptionAdvice 코드

@Slf4j
@RestControllerAdvice(annotations = {RestController.class})
public class ExceptionAdvice extends ResponseEntityExceptionHandler {

    @ExceptionHandler
    public ResponseEntity<Object> validation(ConstraintViolationException e, WebRequest request) {
        String errorMessage = e.getConstraintViolations().stream()
                .map(constraintViolation -> constraintViolation.getMessage())
                .findFirst()
                .orElseThrow(() -> new RuntimeException("ConstraintViolationException 추출 도중 에러 발생"));

        return handleExceptionInternalConstraint(e, ErrorStatus.valueOf(errorMessage), HttpHeaders.EMPTY, request);
    }

    @Override
    public ResponseEntity<Object> handleMethodArgumentNotValid(MethodArgumentNotValidException e, HttpHeaders headers, HttpStatusCode status, WebRequest request) {
        Map<String, String> errors = new LinkedHashMap<>();

        e.getBindingResult().getFieldErrors().forEach(fieldError -> {
            String fieldName = fieldError.getField();
            String errorMessage = Optional.ofNullable(fieldError.getDefaultMessage()).orElse("");
            errors.merge(fieldName, errorMessage, (existing, newMsg) -> existing + ", " + newMsg);
        });

        return handleExceptionInternalArgs(e, HttpHeaders.EMPTY, ErrorStatus._BAD_REQUEST, request, errors);
    }

    @ExceptionHandler
    public ResponseEntity<Object> exception(Exception e, WebRequest request) {
        e.printStackTrace();
        return handleExceptionInternalFalse(e, ErrorStatus._INTERNAL_SERVER_ERROR, HttpHeaders.EMPTY, ErrorStatus._INTERNAL_SERVER_ERROR.getHttpStatus(), request, e.getMessage());
    }

    @ExceptionHandler(value = GeneralException.class)
    public ResponseEntity onThrowException(GeneralException generalException, HttpServletRequest request) {
        ErrorReasonDTO errorReasonHttpStatus = generalException.getErrorReasonHttpStatus();
        return handleExceptionInternal(generalException, errorReasonHttpStatus, null, request);
    }

    private ResponseEntity<Object> handleExceptionInternal(Exception e, ErrorReasonDTO reason, HttpHeaders headers, HttpServletRequest request) {
        ApiResponse<Object> body = ApiResponse.onFailure(reason.getCode(), reason.getMessage(), null);
        WebRequest webRequest = new ServletWebRequest(request);
        return super.handleExceptionInternal(e, body, headers, reason.getHttpStatus(), webRequest);
    }

    private ResponseEntity<Object> handleExceptionInternalFalse(Exception e, ErrorStatus errorCommonStatus, HttpHeaders headers, HttpStatus status, WebRequest request, String errorPoint) {
        ApiResponse<Object> body = ApiResponse.onFailure(errorCommonStatus.getCode(), errorCommonStatus.getMessage(), errorPoint);
        return super.handleExceptionInternal(e, body, headers, status, request);
    }

    private ResponseEntity<Object> handleExceptionInternalArgs(Exception e, HttpHeaders headers, ErrorStatus errorCommonStatus, WebRequest request, Map<String, String> errorArgs) {
        ApiResponse<Object> body = ApiResponse.onFailure(errorCommonStatus.getCode(), errorCommonStatus.getMessage(), errorArgs);
        return super.handleExceptionInternal(e, body, headers, errorCommonStatus.getHttpStatus(), request);
    }

    private ResponseEntity<Object> handleExceptionInternalConstraint(Exception e, ErrorStatus errorCommonStatus, HttpHeaders headers, WebRequest request) {
        ApiResponse<Object> body = ApiResponse.onFailure(errorCommonStatus.getCode(), errorCommonStatus.getMessage(), null);
        return super.handleExceptionInternal(e, body, headers, errorCommonStatus.getHttpStatus(), request);
    }
}

주요 메서드 설명

1. validation(): ConstraintViolationException 처리

   • 유효성 검사 실패 시 발생하는 예외를 처리하고, 표준화된 응답을 반환합니다.

2. handleMethodArgumentNotValid(): MethodArgumentNotValidException 처리

   • 메서드 인자의 유효성 검사가 실패할 경우, 필드별 에러 메시지를 수집해 반환합니다.

3. exception(): 일반 예외 처리

   • 예상치 못한 예외를 포괄적으로 처리하여 클라이언트에게 서버 에러 메시지를 반환합니다.

4. onThrowException(): 사용자 정의 예외 처리

   • GeneralException을 처리하여, 비즈니스 로직에 따라 커스텀 응답을 생성합니다.

5. handleExceptionInternal(): 기본 예외 응답 생성

   • 표준화된 JSON 응답을 생성합니다.

예시 JSON 응답

{
  "success": false,
  "code": "MEMBER4001",
  "message": "사용자가 없습니다.",
  "data": null
}

2-3. 실제로 에러가 처리를 구현하는 과정 예시

GET /temp/exception 요청에 대한 예외 처리 구현 과정을 예시로 살펴봅시다. 이 API는 Query String으로 flag를 받아오며, flag 값이 2일 경우 Exception을 발생시킵니다.

1. ErrorStatus에 새로운 경우 추가하기

ErrorStatus에 테스트용 에러 상태를 추가합니다.

// For test
TEMP_EXCEPTION(HttpStatus.BAD_REQUEST, "TEMP4001", "이거는 테스트");

2. Temp 핸들러 추가하기

handler 패키지에 TempHandler 클래스를 생성합니다. 이 클래스는 GeneralException을 상속받습니다.

public class TempHandler extends GeneralException {

    public TempHandler(BaseErrorCode errorCode) {
        super(errorCode);
    }
}

TempHandler는 테스트용 예외를 처리하기 위해 작성되었고, 부모 클래스의 생성자를 호출해 에러 코드를 전달합니다.

3. TempResponse DTO 추가하기

TempResponse 클래스는 예외와 테스트 응답 데이터를 포함합니다.

public class TempResponse {

    @Builder
    @Getter
    @NoArgsConstructor
    @AllArgsConstructor
    public static class TempTestDTO {
        String testString;
    }

    @Builder
    @Getter
    @NoArgsConstructor
    @AllArgsConstructor
    public static class TempExceptionDTO {
        Integer flag;
    }
}

• TempTestDTO: 테스트 API 응답 데이터.
• TempExceptionDTO: 예외 발생 시 전달되는 데이터.

4. TempConverter 작성하기

TempConverter는 DTO를 생성하는 정적 메서드를 제공합니다. 이를 통해 TempResponse DTO를 생성해서 반환합니다.

public class TempConverter {

    public static TempResponse.TempTestDTO toTempTestDTO() {
        return TempResponse.TempTestDTO.builder()
                .testString("This is Test!")
                .build();
    }

    public static TempResponse.TempExceptionDTO toTempExceptionDTO(Integer flag) {
        return TempResponse.TempExceptionDTO.builder()
                .flag(flag)
                .build();
    }
}

• toTempTestDTO: 테스트 응답 객체 생성.
• toTempExceptionDTO: 예외 발생 시 전달할 DTO 생성.

5. Controller 작성하기

TempRestController는 @RestController를 사용하여 API 요청을 처리합니다.

@RestController
@RequestMapping("/temp")
@RequiredArgsConstructor
public class TempRestController {

    @GetMapping("/test")
    public ApiResponse<TempResponse.TempTestDTO> testAPI() {
        return ApiResponse.onSuccess(TempConverter.toTempTestDTO());
    }

    @GetMapping("/exception")
    public ApiResponse<TempResponse.TempExceptionDTO> exceptionAPI(@RequestParam Integer flag) {
        return null;
    }
}

• @RequestParam을 통해 Query String에서 값을 받아옵니다.
• /test API는 테스트 데이터를 반환합니다.
• /exception API는 서비스 로직과 연동됩니다.

이때, RestControllerAdvice를 통해 @RestController가 붙은 대상에서 Exception이 발생하는 것을 감지하게 됩니다.

6. Service 작성하기

🥕서비스 설계 원칙 1. GET 요청과 나머지 요청의 로직을 분리합니다. - GET 요청: TempQueryService. - 기타 요청: TempCommandService. 2. 인터페이스를 먼저 정의한 뒤 구체화 클래스를 작성합니다. - 인터페이스: TempQueryService. - 구현체: TempQueryServiceImpl. 3. 컨트롤러는 인터페이스에 의존하며, Spring의 의존성 주입을 통해 구현체를 주입받습니다.

TempQueryService 인터페이스

public interface TempQueryService {

    void checkFlag(Integer flag);
}

TempQueryServiceImpl 구현체

@Service
@RequiredArgsConstructor
public class TempQueryServiceImpl implements TempQueryService {

    @Override
    public void checkFlag(Integer flag) {
        if (flag == 1)
            throw new TempHandler(ErrorStatus.TEMP_EXCEPTION);
    }
}

• checkFlag: flag 값이 1인 경우 TempHandler 예외를 던집니다.

7. Controller 완성하기

TempRestController의 /exception API를 완성합니다.

@RestController
@RequestMapping("/temp")
@RequiredArgsConstructor
public class TempRestController {

    private final TempQueryService tempQueryService;

    @GetMapping("/test")
    public ApiResponse<TempResponse.TempTestDTO> testAPI() {
        return ApiResponse.onSuccess(TempConverter.toTempTestDTO());
    }

    @GetMapping("/exception")
    public ApiResponse<TempResponse.TempExceptionDTO> exceptionAPI(@RequestParam Integer flag) {
        tempQueryService.checkFlag(flag);
        return ApiResponse.onSuccess(TempConverter.toTempExceptionDTO(flag));
    }
}

tempQueryService.checkFlag(flag)를 호출하여 예외 발생 여부를 확인하고, 예외가 발생하지 않으면 DTO를 반환합니다.

위 과정을 따라 에러가 처리되는 과정

1. Service에서 예외 발생 TempQueryServiceImpl의 checkFlag 메서드에서 flag 값이 1인 경우 TempHandler를 통해 예외를 발생시킵니다.

   @Override
   public void checkFlag(Integer flag) {
       if (flag == 1)
           throw new TempHandler(ErrorStatus.TEMP_EXCEPTION);
   }

2. ExceptionAdvice에서 예외 처리 TempHandler는 GeneralException을 상속받기 때문에 @RestControllerAdvice에 등록된 ExceptionAdvice가 예외를 처리합니다.

   @ExceptionHandler(value = GeneralException.class)
   public ResponseEntity onThrowException(GeneralException generalException, HttpServletRequest request) {
       ErrorReasonDTO errorReasonHttpStatus = generalException.getErrorReasonHttpStatus();
       return handleExceptionInternal(generalException, errorReasonHttpStatus, null, request);
   }

3. 표준화된 응답 반환 handleExceptionInternal 메서드를 통해 표준화된 JSON 응답이 클라이언트로 반환됩니다.

   private ResponseEntity<Object> handleExceptionInternal(Exception e, ErrorReasonDTO reason, HttpHeaders headers, HttpServletRequest request) {
       ApiResponse<Object> body = ApiResponse.onFailure(reason.getCode(), reason.getMessage(), null);
       WebRequest webRequest = new ServletWebRequest(request);
       return super.handleExceptionInternal(e, body, headers, reason.getHttpStatus(), webRequest);
   }

4. 응답 결과 확인 클라이언트는 에러 코드와 메시지를 포함한 표준화된 응답을 받습니다.

예외 응답 예시

{
  "success": false,
  "code": "TEMP4001",
  "message": "이거는 테스트"
}

📝 정리하며

• API 응답 통일은 협업과 유지보수성을 높이는 핵심입니다.
• 에러 핸들링은 명확하고 일관된 방식으로 사용자와 개발자 모두에게 유용한 정보를 제공합니다.

🎯 다음 시간에는 오늘 배운 내용을 더 구체적인 과정으로 하나하나씩 살펴보고 실제 예제를 같이 보겠습니다!

🌟 학습 목표

1. 즉시 로딩과 지연 로딩의 전략 차이를 이해하고, 지연 로딩을 추천하는 이유를 살펴본다.
2. JPQL과 QueryDSL의 차이를 파악하고, 실제 프로젝트에서의 활용 방법을 익힌다.
3. JPA 사용 방법 및 반복 작업을 줄이는 JPA의 장점을 이해한다.

1) Spring Data JPA 영속성 컨텍스트

영속성 컨텍스트(Persistence Context)란?

영속성 컨텍스트는 JPA가 엔티티 객체를 관리하고 데이터베이스와 연동하는 가상의 메모리 공간입니다. ORM, 즉 객체와 RDB 데이터를 자동으로 매핑해주는 기능을 제공하는 JPA에서 아주 핵심적인 녀석이죠.

일종의 캐시 메모리라고 생각하시면 됩니다.

먼저 최초로 엔티티에 접근하면, DB에서 끌어온 엔티티를 영속성 컨텍스트에 등록해줍니다. 이후에 Spring Data JPA에서 Repository 인터페이스 를 통하여 같은 엔티티에 접근하면, DB에 쿼리를 날리는 게 아닌 영속성 컨텍스트에 있는 데이터를 조회하게 되는 거죠. JPA에서는 테이블과 매핑해주는 엔티티 객체를 영속성 컨텍스트를 통해 애플리케이션 내부에서 오래 지속되도록 돕습니다. JPA를 통해 데이터베이스에서 조회한 엔티티는 영속성 컨텍스트에 저장되고, 그 안에서 문맥적(contextual)으로 하나의 상태를 유지하면서, 여러 기능을 할 수 있게 하죠. 다시 말해, 애플리케이션과 데이터베이스 사이에서 데이터를 저장하는 가상의 데이터베이스 같은 역할을 합니다.

@EntityManager을 이용하여 접근합니다 ‼️

영속성 컨텍스트는 이처럼 데이터베이스 요청을 최소화해 성능을 높이고, 엔티티 변경 사항을 감지하는 등 다양한 이점을 제공합니다.

영속성 컨텍스트의 주요 장점

객체가 ‘영속’ 상태이면, 다음과 같이 크게 3가지 장점을 지닙니다.

• 1차 캐시

• 변경 감지(Dirty Checking)
• 지연 로딩(FetchType.LAZY)

즉시 로딩(FetchType.EAGER) VS 지연 로딩(FetchType.LAZY)

즉시 로딩(FetchType.EAGER)

즉시 로딩은 연관된 모든 데이터를 한 번에 가져오는 로딩 전략입니다.

• 사용 방법: @ManyToOne(fetch = FetchType.EAGER)
• 장점: 필요한 데이터를 미리 로딩해, 추가적인 쿼리 없이 사용할 수 있습니다.
• 단점: 연관된 데이터가 많을 경우 N+1 문제가 발생할 가능성이 높습니다.

지연 로딩(FetchType.LAZY)

지연 로딩은 실제로 데이터가 필요할 때 DB에서 가져오는 로딩 전략입니다.

• 사용 방법: @ManyToOne(fetch = FetchType.LAZY)
• 장점: 초기 쿼리 수를 최소화해 성능 최적화를 이룰 수 있습니다.
• 단점: 데이터 접근 시마다 추가적인 쿼리가 발생할 수 있어 주의가 필요합니다.
• 🌟 지연 로딩은 DB가 아닌 프록시에서 데이터를 가져옵니다‼️*

지연 로딩은 MemberPrefer과 Member, FoodCategory이 각각 분리되어 MemberPrefer은 DB를, Member 및 FoodCategory 은 프록시를 조회합니다.

@Entity
@Getter
@Builder
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor
public class MemberPrefer extends BaseEntity {

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

    **@ManyToOne(fetch = FetchType.LAZY)**
    @JoinColumn(name = "member_id")
    private Member member;

    **@ManyToOne(fetch = FetchType.LAZY)**
    @JoinColumn(name = "category_id")
    private FoodCategory foodCategory;

}

즉, MemberPrefer을 조회할 때, Member과 FoodCategory 를 굳이 조회할 필요가 없다면 분리하여 조회하는 지연 로딩 방법을 사용합시다👍

즉시 로딩과 지연 로딩의 비교

N+1 문제란?

즉시 로딩에서 발생할 수 있다는 N+1 문제는 뭘까요?

문제 정의

N+1 문제는 하나의 메인 쿼리로 N개의 데이터를 가져온 뒤, 각 데이터에 대해 N개의 추가 쿼리가 실행되는 문제입니다.
RDB와 객체 지향의 패러다임 간극에 의해 발생하는 문제인데, 1개의 쿼리를 실행한 후에, 관련된 N개의 데이터를 각각 가져오기 위해 추가적으로 N번의 불필요한 쿼리가 실행되어 성능 저하가 발생합니다.

해결 방법

2) JPQL: 객체 지향 쿼리 언어

JPQL이란?

JPQL(Java Persistence Query Language)은 JPA 엔티티 객체를 대상으로 작성하는 쿼리 언어입니다.

• SQL과 유사하지만, 데이터베이스 테이블이 아닌 엔티티 객체를 사용하여 쿼리를 작성합니다.
• 즉, JPQL은 데이터베이스와 상호작용한다는 기본 컨셉은 유지하되, 객체 지향적인 특성을 반영하여 작성할 수 있는 것이 가장 큰 특징입니다.

JPQL 사용 방법

JPQL을 사용하는 방법에는 두 가지가 있습니다:

[1] EntityManager 인터페이스
[2] Spring Data JPA의 Repository 인터페이스

[1] EntityManager 인터페이스를 통한 JPQL 사용

EntityManager란?

• JPA의 핵심 인터페이스로, 엔티티를 관리하고 JPQL 쿼리를 실행하는 데 사용됩니다.
• Native SQL과 병행 사용이 가능하며, 트랜잭션 관리와 엔티티 작업 관리에 탁월합니다.

기본 사용 예시

// EntityManager 생성 및 트랜잭션 시작
EntityManager em = entityManagerFactory.createEntityManager();
em.getTransaction().begin();

// JPQL 쿼리 작성
String jpql = "SELECT m FROM Member m WHERE m.name = :name";
TypedQuery<Member> query = em.createQuery(jpql, Member.class);
query.setParameter("name", "Alice");

// 결과 리스트로 받기
List<Member> members = query.getResultList();
for (Member member : members) {
    System.out.println("Member Name: " + member.getName());
}

// 트랜잭션 종료
em.getTransaction().commit();
em.close();

주요 메서드

• createQuery(String jpql, Class<T> resultClass): JPQL 쿼리를 작성하고 실행합니다.
• setParameter(String name, Object value): JPQL 쿼리에서 사용할 파라미터를 설정합니다.
• getResultList(): 결과를 리스트로 반환합니다.
• getSingleResult(): 단일 결과를 반환합니다.

업데이트/삭제 쿼리 예시

JPQL을 사용하면 업데이트나 삭제 작업도 가능합니다.

em.getTransaction().begin();

// JPQL 업데이트 쿼리
String jpql = "UPDATE Member m SET m.age = :age WHERE m.name = :name";
Query query = em.createQuery(jpql);
query.setParameter("age", 30);
query.setParameter("name", "Alice");

int rowsUpdated = query.executeUpdate(); // 업데이트된 행 수 반환
System.out.println("Rows updated: " + rowsUpdated);

em.getTransaction().commit();

[2] Repository 인터페이스를 통한 JPQL 사용

Spring Data JPA는 Repository 인터페이스를 통해 JPQL 쿼리를 간편하게 작성할 수 있습니다.
이 방법은 더 직관적이고 간결하며, Spring 환경과 잘 통합됩니다.

메서드 이름 기반 쿼리 생성

Spring Data JPA는 메서드 이름을 기반으로 JPQL 쿼리를 자동 생성합니다.

• 예시: 특정 조건에 맞는 회원을 조회하는 메서드

public interface MemberRepository extends JpaRepository<Member, Long> {
    List<Member> findByNameAndStatus(String name, MemberStatus status);
}

// 호출
List<Member> activeMembers = memberRepository.findByNameAndStatus("Alice", MemberStatus.ACTIVE);

Spring 내부 동작: 위 메서드 호출은 다음 JPQL 쿼리로 변환됩니다.

SELECT m FROM Member m WHERE m.name = 'Alice' AND m.status = 'ACTIVE';

@Query 어노테이션을 통한 JPQL 작성

더 복잡한 쿼리가 필요할 경우, @Query 어노테이션을 사용해 직접 JPQL을 작성할 수 있습니다.

public interface MemberRepository extends JpaRepository<Member, Long> {
    @Query("SELECT m FROM Member m WHERE m.name = :name AND m.status = :status")
    List<Member> findByNameAndStatus(@Param("name") String name, @Param("status") MemberStatus status);
}

장점

• 간결한 코드로 복잡한 JPQL 작성 가능.
• 메서드 이름 기반 쿼리 생성보다 더 높은 유연성 제공.

JPQL과 SQL의 차이점

JPQL 사용 시 주의사항

1. 엔티티 필드 이름을 사용

   • JPQL은 엔티티의 필드 이름을 사용하므로, 테이블 컬럼 이름이 아니라 엔티티의 필드 이름과 일치해야 합니다.
   • 예: m.name은 엔티티의 name 필드를 참조.

2. Lazy Loading과의 연관성

   • 지연 로딩이 설정된 엔티티를 JPQL로 조회할 경우, 필요 시점에 추가 쿼리가 발생할 수 있습니다.

3. 동적 쿼리 작성

   • 복잡한 조건을 가진 동적 쿼리를 작성해야 할 경우, QueryDSL과 같은 도구를 사용하는 것이 더 효율적일 수 있습니다.

3) QueryDSL: 동적 쿼리를 위한 강력한 도구

JPQL 사용으로는 작성하기 너무 복잡한 동적 쿼리를 위해서는 QueryDSL를 사용하는 게 효과적인 방법입니다.

QueryDSL이란?

QueryDSL은 코드 기반의 쿼리 빌더 라이브러리로, 타입 안전성과 동적 쿼리 작성에 강점을 가진 도구입니다.

• 타입 안전성 보장: 컴파일 시점에 쿼리 오류를 잡을 수 있어 안전합니다.
• 동적 쿼리 작성: 조건이나 구조가 실행 시점에 유동적으로 변경될 수 있는 쿼리를 쉽게 작성할 수 있습니다.
• 메서드 체이닝: 조건과 동작을 체계적으로 연결해 직관적이고 간결한 쿼리 작성이 가능합니다.

QueryDSL 사용법

1️⃣ QueryDSL 기본 설정

QueryDSL을 사용하려면 Q 클래스를 자동 생성해야 합니다. 이를 위해 build.gradle 파일에 다음 설정을 추가합니다.

plugins {
    id "com.ewerk.gradle.plugins.querydsl" version "1.0.10"
}

dependencies {
    implementation 'com.querydsl:querydsl-jpa:5.0.0:jakarta'
    annotationProcessor "com.querydsl:querydsl-apt:5.0.0:jakarta"
}
sourceSets {
    main.java.srcDir 'src/main/generated'
}

2️⃣ Q 클래스 생성

Q 클래스는 각 엔티티를 기준으로 자동 생성됩니다.
src/main/generated 폴더에 생성된 QMember 또는 QStore 등을 사용하여 QueryDSL로 쿼리를 작성합니다.

3️⃣ JPAQueryFactory 설정

QueryDSL은 JPAQueryFactory를 사용해 쿼리를 작성합니다.
JPAQueryFactory를 Bean으로 등록하려면 다음과 같은 설정이 필요합니다.

@Configuration
@RequiredArgsConstructor
public class QueryDSLConfig {
    private final EntityManager entityManager;

    @Bean
    public JPAQueryFactory jpaQueryFactory() {
        return new JPAQueryFactory(entityManager);
    }
}

4️⃣ QueryDSL로 동적 쿼리 작성

BooleanBuilder 활용

BooleanBuilder를 사용해 조건을 동적으로 추가할 수 있습니다.

private List<Store> dynamicQueryWithBooleanBuilder(String name, Float score) {
    BooleanBuilder predicate = new BooleanBuilder();

    if (name != null) {
        predicate.and(store.name.eq(name));
    }
    if (score != null) {
        predicate.and(store.score.goe(score));
    }

    return jpaQueryFactory
        .selectFrom(store)
        .where(predicate)
        .fetch();
}

• .and(): 조건 추가
• .or(): 조건 선택적으로 추가

Repository 인터페이스 구성

1. Custom Interface 생성

   public interface StoreRepositoryCustom {
       List<Store> dynamicQueryWithBooleanBuilder(String name, Float score);
   }

2. Custom 구현체 작성

   @Repository
   @RequiredArgsConstructor
   public class StoreRepositoryImpl implements StoreRepositoryCustom {
       private final JPAQueryFactory jpaQueryFactory;
       private final QStore store = QStore.store;
   
       @Override
       public List<Store> dynamicQueryWithBooleanBuilder(String name, Float score) {
           BooleanBuilder predicate = new BooleanBuilder();
   
           if (name != null) predicate.and(store.name.eq(name));
           if (score != null) predicate.and(store.score.goe(score));
   
           return jpaQueryFactory
               .selectFrom(store)
               .where(predicate)
               .fetch();
       }
   }

3. Repository 연결

   public interface StoreRepository extends JpaRepository<Store, Long>, StoreRepositoryCustom {
   }

4. Service Layer에서 호출

   @Service
   @RequiredArgsConstructor
   public class StoreQueryServiceImpl implements StoreQueryService {
       private final StoreRepository storeRepository;
   
       public List<Store> findStoresByNameAndScore(String name, Float score) {
           return storeRepository.dynamicQueryWithBooleanBuilder(name, score);
       }
   }

QueryDSL의 장단점

실습을 통한 QueryDSL 요약

1. QueryDSL 설정

   • build.gradle에 종속성 추가
   • Q 클래스 자동 생성 설정

2. JPAQueryFactory Bean 등록

   • EntityManager와 연동

3. Repository 구성

   • Custom Interface와 Custom 구현체 작성
   • 동적 쿼리를 작성해 비즈니스 로직 적용

4. Service Layer에서 활용

   • 동적 조건에 따라 유연하게 데이터를 조회하고 비즈니스 로직에 적용

정리

1. 즉시 로딩(FetchType.EAGER)은 N+1 문제를 일으킬 수 있으므로, 지연 로딩(FetchType.LAZY)을 기본으로 설정.
2. JPQL은 객체 지향 쿼리 언어로 SQL보다 객체 매핑에 적합.
3. QueryDSL은 동적 쿼리를 작성할 때 강력한 도구로 활용 가능.

```

Spring Boot와 JPA를 통해 데이터를 쉽게 저장하고 조회하며, 프로젝트의 비즈니스 로직을 깔끔하게 구현할 수 있습니다.

학습 목표 🎯

1️⃣ JPA의 개념과 필요성을 이해합니다.
2️⃣ Spring Data JPA를 사용하여 ERD 기반으로 엔티티를 설계하고 매핑합니다.

🌟 1. JPA와 Spring Data JPA란?

객체 지향 프로그래밍의 목표는 캡슐화, 상속, 다형성을 활용하여 데이터를 관리하는 것이고,
RDBMS는 데이터를 정교하게 정규화하여 저장하는 것이 목표입니다.

이 패러다임 차이로 인해 아래와 같은 문제가 발생합니다:
1️⃣ 데이터를 SQL로 저장하고,
2️⃣ SQL 결과를 자바 객체로 변환해야 하는 번거로움.

해결책

• JPA와 Spring Data JPA를 사용하여 반복 작업을 줄이고, 비즈니스 로직에만 집중합니다.

JPA(Java Persistence API)란?

JPA는 Java 진영에서 ORM(Object Relational Mapping) 기술의 표준 인터페이스입니다.
쉽게 말해, 애플리케이션의 객체를 관계형 데이터베이스(RDBMS) 테이블에 매핑해주는 기술입니다. 객체 지향적 언어인 자바는 궁극적으로 캡슐화/상속/다형성을 활용하는 것이 목표이고, RDBMS(관계형 데이터베이스)는 데이터를 정교하게 구성하는 것이 목표입니다. 두 언어가 목표가 다르기 때문에 원래는 개발자가 이를 하나하나 Mapping 해줘야 합니다. 이를 해결하기 위해 JPA가 사용됩니다!

ORM(Object Relational Mapping)이란?

객체 지향 언어와 관계형 데이터베이스 간의 불일치를 해결하는 기술입니다. 기술적인 측면에서는 애플리케이션의 객체를 RDB 클래스에 자동으로 연결시켜준다고 보시면 됩니다. 즉, 반복적인 CRUD SQL 쿼리문을 굳이 짤 필요 없이 자동으로 매핑하여 날려준다고 생각하시면 됩니다👍👍

• 객체: 자바에서 클래스를 통해 데이터를 관리.
• RDBMS: 테이블과 컬럼을 기반으로 데이터를 저장.

JPA는 SQL 작성 없이도 객체와 테이블 간의 변환을 자동으로 처리하여 개발자의 생산성을 높입니다.

🛠️ Spring Data JPA란?

Spring Data JPA는 JPA를 더 간편하게 사용할 수 있도록 지원하는 스프링 모듈입니다.

• CRUD 쿼리 자동 생성: 단순한 쿼리는 메서드 선언만으로 자동 생성.
• JPQL 지원: 복잡한 쿼리도 쉽게 작성 가능.
• Repository 기반 개발: 데이터베이스와의 상호작용을 추상화.

✏️ 2. 프로젝트 구조 설계

🏗️ 프로젝트 디렉토리 구조

Spring Boot 프로젝트는 아래와 같은 디렉토리 구조를 권장합니다.
이 디렉토리 구조는 모듈화와 유지보수성을 높이기 위해 설계되었습니다.

src/main/java
│
├── controller        // HTTP 요청/응답 처리
├── service           // 비즈니스 로직
├── repository        // DB 접근 로직
├── domain            // Entity 클래스
├── dto               // 데이터 전송 객체
└── base              // 공통 클래스 (e.g., BaseEntity)

디렉토리 역할 설명

1. controller

   • 사용자의 요청을 받아 처리하고, 결과를 응답으로 반환하는 계층입니다.
   • Spring MVC의 핵심 구성요소로 @RestController 또는 @Controller를 주로 사용합니다.
   • 예: 로그인 요청, 회원가입 요청 등을 처리.

2. service

   • 비즈니스 로직을 처리하는 계층입니다.
   • Controller에서 받은 요청을 기반으로 데이터를 가공하거나, 여러 Repository를 조합해 복잡한 작업을 처리합니다.
   • 예: 회원 가입 시 이메일 중복 체크와 데이터 저장 처리.

3. repository

   • 데이터베이스와의 직접적인 상호작용을 담당하는 계층입니다.
   • Spring Data JPA의 JpaRepository를 확장해 사용하며, CRUD 작업을 간편하게 처리할 수 있습니다.

4. domain

   • 데이터베이스의 테이블과 1:1로 매핑되는 Entity 클래스들이 위치합니다.
   • JPA에서 사용되는 주요 어노테이션(@Entity, @Id, @GeneratedValue 등)을 사용합니다.
   • 예: User, Order, Product 등 주요 데이터를 표현.

5. dto

   • 클라이언트와의 데이터 교환을 위한 객체(Data Transfer Object)입니다.
   • Entity와 달리 특정 요청이나 응답에 필요한 데이터만 포함합니다.
   • Entity 변경 시 클라이언트에 영향을 주지 않도록 데이터 전달을 추상화하는 역할을 합니다.

6. base

   • 모든 Entity에서 공통으로 사용할 필드나 기능을 정의합니다.
   • 예: 생성일(created_at), 수정일(updated_at) 등을 처리하는 BaseEntity.

1️⃣ Entity 설계 및 매핑

엔티티(Entity)란?

• 엔티티는 데이터베이스의 테이블과 1:1로 매핑되는 클래스입니다.
• JPA를 사용하면 엔티티 클래스를 통해 SQL 없이 데이터베이스 작업을 수행할 수 있습니다.
• Entity 클래스는 주로 데이터의 상태와 관계를 표현합니다.

ERD 기반 설계

ERD(Entity Relationship Diagram)란?

• ERD는 데이터베이스 테이블 간의 관계를 시각적으로 표현한 다이어그램입니다.
• JPA를 사용하여 엔티티를 설계하기 전, ERD를 기반으로 테이블 구조를 정의합니다.
• 예제 ERD:
  

Member 엔티티 예제

@Entity
@Getter
@Builder
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor
public class Member extends BaseEntity {

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

    @Column(nullable = false, length = 20)
    private String name;

    @Enumerated(EnumType.STRING)
    private Gender gender;

    @Column(nullable = false)
    private String email;
}

*주요 어노테이션 설명 *

1. @Entity

   • JPA가 관리할 클래스임을 명시.
   • 데이터베이스 테이블로 매핑됩니다.

2. @Id

   • 기본 키(primary key)를 설정합니다.
   • 모든 엔티티 클래스에는 반드시 하나의 기본 키가 있어야 합니다.

3. @GeneratedValue

   • 기본 키의 값을 자동으로 생성하도록 설정합니다.
   • GenerationType.IDENTITY: MySQL의 AUTO_INCREMENT처럼 자동 증가하도록 설정.

4. @Column

   • 테이블 컬럼의 속성을 설정합니다.
   • 예: nullable = false로 필수 입력 값을 설정하거나, length로 문자열 길이를 제한.

5. @Enumerated

   • Enum 타입을 데이터베이스에 저장하기 위한 설정입니다.
   • EnumType.STRING: Enum 값을 문자열로 저장합니다.
   • EnumType.ORDINAL은 Enum의 순서를 저장하지만, 값 변경 시 오류가 발생할 수 있으므로 사용하지 않습니다.

2️⃣BaseEntity로 공통 필드 처리

공통 필드 처리 예제

모든 테이블에서 공통적으로 사용하는 생성일자와 수정일자를 관리하기 위해 BaseEntity를 작성합니다.

@MappedSuperclass
@EntityListeners(AuditingEntityListener.class)
@Getter
public abstract class BaseEntity {

    @CreatedDate
    private LocalDateTime createdAt;

    @LastModifiedDate
    private LocalDateTime updatedAt;
}

*주요 어노테이션 설명 *

1. @MappedSuperclass

   • 이 클래스의 필드를 상속받는 엔티티에서 사용할 수 있도록 설정합니다.

2. @EntityListeners(AuditingEntityListener.class)

   • Spring Data JPA에서 제공하는 감사(Auditing) 기능을 활성화합니다.

3. @CreatedDate, @LastModifiedDate

   • 데이터 생성 및 수정 시간을 자동으로 기록합니다.

3️⃣ 연관관계 매핑

단방향 연관관계: Member와 MemberPrefer

@Entity
@Getter
@Builder
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor
public class MemberPrefer extends BaseEntity {

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

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "member_id")
    private Member member;
}

*주요 어노테이션 설명 *

1. @ManyToOne

   • 다대일(N:1) 관계를 설정합니다.
   • 예: 여러 MemberPrefer가 하나의 Member에 연결됩니다.

2. @JoinColumn

   • 외래 키 이름을 명시합니다.

3. fetch = FetchType.LAZY

   • 지연 로딩 설정: 필요한 시점에 연관된 데이터를 가져옵니다.
   • 성능 최적화를 위해 기본값인 LAZY를 사용합니다.

양방향 연관관계 설정

양방향 연관관계는 객체 지향적인 설계에서 중요한 역할을 합니다.
데이터베이스 설계에서는 단방향 연관관계만으로도 모든 데이터 처리가 가능하지만,
JPA에서는 양방향 연관관계를 설정함으로써 추가적인 이점을 얻을 수 있습니다.

양방향 연관관계란?

양방향 매핑은 두 엔티티가 서로를 참조하는 관계를 의미합니다.

• 예: Member 엔티티는 MemberPrefer를 참조하고,
• MemberPrefer 엔티티는 다시 Member를 참조.

이러한 구조를 통해 데이터베이스의 데이터를 JPA가 관리하는 객체 그래프 탐색을 쉽게 할 수 있습니다.
즉, Member 객체를 통해 관련된 MemberPrefer 객체들을 탐색하거나,
반대로 MemberPrefer에서 Member를 탐색할 수 있습니다.

양방향 매핑의 장점

1️⃣ 객체 그래프 탐색 가능

• 예: member.getMemberPreferList()와 같이 한쪽 엔티티에서 관련된 엔티티들을 쉽게 탐색할 수 있습니다.
• 객체 지향적인 코드 작성이 가능하며, 데이터 간 관계를 명확히 표현할 수 있습니다.

2️⃣ Cascade 설정 가능

• Cascade는 부모 엔티티의 변경이 자식 엔티티에도 자동으로 적용되도록 설정하는 기능입니다.
• 예: Member 삭제 시, 연관된 MemberPrefer 엔티티도 자동으로 삭제되도록 설정할 수 있습니다.

3️⃣ 편리한 데이터 삭제 및 관리

• 양방향 매핑이 없으면, 연관된 데이터를 수동으로 삭제하거나 관리해야 하는 번거로움이 있습니다.
• Cascade 설정을 통해 부모와 자식 엔티티 간 데이터 관리의 편의성을 높입니다.

Cascade와 연관관계의 주인 문제 💥

데이터베이스에서는 Cascade 설정이 외래키(Foreign Key)를 소유한 테이블(연관관계의 주인)에 적용됩니다.
하지만 JPA에서는 Cascade 설정을 연관관계의 주인이 아닌 엔티티에서 설정해야 합니다.

이 점에서 JPA의 Cascade 설정은 단방향 매핑만으로는 올바르게 동작하지 않을 수 있는 문제를 포함하고 있습니다.

단방향 매핑 상태에서 Cascade를 설정할 경우:

• 참조를 하는 쪽(자식 엔티티)에서 Cascade가 잘못 동작하여,
  자식 엔티티 삭제 시 부모 엔티티가 함께 삭제되는 문제가 발생할 수 있습니다.

예를 들어:

• Member를 참조하는 MemberPrefer가 삭제될 때,
• Member도 함께 삭제되는 의도치 않은 상황이 발생할 수 있습니다.

올바른 Cascade 적용을 위한 양방향 매핑

양방향 매핑을 사용하면 JPA가 연관관계의 전체 흐름을 명확히 이해하고, Cascade를 올바르게 처리할 수 있습니다.

@Entity
public class Member {

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

    @OneToMany(mappedBy = "member", cascade = CascadeType.ALL, orphanRemoval = true)
    private List<MemberPrefer> memberPreferList = new ArrayList<>();

    public void addMemberPrefer(MemberPrefer memberPrefer) {
        memberPrefer.setMember(this);
        memberPreferList.add(memberPrefer);
    }

    public void removeMemberPrefer(MemberPrefer memberPrefer) {
        memberPreferList.remove(memberPrefer);
        memberPrefer.setMember(null);
    }
}

1. Cascade 설정

   • 부모 엔티티(Member) 삭제 시 자식 엔티티(MemberPrefer)도 함께 삭제됩니다.
   • CascadeType.ALL: 부모 엔티티의 모든 변경사항(저장, 삭제 등)이 자식 엔티티에도 적용됩니다.

2. Orphan Removal 설정

   • 부모와의 관계가 끊어진 자식 엔티티를 자동으로 삭제합니다.
   • 예: memberPreferList.remove(memberPrefer)를 호출하면 해당 자식 엔티티가 삭제됩니다.

3. 연관관계 편의 메서드 추가

   • 양방향 매핑에서는 연관관계 편의 메서드를 추가하여 양쪽 엔티티의 상태를 동기화해야 합니다.
   • 위 예제에서 addMemberPrefer()와 removeMemberPrefer()가 이에 해당합니다.
   • 예: member.addMemberPrefer(memberPrefer)를 호출하면,
     memberPrefer.setMember(member)도 자동으로 호출되어 양쪽 관계가 일치하게 됩니다.

양방향 매핑 시 주의점

1️⃣ 무한 루프 방지

• 양방향 매핑에서는 한쪽에서 다른 쪽을 참조하는 형태로 무한 루프가 발생할 수 있습니다.
• 예: Member → MemberPrefer → 다시 Member로 계속 참조.
• 해결 방법: @JsonIgnore 또는 DTO를 사용해 필요 이상의 데이터 참조를 차단합니다.

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "member_id")
@JsonIgnore
private Member member;

2️⃣ Cascade 설정 남용 금지

• Cascade는 부모-자식 관계에서만 사용하는 것이 바람직합니다.
• 서로 독립적인 엔티티 간에 Cascade를 설정하면 데이터 누락이나 불필요한 삭제가 발생할 수 있습니다.

3️⃣ 비즈니스 로직과의 협의

• 특정 연관관계를 Cascade로 처리할지 여부는 기획 단계에서 결정해야 합니다.
• 예: 회원 탈퇴 시 회원의 모든 게시글을 삭제할지 남겨둘지 기획자와 논의 필요.
  • 에브리타임 같은 서비스에서는 탈퇴해도 게시글이 삭제되지 않는 경우가 많습니다.

3️⃣ 칼럼 별 세부적인 설정

엔티티의 각 멤버 변수는 데이터베이스의 컬럼과 매핑되며, 이때 컬럼의 속성을 정확히 정의해야 합니다.
이를 통해 JPA가 테이블을 올바르게 생성하고 관리할 수 있습니다.

1) 칼럼 설정의 필요성

기본적으로 JPA는 엔티티 필드의 타입과 속성을 기반으로 데이터베이스 컬럼을 생성합니다.
예를 들어, String 타입의 필드는 데이터베이스에서 VARCHAR로 매핑됩니다.
하지만, 필드의 길이, 유니크 여부, 기본값 등 추가적인 제약 조건은 명시적으로 설정해야 합니다.

• 문제점
  JPA를 사용할 때 별도의 설정 없이 String name 필드를 생성하면,
  기본적으로 데이터베이스에서는 VARCHAR(255)로 처리됩니다.
  하지만, 실제 요구사항에서는 name 칼럼의 최대 길이가 20자로 제한되어야 할 수 있습니다.

2) @Column 어노테이션

JPA에서는 @Column 어노테이션을 사용하여 칼럼의 속성을 상세히 정의할 수 있습니다.

@Column(
    name = "name",            // 데이터베이스 컬럼명 (기본값: 필드명과 동일)
    nullable = false,         // NOT NULL 제약 조건
    unique = true,            // UNIQUE 제약 조건
    length = 20               // VARCHAR 길이 제한
)
private String name;

3) 주요 속성

1️⃣ name

• 데이터베이스 컬럼명을 지정합니다.
• 기본값은 필드명과 동일하지만, 필요에 따라 별도의 이름을 지정할 수 있습니다.

  @Column(name = "member_name")
  private String name;

2️⃣ nullable

• 해당 필드가 NULL을 허용하는지 여부를 설정합니다.
• 기본값은 true로 설정되며, nullable = false로 지정하면 데이터베이스에 NOT NULL 제약 조건이 추가됩니다.

  @Column(nullable = false)
  private String email;  // NOT NULL

3️⃣ unique

• 해당 컬럼에 고유 제약 조건(UNIQUE)을 추가합니다.
• 동일한 값이 중복 저장되지 않도록 보장합니다.

  @Column(unique = true)
  private String email;  // UNIQUE

4️⃣ length

• 문자열 필드의 최대 길이를 지정합니다.
• 데이터베이스에서 VARCHAR 또는 CHAR 타입의 길이를 제한하는 역할을 합니다.

  @Column(length = 50)
  private String address;

5️⃣ columnDefinition

• SQL을 직접 작성하여 데이터베이스 컬럼 정의를 세밀하게 조정할 수 있습니다.
• 기본값을 설정하거나 데이터 타입을 명시적으로 지정할 때 유용합니다.

  @Column(columnDefinition = "VARCHAR(20) DEFAULT 'UNKNOWN'")
  private String status;

6️⃣ insertable, updatable

• 해당 칼럼이 INSERT 또는 UPDATE 쿼리에 포함될지 여부를 설정합니다.

  @Column(insertable = false, updatable = false)
  private LocalDateTime createdAt;  // 자동 생성/수정 필드로 직접 변경 불가

예제: Member 엔티티의 세부 설정

@Entity
@Getter
@NoArgsConstructor
@AllArgsConstructor
public class Member {

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

    @Column(nullable = false, length = 20)
    private String name;  // 이름은 반드시 입력해야 하며, 최대 길이는 20자

    @Column(nullable = false, unique = true)
    private String email;  // 이메일은 고유하고 반드시 입력해야 함

    @Column(columnDefinition = "VARCHAR(10) DEFAULT 'ACTIVE'")
    private String status;  // 기본값은 'ACTIVE'

    @Column(updatable = false)
    private LocalDateTime createdAt;  // 생성 시에만 값 설정 가능

    @Column(nullable = true)
    private String phoneNumber;  // 전화번호는 입력하지 않아도 됨
}

결과적으로 생성되는 테이블 스키마 (MySQL 기준)

CREATE TABLE member (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    name VARCHAR(20) NOT NULL,
    email VARCHAR(255) NOT NULL UNIQUE,
    status VARCHAR(10) DEFAULT 'ACTIVE',
    created_at DATETIME,
    phone_number VARCHAR(255)
);

주의사항

1️⃣ length 기본값

• @Column의 length 속성을 지정하지 않으면 기본값은 255로 설정됩니다.
• 요구사항에 맞게 항상 적절한 길이를 지정해야 효율적인 테이블 설계가 가능합니다.

2️⃣ nullable과 기본값 충돌

• nullable = false와 columnDefinition의 DEFAULT 값은 함께 사용할 때 주의해야 합니다.
• 데이터베이스는 DEFAULT 값을 설정하더라도, JPA는 이를 인지하지 못하므로 삽입 시 명시적으로 값을 설정해야 합니다.

3️⃣ columnDefinition 사용 시 의존성

• columnDefinition은 데이터베이스에 강하게 의존하므로, 다중 데이터베이스 환경에서는 호환성 문제가 발생할 수 있습니다.
• 가능한 경우 JPA 표준 어노테이션을 사용하는 것이 권장됩니다.

4️⃣ Application.yml 설정

Spring Boot 애플리케이션에서 데이터베이스 및 JPA 설정을 관리하는 파일은 application.yml입니다.
이 파일을 통해 데이터베이스 연결 정보와 JPA 동작 방식을 설정할 수 있습니다.

예제: 데이터베이스 설정

spring:
  datasource:
    url: jdbc:mysql://localhost:3306/study   # 연결할 데이터베이스 URL
    username: your_username                 # 데이터베이스 사용자명
    password: your_password                 # 데이터베이스 비밀번호
  jpa:
    hibernate:
      ddl-auto: update                      # 엔티티 변경 시 테이블 자동 업데이트
    show-sql: true                          # 실행되는 SQL 쿼리를 출력

주요 설정 설명

1️⃣ spring.datasource.url

• 애플리케이션이 연결할 데이터베이스의 주소를 설정합니다.

  • jdbc:mysql://localhost:3306/study: MySQL 데이터베이스 study에 연결.
  • localhost 대신 클라우드 DB를 사용하면 해당 주소를 입력합니다.
  • 포트 번호(3306)는 MySQL 기본 포트입니다.

  spring:
    datasource:
      url: jdbc:mysql://aws-db-instance:3306/study

2️⃣ spring.jpa.hibernate.ddl-auto

• 엔티티의 변경 사항이 데이터베이스 테이블에 반영되는 방식을 설정합니다.

  • update: 엔티티 변경 사항을 반영해 테이블 구조를 자동으로 수정.
  • validate: 엔티티와 테이블의 스키마를 비교해 일치 여부만 확인.
  • none: 테이블 생성 및 수정 작업을 수행하지 않음.

  💡 권장 사항

  • 개발 환경: update (편리한 수정 작업을 위해)
  • 운영 환경: validate 또는 none (데이터 손실 방지)

3️⃣ spring.jpa.show-sql

• 실행되는 SQL 쿼리를 콘솔에 출력합니다.
• 디버깅과 테스트 시 유용하며, 복잡한 쿼리 작성 시 쿼리 최적화에 도움을 줍니다.

  spring:
    jpa:
      show-sql: true

추가 옵션

1️⃣ spring.jpa.properties.hibernate.format_sql

• SQL 쿼리를 가독성이 높게 포맷팅하여 출력합니다.

  spring:
    jpa:
      properties:
        hibernate.format_sql: true

2️⃣ 데이터베이스 연결 풀 설정 (HikariCP)

• Spring Boot는 기본적으로 HikariCP를 데이터베이스 연결 풀로 사용합니다.
• 연결 풀 크기 등을 설정할 수 있습니다.

  spring:
    datasource:
      hikari:
        maximum-pool-size: 10  # 최대 연결 수
        minimum-idle: 5        # 최소 유휴 연결 수

3️⃣ 데이터베이스 드라이버 설정

• 데이터베이스에 맞는 드라이버 클래스를 명시적으로 설정할 수 있습니다.

  spring:
    datasource:
      driver-class-name: com.mysql.cj.jdbc.Driver

환경별 설정 관리

운영 환경과 개발 환경에 따라 설정을 분리하려면 application-{profile}.yml 파일을 사용합니다.
예: application-dev.yml (개발 환경), application-prod.yml (운영 환경).

spring:
  profiles:
    active: dev

정리

이번 시간에는 지금까지 배웠던 내용을 바탕으로 스프링 프로젝트를 시작하는 과정과 틀에 대해 배워봤습니다. 이제 혼자서도 스프링 프로젝트를 만들어낼 수 있게 된 겁니다!!!(와~~) 다음 시간에는 JPA를 더 구체적으로 살펴보면서 오늘 배운 내용의 심화 버전을 배워보겠습니다!🤗😊😁

목차

1. 다음 달 예산 짜기: 메인 기능 소개
2. 더미 데이터와 모범 답안 구성
3. GPT Playground에서 프롬프트 작성하기
4. Temperature, Top-p, Penalty 설정 이해하기
5. 구현된 로직을 gpt 프롬포트로 구현하기
6. 결론 및 최적화 팁

1. 다음 달 예산 짜기: 메인 기능 소개

저희 팀 '탐탐'은 일정을 고려해 자동으로 사용자 맞춤화 가계부 서비스를 졸업프로젝트로 디벨롭하고 있습니다. 여기서 구현하고자 하는 메인 기능 중 하나는 사용자 데이터를 기반으로 사용자 맞춤화 다음 달 예산을 합리적으로 제공하고, 그렇게 예산을 짠 이유를 제공하는 거예요. 사용자가 입력한 고정 지출, 현재 예산, 다음 달 일정 등을 바탕으로, AI가 예산 항목을 자동으로 재분배해주는 거죠. 이렇게 gpt를 사용하거나 코드를 짜서 어떤 기능을 구현하고자 한다면, 자신이 구현하고자 하는 기능을 매우 구체적으로 생각해서 이 기능을 구현할 때 필요한 데이터, 어떤 로직(순서)로 기능이 구현되어야 하는지, 원하는 결과값을 생각하는 과정이 매우 중요합니다. 여러분들도 구현하고 싶은 기능이 있으시면 곰곰이 생각해보고 이를 정리해보세요!

기능 시나리오

저희가 다음달 예산을 짤 때 고려할 것들은 다음과 같습니다.

• 입력:

  • 이번 달 예산: 이번달의 총 예산과 카테고리별 예산
  • 이번 달 피드백 (예: "영화 관람에서 초과 지출"): 이번달 예산에 대한 AI 피드백 summary
  • 고정 지출: 월세, 통신비, 넷플릭스 구독료 등 사용자가 입력해놓은 매달 필수적으로 지출되어야 하는 항목들
  • 사용자 의견 (예: "기타 학원 등록하고 싶어."): 이번 달 예산 피드백을 보고 사용자가 적은 다음 달 예산에서 원하는 점을
  • 다음 달 일정 (예: "도쿄 여행 예정"): 사용자의 캘린더를 읽어와 그 중 AI를 활용해 유의미한 소비가 지출될 만한 것들을 추려놓은 데이터

• 출력: (JSON 형식)

  • 다음 달 예산
  • 예산 배정에 대한 상세 설명 및 이유

이 기능을 통해 사용자는 자신만의 생활 패턴과 목표를 고려한 개인화된 예산 관리를 경험할 수 있어요. 원래 예산을 짜려면 자신의 소비 내역을 전부 보면서 분석하고 예산을 짠 후 실천하고, 이를 피드백해서 다음 달의 일정을 고려해 직접 다음 달 예산을 짜야했다면, AI를 통해 이를 해주는 서비스를 구현할 수 있는 거죠.

2. 더미 데이터와 모범 답안 구성

GPT Playground에서 실험을 하기 전에, AI가 이해할 수 있는 데이터를 미리 준비하는 것이 중요해요. 더미 데이터는 실제 사용자 데이터처럼 구성해야 AI가 자연스럽게 작업을 수행할 수 있어서 다음과 같이 준비했습니다. 위에서 작성한 입력과 출력 데이터를 실제 데이터처럼 구성해놓았습니다. gpt는 자연어 기반의 AI이지만, JSON 형식 또한 해석할 수 있어 JSON 형식으로 데이터를 작성해주면 됩니다. 원하는 데이터 형식을 정해놓고 gpt를 사용해서 값을 채워 넣으면 효율적으로 작업할 수 있습니다.

(1) 이번 달 예산

{
  "monthly_budget": {
    "total_budget": 800000,
    "category_budgets": {
      "교육/학습": 32000,
      "교통": 80000,
      "문화/여가": 120000,
      "식비": 240000,
      "의료/건강": 56000,
      "카페/간식": 64000,
      "패션/쇼핑": 24000
    }
  }
}

(2) 이번 달 피드백

{
  "이번 달 총 예산을 잘 지키며 소비하셨네요! 특히 외식비를 관리하신 점이 돋보여요. 🎉 하지만 의류 구매와 영화 관람에서 예산을 초과한 점은 아쉬운 부분이에요. 다음 달에는 쇼핑과 여가 활동에서의 소비를 조금 줄이고, 그 절약한 금액을 다른 필요한 곳에 투자해보는 것은 어떨까요? 이렇게 하면 더 많은 저축이 가능할 거예요! 😊"
}

(3) 고정 지출

{
  "fixed_expenses": [
    {
      "name": "교통비(정기권)",
      "amount": 30000,
      "frequency": "monthly",
      "type": "교통",
      "description": "지하철/버스 정기권"
    },
    {
      "name": "구독 서비스(넷플릭스)",
      "amount": 12000,
      "frequency": "monthly",
      "type": "문화/여가",
      "description": "넷플릭스 스트리밍 구독"
    }
  ]
}

(4) 사용자 의견

"다음 달에 기타 학원(30만원)을 등록하고싶어. 그리고 식비를 줄일래."

(5) 다음 달 주요 일정

{
  "다음 달의 주요 일정": [
    {
      "이름": "지민이랑 도쿄 일정",
      "시간": "2024-12-26 ~ 2024-12-30",
      "카테고리": "여행/숙박"
    }
  ]
}

AI 응답 예시 (모범 답안)

{
  "monthly_budget": {
    "total_budget": 800000,
    "category_budgets": {
      "교육/학습": 300000,
      "교통": 30000,
      "문화/여가": 80000,
      "식비": 200000,
      "의료/건강": 56000,
      "카페/간식": 64000,
      "여행/숙박": 50000
    }
  },
  "reason": "다음 달 기타 학원 등록을 위해 교육/학습 항목에 300,000원을 배정했어요. 식비를 줄이고 싶다고 하셔서 200,000원으로 조정했답니다. 도쿄 여행을 위해 여행/숙박 항목에 50,000원을 추가 배정했어요."
}

3. GPT Playground에서 프롬프트 작성하기

GPT Playground는 OpenAI가 제공하는 프롬프트 기반 테스트 환경으로, AI 모델(GPT)의 동작 방식을 실험하고 최적화할 수 있는 도구입니다. 이 플랫폼을 사용하면 다양한 입력 데이터를 기반으로 모델의 응답을 미리 테스트하고, 하이퍼파라미터를 조정하여 원하는 결과를 얻을 수 있습니다.

3-1. GPT Playground의 주요 기능

GPT Playground는 다음과 같은 주요 기능을 제공합니다:

1. 프롬프트 설계 및 실험

   • 사용자가 작성한 프롬프트에 따라 AI의 응답을 확인.
   • 응답의 형태, 길이, 창의성 등을 실험적으로 조정 가능.

2. 모델 선택

   • OpenAI에서 제공하는 다양한 모델(GPT-4, GPT-3.5 등)을 선택해 테스트.

3. 하이퍼파라미터 조정

   • Temperature: 모델 응답의 창의성과 안정성 조정.
   • Top-p: 확률 분포 상위 후보를 선택하는 범위 제한.
   • Frequency Penalty: 단어 반복 억제.
   • Presence Penalty: 새로운 단어를 유도.

4. 출력 형식 선택

   • 응답을 텍스트, JSON, 또는 코드 형식으로 반환.

5. 컨텍스트 추가

   • 시스템 메시지를 활용하여 모델의 행동 및 역할 설정.

3-2. GPT Playground에서 설정할 수 있는 것들

(1) 모델 설정

• 모델 선택: GPT-4, GPT-3.5 등 다양한 모델을 선택.
• Max Tokens: 생성 가능한 응답의 최대 토큰 수.

(2) 하이퍼파라미터 설정

• Temperature: 낮을수록 응답이 안정적, 높을수록 창의적.
• Top-p: 확률 분포에서 상위 후보 단어만 선택.
• Frequency Penalty: 이미 사용된 단어의 반복 억제.
• Presence Penalty: 새로운 단어의 사용을 유도.

(3) 응답 형식

• 응답을 텍스트, JSON, 코드로 출력.
• 응답 길이와 스타일을 세부적으로 조정 가능.

(4) 시스템 메시지

• AI의 역할과 성격을 미리 지정하여 컨텍스트 제공. Assistant와 User의 role을 선택할 수 있기 때문에 어떤 context에서 말하는 것인지 설정을 하며 더 정확한 프롬포팅 가능.

3-3. GPT Playground에 접속하는 방법

1. OpenAI 계정 생성

   • OpenAI 홈페이지에서 계정을 생성.

2. GPT Playground 접속

   • 계정에 로그인 후, Playground 페이지로 이동. 이때, 결제를 해야지만 더 다양한 모델을 확인할 수 있다는 점을 참고하세요!

3. 환경 설정

   • 사용할 모델과 설정값(Temperature, Top-p 등)을 선택.

4. 프롬프트 작성

   • AI 모델에게 제공할 지시문을 작성하고 결과를 확인.

3-4. 왜 GPT Playground를 사용해야 하나요?

1. 빠른 테스트와 피드백: AI 모델의 응답을 실시간으로 확인.
2. 직관적 실험 환경: 코드 작성 없이 AI의 작동 방식을 실험.
3. 서비스 품질 향상: 최적화된 프롬프트를 통해 더 나은 사용자 경험 제공. 따라서 내 프롬포팅 결과를 실시간으로 보면서 설정값을 조절하고 싶을 때 GPT playground를 사용하면 좋습니다😊

효과적인 프롬프트 작성법

1. 역할 지정하기

   모델에게 역할을 주면 응답이 훨씬 명확해져요. 또한 gpt는 아직까지는 영어로 된 응답에 더 익숙하기 때문에 영어로 스크립트를 작성하는 걸 추천해요!

   예: *"너는 재무 컨설턴트야. 사용자 데이터를 분석해 예산을 추천해줘."*

    You are a financial assistant AI responsible for creating a personalized monthly budget.
    Analyze the provided data and generate a JSON budget plan.
    Explain the reasoning for allocations in Korean.
   

2. 구체적인 요구사항 전달하기

   AI가 어떤 작업을 해야 할지, 어떤 결과를 기대하는지 명확히 설명하세요.

   예: *"다음 달 예산을 짜고, 각 항목의 배정 이유를 JSON 형식으로 설명해줘."*

3. 예시 제공하기

   AI가 정확히 이해할 수 있도록 예제를 포함하세요.

   예:

    사용자 데이터:
    - 식비: 240,000원
    - 교통: 80,000원

4. 출력 형식 요청하기

   AI가 반환할 결과의 형식을 명확히 지정하세요.

   예: *"JSON 형식으로 반환해줘."*

이런 과정을 통해서 짜여진 저의 prompt는 아래와 같습니다.

You are a financial assistant AI responsible for creating a personalized monthly budget. Your task is to analyze the provided data and generate a budget plan for the next month in JSON format. Ensure the budget is tailored for 30 days (one month). Assign categories reasonably, especially for essential costs like food and living expenses. Explain the reasoning behind your allocations in detail in Korean in the `reason` field. YOU SHOULD ASSING REASONABLE BUDGET FOR SCHEDULE AND EACH CATEGORIES. 

### Inputs:
1. **This Month's Budget**: The budget allocated to each category this month. 
2. **This Month's Spending Feedback**: Feedback on whether the user overspent or underspent in various categories this month.
3. **Fixed Expenses**: Non-negotiable expenses such as rent, utilities, or loan repayments that must be covered.
4. **User's Preferences**: Specific preferences or priorities for the next month. 
   - If the user's preferences cannot be fully accommodated without exceeding the total budget or making other categories severely underfunded, partially adjust the allocations and explain the reasons clearly in the `reason` field. If you cannot make it, YOU SHOULD EXPLAIN IN THE RESON THO.
5. **Next Month's Plans**: Include additional expenses for special events, holidays, or other significant activities. You should assign reasonable amount of cost. Especially if it's travel to somewhere, you should calculate all the flight and accomodations, and food, etc. 
6. **Total Budget**: The maximum budget available for allocation next month (e.g., 800,000 KRW).

### Output Requirements:
Generate the budget in the following JSON format:
```json
{
  "monthly_budget": {
    "total_budget": 800000,
    "category_budgets": {
      "경조/선물": 0,
      "교육/학습": 0,
      "교통": 0,
      "금융": 0,
      "문화/여가": 0,
      "반려동물": 0,
      "뷰티/미용": 0,
      "생활": 0,
      "술/유흥": 0,
      "식비": 0,
      "여행/숙박": 0,
      "온라인 쇼핑": 0,
      "의료/건강": 0,
      "자녀/육아": 0,
      "자동차": 0,
      "주거/통신": 0,
      "카페/간식": 0,
      "패션/쇼핑": 0
    }
  },
  "reason": "Explain the reasoning behind the budget allocations in Korean. Example of response is like the following, 이번 달 예산은 사용자님의 생활 패턴과 피드백을 꼼꼼히 반영해서 짜 보았어요. 먼저, 필수적으로 지출해야 하는 고정비(주거/통신 150,000원, 교통 70,000원)는 꼭 필요한 만큼 먼저 배정했어요. 다음달에는 지민님이 다음 달에는 기타 학원 등록을 원하셨기 때문에 교육/학습 항목에 300,000원을 충분히 배정했어요. 지난달 식비가 조금 초과되었다고 하셔서, 충분히 여유롭게 드실 수 있도록 260,000원으로 살짝 늘렸어요. 카페/간식은 딱 적당히 사용하신 것 같아 이번에도 그대로 유지했어요. 문화/여가 쪽은 사용이 적어서 30,000원을 줄이고, 그 금액은 다른 꼭 필요한 항목에 넣었답니다. 또한, 다음 달 주말 여행을 계획하셨다고 하셔서, 여행/숙박 항목에 150,000원을 새로 배정했어요. 요청하신 다른 항목들 중에서 예산에 부담이 되는 부분은 조금 줄였지만, 최대한 반영하려 노력했답니다. 술/유흥은 특별히 많이 필요하지 않으실 것 같아 조금 줄였고, 생활비는 꼭 필요한 만큼 그대로 유지했어요. 의료/건강 항목은 정기 검진 등 필요한 비용을 고려해서 10,000원을 추가했어요. 지난 달 피드백에 따라 쇼핑에서 지출을 줄여서 다음 달 주요 일정이 여행을 위한 돈을 모아보는 건 어떻까요? 전체 예산이 800,000원을 넘지 않도록 하나하나 신경 써서 조정했으니, 다음 달도 편안하게 보내실 수 있기를 바라요. 😊" 
}

읽어보시면 role을 부여하고 각 input을 어떻게 처리해야할지, 어떤 output을 어떤 형식으로 주어야할지 매우 세세하게 지시하고 있는 걸 알 수 있습니다. 특히, gpt의 경우 같은 말이어도 어떻게 하냐에 따라 매우 다른 성능을 보이니 아래 사이트를 참고해서 프롬포트 작성에 대한 방향성을 잡아서 작성하는 것을 추천드립니다.

OPEN AI 사이트 - prompt refereneces

4. Temperature, Top-p, Penalty 설정 이해하기

이번에는 GPT Playground에서 생성형 AI 모델의 응답을 세밀하게 조정할 수 있는 하이퍼파라미터인 Temperature, Top-p, Frequency Penalty, Presence Penalty를 깊이 탐구해볼 거예요. 이 글에서는 각각의 설정이 어떻게 작동하는지, 실제 실험 데이터를 기반으로 어떤 결과를 얻을 수 있는지 하나씩 설명드리겠습니다. 아까 저희가 봤던 화면에서 보라색 사각형 부분에서 다양한 파라미터를 조절할 수 있는 부분을 확인할 수 있습니다.

1) Temperature: 창의성과 안정성의 균형

Temperature는 출력 확률 분포를 조정하여 모델의 응답에서 창의성과 예측 가능성의 균형을 맞추는 데 사용됩니다. 전체 파라미터 중 가장 먼저, 많이 조정하는 값입니다.

• 낮은 값 (0.2): 결과가 더 결정적이고 예측 가능해요.
• 높은 값 (1.0 이상): 결과가 다양하고 창의적입니다.

작동 방식 Temperature는 모델의 확률 분포를 변경해 낮은 확률의 선택지가 얼마나 고려될지를 결정합니다.

• 낮은 Temperature: 확률이 높은 선택지만 선택 → 안정적 결과.
• 높은 Temperature: 확률이 낮은 선택지도 고려 → 더 다양한 결과.

비유 Temperature는 얼음과 불 같아요.

• 낮은 Temperature는 얼음처럼 차분하고 제한적 선택.
• 높은 Temperature는 불처럼 자유롭고 다양한 선택!

실험 결과 분석

_아래의 예시들은 이번 달 소비에 대한 피드백을 위한 실험값입니다. 위에서 로직과 데이터를 어떻게 처리해야하는지를 알려드리기 위해 "다음 달 예산 짜기"를 사용했지만, 아래 gpt playground를 통한 파라미터 조정은 "이번 달 소비에 대한 피드백"이 피드백을 사용자에게 직접 제공한다는 측면에서 더 이해하시기 쉬울 거 같아 이렇게 보여드립니다! 실제로는 모든 기능에 playground를 사용해 프롬포팅을 튜닝했습니다. _

Temperature = 0.2 (낮음)

"이번 달 예산을 잘 지키셨네요. 다음 달에도 계획대로 진행하시면 좋을 것 같아요."

• 안정적이고 예측 가능한 답변. 안정적이지만, 너무 유사한 답변만을 매번 내놓을 수 있다는 단점이 있음.

Temperature = 1.0 (기본값)

"이번 달 예산을 잘 관리하셨네요! 🎉 특히 식비 절약이 돋보입니다. 하지만 문화/여가 지출에서 초과된 부분을 조정하면 더 좋을 것 같아요."

• 조금 더 창의적이고 부드러운 문장.

Temperature = 1.5 (높음)

"이번 달 예산은 멋지게 관리하셨습니다! 🎉 하지만 교통비와 문화 활동에 대한 새로운 접근을 시도해보시면 어떨까요? 😊"

• 다양하고 자유로운 표현, 하지만 예측 가능성은 줄어듦. 다양한 응답을 준다는 점에서 매우 매력적이지만, gpt를 사용해서 서비스를 구성해야하는 상황에서 gpt의 응답의 예측이 어렵다면 대답 중에서 원하는 컴포넌트를 뽑아내 내 서비스 내에서 사용하기 어려울 수 있음. 특히 아래처럼 예상치 못한 에러 아닌 에러가 나타날 수도 있습니다.

2) Top-p: 선택의 폭을 제한하는 필터

Top-p는 확률 분포에서 누적 확률이 특정 임계값(p)에 도달할 때까지 상위 후보 단어만 선택하는 방식입니다.

• 낮은 값 (0.1): 확률이 높은 상위 후보들만 선택 → 보수적 결과.
• 높은 값 (0.9): 확률이 낮은 후보도 포함 → 다양한 결과.

작동 방식 모델이 계산한 다음 단어의 확률 분포를 누적 합산하여, p 이하의 확률만 포함합니다.

비유 Top-p는 "상위 몇 %의 후보를 선택할지 결정하는 체계적인 필터"입니다.

• 낮은 Top-p는 필터링을 빡세게, 높은 Top-p는 느슨하게.

실험 결과 분석

Top-p = 0.3 (낮음)

"식비 절약을 잘 하셨네요. 교통비도 계획적으로 관리해보세요."

• 확률이 높은 단어들만 사용 → 단순하고 보수적 표현.

Top-p = 0.9 (높음)

"이번 달 예산을 잘 지키셨네요! 특히 식비와 카페 비용에서 멋지게 절약하셨어요. 😊"

• 다양한 단어 조합 → 좀 더 창의적이고 풍부한 표현.

3) Frequency Penalty: 반복을 피하기 위한 설정

Frequency Penalty는 텍스트에서 동일한 단어가 반복적으로 등장하지 않도록 조정합니다.

• 낮은 값 (0.0): 단어가 반복될 가능성이 큼.
• 높은 값 (2.0): 반복 사용을 줄여 더 다양한 표현 유도.

작동 방식

이미 생성된 단어가 텍스트에 몇 번 등장했는지를 기준으로, 해당 단어의 확률을 줄입니다.

실험 결과 분석

Frequency Penalty = 0.0 (기본값)

"이번 달 예산을 잘 지키셨네요. 예산을 잘 지키셨습니다!"

• 반복 표현 발생 가능성 증가.

Frequency Penalty = 2.0 (높음)

"이번 달 예산을 멋지게 관리하셨어요! 다양한 항목에서 절약 노력이 돋보입니다."

• 반복 방지 → 더 창의적이고 유연한 표현.

4) Presence Penalty: 새로운 단어를 유도하는 설정

Presence Penalty는 이미 텍스트에 등장한 단어를 다시 사용하는 가능성을 낮추고, 새로운 단어를 선택하도록 유도합니다.

• 낮은 값 (0.0): 기존 단어를 반복 사용하는 경향.
• 높은 값 (2.0): 새로운 단어를 더 많이 생성.

실험 결과 분석

Presence Penalty = 0.0 (기본값)

"이번 달 예산을 잘 지키셨네요. 예산 항목에서 잘 관리하셨습니다."

• 기존 단어를 여러 번 사용.

Presence Penalty = 2.0 (높음)

"이번 달 예산 관리를 성공적으로 하셨습니다! 다음 달에는 다양한 절약 아이디어를 시도해보세요."

• 새로운 단어 사용 → 더 풍부한 텍스트.

5) 파라미터들을 조합해보기

각 파라미터들은 독립적으로 작동하지만, 함께 사용하면 더 정교하게 출력 제어가 가능합니다.

아래는 다양한 Temperature, Top-p, Frequency Penalty, Presence Penalty 조합으로 생성된 응답 예시입니다.

6) 프롬포팅에 대한 정리 및 팁

1. 명확한 목표 설정 및 데이터 준비

   • 구현하고자 하는 기능의 로직과 필요한 데이터를 명확히 정의하기
   • 예상되는 결과값을 고안하고, AI가 이해하기 쉽게 예시 데이터를 준비하기

2. 프롬프트 내용 및 역할 설정

   • 명확하고 체계적인 영어로 지시를 작성하기
     • AI가 수행할 작업을 구체적으로 설명하고, 입력값과 출력 형식 등을 명시
   • 역할(Role) 부여:
     • Assistant와 User의 역할을 명확히 구분
     • AI에게 적합한 성격이나 역할(예: 재무 컨설턴트, 교육 코치 등)을 부여하면 더 적절한 응답을 얻기 가능

3. 설정값 최적화 및 실험

   • 다양한 하이퍼파라미터(Temperature, Top-p, Penalty) 조합을 실험하여 최적의 설정값을 찾기
   • 실험 결과를 분석해 목표에 가장 적합한 응답을 생성할 수 있도록 설정을 조정하기

이제 여러분도 위의 팁들을 사용해 직접 gpt prompt를 작성해보세요!

5. 실험한 결과를 바탕으로 gpt 프롬포트 완성하기

실제로 코드에 각 컴포넌트로 분리해서 들어가 이와 같은 형태로 합쳐져 gpt에게 request를 보내는 API call이 일어나게 됩니다. 컴포넌트 분리는 백엔드의 domain이나 service가 어떻게 구성되냐에 따라 다르게 설정됩니다.

{
  "model": "gpt-4o-mini",
  "messages": [
    {
      "role": "system",
      "content": [
        {
          "type": "text",
          "text": "You are a financial assistant AI responsible for creating a personalized monthly budget. Your task is to analyze the provided data and generate a budget plan for the next month in JSON format. Ensure the budget is tailored for 30 days (one month). Assign categories reasonably, especially for essential costs like food and living expenses. Explain the reasoning behind your allocations in detail in Korean in the `reason` field. YOU SHOULD ASSING REASONABLE BUDGET FOR SCHEDULE AND EACH CATEGORIES. \n\n### Inputs:\n1. **This Month's Budget**: The budget allocated to each category this month. \n2. **This Month's Spending Feedback**: Feedback on whether the user overspent or underspent in various categories this month.\n3. **Fixed Expenses**: Non-negotiable expenses such as rent, utilities, or loan repayments that must be covered.\n4. **User's Preferences**: Specific preferences or priorities for the next month. \n   - If the user's preferences cannot be fully accommodated without exceeding the total budget or making other categories severely underfunded, partially adjust the allocations and explain the reasons clearly in the `reason` field. If you cannot make it, YOU SHOULD EXPLAIN IN THE RESON THO.\n5. **Next Month's Plans**: Include additional expenses for special events, holidays, or other significant activities. You should assign reasonable amount of cost. Especially if it's travel to somewhere, you should calculate all the flight and accomodations, and food, etc. \n6. **Total Budget**: The maximum budget available for allocation next month (e.g., 800,000 KRW).\n\n### Output Requirements:\nGenerate the budget in the following JSON format:\n```json\n{\n  \"monthly_budget\": {\n    \"total_budget\": 800000,\n    \"category_budgets\": {\n      \"경조/선물\": 0,\n      \"교육/학습\": 0,\n      \"교통\": 0,\n      \"금융\": 0,\n      \"문화/여가\": 0,\n      \"반려동물\": 0,\n      \"뷰티/미용\": 0,\n      \"생활\": 0,\n      \"술/유흥\": 0,\n      \"식비\": 0,\n      \"여행/숙박\": 0,\n      \"온라인 쇼핑\": 0,\n      \"의료/건강\": 0,\n      \"자녀/육아\": 0,\n      \"자동차\": 0,\n      \"주거/통신\": 0,\n      \"카페/간식\": 0,\n      \"패션/쇼핑\": 0\n    }\n  },\n  \"reason\": \"Explain the reasoning behind the budget allocations in Korean. Example of response is like the following, 이번 달 예산은 사용자님의 생활 패턴과 피드백을 꼼꼼히 반영해서 짜 보았어요. 먼저, 필수적으로 지출해야 하는 고정비(주거/통신 150,000원, 교통 70,000원)는 꼭 필요한 만큼 먼저 배정했어요. 다음달에는 지민님이 다음 달에는 기타 학원 등록을 원하셨기 때문에 교육/학습 항목에 300,000원을 충분히 배정했어요. 지난달 식비가 조금 초과되었다고 하셔서, 충분히 여유롭게 드실 수 있도록 260,000원으로 살짝 늘렸어요. 카페/간식은 딱 적당히 사용하신 것 같아 이번에도 그대로 유지했어요. 문화/여가 쪽은 사용이 적어서 30,000원을 줄이고, 그 금액은 다른 꼭 필요한 항목에 넣었답니다. 또한, 다음 달 주말 여행을 계획하셨다고 하셔서, 여행/숙박 항목에 150,000원을 새로 배정했어요. 요청하신 다른 항목들 중에서 예산에 부담이 되는 부분은 조금 줄였지만, 최대한 반영하려 노력했답니다. 술/유흥은 특별히 많이 필요하지 않으실 것 같아 조금 줄였고, 생활비는 꼭 필요한 만큼 그대로 유지했어요. 의료/건강 항목은 정기 검진 등 필요한 비용을 고려해서 10,000원을 추가했어요. 지난 달 피드백에 따라 쇼핑에서 지출을 줄여서 다음 달 주요 일정이 여행을 위한 돈을 모아보는 건 어떻까요? 전체 예산이 800,000원을 넘지 않도록 하나하나 신경 써서 조정했으니, 다음 달도 편안하게 보내실 수 있기를 바라요. 😊\" \n}\n"
        }
      ]
    },
    {
      "role": "user",
      "content": [
        {
          "type": "text",
          "text": "{ \"current_budget\": { \"monthly_budget\": { \"total_budget\": 800000, \"category_budgets\": { \"경조/선물\": 0, \"교육/학습\": 32000, \"교통\": 80000, \"금융\": 0, \"문화/여가\": 120000, \"반려동물\": 0, \"뷰티/미용\": 40000, \"생활\": 40000, \"술/유흥\": 24000, \"식비\": 240000, \"여행/숙박\": 0, \"온라인 쇼핑\": 0, \"의료/건강\": 56000, \"자녀/육아\": 0, \"자동차\": 0, \"주거/통신\": 0, \"카페/간식\": 64000, \"패션/쇼핑\": 24000 } } }, \"current_feedback\": { \"message\": \"이번 달 총 예산을 잘 지키며 소비하셨네요! 특히 외식비를 관리하신 점이 돋보여요. 🎉 하지만 의류 구매와 영화 관람에서 예산을 초과한 점은 아쉬운 부분이에요. 다음 달에는 쇼핑과 여가 활동에서의 소비를 조금 줄이고, 그 절약한 금액을 다른 필요한 곳에 투자해보는 것은 어떨까요? 이렇게 하면 더 많은 저축이 가능할 거예요! 😊\" }, \"fixed_expenses\": [ { \"fixed_expenses\": [ { \"name\": \"교통비(정기권)\", \"amount\": 30000, \"frequency\": \"monthly\", \"type\": \"교통\", \"description\": \"지하철/버스 정기권\" }, { \"name\": \"구독 서비스(넷플릭스)\", \"amount\": 12000, \"frequency\": \"monthly\", \"type\": \"문화/여가\", \"description\": \"넷플릭스 스트리밍 구독\" } ] } ], \"user_opinions\": { \"plans\": \"다음 달에 기타 학원(30만원)을 등록하고싶어. 그리고 식비를 줄일래.\" }, \"next_month_schedules\": [ { \"이름\": \"지민이랑 도쿄 일정\", \"시간\": \"2024-12-26 ~ 2024-12-30\", \"색깔\": \"Blue\", \"카테고리\": \"여행/숙박\" } ] }"
        }
      ]
    },
    {
      "role": "assistant",
      "content": [
        {
          "type": "text",
          "text": "{\n  \"monthly_budget\": {\n    \"total_budget\": 800000,\n    \"category_budgets\": {\n      \"경조/선물\": 0,\n      \"교육/학습\": 300000,\n      \"교통\": 30000,\n      \"금융\": 0,\n      \"문화/여가\": 80000,\n      \"반려동물\": 0,\n      \"뷰티/미용\": 40000,\n      \"생활\": 40000,\n      \"술/유흥\": 24000,\n      \"식비\": 200000,\n      \"여행/숙박\": 50000,\n      \"온라인 쇼핑\": 0,\n      \"의료/건강\": 56000,\n      \"자녀/육아\": 0,\n      \"자동차\": 0,\n      \"주거/통신\": 0,\n      \"카페/간식\": 64000,\n      \"패션/쇼핑\": 24000\n    }\n  },\n  \"reason\": \"이번 달 예산은 사용자님의 생활 패턴과 피드백을 반영하여 짜 보았어요. 지민님이 원하는 기타 학원 등록을 위해 교육/학습 항목에 300,000원을 배정했어요. 이는 사용자님의 구체적인 요구를 충족하기 위한 충분한 금액입니다. 식비는 지난달에 비해 줄이고 싶다고 하셨으므로, 200,000원으로 설정했어요. 외식비 관리가 잘 되었다고 하셨기 때문에 이 정도 금액이면 충분히 문제가 없으리라 판단했답니다. 문화/여가 항목은 영화 관람에서 예산을 초과한 점을 고려하여 80,000원으로 조정했어요. 교통비는 꼭 필요한 정기권이 있으니 30,000원으로 유지하되, 여행/숙박에는 50,000원을 새롭게 배정해 도쿄 일정에 대한 일부 비용을 충당할 수 있도록 했어요. 카페/간식은 사용이 적당하여 그대로 두었고, 뷰티/미용이나 술/유흥 부분은 필요에 맞게 조정했어요. 전체적으로 예산을 800,000원 내에서 효과적으로 조합하여 사용자님의 필요를 최대한 반영해 보았답니다. 다음 달도 좋은 한 달 되시길 바랍니다! 😊\"\n}"
        }
      ]
    }
  ],
  "response_format": {
    "type": "json_object"
  },
  "temperature": 1,
  "max_tokens": 2048,
  "top_p": 1,
  "frequency_penalty": 0,
  "presence_penalty": 0
}

오늘은 GPT Playground를 통해 AI를 활용한 문제 해결 방법을 탐구했는데요, 프롬포트를 잘 설계하고 설정값을 조정하면 AI가 훨씬 효율적이고 정확하게 응답한다는 걸 확인할 수 있었습니다. 이번 결과는 정말 만족스러웠습니다! 특히, Temperature와 Top-p를 실험하며 다양한 결과를 만들어내는 과정이 흥미로웠어요. 프롬포팅 설계의 중요성도 다시 한번 느꼈고요. 다음에는 더 재미있는 주제로 돌아오겠습니다! 궁금한 점은 언제든 댓글로 남겨주세요. 그럼 저는 이만! 🤗

이번 주차 목표

1. Spring 프레임워크와 API의 개념을 이해한다.
2. Spring의 핵심 개념인 DI, IoC, 서블릿에 대해 알아본다.

🌱 스프링 프레임워크 기초 - Spring Framework, DI와 IoC란?

1. 스프링(Spring)이란?

스프링은 Java로 애플리케이션을 쉽게 개발할 수 있도록 도와주는 프레임워크입니다. 즉, 개발자가 복잡한 작업에 집중하지 않고 필요한 기능을 빠르게 구현할 수 있도록 도구와 규칙을 제공하는 틀입니다.

• 자바 기반 개발에서 널리 사용되며, 복잡한 작업을 간단히 처리할 수 있는 다양한 도구를 제공합니다.
• 특히 의존성 관리(DI)와 제어 흐름 관리(IoC)를 통해 개발자가 복잡한 비즈니스 로직에 집중할 수 있도록 돕습니다.

스프링을 쉽게 비유하자면?

1️⃣ 종합 요리 키트

• 요리사가 모든 재료를 준비하고 요리법을 알아야 한다면 시간이 오래 걸리겠죠?
  스프링은 요리사가 아니라도 쉽게 요리를 만들 수 있도록, 필요한 재료와 조리법(구조와 규칙)을 제공하는 키트와 같습니다.
  • 재료: 스프링이 제공하는 기능들 (예: DI, IoC, 서블릿, 데이터 처리 등).
  • 조리법: 스프링이 정해둔 규칙과 패턴을 따라 작업.

2️⃣ 블록 조립 키트

• 마치 레고 블록처럼 미리 만들어진 조각(컴포넌트)들을 끼워 맞춰서 원하는 애플리케이션을 만드는 느낌입니다.
  • 개발자는 각 블록(스프링 기능)을 조립하기만 하면, 복잡한 작업도 간단히 구현할 수 있습니다.

왜 스프링을 사용할까?

1️⃣ 복잡한 작업을 자동화

• 객체를 생성하고, 서로 연결하고, 삭제하는 작업을 스프링이 대신 처리.
• 개발자는 비즈니스 로직(실제 기능 구현)에 집중할 수 있음.

2️⃣ 코드 간소화

• 불필요한 반복 코드를 줄이고, 중요한 부분에만 집중할 수 있게 해줌.

3️⃣ 유연성과 확장성

• 다양한 애플리케이션(웹, API, 데이터베이스 등)에 사용할 수 있으며, 필요한 기능을 추가하기 쉽습니다.

4️⃣ 표준화된 설계 방식

• 스프링이 정해준 규칙에 따라 개발하면, 다른 개발자와 협업하거나 유지보수하기 쉬움.

스프링의 주요 기능

1️⃣ IoC (Inversion of Control)

• 객체 생성과 관리(초기화, 삭제 등)를 스프링이 대신 처리.
• 개발자가 객체를 일일이 관리하지 않아도 됨.

2️⃣ DI (Dependency Injection)

• 객체 간의 관계를 스프링이 설정해 줌.
• 개발자는 "이 객체가 무엇과 연결될지"를 걱정하지 않아도 됨.

3️⃣ MVC 패턴 지원

• 스프링은 Model-View-Controller 패턴을 사용해 웹 애플리케이션의 구조를 명확히 정의.
• 프론트엔드(화면)와 백엔드(데이터 처리)가 분리되어 개발과 유지보수가 쉬움.

4️⃣ AOP (Aspect-Oriented Programming)

• 중복되는 로직(예: 로깅, 트랜잭션 관리)을 분리해 코드 중복을 줄이고 효율성을 높임.

쉽게 이해하기 위한 예

스프링이 없는 개발

• 객체를 직접 생성하고, 서로 연결하며, 요청을 처리하는 로직을 전부 작성해야 함.
• 복잡한 설정 작업과 반복적인 코드가 많아짐.

UserService userService = new UserService();
DatabaseConnection dbConnection = new DatabaseConnection();
userService.setDatabaseConnection(dbConnection);
userService.processRequest(request);

스프링을 사용한 개발

• 객체 생성과 의존성 설정을 스프링이 자동으로 처리.
• 개발자는 주요 로직만 작성.

@Autowired
private UserService userService;

userService.processRequest(request);

2. 프레임워크와 API의 차이점

프레임워크와 API는 비슷하게 들리지만, 사용 방식과 역할에서 차이가 있습니다.

비유

• 프레임워크는 요리 레시피처럼 개발자가 따라야 하는 규칙과 구조를 제공합니다.
• API는 재료를 요청하거나 상호작용하는 도구와 같습니다.

3. IoC(Inversion of Control)란?

그러면 각각의 스프링의 기능에 대해 더 자세히 알아봅시다.

IoC(Inversion of Control)는 제어의 흐름을 개발자가 아닌 스프링 컨테이너가 관리하도록 바꾸는 개념입니다.
즉, 객체를 만들고, 연결하고, 없애는 일을 스프링 컨테이너에게 맡긴다고 생각하면 됩니다.

왜 IoC가 필요할까?

과거의 개발 방식: 모든 것을 직접 관리

개발자가 직접 객체를 생성하고, 필요한 다른 객체와 연결하며, 객체를 없애는 과정까지 전부 관리해야 했습니다.

• 문제점:
  1. 객체를 생성하고 관리하는 코드가 반복적으로 생김.
  2. 객체 간 연결(의존성)이 너무 밀접해서 수정하기 어려움.
  3. 코드가 복잡해지고, 유지보수에 시간이 많이 듦.

IoC 방식: 제어를 스프링 컨테이너에 위임

스프링에서는 객체를 직접 생성하거나 연결하지 않아도 됩니다.

• 해결:
  1. 객체를 생성하고 연결하는 작업을 스프링 컨테이너가 처리.
  2. 개발자는 "무엇을 해야 할지"만 신경 쓰고, "어떻게 할지"는 스프링이 담당.
  3. 결합도가 낮아지고 코드가 단순화되어 유지보수가 쉬워짐.

IoC의 작동 방식

1️⃣ 클래스 정의

• 필요한 기능을 가진 클래스(재료)를 정의합니다.

  public class OrderService {
      private PaymentService paymentService;
  }

2️⃣ 의존성 설정

• 스프링 설정 파일(XML, Java Config) 또는 어노테이션을 사용해 객체 간 연결(의존성)을 설정합니다.

  @Autowired
  private PaymentService paymentService; // OrderService에서 PaymentService가 필요!

3️⃣ 컨테이너 관리

• 스프링 컨테이너가 객체를 생성하고 연결하며, 필요 없으면 소멸까지 자동으로 처리합니다.
  개발자는 OrderService를 바로 사용할 수 있습니다.

  @Autowired
  private OrderService orderService;

IoC로 바뀌면 뭐가 좋아질까?

1. 복잡성 감소

• 객체 생성과 관리 로직이 없어지니 코드가 간단해집니다.

2. 유지보수 용이

• 객체 간 연결이 유연해지면서, 수정이나 추가 작업을 할 때 다른 코드에 영향을 주지 않음.
  3. 확장성 향상
• 새로운 객체나 기능을 추가할 때 스프링 설정만 변경하면 되므로 코드 수정이 적습니다.

간단한 코드 비교

IoC 없이 직접 객체 관리

public class OrderService {
    private PaymentService paymentService;

    public OrderService() {
        this.paymentService = new PaymentService(); // 직접 객체 생성
    }

    public void processOrder() {
        paymentService.pay();
    }
}

IoC로 스프링 컨테이너에 위임

@Component
public class OrderService {
    @Autowired
    private PaymentService paymentService; // 스프링이 자동으로 주입

    public void processOrder() {
        paymentService.pay();
    }
}

4. DI(Dependency Injection)란?

다음으로는 의존성 주입(DI)에 대해 살펴보도록 하겠습니다.

DI(Dependency Injection)는 객체 간의 의존성을 외부에서 주입하는 방식입니다.
즉, 객체가 필요한 다른 객체(의존성)를 스스로 생성하지 않고, 스프링이 대신 연결해 주는 것을 의미합니다.

DI가 왜 필요할까?

1. 결합도를 낮춤
   • 객체 간 연결이 느슨해져서, 하나의 객체를 수정해도 다른 객체에 영향을 주지 않음.
2. 테스트와 유지보수 용이
   • 객체를 쉽게 교체하거나 테스트용 객체(mock 객체)로 대체 가능.
3. 코드 단순화
   • 객체 생성과 연결을 스프링이 처리하니, 개발자는 주요 로직에 집중할 수 있음.

DI의 주요 방식

의존성 주입의 방식에는 대표적으로 생성자 주입, Setter 주입, 필드 주입 총 3가지 있습니다. 하나씩 살펴봅시다.

1️⃣ 생성자 주입

• 객체 생성 시 생성자를 통해 의존성을 설정.
• 장점: 의존성이 항상 설정되므로 안전하며, 테스트에 적합.
• 단점: 의존성이 많으면 생성자가 복잡해질 수 있음.

@Component
public class OrderService {
    private final PaymentService paymentService;

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

2️⃣ Setter 주입

• Setter 메서드를 통해 의존성을 주입.
• 장점: 선택적으로 의존성을 설정 가능.
• 단점: 의존성 누락 여부를 컴파일 시점에 확인할 수 없음.

@Component
public class OrderService {
    private PaymentService paymentService;

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

3️⃣ 필드 주입

• 필드에 직접 의존성을 주입.
• 장점: 코드가 간결함.
• 단점: 테스트와 유지보수에 어려움이 있어 권장되지 않음.

@Component
public class OrderService {

    @Autowired
    private PaymentService paymentService; // 필드로 바로 주입
}

결론

쉽게 비유하자면,

• 생성자 주입: 처음부터 필수 재료를 다 챙겨 요리를 시작.
• Setter 주입: 요리를 하다 필요할 때마다 재료를 추가.
• 필드 주입: 재료가 항상 자동으로 주방에 배치되어 있음.

DI는 객체를 스스로 생성하지 않고, 스프링이 필요한 객체를 대신 연결해 주어 결합도를 낮추고, 코드 유지보수를 쉽게 만들어 줍니다.
생성자 주입은 객체 생성 시 필요한 모든 의존성을 반드시 제공하도록 강제하기 때문에, 의존성 누락으로 생기는 문제를 컴파일 시점에 방지해줍니다. 따라서, 안전성과 테스트 용이성 측면에서 가장 권장되는 방식입니다!

5. 스프링 빈(Bean)이란?

스프링 빈(Bean)은 스프링 컨테이너에서 관리하는 객체를 의미합니다.

• ** 빈은 스프링 컨테이너가 관리**하며, 애플리케이션의 주요 구성 요소를 뜻합니다.
• 개발자는 컨테이너에 빈을 등록하고, 컨테이너는 필요한 의존성을 자동으로 주입합니다.

✅ 스프링 빈의 특징

• 컨테이너 관리: 빈은 스프링 컨테이너(ApplicationContext)에 의해 생성되고 관리됩니다.
• 주요 구성 요소: 애플리케이션의 핵심 기능(서비스, DAO 등)을 담당하는 객체.
• 싱글톤 기본 설정: 빈은 기본적으로 싱글톤(애플리케이션에서 하나의 인스턴스만 존재)으로 관리되며, 필요시 scope를 변경할 수 있습니다.

🌟 스프링 빈의 동작 과정

1️⃣ 빈 정의: 스프링 설정 파일(XML, Java Config)이나 어노테이션(@Component, @Bean)으로 정의.
2️⃣ 빈 등록: 컨테이너가 빈을 읽어 생성하고 등록.
3️⃣ 빈 사용: 컨테이너가 요청에 따라 빈을 반환하거나, 자동으로 주입.

✅ 빈 등록 방법

스프링에서는 빈을 등록하는 방식이 자동 등록과 명시적 등록으로 나뉩니다.

1️⃣ 묵시적 빈 정의 (@Component, @Autowired)

스프링이 자동으로 빈을 스캔하고 등록하는 방식입니다.

• 클래스에 @Component, @Service, @Repository, @Controller를 붙이면 스프링이 빈으로 등록.
• 의존성은 @Autowired로 주입.

@Component // 빈 자동 등록
public class MyService {
    @Autowired // 빈 의존성 자동 주입
    private MyRepository repository;

    public void execute() {
        repository.save();
    }
}

🌟 묵시적 빈 정의의 장점

• 간단한 구조로 빠르게 빈을 등록할 수 있음.
• 반복적인 코드 작성이 필요 없음.

2️⃣ 명시적 빈 정의 (@Configuration, @Bean)

개발자가 빈의 등록 과정을 직접 제어하는 방식입니다.

• 클래스에 @Configuration을 붙이고, 메서드에 @Bean을 사용하여 빈을 등록.
• 복잡한 초기화 작업이나 의존성 설정이 필요한 경우 사용.

@Configuration // 설정 클래스
public class AppConfig {
    @Bean // 명시적 빈 등록
    public MyService myService() {
        return new MyService(myRepository());
    }

    @Bean
    public MyRepository myRepository() {
        return new MyRepository();
    }
}

🌟명시적 빈 정의의 장점

• 빈의 생성 과정을 세밀하게 제어할 수 있음.
• 복잡한 의존성이나 초기화 작업에 적합.

📝 묵시적 빈 정의 vs 명시적 빈 정의 비교

결론: 스프링 빈의 역할

1️⃣ 스프링 빈은 애플리케이션의 주요 구성 요소이며, 컨테이너에서 객체 생성 및 생명 주기를 관리합니다.
2️⃣ 자동 등록은 간단하고 반복적인 작업에 적합하며, 명시적 등록은 복잡한 작업에 적합합니다.
3️⃣ DI와 결합되어, 스프링 빈은 유연성과 유지보수성을 극대화합니다.

6. 서블릿(Servlet)과 DispatcherServlet

서블릿(Servlet)이란?

서블릿(Servlet)은 웹 애플리케이션에서 클라이언트의 요청(HTTP Request)을 처리하고 응답(HTTP Response)을 생성하는 자바 기반의 컴포넌트입니다.
서블릿은 동적인 웹 페이지를 생성하는 데 사용되며, 클라이언트 요청에 따라 결과를 반환하는 역할을 합니다.

웹 애플리케이션에서 서블릿은 다음과 같은 역할을 합니다:

1. HTTP 요청 수신: 클라이언트가 입력하거나 클릭한 요청을 서버로 전달.
2. 비즈니스 로직 처리: 요청 데이터를 분석하고 필요한 작업 수행.
3. 응답 생성: 처리 결과를 HTML, JSON, XML 등의 형식으로 클라이언트에 반환.

서블릿의 동작 과정

1. 사용자 요청: 클라이언트가 URL을 통해 HTTP 요청을 서버로 보냄.
2. 서블릿 컨테이너: 요청을 받아 적합한 서블릿을 실행.
3. 비즈니스 로직 처리: 서블릿이 데이터를 처리하거나 데이터베이스와 상호작용.
4. 결과 반환: 처리 결과를 HTTP 응답으로 클라이언트에게 전송.

서블릿의 생명주기

1. 초기화(init): 서블릿 컨테이너가 서블릿 객체를 생성하고 초기화.
2. 서비스(service): HTTP 요청을 처리하며 doGet(), doPost() 메서드를 실행.
3. 소멸(destroy): 서블릿 컨테이너가 서블릿 객체를 소멸하고 자원 해제.

Servlet Container란?

Servlet Container(서블릿 컨테이너)는 서블릿을 관리하고 실행하는 환경을 제공합니다. Servlet이 어떤 역할을 수행하는 메뉴얼이라면, Servlet 컨테이너는 해당 메뉴얼을 보고 직접 핸들링한다고 생각하시면 됩니다.

서블릿 컨테이너는 클라이언트의 요청(Request)를 받아주고 응답(Response)할 수 있게, 웹 서버와 Socket으로 통신합니다. 대표적인 서블릿 컨테이너로는 Apache Tomcat이 있으며, 다음과 같은 역할을 수행합니다:

1. 요청 관리: 클라이언트의 요청을 받아 적절한 서블릿으로 전달.
2. 객체 관리: 서블릿의 생성, 초기화, 실행, 소멸 등을 자동으로 관리.
3. 네트워크 통신 지원: 클라이언트-서버 간의 네트워크 통신을 처리.
4. 비즈니스 로직 분리: 개발자가 요청 처리에만 집중할 수 있도록 도움.

Spring의 DispatcherServlet

스프링에서 가장 중요한 서블릿은 DispatcherServlet입니다.
DispatcherServlet은 스프링 MVC의 중심으로, 클라이언트의 모든 HTTP 요청을 받아 적절한 Controller로 전달하고 처리 결과를 반환합니다. 이는 Front Controller 패턴을 구현한 서블릿으로, 모든 HTTP 요청을 받는 녀석이에요. 이후, 요청을 적절한 Controller로 전달하고, 로직을 실행한 후 응답을 생성해줍니다.

DispatcherServlet의 처리 과정

1. 요청 수신: 클라이언트가 보낸 모든 HTTP 요청을 수신.
2. Handler Mapping: 요청 URL에 따라 적합한 컨트롤러를 검색.
3. Controller 실행: 컨트롤러에서 비즈니스 로직을 처리하고 결과를 반환.
4. View Resolver: 처리 결과를 View로 렌더링하여 응답 생성.
5. 클라이언트 응답: HTML, JSON 등의 형태로 결과를 반환.

DispatcherServlet의 특징

• Front Controller 패턴 구현: 모든 요청을 중앙에서 관리.
• Controller-서비스-DAO 계층 구조를 통해 코드의 모듈화와 유지보수를 용이하게 만듦.

예제 코드

@Controller
public class MyController {

    @GetMapping("/umc")
    public String hello(Model model) {
        model.addAttribute("message", "UMC Spring Fighting!");
        return "greeting";  
    }
}

1. 클라이언트가 /umc URL을 요청하면, DispatcherServlet이 요청을 수신.
2. DispatcherServlet의 Handler Mapping: DispatcherServlet가 해당 HTTP Request를 처리할 수 있는 적합한 컨트롤러(MyController)를 찾아 hello() 메서드를 호출.
3. 비즈니스 로직을 처리한 결과를 View 이름(greeting)으로 반환.
4. ViewResolver가 HTML 페이지를 렌더링하여 클라이언트에 응답.

서블릿과 스프링 빈의 관계

전체적인 흐름을 이해하기 위해, 서블릿과 스프링 빈 어떤 관계인지 살펴보고 마무리합시다!

1. 서블릿은 웹 애플리케이션의 핵심 요청-응답을 처리

• 서블릿은 클라이언트의 HTTP 요청을 가장 먼저 수신하여 처리하는 역할을 합니다.

2. 스프링 빈은 서블릿의 요청 처리를 돕는 객체

• 서블릿(특히 Spring의 DispatcherServlet)이 HTTP 요청을 처리할 때, 요청을 스프링 빈(Controller, Service, Repository 등)에 전달하여 필요한 작업을 수행합니다.

3. 서블릿은 스프링 애플리케이션의 일부로 포함

• DispatcherServlet은 서블릿의 한 종류이며, 스프링 MVC에서 모든 요청을 받아 스프링 빈과 상호작용하며 작업을 처리합니다.

서블릿과 스프링 빈이 협력하는 과정

1. 서블릿 수신
   클라이언트가 보낸 HTTP 요청은 서블릿 컨테이너(Tomcat 등)로 전달되고, 해당 요청이 DispatcherServlet으로 처리됩니다.

2. DispatcherServlet 역할
   요청을 분석하여 적절한 스프링 빈(Controller)을 호출.

3. 스프링 빈 처리
   Controller, Service, Repository 계층에서 비즈니스 로직을 수행하고 결과를 반환.

4. 결과 반환
   DispatcherServlet이 처리 결과를 클라이언트에 응답.

비유로 이해하기

1. 서블릿: 식당의 매니저

   • 손님(클라이언트)이 요청하면 매니저(서블릿)가 요청을 접수하고 주방이나 계산대로 전달.
   • 최종 결과(요리나 계산 결과)를 손님에게 전달.

2. 스프링 빈: 식당의 직원

   • 매니저가 전달한 요청을 실제로 처리.
   • 요리사(비즈니스 로직), 서빙 직원(데이터 전달), 계산원(데이터 처리)이 모두 스프링 빈의 역할.

정리하자면,

• 서블릿: 클라이언트 요청을 처리하고 응답을 생성하는 웹 애플리케이션의 요청-응답 처리자.
• 스프링 빈: 애플리케이션의 비즈니스 로직과 핵심 기능을 담당하며, 스프링 컨테이너에서 관리.

둘은 역할이 다르지만, 협력하여 클라이언트 요청을 처리하고 애플리케이션의 동작을 구현합니다.

🎯 핵심 키워드 정리

오늘 배운 내용 중 핵심 키워드를 정리해보겠습니다.

• DI (Dependency Injection): 객체 의존성을 외부에서 주입하여 결합도를 낮추는 기법.
• IoC (Inversion of Control): 객체 생성과 제어를 개발자가 아닌 스프링 컨테이너에 위임.
• 프레임워크 vs API: 프레임워크는 코드 흐름 제공, API는 상호작용 인터페이스 제공.
• 스프링 빈: 스프링 컨테이너에서 관리되는 객체.
• DispatcherServlet: 클라이언트 요청을 적절한 컨트롤러로 전달하는 서블릿.

💡 정리하며

스프링의 DI, IoC, DispatcherServlet 개념은 애플리케이션 설계의 복잡성을 줄이고 유지보수를 쉽게 만드는 핵심입니다. 이 기본 개념을 통해, 스프링 기반의 프로젝트를 체계적으로 설계할 수 있습니다.
다음 시간부터는 오늘 배운 스프링부트를 본격적으로 학습하면서 JPA에 대해 배워보도록 하겠습니다.😊

API는 단순히 클라이언트와 서버 간의 통신을 위한 도구가 아닙니다.
API 설계는 프로젝트의 기능을 구체화하고, 팀원 간 협업을 원활히 하기 위한 로드맵을 만드는 작업입니다.

왜 API 설계가 중요한가요?

1️⃣ 프로젝트의 큰 틀을 잡는 과정

• API는 데이터베이스와 함께 프로젝트의 핵심 구조를 형성합니다.
• 명확한 설계를 통해 데이터 흐름을 효율적으로 관리할 수 있습니다.

2️⃣ 협업의 가이드라인 제공

• API 명세서를 통해 프론트엔드, 백엔드, 기획자 모두가 같은 방향으로 작업할 수 있습니다.
• 이를 통해 기능 구현 단계에서 발생할 수 있는 혼란을 최소화할 수 있습니다.

3️⃣ 확장성과 유지보수성 확보

• 설계 초기부터 API 구조를 체계적으로 정의하면, 새로운 기능 추가나 변경 시에도 유연하게 대응할 수 있습니다.

API 설계에서 가장 중요한 두 가지

1️⃣ API Endpoint 설계

• 각 기능이 어떤 경로(URL)를 통해 호출될지 정의.
• 명확하고 직관적인 경로로 설계해야 협업과 유지보수가 쉬워집니다.

2️⃣ 요청(Request)과 응답(Response) 데이터 설계

• 클라이언트가 서버에 전달할 데이터와, 서버가 반환할 데이터를 명확히 정의.
• 데이터를 어떻게 요청하고, 어떤 형식으로 받을지를 설계합니다.

API 설계 결과물: API 명세서

API 설계의 결과는 API 명세서라는 형태로 문서화됩니다.
이 명세서는 프론트엔드 개발자와 다른 팀원들이 API를 쉽게 이해하고 활용할 수 있도록 돕는 가이드가 됩니다.

API 명세서는 마치 ERD의 API 버전과도 같습니다.

• ERD가 데이터베이스 설계의 기반이라면, API 명세서는 시스템 간 데이터 흐름과 상호작용을 정의합니다.

이번 주차 목표

이번 포스팅에서는 API 설계의 원칙과 실전 활용 방법을 배우고, 이를 바탕으로 프로젝트의 기초를 다집니다.

학습 목표

📌 1. API, HTTP 메소드 배우기
📌 2. RESTful API Endpoint 설계 배우기
📌 3. 세부적인 API 설계 배우기

🌟 1. API, HTTP 메소드 배우기

API 설계 시 필요한 것은 아래와 같습니다:
1️⃣ API Endpoint의 설계
2️⃣ 요청 데이터, 응답 데이터의 설계

위의 정보를 문서화하여 프론트엔드 개발자가 API를 사용하기 쉽게 돕는 문서를 API 명세서라고 부릅니다.
📝 API 명세서는 ERD처럼 개발 초기 단계에서 큰 틀을 설계해야 합니다.

✏️ 1-1. 용어 정리

• 💡 API (Application Programming Interface)

  • 애플리케이션을 프로그래밍할 때 쉽게 작업할 수 있도록 돕는 도구 또는 인터페이스.
  • 예시: 네이버 로그인 API를 사용해 간단히 로그인 기능 구현.

• 💡 REST API

  • HTTP 메소드와 자원을 이용해 서로 간에 통신하는 방식.
  • REST는 Representational State Transfer의 약자로, HTTP를 기반으로 한 웹 서비스 아키텍처.

• 💡 API Endpoint

  • REST API에서 API 호출을 위한 HTTP 메소드와 URL의 조합.
  • 예: /users, /users/{id}
  • 구성 요소: HTTP 메소드 + URL = API Endpoint

• 💡 HTTP 메소드

  • REST 통신 시 작업의 종류를 표시하는 방법.
  • CRUD 작업에 대응하는 대표적인 5가지 메소드:
    1️⃣ GET: 조회
    2️⃣ POST: 생성 및 데이터 전송
    3️⃣ PUT: 전체 갱신
    4️⃣ PATCH: 부분 갱신
    5️⃣ DELETE: 삭제

⚠️ 주의: 모든 작업을 POST로 구현 가능하나, RESTful 설계 원칙을 지키려면 적합한 메소드를 선택해야 합니다!

🌟 2. RESTful API Endpoint의 설계 규칙

RESTful의 핵심은 "리소스 중심" 설계에 있습니다. RESTful(Representational State Transfer) 아키텍처 스타일은 HTTP 프로토콜을 기반으로 한 웹 서비스 설계 방식으로, 주로 리소스(Resource)를 중심으로 동작합니다. 즉, RESTful API는 리소스를 URI(Uniform Resource Identifier)로 표현하고, 이를 처리하기 위한 HTTP 메소드를 사용합니다.

2-1. RESTful API Endpoint 설계의 의미

API Endpoint 설계는 리소스와 작업을 조합해 사용자가 원하는 기능을 제공하는 경로(URL)를 정의하는 것을 의미합니다.

예를 들어, "게시글의 목록을 조회"하는 API가 필요하다고 가정해 봅시다.

• 리소스: 게시글(posts)
• 작업: 조회(GET)
• 엔드포인트 설계:
  • GET /posts: 게시글 목록을 조회

또 다른 예: "특정 사용자의 게시글 목록을 조회"하는 API

• 리소스: 게시글(posts), 사용자(users)
• 작업: 조회(GET)
• 엔드포인트 설계:
  • GET /users/{userId}/posts: 특정 사용자의 게시글 목록 조회

2-2. 설계 규칙

RESTful API의 Endpoint는 아래 규칙에 따라 설계합니다:

1️⃣ URI에 동사를 포함하지 않는다.

• ❌ /getUsers
• ✅ /users
• 작업은 HTTP 메소드로 표현하므로, URI에 동사를 포함할 필요가 없습니다.

2️⃣ 단어 구분은 하이픈(-)으로 한다.

• ❌ /users_list
• ✅ /users-list

3️⃣ 자원(Resource)은 복수형으로 표현한다.

• ❌ /user
• ✅ /users
• 리소스는 여러 개의 데이터를 다룰 수 있으므로 복수형으로 설계합니다.

4️⃣ 단일 자원을 표현할 경우 식별자(id)를 추가로 사용.

• ✅ /users/{id}
• 특정 데이터를 지칭할 때 고유 식별자(ID)를 URI에 포함해야 합니다.

5️⃣ 자원 간 연관 관계는 URI에 명시한다.

• ✅ /users/{id}/subjects
• 계층 구조를 사용하여 자원 간 관계를 표현해야 합니다.

💡 Tip: 설계 규칙을 기본적으로 따르되, 프론트엔드 개발자가 이해하기 쉬운 API를 설계하는 것이 가장 중요합니다.

🧩 자원 간 관계 표현

• 1:1 관계:

  • 특정 자원만을 명확히 표현.
  • ✅ /users/{id}/subjects/{subject-id}

• 1:N 관계:

  • 계층 관계에서 상위 자원이 먼저 위치.
  • ✅ /users/{id}/subjects

• N:M 관계:

  • 비즈니스 로직에서 중요한 자원을 앞에 배치.

🔑 예시: 회원가입 및 로그인

• 로그인:

  • POST /users/login
  • 예시 요청:

    POST https://example.com/users/login

• 회원가입:

  • POST /users

• 회원탈퇴 (Soft Delete):

  • PATCH /users

🌟 3. 세부적인 API 설계 배우기

3-1. 데이터 전달 방식

1️⃣ Path Variable

• 특정 자원을 식별할 때 사용.
• 예시:

  GET /users/articles/{article-id}

2️⃣ Query String

• 검색 및 필터링 시 사용.
• 엔드포인트 뒤에 ?로 시작, 여러 값은 &로 연결.
• 예시:

  GET /users/articles?name=mango&owner=yappi

3️⃣ Request Body

• 데이터를 생성하거나 업데이트할 때 사용.
• JSON 또는 Form-data 형식으로 전송.
• 예시:

  {
    "name": "최용욱",
    "phoneNum": "010-1111-2222",
    "nickName": "ddol"
  }

4️⃣ Request Header

• 서버와 클라이언트 간의 메타데이터를 전달.
• 예시:

  Authorization: Bearer <token>
  Content-Type: application/json

🌟 4. API 명세서 예시

• 요즘에는 노션을 사용해 작성하는 경우가 많습니다.

API 명세서 예시 스크린샷

최종적으로는, SWAGGER을 사용해서 API 명세서를 프론트엔드에게 넘겨주게 되고, 프론트엔드를 이를 확인하면서 협업하게 됩니다.

🔎 참고: HTML Form 방식의 데이터 전송

• POST 요청 시, Form 데이터를 전송하는 방식.
• 주로 회원가입, 상품 주문 등에 사용.

📤 HTTP 메시지 구조

이번 시간에는 백엔드 설계에서 매우 중요한 API 설계에 대해 배워봤습니다! 다음 포스팅에는 본격적으로 Spring Boot에 대해 배워보면서 실제로 개발을 해볼 준비를 해봅시다!😊

목차

0. 기본개념 - Join과 SubQuery 개념
1. 여러가지 요구 사항에 대한 SQL 쿼리 짜는 방법 배우기
2. offset paging(페이징)과 cusor-based paging 배우기

0. 기본개념 - Join과 SubQuery 개념

해당 주제는 스터디 워크북에서 sql 문법에 대해 잘 알고 있다고 가정하고 시작했기에, 아래 블로그들을 참고해서 사전공부를 진행했습니다! SQL 기본 문법: JOIN(INNER, OUTER, CROSS, SELF JOIN) [SQL] 테이블 JOIN의 개념과 예제 [MYSQL] 📚 테이블 조인(JOIN) - 그림으로 알기 쉽게 정리 SQL / MySQL 서브쿼리(SubQuery) [MYSQL] 📚 서브쿼리 개념 & 문법 💯 정리

0.1. Join

1) join: 서로 다른 각각의 테이블 속 데이터를 동시에 보여주려고 할 때 사용하는 SQL문

2)** join의 종류**

• inner join: 가장 basic, 양측 모두에 존재하는 것만 조인 (교집합)
• outer join
  • left join: 좌측 테이블 데이터에 추가로 우측 정보를 조인하는 문법, 좌측 테이블 중 조인 불가능한 것들도 모두 결과(Null)로 채운다.
    • right join: LEFT 조인을 뒤집은 개념
    • full join: 좌측,우측 상관없이 데이터가 있는 것은 모두 가져오고 없는 것은 모두 Null 이 되는 것 (합집합)

3) 형식

-- inner join
SELECT <열 목록>
FROM <첫 번째 테이블>
    INNER JOIN <두 번째 테이블>
    ON <조인 조건>
[WHERE 검색 조건]

#INNER JOIN을 JOIN이라고만 써도 INNER JOIN으로 인식

-- outer join
SELECT <열 목록>
FROM <첫 번째 테이블(LEFT 테이블)>
    <LEFT | RIGHT | FULL> OUTER JOIN <두 번째 테이블(RIGHT 테이블)>
     ON <조인 조건>
[WHERE 검색 조건]

4) 예시 쿼리

-- (inner) join
SELECT
  comments.body,
  users.nickname
FROM
  comments
JOIN users ON
  users.id = comments.user_id
WHERE
  comments.photo_id = 1
;

-- outer left join
SELECT photos.filename, users.nickname
FROM photos
LEFT JOIN users ON users.id = photos.user_id

0.2. Subquery

1) Subquery: 쿼리 안에 포함된 또 다른 쿼리. 주로 데이터 검색, 조건 필터링, 집계 연산 등 특정한 데이터를 추출하거나 처리할 때 사용.

2) Subquery의 특징 및 종류

• 특징:

  • () 안에 작성되며, 메인 쿼리에서 활용됨.
  • 독립적으로 실행 가능한 쿼리로, 메인 쿼리에서 필요로 하는 데이터를 반환함.
  • 반환값 형태에 따라 스칼라 값, 단일 행, 다중 행, 다중 열로 나뉨.

• 종류:

  • 스칼라 서브쿼리: 하나의 값을 반환하며, SELECT 문의 필드나 조건에 사용.
  • 다중 행 서브쿼리: 여러 행을 반환하며, IN, ANY, ALL과 같은 연산자와 함께 사용.
  • 다중 열 서브쿼리: 여러 열을 반환하며, 일반적으로 EXISTS와 함께 사용.
  • 상관 서브쿼리 (Correlated Subquery): 메인 쿼리의 값을 참조하여 동작. 서브쿼리가 메인 쿼리와 반복적으로 실행됨.

3) 형식

-- 일반적인 서브쿼리
SELECT <열 목록>
FROM <테이블>
WHERE <열> = (
    SELECT <열>
    FROM <테이블>
    WHERE <조건>
);

-- 다중 행 서브쿼리
SELECT <열 목록>
FROM <테이블>
WHERE <열> IN (
    SELECT <열>
    FROM <테이블>
    WHERE <조건>
);

-- 상관 서브쿼리
SELECT <열 목록>
FROM <테이블> T1
WHERE EXISTS (
    SELECT 1
    FROM <테이블> T2
    WHERE T2.<열> = T1.<열> AND <조건>
);

4) 예시 쿼리

-- 1. 스칼라 서브쿼리: 가장 높은 급여를 받는 직원의 이름 출력
SELECT name
FROM employees
WHERE salary = (
    SELECT MAX(salary)
    FROM employees
);

-- 2. 다중 행 서브쿼리: 특정 부서에서 근무하는 직원의 이름 출력
SELECT name
FROM employees
WHERE department_id IN (
    SELECT department_id
    FROM departments
    WHERE location = 'New York'
);

-- 3. 상관 서브쿼리: 자신보다 급여를 적게 받는 직원의 수 출력
SELECT name, (
    SELECT COUNT(*)
    FROM employees E2
    WHERE E2.salary < E1.salary
) AS lower_salary_count
FROM employees E1;

0.3. Join vs Subquery 비교

• Join은 여러 테이블의 데이터를 결합하여 하나의 결과로 출력하는 데 사용.
• Subquery는 메인 쿼리에 필요한 데이터를 제공하기 위한 용도로 사용.
• 성능 면에서 Join이 일반적으로 효율적이며, Subquery는 간단한 작업에서 가독성을 높이는 데 유리.

Tip: Join은 관계형 데이터 처리에서 성능과 효율성을 중시할 때 유용하며, Subquery는 특정 데이터 추출이나 조건 필터링에 적합.

2) 조인과 서브쿼리의 형식 비교

3) 조인 형식 예시

-- 조인: 두 테이블 연결
SELECT employees.name, departments.department_name
FROM employees
INNER JOIN departments
ON employees.department_id = departments.department_id;

-- 조인: 왼쪽 테이블의 모든 데이터 포함
SELECT products.product_name, orders.order_date
FROM products
LEFT JOIN orders
ON products.product_id = orders.product_id;

4) 서브쿼리 형식 예시

-- 서브쿼리: 특정 조건을 만족하는 데이터를 추출
SELECT name
FROM employees
WHERE department_id = (
    SELECT department_id
    FROM departments
    WHERE department_name = 'Sales'
);

-- 서브쿼리: 집계된 데이터를 조건으로 사용
SELECT product_id, product_name
FROM products
WHERE price > (
    SELECT AVG(price)
    FROM products
);

5) 핵심 차이점 요약

1. 사용 용도:

   • 조인은 여러 테이블의 데이터를 결합하고, 테이블 간의 관계를 명확히 정의하는 데 유용.
   • 서브쿼리는 특정 조건을 만족하는 데이터를 추출하거나 필터링에 적합.

2. 성능:

   • 조인이 일반적으로 더 빠르고 효율적.
   • 서브쿼리는 직관적이지만 데이터 양이 많으면 비효율적일 수 있음.

3. 가독성:

   • 조인은 관계형 데이터를 다룰 때 명확성을 높여줌.
   • 서브쿼리는 간단한 작업에서 더 읽기 쉽고 간단.

참고) join과 서브쿼리의 성능 차이의이유 이유: 내부 처리 방식의 차이

• JOIN: 데이터베이스는 JOIN을 할 때 두 테이블을 결합하며, 조인된 데이터를 한 번에 처리하도록 쿼리 최적화를 적용할 수 있다. 이를 통해 단일 스캔으로 결과를 가져올 수 있다.
• 서브쿼리: 서브쿼리는 외부 쿼리의 각 행에 대해 독립적으로 실행되므로, 각 행마다 서브쿼리를 처리하는 오버헤드가 발생. 특히 서브쿼리가 SELECT와 같은 필터링을 포함할 때, 반복적인 조회로 인해 성능이 느려질 수 있음.

⇒ JOIN을 기본으로 사용하고, 서브쿼리는 필요한 경우에만 활용하는 것이 좋다!!

1. 여러가지 요구 사항에 대한 SQL 쿼리 짜는 방법

이제 실제로 여러 시나리오를 살펴보면서 SQL문을 어떻게 짜는지 살펴보자.

시나리오 1

** 책의 좋아요 개수를 집계하는데, 내가 차단한 사용자의 좋아요는 집계하지 않는 경우**

두 entity에 대한 ERD는 아래와 같다

-- 책의 아이디가 3, 내 아이디가 2라고 가정

-- 1) subquery 사용해서 구현
select count(*) from book_like where book_id = 3
    and user_id not in (select target_id from block where owner_id = 2);

-- 2) left join 사용해서 구현
select count(*)
from book_like as bl
left join block as b on bl.user_id = b.target_id and b.owner_id = 2
where bl.book_id = 3 and b.target_id is null;

_#참고사항 - in과 on의 차이 _ sql문을 처음 배우는 나는 등호(=) 사용 대신에 in, on 등을 사용하는 걸 보고 둘의 차이점이 궁금했다.

• in: 서브쿼리에서 여러 값이 나올 때 사용하는 연산자, 여러 값이나 서브쿼리에서 반환한 다중 결과와 비교가능 / not in 으로도 사용 가능

    SELECT * FROM user 
    WHERE user_id IN (1, 2, 3); -- 여러 값 중 하나에 일치하는 경우
  
    SELECT * FROM user 
    WHERE region_id IN (SELECT id FROM region WHERE name = 'Seoul'); -- 서브쿼리에서 반환된 값 중 일치

• on: JOIN 조건에서 두 테이블 간의 관계를 정의할 때 사용, 테이블을 결합할 때 특정 컬럼 값이 서로 일치하는지 확인하는 데 사용

    SELECT u.username, r.name AS region_name 
    FROM user AS u
    JOIN region AS r ON u.region_id = r.id; -- 두 테이블 간의 관계를 정의

시나리오 2 - n:m 관계 경우

** 해시태그를 통한 책의 검색인데, N : M 관계로 인해 가운데 매핑 테이블이 추가 된 경우**

-- 서브쿼리
select * from book where id in 
    (select book_id from book_hash_tag 
            where hash_tag_id  = (select id from hash_tag where name = 'mango' ));

-- join
select b.*
from book as b
inner join book_hash_tag as bht on b.id = bht.book_id
inner join hash_tag as ht on bht.hash_tag_id = ht.id -- join을 두 번 진행해야 돼
where ht.name = 'mango';

시나리오 3 - 나열

1. 최신 순 조회

   select * from book order by created_at desc;

   내림차순으로 정렬해야 최신 것부터 조회된다.

2. *좋아요 개수 순 조회 * (해당 table에 likes 칼럼이 없는 상황)

select * from book as b 
join (select count(*) as like_count
                 from book_likes
                        group by book_id) as likes on b.id = likes.book_id
order by likes.like_count desc;

2. 페이징(paging)

목록 조회를 시나리오3처럼 하게 되면 db의 모든 book 데이터를 다 가져오는 등의 쿼리를 하니까, 엄청난 렉이 걸려서 이에 대한 해결책이 필요하다!

=> paging 필요 - 페이징이란, Db에서 끊어서 데이터 보내도록 쿼리 보내는 것

paging의 종류

1. offset based 페이징
   2. cursor based 페이징

1) Offset based 페이징

우리가 자주 보는 이런 목록이 오프셋 페이징이다.

1-1. Offset based 페이징 형식과 내용

• limit: 한 페이지에서 보여줄 데이터 개수
• offset으로 몇 개를 건너뛸지를 정함

-- 형식
select * 
from book
order by likes desc
limit y offset(x - 1) * y; -- 보통 1페이지가 첫 페이지이기 때문에 1 빼줌

-- 예시: 2페이지이고 한 페이지에 10개씩 보여주는 경우(x=2, y=10)
select *
from book
order by likes desc
limit 10 offset 10; 

-- 인기순 정렬
select * from book as b
join (select count(*) as like_count
                 from book_likes 
                    group by book_id) as likes on b.id = likes.book_id
order by likes.like_count desc
limit 15 offset (n - 1) * 15; -- 실제로는 n자리에 계산해서 넣어야 해

1-2. Offset based 페이징 단점

1. 페이지가 뒤로 갈수록 넘어가는 데이터가 많아져 성능 상의 이슈
2. 사용자가 다음 페이지로 넘어갈 때, 게시글이 추가되면 전 페이지에서 보이던 게 다음 페이지에도 보이게 됨.

1-3. Offset based 페이징 형식 동적으로 구현하기

=> 변수 활용: 클라이언트 측에서 마지막 레코드의 커서 값(예: created_at이나 id)을 서버로 전송하고, 서버에서 이를 받아 SQL 쿼리의 조건으로 사용

1. SQL에서 변수를 사용하는 방법 (Prepared Statements 또는 Dynamic SQL) 대부분의 프로그래밍 언어에서 SQL 쿼리에 변수를 넣어 동적으로 커서 값을 적용 가능하다. Python, Node.js, Java 등과 같은 언어에서는 Prepared Statements를 사용하여 안전하게 변수를 SQL 쿼리에 삽입한다.

   예시 (Python에서 MySQL 쿼리 실행):cursor_value와 user_id 값을 쿼리에 넣고, 동적으로 결과를 가져오기

   cursor_value = '2024-10-04 12:00:00'  # 클라이언트로부터 받은 마지막 커서 값
   
   sql = """
      SELECT mission.restaurant_id
      FROM mission
      WHERE mission.created_at < 
        AND mission.status = '진행중'
        AND mission.user_id = %s
      ORDER BY mission.created_at DESC
      LIMIT 5;
   """
   cursor.execute(sql, (cursor_value, 3))  # 커서 값과 user_id 값을 쿼리에 동적으로 넣음
   results = cursor.fetchall()
   

2. 변수를 이용한 동적 SQL 쿼리 (MySQL 변수 사용) MySQL에서 쿼리 안에 변수를 직접 사용하려면, MySQL 세션 변수 또는 프로시저 내에서 입력 매개변수를 활용

   ** 예시** (MySQL 변수 사용): @변수명 형식으로 MySQL 내에서 변수를 정의하고, 이 변수를 SQL 쿼리 안에 넣음

   SET @cursor_value = '2024-10-04 12:00:00';
   SET @user_id = 3;
   
   SELECT mission.restaurant_id
   FROM mission
   WHERE mission.created_at < **@cursor_value**
    AND mission.status = '진행중'
    AND mission.user_id = @user_id
   ORDER BY mission.created_at DESC
   LIMIT 5;

3. 클라이언트-서버 구조에서 동적 커서 페이징 구현 일반적으로 커서 기반 페이징을 구현할 때는 클라이언트-서버 구조에서 다음과 같은 방식으로 동작:
   1. 첫 번째 요청: 클라이언트가 서버에 페이지를 요청할 때는 커서 값이 없으므로, 서버는 기본 쿼리로 처음 5개의 레코드를 반환합니다.
   2. 응답 데이터와 커서 값 반환: 서버는 응답할 때 마지막으로 반환한 레코드의 커서 값(예: created_at)을 함께 반환합니다.

         json
         {
           "data": [...],
           "next_cursor": "2024-10-04 12:00:00"
         }

      3. 다음 페이지 요청 시 커서 값 전송: 클라이언트는 다음 페이지를 요청할 때 next_cursor 값을 서버에 전달합니다.
      4. 서버에서 커서 값으로 쿼리 실행: 서버는 이 커서 값을 받아, 동적으로 쿼리에 넣어 데이터를 가져옵니다.

2) Cursor based 페이징 - offset 페이징 보완책

앞서 말한 offset의 성능이나 여러 버그를 해결할 수 있는 또다른 페이징 방법입니다.

2-1. Cursor based 페이징 형식과 내용

cusor paing의 경우 이름에서 유추 할 수 있듯이 커서로 무언가를 가르켜 페이징을 하는 방법입니다.

여기서 커서는? 마지막으로 조회한 콘텐츠입니다.

마지막으로 조회한 대상 그 다음부터 가져와!

이렇게 생각하면 됩니다.

예시를 함께 봐봅시다.

-- 예시 1: 마지막으로 조회한 책의 아이디가 4인 경우

-- 원래대로 구현하면, 마지막으로 조회한 책의 아이디를 가져와서
select * from book where book.likes < 
        (select likes from book where id = 4)
            order by likes desc limit 15;

-- 커서페이징으로 구현한 책 목록 조회 쿼리
select * from book where created_at < 
    (select created_at from book where id = 3)
        order by created_at desc limit 15;

-- 커서페이징으로 구현한 인기순 목록 조회 쿼리
select * from book as b
     join (select count(*) as like_count 
                    from book_likes 
                        group by book_id) as likes on b.id = likes.book_id
            where likes.like_count < (select count(*) from book_likes where book_id = 3)
                order by likes.like_count desc limit 15;

2-2. 위의 인기순 정렬에서 생기는 문제점과 해결

🔥 예를 들어 좋아요가 0개인 게시글이 400개이고, 공교롭게 마지막으로 조회한 책의 좋아요가 0개라면, 그리고 아직 뒤에 조회를 하지 않은 책이 있다면 => 다음 페이지에 책이 목록으로 조회가 되지 않음!

인기 순 정렬같이 같은 값이 있을 수 있는 경우, 정렬 기준이 하나 더 있어야 한다는 결론!!

해결코드

-- 좋아요 수가 같을 경우 PK값을 정렬 기준을 추가
select * from book as b
     join (select count(*) as like_count 
                        from book_likes
                            group by book_id) as likes on b.id = likes.book_id
            where likes.like_count < (select count(*) from book_likes where book_id = 3)
                order by likes.like_count desc, b.id desc limit 15; 
                -- 좋아요 갯수가 같은 book이 15개가 넘어가면 그 이상의 것은 무시가 됨

LPAD 함수를 이용한 해결 코드

SELECT b.*,
       CONCAT(LPAD(likes.like_count, 10, '0'), LPAD(b.id, 10, '0')) AS cursor_value
FROM book AS b
JOIN (SELECT book_id, COUNT(*) AS like_count
      FROM book_likes
      GROUP BY book_id) AS likes ON b.id = likes.book_id
HAVING cursor_value < (SELECT CONCAT(LPAD(like_count_sub.like_count, 10, '0'), LPAD(like_count_sub.book_id, 10, '0'))
                FROM (SELECT book_id, COUNT(*) AS like_count
                      FROM book_likes
                      GROUP BY book_id) AS like_count_sub
                WHERE like_count_sub.book_id = 3) # 여기에 cursor_value 값이 들어가면 됨.
ORDER BY likes.like_count DESC, b.id DESC
LIMIT 15;

--  having 절 없이, where 절로 구현하면
SELECT b.*,
       CONCAT(LPAD(likes.like_count, 10, '0'), LPAD(b.id, 10, '0')) AS cursor_value
FROM book AS b
JOIN (SELECT book_id, COUNT(*) AS like_count
      FROM book_likes
      GROUP BY book_id) AS likes ON b.id = likes.book_id
WHERE CONCAT(LPAD(likes.like_count, 10, '0'), LPAD(b.id, 10, '0')) < 
      (SELECT CONCAT(LPAD(like_count_sub.like_count, 10, '0'), LPAD(like_count_sub.book_id, 10, '0'))
       FROM (SELECT book_id, COUNT(*) AS like_count
             FROM book_likes
             GROUP BY book_id) AS like_count_sub
       WHERE like_count_sub.book_id = 3) # 여기에 cursor_value 값이 들어가면 됨.
ORDER BY likes.like_count DESC, b.id DESC
LIMIT 15;

• LPAD 함수란?: 문자열의 길이를 지정하고, 지정된 길이만큼 왼쪽을 특정 문자로 채워주는 함수

  LPAD 함수의 기본 사용법

    LPAD(문자열, 목표 길이, 채울 문자)

  • 문자열: 왼쪽을 채울 대상이 되는 문자열.

  • 목표 길이: 최종적으로 만들어질 문자열의 전체 길이.

  • 채울 문자: 목표 길이를 채우기 위해 문자열 왼쪽에 추가할 문자.

    예를 들어, LPAD('123', 5, '0')는 결과로 '00123'을 반환

  ---

  예제 쿼리 cursor_value 생성:

  • CONCAT(LPAD(likes.like_count, 10, '0'), LPAD(b.id, 10, '0'))를 사용하여 cursor_value를 생성.

  • like_count와 book_id를 각각 10자리 숫자 문자열로 변환하고 결합하여 좋아요 수와 책 ID 기반의 고유한 정렬 기준을 만듦.

  • 페이징 조건*:

  • HAVING cursor_value < (...) 구문에서 cursor_value를 기준으로 커서 페이징을 구현

  • 서브쿼리에서 book_id = 3인 책의 cursor_value를 가져와, 이 값을 기준으로 이전 책 목록을 15개까지 조회

3) Offset 페이징 vs Cursor based 페이징

그렇다면 커서 페이징이 어떻게 offset 페이징의 문제점을 극복하는지 서로를 비교하면서 봐보겠습니다.

1. 성능 문제 극복

Offset 페이징의 주요 문제는 페이지가 뒤로 갈수록 많은 데이터를 건너뛰기 위해 DB가 불필요한 계산을 수행해야 한다는 점입니다.

• Offset 방식: OFFSET 값만큼 데이터를 스캔한 후, 해당 범위를 제외하고 필요한 데이터를 반환. 페이지가 뒤로 갈수록 처리 시간이 증가.
• Cursor 방식: WHERE 조건을 통해 필요한 데이터만 직접 조회하므로, 건너뛰는 데이터를 처리하지 않아 효율적.

예시: 100만 개의 데이터에서 1만 번째 페이지를 조회

• Offset 방식 쿼리:

  SELECT * 
  FROM book 
  ORDER BY created_at DESC 
  LIMIT 10 OFFSET 99990; -- 앞의 99990개를 건너뜀

  • 이 경우, DB는 99990개의 데이터를 스캔하고 버린 후 필요한 10개를 반환.
• Cursor 방식 쿼리:

  SELECT * 
  FROM book 
  WHERE created_at < '2024-10-04 12:00:00' -- 마지막 커서 값
  ORDER BY created_at DESC 
  LIMIT 10;

  • WHERE 조건을 사용하여 필요한 데이터만 조회. 건너뛰는 데이터 스캔이 없으므로 성능이 훨씬 우수.

2. 데이터 중복 및 누락 문제 극복

Offset 방식은 데이터가 추가/삭제될 경우 페이지 간 데이터 중복이 발생할 가능성이 높습니다.

• 문제 상황: 사용자가 1페이지를 보고 2페이지로 넘어가는 사이에 새로운 데이터가 추가되면, 다음 페이지에서 이미 본 데이터가 다시 나타날 수 있음.

예시

• Offset 방식:

  1. 1페이지 쿼리:

     SELECT * 
     FROM book 
     ORDER BY created_at DESC 
     LIMIT 10 OFFSET 0; -- 처음 10개

  2. 2페이지 쿼리:

     SELECT * 
     FROM book 
     ORDER BY created_at DESC 
     LIMIT 10 OFFSET 10; -- 다음 10개

     • 1페이지와 2페이지 사이에 새로운 데이터가 추가되면, 중복 데이터가 포함될 가능성이 높음.

• Cursor 방식:

  1. 1페이지 쿼리:

     SELECT * 
     FROM book 
     ORDER BY created_at DESC 
     LIMIT 10;

     • 마지막 커서 값: created_at = '2024-10-04 12:00:00'.
  2. 2페이지 쿼리:

     SELECT * 
     FROM book 
     WHERE created_at < '2024-10-04 12:00:00' -- 마지막 커서 기준
     ORDER BY created_at DESC 
     LIMIT 10;

     • 새 데이터가 추가되더라도 커서 값 이후의 데이터만 조회하므로 중복 발생 없음.

3. 안정적인 정렬 보장

Cursor 페이징은 일반적으로 정렬 가능한 고유한 값(예: created_at, id)을 기반으로 데이터를 조회합니다.

• Offset 방식: 데이터 정렬 순서가 변경될 경우, 페이지 이동 시 정확한 데이터를 보장하기 어려움.
• Cursor 방식: 특정 정렬 기준(예: created_at)을 유지하며 데이터를 조회하므로 일관성 있는 결과를 보장.

결론 : Offset 기반 페이징 vs Cursor 기반 페이징 비교 표

요약

• Offset 기반 페이징은 간단하고 빠르게 구현할 수 있지만, 대규모 데이터셋이나 실시간 데이터 동기화에는 적합하지 않음.
• Cursor 기반 페이징은 성능과 데이터 정합성을 보장하며, 대규모 데이터 처리 및 실시간 시스템에서 매우 효과적.

Tip: 선택은 데이터 크기, 성능 요구사항, 정렬 기준에 따라 결정해야 하며, 대규모 데이터 처리에서는 Cursor 기반 페이징이 권장됩니다.

오늘 배운 것 정리

1. sql 기본 문법인 join과 subquery
2. ERD 바탕으로 쿼리 짜는 법(데이터 가져오기, 목록 조회, ~순 나열)
3. 페이징(오프셋, 커서)을 사용해서 목록을 조회하는 방법

수고하셨습니다~! 다음 포스팅에는 본격적으로 API에 대해 알아보겠습니다! 🤗

1. 주제

• SQL과 NoSQL에 대해 이해
• 데이터베이스 설계 방법 학습
• local DB 연결

2. SQL과 NoSQL

먼저 데이터베이스를 만드는 데 가장 기본이 되는 데이터베이스 언어에 대해 살펴봅시다. 언어는 크게 SQL과 NOSQL이 있는데, SQL은 Stands for Structured Query의 약자로 주로 관계형 데이터 베이스에 이용이 되고 NoSQL은 Not Only SQL의 약자로 SQL이 아닌 나머지를 의미합니다. 더 자세히 살펴봅시다.

• SQL: 관계형 데이터베이스를 사용하는 시스템(RDBMS)에서 데이터를 관리하는 데 사용되는 언어 <- 주로 사용!!

  • 입출력 속도보다는 정확도와 입출력이 중요할 때 적합(데이터를 메모리 중심이 아닌, 테이블 구조로 저장하기 때문에 디스크 I/O 작업이 많아지는 데 영향)
    • 데이터가 일관되고 테이블 간의 관계가 잘 정의된 구조화된 데이터에 좋음
    • 관계를 맺고 있는 데이터가 자주 변경되는 경우 좋음
      • NoSQL에서는 관계를 맺고 있는 컬렉션들을 모두 수정해야 하기 때문에 비효율적
    • 우리가 주로 사용하는 MySQL, PostgreSQL ...이 모두 포함

• NoSQL = Not Only SQL의 약자로 SQL이 아닌 나머지

  • key-value, document, graph 등 다양한 데이터 구조를 지원
    • 데이터가 미리 정의된 스키마를 따르지 않고 데이터 요소 간의 관계가 잘 정의되어 있지 않은 반정형 또는 비정형 데이터에 적합
    • 막대한 양의 데이터를 다뤄야 하는 경우 적합
    • MongoDB, Redis 등 존재

  보편적으로 SQL을 사용하므로, 이를 사용해 앞으로의 내용을 다뤄보자.

3. 데이터베이스 설계 - ERD

*프로젝트 개발 시작과 동시에 설계하는 게 좋음. * - 기획과 디자인이 어느 정도 나와 기능이 정해지면, DB를 먼저 설계하고 코드 작업에 들어가야 합니다. *모든 서버 팀원이 인지하는 DB는 동일해야 함. * - 자기 마음대로 DB를 설계하고, 작업 후 나중에 합치는 행위는 혼동을 일으키고 비효율적인 중복 작업을 만들어낼 수 있으므로 자제해야합니다!! 😐

그렇다면, 데이터베이스 설계의 결과물인 ERD에 대해 더 살펴봅시다.

ERD(Entity-Relationship Diagram)란?

• 데이터베이스에서 엔티티와 관계를 시각적으로 표현한 다이어그램
  • 엔티티란 뭐냐면... => 즉, 데이터베이스 테이블 간의 관계를 표현한 다이어그램이라고 생각하면 이해하기 쉽습니다!
    • 저장할 가치가 있는 데이터 객체
    • 현실 세계의 사물이나 개념 표현한 것
    • 데이터베이스 내에서 테이블로 표현
    • 독립적으로 존재
    • 여러 속성이 있음
    • 기본키를 통해 고유하게 식별 가능
• 테이블, 속성, 관계를 그림으로 표현하여 데이터 모델을 설계할 때 사용
• 저는 dbdigram로 그리는 게 제일 편했는데, 주로 ERDcloud를 통해 다같이 작업하는 편입니다.

+참고. sql 문법에 대한 기본 지식

• 외래키

  • FK(Foreign Key)
  • 다른 테이블의 기본 키를 참조하는 키
  • 두 테이블 간의 연관 관계를 정의하며, 데이터의 일관성을 유지하는 데 사용

• 기본키

  • PK(Primary Key)
  • 테이블에서 각 행을 유일하게 식별할 수 있는 키
  • 하나의 테이블에는 하나의!! 기본키만!! 존재
  • 중복 X, NULL X
  • 기본키가 존재하지 않을 수도 있기는 한데, 권장되지는 않음
  • 정의하는 방법
    • 기본 키 정의 방법 (SQL): 기본 키는 테이블을 생성할 때 PRIMARY KEY 제약 조건을 사용하여 정의할 수 있습니다.
    1. 단일 컬럼을 기본 키로 정의:

       CREATE TABLE Students (
        student_id INT PRIMARY KEY,  -- student_id가 기본 키로 정의됨
        name VARCHAR(100),
        age INT
       );

    • 이 경우, student_id는 기본 키로 설정되었고, 중복되거나 NULL 값을 가질 수 없게 됩니다.

  2. 복합 키(두 개 이상의 컬럼을 묶어 기본 키로 정의):

      CREATE TABLE Enrollment (
          student_id INT,
          course_id INT,
          enrollment_date DATE,
          PRIMARY KEY (student_id, course_id)  -- student_id와 course_id가 복합 기본 키로 정의됨
      );

     • 이미 존재하는 테이블에 기본 키 추가: : 테이블이 이미 만들어진 경우, 기본 키를 추가하려면 ALTER TABLE을 사용

       ALTER TABLE Students
       ADD PRIMARY KEY (student_id);

 - `AUTO_INCREMENT` 의 사용
      - PRIMARY KEY의 속성 중 하나
      - 삽입되는 레코드에 유니크한 값을 자동적으로 부여
      - 일반적으로 1부터 증가하며 값을 부여하지만, 별도의 다른 값을 부여할 수도 있음

```sql
CREATE TABLE user {
     id int PRIMARY KEY AUTO_INCREMENT
            }

---
자 이제 ERD를 작성하는 방법에 대해 더 자세히 살펴보도록 하자. 
## 3-2. ERD 작성의 기본 규칙

- 테이블 이름과 칼럼 이름은 모두 소문자, 단어 구분은 대소문자가 아닌 밑줄로 구분해줘야 함
  - SQL 표준에서 테이블 이름과 칼럼 이름의 대소문자를 구분하지 않는 것으로 처리하기 때문
- 기본 키를 위해 index를 따로 두는 것이 편함.
- 각 index를 위한 id를 book_id, member_id가 아닌, 그냥 id로 이름을 짓는 것이 좋음
- 기본 키 타입은 int가 아닌 추후 서비스 확장을 고려해서 bigint로

<span style="background-color:#F5F5F5"> **기본 entity #1**</span>
![](https://velog.velcdn.com/images/funda__mental_/post/51e6609c-c8cf-43bf-8188-3a7ce48f1efd/image.png)
_MySQL에서 varchar(20)는 최대 20글자인데, 유니코드 기준 20글자니, 한글 20글자로 생각_
- varchar로 두는 경우는, enum으로 관리하는 경우 (ex. gender: man, woman)
- created_at, 그리고 updated_at을 테이블마다 추가해주는 것이 좋음 - 최신순 정렬 등의 목적
    - <u>Datetime VS Timestamp</u>
      - datetime(6)에서 (6)은 밀리초 소수점 6자리까지 구분한다는 의미 - 밀리초 소수점까지 고려하지 않으면, 최신순 정렬이 어려울 수 있음 
       -  Timestamp 타입의 값은 현재 시각 → UTC 시각으로 변환되며 Datetime은 변환되지 않음. => Timestamp이 더 호환성 좋음!

<span style="background-color:#F5F5F5"> **기본 entity #2: member entity**</span>
![](https://velog.velcdn.com/images/funda__mental_/post/4a107960-8200-4f5f-b4e4-709a68edec03/image.png)
- member 테이블은 status와 inactive_date를 두는 것이 좋음 
=> **soft delete**를 위함 (꼭 member가 아니어도 다양한 곳에 적용 가능)
   - Hard delete: 회원 탈퇴, 게시글 삭제 등의 연산을 HTTP Method 중 Delete로 바로 삭제를 해 버리는 방법 => No!
    - 문제가 발생할 수 있음. ex) 회원 탈퇴를 철회하고 다시 돌아오는 회원들이 존재하는 경우처럼 복구하기 어려움
   - Soft delete: 비활성 상태로 두고, 일정 기간동안 비활성인 경우 자동 삭제가 되도록 설계
     - status가 inactivate된 지 얼마 뒤에(inactivate_date로 count), batch 사용해서 삭제
       - batch: 정해진 시간에 자동으로 실행되는 프로세스로, 대개 하루가 끝날 때나 야간과 같이 컴퓨팅 리소스 사용량이 적은 시간에 task를 batch로 처리, batch는 HTTP Method 중 Patch -  레코드 자체를 삭제하는 것이 아니라, 레코드의 특정 필드(ex: is_deleted, deleted_at 등)만 업데이트하는 것이기 때문

## 3-3. 연관 관계
ERD에서 Entity 하나하나를 설계하는 것도 중요하지만, 이들간의 관계를 연결하는 것도 매우 중요합니다! 이에 대해 자세히 살펴봅시다. 

- <span style="background-color:#fff5b1">**1:N**</span>의 경우, N 쪽이 외래키를 가짐
- <span style="background-color:#fff5b1">**N:M**</span>의 경우
  양쪽에 대해 서로 a가 b 여러 개 적용 가능, b가 a 여러 개 적용 가능이면, N:M 관계 
 가운데 매핑 테이블이 양쪽의 기본키(PK)를 외래키(FK)로 가지고 각각 1:N의 관계를 가짐

- 알림과 같이, 알림 중에서 여러 type이 구분되는 경우를 연관관계를 활용해 다양하게 설계 가능!
     ** 1. 슈퍼타입과 서브타입의 구성**
          ![](https://velog.velcdn.com/images/funda__mental_/post/392221a4-51d1-4b1a-9c02-84de99f84091/image.png)
   - **슈퍼 타입**: `알림(alarm)`
     공통적으로 모든 알림이 가져야 할 속성들을 정의 ⇒ 공통적인 알림의 동작과 속성들을 관리
      : `알림 ID`, `제목`, `내용`,`생성 시간`,`읽음 여부`, 등등...
    - **서브 타입 ⇒** 각각의 알림 타입에 특화된 정보를 관리
         - **공지 알림(notice)**: 공지 사항과 관련된 알림.
                - 추가적으로 "공지사항 ID" 같은 공지 사항으로 이동할 때 필요한 정보를 포함.
         - **마케팅 알림(marketing)**: 마케팅과 관련된 알림.
                - 추가적으로 "마케팅 ID" 같은 마케팅 관련 정보를 포함.
    ** 2. 하나의 테이블을 두고 dtype으로 구분**
          ![](https://velog.velcdn.com/images/funda__mental_/post/8af9a505-ce7e-4c93-a12d-05789d22ac46/image.png)
        ![](https://velog.velcdn.com/images/funda__mental_/post/44d602bb-c6b5-429e-98a0-96b690e6d1f1/image.png)


 **  3. 그냥 각각 테이블 다 나누기: 각 type마다 다른 알람 entity를 만드는 방법**

---
## 4. local DB 접속해서 DB 설계하기 
다음으로는, 실제로 local DB에 접속해서 설계한 ERD를 바탕으로 데이터베이스를 만들어보겠습니다. 
> intelliJ로도 접속할 수 있는 방법이 있어서 그 방법을 소개하겠습니다! 
1. Intellij에 접속해서 DataBase로 들어가기
![](https://velog.velcdn.com/images/funda__mental_/post/d4f47a55-25d7-4152-8ff3-1f0a0ddd62fc/image.png)
2. Data Source에서 MySQL을 클릭
![](https://velog.velcdn.com/images/funda__mental_/post/3e9a3b86-ee3a-4dcb-a005-6bb5a57a0262/image.png)
3. mysql에 하는 것처럼 Host, User, Password에 알맞은 값을 넣고 Test Connection을 눌러서 Succeeded가 나오면 성공


----
오늘은 백엔드 서버의 핵심이 DB 설계와 ERD에 대해 배워봤는데요. 다음 시간에는 실제로 어떻게 SQL문을 작성해야하는지 알아봅시다!😊

1) 클래스

• 학생을 지칭하는 새로운 형태를 하나 정의하고, 그 형태를 이루기 위한 요소로 (국어, 영어, 수학)을 정의
• 형태

  class Student:
    def __init__(self, kor, eng, math = 40):
        self.kor = kor
        self.eng = eng
        self.math = math

__init__ 함수는 이 Student 클래스의 형태를 정의하는, 생성자(constructor) 라 불리는 함수입니다. self를 항상 첫 번째 인자로 넣어주고, self는 학생을 지칭 인자로 넘어오는 kor, eng, math는 현재 학생의 kor, eng, math라는 값이 되어야 하기 때문에 그 값을 대입해 주는 식으로 코드를 작성하며, 이때 이러한 kor, eng, math 값을 멤버 변수라고 부릅니다.

위의 클래스를 이용하면 다음과 같이 학생 정보를 저장하는 코드를 작성해볼 수 있습니다. Student를 마치 함수를 호출 할때처럼 사용하며, __init__ 함수에 self 다음에 인자가 정의되어 있는 순서대로 값을 적어주게 되면, 각각의 값을 갖는 하나의 학생 객체(instance) 를 만들어내게 됩니다. 이 객체는 kor, eng, math 라는 이름의 멤버 변수를 갖으며, 이 값들을 조회하기 위해서는 객체이름.멤버변수이름 형태로 사용이 가능합니다.

student1 = Student(90, 80, 90)
print(student1.kor)  # 90
print(student1.eng)  # 80
print(student1.math) # 90

이처럼 원하는 형태의 Class를 선언하고, 해당 Class를 이용하여 원하는 객체를 만들게 되면, 원하는 형태 단위로 값을 관리할 수 있게 됩니다.

2) tuple

• tuple
  • 새로운 형태를 정의할 때 class를 만들지 않고 진행하는 방법
  • 소괄호로 둘러쌓인 형태로 정의되어 있는 것
  • 리스트와 비슷하지만, 크게 2개의 차이점이 존재 - tuple은 immutable
    • 튜플에 들어있는 값은 수정할 수 없음
    • 튜플에 추가 원소를 넣거나 기존 원소를 제거하는 것은 불가능
  • 기본값 개념 없음

def hello():
    return 1, 2

print(hello()) # (1, 2)

• 튜플의 주 된 역할은 패킹과 언패킹

  def hello():
    return 1, 2
  

a, b = hello() # a, b = (1, 2) - 튜플 언패킹 (Tuple Unpacking) print(a, b, a + b)

- 패킹
    - 즉 여러개의 값을 하나의 변수에 넣을 수 있는 방법이 있을까요?
- 리스트
```python
dt = [1, 2, 3, 4, 5]

• 튜플

  dt = 1, 2, 3, 4, 5

그렇다면 어떻게 class 대신 tuple을 이용해 원하는 형태를 담을 수 있을까요?

다음과 같이 tuple 형태로 값을 저장하면 됩니다.

student1 = (90, 80, 90)

다만, tuple을 이용하는 경우에는 각 값이 의미하는 것이 무엇인지 알기 어렵기 때문에, 값을 이용할 때 되도록이면 unpacking을 통해 꼭 적절한 이름을 붙여준 뒤 사용하는 것을 권장합니다.

다음과 같이 각 원소에 대해 unpacking시 적절한 변수 이름을 사용하여 의미를 부여한 뒤, 사용

student1 = (90, 80, 90)
kor, eng, math = student1
print(kor, end, math) # 90 80 90

그렇다면 tuple에 이미 들어있는 값은 어떻게 바꿀 수 있을까요?
tuple은 immutable하기 때문에 원소 값을 바꿀 수 없다고 했었습니다. 따라서 tuple에 있는 원소의 값을 의미상 바꾸기 위해서는 다음과 같이 꼭 새로운 tuple을 생성해줘야만 합니다. 다음은 수학 점수만 90점으로 바꾼 예입니다.

student1 = (0, 0, 0)
kor, eng, math = student1
print(kor, eng, math) # 0 0 0

student1 = (kor, eng, 90)

kor, eng, math = student1
print(kor, eng, math) # 0 0 90

tuple 이용시 만약 수학 점수만 필요한 경우라면, 코드를 어떻게 작성해주는 것이 좋을까요?
바로 unpacking시 국어, 영어 점수와 같이 필요 없는 곳에는 _를 넣어 사용하지 않겠다는 의미 부여를 해주는 것이 좋습니다.

student1 = (90, 80, 90)
_, _, math = student1 # 수학 점수만 사용하겠다는 의지
print(math) # 90

3) 객체를 원소로 하는 리스트

class를 이용한 객체 리스트

국어, 영어, 수학 점수를 포함한 학생 5명의 정보를 쉽게 표현해볼 수는 없을까요? 이는 class를 이용한 객체 선언과 동시에, 이 각각의 객체를 원소로 갖는 리스트를 이용하여 깔끔하게 정의가 가능합니다.

class Student:
    def __init__(self, kor, eng, math):
        self.kor = kor
        self.eng = eng
        self.math = math

students = [
    Student(90, 80, 90), # 첫 번째 학생
    Student(20, 80, 80), # 두 번째 학생
    Student(90, 30, 60), # 세 번째 학생
    Student(60, 10, 50), # 네 번째 학생
    Student(80, 20, 10), # 다섯 번째 학생 
]

student3 = students[2] # 세 번째 학생 정보
print(student3.kor)  # 90
print(student3.eng)  # 30
print(student3.math) # 60

아직 점수 확정되지 않은 5명 학생의 정보를 정의하기 위해서는, class 정의시 각 점수의 기본값을 설정해주고, 다음과 같이 리스트에 각 객체를 넣어 정의해 줄 수 있습니다.

class Student:
    def __init__(self, kor=0, eng=0, math=0):
        self.kor = kor
        self.eng = eng
        self.math = math

students = []
for _ in range(5):
    students.append(Student()) # 5명의 학생 추가
    # students = [Student() for _ in range(5)] #  [list comprehension]으로 대체가 가능
# 입력 받는 경우
    # for _ in range(5):
        # kor, eng, math = tuple(map(int, input().split()))
        # students.append(Student(kor, eng, math))

student3 = students[2] # 세 번째 학생 정보
print(student3.kor)  # 0
print(student3.eng)  # 0
print(student3.math) # 0

tuple을 이용한 객체 리스트

국어, 영어, 수학 점수를 포함한 학생 5명의 정보를 tuple을 이용하면 다음과 같이 표현이 가능합니다.

students = [
    (90, 80, 90), # 첫 번째 학생
    (20, 80, 80), # 두 번째 학생
    (90, 30, 60), # 세 번째 학생
    (60, 10, 50), # 네 번째 학생
    (80, 20, 10), # 다섯 번째 학생 
]

student3 = students[2] # 세 번째 학생 정보
kor, eng, math = student3
print(kor)  # 90
print(eng)  # 30
print(math) # 60

만약 5명의 학생 정보를 입력받아 리스트를 만드는 경우라면, 다음과 같이 코드 작성이 가능합니다. 지금처럼 list comprehension을 이용하면 더욱 깔끔하게 작성이 가능합니다.

students = [
    tuple(map(int, input().split()))
    for _ in range(5)
]

student3 = students[2] # 세 번째 학생 정보
kor, eng, math = student3
print("student3:", kor, eng, math)

>> 90 80 90
   20 80 80
   90 30 60
   60 10 50
   80 20 10

student3: 90 30 60

• 도전문제
  • 미래의 기상을 예측한 데이터가 n개 주어집니다. 각 데이터에는 날짜, 요일, 날씨의 정보가 순서대로 담겨있을 때, 가장 근 시일내에 비가 오는 날을 찾아 출력하는 프로그램을 작성해보세요.

단, 데이터에서 주어지는 연도의 범위는 2,000≤Y≤2,100 입니다.

• 입력 형식 첫 번째 줄에 정수 n이 주어집니다. 두 번째 줄부터는 n개의 줄에 걸쳐 각 예측 정보에 대한 날짜, 요일, 그리고 날씨에 대한 정보가 공백을 사이에 두고 주어집니다. 날짜는 yyyy-mm-dd 형태로 주어지며 요일, 날씨의 경우 알파벳으로만 이루어져 있는 단어 형태로 주어짐을 가정해도 좋습니다. 비가 오는 날씨의 경우 Rain이라는 이름으로 주어집니다.

• 1≤n≤100

• n 개의 데이터 중에서 비가 오는 날이 적어도 하루 존재합니다.

• 출력 형식 첫 번째 줄에 가장 근 시일내에 비가 오는 날의 정보를 날짜, 요일, 날씨 순으로 주어진 포맷과 동일하게 출력합니다.

입출력 예제

예제1

입력:

4
2036-12-27 Sun Snow
2052-08-28 Wed Rain
2043-03-21 Sat Sun
2077-08-19 Thu Rain

출력:

2052-08-28 Wed Rain

• 정답

  # 변수 선언 및 입력
  n = int(input())
  
  

Forecast 정보를 나타내는 클래스 선언

class Forecast: def init(self, date, day, weather): self.date, self.day, self.weather = date, day, weather

ans = Forecast("9999-99-99", "", "")

for _ in range(n): date, day, weather = tuple(input().split()) # Forecast 객체를 만들어 줍니다. f = Forecast(date, day, weather) if weather == "Rain": # 비가 오는 경우 가장 최근인지 확인하고, # 가장 최근일 경우 정답을 업데이트합니다. if ans.date >= f.date: ans = f

결과를 출력합니다.

print(ans.date, ans.day, ans.weather)

```

• 틀린 이유
  1. date가 스프링으로 들어가있는데 그대로 비교가 되는지 몰랐음.
  2. 저렇게 객체를 만들 생각을 하지 못함.

뒤집는 법- 1

arr.sort(reverse=True) print(arr) # [81, 60, 41, 37, 25, 20, 19, 12]

뒤집는 법 - 2

arr = [12, 41, 37, 81, 19, 25, 60, 20] arr.sort() arr = arr[::-1] # reversed array print(arr) #[81, 60, 41, 37, 25, 20, 19, 12]

- `sorted()`라는 함수
    -  **단, sorted 함수는 정렬된 리스트를 반환하는 함수이기 때문에, 다음과 같이 정렬 이후의 리스트를 변수에 할당을 해줘야만 합니다.**
```python hl:2
arr = [12, 41, 37, 81, 19, 25, 60, 20]
arr = sorted(arr)
print(arr) # [12, 19, 20, 25, 37, 41, 60, 81]

• 문자열 정렬

  string = "banana"
  arr = list(string)
  arr.sort()
  print(arr) # ['a', 'a', 'a', 'b', 'n', 'n']
  sorted_str = ''.join(arr)
  print(sorted_str) # aaabnn

sorted() 함수는 어떨까요? sorted 함수의 경우에는, 문자열을 함수 인자로 넣더라도, 이를 성공적으로 정렬해줍니다. 다만, 결과물이 list로 나오는 것을 확인할 수 있습니다. 따라서 sorted 함수를 이용한 이후에 다시 join함수를 이용해 문자열을 만들어주면 됩니다.

string = "banana"
sorted_arr = sorted(string)
print(sorted_arr) # ['a', 'a', 'a', 'b', 'n', 'n']
sorted_str = ''.join(sorted_arr)
print(sorted_str) # aaabnn

• 문자열 리스트 정렬 - 일반 리스트와 동일

  words = ["banana", "apple", "cat", "app"]
  words.sort()
  print(words) # ['app', 'apple', 'banana', 'cat']

! 복기: print( , end=" ")- 이렇게 해야 공백으로 받을 수 있어

 def print_5_stars():
    print("*" * 5)


for _ in range(4):
    print_5_stars()

def print_n_lines(n): # n: 함수의 인자
    코드 작성

def print_rect(n, m):
    코드 작성

def add(a, b):
    return a + b

add(a,b) # 함수 호출

def add(a, b, c=0): # 기본값 설정해주기
    return a + b + c  # 함수는 `return` 을 만나게 되면 그 즉시 종료

• 함수와 함수 혹은 다른 코드와의 줄 간격은 일반적으로 2줄을 띄기
• 의미 단위로 _를 붙여 구분해주는 snake case

• 도전문제: 최소공배수 구하는 문제

  k = list(map(int, input().split()))
  n, m = k[0], k[1]
  

def guess_min(n,m):     a = 1     x, y = 0, 0     i = 2

    while i <= min(n,m):         x = n % i         y = m % i         if x == 0 and y == 0:             n = n // i             m = m // i             a = ai             # 같은 i로 실행되게 해야 돼         else:             i += 1     a = an*m     print(a)     guess_min(n,m)

- 모범답안: 최소공배수 = `a*b / (a와b의 최대공약수)`
```python hl:7=8,11
# 변수 선언 및 입력:
n, m = tuple(map(int, input().split()))

# n과 m의 최소공배수를 출력합니다.
def find_lcm(n, m):
    gcd = 0
    for i in range(1, min(n, m) + 1):
        if n % i == 0 and m % i == 0:
            gcd = i

    print(n * m // gcd)


find_lcm(n, m)

• 참고: 그렇게 되는 이유 ![[Pasted image 20240804233647.png]]

• 여러수의 최소공배수.. 접근방법 팁 (스포주의)

• 기본적인 두 수의 최대공약수, 최소공배수를 구하고

두 수 a, b의 최대공약수 gcd
두 수 a, b의 최소공배수 lcm = (a * b) // gcd

• 처음에 잘못된 접근방법

세 수 a, b, c의 최대공약수 = 두 수 a, b의 최대공약수인 g와 c의 최대공약수 gcd
세 수 a, b, c의 최소공배수 = (a // gcd) * (b // gcd) * (c // gcd) * gcd

샘플케이스는 통과 하지만 간단하게 arr = [2,3,4] 이런 경우만 생각해봐도
리턴값은 12가 나와야하지만, 위의 방식으로 접근하면24라는 잘못된 값이 나오는걸 알 수 있습니다.

• 제대로된 접근방법

세 수 a, b, c의 최소공배수 = 두 수 a, b의 최소공배수인 l과 c의 최소공배수 lcm

    while len(arr) >= 2:
        a = arr.pop()
        b = arr.pop()
        arr.append(lcm(a,b))

리스트에서 맨 뒤 2개의 수를 꺼내 최소공배수를 구하고, 리스트에 추가해주는 방식을 반복
마지막에 arr 리스트에 1개의 값만 있을 경우, 이 값이 n개수의 최소공배수가 됩니다.

단순하게 2개씩 구하면서 넘어가면되는 간단한 문젠데, 저처럼 방법때문에 삽질하시는 분들 계시다면....
참고하셔도 좋을것 같네요 ㅎㅎ

• 인자가 2개가 넘어오든, 3개, 4개 몇 개가 넘어오든 넘어온 값들의 합을 반환해주는 함수
  • *(asterisk)을 사용하면 인자 개수에 상관없이 tuple이라는 형태로 값들을 받아올 수 있음

    def add(*args):
    return sum(args)
    

add(1, 3, 2, 6, 5, 4) 21

- 고난도 문제 함수로 해결하기
    - `단 하나라도` 라는 조건이 들어가는 경우에는, 주로 True / False 값을 갖는 bool 타입의 변수를 하나 선언하여 해결
    - if 조건문으로만 해결하기에는 조건이 상당히 까다로울 때, 함수와 bool type 변수를 통해, return으로 구현

## 2. Call by value / Call by reference / 두 정수 값 교환하기
- Python에서는 변수의 type에 따라 immutable과 mutable한 것으로 나뉨
    - ==[Call by value] immutable한 type: tuple, string 그리고 int, bool 등을 포함한 primitive type==
        - immutable 특성을 갖는 변수가 함수의 인자로 넘어가게 되면, <u>변할 수 없는 특성</u> 때문에 그 변수가 그대로 넘어가는 것이 아닌, **변수가 갖고 있던 값을 복사**하여 값을 넘겨줌
        - 함수 안에서 어떠한 일이 일어나더라도 전혀 밖에 있는 변수에 영향을 끼치지 않음
        - 함수 안에서의 역할이 밖에 있는 변수에도 영향을 끼치고 싶다면, 아래와 같이 해당 문자열 자체를 반환하는 함수 작성
    - ==[Call by reference] mutable한 type: list, dict 등==
        - mutable한 변수를 함수 인자로 넘기게 되면 해당 변수 자체의 **주소**가 넘어가게 됨
        - 함수 안에서 해당 인자에 주는 모든 변화가 고스란히 함수 호출시 넘겼던 변수에 남게 됨
        -  함수로 값을 넘길때 다음과 같이 slicing을 하게 되면 기존 리스트와 동일한 원소를 갖는 **새로운 리스트**를 만들어 값을 넘겨주면 이거 방지 가능
```python hl:14,17
# n과 m의 값이 바뀌지 않음
def swap(a, b):
    a, b = b, a
    print(a, b)


n, m = 10, 20
swap(n, m)
print(n, m)

# 바뀜
def swap(a, b):
    a, b = b, a
    return a, b

n, m = 10, 20
n, m = swap(n, m)
print(n, m)

>> 20 10

def modify(arr): # arr는 _list와 관련이 없다.
    arr[0] = 10


_list = [1, 2, 3, 4]
modify(_list[:]) # 새로운 리스트를 만들어 넘기기

for elem in _list:
    print(elem, end=" ")

>> 1 2 3 4 # 값에 변화가 없다

3. 변수의 영역

1) 전역 변수(Global variable)

•  global 변수: 함수 위에 값들을 정의하게 되면, 어디에서도 쓰일 수 있음
  • 함수 안에서 바로 참조 가능
• local 변수: 함수 안에서 정의한 변수는, 함수를 벗어나면 더 이상 쓰일 수 없음
  • 함수가 종료되는 순간에 변수도 같이 사라지기 때문에, 다른 곳에서 사용이 불가함

modify 함수 안의 _list 변수를 global 변수로 인식하게 하려면, 다음과 같이 함수 안에 global 표식을 해줘야 합니다.

_list = [1, 2, 3, 4]


def modify():
    global _list # global 변수인 _list를 가져다 쓸 것이다.
    _list = [5, 6, 7, 8]


modify()
for elem in _list:
    print(elem, end=" ")

>> 5 6 7 8

num = 10


def modify():
    global num
    num = 5

modify()
print(num)

>> 5

• 같은 변수 이름을 갖는 경우 가장 가까이에 있는 변수를 사용

1. 재귀함수 형태

이 함수는 print_star(n - 1) 를 먼저 수행하여 1번째부터 n - 1번째 줄까지의 별을 알맞게 출력한 뒤, n번째 줄을 출력해보는 식

def print_star(n):    # 1부터 n번째 줄까지 별을 출력하는 함수
    if n == 0:        # n이 0이라면, 더 이상 진행하지 않고
        return        # 퇴각합니다.

    print_star(n - 1) # 1부터 n - 1번째 줄까지 출력하는 함수
    print("*" * 5)    # n번째 줄에 해당하는 별 출력


print("start")
print_star(3)
print("end")

• 종료 조건이 무조건 있어야 됨!!!!!!!!!!
  • 값을 반환하지 않는 함수에서, 해당 함수를 종료하고 싶을 때는 값 없이 return 적어주면 됨

def print_star(n):    # 1부터 n번째 줄까지 별을 출력하는 함수
    if n == 0:        # 종료 조건
        return

    print_star(n - 1) # 1부터 n - 1번째 줄까지 출력하는 함수
    print("*" * n)    # n번째 줄에는 n개의 별을 출력합니다.

위의 코드를 실행하면 예상과 동일한 결과를 얻을 수 있게 됩니다.

print_star(3)

>> *
   **
   ***

하지만 다음과 같이 print 함수와 print_star 함수를 호출하는 부분의 순서가 바뀌어있는 경우라면, 어떤 출력 결과를 받게 될지 예상이 되시나요?

def print_star(n):    # 1부터 n번째 줄까지 별을 출력하는 함수
    if n == 0:        # 종료 조건
        return

    print("*" * n)    # n번째 줄에는 n개의 별을 출력합니다.
    print_star(n - 1) # 1부터 n - 1번째 줄까지 출력하는 함수

바로 뒤집어진 삼각형 모양을 받게 됩니다. 그 이유는 1부터 n - 1번째 줄까지 출력을 진행하기 전에, 먼저 n개의 별을 출력하였기 때문입니다.

print_star(3)

>> ***
   **
   *

한 가지 예시를 더 살펴보겠습니다. 다음 코드를 실행하면 어떤 결과가 나오게 될까요?

def print_star(n):  
    if n == 0:      
        return

    print("*" * n)
    print_star(n - 1)
    print("*" * n)

바로 두 직각삼각형이 위아래로 붙어있는 모양을 받아보게 됩니다. 크게 봤을 때 상상을 해보면, print_star(n - 1)을 실행하기 직전에 n개의 별을 출력하고, n - 1개를 처리한 이후에 다시 n개의 별을 출력하므로 위아래로 n개를 출력하고 계속 안쪽으로 별을 채워넣어가는 모양이 될 것이라 예상할 수 있습니다.

print_star(3)

>> ***
   **
   *
   *
   **
   ***

이렇듯 재귀함수에서는 print문을 어디에 정의하는지에 따라 예상과는 아예 다른 결과를 받아보게 됩니다. -> 너무너무 헷갈림!!!!!!!!!!

2. 값을 반환하는 재귀함수

 - 값을 반환하는 재귀함수에서의 종료조건은 지극히 자명한, 계산 없이도 바로 결과를 알 수 있는 경우로 설정  - 값을 return해도 종료조건이 따로 있어야 됨

• 팩토리얼 함수

  • 1부터 n까지의 곱을 반환

    def fact(n):
    if n == 1:
      return 1
    
    return fact(n - 1) * n
    
    

print(fact(3))

6

- 점화식
    - An = An-1 + 2 * An-2
```python hl:9
def f(n):
    # 종료 조건
    if n == 1:
        return 2
    if n == 2:
        return 7

    # 점화식
    return f(n - 1) + 2 * f(n - 2)


print(f(4))

>> 25

•  input()함수를 이용해서 입력받음

  • 중간에 공백 있으면 공백도 인식됨

• 문자열 ≒ 1차원 배열

  given_input = "banana"
  

print(given_input[0]) # b <- 문자열의 첫 번째 문자 print(given_input[1]) # a <- 문자열의 두 번째 문자 print(given_input[2]) # n <- 문자열의 세 번째 문자

- 문자열의 경우에는 for loop 없이 print 함수만을 이용하여 출력 가능
```python
given_input = "banana"
print(given_input)

>> banana

하지만 일반 리스트의 경우, 리스트를 그대로 출력하면 리스트 type 형태로 나와서 for loop 필요

arr = [1, 2, 3]
print(arr)                   # [1, 2, 3] 그 자체로 출력됨

for elem in arr:             # 1 2 3 이렇게 출력됨
    print(elem, end=" ")     

• 문자열의 길이: print(len(given_input))
  • ['apple', 'banana', 'candy'] 여기서의 arr는 1차원 리스트이기 때문에, len(arr)를 출력하면 문자열의 개수 = 3
• 도전문제: 3개의 문자열이 주어졌을 때, 가장 긴 문자열과 가장 짧은 문자열의 길이 차가 얼마인지 구해보는 프로그램

  a = input()
  b= input()
  c = input()
  

a = len(a) b= len(b) c= len(c)

print(max(a,b,c) - min(a,b,c)) # 이런 식으로 max와 min 사용 가능

모범답안
```python
# 문자열을 입력받습니다.
str1 = input()
str2 = input()
str3 = input()

# 문자열의 길이를 구합니다.
len1 = len(str1)
len2 = len(str2)
len3 = len(str3)

# 세 문자열 중 가장 긴 길이와 가장 짧은 길이를 구합니다.
mx = max([len1, len2, len3])
mn = min([len1, len2, len3])

# 문제에서 구하고자 하는 값을 출력합니다.
print(mx - mn)

• max() 함수의 괄호 안에 들어갈 수 있는 값:

  1. 여러 개의 개별 인자:
     • max(1, 3, 2)는 3을 반환합니다.
     • max('apple', 'banana', 'cherry')는 cherry를 반환합니다. (사전 순으로 비교)
  2. 하나의 iterable (리스트, 튜플 등):
     • max([1, 3, 2])는 3을 반환합니다.
     • max(('apple', 'banana', 'cherry'))는 cherry를 반환합니다.
  3. key 인자를 사용하는 경우:
     • max(['apple', 'banana', 'cherry'], key=len)는 가장 긴 문자열인 banana를 반환합니다.
     • max([{'a': 1}, {'b': 2, 'c': 3}], key=len)는 가장 많은 키를 가진 딕셔너리 {'b': 2, 'c': 3}를 반환합니다.

• python에서 문자열을 정수로 변환하기 위해서는 문자열을 단순히 int() 함수

• 문자열로 변환하기 위해서는 정수를 단순히 str() 함수

  2. 문자열 리스트 관리

  arr = ["banana", "apple", "pizza"]
  

print(arr[0]) # banana <- 첫 번째 문자열 print(len(arr[0])) # 6 <- 첫 번째 문자열의 길이

print(arr[0][0]) # b <- 첫 번째 문자열의 첫 번째 문자 print(arr[0][1]) # a <- 첫 번째 문자열의 두 번째 문자 print(arr[0][2]) # n <- 첫 번째 문자열의 세 번째 문자

- 끝에 있는 3개의 문자열만 순서대로 출력하는 코드
```python hl:12
n = 5
# 방법1
arr = []
for _ in range(n):
    given_str = input()
    arr.append(given_str)

# 방법2
arr = [ input() for _ in range(n) ]

# 공통
for string in arr[-3:]:
    print(string) 

3. 문자열 붙이기

• 문자열끼리 + 연산
• join() 함수: 여러 문자열을 하나로 합치는 과정을 더 쉽게 구현 가능 join 함수는 각 원소들을 특정 구분값(sep)을 기준으로 합쳐주는 함수.

  sep.join(리스트)
  

','.join(['1', '2', '3']) -> '1,2,3' ':'.join(['11', '22', '33']) -> '11:22:33' ''.join(['a','b','c']) -> 'abc'

따라서 3개의 문자열을 합치는 코드를 다음과 같이 작성해볼 수 있습니다.
```python
a, b, c = "apple", "banana", "candy"
tot_str = "".join([a, b, c])
print(tot_str)

>> applebananacandy

4. 문자열 찾기

• 문자열 안에 찾는 거 존재하는지 여부
  • for loop 돌려서 찾기
  • in 키워드로 찾기
• 특정 문자열이 포함된 위치 구하기
  • for loop 돌리기
  • find() 함수 사용
    • 해당 부분 문자열이 없는 경우에는 -1을, 있는 경우에는 가장 앞에 나오는 부분 문자열의 위치를 반환
  • index() 함수로 찾기
    • 유의해야 할 점은, 부분 문자열이 없는 경우에는 다음과 같이 ValueError가 발생함

      s = 'appleabanana'
      

if 'ab' in s: print(s.index('ab')) else: print(-1)

s = 'appleabanana' print(s.find('bob'))

## 5. 문자열 내 문자 수정

- 문자열은 `immutable`, 즉 변할 수 없는 타입이기 때문에 내부 문자를 절대 변경할 수 없음
    - => 2가지 방법
        1. **아예 새로운 문자열을 만들어 주는 것**
            -  바뀌어야 하는 문자 양옆으로 slicing을 적용하여 해당 문자를 제외하고는 그대로 유지가 되도록 새로운 문자열을 만들어주는 방식
        - 2. **각 문자를 원소로 갖는 리스트로 변환**
            - 문자열을 `list()`라는 함수로 감싸면, 각 문자를 원소로 갖는 리스트가 만들어지고, 이러한 문자들로만 이루어진 리스트는 `join()` 함수를 이용하여 다시 문자열로 합쳐줄 수 있습니다.
```python hl:3,9,11
# 방법1
s = 'baaana'
s = s[:2] + 'n' + s[3:]
print(s)
>> banana

# 방법2
s = 'baaana'
arr = list(s)
arr[2] = 'n'
s = ''.join(arr)
print(s)

>> 'banana'

• 도전문제: 문자열이 주어지면, 문자열 내에서 두 번째 문자와 같은 문자들을 모두 첫 번째 문자로 바꾸어 출력하는 프로그램

  a = input()
  arr = list(a)
  m = a[0]
  n = a[1]
  for i in range(len(arr)): # 이때 그냥 for i in arr 이렇게 하면 바꿔도 반영 안돼!!
      if arr[i] == n:
          arr[i] = m
  a = ''.join(arr)
  print(a)

6. 문자열 내 문자 제거

• 방법1: slicing

  s = 'baknana'
  s = s[:2] + s[3:]
  print(s)
  

banana

- 방법2: 문자열을 list로 변환한 뒤, pop 함수를 이용해 해당 문자를 제거하고 다시 문자열로 변환
```python hl:3
s = 'baknana'
arr = list(s)
arr.pop(2)
s = ''.join(arr)
print(s)

>> banana

• 도전문제: 문자열 A가 주어졌을 때, 명령에 따라 문자열 A를 민 결과를 출력하는 프로그램을 작성해보세요. 명령은 L 또는 R 로 이루어진 명령 문자열로 주어지고, 명령에 따라 순서대로 다음을 반복합니다.
• L일 때는 좌측으로 한 칸 밀고, R일 때는 우측으로 한 칸 미는 것을 진행합니다.

  k = input()
  n = input()
  

for i in n:     if i == 'L':         k = k[+1:] + k[:+1]     else:          k = k[-1:] + k[:-1] print(k)

- 처음에 L과 R의 계산을 한번에 해서 실행하려고 했는데 그러면, 이런 반례(문자열의 개수보다 이동횟수가 많은 경우)에 오류가 생김
    qebh
    LLLLL


## 7. 아스키 코드
-  ASCII: python 언어에서 사용할 수 있는 모든 문자들은 전부 하나의 숫자와 대응
-  아스키 코드 (ASCII)
- ord(): 특정 문자의 아스키 코드 값
```python hl:1
>> print(ord('A')) #따옴표 넣어줘야 돼

65

•  chr() 함수

  >> print(chr(65))
  

'A'

- 알파벳 x 다음 알파벳을 구하는 것:  `chr(ord(x) + 1)`

- 대소문자 변경
    - 1. 아스키 코드 활용
    - 2. `lower()` 함수 사용(<-> `upper()`)
```python hl:6,10
# 방법1
x = 'C'
ord(x)                            -> 67
ord(x) - ord('A')                 -> 2 (67 - 65)
ord(x) - ord('A') + ord('a')      -> 99 (2 + 97)
chr(ord(x) - ord('A') + ord('a')) -> 'c'

# 방법2
x = 'C'
print(x.lower())

>> 'c'

•  x가 알파벳인지에 대한 여부는 python에서 isalpha라는 함수를 제공합니다.
  • 숫자인지에 대한 여부 역시 x.isdigit()이라는 함수

8. 문자열 비교

• 두 문자열이 동일한지 비교할 때 숫자 비교와 마찬가지로 == 연산자를 그대로 사용
• python에서의 문자열 끼리는 <, > 연산 가능
  • 이는 사전순으로 앞선 문자열이 누구인가에 대한 비교이며, 값이 더 작을 수록 사전순으로 앞서다는 것

@코드트리 Novice Low python으로 수료!@

n개의 줄에 걸쳐 각 n개의 숫자를 공백을 사이에 두고 입력받는 코드

n = 4
arr_2d = []
for _ in range(n):
    arr_1d = list(map(int, input().split()))
    arr_2d.append(arr_1d)

print(arr_2d)

>> 출력 결과
[[1, 2, 3, 4], [7, 8, 9, 10], [11, 12, 13, 14], [15, 16, 17, 18]]

• 어떤 배열을 정의하고 for loop 안에 append만 사용하는 경우는 list comprehension을 이용할 수 있습니다.

  n = 4
  arr_2d = [
    list(map(int, input().split()))
    for _ in range(n)
  ]
  print(arr_2d)

2. 배열 원소에 대한 접근

"""
i/j  0  1  2  3
0    1  2  3  4
1    7  8  9 10
2   11 12 13 14
3   15 16 17 18
"""
arr_2d = [[1, 2, 3, 4], [7, 8, 9, 10], [11, 12, 13, 14], [15, 16, 17, 18]]
print(arr_2d[0][0]) # 1행 1열 -> 1
print(arr_2d[1][2]) # 2행 3열 -> 9

3. 새로운 2차원 배열 선언

n * m 크기의 격자라면 다음과 같이 초기화가 가능합니다. list comprehension 사용시 n, m 위치에 유의합니다.

n, m = 4, 5
arr_2d = [
    [0 for _ in range(m)] # m개의 0을 가진 리스트를 생성(열)
    for _ in range(n) # n개의 행을 가진 2차원 리스트를 생성(행)
]
print(arr_2d)

>> 출력 결과
[[0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0]]

4. 2차원 배열 출력

n = 4
arr_2d = [[1, 2, 3, 4], [7, 8, 9, 10], [11, 12, 13, 14], [15, 16, 17, 18]]

#방법 1
for i in range(n): #행
    for j in range(n): #열
        print(arr_2d[i][j], end=" ")
    print()

#방법2
for row in arr_2d: #행
    for elem in row: #열
        print(elem, end=" ")
    print()

5. 다양한 활용

• 신기한 규칙: 손으로 숫자를 쭉 적다가 내려서 다시 반대 방향으로 적는 것을 반복하는 것

  입력
  n = 4
  

출력 1 2 3 4 8 7 6 5 9 10 11 12 16 15 14 13

=> 홀수번째 행에 대해서는 우측으로 이동하며 숫자를 적어야 하고, 짝수번째 행에 대해서는 좌측으로 이동하며 숫자를 적는 식으로 코드를 작성하면 됩니다. & num 변수 사용해서 계속 더해줌

```python hl:3-6
# 0으로 채워진 배열 만들기 
n = 4
arr_2d = [
    [0 for _ in range(n)]
    for _ in range(n)
]

num = 1
# 짝수, 홀수에 따른 배열 숫자 입력(대체)
for i in range(n):
    if i % 2 == 0:
        for j in range(n):
            arr_2d[i][j] = num
            num += 1
    else:
        for j in range(n - 1, -1, -1):
            arr_2d[i][j] = num
            num += 1

# 출력
for row in arr_2d:
    for elem in row:
        print(elem, end=" ")
    print()

어디를 기준으로 연속성이 있는지 봐야됨. if 같은 행으로 쭉 가는 경우, 행이 밖 loop 이런 식

2차 격자점으로서의 배열

2차 평면 상에 n개의 점이 주어졌을 때, (a, b)가 해당 점들 중 하나인지를 쉽게 판단할 수는 없을까요?

• 방법1: n개의 점들 중 (a, b)가 있는지를 직접 확인

  a, b = 1, 3
  exists = False
  for _ in range(n):
    r, c = tuple(map(int, input().split()))
    if r == a and c == b:
        exists = True
  

print(exists)

- 방법2: 점들의 위치 (r, c)의 범위가 1에서 10 사이라면 다음과 같이 0으로 초기화된 2차원 배열을 만든 뒤, 각 점들이 주어질때마다 해당 위치에 1로 표시해주는 방식
```python hl:4,9,10
a, b = 1, 3

placed = [
   [0 for _ in range(10)]
   for _ in range(10)
]

for _ in range(n):
   r, c = tuple(map(int, input().split()))
   placed[r - 1][c - 1] = 1

exists = True if placed[a - 1][b - 1] == 1 else False
print(exists)

• 도전문제 첫 번째 줄에 격자의 크기 n과 점의 개수 m이 공백을 두고 주어집니다. 두 번째 줄부터 m개의 줄에 걸쳐 각 점의 행 번호와 열 번호가 공백을 사이에 두고 주어집니다. 주어진 m개의 점의 위치는 모두 다름을 가정해도 좋습니다.
• 1 ≤ n ≤ 10
• 1 ≤ m ≤ n * n 예제1 입력:

  3 3
  1 1
  3 2
  3 3

  출력:

  1 0 0
  0 0 0
  0 6 9

  정답

  k = input().split()
  n, m = int(k[0]), int(k[1])
  

arr = []

for _ in range(m):     arr.append(tuple(map(int, input().split())))

arr2 = [     [0 for _ in range(n)]     for _ in range(n) ]

for i in range(1, n+1):     for j in range(1, n+1):         if (i, j) in arr: #헷갈림 - tuple이므로 ( , )             arr2[i-1][j-1] = i*j for i in range(n):     for j in range(n):         print(arr2[i][j], end =" ")

    print() ```

arr = input().split()

sum_val = 0 for i in range(10): sum_val += int(arr[i]) print(sum_val)

for elem in arr: print(elem)

#map을 이용하면 리스트에 있는 원소 type을 전부 변환한 이후의 리스트를 반환할 수 있음 arr = list(map(int, input().split())) print(arr)

1 3 [1, 3]

2개의 숫자만 입력받는 경우, tuple 사용 가능

n, m = tuple(map(int, input().split())) print(n, m)

1 3 1 3

- ## Slicing

리스트에 대해 slice(`[]`)를 활용하면 일부 범위, 조건에 해당하는 원소들을 가져올 수 있습니다.
```python hl:1
arr[start:end:step]

start index에서 시작하여 end index 직전까지 step씩 뛰며 전진합니다.

index  0  1  2  3  4
=====================
arr = [1, 2, 3, 4, 5]
print(arr[1:3:1]) # 1번째 index부터 3번째 index 전까지 1씩 증가
print(arr[1:3]) #이렇게 표현해도 동일
print(arr[:3]) #처음부터 받고 싶은 경우
print(arr[3:0:-1]) # 3번째 index부터 0번째 index 전까지 -1씩 감소하면서
print(arr[::-1]) # 전체 원소 뒤집기

•  10개의 원소를 입력받아 뒤집는 문제는 다음과 같이 코드를 작성

  arr = list(map(int, input().split()))
  reversed_arr = arr[::-1]
  

for elem in reversed_arr: print(elem, end=" ")

## 리스트 push, pop, len

```python hl:2,4
# 비어있는 리스트
arr = []
혹은
arr = list()

• append 함수를 이용하면, 리스트의 맨 끝에 원소를 추가할 수 있습니다.

  arr = [3, 5]
  arr.append(9) #append 괄호에 들어갈 원소 쓰기
  print(arr)
  

[3, 5, 9]

- **pop 함수**를 이용하면, **리스트의 맨 뒤에 있는 원소를 지울** 수 있습니다.
```python hl:2
arr = [3, 5, 9]
arr.pop()
print(arr)

>> [3, 5]

•  len() 함수: 해당 리스트에 있는 원소의 개수를 반환해줍니다.

>> print(len([1, 3, 5]))
3

• 모든 원소의 합을 구하기

  arr = [1, 2, 2, 5]
  

n = len(arr)

sum_val = 0 for i in range(n): sum_val += arr[i]

print(sum_val)

10

이때 len 함수를 이용하지 않고, 다음과 같이 코드를 작성하여 원소를 바로 꺼내는 식으로도 해결이 가능
```python hl:4-5,7
arr = [1, 2, 2, 5]

sum_val = 0
for elem in arr:
    sum_val += elem
#or
sum_val = sum(arr) #sum 함수 사용

print(sum_val)

>> 10

• sum 함수란?

  • sum(iterable, start) 형태
  • iterable: 리스트나 튜플 등 숫자로 이루어진 객체
  • start: 처음에 더해줄 값
  • 그러니까, iterable 내의 값을 다 더해주고 start도 더해주는 거

• 2번째 숫자부터 끝까지의 합을 구하기 위해서는 range를 꼭 사용해야만 할까요?
  이런 경우에는, slicing을 활용해볼 수 있습니다.

  arr = [1, 2, 2, 5]
  

sum_val = 0 for elem in arr[1:]: sum_val += elem #or sum_val = sum(arr[1:])

print(sum_val)

9

## 음수 index
 arr[-1]의 의미는 끝에서부터 첫 번째 원소, arr[-2]의 의미는 끝에서부터 2번째 원소라는 의미를 갖습니다.
```python
index  0  1  2  3
index -4 -3 -2 -1
==================
arr = [1, 2, 3, 5]

따라서 가장 끝에 있는 2개의 원소를 더해 출력하는 코드는 다음과 같이 작성해볼 수 있습니다.

arr = list(map(int, input().split()))

print(arr[-1] + arr[-2])

list comprehension

선언과 동시에 for loop으로부터 나온 원소를 원하는 값으로 변경해줄 수 있습니다

[(append 안에 들어갈 내용) (for loop)]

# 조건문을 포함하는 list comprehension
[(append 안에 들어갈 내용) (for loop) <조건문>]

# 리스트 arr의 각 원소들을 전부 2배씩 해주는 코드
arr = [1, 2, 3, 5]
new_arr = [elem * 2 for elem in arr]

# 홀수의 제곱수 배열
list_ = [i ** 2 for i in range(1, 10) if i % 2 == 1]

변수가 두 개 이상인 list comprehension

list_ = [(i + j) for i in range(3) for j in range(3)]

해당 코드의 결과는 다음과 같습니다.

[0, 1, 2, 1, 2, 3, 2, 3, 4]

for 문을 사용해 표현하면 다음과 같습니다.

list_ = []
for i in range(3):
    for j in range(3):
        list_.append(i + j)

피보나치 수열

arr = [0, 1, 1]

# 3번째 항부터 10번째 항까지 추가 - 배열이 이미 있어도 append로 그냥 넣을 수 있음 
for i in range(3, 11): 
    arr.append(arr[-1] + arr[-2])

# 10번째 항 출력
print(arr[10])

>> 55

# or - p: 전항, pp: 전전항

pp, p = 1, 1

for _ in range(3, 11):
    pp, p = p, pp + p

print(p)

>> 55

Counting 배열

전부 0으로 초기화된 크기가 7인 배열이 필요합니다. (1부터 6까지를 각각 index로 사용한다고 했을 때)

# 숫자 별 출현 횟수 1  2  3  4  5  6
count_arr = [0, 0, 0, 0, 0, 0, 0]

# 혹은 다음과 같이도 정의가 가능합니다.
count_arr = [0] * 7

# list comprehension을 이용할수도 있습니다.
count_arr = [0 for _ in range(7)]

10번 던져 나온 숫자 목록을 arr라 한다면, count_arr의 해당 숫자 index에 1씩 증가시키는 식으로 진행해볼 수 있습니다.

count_arr = [0] * 7

# 개수 세기
arr = list(map(int, input().split()))
for elem in arr:
    count_arr[elem] += 1

# 개수 출력
for i in range(1, 7):
    cnt = count_arr[i]
    print(f"숫자 {i} - {cnt}번")

탐색 - 문자를 원소로 갖는 배열

•  enumerate() 함수
  • 원소와 index가 동시에 필요한 경우
  • enumerate로 list를 감싸면, 원소로 (index, 원소)를 동시에 받으며 진행할 수 있음
  • 형식: enumerate(순서가 있는 객체, start=0)

word = ['A', 'P', 'P', 'L', 'E']

# 해당 문자를 찾지 못했다면 -1
idx = -1

# 문자 탐색
for i, char in enumerate(word):
    if char == 'L':
        idx = i

# 문자가 존재하지 않는 경우
if idx == -1:
    print("not exist")
else:
    print(idx)

>> 3

• 특정 원소가 리스트 안에 있는지, 없는지에 대해서:  in, not in 이라는 키워드

  word = ['A', 'P', 'P', 'L', 'E']
  

if 'L' in word: print('L is in list') if 'L' not in word: print('L is not in list')

L is in list

- 이미 존재하는 원소가 list의 <u>어느 index에 있는지</u>는 `.index()` 함수
    - 존재하지 않는 원소에 대해 index 함수를 이용하면 **Value Error**
    - index 함수 이용시에는 꼭 먼저 해당 원소가 리스트에 포함되는지를 확인한 이후에 진행
    - 만약 문자가 여러 개 존재한다면, 그 중 가장 앞에 있는 index를 반환합니다.
```python hl:3-4
word = ['A', 'P', 'P', 'L', 'E']

if 'K' in word:
    print(word.index('K'))

• 특정 원소의 개수
  • count()라는 함수를 사용해볼 수도 있습니다.

    word = ['A', 'P', 'P', 'L', 'E']
    

cnt = word.count('P') print(cnt)

2

### Min/Max
- 최대: `max(arr)`
```python hl:4
arr = [-1, -5, -2, -5, -3, -9]
# 첫번째 원소를 max로 설정하고 두번째 값부터 비교하면서 알아내기
max_val = arr[0]
for elem in arr[1:]:
    if elem > max_val:
        max_val = elem

print(max_val)

• 최소: min(arr)

• 증가 시
  • i = a부터 b - 1까지
• 감소 시
  • i = a부터 b+1까지
• b에 등호가 들어가지 않음
• for문 뒤에는 꼭 :를
• indentation으로 분리

for i in range(4): # i = 0 ~ 3

for i in range(a, b):
    코드 작성
    이 위치에 i값이 a부터 b - 1까지 1씩 증가하며 들어옴

for i in range(5, 11, 2): print(i) #2씩 증가 5,7,9

`range(a, b, -1)`는 a부터 b + 1까지 1씩 감소

for _ in range(5): #변수가 별로 중요하지 않은 경우
    print(1, end="") 

• 도전 문제
  • n을 입력받아, 1부터 n까지 공백을 두고 출력하는 프로그램을 작성해보세요.

    # 변수 선언, 입력
    n = int(input())
    

출력

for i in range(1, n + 1): print(i, end=" ") #이렇게 하면 \n 자동 실행되지 않아.

### while문
```python
i = 5           <- 시작 값

while i <= 10:  <- 계속 반복할 조건
    print(i)    <- 원하는 코드 작성
    i += 1      <- 원하는 증감값 설정

print("Done")

while True: #계속 반복

continue문

• for, while 안에서만 사용이 가능

• 조건이 만족하는 경우에는 아래 코드를 더 이상 실행하지 않고 다시 위로 올라가 그 다음 for loop을 실행

• 조건문과 같이 쓰여야 함

  for i in range(5, 11):
    코드1
    if i % 2 == 0:
        코드2
        continue
    코드3
  #이 경우 i = 짝수라면, 코드3이 실행되지 않고 바로 다시 for문

• 도전문제

  • 조건에 부합하는 수 정수 a 를 입력받아 1부터 a까지의 수 중 다음 조건을 모두 만족하지 않는 수들을 모두 출력하는 프로그램을 작성해보세요.
    • 짝수이면서 4의 배수가 아닌 수
    • 8로 나눈 몫이 짝수인 수
    • 7로 나눈 나머지가 4보다 작은 수 입력 형식: 첫 번째 줄에 정수 a가 공백을 두고 주어집니다 1 ≤ a ≤ 100 출력 형식: 첫 번째 줄에 1부터 a까지의 수 중 문제의 조건을 모두 만족하지 않는 수들을 공백을 사이에 두고 오름차순으로 출력합니다.

      # 변수 선언, 입력
      a = int(input())
      

조건을 모두 만족하지 않는 수들만 출력합니다.

for i in range(1, a + 1): if(i % 2 == 0 and i % 4 != 0) or (i // 8) % 2 == 0 or (i % 7) < 4: continue print(i, end=" ")

### break문
- for, while 안에서만 사용
- **가장 가까이에 있는 <u>for loop</u>을 완전히 탈출**
- **조건문과 같이 쓰여야 함**
다음 코드에서는 i가 6, 7, 8, 9인 경우에는 순서대로 `코드1` -> `코드3`이 계속 수행되다가, i가 10이 되는 순간에 `코드1` -> `코드2`가 수행되며 for loop을 탈출하여 바로 `코드4`가 수행
```python hl:5,8,10
for i in range(6, 101):
    코드1
    if i % 5 == 0:
        코드2
        break
    코드3

코드4

while True:
    n = int(input())
    if n >= 10:
        코드1
        break
    코드2

코드3

모양의 규칙부터 찾아야 돼!!!

• 행이 1 증가함에 따라 변화하는 별의 개수에 집중

3 * 5 크기의 격자 = 3개의 행과 5개의 열 = 가로 5, 세로 3

for _ in range(3):
    for _ in range(5):
        print(1, end="")
    print()

• 직각 삼각형
  • 규칙: 행이 1씩 증가함에 따라 열도 1씩 증가함

    for i in range(4):         -> i는 0부터 3까지 돌면 됩니다.
    for j in range(i + 1): -> j는 0부터 i 까지 돌면 됩니다. 
      print("*", end="")
    print()
    

- 행에 대하여 대칭인 경우

** * **

```python hl:2,6-7
#감소하는 경우
for i in range(3): #i=0,1,2
    for j in range(3 - i): #j=3,2,1
        print("*", end="")
    print()
for i in range(1, -1, -1): #i=1,0
    for j in range(3 - i): #j=2,3
        print("*", end="")
    print()

#증가하는 경우
*
* *
*

# 변수 선언 및 입력
n = int(input())

# 길이가 n인 직각삼각형을 출력합니다.
for i in range(n):
    for j in range(i+1):
        print("*", end=" ")
    print()

# 길이가 n-1인 직각삼각형을 뒤집어 출력합니다.
for i in range(n-2, -1, -1):
    for _ in range(i+1):
        print("*", end=" ")
    print()

• 열에 대해 대칭인 경우 - 앞에 공백이 붙는 경우
  • 행에 따른 공백의 개수를 변화를 파악 후, 별 출력 전에 공백 출력
  • 공백의 개수 = 격자의 개수 -별의 개수
  • 뒤에 있는 공백은 출력 X
• 실력체크: 가로 세로 2n-1 크기에 해당하는 격자에 체크 다이아몬드 모양을 그리는 코드를 작성해보세요. 규칙은 다음과 같습니다.
• n = 3 일 때

  *
  * *

• * *

# 변수 선언 및 입력
n = int(input())

# 모양에 맞게 위쪽 별을 출력합니다.
for i in range(n):
    for _ in range(n - i - 1):
        print(" ", end="")
    for _ in range(i + 1):
        print("* ", end="")
    print()

# 모양에 맞게 아래쪽 별을 출력합니다.
for i in range(n-2, -1, -1):
    for _ in range(n - i - 1):
        print(" ", end="")
    for _ in range(i + 1):
        print("* ", end="")
    print()

• 행에 따라 모양이 다른 경우
  • if 문을 통해서 짝수, 홀수일 때마다 다르게 출력

아스키 코드 (ASCII)

• ord(): 특정 문자의 아스키 코드 값

  >> print(ord('A')) #따옴표 넣어줘야 돼
  

65

-  `chr()` 함수
```python hl:1
>> print(chr(65))

'A'

• 알파벳 x 다음 알파벳을 구하는 것:  chr(ord(x) + 1)

• n번 반복

  • 실력체크 : n번에 걸쳐 두 정수 a, b가 주어졌을 때, a부터 b까지의 짝수를 모두 합한 결과를 출력하는 프로그램을 작성해보세요.
    • 입력 형식 첫 번째 줄에 테스트케이스의 수 n이 주어집니다. 두 번째 줄 부터 n개의 줄에 걸쳐 한 줄에 두 정수 a, b가 공백을 두고 주어집니다.
    • 1 ≤ n ≤ 10
    • 1 ≤ a ≤ b ≤ 100
      • 출력 형식 첫 번째 줄부터 n개의 줄에 걸쳐, 각 줄에 각 테스트 케이스마다 a이상 b이하의 짝수들의 합을 출력합니다.

# 변수 선언 및 입력
n = int(input())

#n회 반복합니다.
for i in range(n):
    # 변수 선언, 입력
    inp = input()
    arr = inp.split()
    a, b = int(arr[0]), int(arr[1])

    ans = 0

    # a부터 b까지 짝수를 전부 더한 값을 출력합니다.
    for j in range(a, b + 1): #for문 하나만 써서 if 절로 나누면 됨
        if j % 2 == 0:
            ans += j

    print(ans)

ab을 계산하기 위해서는 ** 연산 =>

a**b
a !=b
a += b #a = a + 5

• 증감연산자 파이썬에서는 적용 X
  • i++ 이런 거 X => i += 1 이렇게 써야 돼

• if : 사용
  • indentation으로 범위 표시

if 조건:
    여기에 조건이 참일 경우에만 수행되는 코드 작성
    여기에 써도 됨
else:
    여기에 조건이 거짓일 경우에만 수행되는 코드 작성

이 위치에 있는 코드는 조건과 무관하게 항상 수행됩니다.

04. 조건문

삼항연산자

기존 코드

if 조건:
    a = v1
else:
    a = v2

삼항연산자를 이용한 코드

a = v1 if 조건 else v2

• 2 + 6은 항상 계산되기를 원하고, 삼항 연산자에 따라 5또는 6이 선택되기를 원했다면,

n = 8
a = 2 + 6 + (5 if n > 10 else 6)
print(a)

• 도전 문제

  • 정수 a가 주어졌을 때, a가 1이라면 t 를 출력하고, 1이 아니라면 f 를 출력하는 프로그램 삼항연산자를 사용하여 작성해보세요.

    입력 형식 첫 번째 줄에 정수 a가 주어집니다.

  • 0 ≤ a ≤ 100

    출력 형식 첫 번째 줄에 a가 1이라면 t 를 출력하고, 1이 아니라면 f 를 출력합니다

    a = int(input())    
    print(('t' if a == 1 else 'f'))

if elif else 조건문

비교 연산자

비교 연산자는 식이 옳은지 틀린지에 따라 참(True) 혹은 거짓(False) 값을 반환 < > ==

and

a = int(input())

if a % 2 == 0 and a >= 10: # 괄호 안 쳐도 됨
    print("special")
else:
    print("normal")

중첩 조건문

if a % 2 == 1:
    if a >= 10:
        print('A')
    else:
        print('B')
else:
    if a >= 15:
        print('C')
    else:
        print('D')