[REFACTOR/#72] 가계부 동기화 로직 성능 최적화 및 중복 처리 개선 (#91)

## 🔗 Related Issue
<!-- 이슈 번호를 작성하여 종료시켜주세요 -->
- Closes #72 

## 📝 Summary
<!-- 작업한 기능을 설명해주세요 -->
가계부 동기화 로직의 성능 저하 및 중복 처리 오류를 개선했습니다.
- IN 절 과다 파라미터 문제 해결
- LedgerEntry에 미등록된 CardApproval/BankTransaction만 조회하도록 JPQL 기반 조회
메서드(`findUnsynced...`)를 추가
  - 애플리케이션 단에서 ID 목록을 모아 IN 절로 조회하던 방식을 제거하고, DB 레벨에서 필터링하도록 개선
- 카드/은행 중복 처리 로직 정확도 개선
  - 중복 비교 대상 카드 내역 조회 시 `memberId` 조건을 추가하여, 해당 회원의 카드 내역만 비교하도록 수정

## 🔄 Changes
<!-- 구체적으로 어떤 파일/로직이 변경되었는지 체크해주세요 -->
- [ ] API 변경 (추가/수정)
- [ ] 데이터 및 도메인 변경 (DB, 비즈니스 로직)
- [ ] 설정 또는 인프라 관련 변경
- [X] 리팩토링

## 💬 Questions & Review Points
<!-- 리뷰어가 특별히 봐주었으면 하는 부분이 있다면 작성해주세요 -->

## 📸 API Test Results (Swagger)
<!-- API 테스트 스크린샷 첨부 -->

## ✅ Checklist
- [x] API 테스트 완료
- [ ] 테스트 결과 사진 첨부
- [x] 빌드 성공 확인 (./gradlew build)

Author: seamooll

src/main/java/org/umc/valuedi/domain/asset/repository/bank/bankTransaction/BankTransactionRepository.java

@@ -18,4 +18,11 @@ public interface BankTransactionRepository extends JpaRepository<BankTransaction
     Optional<LocalDate> findLatestTransactionDateByAccount(@Param("account") BankAccount account);
 
     List<BankTransaction> findByBankAccountInAndTrDatetimeAfter(List<BankAccount> accounts, LocalDateTime startTime);
+
+    @Query("SELECT bt FROM BankTransaction bt " +
+            "LEFT JOIN LedgerEntry le ON le.bankTransaction = bt " +
+            "WHERE bt.bankAccount.codefConnection.member.id = :memberId " +
+            "AND bt.trDate BETWEEN :from AND :to " +
+            "AND le.id IS NULL")
+    List<BankTransaction> findUnsyncedBankTransactions(@Param("memberId") Long memberId, @Param("from") LocalDate from, @Param("to") LocalDate to);
 }

src/main/java/org/umc/valuedi/domain/asset/repository/card/cardApproval/CardApprovalRepository.java

@@ -15,10 +15,23 @@
 
 public interface CardApprovalRepository extends JpaRepository<CardApproval, Long>, CardApprovalRepositoryCustom {
     List<CardApproval> findByUsedDateBetween(LocalDate fromDate, LocalDate toDate);
+    
+    @Query("SELECT ca FROM CardApproval ca " +
+            "WHERE ca.card.codefConnection.member.id = :memberId " +
+            "AND ca.usedDate BETWEEN :from AND :to")
+    List<CardApproval> findMemberCardApprovalsBetween(@Param("memberId") Long memberId, @Param("from") LocalDate from, @Param("to") LocalDate to);
+
     boolean existsByUsedAmountAndUsedDatetimeBetween(Long amount, LocalDateTime start, LocalDateTime end);
 
     @Query("SELECT MAX(ca.usedDate) FROM CardApproval ca JOIN ca.card c WHERE c.codefConnection.member = :member")
     Optional<LocalDate> findLatestApprovalDateByMember(@Param("member") Member member);
 
     List<CardApproval> findByCardInAndApprovalNoIn(List<Card> cards, List<String> approvalNos);
+
+    @Query("SELECT ca FROM CardApproval ca " +
+            "LEFT JOIN LedgerEntry le ON le.cardApproval = ca " +
+            "WHERE ca.card.codefConnection.member.id = :memberId " +
+            "AND ca.usedDate BETWEEN :from AND :to " +
+            "AND le.id IS NULL")
+    List<CardApproval> findUnsyncedCardApprovals(@Param("memberId") Long memberId, @Param("from") LocalDate from, @Param("to") LocalDate to);
 }

src/main/java/org/umc/valuedi/domain/asset/service/command/AssetFetchService.java

@@ -15,7 +15,6 @@
 import org.umc.valuedi.domain.asset.service.command.worker.AssetFetchWorker;
 import org.umc.valuedi.domain.connection.entity.CodefConnection;
 import org.umc.valuedi.domain.connection.repository.CodefConnectionRepository;
-import org.umc.valuedi.domain.ledger.service.command.LedgerSyncService;
 import org.umc.valuedi.domain.member.entity.Member;
 
 import java.time.LocalDate;
@@ -37,14 +36,13 @@ public class AssetFetchService {
     private final BankTransactionRepository bankTransactionRepository;
     private final CardApprovalRepository cardApprovalRepository;
     private final AssetFetchWorker assetFetchWorker;
-    private final LedgerSyncService ledgerSyncService;
 
     private record BankTransactionKey(LocalDateTime trDatetime, Long inAmount, Long outAmount, String desc3) {}
     private record CardApprovalKey(Card card, String approvalNo) {}
 
     @Transactional
     public AssetResDTO.AssetSyncResult fetchAndSaveLatestData(Member member) {
-        List<CodefConnection> connections = codefConnectionRepository.findByMemberId(member.getId());
+        List<CodefConnection> connections = codefConnectionRepository.findByMemberIdWithMember(member.getId());
         LocalDate today = LocalDate.now();
 
         // 각 기관별로 비동기 API 호출 실행
@@ -103,11 +101,6 @@ public AssetResDTO.AssetSyncResult fetchAndSaveLatestData(Member member) {
         entityManager.flush();
         entityManager.clear();
 
-        // 가계부 동기화
-        if (totalNewBankTransactions > 0 || totalNewCardApprovals > 0) {
-            ledgerSyncService.syncTransactions(member, overallMinDate, today);
-        }
-
         return AssetResDTO.AssetSyncResult.builder()
                 .newBankTransactionCount(totalNewBankTransactions)
                 .newCardApprovalCount(totalNewCardApprovals)

src/main/java/org/umc/valuedi/domain/asset/service/command/AssetSyncProcessor.java

@@ -4,6 +4,7 @@
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.scheduling.annotation.Async;
 import org.springframework.stereotype.Service;
+import org.springframework.transaction.annotation.Transactional;
 import org.umc.valuedi.domain.asset.dto.res.AssetResDTO;
 import org.umc.valuedi.domain.connection.service.command.SyncLogCommandService;
 import org.umc.valuedi.domain.ledger.service.command.LedgerSyncService;
@@ -28,6 +29,7 @@ public class AssetSyncProcessor {
      * 실제 동기화 로직을 수행하는 비동기 메서드
      */
     @Async("assetFetchExecutor")
+    @Transactional
     public void runSyncProcess(Long memberId, Long logId) {
         log.info("자산 동기화 백그라운드 작업을 시작합니다. 회원 ID: {}", memberId);
         try {
@@ -42,12 +44,12 @@ public void runSyncProcess(Long memberId, Long logId) {
                 LocalDate fromDate = syncResult.getFromDate();
                 LocalDate toDate = syncResult.getToDate();
 
-                // 트랜잭션 2: 가계부 연동 및 최종 업데이트
-                // Member 객체 대신 ID를 전달하여 영속성 컨텍스트 내에서 조회 및 업데이트하도록 변경
+                // 트랜잭션 2: 가계부 연동
                 ledgerSyncService.syncTransactions(member, fromDate, toDate);
             }
 
-            // 트랜잭션 3: 동기화 로그 업데이트
+            // 트랜잭션 3: 동기화 로그 및 최종 시간 업데이트
+            member.updateLastSyncedAt();
             syncLogCommandService.updateToSuccess(logId);
             log.info("자산 동기화 백그라운드 작업을 성공적으로 완료했습니다. 회원 ID: {}", member.getId());
 

src/main/java/org/umc/valuedi/domain/connection/repository/CodefConnectionRepository.java

@@ -1,23 +1,26 @@
 package org.umc.valuedi.domain.connection.repository;
 
 import org.springframework.data.jpa.repository.JpaRepository;
+import org.springframework.data.jpa.repository.Query;
+import org.springframework.data.repository.query.Param;
 import org.umc.valuedi.domain.connection.entity.CodefConnection;
 import org.umc.valuedi.domain.connection.enums.BusinessType;
 
 import java.util.List;
 import java.util.Optional;
 
 public interface CodefConnectionRepository extends JpaRepository<CodefConnection, Long> {
-    // 회원의 모든 연동
-    List<CodefConnection> findByMemberId(Long memberId);
 
-    // 특정 기관 연동 여부
-    boolean existsByMemberIdAndOrganization(Long memberId, String organization);
+    @Query("SELECT c FROM CodefConnection c JOIN FETCH c.member WHERE c.id = :id")
+    Optional<CodefConnection> findByIdWithMember(@Param("id") Long id);
 
-    // connectedId 조회용
-    Optional<CodefConnection> findFirstByMemberId(Long memberId);
+    @Query("SELECT c FROM CodefConnection c JOIN FETCH c.member WHERE c.member.id = :memberId")
+    List<CodefConnection> findByMemberIdWithMember(@Param("memberId") Long memberId);
 
-    // 타입별 조회 (은행/카드사)
-    List<CodefConnection> findByMemberIdAndBusinessType(Long memberId, BusinessType businessType);
+    @Query("SELECT c FROM CodefConnection c JOIN FETCH c.member WHERE c.member.id = :memberId AND c.businessType = :businessType")
+    List<CodefConnection> findByMemberIdAndBusinessTypeWithMember(@Param("memberId") Long memberId, @Param("businessType") BusinessType businessType);
 
+    List<CodefConnection> findByMemberId(Long memberId);
+
+    List<CodefConnection> findByMemberIdAndBusinessType(Long memberId, BusinessType businessType);
 }

src/main/java/org/umc/valuedi/domain/connection/service/command/ConnectionCommandService.java

@@ -11,6 +11,10 @@
 import org.umc.valuedi.domain.connection.exception.code.ConnectionErrorCode;
 import org.umc.valuedi.domain.connection.repository.CodefConnectionRepository;
 import org.umc.valuedi.domain.goal.repository.GoalRepository;
+import org.umc.valuedi.domain.member.entity.Member;
+import org.umc.valuedi.domain.member.exception.MemberException;
+import org.umc.valuedi.domain.member.exception.code.MemberErrorCode;
+import org.umc.valuedi.domain.member.repository.MemberRepository;
 import org.umc.valuedi.global.external.codef.service.CodefAccountService;
 
 @Slf4j
@@ -22,20 +26,23 @@ public class ConnectionCommandService {
     private final CodefAccountService codefAccountService;
     private final CodefConnectionRepository codefConnectionRepository;
     private final GoalRepository goalRepository;
+    private final MemberRepository memberRepository;
 
     /**
      * 금융사 계정 연동
      */
     public void connect(Long memberId, ConnectionReqDTO.Connect request) {
-        codefAccountService.connectAccount(memberId, request);
+        Member member = memberRepository.findById(memberId)
+                .orElseThrow(() -> new MemberException(MemberErrorCode.MEMBER_NOT_FOUND));
+        codefAccountService.connectAccount(member, request);
         log.info("금융사 연동 완료 - memberId: {}, organization: {}", memberId, request.getOrganization());
     }
 
     /**
      * 금융사 연동 해제
      */
     public void disconnect(Long memberId, Long connectionId) {
-        CodefConnection connection = codefConnectionRepository.findById(connectionId)
+        CodefConnection connection = codefConnectionRepository.findByIdWithMember(connectionId)
                 .orElseThrow(() -> new ConnectionException(ConnectionErrorCode.CONNECTION_NOT_FOUND));
 
         if (!connection.getMember().getId().equals(memberId)) {

src/main/java/org/umc/valuedi/domain/connection/service/query/ConnectionQueryService.java

@@ -26,7 +26,7 @@ public class ConnectionQueryService {
      */
     public List<BankResDTO.BankConnection> getConnectedBanks(Long memberId) {
         List<CodefConnection> connections =
-                connectionRepository.findByMemberIdAndBusinessType(
+                connectionRepository.findByMemberIdAndBusinessTypeWithMember(
                         memberId,
                         BusinessType.BK
                 );
@@ -41,7 +41,7 @@ public List<BankResDTO.BankConnection> getConnectedBanks(Long memberId) {
      */
     public List<CardResDTO.CardIssuerConnection> getConnectedCardIssuers(Long memberId) {
         List<CodefConnection> connections =
-                connectionRepository.findByMemberIdAndBusinessType(
+                connectionRepository.findByMemberIdAndBusinessTypeWithMember(
                         memberId,
                         BusinessType.CD
                 );
@@ -56,7 +56,7 @@ public List<CardResDTO.CardIssuerConnection> getConnectedCardIssuers(Long member
      */
     public List<ConnectionResDTO.Connection> getAllConnections(Long memberId) {
         List<CodefConnection> connections =
-                connectionRepository.findByMemberId(memberId);
+                connectionRepository.findByMemberIdWithMember(memberId);
 
         return connections.stream()
                 .map(ConnectionConverter::toConnectionDTO)

src/main/java/org/umc/valuedi/domain/ledger/repository/LedgerEntryRepository.java

@@ -9,17 +9,11 @@
 
 import java.time.LocalDateTime;
 import java.util.List;
-import java.util.Set;
 
 public interface LedgerEntryRepository extends JpaRepository<LedgerEntry, Long>, LedgerEntryRepositoryCustom {
     boolean existsByBankTransactionId(Long bankTransactionId);
-    boolean existsByCardApprovalId(Long cardApprovalId);
-
-    @Query("SELECT le.cardApproval.id FROM LedgerEntry le WHERE le.cardApproval.id IN :ids")
-    Set<Long> findExistingCardApprovalIds(@Param("ids") List<Long> ids);
 
-    @Query("SELECT le.bankTransaction.id FROM LedgerEntry le WHERE le.bankTransaction.id IN :ids")
-    Set<Long> findExistingBankTransactionIds(@Param("ids") List<Long> ids);
+    boolean existsByCardApprovalId(Long cardApprovalId);
 
     @Modifying
     @Query("DELETE FROM LedgerEntry le WHERE le.member = :member AND le.transactionAt >= :start AND le.transactionAt < :end")

src/main/java/org/umc/valuedi/domain/ledger/service/command/LedgerSyncService.java

@@ -125,8 +125,6 @@ public void rebuildLedger(Member member, LocalDate from, LocalDate to) {
             ledgerEntryRepository.bulkInsert(entries);
             log.info("Ledger Rebuild Complete: Member {}, {} entries created.", member.getId(), entries.size());
         }
-
-        member.updateLastSyncedAt();
     }
 
     private LedgerEntry createFromCard(Member member, CardApproval ca, Category defaultCategory, String key) {
@@ -179,22 +177,6 @@ private LedgerEntry createFromBank(Member member, BankTransaction bt, Category d
                 .build();
     }
 
-
-    @Transactional
-    public void syncTransactionsAndUpdateMember(Long memberId, LocalDate from, LocalDate to) {
-        Member member = memberRepository.findById(memberId)
-                .orElseThrow(() -> new LedgerException(MemberErrorCode.MEMBER_NOT_FOUND));
-        syncTransactions(member, from, to);
-        member.updateLastSyncedAt();
-    }
-
-    @Transactional
-    public void updateMemberLastSyncedAt(Long memberId) {
-        Member member = memberRepository.findById(memberId)
-                .orElseThrow(() -> new LedgerException(MemberErrorCode.MEMBER_NOT_FOUND));
-        member.updateLastSyncedAt();
-    }
-
     @Transactional
     public void syncTransactions(Long memberId, LedgerSyncRequest request) {
         Member member = memberRepository.findById(memberId).orElseThrow(() -> new LedgerException(MemberErrorCode.MEMBER_NOT_FOUND));
@@ -203,7 +185,7 @@ public void syncTransactions(Long memberId, LedgerSyncRequest request) {
         syncTransactions(member, from, to);
     }
 
-    // 트랜잭션 어노테이션 제거 (상위 메서드에서 관리)
+    @Transactional
     public void syncTransactions(Member member, LocalDate from, LocalDate to) {
         if (to.isBefore(from)) {
             throw new LedgerException(LedgerErrorCode.INVALID_DATE_RANGE);
@@ -214,7 +196,8 @@ public void syncTransactions(Member member, LocalDate from, LocalDate to) {
         Category transferCategory = categoryRepository.findByCode("TRANSFER")
                 .orElseThrow(() -> new LedgerException(LedgerErrorCode.CATEGORY_NOT_FOUND));
 
-        List<CardApproval> cards = cardApprovalRepository.findByUsedDateBetween(from.minusDays(1), to.plusDays(1));
+        // 중복 체크를 위한 카드 내역 (은행 거래와 비교용)
+        List<CardApproval> cards = cardApprovalRepository.findMemberCardApprovalsBetween(member.getId(), from.minusDays(1), to.plusDays(1));
 
         List<LedgerEntry> allNewEntries = new ArrayList<>();
         syncCardApprovals(member, from, to, defaultCategory, allNewEntries);
@@ -274,18 +257,11 @@ public int rematchCategories(Long memberId, LocalDate from, LocalDate to) {
     }
 
     private void syncCardApprovals(Member member, LocalDate from, LocalDate to, Category defaultCategory, List<LedgerEntry> allNewEntries) {
-        List<CardApproval> cards = cardApprovalRepository.findByUsedDateBetween(from, to);
+        // 가계부에 없는 카드 내역만 조회
+        List<CardApproval> cards = cardApprovalRepository.findUnsyncedCardApprovals(member.getId(), from, to);
         if (cards.isEmpty()) return;
 
-        // ID 목록을 추출
-        List<Long> cardApprovalIds = cards.stream().map(CardApproval::getId).collect(Collectors.toList());
-
-        // 이미 존재하는 LedgerEntry의 CardApproval ID를 한 번의 쿼리로 조회
-        Set<Long> existingIds = ledgerEntryRepository.findExistingCardApprovalIds(cardApprovalIds);
-
         for (CardApproval ca : cards) {
-            // DB 쿼리 대신 메모리의 Set에서 확인
-            if (existingIds.contains(ca.getId())) continue;
             if (ca.getUsedDatetime() == null) continue;
 
             String merchantName = ca.getMerchantName();
@@ -308,18 +284,11 @@ private void syncCardApprovals(Member member, LocalDate from, LocalDate to, Cate
     }
 
     private void syncBankTransactions(Member member, LocalDate from, LocalDate to, List<CardApproval> cards, Category defaultCategory, Category transferCategory, List<LedgerEntry> allNewEntries) {
-        List<BankTransaction> banks = bankTransactionRepository.findByTrDateBetween(from, to);
+        // 가계부에 없는 은행 내역만 조회
+        List<BankTransaction> banks = bankTransactionRepository.findUnsyncedBankTransactions(member.getId(), from, to);
         if (banks.isEmpty()) return;
 
-        // ID 목록 추출
-        List<Long> bankTransactionIds = banks.stream().map(BankTransaction::getId).collect(Collectors.toList());
-
-        // 한 번의 쿼리로 조회
-        Set<Long> existingIds = ledgerEntryRepository.findExistingBankTransactionIds(bankTransactionIds);
-
         for (BankTransaction bt : banks) {
-            // 메모리에서 확인
-            if (existingIds.contains(bt.getId())) continue;
             if (bt.getTrDatetime() == null) continue;
 
             String combinedDesc = Stream.of(bt.getDesc2(), bt.getDesc3(), bt.getDesc4()).filter(Objects::nonNull).collect(Collectors.joining(" "));

src/main/java/org/umc/valuedi/global/external/codef/service/CodefAccountService.java

@@ -28,17 +28,13 @@ public class CodefAccountService {
 
     private final CodefApiClient codefApiClient;
     private final EncryptUtil encryptUtil;
-    private final MemberRepository memberRepository;
     private final ApplicationEventPublisher eventPublisher;
 
     /**
      * 금융사 계정 연동 메인 로직
      */
     @Transactional
-    public void connectAccount(Long memberId, ConnectionReqDTO.Connect request) {
-
-        Member member = memberRepository.findById(memberId)
-                .orElseThrow(() -> new MemberException(MemberErrorCode.MEMBER_NOT_FOUND));
+    public void connectAccount(Member member, ConnectionReqDTO.Connect request) {
 
         // 기존에 발급받은 Connected ID가 있는지 리스트에서 확인
         String existingConnectedId = member.getCodefConnectionList().stream()