WildFly 23环境下如何使用EJB TimerService实现每两年1月1日重置订单号？

Got it, let's work through this problem together. Since EJB TimerService has strict limitations on cron expressions—it doesn't support the ? wildcard or increment values like */2 for the year field—here are a few practical ways to get your bi-annual order number reset up and running on WildFly 23 with JDK 11:

1. Use an Annual Timer with a Year Check #

The simplest approach is to create an EJB Timer that runs every January 1st (a cron expression EJB supports), then add logic to only execute the reset on every other year.

Example Code: #

@Singleton
@Startup
public class OrderNumberResetTimer {

    @Resource
    private TimerService timerService;

    @PostConstruct
    public void initAnnualTimer() {
        // Schedule to run every January 1st at midnight
        ScheduleExpression schedule = new ScheduleExpression()
            .second(0)
            .minute(0)
            .hour(0)
            .dayOfMonth(1)
            .month(1)
            .year("*");
        
        timerService.createCalendarTimer(schedule, new TimerConfig("AnnualOrderResetTimer", false));
    }

    @Timeout
    public void handleTimerTimeout(Timer timer) {
        LocalDate currentDate = LocalDate.now();
        int currentYear = currentDate.getYear();

        // Adjust the logic to match your starting year (e.g., 2024 as the first reset year)
        if ((currentYear - 2024) % 2 == 0) {
            // Execute your order number reset logic here
            resetOrderNumberSequence();
        }
        // If the year doesn't match, do nothing—wait for the next annual run
    }

    private void resetOrderNumberSequence() {
        // Replace with your actual database reset logic
        // Example: Reset a sequence to 1
        // try (EntityManager em = entityManagerFactory.createEntityManager()) {
        //     em.getTransaction().begin();
        //     em.createNativeQuery("ALTER SEQUENCE order_number_seq RESTART WITH 1").executeUpdate();
        //     em.getTransaction().commit();
        // }
    }
}

This uses only native EJB APIs, no extra dependencies, and is easy to maintain. The logic checks if the current year falls into your 2-year interval before running the reset.

2. Integrate Quartz with WildFly #

If you prefer using your original cron expression (0 0 0 1 1 ? */2), you can integrate Quartz directly into WildFly. Quartz supports full cron syntax, so your existing expression will work perfectly.

Steps: #

1. Add the Quartz subsystem to WildFly's standalone.xml (or use WildFly's CLI to install the extension).
2. Create a Quartz Job to handle the reset logic.
3. Initialize the Quartz scheduler in a startup bean to schedule your job.

Example Code: #

@Singleton
@Startup
public class QuartzOrderResetScheduler {

    @PostConstruct
    public void initQuartzScheduler() throws SchedulerException {
        Scheduler scheduler = StdSchedulerFactory.getDefaultScheduler();
        scheduler.start();

        // Define the job
        JobDetail resetJob = JobBuilder.newJob(OrderNumberResetJob.class)
            .withIdentity("orderResetJob", "orderGroup")
            .build();

        // Use your original cron expression
        CronTrigger resetTrigger = TriggerBuilder.newTrigger()
            .withIdentity("orderResetTrigger", "orderGroup")
            .withSchedule(CronScheduleBuilder.cronSchedule("0 0 0 1 1 ? */2"))
            .build();

        scheduler.scheduleJob(resetJob, resetTrigger);
    }
}

public class OrderNumberResetJob implements Job {
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        // Run your order number reset logic
        resetOrderNumberSequence();
    }

    private void resetOrderNumberSequence() {
        // Database reset implementation here
    }
}

This leverages Quartz's robust scheduling capabilities, but requires extra configuration for WildFly integration.

3. Manually Schedule Next Reset Time #

For full control, you can calculate the next valid reset date manually, create a one-time EJB Timer, and re-schedule the next timer after each reset.

Example Code: #

@Singleton
@Startup
public class ManualOrderResetTimer {

    @Resource
    private TimerService timerService;

    @PostConstruct
    public void scheduleFirstReset() {
        calculateAndScheduleNextReset();
    }

    private void calculateAndScheduleNextReset() {
        LocalDate now = LocalDate.now();
        LocalDate nextResetDate;

        // Determine the next valid January 1st in a 2-year interval
        int currentYear = now.getYear();
        int baseYear = 2024; // Adjust to your first reset year
        int yearsSinceBase = currentYear - baseYear;

        if (yearsSinceBase % 2 == 0) {
            nextResetDate = LocalDate.of(currentYear, Month.JANUARY, 1);
            if (nextResetDate.isBefore(now)) {
                nextResetDate = nextResetDate.plusYears(2);
            }
        } else {
            nextResetDate = LocalDate.of(currentYear + 1, Month.JANUARY, 1);
        }

        // Convert to Instant for the timer
        Instant nextResetInstant = nextResetDate.atStartOfDay(ZoneId.systemDefault()).toInstant();
        TimerConfig config = new TimerConfig("ManualOrderResetTimer", false);
        timerService.createSingleActionTimer(nextResetInstant, config);
    }

    @Timeout
    public void handleTimeout(Timer timer) {
        // Execute reset
        resetOrderNumberSequence();
        // Schedule the next reset
        calculateAndScheduleNextReset();
    }

    private void resetOrderNumberSequence() {
        // Database reset logic here
    }
}

This approach avoids cron expressions entirely and gives you full control over the scheduling logic, which is useful if your interval needs to change later.

内容的提问来源于stack exchange，提问作者raho