zwon.log

[코드트리] 청약 통장 1회차 미션 - 코딩테스트 준비, 갭체크부터 시작하기

Mon, 11 May 2026 13:15:03 GMT

평소 코딩테스트 공부를 해야겠다고 생각만 하고 제대로 실천하지 못하고 있었다. 뭔가 알고리즘은 항상 뒤로 미루게 되었고, 막상 문제를 풀려고 하면 손이 잘 가지 않았다.

그러던 중 우연히 코드트리 청약통장 챌린지를 발견하게 되었다.

평소에도 코드트리는 많이 들어봤지만 유료 플랫폼이라는 인식이 있어서 무료 사이트 위주로만 공부했었다. 그런데 이번 챌린지는 완주 시 일정 기간 무료 이용 혜택도 제공하고 있어서 이번 기회에 코딩테스트 공부 습관을 만들어보자라는 생각으로 신청하게 되었다.

특히 7주 동안 꾸준히 인증하면 8월 31일까지 무료 연장이 가능하다는 점이 동기부여가 되었다. 단순히 문제 몇 개 푸는 이벤트가 아니라 꾸준히 공부하는 루틴을 만드는 챌린지라는 점이 좋았다.

코드트리 청약 통장 사이트는 다음과 같다.

https://www.codetree.ai/ko/no-free-lunch-2026/?ref=LV93D6

나의 갭체크 결과는 다음과 같다.

사실 어느 정도는 부족할 거라고 생각했지만, 예상보다 훨씬 부족한 결과가 나와서 꽤 충격을 받았다.

시간 안에 못 푼 문제도 있었지만, 개인적으로 더 충격이었던 건 생각보다 기본적인 문제도 제대로 못 풀었다는 점이었다.평소에 구현 정도는 할 수 있다고 생각했는데 실제 제한 시간 안에서 문제를 읽고 로직을 설계하고 예외를 처리하는 과정은 완전히 다른 영역이었다.

특히 문제를 보자마자 바로 풀이 방향이 떠오르지 않는 경우가 많았고 알꺼같은데.. 알꺼같은데 하면서 구현하면서 시간을 까먹기도했다.

이런 갭체크를 통해서 얻어간 것도 있다. 문제를 풀면서 어떤 부분이 부족한지 조금 더 구체적으로 알게 되었다는 점이다. 그리고 갭체크 이후 부족한 부분을 채울 수 있도록 챕터를 추천해준다. 단순히 점수만 보여주는 것이 아니라 어떤 유형을 먼저 공부해야 하는지 방향성을 알려줘서 좋았다.특히 혼자 공부하면 무엇부터 해야 할지 막막한 경우가 많은데, 단계별로 문제를 풀 수 있도록 구성되어 있어서 코딩테스트를 연습하는 사람 입장에서 도움이 될 것 같았다.

아직 첫 주차라 실력이 크게 늘었다고 말하기는 어렵지만, 적어도 이번 챌린지를 통해 “매일 조금이라도 문제를 푸는 습관”은 만들어보고 싶다.

당장 어려운 문제를 푸는 것보다도 꾸준히 문제를 읽고 고민하는 시간을 늘리는 게 현재 내 목표다.

#코드트리 #코딩테스트 #코테공부 #코테준비 #알고리즘공부 #갭체크

LeetCode - 45. Jump Game II

Sat, 25 Nov 2023 03:58:59 GMT

문제

문제 : 45. Jump Game II 문제는 nums[0]에서 j만큼 점프할 수 있고( nums[i + j] ) 최소한의 점프로 nums[i-1]에 도달하는 경우의 수를 구한 후 점프 횟수를 반환하는 것이다. 조건은 다음과 같다.

1) 0 <= j <= nums[i]

2) i + j < n

풀이

class Solution:
  def jump(self, nums: List[int]) -> int:
      jumpCnt = [0] * len(nums)
      for i in range(len(nums)):
          for j in range(1, nums[i]+1): # 0 <= j <= nums[i]
              if i + j >= len(nums):
                  break
              if jumpCnt[i + j] == 0 or jumpCnt[i+j] > jumpCnt[i] + 1:
                  jumpCnt[i + j] = jumpCnt[i] + 1
      return jumpCnt[-1]

for j in range(1, nums[i]+1)에서 0부터 시작하지 않은 이유는 0은 제자리 점프기 때문에 1부터 시작하도록 했다.

내가 생각하는 이 코드의 핵심이다.

if jumpCnt[i + j] == 0 or jumpCnt[i+j] > jumpCnt[i] + 1:
   jumpCnt[i + j] = jumpCnt[i] + 1

현재위치 i에서 점프할 위치인 i + j의 값이 0이면 jumpCnt[i+j]는 점프할려는 위치의 값 + 1을 해주면 된다.
각 배열에는 해당 위치까지 오는데 필요한 점프 횟수가 jumpCnt 배열에 저장되어있기때문에 jumpCnt[i] + 1의 값을 jumpCnt[i + j]에 할당해주는 것이다.
그리고 점프할 위치인 jumpCnt[i+j]값이 0이아닌경우에는 jumpCnt[i+j]값보다 jumpCnt[i] + 1의 값이 작은 경우엔 junpCnt[i+j]값을 바꿔준다.
메모
- DP 사용

LeetCode - 150. Evaluate Reverse Polish Notation

Thu, 23 Nov 2023 17:55:22 GMT

문제

문제는 간단하다. 후위연산자 계산이다. 문제 링크 : LeetCode - 150. Evaluate Reverse Polish Notation

풀이

stack을 사용했다.

연산자가 나올때까지 숫자들을 stack에 append한다.
피연산자가 나오면 stack[-1]과 stack[-2]의 숫자를 연산한다.
- 순서는 ex) stack[-2] + stack[-1]

후위연산자 표기법에 대해서는 여기를 확인하자.

class Solution:
    def evalRPN(self, tokens: List[str]) -> int:
        stack = []
        operator = ['+', '-', "/", "*"]
        for token in tokens:
            if token not in operator: # number
                stack.append(token)
            else:
                num1 = int(stack.pop())
                num2 = int(stack.pop())
                if token == '+':
                    stack.append(num2 + num1)
                elif token == '-':
                    stack.append(num2 - num1)
                elif token == '*':
                    stack.append(num2 * num1)
                elif token == '/':
                    stack.append(num2 / num1)
        return int(stack.pop())

메모

stack 사용
후위연산자

LeetConde - 61. Rotate List

Thu, 23 Nov 2023 13:50:46 GMT

문제

문제 : 61. Rotate List

문제는 간단하다. linked list가 주어지고 k만큼 오른쪽으로 회전한 결과값을 반환하면 된다.

풀이

from collections import deque
class Solution(object):
    def rotateRight(self, head, k):
        if head == None:
            return None

        answer = deque()
        curr = head

        while curr:
            if curr.next == None:
                answer.append(curr.val)
                break
            answer.append(curr.val)
            curr = curr.next

        answer.rotate(k)

        listNode = ListNode(answer[0])
        curr_node = listNode
        for i in range(1,len(answer)):
            new_node = ListNode(answer[i])
            curr_node.next = new_node
            curr_node = curr_node.next
        return listNode

간단하게 설명하자면 while문을 돌아서 deque()에 val값들을 넣어주고, 반환타입이 listNode라서 deque()의 값들을 하나씩 꺼내 ListNode로 생성해주고 연결해주었다.

처음엔 curr_node가 아닌 listNode를 바로 사용해서 작성했더니,

listNode = ListNode(answer[0])
  for i in range(1,len(answer)):
      new_node = ListNode(answer[i])
      listNode.next = new_node
      listNode = listNode.next
  return listNode

listNode = listNode.next때문에 항상 마지막 값으로 세팅되게 해줘서 마지막 노드만 반환되었다.
그래서 curr_node를 생성해서 연결한 후 반환값으로 첫 번째 노드를 반환하도록 해주었다.
메모
deque()의 rotate()함수 사용
deque()의 rotate()함수를 사용하지 않고 풀어봐야겠다.
linked List 복습

[개발일지] 취미 커뮤니티 - 사용자 프로필 설정 및 변경

Fri, 27 Oct 2023 21:53:46 GMT

사용자 프로필 설정 기능이다. 롬복 어노테이션들은 생략하고 포스팅하고자 한다.

User

public class User extends BaseTimeEntity {
  ...
  @OneToOne(mappedBy = "user", fetch = FetchType.LAZY, cascade = CascadeType.ALL)
  private Profile profile;

  public void updateProfile(Profile newProfile) {
    this.profile = newProfile;
    newProfile.setUser(this);
  }
  ...

회원 탈퇴 시 프로필 사진도 삭제되게 CascadeType.ALL로 설정하였다.

Profile

public class Profile {

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

  private String originFilename; // 업로드된 파일 이름
  private String storeFilename; // 저장한 파일명 ex) 132-5sdf-23451-1as.png -> UUID로 식별자 생성 + 확장자

  @OneToOne(fetch = FetchType.EAGER)
  @JoinColumn(name = "user_id")
  private User user;

  public void setUser(User user) {
    this.user = user;
  }
}

ImgController

@Controller
@RequiredArgsConstructor
public class ImgController {
  private final FileStore fileStore;
  private final FileService fileService;


  @PostMapping("/profile/update") // 프로필 사진 변경과 삭제
  public String profileUpdate(@ModelAttribute ProfileUpdateDto profileUpdateDto,
                              HttpSession session) throws IOException {
    User loginUser = (User) session.getAttribute("loginUser");

    if (profileUpdateDto.getProfile().isEmpty()) { 
      fileService.deleteBeforeProfile(loginUser.getNickname());
    } else {
      fileService.transferProfile(profileUpdateDto.getProfile(), loginUser.getNickname());
    }

    return "redirect:/my-page";
  }
  // 프로필 이미지 보여주기
  @ResponseBody
  @GetMapping("/profile/{filename}")
  public Resource downloadProfile(@PathVariable String filename)
      throws MalformedURLException {
    return new UrlResource("file:" + fileStore.getProfileFullPath(filename));
  }
}

FileStore

첨부파일 업로드 포스팅과 별 차이 없다.

추가된 부분만 정리하겠다.

// 프로필 이미지
@Value("${profile.dir}")
private String profileDir;

// 파일 저장 경로 Full
public String getProfileFullPath(String filename){
  return profileDir + filename;
}

public Profile profileImgStore(MultipartFile multipartFile) throws IOException {
  if (multipartFile.isEmpty()){
    return null;
  }
  String originalFileName = multipartFile.getOriginalFilename();
  String ext = extractedExt(originalFileName);
  String storeFileName = createStoreFileName(ext);
  multipartFile.transferTo(new File(getProfileFullPath(storeFileName)));

  return Profile.builder()
      .originFilename(originalFileName)
      .storeFilename(storeFileName)
      .build();
}

첨부파일 구현과 똑같고 약간 다른거는 파일 경로 가져오는거나(따로 폴더를 생성함) ,, 말고는 없다.

FileService

@Service
@RequiredArgsConstructor
@Slf4j
public class FileService {
private final FileStore fileStore;
private final FileRepository fileRepository; 
private final UserRepository userRepository;
private final ProfileRepository profileRepository;

// 프로필 이미지 변경 @Transactional public Profile transferProfile(MultipartFile profile, String nickname) throws IOException { User user = userRepository.findUserByNickname(nickname).orElseThrow(IllegalArgumentException::new); Profile profileImg = fileStore.profileImgStore(profile); user.updateProfile(profileImg); return profileImg; }

public void deleteBeforeProfile(String nickname) { User user = userRepository.findUserByNickname(nickname).orElseThrow(IllegalArgumentException::new);

if (user.getProfile() != null) {
  Profile profile = user.getProfile();

  File imgFileOnDisk = new File(fileStore.getProfileFullPath(profile.getStoreFilename()));
  if (imgFileOnDisk.exists()) {
    imgFileOnDisk.delete();
  }
  user.updateProfile(null);
  profileRepository.delete(profile);
}

}

- 이 부분도 첨부파일과는 별 차이 없다.

## 마이페이지
```html

기본 이미지 같은 경우는 프로필을 저장하는 로컬 폴더에 저장해두고 사용자의 profile에 사용자가 저장판 프로필 사진이 없으면 기본 이미지가 보이도록 구현하였다ㅏ.

화면

프로필을 설정하지 않은 경우

프로필을 설정한 경우
프로필 수정을 누르면 수정폼이 나오도록 자바스크립트 코드를 작성했다. (코드 생략)

프로필 설정을 하면 다음과 같이 크루 상세 조회에서 크루원 정보를 나타낼 때 프로필 사진도 나오도록 했다.

프로필 설정 안한 경우

크루의 Banner이미지도 사용자 프로필 설정하는 코드와 거의 매서드명이랑 반환타입만 다르고 동일한 방식으로 구현해서 크루의 배너 설정의 포스팅은 생략하겠다.

깨달음..

객체가 영속성 컨텍스트에 있는줄 알았는데 없어서 원하는대로 결과가 나오지 않는 일을 많이 겪으면서 영속성 컨텍스트의 동작과정을 잘 이해해야함을 너무나 깨달았다.

자꾸 session에서 로그인한 user를 가져오면서 사용하고있는데, 영속성 컨텍스트에 올라가있는줄 착각하고 개발을 하다보다 잘못된 방식으로 작성한 코드가 많으거같아서 하나씩 수정하고자한다.

나중에 OAuth로 로그인 구현 후 전체적인 리펙토링이 필요할꺼라고 생각하고있는데 계속 기능 개발하면서 수정해야겠다.

[개발일지] 취미 커뮤니티 마이페이지 구현 (1)

Fri, 27 Oct 2023 10:37:26 GMT

먼저 사용자가 관심있어요 누른 크루즈와 사용자가 참여중인 크루즈를 가져오는 코드이다. 그전에 User와 Crew 엔티티 연관관계를 단방향이었다가 양방향으로 다음과 같이 설정했다. 코드를 구현하면서 느낀게 스트림을 정말 잘 다루면 너무 좋을꺼같다.........

User

public class User extends BaseTimeEntity {
    ...
    @OneToMany(mappedBy = "user")
      private List leaderCrews = new ArrayList<>(); // 내가 크루장인 크루

     @ManyToMany(mappedBy = "crew")
      private List crews = new ArrayList<>(); // 내가 참여중인 크루
    ...

Crew

public class Crew extends BaseTimeEntity {
    ...
     @ManyToMany// 크루에 속한 팀원, 우선 ManyToMany로 함.
      @JoinTable(
      name = "user_crew",
      joinColumns = @JoinColumn(name = "crew_id"),
      inverseJoinColumns = @JoinColumn(name = "user_id")
  )
  private List users = new ArrayList<>();
    ...

UserService

// 관심 있는 크루
  public List LikeCrew(Long id){
    User user = userRepository.findById(id)
    .orElseThrow(() -> new blogException("해당 회원은 존재하지 않습니다."));

    List crews = user.getLikes().stream()
        .map(like -> new CrewResponseDto(like.getCrew()))
        .collect(Collectors.toList());
    return crews;
  }
  // 참여하고 있는 크루
  public List joinCrew(Long id){
    User user = userRepository.findById(id)
    .orElseThrow(() -> new blogException("해당 회원은 존재하지 않습니다."));

    List crews = user.getCrews().stream()
        .map(CrewResponseDto::new)
        .collect(Collectors.toList());
    return crews;
  }

  // 크루장인 크루
  public List leaderCrew(String nickname){
    User user = userRepository.findUserByNickname(nickname)
        .orElseThrow(() -> new blogException("해당 회원은 존재하지 않습니다."));

    List crews = user.getLeaderCrews().stream()
        .filter(crew -> crew.getUser().equals(user))
        .map(CrewResponseDto::new)
        .collect(Collectors.toList());
    return crews;
  }

  // 활동종료 크루 (크루원일 때)
  public List closeCrew(String nickname){
    User user = userRepository.findUserByNickname(nickname)
        .orElseThrow(() -> new blogException("해당 회원은 존재하지 않습니다."));

    List crews = user.getCrews().stream()
        .filter(crew -> crew.isClosed())
        .map(CrewResponseDto::new)
        .collect(Collectors.toList());
    return crews;
}

참고로 new blogException는 사용자 정의 예외를 한번 해본건데 테스트(?)느낌이라 아마 나중에 예외 처리를 따로 할 때 수정할 예정이다.

UserController

@Controller
@RequiredArgsConstructor
public class UserController {

  private final UserService userService;

  @GetMapping("/my-page")
  public String myPage(Model model, HttpSession session){
    User loginUser = (User) session.getAttribute("loginUser");
    // 크루장인 크루즈
    List leaderCrew = userService.leaderCrew(loginUser.getNickname());
    model.addAttribute("leaderCrew", leaderCrew);

    // "관심있어요" 크루즈
    List likeCrews = userService.LikeCrew(loginUser.getNickname());
    model.addAttribute("likeCrews", likeCrews);

    // 내가 참여한 크루즈
    List joinCrews = userService.joinCrew(loginUser.getNickname());
    model.addAttribute("joinCrews", joinCrews);

    return "/user/my-page";
  }
}

테스트 화면




  
  마이 페이지
  


관리 중인 크루 (크루장인 경우)
  
    
  
관심 있는 크루
  
    
  
참여하고 있는 크루
  
    활동 종료

[개발일지] 취미 커뮤니티 서비스 - 크루 참가 및 탈퇴 + 크루 세팅

Thu, 26 Oct 2023 07:27:28 GMT

크루에 참여 및 탈퇴 기능과 크루 세팅하는 부분에 대해서 정리하고자 한다. 크루 세팅은 크루 공개/비공개, 크루원 모집 혹은 모집X인지, 크루 활동이 종료되었는지 아닌지를 설정하는 코드를 정리하고자 한다.

Crew

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

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

  @ManyToOne(fetch = FetchType.LAZY)
  @JoinColumn(name = "user_id")
  private User user; // 크루장 - 로그인한 user

  private String name; // 크루이름
  private boolean type; //  true-온라인, false-오프라인
  private boolean cost; // true-유료탑승, false-무료탑승
  private boolean isRecruiting; // true - 모집중, false - 모집X,
  private boolean isPublished; // true - 공개O, false - 공개X
  private boolean isClosed; // true - 종료
  private String thumbnail; //이미지 경로 , 처음엔 기본 이미지 -> 크루 설정을 통해 배너 수정 가능

  @Lob // varchar보다 클 경우 사용하는 어노테이션
  private String description; // 항해 목적

  @Lob // varchar보다 클 경우 사용하는 어노테이션
  private String wisher; // 원하는 선원

  @Lob // varchar보다 클 경우 사용하는 어노테이션
  private String plan; // 크루즈 설명


  @ManyToMany // 크루에 속한 팀원
  @JoinTable(name = "user_crew")
  private List users = new ArrayList<>();

  @OneToMany(mappedBy = "crew")
  private List likes = new ArrayList<>();

  // 크루 가입
  public void addUser(User user){
    if(!this.users.contains(user)) {
      this.users.add(user);
    }
  }
  // 크루 탈퇴
  public void removeUser(User user) {
    if (this.users.contains(user)) {
      this.users.remove(user);
    }
  }

  // 크루에 가입이 가능한지
  public boolean isJoinable(User user) { // (1)
    return this.isPublished && this.isRecruiting && !this.users.contains(user) && !this.isClosed;
  }
  // 크루 멤버인지
  public boolean isMember(User user) { // (2)
    if (this.user.equals(user)){ // 크루장인 경우
      return true;
    }
    return this.users.contains(user); // 크루원인 경우
  }

  // 크루장
  public void setUser(User user){
    this.user = user;
  }

  public void update(CrewUpdateRequestDto crewUpdateRequestDto){
    this.name = crewUpdateRequestDto.getName();
    this.type = crewUpdateRequestDto.isType();
    this.cost = crewUpdateRequestDto.isCost();
    this.description = crewUpdateRequestDto.getDescription();
    this.wisher = crewUpdateRequestDto.getWisher();
    this.plan = crewUpdateRequestDto.getPlan();
  }

  public void setPublished(){
    if (this.isPublished) {
      this.isPublished = false;
    } else {
      this.isPublished = true;
    }

  }
  public void setRecruited(){
    if (this.isRecruiting) {
      this.isRecruiting = false;
    } else {
      this.isRecruiting = true;
    }
  }
  public void setClosed(){
    if (this.isClosed) {
      this.isClosed = false;
    } else {
      this.isClosed = true;
    }
  }

}

코드를 보면 이해가 갈 것이다.
그냥 단순히 true/false 또는 contains(...)를 이용해서 포함하고있는지 아닌지를 확인하는 코드들이라 설명이 필요해 보이지는 않는다.

주석으로도 설명을 작성해놨다.

Dto

CrewSaveRequestDto

@Getter @Setter
@NoArgsConstructor
@AllArgsConstructor
public class CrewSaveRequestDto {
private String name; // 크루이름
private boolean type; //  true-온라인, false-오프라인
private boolean cost; // true-유료탑승, false-무료탑승
private String description; // 크루즈 설명
private String wisher; // 원하는 선원
private String plan; // 크루즈 설명

public Crew toEntity(){ return Crew.builder() .name(name) .type(type) .cost(cost) .wisher(wisher) .plan(plan) .description(description) // 이 부분 .isPublished(true) // 처음 crew를 만들 땐 true .isRecruiting(true) // 처음 crew를 만들 땐 true .isClosed(false) // 처음 crew를 만들 땐 false // .build(); } }

- 우선 크루를 처음 만들었을땐 크루 공개 여부 true, 크루 모집 true, 크루 종료 false로 세팅했다.
### CrewResponseDto
```java
@Getter
@NoArgsConstructor
public class CrewResponseDto {

  private Long id; // 크루 조회할 때 사용
  private String leader; // 크루장
  private String name; // 크루명
  private boolean type; //  true-온라인, false-오프라인
  private boolean cost; // true-유료탑승, false-무료탑승
  private String description; // 크루즈 설명
  private String wisher; // 원하는 선원
  private String plan; // 크루즈 설명
  private boolean isRecruit; // true - 모집중, false - 모집X
  private boolean isPublished; // true - 공개O, false - 공개X
  private boolean isClosed;
  private List users;

  public CrewResponseDto(Crew crew) {
    this.id = crew.getId();
    this.leader = crew.getUser().getNickname();
    this.name = crew.getName();
    this.type = crew.isType();
    this.cost = crew.isCost();
    this.description = crew.getDescription();
    this.wisher = crew.getWisher();
    this.plan = crew.getPlan();
    this.isRecruit = crew.isRecruiting();
    this.isPublished = crew.isPublished();
    this.isClosed = crew.isClosed();
    this.users = crew.getUsers().stream().map(UserResponseDto::new).collect(Collectors.toList());
  }
}

CrewRepository

생략 (크루 CRUD와 동일)

CrewService

public class CrewService {
private final CrewRepository crewRepository;

...
// 크루 참가
public void addUser(Long id, User user){
  Crew crew = crewRepository.findById(id).orElseThrow(IllegalArgumentException::new);
  if (crew.isJoinable(user)){
    crew.addUser(user);
  }
}

public void leaveCrew(Long id, User user){
  Crew crew = crewRepository.findById(id).orElseThrow(IllegalArgumentException::new);
  if (crew.isMember(user)) {
    crew.removeUser(user);
  }
}

@Transactional
public void update(Long id, CrewUpdateRequestDto crewUpdateRequestDto){
  Crew crew = crewRepository.findById(id).orElseThrow(IllegalArgumentException::new);
  crew.update(crewUpdateRequestDto); // 이렇게 엔티티로 Dto를 넘겨도 되나?
}

// 크루 세팅 - 크루 공개 여부
public void setPublished(Long id){
  Crew crew = crewRepository.findById(id).orElseThrow(IllegalArgumentException::new);
  crew.setPublished();
}

// 크루 세팅 - 크루원 모집 여부
public void setRecruited(Long id){
  Crew crew = crewRepository.findById(id).orElseThrow(IllegalArgumentException::new);
  crew.setRecruited();
}
// 크루 세팅 - 크루 종료 여부
public void setClosed(Long id){
  Crew crew = crewRepository.findById(id).orElseThrow(IllegalArgumentException::new);
  crew.setClosed();
}

}

## CrewViewController
- 크루 CRUD 부분은 이 포스팅에선 생략하겠다.
```java
@Controller
@RequiredArgsConstructor
@Transactional
@Slf4j
public class CrewViewController {
  private final CrewService crewService;

  // 크루 참가 신청
  @GetMapping("/crews/{id}/join")
  public String joinCrew(HttpSession session, @PathVariable Long id) {
    User loginUser = (User) session.getAttribute("loginUser");
    crewService.addUser(id, loginUser);
    return "redirect:/crews/" + id;
  }

  // 크루 탈퇴
  @GetMapping("/crews/{id}/leave")
  public String leaveCrew(HttpSession session, @PathVariable Long id) {
    User loginUser = (User) session.getAttribute("loginUser");
    crewService.leaveCrew(id, loginUser);
    return "redirect:/crews/" + id;
  }

  // 크루 detailView
  @GetMapping("/crews/{id}/log") // 활동일지
  public String crewActivity(@PathVariable Long id, Model model, HttpSession session) {
    User user = (User) session.getAttribute("loginUser");
    CrewResponseDto crewResponseDto = crewService.findById(id);
    UserResponseDto loginUser = new UserResponseDto(user);
    model.addAttribute("loginUser", loginUser);
    model.addAttribute("crewResponseDto", crewResponseDto);
    return "crew/log";
  }

  @GetMapping("/crews/{id}/meeting") // 모임
  public String crewMeeting(@PathVariable Long id, Model model, HttpSession session) {
    User user = (User) session.getAttribute("loginUser");
    CrewResponseDto crewResponseDto = crewService.findById(id);
    UserResponseDto loginUser = new UserResponseDto(user);
    model.addAttribute("loginUser", loginUser);
    model.addAttribute("crewResponseDto", crewResponseDto);
    return "crew/meeting";
  }

  @GetMapping("/crews/{id}/setting") // 설정 -> Crew Update
  public String crewSetting(@PathVariable Long id, Model model, HttpSession session) {
    User user = (User) session.getAttribute("loginUser");
    CrewResponseDto crewResponseDto = crewService.findById(id);
    UserResponseDto loginUser = new UserResponseDto(user);

    model.addAttribute("loginUser", loginUser);
    model.addAttribute("crewResponseDto", crewResponseDto);

    model.addAttribute("crewUpdateRequestDto", new CrewUpdateRequestDto());
    return "crew/setting";
  }

  @PostMapping("/crews/{id}/setting") // 설정 -> Crew Update
  public String crewSetting(@PathVariable Long id,
                            @ModelAttribute CrewUpdateRequestDto crewUpdateRequestDto) {
    crewService.update(id, crewUpdateRequestDto);
    return "redirect:/crews/" + id;
  }

  // 크루 공개 여부
  @PostMapping("/crews/{id}/published")
  public String publishedCrew(@PathVariable Long id) {
    crewService.setPublished(id);
    return "redirect:/crews/" + id + "/setting";
  }
  // 크루 인원 모집 여부
  @PostMapping("/crews/{id}/recruit")
  public String recruitCrew(@PathVariable Long id) {
    crewService.setRecruited(id);
    return "redirect:/crews/" + id + "/setting";
  }

  // 크루 종료 여부
  @PostMapping("/crews/{id}/close")
  public String closeCrew(@PathVariable Long id) {
    crewService.setClosed(id);
    return "redirect:/crews/" + id + "/setting";
  }

}

참고로 Thymeleaf는 바로 이전 게시글인 크루 CRUD와 똑같아서 크루 세팅이나 참가, 탈퇴와 관련된 부분만 가져오겠다

Thymeleaf

크루 소개 화면

...
👥크루원
  
  
    
  
...

크루원을 가져올 때 Crew 엔티티의 List users = new ArrayList<>();를 통해 크루원들을 가져온다.

크루 설정

이 부분은 crewResponse로부터 크루 공개 여부, 크루 모집 여부, 크루 활동 종료 여부 등의 값들을 가져와서 true, false값을 가지고 버튼의 값을 변경한다.

크루 가입

fragment에 크루 헤더에 관해 작성한 부분인데 다음과 같이 값이 넘어온다.

- 크루 설정은 크루장만 볼 수 있게 작성했다.
- 멤버이면 크루 탈퇴 버튼이 보이고 멤버가 아니면 크루 가입 버튼이 보인다.

#### 크루장인 경우![](https://velog.velcdn.com/images/security-won/post/27a63b89-06cf-46cb-83a0-153b7b76afe7/image.png)

#### 크루장인 아닌 경우![](https://velog.velcdn.com/images/security-won/post/d0a542fa-d816-45fe-b710-789e843c7ae7/image.png)

#### 크루원이 아닌 경우![](https://velog.velcdn.com/images/security-won/post/eb4ac660-ced8-4401-8e67-389ca13331c9/image.png)

#### 크루원인  경우![](https://velog.velcdn.com/images/security-won/post/319cbef4-563b-42ff-bf4b-35f2d5a09f1d/image.png)![](https://velog.velcdn.com/images/security-won/post/6b9c783f-d78d-43b4-8c41-44124d79bc21/image.png)
- 관심있어요 기능은 크루원인 경우에 안보이게 했다.

[개발일지] 취미 커뮤니티 - 크루 CRUD

Tue, 24 Oct 2023 16:11:13 GMT

크루 CRUD 기능 구현에 대해 정리하고자 한다.

Crew

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

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

  @ManyToOne(fetch = FetchType.LAZY)
  @JoinColumn(name = "user_id")
  private User user; // 크루장 - 로그인한 user

  private String name; // 크루이름
  private boolean type; //  true-온라인, false-오프라인
  private boolean cost; // true-유료탑승, false-무료탑승
  private boolean isRecruiting; // true - 모집중, false - 모집X,
  private boolean isPublished; // true - 공개O, false - 공개X
  private boolean isClosed; // true - 종료
  private String thumbnail; //이미지 경로 , 처음엔 기본 이미지 -> 크루 설정을 통해 배너 수정 가능

  @Lob // varchar보다 클 경우 사용하는 어노테이션
  private String description; // 크루 목적

  @Lob // varchar보다 클 경우 사용하는 어노테이션
  private String wisher; // 원하는 선원

  @Lob // varchar보다 클 경우 사용하는 어노테이션
  private String plan; // 크루즈 설명

  @ManyToMany
  @JoinTable(name = "user_crew")
  private List users = new ArrayList<>();


  public void update(CrewUpdateRequestDto crewUpdateRequestDto){
    this.name = crewUpdateRequestDto.getName();
    this.type = crewUpdateRequestDto.isType();
    this.cost = crewUpdateRequestDto.isCost();
    this.description = crewUpdateRequestDto.getDescription();
    this.wisher = crewUpdateRequestDto.getWisher();
    this.plan = crewUpdateRequestDto.getPlan();
  }

}

@ManyToMany를 권장하지는 않지만 우선 존재하는 방법이기 때문에 한번 사용은 해봐야겠다는 생각이 들어 여기서는 @ManyToMany를 사용해보았다.

우선 크루 생성과 관련된 필드들만 나타냈다.

DTO

CrewSaveRequestDto

@Getter @Setter
@NoArgsConstructor
@AllArgsConstructor
public class CrewSaveRequestDto {
private String name; // 크루이름
private boolean type; //  true-온라인, false-오프라인
private boolean cost; // true-유료탑승, false-무료탑승
private String description; // 크루즈 설명
private String wisher; // 원하는 선원
private String plan; // 크루즈 설명

public Crew toEntity(){ return Crew.builder() .name(name) .type(type) .cost(cost) .wisher(wisher) .plan(plan) .description(description) .isPublished(true) // 처음 crew를 만들 땐 true .isRecruiting(true) // 처음 crew를 만들 땐 true .isClosed(false) // 처음 crew를 만들 땐 false .build(); } }

- 크루 썸네일 기능은 구현중에 있다..............
### CrewResponseDto
```java
@Getter
@NoArgsConstructor
public class CrewResponseDto {

  private Long id; // 크루 조회할 때 사용
  private String leader; // 크루장
  private String name; // 크루명
  private boolean type; //  true-온라인, false-오프라인
  private boolean cost; // true-유료탑승, false-무료탑승
  private String description; // 크루즈 설명
  private String wisher; // 원하는 선원
  private String plan; // 크루즈 설명
  private boolean isRecruit; // true - 모집중, false - 모집X
  private boolean isPublished; // true - 공개O, false - 공개X
  private boolean isClosed;
  private List users;

  public CrewResponseDto(Crew crew) {
    this.id = crew.getId();
    this.leader = crew.getUser().getNickname();
    this.name = crew.getName();
    this.type = crew.isType();
    this.cost = crew.isCost();
    this.description = crew.getDescription();
    this.wisher = crew.getWisher();
    this.plan = crew.getPlan();
    this.isRecruit = crew.isRecruiting();
    this.isPublished = crew.isPublished();
    this.isClosed = crew.isClosed();
    this.users = crew.getUsers().stream().map(UserResponseDto::new).collect(Collectors.toList());
  }
}

딱히 설명이 필요해 보이는 코드는 없는거같다.

CrewUpdateRequestDto

@Getter @Setter
@NoArgsConstructor
@AllArgsConstructor
public class CrewUpdateRequestDto {
private String name; // 크루이름
private boolean type; //  true-온라인, false-오프라인
private boolean cost; // true-유료탑승, false-무료탑승
private String description; // 크루즈 설명
private String wisher; // 원하는 선원
private String plan; // 크루즈 설명
}

## CrewRepository
```java
public interface CrewRepository extends JpaRepository {

  Page findAll(Pageable pageable);

}

크루 전체 조회시 페이징 기능을 위해 추가했다.

CrewService

@Service
@RequiredArgsConstructor
@Transactional
@Slf4j
public class CrewService {
private final CrewRepository crewRepository;

// 크루 저장
public Long save(CrewSaveRequestDto crewSaveRequestDto, User user){
  Crew crew = crewSaveRequestDto.toEntity();
  crew.setUser(user);
  Crew savedCrew = crewRepository.save(crew);
  return savedCrew.getId();
}
// 크루 전체 조회
public Page findAll(Pageable pageable) {
  Page crews = crewRepository.findAll(pageable).map(CrewResponseDto::new);
  return crews;
}
// 크루 상세 조회
public CrewResponseDto findById(Long id){
  Crew crew = crewRepository.findById(id).orElseThrow(IllegalArgumentException::new);
  return new CrewResponseDto(crew);
}

// 크루 삭제 (크루장만 삭제 가능)
public void delete(Long id){
  crewRepository.deleteById(id);
}

// 크루 참가
public void addUser(Long id, User user){
  Crew crew = crewRepository.findById(id).orElseThrow(IllegalArgumentException::new);
  if (crew.isJoinable(user)){
    crew.addUser(user);
  }
}

public void leaveCrew(Long id, User user){
  Crew crew = crewRepository.findById(id).orElseThrow(IllegalArgumentException::new);
  if (crew.isMember(user)) {
    crew.removeUser(user);
  }
}

@Transactional
public void update(Long id, CrewUpdateRequestDto crewUpdateRequestDto){
  Crew crew = crewRepository.findById(id).orElseThrow(IllegalArgumentException::new);
  crew.update(crewUpdateRequestDto); 
}
}

이렇게 엔티티로 Dto를 넘겨도 되는지는 아직 의문이지만 우선은 Update 정보를 담은 dto를 넘겨줌으로써 크루 수정 코드를 작성했다.

CrewViewController

@Controller
@RequiredArgsConstructor
@Transactional
@Slf4j
public class CrewViewController {
private final CrewService crewService;

// 크루 생성 폼
@GetMapping("/crews/form")
public String crewForm(Model model) {
  model.addAttribute("crewSaveRequestDto", new CrewSaveRequestDto());
  return "crew/form";
}

// 크루 생성
@PostMapping("/crews/form")
public String crewSave(@ModelAttribute CrewSaveRequestDto crewSaveRequestDto,
                       HttpSession session) {
  User loginUser = (User) session.getAttribute("loginUser");
  Long id = crewService.save(crewSaveRequestDto, loginUser);
  return "redirect:/crews/" + id;
}

// 크루 조회 - 상세 조회
@GetMapping("/crews/{id}") // 서비스 기본화면
public String crew(@PathVariable Long id, Model model, HttpSession session) {
  User user = (User) session.getAttribute("loginUser");
  CrewResponseDto crewResponseDto = crewService.findById(id);

  UserResponseDto loginUser = new UserResponseDto(user);

  model.addAttribute("loginUser", loginUser);
  model.addAttribute("crewResponseDto", crewResponseDto);

  return "crew/intro";
}

// 크루 전체 조회 - 현재 모집 중인 크루즈
@GetMapping(/crews) // 서비스 기본화면
public String crews(Model model,
                    @PageableDefault(size = 5, sort = "createdDate",
                        direction = Sort.Direction.DESC) Pageable pageable,
                    @SessionAttribute(name = "loginUser", required = false) User loginUser) {
  Page crews = crewService.findAll(pageable);
  model.addAttribute("loginUser", loginUser);
  model.addAttribute("crews", crews); // 현재 모집 중인 크루즈를 나타낼 때 사용
  //model.addAttribute("top10Crew", crews); // top10크루 정보를 담고 있음 -> 쿼리를 생성해서 가져와야할듯
  return "main";

}
@DeleteMapping("/crews/{id}/delete")
public String deleteCrew(@PathVariable Long id){
  crewService.delete(id);
  return "redirect:/";
}

}

- 아직 Top10 크루는 구현하지 않았다. 어떤 기준으로 Top10을 선정할지 고민중이다.
- 아마 Top10 크루를 가져올 때 쿼리를 직접 작성해서 가져올거같다.

## Top10 크루 가져오기 추가 예정!
- 이 부분은 아직 기능이 완성되지 않았다.
- 그래서 Top10 관련된 코드들은 무시하면 된다.

## Thymeleaf
### 크루 생성 폼
```html



  
  Title
  



  크루 생성 후 수정할 수 있습니다.
  
    크루즈명
    

    온라인 유무
    

    비용 유무
    

    크루 소개
    

    이런 선원을 원해요.
    

    항해 계획

크루 상세 화면




  
  크루 상세 화면
  



  
  

  
    
    👍저희 크루는 이런 크루입니다.
    
    
🧐저희 크루는 이러한 사람을 원해요.
    
    📆저희 크루의 활동 계획입니다.
    
    
👥크루원

fragment.html

Top 10 크루

현재 모집 중인 크루즈

아직 해당 웹 서비스 컨셉을 고민중이어서 단어 컨셉(?)이 일치하지 않을 수 있습니다... 디자인은 마지막에...

화면

main 화면

크루 form 화면

크루 상세 화면

크루 수정 및 삭제

포스팅 중에 경로를 crew -> crews로 변경했고 포스팅 내용에도 수정을 했지만 수정이 덜 된 부분이 있을 수 있어 혹시 404에러가 발생하신다면 crews로 변경하시면 됩니다.

아직 부족한 코드이고 공부하면서 작성하고있습니다. 조언 너무 감사합니다.

[개발일지] 첨부파일 기능 추가

Thu, 19 Oct 2023 03:43:25 GMT

게시글을 작성할 때 이미지 파일도 업로드 가능하게 기능을 추가하였다. 참고로 파일 업로드를 구현할 때 폼에 enctype="multipart/form-data"를 추가해줘야한다.

~~해시태그는 구현중이다........~~

application.yaml

이름엔 제 이름이 들어있어서 우선 저렇게 작성했습니다.
```
file:
dir: /Users/이름/Desktop/file-upload/
```

Board

@Entity
@Getter
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Board extends BaseTimeEntity {

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

  private String title;

  @Lob
  private String content;

  @ManyToOne(fetch = FetchType.LAZY) "user" 추가해주면 됨.
  @JoinColumn(name = "user_id")
  private User user;

  @OneToMany(mappedBy = "board", fetch = FetchType.LAZY, cascade = CascadeType.REMOVE) // 글이 삭제되면 댓글 모두 삭제
  @OrderBy("createdDate")
  private List replies = new ArrayList<>();

  @OneToMany(mappedBy = "board",fetch = FetchType.LAZY, cascade = CascadeType.ALL)
  private List imgFiles = new ArrayList<>(); 

  @OneToMany(mappedBy = "board", fetch = FetchType.LAZY, cascade = CascadeType.REMOVE)
  private List tags = new ArrayList<>();

  public void setUser(User user){
    this.user = user;
  }

  public void setImgFile(List imgFiles){
    this.imgFiles = imgFiles;
    for (ImgFile file : imgFiles) {
      file.setBoard(this);
    }
  }

  public void addTag(Tag tag){
    tags.add(tag);
    tag.setBoard(this);
  }

  public void update(String title, String content) {
    this.title = title;
    this.content = content;
  }

  @Builder
  public Board(String title, String content) {
    this.title = title;
    this.content = content;
  }
}

Board엔티티인데 Board랑 imgFiles는 1:N 관계이다.

Board랑 imgFiles는 양방향 관계라서 연관관계 편의 메서드인 setImgFile(...)을 작성해줬는데 뭔가 아쉽다.....좀 더 연관관계 편의 메서드에 대해서 찾아봐야겠다.

ImgFile

@Getter
@Entity
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor(access = AccessLevel.PROTECTED) // 이거 추가해주니까 되네... 이유가..
public class ImgFile extends BaseTimeEntity {

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

private String originFilename; // 업로드된 파일 이름
private String storeFilename; // 저장한 파일명 ex) 132-5sdf-23451-1as.png -> UUID로 식별자 생성 + 확장자

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name = "board_id")
private Board board;

@Builder
public ImgFile(String originFilename, String storeFilename) {
  this.originFilename = originFilename;
  this.storeFilename = storeFilename;
}

public void setBoard(Board board) {
  this.board = board;
}
}

FileStore

파일 처리 관련 코드만을 모아두었다.
파일을 업로드한 파일명은 중복될 수 있기때문에 UUID를 활용하여 DB엔 "UUID + 확장자"로 파일명을 변경하여 DB에 파일명만 저장한다.
파일 자체를 DB에 저장하지않고 보통 스토리지에 저장한다. AWS로 예를 들자면 S3에 저장한다.

그래서 DB엔 파일 자체를 저장하지 않는다.

@Component
public class FileStore {

@Value("${file.dir}") // application.yaml or application.properties에 지정한 파일 경로
private String fileDir;

// 파일 저장 경로 Full
public String getFullPath(String filename){
  return fileDir + filename;
}

public ImgFile storeFile(MultipartFile multipartFile) throws IOException {
  if (multipartFile.isEmpty()){
    return null;
  }
  String originalFileName = multipartFile.getOriginalFilename();
  String ext = extractedExt(originalFileName);
  String storeFileName = createStoreFileName(ext);
  multipartFile.transferTo(new File(getFullPath(storeFileName)));

  return ImgFile.builder()
      .originFilename(originalFileName)
      .storeFilename(storeFileName)
      .build();
}
// 여러 개 업로드 하는 경우
public List storeFiles(List multipartFiles) throws IOException{
  List files = new ArrayList<>();
  for (MultipartFile multipartFile : multipartFiles) {
    if (multipartFile.isEmpty()) {
      return null;
    }
    files.add(storeFile(multipartFile));
  }
  return files;
}

// UUID를 활용해 저장용 파일명
private String createStoreFileName(String ext) {
  String uuid = UUID.randomUUID().toString();
  String storedFileName = uuid + "." + ext;
  return storedFileName;
}

// 파일 확장자 추출
private String extractedExt(String originalFileName) {
  int pos = originalFileName.lastIndexOf(".");
  String ext = originalFileName.substring(pos + 1);
  return ext;
}
}

FileService

@Service
@RequiredArgsConstructor
public class FileService {
private final FileStore fileStore;
private final FileRepository fileRepository; 

public List transferImgFile(List imgFile) throws IOException {
  List imgFiles = fileStore.storeFiles(imgFile);
  return imgFiles;
}

public void deleteBeforeFile(Board board){
  if (!board.getImgFiles().isEmpty()) {
    // 이전 첨부파일 삭제
    if (!board.getImgFiles().isEmpty()) {
      for (ImgFile imgFile : board.getImgFiles()) {
        // 파일 시스템에서 실제 이미지 파일 삭제
        File imgFileOnDisk = new File(fileStore.getFullPath(imgFile.getStoreFilename()));
        if (imgFileOnDisk.exists()) {
          imgFileOnDisk.delete();
        }
        // 데이터베이스에서 이미지 파일 레코드 삭제
        this.delete(imgFile);
      }
    }
  }
}
public void delete(ImgFile imgFile){
  fileRepository.delete(imgFile);
}

}

## FileRepository
```java
public interface FileRepository extends JpaRepository {

}

BoardSaveRequestDto

@Getter
@Setter
@NoArgsConstructor
@AllArgsConstructor
public class BoardSaveRequestDto {
  private String title;
  private String content;
  private List imgFiles;

  public Board toEntity() {
    return Board.builder()
        .title(title)
        .content(content)
        .imgFiles(new ArrayList<>())
        .build();
  }
}

BoardController

게시글 등록 관련한 부분만 가져왔다.

...
// 글 등록
@PostMapping("/board/form")
public String boardSave(@ModelAttribute BoardSaveRequestDto boardSaveRequestDto,
                        @RequestBody TagSaveRequestDto tagSaveRequestDto, // 해시태그
                        HttpSession session) throws IOException {
  User loginUser = (User) session.getAttribute("loginUser");
  boardService.save(boardSaveRequestDto, loginUser);
  return  "redirect:/boards";
}
...

BoardService

파일 처리 관련 부분만 가져왔다.

// 게시판 등록
private final BoardRepository boardRepository;
private final FileService FileService;

...
@Transactional
public Long save(BoardSaveRequestDto request, User user) throws IOException {
  List imgFiles = FileService.transferImgFile(request.getImgFiles());// List -> List
  Board board = request.toEntity(); // title, content
  board.setUser(user);
  if (imgFiles == null){
    board.setImgFile(new ArrayList<>()); // 첨부파일이 없더라도 게시글이 저장이 되도록하기 위해서 추가함. 
  } else {
    board.setImgFile(imgFiles); //
  }
  Board savedBoard = boardRepository.save(board);
  return savedBoard.getId();
}

다음은 게시글을 수정할 때의 로직이다.

BoardService

파일 처리 관련 부분만 가져왔다.

// 게시판 등록
// 게시글 수정
@Transactional
public void update(Long id, BoardUpdateRequestDto request) throws IOException {
  Board board = boardRepository.findById(id)
      .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 포스트입니다."));

  List imgFiles = FileService.transferImgFile(request.getImgFiles()); // 새로 업로드한 파일
  FileService.deleteBeforeFile(board); // 이전에 업로드 한 파일 삭제

  // 수정한 첨부파일로 연관관계 매핑
  board.setImgFile(imgFiles);
  board.update(request.getTitle(), request.getContent());

실행 화면

화면에 출력하는 html 코드는 생략하겠다.

스토리지

데이터베이스

뭔가 부족함이 많은 코드인거같다. 계속 공부하면서 리팩토링 해야겠다. 피드백을 주시면 감사하겠습니다.........

[개발일지] 취미 커뮤니티 Trouble Shooting - MultipleBagFetchException

Tue, 17 Oct 2023 03:09:35 GMT

해시 태그 구현 중에 다음과 같이 에러가 발생했다.

Invocation of init method failed; nested exception isjavax.persistence.PersistenceException:[PersistenceUnit: default]
Unable to build Hibernate SessionFactory;nested exception is org.hibernate.loader.MultipleBagFetchException:
cannot simultaneously fetch multiple bags: [com.jiwon.blog.domain.board.Board.tags, com.jiwon.blog.domain.board.Board.replies]

Board

@Entity @Getter
@NoArgsConstructor @AllArgsConstructor
@Builder
public class Board extends BaseTimeEntity {

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

  private String title;
  @Lob
  private String content;

  @ManyToOne(fetch = FetchType.EAGER)
  @JoinColumn(name = "user_id")
  private User user;

  @OneToMany(mappedBy = "board", fetch = FetchType.EAGER, cascade = CascadeType.REMOVE) // 글이 삭제되면 댓글 모두 삭제
  @OrderBy("createdDate")
  private List replies = new ArrayList<>();

  @OneToMany(mappedBy = "board", fetch = FetchType.EAGER, cascade = CascadeType.REMOVE)
  private List tags = new ArrayList<>();

  public void setUser(User user){ 
    this.user = user;
  }

  public void update(BoardUpdateRequestDto request) {
    this.title = request.getTitle();
    this.content = request.getContent();
  }
}

Hibernate MultipleBagFetchException

찾아보니 OneToMany, ManyToMany인 Bag 두 개 이상을 EAGER로 fetch할 때 발생하는 에러라고 한다. 위 코드에선 OneToMany인 replies와 tags를 EAGER로 fetch해서 발생한 것이었다.

Bag

Bag 2개 이상.. Bag란 무엇인가 Bag(Multiset)은 Set과 같이 순서가 없고, List와 같이 중복을 허용하는 자료구조라고 한다. 하지만 자바 컬렉션 프레임워크에서는 Bag가 없기 때문에 하이버네이트에서는 List를 Bag으로써 사용하고 있는 것이다고 한다.

해시 태그는 보통 중복이 발생하지 않으니 List로 된 형식을 Set으로 바꿔서 해결할 수 있는데 프로젝트에선 tagify 라이브러리를 사용해서 해시 태그를 구현했다. 사용해보니 화면에서 값이 넘어올 때 중복 해시 태그가 제거된 상태로 넘어와서 해시 태그도 Set타입이 아닌 List타입으로 사용했었다.

그렇다면 왜 OneToMany, ManyToMany인 Bag 두 개 이상을 EAGER로 fetch할 때 발생하는것인가?

이유

해시 태그를 set자료형으로 바꾸고 실행해보면 MultipleBagFetchException이 발생하지 않는다.

하이버네이트에서는 list를 Bag타입으로 취급한다고 했다.
Bag는 순서도 없고 중복을 허용하는 자료구조이다.
OneToMany, ManyToMany인 Bag(list) 두 개 이상을 가져오면 발생한다고 했다.
순서도 보장해주지 않고 중복도 허용하는 자료구조에서 어떤 기준으로 join을 할 지에 대한 기준도 명확하지 않기 때문에 발생하는 에러인거 같다.

해결

그래서 해결법에 대한 것을 찾아보다가 다음과 같이 정리해주신 분의 블로그를 읽으면서 해결했다. MultipleBagFetchException 발생시 해결 방법

fetch 타입을 LAZY로 변경
@Entitygraph 사용

bachsize 지정

@Entity
@Getter
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Board extends BaseTimeEntity {

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

private String title;
@Lob
private String content;

@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name = "user_id")
private User user;

@OneToMany(mappedBy = "board", fetch = FetchType.LAZY, cascade = CascadeType.REMOVE) // 글이 삭제되면 댓글 모두 삭제
@OrderBy("createdDate")
private List replies = new ArrayList<>();

@OneToMany(mappedBy = "board", fetch = FetchType.LAZY, cascade = CascadeType.REMOVE)
private Set tags = new HashSet<>();

// 연관관계 편의 메서드 ...(?) 맞나? 잘 모르겠다..
public void addTags(Tag tag){
 this.tags.add(tag);
}

public void setUser(User user){ // 연관관계 편의 메서드
 this.user = user;
}

public void update(BoardUpdateRequestDto request) {
 this.title = request.getTitle();
 this.content = request.getContent();
}
}

@Repository
public interface BoardRepository extends JpaRepository {

@Override
@EntityGraph(attributePaths = {"replies","tags"}) //{}안에 있는 것들을 fetch join해서 가져오겠다.
List findAll();

Page findAll(Pageable pageable);
}

```yaml
...
  jpa:
    hibernate:
      ddl-auto: create # ???? ??? drop? ???
    properties:
      hibernate:
        show_sql: true
        format_sql: true
        default_batch_fetch_size: 1000 # multibagfetchException 해결
...

reference (Troubleshooting) Hibernate MultipleBagFetchException 정복하기

MultipleBagFetchException 발생시 해결 방법

[개발일지] 취미 커뮤니티 (4) 댓글 등록, 삭제, 수정

Sun, 15 Oct 2023 13:54:43 GMT

User

@Entity @Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor
@Table(name = "users")
public class User extends BaseTimeEntity {
  @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "user_id")
  private Long id;
  private String name; // 본명
  private String nickname; // 별명
  private String password;
  private String email;

  @Builder
  public User(String name, String nickname, String password, String email) {
    this.name = name;
    this.nickname = nickname;
    this.password = password;
    this.email = email;
  }

  public void update(UserUpdateRequestDto updateDto) {
    this.nickname = updateDto.getNickname();
    this.password = updateDto.getPassword();
  }
}

Reply

@Entity
@Getter
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Reply extends BaseTimeEntity {
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;
  @Lob
  private String comment;

  @ManyToOne(fetch = FetchType.EAGER)
  @JoinColumn(name = "user_id")
  private User user;

  @ManyToOne(fetch = FetchType.EAGER)
  @JoinColumn(name = "board_id")
  private Board board;

  public void update(ReplyUpdateRequestDto updateRequestDto) {
    this.comment = updateRequestDto.getComment();
  }

  public void setUser(User user){
    this.user = user;
  }
  // 연관관계 편의 메서드
  public void setBoard(Board board){
    if(this.board != null) {
      this.board.getReplies().remove(this);
    }
    this.board = board;
    this.board.getReplies().add(this);
  }
}

Board

@Entity
@Getter
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Board extends BaseTimeEntity {

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

  private String title;
  @Lob
  private String content;

  @ManyToOne(fetch = FetchType.EAGER)
  @JoinColumn(name = "user_id")
  private User user;

  @OneToMany(mappedBy = "board", fetch = FetchType.EAGER, cascade = CascadeType.REMOVE) // 글이 삭제되면 댓글 모두 삭제
  @OrderBy("createdDate")
  private List replies = new ArrayList<>();


  public void setUser(User user){ // 연관관계 편의 메서드
    this.user = user;
  }

  public void update(BoardUpdateRequestDto request) {
    this.title = request.getTitle();
    this.content = request.getContent();
  }
}

게시물 삭제 시 댓글도 함께 삭데되도록 cascade 설정함.
게시물 가져올 땐 댓글도 필수이니 EAGER로 설정했음.. ~~하지만 나중에 문제가 될지 몰랐지..~~

ReplyRepository

public interface ReplyRepository extends JpaRepository {
  Page findAll(Pageable pageable);
}

ReplyService

@Service
@RequiredArgsConstructor
public class ReplyService {
  private final ReplyRepository replyRepository;
  private final BoardRepository boardRepository;
  private final EntityManager em;

  // 댓글 등록
  public void save(Long boardId, User user, ReplySaveRequestDto replySaveRequestDto){
    Board board = boardRepository.findById(boardId)
        .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 포스트입니다.")); // 이러면 코드가 너무 반복되지 않나..음..방법을 찾아보자..
    Reply reply = replySaveRequestDto.toEntity();
    reply.setBoard(board);
    reply.setUser(user);
    replyRepository.save(reply);
  }
  // 댓글 조회 (전체) , 댓글 단건 조회는 딱히,, "내가 쓴 댓글 보기"에서 사용할 메서드
  // 마이페이지 구현할 때 구현할 것
  // 댓글 삭제
  public Long delete(Long id){
    // 여기서 postID를 반환하게 ..
    Long boardId = em.createQuery("select r.board.id from Reply r where r.id=:id ", Long.class)
        .setParameter("id", id)
        .getSingleResult();
    replyRepository.deleteById(id);
    return boardId;
  }
  // 댓글 수정
  @Transactional
  public Long update(Long id, ReplyUpdateRequestDto updateRequestDto){
    Long boardId = em.createQuery("select r.board.id from Reply r where r.id=:id ", Long.class)
        .setParameter("id", id)
        .getSingleResult();
    Reply reply = replyRepository.findById(id).orElseThrow(IllegalArgumentException::new);
    reply.update(updateRequestDto);
    return boardId;
  }
}

ReplyViewController

@Controller
@RequiredArgsConstructor
public class ReplyViewController {
  private final ReplyService replyService;
  private final BoardService boardService;

  // 댓글 등록
  @PostMapping("/boards/reply/{boardId}")
  public String save(@PathVariable Long boardId, @ModelAttribute ReplySaveRequestDto replySaveRequestDto,
                     HttpSession session) {
    User loginUser = (User) session.getAttribute("loginUser");
    replyService.save(boardId, loginUser, replySaveRequestDto);
    return "redirect:/boards/"+boardId;
  }
  // 댓글 삭제
  @DeleteMapping("/boards/reply/{replyId}")
  public String delete(@PathVariable Long replyId) {
    // 게시판의 아이디가 아니라 댓글의 아이디 여야함.
    // board로 어떻게 보내지,, -> replyId를 사용해서 쿼리문 조인해서 보드 아이디 가져오게함. 지금은 생각나는 방법이 이거밖에 없음..
    Long boardId = replyService.delete(replyId);
    return "redirect:/boards/"+boardId;
  }

  // 댓글 수정
  @PostMapping("/boards/edit/reply/{replyId}")
  public String update(@PathVariable Long replyId, @ModelAttribute ReplyUpdateRequestDto updateRequestDto){
    Long boardId = replyService.update(replyId, updateRequestDto);
    return "redirect:/boards/"+boardId;
  }
  // 댓글 조회 - "내가 쓴 댓글 보기"를 클릭한 경우

}

Thymeleaf - detailBoard.html




  
  상세 조회 화면
  


  
    
      작성자 :

동작 화면

대댓글 기능도 추가할기 말지 고민이다.

[개발일지] 취미 커뮤니티 개발일지 (3) 자유게시판 글 CRUD + 페이징

Thu, 12 Oct 2023 18:24:21 GMT

자유 게시판 기능부터 구현해보도록 하겠다. ~~상대적으로 ,, 간단해보인다,,,~~

우선 값 검증이나 이런것들은 한번에 하겠다.

참고로 제대로 동작하는지 위해 다음과 같이 임시 데이터를 넣어줬다. (@PostConstruct 사용)

baseTimeEntity

@MappedSuperclass
@Getter
@EntityListeners(AuditingEntityListener.class)
public class BaseTimeEntity {

  @CreatedDate
  @Column(updatable = false)
  private LocalDateTime createdDate; // 등록일

  @LastModifiedDate
  private LocalDateTime lastModifiedDate; // 수정일

  @PrePersist
  public void prePersist() {
    LocalDateTime now = LocalDateTime.now();
    createdDate = now;
    lastModifiedDate = now;
  }
  @PreUpdate
  public void preUpdate(){
    LocalDateTime now = LocalDateTime.now();
    lastModifiedDate = now;
  }![](https://velog.velcdn.com/images/security-won/post/ffc89259-97f5-4f89-9789-e65f007cfa8f/image.gif)


}

User

@Entity @Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor
@Table(name = "users")
public class User extends BaseTimeEntity {
  @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
  @Column(name = "user_id")
  private Long id;
  private String name; // 본명
  private String nickname; // 별명
  private String password;
  private String email;

  @Builder
  public User(String name, String nickname, String password, String email) {
    this.name = name;
    this.nickname = nickname;
    this.password = password;
    this.email = email;
  }

  public void update(UserUpdateRequestDto updateDto) {
    // 갑자기 궁금한게 회원정보를 닉네임만 변경하던가 비번만 변경할 수 있는데 이럴경우 업데이트 메서드를 따로 분리해야하나?
    this.nickname = updateDto.getNickname();
    this.password = updateDto.getPassword();
  }
}

board

자유게시판 엔티티

@Getter
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Board extends BaseTimeEntity {

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

private String title;
@Lob
private String content;

@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name = "user_id")
private User user;

public void setUser(User user){ 
  this.user = user;
}

public void update(BoardUpdateRequestDto request) {
  this.title = request.getTitle();
  this.content = request.getContent();
}
}

User와 board는 일대다 관계.

boardRepository

@Repository
public interface BoardRepository extends JpaRepository {

Page findAll(Pageable pageable);
}

boardService

@Service
@RequiredArgsConstructor
public class BoardService {
private final BoardRepository boardRepository;

// 게시판 등록
public Long save(BoardSaveRequestDto request, User user){
  Board board = request.toEntity();
  board.setUser(user);
  boardRepository.save(board);
  return board.getId();
}
// 게시판 조회 - 단건
public BoardResponseDto findById(Long id){
  Board board = boardRepository.findById(id).orElseThrow(() -> new IllegalArgumentException("존재하지 않는 포스트입니다."));
  return new BoardResponseDto(board);
}
// 게시판 조회 - 전체
public List findAll() {
  List boards = boardRepository.findAll()
      .stream()
      .map(BoardResponseDto::new)
      .collect(Collectors.toList());
  return boards;
}
// 게시판 조회 - 전체, 페이징 적용
public Page findAll(Pageable pageable) {
  Page boards = boardRepository.findAll(pageable).map(BoardResponseDto::new);
  return boards;
}
// 회원 삭제
public void delete(Long id){
  boardRepository.deleteById(id);
}

// 게시판 수정
@Transactional
public void update(Long id, BoardUpdateRequestDto request){
  Board board = boardRepository.findById(id)
      .orElseThrow(() -> new IllegalArgumentException("존재하지 않는 포스트입니다."));
  board.update(request);
}
}

boardViewController

package com.jiwon.blog.web.controller.view;

import com.jiwon.blog.domain.user.User; import com.jiwon.blog.repository.UserRepository; import com.jiwon.blog.service.BoardService; import com.jiwon.blog.web.dto.board.BoardResponseDto; import com.jiwon.blog.web.dto.board.BoardSaveRequestDto; import com.jiwon.blog.web.dto.board.BoardUpdateRequestDto; import lombok.RequiredArgsConstructor; import org.springframework.data.domain.Page; import org.springframework.data.domain.Pageable; import org.springframework.data.domain.Sort; import org.springframework.data.web.PageableDefault; import org.springframework.stereotype.Controller; import org.springframework.ui.Model; import org.springframework.web.bind.annotation.*;

import javax.servlet.http.HttpSession; import java.util.List;

@Controller @RequiredArgsConstructor public class BoardViewController {

private final BoardService boardService;

// 글 등록 폼 보여주기 @GetMapping("/board/form") public String boardWrite(Model model){ model.addAttribute("boardSaveRequestDto", new BoardSaveRequestDto()); return "board/form"; }

// 글 등록 @PostMapping("/board/form") public String boardSave(@ModelAttribute BoardSaveRequestDto boardSaveRequestDto, HttpSession session){ User loginUser = (User) session.getAttribute("loginUser"); boardService.save(boardSaveRequestDto, loginUser); return "redirect:/boards"; }

// 글 조회 - 단건 = 상세 조회 @GetMapping("/boards/{id}") public String boards(@PathVariable Long id, Model model) { BoardResponseDto board = boardService.findById(id); model.addAttribute("board", board); return "board/detailBoard";

} // 글 조회 - 전체 - 페이징 @GetMapping("/boards") public String boards(Model model, @PageableDefault(size = 5, sort = "createdDate", direction = Sort.Direction.DESC) Pageable pageable) { Page boards = boardService.findAll(pageable); model.addAttribute("boards", boards); return "board/main";

} // 글 삭제 @DeleteMapping("/boards/{id}") public String delete(@PathVariable Long id){ boardService.delete(id); return "redirect:/boards"; }

// 글 수정 폼 @GetMapping("/boards/{id}/edit") public String updateForm(@PathVariable Long id, Model model){ BoardResponseDto board = boardService.findById(id); BoardUpdateRequestDto boardUpdateRequestDto = new BoardUpdateRequestDto(); boardUpdateRequestDto.setTitle(board.getTitle()); boardUpdateRequestDto.setContent(board.getContent());

model.addAttribute("boardUpdateRequestDto", new BoardUpdateRequestDto());
return "board/modifyForm";

} // 글 수정 @PutMapping("/boards/{id}/edit") public String update(@PathVariable Long id, @ModelAttribute BoardUpdateRequestDto boardUpdateRequestDto, @RequestParam(defaultValue = "/") String redirectURL){ boardService.update(id, boardUpdateRequestDto); return "redirect:/boards/"+id; } }

## 
---
- CRUD 기능 구현, 임시지만 로그인 한 사용자가 글 작성시 글과 작성자가 제댈 매핑되는지 확인하기 위해 아주 간단한 로그인 로직을 구성했다.
- 그리고 delete와 put 메서드르 사용하기 위해 application.yml에 다음과 같이 설정해줌으로써 put, delete 메서드를 form태그에서 사용할 수 있게되었다.
- 참고로 th:method="delete", th:method="put"이라고 작성해야한다. th를 써주지 않으면 제대로 동작이 안한다.

spring: ... mvc: hiddenmethod: filter: enabled: true


- 아직은 단순히 CRUD 위주로 구현해서 디테일이 부족하다. 내가 쓴 글에만 삭제와 수정 버튼이 보이게하는지 등 이러한 디테일은 계속 개발을 하면서 수정해나갈 것이다.
- 그리고 page 구현했따^^ sw 직무 역량 부트캠프를 수강하면서 페이징 구현을 하지 못했는데 공부하고 직접 구현해보니까 너무 뿌듯하다.
- UI는 나중에....

짱구로 로그인한 후 테스트 시연이다. ~~(맥북 영상녹화 시프트 + 커맨드 + 숫자 5)~~![](https://velog.velcdn.com/images/security-won/post/d9609f99-d094-480f-a59f-8eceb86a1172/image.gif)

디테일보단 우선 기능위주로,,, ~~UI는 참참참^^~~

[개발일지] 취미 커뮤니티 개발일지 (2)

Wed, 11 Oct 2023 12:03:11 GMT

User

@Entity @Getter
@NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor
@Table(name = "users")
public class User extends BaseTimeEntity {
  @Id @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;
  private String username; // 본명
  private String nickname; // 별명
  private String password;
  private String email;

  @OneToMany(mappedBy = "user")
  private Set tags = new HashSet<>(); // tag를 중복으로 가질 수 없으니 Set 자료형으로 함.

  @Builder
  public User(String username, String nickname, String password, String email) {
    this.username = username;
    this.nickname = nickname;
    this.password = password;
    this.email = email;
  }

  public void update(UserUpdateRequestDto updateDto) {
    this.nickname = updateDto.getNickname();
    this.password = updateDto.getPassword();
  }
}

BaseTimeEntity는 등록일과 수정일이 들어있는 베이스 엔티티
User와 Tag는 다대다 관계로 설정함.
다대다 관계는 @ManyToMany어노테이션을 사용해서 구현할 수 있지만 다대다 관계를 일대다,다대일 관계로 풀어내서 작성하는 것이 더 좋아서 UserTag라는 중간 테이블을 생성함

(프로필 기능은 후에 추가할 것)

Tag

@NoArgsConstructor(access = AccessLevel.PROTECTED) @AllArgsConstructor(access = AccessLevel.PROTECTED)
@Getter @Entity @Builder
public class Tag extends BaseTimeEntity {
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;
private String tagName;
}

UserTag

@NoArgsConstructor(access = AccessLevel.PROTECTED)
@AllArgsConstructor(access = AccessLevel.PROTECTED)
@Getter @Entity @Builder
public class UserTag {
// user - UserTag - tag
// User는 관심 주제를 Tag로 설정해서 알림을 받을 수 있도록함.
// 그래서 user와 tag는 다대다 관계여서 일대다, 다대일 관계로 풀어주기 위한 중간 테이블 생성
@Id
@GeneratedValue(strategy = GenerationType.IDENTITY)
private Long id;

@ManyToOne
@JoinColumn(name = "user_id")
private User user;

@ManyToOne
@JoinColumn(name="tag_id")
private Tag tag;
}

Crew

@Entity
@Getter
@NoArgsConstructor
@AllArgsConstructor
@Builder
public class Crew extends BaseTimeEntity {

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

private Long leaderId; // 크루장 id
private String name; // 크루이름
private boolean type; //  true-온라인, false-오프라인
private boolean cost; // true-유료탑승, false-무료탑승
private String thumbnail; //이미지 경로

@Lob // varchar보다 클 경우 사용하는 어노테이션
private String description; // 크루즈 설명
private byte capacity; // 인원수

@OneToMany(mappedBy = "crew")
private Set tags = new HashSet<>(); // tag를 중복으로 가질 수 없으니 Set 자료형으로 함.

@Builder public Crew(Long leaderId, String name, boolean type, boolean cost, String introduction, byte capacity, String thumbnail) { this.leaderId = leaderId; this.name = name; this.type = type; this.cost = cost; this.description = introduction; this.capacity = capacity; this.thumbnail = thumbnail; } public void update(CrewUpdateRequestDto updateDto) { this.name = updateDto.getName(); this.type = updateDto.isType(); this.cost = updateDto.isCost(); this.introduction = updateDto.getIntroduction(); this.capacity = updateDto.getCapacity(); this.thumbnail = updateDto.getThumbnail(); } }

- 갑자기 코드가 와다다다닥 있어서 당황스럽겠지만 개발하면서 필요할꺼같은 메서드들은 미리 생성해두었다.
## CrewTag
```java
@NoArgsConstructor(access = AccessLevel.PROTECTED) @AllArgsConstructor(access = AccessLevel.PROTECTED)
@Getter @Entity @Builder
public class CrewTag {
  // Crew-CrewTag-tag , 다대다 관계를 일대다 다대일 관계로 풀어내기 위한 중간 테이블
  @Id
  @GeneratedValue(strategy = GenerationType.IDENTITY)
  private Long id;

  @ManyToOne(fetch = FetchType.LAZY)
  @JoinColumn(name = "crew_id")
  private Crew crew;

  @ManyToOne(fetch = FetchType.LAZY)
  @JoinColumn(name="tag_id")
  private Tag tag;
}

뭔가 빵꾸가 와장창 있는 코드같다.. 공부하면서 리팩토링을 계속 해야겠다. 음...우선 도메인을 구성하면서 든 생각이,, 자유게시판부터 구현해야겠다. 다음 포스팅은 자유게시판 구현부터 시작하겠다.

조언, 충고,,잔소리 쓴소리 너무 감사합니다.

10.16 양방향 관계가 아니라 단방향 관계로 수정함.

Spring Data jpa 페이징 (2)

Tue, 10 Oct 2023 12:17:53 GMT

Spring Data Jpa에서 페이징과 정렬기능을 스프링 MVC에서 편하게 사용할 수 있다.

바로 코드를 봐보자.

Controller

@RestController
@RequiredArgsConstructor
public class MemberController {
  private final MemberRepository memberRepository;

  @GetMapping("/members")
  public Page memberList(Pageable pageable){
    Page page = memberRepository.findAll(pageable);
    return page;
  }

  @PostConstruct
  public void init() {
    for(int i = 0; i<100; i++){
      memberRepository.save(new Member("user"+i));
    }
  }
}

memberList 메서드의 파리미터로 Pageable이 날라온다.

pageable은 인터페이스여서 구현체로 PageRequest를 사용한다.

protected PageRequest(int page, int size, Sort sort) {
  super(page, size);
  Assert.notNull(sort, "Sort must not be null");
  this.sort = sort;
}
public static PageRequest of(int page, int size) {
  eturn of(page, size, Sort.unsorted());
}

public static PageRequest of(int page, int size, Sort sort) { return new PageRequest(page, size, sort); }

public static PageRequest of(int page, int size, Direction direction, String... properties) { return of(page, size, Sort.by(direction, properties)); }

- PageRequest를 생성할 때 생성자를 통해 객체를 생성하는 것은 deprecated되어 있다고 한다. 그래서 정적 팩토리 메서드 패턴으로 PageRequest.of(...)로 PageRequest를 생성한다.
- 다시 본론으로 돌아가자면 파라미터로 Pageable을 받아 Web의 요청 파라미터를 Pageable과 바인딩할 수 있다.
- 정리하자면 컨트롤러에서 파라미터로 Pageable이 있으면 스프링 부트가 PageRequest객체를 생성해서 파라미터로 넘어온 값들을 바인딩 해준다.

---
이렇게 작성하면 끝이다.
postman을 통해 페이징 파라미터를 함께 전달해보자

### 요청 파라미터
- page : 현재 페이지, 0부터 시작
- size : 한 페이지에 노출할 데이터 건수
- sort : 정렬 조건

### 요청 파라미터 page

GET - http://localhost:8080/members?page=0

### 결과
```json
{
    "content": [
        {
            "createdDate": "2023-10-10T12:42:35.991973",
            "updatedDate": "2023-10-10T12:42:35.991973",
            "id": 1,
            "username": "user0",
            "age": 0,
            "team": null
        },
        {
            "createdDate": "2023-10-10T12:42:36.021407",
            "updatedDate": "2023-10-10T12:42:36.021407",
            "id": 2,
            "username": "user1",
            "age": 1,
            "team": null
        },

        ...

        {
            "createdDate": "2023-10-10T12:42:36.06707",
            "updatedDate": "2023-10-10T12:42:36.06707",
            "id": 18,
            "username": "user17",
            "age": 17,
            "team": null
        },
        {
            "createdDate": "2023-10-10T12:42:36.068257",
            "updatedDate": "2023-10-10T12:42:36.068257",
            "id": 19,
            "username": "user18",
            "age": 18,
            "team": null
        },
        {
            "createdDate": "2023-10-10T12:42:36.069959",
            "updatedDate": "2023-10-10T12:42:36.069959",
            "id": 20,
            "username": "user19",
            "age": 19,
            "team": null
        }
    ],
    "pageable": {
        "sort": {
            "empty": true,
            "unsorted": true,
            "sorted": false
        },
        "offset": 0,
        "pageNumber": 0,
        "pageSize": 20,
        "paged": true,
        "unpaged": false
    },
    "last": false,
    "totalElements": 100,
    "totalPages": 5,
    "number": 0,
    "first": true,
    "sort": {
        "empty": true,
        "unsorted": true,
        "sorted": false
    },
    "size": 20,
    "numberOfElements": 20,
    "empty": false
}

결과를 보니 디폴트가 20개인가보다. 20개가 불러와졌다.

요청 파라미터 page & size

GET - http://localhost:8080/members?page=0&size=3

결과

{
  "content": [
      {
          "createdDate": "2023-10-10T12:42:35.991973",
          "updatedDate": "2023-10-10T12:42:35.991973",
          "id": 1,
          "username": "user0",
          "age": 0,
          "team": null
      },
      {
          "createdDate": "2023-10-10T12:42:36.021407",
          "updatedDate": "2023-10-10T12:42:36.021407",
          "id": 2,
          "username": "user1",
          "age": 1,
          "team": null
      }
  ],
  "pageable": {
      "sort": {
          "empty": true,
          "unsorted": true,
          "sorted": false
      },
      "offset": 0,
      "pageNumber": 0,
      "pageSize": 2,
      "paged": true,
      "unpaged": false
  },
  "last": false,
  "totalElements": 100,
  "totalPages": 50,
  "number": 0,
  "first": true,
  "sort": {
      "empty": true,
      "unsorted": true,
      "sorted": false
  },
  "size": 2,
  "numberOfElements": 2,
  "empty": false
}

- page파라미터를 1로 바꾸면 2번째 페이지로 , 3과 4를 가져온다. 3으로 바꾸면 5와6을 가져올 것이다
```json
{
    "content": [
        {
            "createdDate": "2023-10-10T12:42:36.025348",
            "updatedDate": "2023-10-10T12:42:36.025348",
            "id": 3,
            "username": "user2",
            "age": 2,
            "team": null
        },
        {
            "createdDate": "2023-10-10T12:42:36.04167",
            "updatedDate": "2023-10-10T12:42:36.04167",
            "id": 4,
            "username": "user3",
            "age": 3,
            "team": null
        }
    ],
    "pageable": {
        "sort": {
            "empty": true,
            "unsorted": true,
            "sorted": false
        },
        "offset": 2,
        "pageNumber": 1,
        "pageSize": 2,
        "paged": true,
        "unpaged": false
    },
    "last": false,
    "totalElements": 100,
    "totalPages": 50,
    "number": 1,
    "first": false,
    "sort": {
        "empty": true,
        "unsorted": true,
        "sorted": false
    },
    "size": 2,
    "numberOfElements": 2,
    "empty": false
}

sort를 추가해보자 오름차순은 결과과 위와 똑같아서 내림차순으로 했다.

요청 파라미터 page & size & sort

GET - http://localhost:8080/members?page=0&size=2&sort=id,desc

참고로 Sort조건은 &를 사용해서 여러 개 넣어줄 수 있다. ex) http://localhost:8080/members?page=0&size=2&sort=id,desc&sort=username,desc

결과

{
  "content": [
      {
          "createdDate": "2023-10-10T12:42:36.15968",
          "updatedDate": "2023-10-10T12:42:36.15968",
          "id": 100,
          "username": "user99",
          "age": 99,
          "team": null
      },
      {
          "createdDate": "2023-10-10T12:42:36.158977",
          "updatedDate": "2023-10-10T12:42:36.158977",
          "id": 99,
          "username": "user98",
          "age": 98,
          "team": null
      }
  ],
  "pageable": {
      "sort": {
          "empty": false,
          "unsorted": false,
          "sorted": true
      },
      "offset": 0,
      "pageNumber": 0,
      "pageSize": 2,
      "paged": true,
      "unpaged": false
  },
  "last": false,
  "totalElements": 100,
  "totalPages": 50,
  "number": 0,
  "first": true,
  "sort": {
      "empty": false,
      "unsorted": false,
      "sorted": true
  },
  "size": 2,
  "numberOfElements": 2,
  "empty": false
}


### DTO 변환
API 요청 결고값으로 엔티티를 그대로 노출시키는 것보다 DTO로 변환해서 노출시켜야한다.
Page는 map()지원해서 쉽게 DTO로 변환할 수 있다.
```java
@GetMapping("/members") 
public Page list(Pageable pageable) { 
    Page page = memberRepository.findAll(pageable);
    Page pageDto = page.map(MemberDto::new);
    return pageDto;
}

인프런 - (실전! 스프링 데이터 JPA)[https://www.inflearn.com/course/%EC%8A%A4%ED%94%84%EB%A7%81-%EB%8D%B0%EC%9D%B4%ED%84%B0-JPA-%EC%8B%A4%EC%A0%84/dashboard]를 수강하면서 정리한 글입니다.

JPA 페이징

Sun, 08 Oct 2023 12:57:02 GMT

SW 직무 역량 부트캠프를 수강했을 때 진행한 팀 프로젝트에서 페이징 기능 구현에 실패했다. 그래서 페이징에 대한 내용을 진짜 공부하고싶었는데 공부한 부분을 정리하겠다.

JPA 페이징 코드

public List findByPage(int age, int offset, int limit){
    return em.createQuery("select m from Member m where m.age = : age order by m.username desc", Member.class)
        .setParameter("age", age)
        .setFirstResult(offset) // 어디서부터 가져올꺼야?
        .setMaxResults(limit) // 개수는 몇개 가져올꺼야?
        .getResultList();
  }

현재 몇 번째 페이지인지를 알기 위한 코드

// 현재 몇 번째 페이지인지
public long totalCount(int age){
  return em.createQuery("select count(m) from Member m where m.age = : age", Long.class)
      .setParameter("age", age)
      .getSingleResult();
}

테스트 코드

@Test
public void paging() {
  Member m1 = new Member("member1", 10);
  Member m2 = new Member("member2", 10);
  Member m3 = new Member("member3", 10);
  Member m4 = new Member("member4", 20);
  Member m5 = new Member("member5", 25);

  memberJpaRepository.save(m1);
  memberJpaRepository.save(m2);
  memberJpaRepository.save(m3);
  memberJpaRepository.save(m4);
  memberJpaRepository.save(m5);

  int age = 10;
  int offset = 0;
  int limit = 3;

  List result = memberJpaRepository.findByPage(age, offset, limit);
  long totalCount = memberJpaRepository.totalCount(age);

  Assertions.assertThat(result.size()).isEqualTo(3);
  Assertions.assertThat(totalCount).isEqualTo(3);
}

사실 좀 빠진 부분이 있는데 totalCount를 활용해서 현재 페이지 수를 구해야하고,, 마지막 페이지가 있는지, 첫번 째 페이지인지 아닌지 등 좀 고려해야할 부분들이 있는데 Spring Data JPA에서는 이러한 부분들을 알아서 계산해준다.

코드를 봐보자.

Spring Data JPA 페이징 코드

페이징을 인터페이스로 표준화 시킴.

[Page 예시 코드 - 나이를 기준으로 검색]

public interface MemberRepository extends JpaRepository {
    // pageable에는 쿼리 조건들을 넣으면 됨.
    Page findByAge(int age, Pageable pageable); 
  }

  @Test
  public void paging() {
    Member m1 = new Member("member1", 10);
    Member m2 = new Member("member2", 10);
    Member m3 = new Member("member3", 10);
    Member m4 = new Member("member4", 10);
    Member m5 = new Member("member5", 10);

    memberRepository.save(m1);
    memberRepository.save(m2);
    memberRepository.save(m3);
    memberRepository.save(m4);
    memberRepository.save(m5);

    // page0에서 3개 가져와, sorting 조건은 username을 기준으로 내림차순이야.
    PageRequest pageRequest = PageRequest.of(0, 3, Sort.by(Sort.Direction.DESC, "username"));

    // pageRequest은 Pagable 인터페이스의 구현체
    Page page = memberRepository.findByAge(10, pageRequest);

    // 반환타입이 page면 totalCount 쿼리까지 함꼐 날림!
    // 왜냐하면 페이지 계산하기 위해 필요하니까 알아서 날린거임!
    Page content = page.getContent();

    // totalCount 가져오는 메서드
    long totalElements = page.getTotalElements();

    for (Member member : content) {
      System.out.println("member = " + member);
    }
    System.out.println("totalElements = " + totalElements);

    Assertions.assertThat(content.size()).isEqualTo(3);
    Assertions.assertThat(page.getTotalElements()).isEqualTo(5);
    Assertions.assertThat(page.getNumber()).isEqualTo(0);
    Assertions.assertThat(page.getTotalPages()).isEqualTo(2);
    Assertions.assertThat(page.isFirst()).isTrue();
    Assertions.assertThat(page.hasNext()).isTrue();

  }

페이징 관련한 코드는 주석으로 설명을 달아놨다.
agable의 인터페이스의 구현체인 PageRequest를 사용한다.
PageRequest 생성자의 첫 번째 파라미터에는 현재 페이지, 두 번째 파라미터는 조회할 데이터 수, 세 번째 파라미터에는 추가로 정렬 조건을 작성할 수 있다.
그리고 반환타입으로 Page<...>, Slice<...>, List<...>가 있다.
- Page<...> : totalCount 쿼리 결과를 포함 + content 쿼리
- Slice<...> : totalCount 쿼리 결과 포함X + content 쿼리 + 다음 페이지만 확인 (limit + 1와서 확인함.)
- List<...> : totalCount 쿼리 없이 List 쿼리만 나감.
- 직접 날려보면서 DB로 나가는 쿼리를 눈으로 확인하는 것을 추천한다.
참고로 페이징 시작은 1부터가 아닌 0부터다.

인프런 - 실전! 스프링 데이터 JPA를 수강하면서 정리한 글입니다.

JPA 값 타입

Wed, 04 Oct 2023 07:20:01 GMT

JPA는 크게 2가지 데이터 타입으로 나눌 수 있다.

엔티티 타입
- @Entity로 정의한 객체
- 데이터가 변해도 PK같은 식별자로 추적이 가능하다.
값 타입
- int, Integer, String처럼 자바 기본 타입이나 객체
- 데이터가 변하면 식별자가 없어 추적이 불가능하다.

값 타입은 또 다음과 같이 분류할 수 있다.

기본값 타입
- 자바 기본 타입
- 래퍼 클래스
- String
임베디드 타입
- JPA에서 정의해서 사용해야함
컬렉션 값 타입
- JPA에서 정의해서 사용해야함

타입에 대해 보다 더 자세히 알아보자.

기본 값 타입

String, int 와 같은 타입들
생명주기를 엔티티의 의존한다.
- 예시로 Member 삭제 시 이름과 나이가 함께 삭제됨
값 타입은 공유하면 안된다.
- Member1의 이름 필드 변경 시 Member2의 이름 필드가 변경되면 안됨.

임베디드 타입

새로운 값 타입을 직접 정의
주로 기본 값 타입을 모아서 만들어서 복합 값 타입이라고도 한다.
예를 들어 Member의 집 주소를 저장할 때 Member 클래스에 도시,우편번호 등의 필드를 따로 생성할 수 있지만 그냥 Address타입을 가지게 하면 가독성이 훨 좋을 것이다.
@Embeddable : 값 타입을 정의하는 곳에
@Embedded : 값 타입을 사용하는 곳에
그리고 기본 생성자는 필수.

[임베디드 타입 예시]

@Embeddable // 임베디드 타입 정의
public class Address {

    private String city;
    private String street;
    private String zipcode;

    public Address() {}
    ...
}

@Entity
public class Member extends BaseEntity {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    @Column(name = "MEMBER_ID")
    private Long id;

    @Column(name="name", nullable = false)
    private String username;

    @ManyToOne(fetch = FetchType.LAZY)
    @JoinColumn
    private Team team;

    // 임베디드 타입 사용
    @Embedded 
    private Address address;
    ...
}

그런데 만약 Member가 Address타입을 2개 가지고 있다면?

이럴땐 컬럼명이 중복되기 때문에 @AttributeOverrrides를 사용해서 속성을 재정의해야한다.

@Entity
public class Member extends BaseEntity {
  ...

  // 임베디드 타입 사용
  @Embedded 
  private Address homeAddress;

  @Embedded 
  @AttributeOverrrides({
        @AttributeOverrride(name="city",
        column=@Column("work_city")
        @AttributeOverrride(name="street",
        column=@Column("work_street")
        @AttributeOverrride(name="zipcode",
        column=@Column("work_zipcode"))
  })
  private Address workAddress;
  ...
}

임베디드 타입을 사용하면 응집도도 높아지고 재사용성도 좋아지지만 입베디드 타입을 여러 엔티티에서 공유하면 위험하다.
그래서 임베디드 타입의 값을 복사해서 사용하는 것을 추천한다.
하지만 정의한 임베디드 타입은 객체여서 참조 값에 직접 값을 대입하는 것은 막을 수 없다는 한계가 있다.
그래서! 객체 타입을 수정할 수 없도록 생성자로만 값을 설정하고 setter로 수정할 수 없게 하면된다. 즉 setter를 생성하지 않으면 된다.
이렇게 하면 불변 객체가 괸다.
또는 setter의 접근 제어자를 private으로 변경.
주의해서 잘 사용하자...

컬렉션 값 타입
값 타입을 컬렉션에 넣어서 사용하는 타입
- ex) List
  addressHistory = ...
DB에서는 value만 넣을 수 있지 컬렉션을 담을 구조가 없다.
그래서 보통 별도의 컬렉션 테이블을 생성해야한다.
별도의 컬렉션 테이블은 식별자 PK를 따로 가지지않고 모든 컬럼을 묶어 PK로 구성한다. 당연히 null 입력 X, 중복 저장 X다.

[값 타입 컬렉션 예시]

@Entity
public class Member {
    ...

    @ElementCollection
    @CollectionTable(name="FAVORITE_FOOD", joinColumns =
    @JoinColumn(name="member_id"))
    @Column(name="food_name")
    private Set favoriteFoods = new HashSet<>();

    @ElementCollection
    @CollectionTable(name="ADDRESS", joinColumns =
    @JoinColumn(name="member_id"))
    private List addressHistory = new ArrayList<>();

    ...
}

[DB 테이블 생성 결과]

직접 작성해보고 생성결과를 봐야 더욱 와닿는 것 같다. 특히 값 타입 수정부분은 나가는 쿼리를 직접 보는 것을 추천한다.

값 타입은 식별자 개념이 없다고 위에서 언급했다. 그래서 값이 변경될 경우 추적이 어려워서 값 타입 컬렉션을 수정할 경우 주인 엔티티와 연관된 모든 데이터를 삭제하고 현재 값 타입 컬렉션에 있는 값들을 모두 다시 저장한다........

참고로 값 타입 컬렉션은 영속성 전이와 고가 객체 제거 기능을 필수로 가진다고 볼 수 있다. 그리고 지연 로딩 전략을 사용한다.

값 타입 컬렉션을 사용할 때 매우매우 생각을 많이 해보고 ,,, 꼭 사용해야하는지 고민하자. 일대다 관계로 풀어낼 수 있으면 일대다 관계로 풀어내자

자바 ORM 표준 JPA 프로그래밍-기본편을 학습하면서 정리한 블로그입니다.

JPA 프록시와 연관관계 관리

Wed, 04 Oct 2023 03:40:23 GMT

회원과 크루 예시를 그대로 가져가겠다.

@Entity
public class Member {
    @Id @GeneratedValue
    private Long id;

    private String name;

    @ManyToOne 
    @JoinColumn(name="crew_id")
    private Crew crew;
    ...
}

@Entity
public class Crew {
    @Id @GeneratedValue
    private Long id; //crewId

    private String name;    

    @OneToMany(mappedBy="crew") // Crew입장에서 Member는 1:N
    private List members = new ArrayList<>();
    ...
}

Member를 조회할 때 Crew도 함께 조회해야 할까?

Member member = em.find(Member.class, 1L);

printMember(member); // 1. Member만 조회
printMemberAndCrew(member); // 2. Member와 Crew를 함께 조회

만약 Member정보만 출력하고싶고 Crew는 출력하고싶지 않는 경우도 있을 것이다. 사용하지도 않는 정보인 Crew 정보까지 땡겨온다면 뭔가 깔끔하지 않다. 어떤 경우엔 Member와 Crew를 함께 가져오고싶고, 어떤 경우엔 Member만 가져오고싶을 땐 어떻게 해야할까?

JPA는 이러한 문제를 지연 로딩, 프록시 등을 통해 해결한다.

프록시

JPA는 em.find(...) 말고도 em.getReference()라는 메서드도 제공한다.
em.find(...)는 DB를 통해 실제 엔티티 객체를 조회한다.
em.getReference()는 DB 조회를 미루는 가짜(프록시) 엔티티 객체를 조회한다. 즉 DB에 쿼리가 나가지 않는데 객체 조회가 되는 것이다.
```
Member member = new Member();
member.setUsername("hello");
```

em.persist(member);

em.flush(); em.clear();

Member findMember = em.getReference(Member.class, member.getId());

tx.commit();

```text
실행 결과
    /* insert hellojpa.Member
        */ insert 
        into
            Member
            (MEMBER_ID, createBy, createdDate, lastModifiedBy, lastModifiedDate, city, street, zipcode, team_TEAM_ID, name) 
        values
            (null, ?, ?, ?, ?, ?, ?, ?, ?, ?)
10월 04, 2023 1:32:44 오전 org.hibernate.engine.jdbc.connections.internal.DriverManagerConnectionProviderImpl stop
INFO: HHH10001008: Cleaning up connection pool [jdbc:h2:tcp://localhost/~/hellojpa;MODE=MYSQL]

Process finished with exit code 0

실행 결과에서 볼 수 있듯이 select쿼리가 나가지 않았다.

하지만 다음과 같이 getReference()를 통해 가져온 값을 직접 사용(getUsername())하면 쿼리문이 나간다.

...
Member findMember = em.getReference(Member.class, member.getId());
System.out.println("findMember.getClass() = " + findMember.getClass());
System.out.println("findMember.getUsername() = " + findMember.getUsername());

tx.commit();

```text
findMember.getClass() = class hellojpa.Member$HibernateProxy$2gyJwktl
Hibernate: 
    select
        member0_.MEMBER_ID as MEMBER_I1_4_0_,
        member0_.createBy as createBy2_4_0_,
        member0_.createdDate as createdD3_4_0_,
        member0_.lastModifiedBy as lastModi4_4_0_,
        member0_.lastModifiedDate as lastModi5_4_0_,
        member0_.city as city6_4_0_,
        member0_.street as street7_4_0_,
        member0_.zipcode as zipcode8_4_0_,
        member0_.team_TEAM_ID as team_TE10_4_0_,
        member0_.name as name9_4_0_ 
    from
        Member member0_ 
    where
        member0_.MEMBER_ID=?
findMember.getUsername() = hello

select쿼리문이 나갔다.
findMember().getClass()를 통해 가져온 값을 보면 ~Proxy라는 단어가 있는 것을 볼 수 있다. 즉 하이버네이트가 만든 가짜 객체이다.
프록시 특징
실제 클래스를 상속받아서 만들어졌다. 그래서 타입 비교시 instance of 사용
그래서 실제 클래스와 겉 모양은 같다.
프록시 객체는 실제 객체의 참조를 보관하고있어 프록시 객체를 호출(ex. findMember.getUsername())하면 프록시 객체는 실제 객체의 메서드를 호출한다.
프록시 객체는 처음 사용할 때 한 번만 초기화한다.
초기화할 때, 프록시 객체가 실제 엔티티로 바뀌는것이 아니라 프록시 객체를 통해 실제 엔티티에 접근이 가능해지는 것
만약 getReference()로 조회할 객체가 영속성 컨텍스트에 존재한다면 실제 엔티티를 반환한다.
- == 비교 시 true값을 반환해야하기 때문에
영속성 컨텍스트의 도움을 받을 수 없는 준영속 상태일 때, 프록시를 초기화할 떄 문제가 발생한다.

프록시 확인 메서드

프록시 인스턴스 초기화 여부
entitiyManagerfactory.getPersistenceUnitUtil.isLoaded(Object entity) 

프록시 클래스 확인 방법
entity.getClass().getName() 

프록시 강제 초기화
org.hibernate.Hibernate.initialize(entity)

약간 헷갈린다면 직접 em.find(...), em.getReference(...)해서 값을 가져온 다음 타입 비교를 해보자.

프록시에 대해 알아보았고 프록시에 대한 이해가 있어야 즉시 로딩, 지연 로딩을 깊이 이해할 수 있다. 맨 위에서 언급한 Member를 조회할 때 Crew도 함꼐 조회해야하는지에 대한 질문의 답을 이제 알아보자.

지연 로딩

Member의 정보만 필요한 경우 Crew를 함께 땡겨올 필요가 없으니 JPA는 지연로딩이라는 옵션을 제공한다.

@ManyToOne(fetch = FetchType.LAZY)

@Entity
public class Member extends BaseEntity {

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

@ManyToOne(fetch = FetchType.LAZY)
@JoinColumn(name="crew_id")
private Crew crew;
}

FetchType.LAZY로 조회하는 경우 Member클래스만 DB에서 조회하고 Crew는 프록시 객체로 조회한다.
그래서 프록시 객체로 가져온 crew의 값을 직접 사용하는 순간 DB에 쿼리가 나간다.
즉 지연 로딩으로 설정하면 연관된 정보들은 프록시 객체로 가져온다.

즉시 로딩

지연 로딩과 다르게 연관된 것들도 프록시 객체가 아닌 Join해서 DB에서 실제로 조회하도록 하고싶으면 즉시 로딩을 사용하면 된다.

@Entity
public class Member extends BaseEntity {

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

@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name="crew_id")
private Crew crew;
}

즉시로딩보단 지연로딩을 사용하도록 하자.
즉시로딩은 예상치 못한 SQL이 발생하고 N+1문제를 일으키기때문이다.
- N+1문제에 대해서는 따로 정리할 생각
@ManyToOne, @OneToOne은 기본값이 즉시 로딩이어서 값을 변경해줘야함
@OneToMany, @ManyToMany는 기본값이 지연 로딩이다.

직접 즉시 로딩, 지연 로딩을 해보면서 나가는 쿼리문을 눈으로 보는 것을 추천한다.

영속성 전이 cascade

영속성 전이란 특정 엔티티를 영속 상태로 만들 때 연관된 엔티티도 함께 영속 상태로 만들고 싶을 때 사용

cascade = CasecadeType.ALL
CasecadeType.ALL은 연관된 엔티티까지 모두 영속 상태로 만들어준다.
즉 em.persist(parent)할 경우 child까지 다 persist된다.

하지만 연관관계 매핑과는 관련이 없고 단순히 연관된 엔티티도 함께 영속화하는 편리함을 제공

@Entity
public class Parent {

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

private String name;

@OneToMany
(mappedBy = "parent",
cascade = CascadeType.ALL)
private List childList = new ArrayList<>();
...
}

@Entity
public class Child{

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

private String name;

@ManyToOne
@JoinColumn(name = "PARENT_ID")
private Parent parent;
...
}

아래 코드처럼 em.persist(ch1);을 따로 안해주더라도 영속성 전이 옵션을 통해 ch1,ch2도 영속 상태로 만들 수 있다.
```
Child ch1 = new Child();
Child ch2 = new Child();
```

Parent parent = new Parent(); parent.addChild(ch1); // 연관관계 편의 메서드 parent.addChild(ch2); // 연관관계 편의 메서드

em.persist(parent);

tx.commit();

- CasecadeType.ALL뿐만 아니라 PERSIST, REMOVE 등이 있는데 이와 관련한 부분은 우선 넘어가겠다. 필요할 때 찾아쓰도록.

## 고아 객체
- 부모 엔티티와 연관관계가 끊어진 자식 엔티티를 고아 객체라고 하는데 이러한 객체를 자동으로 삭제하고 싶을 땐 다음과 같은 설정을 하면된다.
- 주의할 점은 참조하는 곳이 하나일 때 , 특정 엔티티가 개인 소유할 때, @OneToOne, @OneToMany만 가능하다.
```java
@Entity
public class Parent {

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

  private String name;

  @OneToMany
  (mappedBy = "parent",
  cascade = CascadeType.ALL,
  orphanRemoval = true) //이 부분
  private List childList = new ArrayList<>();
  ...
}

@Entity
public class Child{

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

  private String name;

  @ManyToOne
  @JoinColumn(name = "PARENT_ID")
  private Parent parent;
  ...
}

자바 ORM 표준 JPA 프로그래밍-기본편을 학습하면서 정리한 블로그입니다.

zwon.log

[코드트리] 청약 통장 1회차 미션 - 코딩테스트 준비, 갭체크부터 시작하기

LeetCode - 45. Jump Game II

문제

풀이

메모

LeetCode - 150. Evaluate Reverse Polish Notation

문제

풀이

메모

LeetConde - 61. Rotate List

문제

풀이

메모

[개발일지] 취미 커뮤니티 - 사용자 프로필 설정 및 변경

User

Profile

ImgController

FileStore

FileService

화면

깨달음..

[개발일지] 취미 커뮤니티 마이페이지 구현 (1)

User

Crew

UserService

UserController

테스트 화면

관리 중인 크루 (크루장인 경우)

관심 있는 크루

참여하고 있는 크루

[개발일지] 취미 커뮤니티 서비스 - 크루 참가 및 탈퇴 + 크루 세팅

Crew

Dto

CrewSaveRequestDto

CrewRepository

CrewService

Thymeleaf

크루 소개 화면

👥크루원

크루 설정

크루 가입

[개발일지] 취미 커뮤니티 - 크루 CRUD

Crew

DTO

CrewSaveRequestDto

CrewUpdateRequestDto

CrewService

CrewViewController

크루 상세 화면

👍저희 크루는 이런 크루입니다.

🧐저희 크루는 이러한 사람을 원해요.

📆저희 크루의 활동 계획입니다.

👥크루원

fragment.html

Top 10 크루

현재 모집 중인 크루즈

화면

main 화면

크루 form 화면

크루 상세 화면

크루 수정 및 삭제

[개발일지] 취미 커뮤니티 - 크루 가입 및 탈퇴 기능 중 객체의 동등성 비교

Crew

CrewViewController

CrewService

User

[개발일지] 첨부파일 기능 추가

application.yaml

Board

ImgFile

FileStore

FileService

BoardSaveRequestDto

BoardController

BoardService

BoardService

실행 화면

스토리지

데이터베이스