seon99il

Spring

QuartzScheduler로 사용자별 특정 시간에 알림 보내기

4분 소요

java : 11 springBoot : 2.7.5

Part 1 : Learn about the Quartz Scheduler Part 2 : Implementing Scheduler with Quartz Scheduler with SpringBoot Part 3 : QuartzScheduler로 사용자별 특정 시간에 알림 보내기

마지막 Part 3에서는 최종 목표였던, 사용자별로 특정 시간에 알림을 보내는 기능을 구현합니다.

문제는 사용자별로 임의의 시간에 알림을 보내는 것에서 시작되었습니다. 생각해 보세요. 새벽 2시에 알림을 받고 싶은 사용자와 3시 30분에 알림을 받고 싶은 사용자가 있다고 해 보겠습니다.

기존의 스케줄러를 사용한다면 매분마다 알림을 보내야 하는 사용자를 찾아야 합니다 (아니라면 댓글 부탁드립니다). 하지만 사용자가 많다면 이런 방식으로는 감당할 수 없습니다.

  • 작업이 1분 안에 끝나지 않으면 어떻게 될까요?
  • 작업이 실패하면 어떻게 될까요?

이런 문제들에 부딪혀 Quartz Scheduler를 사용하게 되었습니다. 예제에서는 Job을 생성하는 데 REST를 사용하지만, 필요하다면 CronJob으로도 구현할 수 있습니다.

개요

이번 파트에서는 두 개의 엔드포인트를 만듭니다.

  • Job 생성 (POST) /jobs/{groupName}/{jobName}/{minutes}
  • 활성화된 Job 조회 (GET) /jobs

예제를 읽어 보시고 프로젝트에 맞게 충분히 변경하실 수 있습니다. 기본 설정과 동작 원리는 Part 1과 Part 2를 참고해 주세요.

요청 생성

먼저 Job을 생성하는 요청을 구현합니다. 모든 JobRequest는 BaseJobRequest를 상속하여 구현합니다. 같은 그룹에는 같은 이름의 Job이 존재할 수 없습니다 -> 만들면 에러가 발생하지만, 저는 덮어쓰도록 구현했습니다.

@Getter
@Setter
public abstract class BaseJobRequest {
    @NotNull(message = "name cannot be Null")
    private String name;
    @NotNull(message = "group cannot be Null")
    private String group;
    private String description;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        BaseJobRequest that = (BaseJobRequest) o;
        return name.equals(that.name) && group.equals(that.group);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, group);
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setGroup(String group) {
        this.group = group;
    }

    public void setDescription(String description) {
        this.description = description;
    }
}

이제 시작 시간, 대상 userId, 내용을 포함하는 SampleJobRequest를 구현합니다. 흐름: startTime에 content가 userId에게 전달됩니다.

@Getter
public class SampleJobRequest extends BaseJobRequest {
    private final UUID userId; // userId
    private final LocalTime startTime; // Desired start time
    private final String content;

    private SampleJobRequest(Builder builder) {
        super.setName(builder.name);
        super.setGroup(builder.group);
        super.setDescription(builder.description);
        userId = builder.userId;
        startTime = builder.startTime;
        content = builder.content;
    }

    public static Builder builder() {
        return new Builder();
    }

    public static final class Builder {
        private @NotNull(message = "name cannot be Null") String name;
        private @NotNull(message = "group cannot be Null") String group;
        private String description;
        private UUID userId;
        private LocalTime startTime;
        private String content;

        private Builder() {
        }

        public static Builder builder() {
            return new Builder();
        }

        public Builder name(@NotNull(message = "name cannot be Null") String val) {
            name = val;
            return this;
        }

        public Builder group(@NotNull(message = "group cannot be Null") String val) {
            group = val;
            return this;
        }

        public Builder description(String val) {
            description = val;
            return this;
        }

        public Builder userId(UUID val) {
            userId = val;
            return this;
        }

        public Builder startTime(LocalTime val) {
            startTime = val;
            return this;
        }

        public Builder content(String val) {
            content = val;
            return this;
        }

        public SampleJobRequest build() {
            return new SampleJobRequest(this);
        }
    }
}

Trigger가 실행될 때 동작할 내용을 구현합니다. DI(의존성 주입) 는 Part 2를 참고하고 @Component를 사용합니다 (AutoWiringSpringBeanJobFactory가 필요합니다).

@Slf4j
@Component
@PersistJobDataAfterExecution
@DisallowConcurrentExecution
public class SampleJob implements Job {

    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        JobDataMap jobDataMap = context.getJobDetail().getJobDataMap();

        log.info("userId : " + jobDataMap.get("userId"));
        log.info("content : " + jobDataMap.get("content"));

        log.info("[send Message] " + jobDataMap.get("content") + " to " + jobDataMap.get("userId"));

    }
}

Job 생성, Trigger 생성, Job 목록 조회를 도와주는 QuartzHandler를 구현합니다. 시작 시점에 스케줄러를 초기화합니다.

@Slf4j
@Configuration
@RequiredArgsConstructor
public class QuartzHandler {
    private final Scheduler scheduler;

    @PostConstruct
    public void init() {
        try {
            // Initialization (DB)
            scheduler.clear();
            // add Listener
            scheduler.getListenerManager()
                    .addJobListener(new JobsListener());
            scheduler.getListenerManager()
                    .addTriggerListener(new TriggersListener());

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    public <T extends Job> void addJob(Class<? extends Job> job, SampleJobRequest request, Map params)
            throws SchedulerException {

        final JobDetail jobDetail = buildJobDetail(job, request.getName(), request.getGroup(), request.getDescription(), params);
        final Trigger trigger = buildTrigger(request.getName(), request.getGroup(), request.getStartTime());

        registerJobInScheduler(jobDetail, trigger);
    }

    public List<JobResponse> findAllActivatedJob() {
        List<JobResponse> result = new ArrayList<>();
        try {
            for (String groupName : scheduler.getJobGroupNames()) {
                log.info("groupName : " + groupName);

                for (JobKey jobKey : scheduler.getJobKeys(GroupMatcher.jobGroupEquals(groupName))) {
                    List<Trigger> trigger = (List<Trigger>) scheduler.getTriggersOfJob(jobKey);

                    result.add(JobResponse.builder()
                            .jobName(jobKey.getName())
                            .groupName(jobKey.getGroup())
                            .scheduleTime(trigger.get(0).getStartTime().toString()).build());
                }
            }
        } catch (SchedulerException e) {
            e.printStackTrace();
        }

        return result;
    }

    private void registerJobInScheduler(final JobDetail jobDetail, final Trigger trigger) throws SchedulerException {
        if (scheduler.checkExists(jobDetail.getKey())) {
            scheduler.deleteJob(jobDetail.getKey());
            scheduler.scheduleJob(jobDetail, trigger);
        } else {
            scheduler.scheduleJob(jobDetail, trigger);
        }

    }

    public <T extends Job> JobDetail buildJobDetail(
            Class<? extends Job> job, final String jobName, final String group,
            String jobDescription, Map<String, Object> params) {

        JobDataMap jobDataMap = new JobDataMap();

        if (params != null) {
            jobDataMap.putAll(params);
        }

        return JobBuilder.newJob(job)
                .withIdentity(jobName, group)
                .withDescription(jobDescription)
                .usingJobData(jobDataMap)
                .build();
    }

    private Trigger buildTrigger(final String name, final String group, final LocalTime startTime) {
        SimpleTriggerFactoryBean triggerFactory = new SimpleTriggerFactoryBean();

        triggerFactory.setName(name);
        triggerFactory.setGroup(group);
        triggerFactory.setStartTime(localTimeToDate(startTime));
        triggerFactory.setRepeatCount(0);
        triggerFactory.setRepeatInterval(0);

        triggerFactory.afterPropertiesSet();
        return triggerFactory.getObject();

    }

    private Date localTimeToDate(final LocalTime startTime) {
        Instant instant = startTime.atDate(LocalDate
                        .of(LocalDate.now().getYear(), LocalDate.now().getMonth(), LocalDate.now().getDayOfMonth()))
                .atZone(ZoneId.systemDefault()).toInstant();

        return Date.from(instant);
    }
}

이제 앞서 언급한 두 엔드포인트를 구현합니다. 앞서 말씀드린 대로, 같은 그룹에 같은 이름의 Job을 생성하면 덮어쓰기 됩니다 (Job 변경에 유용합니다).

@Slf4j
@RestController
@RequiredArgsConstructor
public class QuartzController {
    private final QuartzHandler quartzHandler;

    @PostMapping("/jobs/{group}/{name}/{minutes}")
    public ResponseEntity<Void> createJob(@PathVariable final String group, @PathVariable final String name,
                                          @PathVariable final Integer minutes) throws Exception {

        quartzHandler.addJob(SampleJob.class, SampleJobRequest.builder()
                .group(group)
                .name(name)
                .userId(UUID.randomUUID())
                .content("[Send Message] at " + LocalDateTime.now())
                .startTime(LocalTime.now().plusMinutes(minutes)).build());

        return ResponseEntity.status(HttpStatus.CREATED).build();

    }

    @GetMapping("/jobs")
    public ResponseEntity<List<JobResponse>>findAllJob() throws Exception {
        return ResponseEntity.ok().body(quartzHandler.findAllActivatedJob());
    }
}
@Builder
@Getter
@RequiredArgsConstructor
@NoArgsConstructor(force = true)
public class JobResponse {
    private final String jobName;
    private final String groupName;
    private final String scheduleTime;
}

코드는 제 GitHub에서 확인하실 수 있습니다.

GitHub - Seonggil-Jeong/QuartzScheduler-Sample

이전 글

전체 글 보기 →

댓글