기역니은

Q1) 댓글이 달려있는 게시글을 삭제하려고 할 때 무슨 문제가 발생할까요? JPA가 아닌 Database 테이블 관점에서 해결방법이 무엇일까요?

삭제된 포스트에 있는 댓글도 댓글 테이블에서 같이 삭제해야 한다. 
foreign key constraints에 ON DELETE CASCADE 를 걸어준다.

Q2) 같은 문제가 발생했을 때 JPA에서는 어떻게 해결할 수 있을까요?

영속성 전이를 걸어준다. (OneToMany entity에 Cascade 옵션을 걸어준다.)
또는 orphanRemoval 설정을 해준다.

Q3) IoC / DI 에 대해 간략하게 설명해 주세요!

IoC 객체 관리를 개발자가 아닌 외부에 맡기는 것

DI 객체를 직접 생성하지 않고 외부에서 생성한 객체를 주입받아 쓰는 것

컨트롤러

    @PostMapping("/signup")
    public ApiResult signup(@RequestBody SignupRequestDto requestDto) {
        userService.signup(requestDto);
        return new ApiResult("회원가입 성공", HttpStatus.OK.value());
    }

    @PostMapping("/login")
    public ApiResult login(@RequestBody LoginRequestDto requestDto, HttpServletResponse response) {
        userService.login(requestDto, response);
        return new ApiResult("로그인 성공", HttpStatus.OK.value());
    }
}

서비스

    public void signup(SignupRequestDto requestDto) {
        String username = requestDto.getUsername();
        String password = requestDto.getPassword();
        String role = requestDto.getRole();

        // 회원 중복 확인
        Optional<User> found = userRepository.findByUsername(username);
        if (found.isPresent()) {
            throw new HanghaeBlogException(HanghaeBlogErrorCode.IN_USED_USERNAME, null);
        }

        User userEntity = new User(username, password, role);
        userRepository.save(userEntity);
    }​

    public void login(LoginRequestDto requestDto, HttpServletResponse response) {
        String username = requestDto.getUsername();
        String password = requestDto.getPassword();

        User user = userRepository.findByUsername(username).orElseThrow(
                () -> new HanghaeBlogException(HanghaeBlogErrorCode.NOT_FOUND_USER, null)
        );

        if (!user.getPassword().equals(password)) {
            throw new HanghaeBlogException(HanghaeBlogErrorCode.WRONG_PASSWORD, null);
        }

        response.addHeader(JwtUtil.AUTHORIZATION_HEADER, jwtUtil.createToken(user.getUsername()));
    }

JWT에서 유저 정보 조회

    public User checkToken(HttpServletRequest request) {

        String token = this.resolveToken(request);
        Claims claims;

        User userEntity = null;

        if (token != null) {
            if (this.validateToken(token)) {
                // 토큰에서 사용자 정보 가져오기
                claims = this.getUserInfoFromToken(token);

            } else {
                throw new HanghaeBlogException(HanghaeBlogErrorCode.INVALID_TOKEN, null);
            }

            // 토큰에서 가져온 사용자 정보를 사용하여 DB 조회
            userEntity = userRepository.findByUsername(claims.getSubject()).orElseThrow(
                    () -> new HanghaeBlogException(HanghaeBlogErrorCode.NOT_FOUND_USER, null)
            );
        }
        return userEntity;
    }

package com.sparta.blog.entity;

import com.sparta.blog.dto.PostRequestDto;
import jakarta.persistence.*;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;


@Entity
@Getter
@Setter
@NoArgsConstructor
@Table(name = "posts")
public class Post extends Timestamped {

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

    @Column(nullable = false)
    private String title;

    @Column(nullable = false)
    private String content;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn(name = "user_id", nullable = false)
    private User user;


    public Post(PostRequestDto postRequestDto, User user) {
        this.title = postRequestDto.getTitle();
        this.content = postRequestDto.getContent();
        this.user = user;
    }
}

package com.sparta.blog.entity;

import jakarta.persistence.*;
import lombok.Getter;
import lombok.NoArgsConstructor;
import lombok.Setter;

import java.util.ArrayList;
import java.util.List;

@Entity
@Getter
@Setter
@NoArgsConstructor
@Table(name="users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(nullable = false, unique = true)
    private String username;
    @Column(nullable = false)
    private String password;

    @Column(nullable = false)
    @Enumerated(value = EnumType.STRING)
    private UserRoleEnum role;

    @OneToMany(mappedBy = "user")
    private List<Post> postList = new ArrayList<>();

    public User(String username, String password, UserRoleEnum role) {
        this.username = username;
        this.password = password;
        this.role = role;
    }
}

   @PutMapping("/post/{id}")
    public PostResponseDto updatePost(@PathVariable Long id, @RequestBody PostRequestDto requestDto, @AuthenticationPrincipal UserDetailsImpl userDetails) {
        return postService.updatePost(id, requestDto, userDetails.getUser());
    }

    @Transactional
    public PostResponseDto updatePost(Long id, PostRequestDto requestDto, User user) {
        Post post = findPost(id);
        if (!post.getUser().getId().equals(user.getId())) {
            throw new IllegalArgumentException("다른 회원의 글은 수정할 수 없습니다.");
        } else {
            post.setTitle(requestDto.getTitle());
            post.setContent(requestDto.getContent());
            postRepository.save(post);
        }
        return new PostResponseDto(post);
    }

user entity의 postList도 업데이트 되도록 수정할 예정

쿠키

그냥 옮기는 매개체, 사용자가 조작해도 크게 문제되지 않을 정보를 브라우저에 저장

세션

인증에 대한 정보를 서버가 저장

토큰

서버가 기억하는 이상하게 생긴 스트링, ID카드처럼 서버에게 보여줘야 하는 것, 인증에 대한 정보를 사용자가 저장

JWT

정보를 가지고 있는 토큰. DB 없이 검증할 수 있음