[🔥TroubleShooting - MoodBuddy🔥] 너의 쿼디티아이는 뭐니?!

📌 프로젝트 소개

팀원 : PM(1) / Design(1) / Frontend(2) / Backend(3)
기간 : 2024.03 ~ 2025.03
링크 : https://github.com/M-ung/MoodBuddy_Server
서비스 내용 : 사용자가 작성한 일기를 바탕으로 감정 분석하는 웹 서비스
소통 : GitHub, Slack, Notion, Discord

---

🔥TroubleShooting🔥

Problems

우리 서비스 'MoodBuddy" 에는 특별한 기능이 있다. 바로 "쿼디티아이(QuddyTI)" 이다.

쿼디티아이(QuddyTI)란?
단순히 MBTI를 생각하면 된다.
사용자가 한 달 동안 작성한 일기를 기반으로 "일기 작성 횟수, 일기 분석을 통해 나온 감정, 주제" 를 기반으로 일기 성격 유형을 판별해주는 서비스이다.
이는 한 달 기반으로 결과가 나와야 하기 때문에 매달 00시에 쿼디티아이(QuddyTI) 생성(현재 달) 및 수정(지난 달)이 발생한다.

처음 1차 배포 때는 단순히 스케줄러를 사용해서 아래와 같이 구현했다.

@Component
@RequiredArgsConstructor
public class QuddyTIScheduler {
    private final QuddyTIFacade quddyTIFacade;

    @Scheduled(cron = "0 0 0 1 * ?")
    @Transactional
    public void aggregateAndSaveDiaryData() {
        quddyTIFacade.createAndUpadteQuddyTI();
    }
}

스케줄러를 돌려 매달 00시에 동작하도록 구현했다.

하지만 아래와 같은 문제점들이 발생했다.

1. 한 번에 모든 사용자의 데이터를 처리하려다 보니 데이터가 많아질수록 쿼리 부하 증가
2. 트랜잭션이 길어지고, 전체 데이터 처리 시간이 늘어나면서 서버 부하 발생
3. 사용자가 많아질수록 데이터 증가로 인해 하나의 스케줄러에서 처리하는 방식이 점점 부담스러워짐

---

How

그래서 위 문제들을 해결하기 위해 "Spring Batch" 를 우리 서비스에 도입하기로 했다.

Spring Batch란?
Spring Batch는 대량의 데이터를 효과적으로 처리할 수 있도록 설계된 배치 처리 프레임워크다.
스케줄러가 단순 반복 실행을 하는 것과 달리, 대량 데이터를 효율적으로 나누어 처리하고, 재시도 및 실패 복구 기능을 제공한다.

Spring Batch의 핵심 개념
1. Job: 하나의 배치 작업 단위
2. Step: Job을 구성하는 개별 단계
3. ItemReader: 데이터를 읽는 역할
4. ItemProcessor: 데이터를 가공하는 역할
5. ItemWriter: 데이터를 저장하는 역할

위 "Spring Batch" 를 적용하게 되면 아래와 같은 기대 효과를 얻을 수 있다.

1. 성능 개선: 작은 단위로 데이터를 처리하여 DB 부하 감소
2. 안정성 향상: 실패한 작업을 자동으로 재시도 가능

---

Process

먼저 기존 스케줄러는 Spring Batch의 트리거 역할을 할 수 있게 변경해 주었다.

📍 QuddyTIBatchScheduler

@Component
@RequiredArgsConstructor
public class QuddyTIBatchScheduler {
    private final JobLauncher jobLauncher;
    private final Job quddyTIJob;

    @Scheduled(cron = "0 0 0 1 * ?")
    public void runBatchJob() throws JobExecutionException {
        JobParameters jobParameters = new JobParametersBuilder()
                .addLong("time", System.currentTimeMillis())
                .toJobParameters();
        jobLauncher.run(quddyTIJob, jobParameters);
    }
}

매월 00시에 위 스케줄러를 동작시킨 후 Spring Batch가 동작하게 만들어줬다.

그리고 Spring Batch 시나리오는 아래와 같게 설계해 주었다.

1. 매달 1일 00시에 스케줄러를 통해 트리거를 발생한다.
2. Job -> Step 순으로 실행한다.
3. Reader에서 활동 중인 사용자 전체를 조회해 온다.
4. Processor에서 사용자들 userId를 기반으로 쿼디티아이 생성 및 수정을 준비한다.
5. 마지막으로 Writer에서 쿼디티아이 생성 및 수정을 한다.

그리고 위 과정을 처음에는 단순히 Spring Data JPA를 활용해서 생성, 수정, 조회를 해결하려고 했다.

하지만 Spring Data JPA를 활용한 방식에는 아래와 같은 문제점들이 있었다.

1. 대량 데이터 처리 시 성능 저하
2. JPA의 기본적인 Bulk Update/Insert의 한계

그래서 Spring Data JPA 보다 JDBC 방식으로 생성, 수정, 조회를 구현하였다.
코드는 아래와 같다.

📍 QuddyTIBatchConfig.java

@Configuration
@EnableBatchProcessing
@RequiredArgsConstructor
public class QuddyTIBatchConfig {
    private final QuddyTIBatchJDBCRepository quddyTIBatchJDBCRepository;
    private final DiaryCountService diaryCountService;
    private final JobRepository jobRepository;
    private final DataSource dataSource;
    private final PlatformTransactionManager transactionManager;

    @Bean
    public Job quddyTIJob(Step updateUserStatusStep) {
        return new JobBuilder("quddyTIJob", jobRepository)
                .start(updateUserStatusStep)
                .build();
    }

    @Bean
    public Step quddyTIStep(CompositeItemWriter<QuddyTI> compositeWriter) {
        return new StepBuilder("quddyTIStep", jobRepository)
                .<Long, QuddyTI>chunk(100, transactionManager)
                .reader(userIdReader())
                .processor(compositeProcessor())
                .writer(compositeWriter)
                .build();
    }

    @Bean
    public JdbcCursorItemReader<Long> userIdReader() {
        return new JdbcCursorItemReaderBuilder<Long>()
                .dataSource(dataSource)
                .name("userIdReader")
                .sql("SELECT user_id FROM user WHERE deleted = 0 AND user_role = 'ROLE_USER'")
                .rowMapper((rs, rowNum) -> rs.getLong("user_id"))
                .build();
    }

    @Bean
    public CompositeItemProcessor<Long, QuddyTI> compositeProcessor() {
        CompositeItemProcessor<Long, QuddyTI> processor = new CompositeItemProcessor<>();
        processor.setDelegates(Arrays.asList(quddyTICreator(), quddyTIUpdater()));
        return processor;
    }

    @Bean
    public ItemProcessor<Long, QuddyTI> quddyTICreator() {
        return userId -> QuddyTI.of(userId, DateUtil.formatYear(LocalDate.now()), DateUtil.formatMonth(LocalDate.now()));
    }

    @Bean
    public ItemProcessor<Long, QuddyTI> quddyTIUpdater() {
        return userId -> {
            LocalDate[] dates = DateUtil.getLastMonthDates();
            Map<DiaryEmotion, Long> emotionCounts = diaryCountService.getEmotionCountsByDate(dates);
            Map<DiarySubject, Long> subjectCounts = diaryCountService.getSubjectCountsByDate(dates);
            QuddyTI quddyTI = quddyTIBatchJDBCRepository.findQuddyTIByUserIdAndDate(userId, DateUtil.formatYear(dates[0]), DateUtil.formatMonth(dates[1]));
            quddyTI.update(emotionCounts, subjectCounts);
            return quddyTI;
        };
    }

    @Bean
    public CompositeItemWriter<QuddyTI> compositeWriter() {
        List<ItemWriter<? super QuddyTI>> writers = List.of(saveQuddyTI(), updateQuddyTI());
        CompositeItemWriter<QuddyTI> writer = new CompositeItemWriter<>();
        writer.setDelegates(writers);
        return writer;
    }

    @Bean
    public JdbcBatchItemWriter<QuddyTI> saveQuddyTI() {
        return new JdbcBatchItemWriterBuilder<QuddyTI>()
                .dataSource(dataSource)
                .sql("INSERT INTO quddy_ti (user_id, quddy_ti_year, quddy_ti_month, diary_frequency, daily_count, growth_count, " +
                        "emotion_count, travel_count, happiness_count, anger_count, disgust_count, fear_count, neutral_count, " +
                        "sadness_count, surprise_count, quddy_ti_type, mood_buddy_status) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)")
                .beanMapped()
                .itemPreparedStatementSetter(new ItemPreparedStatementSetter<QuddyTI>() {
                    @Override
                    public void setValues(QuddyTI item, PreparedStatement ps) throws SQLException {
                        ps.setLong(1, item.getUserId());
                        ps.setString(2, item.getQuddyTIYear());
                        ps.setString(3, item.getQuddyTIMonth());
                        ps.setInt(4, item.getDiaryFrequency());
                        ps.setInt(5, item.getDailyCount());
                        ps.setInt(6, item.getGrowthCount());
                        ps.setInt(7, item.getEmotionCount());
                        ps.setInt(8, item.getTravelCount());
                        ps.setInt(9, item.getHappinessCount());
                        ps.setInt(10, item.getAngerCount());
                        ps.setInt(11, item.getDisgustCount());
                        ps.setInt(12, item.getFearCount());
                        ps.setInt(13, item.getNeutralCount());
                        ps.setInt(14, item.getSadnessCount());
                        ps.setInt(15, item.getSurpriseCount());
                        ps.setString(16, item.getQuddyTIType());
                        ps.setString(17, item.getMoodBuddyStatus().name());
                    }
                })
                .build();
    }

    @Bean
    public JdbcBatchItemWriter<QuddyTI> updateQuddyTI() {
        return new JdbcBatchItemWriterBuilder<QuddyTI>()
                .dataSource(dataSource)
                .sql("UPDATE quddy_ti SET diary_frequency = ?, daily_count = ?, growth_count = ?, emotion_count = ?, " +
                        "travel_count = ?, happiness_count = ?, anger_count = ?, disgust_count = ?, fear_count = ?, neutral_count = ?, " +
                        "sadness_count = ?, surprise_count = ?, quddy_ti_type = ? WHERE id = ? AND user_id = ? AND quddy_ti_year = ? AND quddy_ti_month = ?")
                .beanMapped()
                .itemPreparedStatementSetter(new ItemPreparedStatementSetter<QuddyTI>() {
                    @Override
                    public void setValues(QuddyTI item, PreparedStatement ps) throws SQLException {
                        ps.setInt(1, item.getDiaryFrequency());
                        ps.setInt(2, item.getDailyCount());
                        ps.setInt(3, item.getGrowthCount());
                        ps.setInt(4, item.getEmotionCount());
                        ps.setInt(5, item.getTravelCount());
                        ps.setInt(6, item.getHappinessCount());
                        ps.setInt(7, item.getAngerCount());
                        ps.setInt(8, item.getDisgustCount());
                        ps.setInt(9, item.getFearCount());
                        ps.setInt(10, item.getNeutralCount());
                        ps.setInt(11, item.getSadnessCount());
                        ps.setInt(12, item.getSurpriseCount());
                        ps.setString(13, item.getQuddyTIType());
                        ps.setLong(14, item.getId());
                        ps.setLong(15, item.getUserId());
                        ps.setString(16, item.getQuddyTIYear());
                        ps.setString(17, item.getQuddyTIMonth());
                    }
                })
                .build();
    }
}

하지만 위처럼 구현했을 때, 에러도 많이 발생했고 하나의 Reader에 두 개의 Processor, Writer를 관리하기에 어려웠다. 또 한 번에 많은 DB 접근을 하기에는 부하가 클 것 같았다.

그래서 이를 두 개로 나누기로 했다. 시나리오는 아래와 같게 설계해 주었다.

스케줄러는 두 개로 나눴더라도 같은 시간에 실행하면 위와 같은 문제가 발생할 수 있기 때문에 생성과 수정 스케줄러를 각각 다른 매달 말일과 1일로 분리해서 실행하도록 설계했다.

📍 쿼디티아이 생성
1. 매달 말 일 23시 58분에 스케줄러를 통해 트리거를 발생한다.
2. Job -> Step 순으로 실행한다.
3. Reader에서 활동 중인 사용자 전체를 조회해 온다.
4. Processor에서 사용자들 userId를 기반으로 쿼디티아이 생성을 준비한다.
5. 마지막으로 Writer에서 쿼디티아이 생성을 한다.

📍 쿼디티아이 수정
1. 매달 1일 00시에 스케줄러를 통해 트리거를 발생한다.
2. Job -> Step 순으로 실행한다.
3. Reader에서 지난달 쿼디티아이 전체를 조회해 온다.
4. Processor에서 쿼디티아이 quddy_ti_id를 기반으로 쿼디티아이 수정을 준비한다.
5. 마지막으로 Writer에서 쿼디티아이 수정을 한다.

시나리오에 맞게 구현한 코드는 아래와 같다.

📍 QuddyTICreateBatchScheduler.java

@Component
@RequiredArgsConstructor
public class QuddyTICreateBatchScheduler {
    private final JobLauncher jobLauncher;
    private final Job quddyTICreateJob;

    @Scheduled(cron = "0 58 23 L * ?")
    public void runBatchJob() throws JobExecutionException {
        JobParameters jobParameters = new JobParametersBuilder()
                .addLong("time", System.currentTimeMillis())
                .toJobParameters();
        jobLauncher.run(quddyTICreateJob, jobParameters);
    }
}

📍 QuddyTICreateBatchConfig.java

@Configuration
@RequiredArgsConstructor
@EnableTransactionManagement
public class QuddyTICreateBatchConfig {

    private final JobRepository jobRepository;
    private final DataSource dataSource;
    private final QuddyTIBatchJDBCRepository quddyTIBatchJDBCRepository;
    private final PlatformTransactionManager transactionManager;

    @Bean
    public Job quddyTICreateJob(Step quddyTICreateStep) {
        return new JobBuilder("quddyTICreateJob", jobRepository)
                .start(quddyTICreateStep)
                .build();
    }

    @Bean
    public Step quddyTICreateStep() {
        return new StepBuilder("quddyTICreateStep", jobRepository)
                .<Long, QuddyTI>chunk(100, transactionManager)
                .reader(userIdReader())
                .processor(createQuddyTIProcessor())
                .writer(saveQuddyTIWriter())
                .build();
    }

    @Bean
    public JdbcCursorItemReader<Long> userIdReader() {
        return new JdbcCursorItemReaderBuilder<Long>()
                .dataSource(dataSource)
                .name("userIdReader")
                .sql("SELECT id FROM user WHERE deleted = 0")
                .rowMapper((rs, rowNum) -> rs.getLong("id"))
                .fetchSize(100)
                .saveState(false)
                .build();
    }

    @Bean
    public ItemProcessor<Long, QuddyTI> createQuddyTIProcessor() {
        return userId -> QuddyTI.of(
                userId,
                DateUtil.formatYear(LocalDate.now()),
                DateUtil.formatMonth(LocalDate.now())
        );
    }

    @Bean
    public ItemWriter<QuddyTI> saveQuddyTIWriter() {
        return items -> quddyTIBatchJDBCRepository.bulkSave(items.getItems());
    }
}

📍 QuddyTIUpdateBatchScheduler.java

@Component
@RequiredArgsConstructor
public class QuddyTIUpdateBatchScheduler {
    private final JobLauncher jobLauncher;
    private final Job quddyTIUpdateJob;

    @Scheduled(cron = "0 0 0 1 * ?")
    public void runBatchJob() throws JobExecutionException {
        JobParameters jobParameters = new JobParametersBuilder()
                .addLong("time", System.currentTimeMillis())
                .toJobParameters();
        jobLauncher.run(quddyTIUpdateJob, jobParameters);
    }
}

📍 QuddyTIUpdateBatchConfig.java

@Configuration
@RequiredArgsConstructor
@EnableTransactionManagement
public class QuddyTIUpdateBatchConfig {
    private final DataSource dataSource;
    private final JobRepository jobRepository;
    private final DiaryCountService diaryCountService;
    private final QuddyTIBatchJDBCRepository quddyTIBatchJDBCRepository;
    private final PlatformTransactionManager transactionManager;

    @Bean
    public Job quddyTIUpdateJob(Step quddyTIUpdateStep) {
        return new JobBuilder("quddyTIUpdateJob", jobRepository)
                .start(quddyTIUpdateStep)
                .build();
    }

    @Bean
    public Step quddyTIUpdateStep() {
        return new StepBuilder("quddyTIUpdateStep", jobRepository)
                .<QuddyTI, QuddyTI>chunk(100, transactionManager)
                .reader(quddyTIReader())
                .processor(findCountProcessor())
                .writer(updateQuddyTIWriter())
                .build();
    }

    @Bean
    public JdbcCursorItemReader<QuddyTI> quddyTIReader() {
        LocalDate[] dates = DateUtil.getLastMonthDates();
        return new JdbcCursorItemReaderBuilder<QuddyTI>()
                .dataSource(dataSource)
                .name("quddyTIReader")
                .sql(
                """
                SELECT id, user_id, quddy_ti_year, quddy_ti_month, mood_buddy_status
                FROM quddy_ti 
                WHERE quddy_ti_year = ? AND quddy_ti_month = ? AND mood_buddy_status = ?
                """
                )
                .queryArguments(
                        DateUtil.formatYear(dates[0]),
                        DateUtil.formatMonth(dates[1]),
                        MoodBuddyStatus.DIS_ACTIVE.name()
                )
                .rowMapper(this::mapQuddyTI)
                .fetchSize(50)
                .saveState(false)
                .build();
    }

    private QuddyTI mapQuddyTI(ResultSet rs, int rowNum) throws SQLException {
        return QuddyTI.builder()
                .id(rs.getLong("id"))
                .userId(rs.getLong("user_id"))
                .quddyTIYear(rs.getString("quddy_ti_year"))
                .quddyTIMonth(rs.getString("quddy_ti_month"))
                .moodBuddyStatus(MoodBuddyStatus.valueOf(rs.getString("mood_buddy_status")))
                .build();
    }

    @Bean
    public ItemProcessor<QuddyTI, QuddyTI> findCountProcessor() {
        return quddyTI -> {
            LocalDate[] dates = DateUtil.getLastMonthDates();
            Map<DiaryEmotion, Long> emotionCounts = diaryCountService.getEmotionCountsByDate(quddyTI.getUserId(), dates);
            Map<DiarySubject, Long> subjectCounts = diaryCountService.getSubjectCountsByDate(quddyTI.getUserId(), dates);
            quddyTI.update(emotionCounts, subjectCounts);
            return quddyTI;
        };
    }

    @Bean
    public ItemWriter<QuddyTI> updateQuddyTIWriter() {
        return items -> quddyTIBatchJDBCRepository.bulkUpdate(items.getItems());
    }
}

정상적으로 돌아가는지 확인하기 위해 더미 데이터를 넣고 실행한 결과, 정상적으로 돌아가는 걸 확인할 수 있다.

---

Result

문제 해결로 아래와 같은 결과를 얻었다.
1. 사용자 10,000명 기준, 쿼디티아이 생성 평균 약 919ms, 수정 평균 약 14,528ms로 성능 개선.
2. 스케줄러 → Spring Batch 트리거 방식으로 전환하여 유지보수성을 향상.
3. JPA 대신 JDBC 사용으로 더티 체킹 오버헤드를 제거하고 batch 성능 최적화.
4. 쿼디티아이 생성과 수정 작업을 분리하여 DB 부하를 분산

---

Thoughts

이번 Spring Batch 도입을 통해 스케줄러 기반의 대량 데이터 처리를 개선하는 경험을 할 수 있었다.

처음 적용한 스케줄러 방식에서는 대량 데이터 조회 및 업데이트로 인해 트랜잭션이 길어지고 성능 저하 문제가 발생했지만, Spring Batch를 활용하여 작은 단위로 나누어 처리할 수 있었으며 성능을 개선하고 안정성을 확보할 수 있었다.

위 경험들을 통해 대량 데이터 처리는 단순히 스케줄러로 적용해야겠다는 생각보단 Spring Batch와 같은 프레임워크를 적용하는 것이 필수적이라는 생각을 했다.

또 Spring Data JPA의 편리성으로 인해 이에 의존하기보단 알고 쓰는 것이 중요하다는 것을 깨달았다. 불편하더라도 성능적으로 떨어지면 JDBC와 같은 기술을 적용할 수 있는 설계 능력을 갖춘 개발자가 되어야겠다고 생각했다.

---