[REFACTOR] Service 계층에서 Adapter 계층을 의존하도록 리팩토링

smeem-api/src/main/java/com/smeem/api/auth/service/AuthService.java

@@ -6,11 +6,12 @@
 import com.smeem.api.diary.service.DiaryCommandService;
 import com.smeem.api.member.service.MemberBadgeService;
 import com.smeem.api.member.service.TrainingTimeService;
-import com.smeem.domain.member.exception.MemberException;
+import com.smeem.domain.member.adapter.member.MemberDeleter;
+import com.smeem.domain.member.adapter.member.MemberFinder;
+import com.smeem.domain.member.adapter.member.MemberSaver;
 import com.smeem.external.oauth.exception.TokenException;
 import com.smeem.domain.member.model.Member;
 import com.smeem.domain.member.model.SocialType;
-import com.smeem.domain.member.repository.MemberRepository;
 import com.smeem.external.oauth.apple.AppleService;
 import com.smeem.external.oauth.kakao.KakaoService;
 import lombok.RequiredArgsConstructor;
@@ -22,16 +23,16 @@
 import java.security.spec.InvalidKeySpecException;
 
 import static com.smeem.common.code.failure.AuthFailureCode.INVALID_TOKEN;
-import static com.smeem.common.code.failure.MemberFailureCode.INVALID_MEMBER;
 import static java.util.Objects.nonNull;
 
 @Service
 @RequiredArgsConstructor
 @Transactional(readOnly = true)
 public class AuthService {
 
-    private final MemberRepository memberRepository;
-
+    private final MemberFinder memberFinder;
+    private final MemberSaver memberSaver;
+    private final MemberDeleter memberDeleter;
     private final TokenService tokenService;
     private final AppleService appleService;
     private final KakaoService kakaoService;
@@ -46,7 +47,7 @@ public SignInServiceResponse signIn(final String socialAccessToken, final SignIn
         val existMember = isMemberBySocialAndSocialId(socialType, socialId);
         if (!existMember) {
             val initialMember = Member.createInitialMember(socialType, socialId, request.fcmToken());
-            memberRepository.save(initialMember);
+            memberSaver.save(initialMember);
         }
         val signedMember = getMemberBySocialAndSocialId(socialType, socialId);
         val isRegistered = nonNull(signedMember.getUsername());
@@ -58,37 +59,31 @@ public SignInServiceResponse signIn(final String socialAccessToken, final SignIn
 
     @Transactional
     public void signOut(final long memberId) {
-        val member = get(memberId);
+        val member = memberFinder.findById(memberId);
         member.updateRefreshToken(null);
     }
 
     @Transactional
     public void withdraw(final long memberId) {
-        val member = get(memberId);
+        val member = memberFinder.findById(memberId);
         diaryService.deleteAllByMember(member);
         trainingTimeService.deleteAllByMember(member);
         memberBadgeService.deleteAllByMember(member);
-        memberRepository.deleteById(memberId);
-    }
-
-    private Member get(final long memberId) {
-        return memberRepository.findById(memberId)
-                .orElseThrow(() -> new MemberException(INVALID_MEMBER));
+        memberDeleter.deleteById(memberId);
     }
 
     private Member getMemberBySocialAndSocialId(final SocialType socialType, final String socialId) {
-        return memberRepository.findBySocialAndSocialId(socialType, socialId)
-                .orElseThrow(() -> new MemberException(INVALID_MEMBER));
+        return memberFinder.findBySocialAndSocialId(socialType, socialId);
     }
 
     private boolean isMemberBySocialAndSocialId(SocialType socialType, String socialId) {
-        return memberRepository.existsBySocialAndSocialId(socialType, socialId);
+        return memberFinder.existsBySocialAndSocialId(socialType, socialId);
     }
 
     private String socialLogin(SocialType socialType, final String socialAccessToken) {
-        return switch (socialType.toString()) {
-            case "APPLE" -> appleService.getAppleData(socialAccessToken);
-            case "KAKAO" -> kakaoService.getKakaoData(socialAccessToken);
+        return switch (socialType) {
+            case APPLE -> appleService.getAppleData(socialAccessToken);
+            case KAKAO -> kakaoService.getKakaoData(socialAccessToken);
             default -> throw new TokenException(INVALID_TOKEN);
         };
     }

smeem-api/src/main/java/com/smeem/api/auth/service/TokenService.java

@@ -6,6 +6,7 @@
 import com.smeem.api.auth.jwt.SmeemToken;
 import com.smeem.api.auth.service.dto.response.TokenServiceResponse;
 import com.smeem.api.member.service.MemberService;
+import com.smeem.domain.member.adapter.member.MemberFinder;
 import lombok.RequiredArgsConstructor;
 import lombok.val;
 import org.springframework.security.core.Authentication;
@@ -20,13 +21,13 @@ public class TokenService {
     private static final Long ACCESS_TOKEN_EXPIRATION_TIME = 60 * 60 * 1000 * 2 * 12 * 1000000L; // 2시간
     private static final Long REFRESH_TOKEN_EXPIRATION_TIME = 60 * 60 * 1000 * 24 * 14L; // 2주
 
-    private final MemberService memberService;
+    private final MemberFinder memberFinder;
     private final TokenProvider tokenProvider;
 
     @Transactional
     public TokenServiceResponse issueToken(final long memberId) {
         val token = generateSmeemToken(UserAuthentication.create(memberId));
-        val member = memberService.get(memberId);
+        val member = memberFinder.findById(memberId);
         member.updateRefreshToken(token.getRefreshToken());
         return TokenServiceResponse.of(token);
     }

smeem-api/src/main/java/com/smeem/api/badge/service/BadgeService.java

@@ -1,13 +1,13 @@
 package com.smeem.api.badge.service;
 
 import com.smeem.api.badge.service.dto.response.BadgeListServiceResponse;
-import com.smeem.domain.badge.exception.BadgeException;
+import com.smeem.domain.badge.adapter.BadgeFinder;
 import com.smeem.domain.badge.model.Badge;
 import com.smeem.domain.badge.model.BadgeType;
-import com.smeem.domain.badge.repository.BadgeRepository;
+import com.smeem.domain.member.adapter.memberbadge.MemberBadgeFinder;
+import com.smeem.domain.member.adapter.memberbadge.MemberBadgeSaver;
 import com.smeem.domain.member.model.Member;
 import com.smeem.domain.member.model.MemberBadge;
-import com.smeem.domain.member.repository.MemberBadgeRepository;
 import lombok.RequiredArgsConstructor;
 import lombok.val;
 import org.springframework.stereotype.Service;
@@ -18,51 +18,46 @@
 import java.util.List;
 import java.util.Map;
 
-import static com.smeem.common.code.failure.BadgeFailureCode.INVALID_BADGE;
-
 @Service
 @RequiredArgsConstructor
 @Transactional(readOnly = true)
 public class BadgeService {
 
-    private final MemberBadgeRepository memberBadgeRepository;
-    private final BadgeRepository badgeRepository;
+    private final BadgeFinder badgeFinder;
+    private final MemberBadgeSaver memberBadgeSaver;
+    private final MemberBadgeFinder memberBadgeFinder;
 
     @Transactional
     public void saveMemberBadge(final Member member, final Badge badge) {
-        memberBadgeRepository.save(MemberBadge.builder()
+        val memberBadge = MemberBadge.builder()
                 .member(member)
                 .badge(badge)
-                .build());
+                .build();
+        memberBadgeSaver.save(memberBadge);
     }
     public BadgeListServiceResponse getBadges(final long memberId) {
-        val badges = badgeRepository.findAllOrderById();
+        val badges = badgeFinder.findAllOrderById();
         val badgeMap = classifiedByType(badges);
-        val memberBadges = memberBadgeRepository.findAllByMemberId(memberId);
+        val memberBadges = memberBadgeFinder.findAllByMemberId(memberId);
         return BadgeListServiceResponse.of(badgeMap, memberBadges);
     }
 
-    public Badge get(final long id) {
-        return badgeRepository.findById(id)
-                .orElseThrow(() -> new BadgeException(INVALID_BADGE));
-    }
-
     public Badge getBadgeByCountOfDiary(final int diaryCount) {
         return switch (diaryCount) {
-            case 50 -> get(5L);
-            case 30 -> get(4L);
-            case 10 -> get(3L);
-            case 1 -> get(2L);
+            case 50 -> badgeFinder.findById(5L);
+            case 30 -> badgeFinder.findById(4L);
+            case 10 -> badgeFinder.findById(3L);
+            case 1 -> badgeFinder.findById(2L);
             default -> null;
         };
     }
 
     public Badge getBadgeByComboCountOfDiary(final int diaryComboCount) {
         return switch (diaryComboCount) {
-            case 30 -> get(9L);
-            case 15 -> get(8L);
-            case 7 -> get(7L);
-            case 3 -> get(6L);
+            case 30 -> badgeFinder.findById(9L);
+            case 15 -> badgeFinder.findById(8L);
+            case 7 -> badgeFinder.findById(7L);
+            case 3 -> badgeFinder.findById(6L);
             default -> null;
         };
     }

smeem-api/src/main/java/com/smeem/api/member/service/MemberBadgeService.java

@@ -1,28 +1,29 @@
 package com.smeem.api.member.service;
 
 
-import com.smeem.domain.badge.exception.BadgeException;
 import com.smeem.domain.badge.model.Badge;
+import com.smeem.domain.member.adapter.memberbadge.MemberBadgeDeleter;
+import com.smeem.domain.member.adapter.memberbadge.MemberBadgeFinder;
+import com.smeem.domain.member.adapter.memberbadge.MemberBadgeSaver;
 import com.smeem.domain.member.model.Member;
 import com.smeem.domain.member.model.MemberBadge;
-import com.smeem.domain.member.repository.MemberBadgeRepository;
 import lombok.RequiredArgsConstructor;
 import lombok.val;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import static com.smeem.common.code.failure.BadgeFailureCode.EMPTY_BADGE;
-
 @Service
 @RequiredArgsConstructor
 @Transactional(readOnly = true)
 public class MemberBadgeService {
 
-    private final MemberBadgeRepository memberBadgeRepository;
+    private final MemberBadgeFinder memberBadgeFinder;
+    private final MemberBadgeSaver memberBadgeSaver;
+    private final MemberBadgeDeleter memberBadgeDeleter;
 
     @Transactional
     public void deleteAllByMember(final Member member) {
-        memberBadgeRepository.deleteAllInBatch(member.getBadges());
+        memberBadgeDeleter.deleteAllInBatch(member.getBadges());
     }
 
     @Transactional
@@ -31,11 +32,10 @@ public void save(Member member, Badge badge) {
                 .member(member)
                 .badge(badge)
                 .build();
-        memberBadgeRepository.save(memberBadge);
+        memberBadgeSaver.save(memberBadge);
     }
 
     public Badge getBadgeByMemberId(final long memberId) {
-        return memberBadgeRepository.findFirstByMemberIdOrderByCreatedAtDesc(memberId).orElseThrow(
-                () -> new BadgeException(EMPTY_BADGE)).getBadge();
+        return memberBadgeFinder.findFirstByMemberIdOrderByCreatedAtDesc(memberId).getBadge();
     }
 }

smeem-api/src/main/java/com/smeem/api/member/service/MemberService.java

@@ -1,7 +1,6 @@
 package com.smeem.api.member.service;
 
 
-import com.smeem.api.badge.service.BadgeService;
 import com.smeem.api.badge.service.dto.response.BadgeServiceResponse;
 import com.smeem.api.goal.service.GoalService;
 import com.smeem.api.goal.service.dto.request.GoalGetServiceRequest;
@@ -14,11 +13,13 @@
 import com.smeem.api.member.service.dto.response.MemberUpdateServiceResponse;
 import com.smeem.api.member.service.dto.response.TrainingTimeServiceResponse;
 import com.smeem.common.config.ValueConfig;
+import com.smeem.domain.badge.adapter.BadgeFinder;
 import com.smeem.domain.member.exception.MemberException;
 import com.smeem.domain.training.exception.TrainingTimeException;
 import com.smeem.domain.badge.model.Badge;
+import com.smeem.domain.member.adapter.member.MemberFinder;
+import com.smeem.domain.member.adapter.member.MemberUpdater;
 import com.smeem.domain.member.model.Member;
-import com.smeem.domain.member.repository.MemberRepository;
 import com.smeem.domain.training.model.DayType;
 import com.smeem.domain.training.model.TrainingTime;
 import com.smeem.external.discord.DiscordAlarmSender;
@@ -33,7 +34,6 @@
 import java.util.stream.Collectors;
 
 import static com.smeem.common.code.failure.MemberFailureCode.DUPLICATE_USERNAME;
-import static com.smeem.common.code.failure.MemberFailureCode.EMPTY_MEMBER;
 import static com.smeem.common.code.failure.TrainingTimeFailureCode.NOT_SET_TRAINING_TIME;
 import static com.smeem.common.config.ValueConfig.SIGN_IN_MESSAGE;
 import static com.smeem.external.discord.DiscordAlarmCase.INFO;
@@ -45,20 +45,21 @@
 @RequiredArgsConstructor
 public class MemberService {
 
-    private final MemberRepository memberRepository;
-
     private final TrainingTimeService trainingTimeService;
     private final GoalService goalService;
-    private final BadgeService badgeService;
     private final MemberBadgeService memberBadgeService;
     private final DiscordAlarmSender discordAlarmSender;
 
+    private final BadgeFinder badgeFinder;
+    private final MemberFinder memberFinder;
+    private final MemberUpdater memberUpdater;
+
     private final ValueConfig valueConfig;
 
     @Transactional
     public MemberUpdateServiceResponse updateUserProfile(final MemberServiceUpdateUserProfileRequest request) {
         checkMemberDuplicate(request.username());
-        val member = get(request.memberId());
+        val member = memberFinder.findById(request.memberId());
         updateTermAccepted(member, request);
 
         ArrayList<Badge> badges = new ArrayList<>();
@@ -71,7 +72,7 @@ public MemberUpdateServiceResponse updateUserProfile(final MemberServiceUpdateUs
     }
 
     public MemberGetServiceResponse getMemberProfile(final long memberId) {
-        val member = get(memberId);
+        val member = memberFinder.findById(memberId);
         val goal = goalService.getByType(GoalGetServiceRequest.of(member.getGoal()));
         val trainingTimes = trainingTimeService.getAllByMember(member);
 
@@ -91,28 +92,23 @@ public MemberGetServiceResponse getMemberProfile(final long memberId) {
 
     @Transactional
     public void updateLearningPlan(final MemberUpdatePlanServiceRequest request) {
-        val member = get(request.memberId());
+        val member = memberFinder.findById(request.memberId());
         member.updateGoal(request.goalType());
         member.updateHasAlarm(request.hasAlarm());
         updateTrainingTime(member, request.trainingTime());
     }
 
     @Transactional
     public void updateHasAlarm(final MemberPushUpdateServiceRequest request) {
-        val member = get(request.memberId());
+        val member = memberFinder.findById(request.memberId());
         member.updateHasAlarm(request.hasAlarm());
     }
 
     public MemberNameServiceResponse checkDuplicatedName(final String name) {
-        val isExist = memberRepository.existsByUsername(name);
+        val isExist = memberFinder.existsByUsername(name);
         return MemberNameServiceResponse.of(isExist);
     }
 
-    public Member get(final long id) {
-        return memberRepository.findById(id)
-                .orElseThrow(() -> new MemberException(EMPTY_MEMBER));
-    }
-
     private void updateTrainingTime(Member member, TrainingTimeServiceRequest request) {
         if (nonNull(request) && StringUtils.hasText(request.day())) {
             trainingTimeService.deleteAll(member);
@@ -145,13 +141,13 @@ private String getDays(List<TrainingTime> trainingTimes) {
     }
 
     private void checkMemberDuplicate(final String username) {
-        if (memberRepository.existsByUsername(username)) {
+        if (memberFinder.existsByUsername(username)) {
             throw new MemberException(DUPLICATE_USERNAME);
         }
     }
 
     private void addWelcomeBadge(final Member member, List<Badge> badges) {
-        Badge welcomeBadge = badgeService.get(valueConfig.getWELCOME_BADGE_ID());
+        Badge welcomeBadge = badgeFinder.findById(valueConfig.getWELCOME_BADGE_ID());
         memberBadgeService.save(member, welcomeBadge);
         badges.add(welcomeBadge);
     }
@@ -170,7 +166,7 @@ private boolean isNewMember(Member member) {
 
     private void updateTermAccepted(final Member member, final MemberServiceUpdateUserProfileRequest request) {
         if (nonNull(request.termAccepted())) {
-            member.updateTermAccepted(request.termAccepted());
+            memberUpdater.updateTermAccepted(member, request.termAccepted());
         }
     }
 }