패스트캠퍼스X야놀자: 백엔드 개발 부트 캠프 - 🎠Spring 기반 토이 프로젝트 3

🎠프로젝트 개요

 

1️⃣프로젝트내용

여행, 여정을 기록하는 SNS 서비스 3단계

2️⃣프로젝트 주제 및 필수 구현 기능 제안

야놀자

3️⃣프로젝트 목적

Spring Boot, DB 설계, DB 트랜잭션, RESTful API  설계 능력 향상,  Spring Security, JWT, JUnit, OpenApi 활용

4️⃣프로젝트 기간

 2023년 11월 10일 (월) ~ 11월 16일(목)

5️⃣Team Repository

https://github.com/FC-BE-ToyProject-Team8/TravelApp

GitHub - FC-BE-ToyProject-Team8/TravelApp: 여행 기록 서비스 SpringBoot REST API 서버

6️⃣기술스택

언어

Java17

개발환경 및 Dependency

Spring Boot 3.1.5

Gradle 8.3

MySQL 8

Spring Web

Spring Data JPA

JUint5

lombok

MapStruct

JWT

Redis

CI

GitHub Actions

API 명세

Swagger

 

---

⚖️프로젝트 컨벤션

 

1️⃣코딩 컨벤션

블록의 들여쓰기만 4공백으로 커스텀하여 구글 자바 코딩 컨벤션을 사용

Git Hub Actions CI를 통해 체크 스타일이 맞지 않는다면 Merge 못하도록 블락킹

 

2️⃣테스트 코드 컨벤션

Repository : @Query 어노테이션 등을 사용한 메서드에 대해 테스트 코드 작성 필수

Service : 단순 Repository 메서드 호출 이상의 로직을 수행하는 메서드에 대해 테스트 코드 작성 필수

Controller : 모든 public 메서드 테스트 코드 작성 필수

 

3️⃣상태코드 컨벤션

• 200 : 모든 성공
• 400 : 클라이언트가 입력을 잘못한 경우
• 401 : 인증 정보가 없는 경우
• 403 : 접근 권한이 없는 경우
• 500 : 서버 내부 에러

 

4️⃣커밋 메세지 컨벤션

커밋 제목은 prefix: 커밋 메시지 형태로 작성

 

prefix 는 각각 상황에 맞는 prefix를 사용
(feat, fix, docs, test, refactor...)

모든 커밋 메세지는 한국어로 작성

 

5️⃣프로젝트 깃 브랜치 전략

GitFlow 전략 ( 프로젝트 규모 특징상 release, hotfix 브랜치는 생략)

 

feature/#

• 실제 작업을 하는 브랜치
• 이슈 번호가 1이라면 feature/1로 만들면 된다.
• 'develop'을 베이스 브랜치로 하여 만들어야 한다.
  • ( 브랜치 생성은 베이스 브랜치[ 체크아웃되어있는 브랜치 ]를 기준으로 만들어진다.)
• 작업이 완료되면 develop으로 Pull Request를 날린다.
• 4명의 Approve를 받았다면 Merge한다.

develop

• 다음 버전 개발을 위해 main으로 가기 전 기능 코드들을 모아두는 브랜치
• 작성한 기능이 잘 작동되는지 확인하고, main으로 PR 및 Merge를 하면 된다.
• main으로 Pull Request를 날릴때는 Approve 받는 것은 선택사항이다.

main

• 실제 서비스를 운영할 수 있는 브랜치
• main에 배포가 되고 나서도 기능이 잘 작동하는지 확인해야 한다.

6️⃣기타 협의 사항

협업 관련

• 데일리 스크럼: 매일 오전 10:00 Slack에 진행상황 공유

 

 

📑기획 및 담당 파트

ERD

 

 

 

API 명세

 

 

🙋‍♂️담당 파트

좋아요 등록,  좋아요 취소 ,  사용자 닉네임으로 여행 검색

 

 

LikeService.java

import kr.co.fastcampus.travel.common.exception.DuplicatedLikeException;
import kr.co.fastcampus.travel.common.exception.InvalidLikeCancelException;
import kr.co.fastcampus.travel.domain.like.entity.Like;
import kr.co.fastcampus.travel.domain.like.repository.LikeRepository;
import kr.co.fastcampus.travel.domain.member.entity.Member;
import kr.co.fastcampus.travel.domain.member.service.MemberService;
import kr.co.fastcampus.travel.domain.trip.entity.Trip;
import kr.co.fastcampus.travel.domain.trip.service.TripService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
@Service
@RequiredArgsConstructor
@Slf4j
@Transactional(readOnly = true)
public class LikeService {
 
    private final TripService tripService;
    private final LikeRepository likeRepository;
    private final MemberService memberService;
 
    @Transactional
    public void saveLike(Long tripId, String memberEmail) {
        Trip trip = findTrip(tripId);
        Member member = findMember(memberEmail);
        if (isExisted(trip, member)) {
            throw new DuplicatedLikeException();
        }
        likeRepository.save(createLike(trip, member));
    }
 
    @Transactional
    public void deleteLike(Long tripId, String memberEmail) {
        Trip trip = findTrip(tripId);
        Member member = findMember(memberEmail);
        if (isExisted(trip, member)) {
            likeRepository.deleteByTripAndMember(trip, member);
        } else {
            throw new InvalidLikeCancelException();
        }
    }
 
    private Trip findTrip(Long tripId) {
        return tripService.findById(tripId);
    }
 
    private Like createLike(Trip trip, Member member) {
        return Like.builder()
            .trip(trip)
            .member(member)
            .build();
    }
 
    private Member findMember(String memberEmail) {
        return memberService.findMemberByEmail(memberEmail);
    }
 
    private boolean isExisted(Trip trip, Member member) {
        return likeRepository.existsByTripAndMember(trip, member);
    }
}
 

 

 

 

TripService.java

package kr.co.fastcampus.travel.domain.trip.service;
 
import java.util.List;
import java.util.stream.Collectors;
import kr.co.fastcampus.travel.common.exception.EntityNotFoundException;
import kr.co.fastcampus.travel.common.exception.MemberMismatchException;
import kr.co.fastcampus.travel.domain.member.entity.Member;
import kr.co.fastcampus.travel.domain.member.service.MemberService;
import kr.co.fastcampus.travel.domain.trip.entity.Trip;
import kr.co.fastcampus.travel.domain.trip.repository.TripRepository;
import kr.co.fastcampus.travel.domain.trip.service.dto.request.TripSaveDto;
import kr.co.fastcampus.travel.domain.trip.service.dto.request.TripUpdateDto;
import kr.co.fastcampus.travel.domain.trip.service.dto.response.TripDetailDto;
import kr.co.fastcampus.travel.domain.trip.service.dto.response.TripInfoDto;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
@Slf4j
@Service
@RequiredArgsConstructor
@Transactional(readOnly = true)
public class TripService {
 
    private final TripRepository tripRepository;
    private final MemberService memberService;
 
    public List<TripInfoDto> findAllTrips() {
        List<Trip> trips = tripRepository.findAll();
        return trips.stream()
            .map(TripInfoDto::from)
            .collect(Collectors.toList());
    }
 
    @Transactional
    public TripInfoDto addTrip(TripSaveDto dto, String memberEmail) {
        Member member = findMember(memberEmail);
        var trip = tripRepository.save(dto.toEntity(member));
        return TripInfoDto.from(trip);
    }
 
    private Member findMember(String memberEmail) {
        return memberService.findMemberByEmail(memberEmail);
    }
 
    public TripDetailDto findTripDetailById(Long id) {
        var trip = tripRepository.findFetchDetailById(id)
            .orElseThrow(EntityNotFoundException::new);
        return TripDetailDto.from(trip);
    }
 
    @Transactional
    public TripInfoDto editTrip(Long tripId, TripUpdateDto dto, String memberEmail) {
        var trip = findById(tripId);
 
        boolean isWriter = memberEmail.equals(trip.getMember().getEmail());
        if (!isWriter) {
            throw new MemberMismatchException();
        }
 
        Trip updateTrip = dto.toEntity();
        trip.update(updateTrip);
        return TripInfoDto.from(trip);
    }
 
    @Transactional
    public void deleteTrip(Long id) {
        var trip = findById(id);
        tripRepository.delete(trip);
    }
 
    public Page<TripInfoDto> findTripsByNickname(String nickname, Pageable pageable) {
        Member member = findMemberByNickname(nickname);
        Page<Trip> trips = tripRepository.findTripByMember(member, pageable);
        return trips.map(TripInfoDto::from);
    }
 
    private Member findMemberByNickname(String nickname) {
        return memberService.findByNickname(nickname);
    }
 
    public Page<TripInfoDto> searchByTripName(String tripName, Pageable pageable) {
        Page<Trip> trips = tripRepository.findAllByNameContainingIgnoreCase(tripName, pageable);
        return trips.map(TripInfoDto::from);
    }
 
    public List<TripInfoDto> findTripsByLike(String email, Pageable pageable) {
        var member = memberService.findMemberByEmail(email);
        var trips = tripRepository.findByLike(member, pageable);
        return trips.stream()
                .map(TripInfoDto::from)
                .collect(Collectors.toList());
    }
 
    public Trip findById(Long id) {
        return tripRepository.findById(id)
            .orElseThrow(EntityNotFoundException::new);
    }
}
 

 

 

실행 결과  

좋아요 등록

좋아요 취소

 

사용자 닉네임으로 여행 검색

 

 

🤔개인 회고

먼저 3Layered architecture 에 익숙해져 빠른 시간내에 개발을 한 내 자신이 뿌듯했다. 어떤 케이스에 어떤 예외처리를 해야할지도 바로바로 떠오르고, 로직을 어떻게 구상해야하는지도 스스로에게 확실한 믿음이 생겼다. 이번 팀 토이 프로젝트도 개발은 빠른 시일내에 끝냈다. 

다만 아쉬운 점이 조금 있었다. 좋아요 레퍼런스를 인스타그램의 하트로 생각했다. 따라서 호날두나 BTS 멤버, 유명 인플루언서 등과 같이 인기 많은 사람의 피드의 좋아요는 매우 빠르게 올라가기에 좋아요 수에 대한 동시성 제어를 해보려 했지만 실패했다.

트랜잭션 격리수준 설정( @Transactional(isolation = Isolation.READ_COMMITTED) )과 낙관적인 락( @Lock(LockModeType.OPTIMISTIC) )을 사용했지만 실패했다. 테스트 코드에서 스레드 수를 10000으로 주고 돌렸을 때 성공해서 해결한 줄 알았지만, 몇 번 더 실행하면 실패 케이스가 생겼다.

@Test
    @DisplayName("좋아요 등록")
    void saveLike() throws InterruptedException {
        int threadCount = 10000;
        ExecutorService executorService = Executors.newFixedThreadPool(32);
        CountDownLatch latch = new CountDownLatch(threadCount);

        //given
        Long tripId = 1L;
        Trip trip = createTrip();
        given(tripService.findById(tripId)).willReturn(trip);

        //when
        for (int i = 0; i < threadCount; i++) {
            executorService.submit(() -> {
                try {
                    Member member = createMember();
                    likeService.saveLike(tripId, member.getEmail());
                } finally {
                    latch.countDown();
                }
            });
        }
        latch.await();

        //then
        assertThat(trip.getLikeCount()).isEqualTo(threadCount);
    }

 

엔티티에 버전 (@Version)도 다 넣고 해봤지만 끝끝내 해결하지 못하여 너무 아쉬웠다.

다음 미니 프로젝트때 숙박 예약파트에 또 동시성 제어할 만한 요소가 생기는데, 내가 나서서 해보겠다고 할 예정이다. 이땐 확실하게 됐으면 좋겠다.

 

@PageableDefault(size = 5) Pageable pageable 를 사용하며 Pageable 에 대해서 처음 알게 돼서 좋았다. 기존엔 페이징네이션만 알고 있었는데, 이런 강력한 기능이 있는지 몰랐다. Pageable 덕분에 알아서 DB에서 페이징네이션 된 채 나오는 게 정말 좋았다.

 

벌써 1단계, 2단계, 3단계 해오면서 스스로 많이 성장했다는 게 느껴졌다. 특히 테스트 코드 작성에서 실력이 많이 늘었음을 느꼈다. 또한 클린코드 방법론을 최대한 살리기 위해 메소드로 따로 빼고, 변수 명, 클래스 명, 메소드 명 하나하나 신경쓰면서 하니, 실무에서도 잘 할 수 있을 거란 생각이 들었다.(어째서 1단계 자바 콘솔 프로젝트가 제일 어려웠던 거 같지 ㅋㅋㅋㅋㅋ)

좋은 팀원들과 함께하여 실력이 일취월장 했다고 생각한다. 함께 했던 4명의 팀원들에게 감사함을 전한다.