Spring的监听器和org.quartz.Job的使用

最新推荐文章于 2025-05-26 14:06:19 发布

原创最新推荐文章于 2025-05-26 14:06:19 发布 · 3.6k 阅读

3 ·

CC 4.0 BY-SA版权

文章标签：

#spring #job

本文详细介绍了如何在JavaWeb工程中配置监听器，特别是在项目启动时执行的ServletContextListener。首先，通过实现ServletContextListener接口创建监听类，并在web.xml中进行配置。接着，文章深入探讨了在系统启动的监听器中配置org.quartz.Job，包括web.xml、applicationContext.xml和spring-mvc.xml的设置。最后，讲解了SystemStartListener、Plan、TaskService接口、TaskServiceImpl实现类、SpringBeanUtils、PublicJob以及具体任务类OnlineEquipmentPublicJob的编写过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

JavaWeb工程中配置监听器

一.在项目启动时就执行的监听器,使用ServletContextListener

1.监听类的书写

自定义的listener需要实现ServletContextListener 接口

package com.glite.listener;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import org.apache.log4j.Logger;
import com.glite.thread.UDPSaveThread;
import com.glite.thread.UDPSocketThread;
public class UDPSocketListener implements ServletContextListener {
    private static final Logger logger = Logger.getLogger(UDPSocketListener.class);
    @Override
    public void contextDestroyed(ServletContextEvent event) {
        logger.info("-----------contextDestroyed---------");
    }
    @Override
    public void contextInitialized(ServletContextEvent event) {
        logger.info("-----------contextInitialized---------");
        UDPSocketThread socket = new UDPSocketThread();
        UDPSaveThread save = new UDPSaveThread();
        socket.start();
        save.start();
    }
}

2.web.xml的书写

注入自定义的listener和context-param

...
<context-param>
<param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>
<listener>
    <listener-class>com.glite.listener.UDPSocketListener</listener-class>
</listener>
...

二.在系统启动的监听器中配置org.quartz.Job

1. web.xml的书写

注入ContextLoaderListener

...
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>classpath:applicationContext.xml</param-value>
</context-param>
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<servlet>
    <servlet-name>springMVC</servlet-name>
    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
    <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:spring-mvc.xml</param-value>
    </init-param>
    <load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
    <servlet-name>springMVC</servlet-name>
    <url-pattern>/</url-pattern>
</servlet-mapping>
...

2.applicationContext.xml

<context:annotation-config />
    <context:component-scan base-package="cn.gilight,cn.gilight.listener">
</context:component-scan>

<bean id="jobFactory" class="cn.gilight.task.MyJobFactory"></bean>
<!-- 调度对象 -->
<bean id="schedulerFactoryBean" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">
    <property name="jobFactory" ref="jobFactory"></property>
</bean>

3.spring-mvc.xml

<context:annotation-config />
    <context:component-scan base-package="cn.gilight.business.**.controller">
</context:component-scan>

4.具体类的关系图

这里写图片描述

5.具体类的书写

1.SystemStartListener类的书写

需要实现InitializingBean和ServletContextAware 接口

package cn.gilight.listener;
import javax.servlet.ServletContext;
import org.apache.log4j.Logger;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.web.context.ServletContextAware;
import cn.gilight.task.job.bean.Plan;
import cn.gilight.task.service.TaskService;
@Service
public class SystemStartListener implements InitializingBean, ServletContextAware {
    /**
     * Logger for this class
     */
    private static final Logger logger = Logger.getLogger(SystemStartListener.class);
    @Autowired
    private TaskService taskService;
    @Override
    public void setServletContext(ServletContext arg0) {
        logger.info("-------------------System starting--------------------");
        try {
            Plan plan = new Plan();
            plan.setId(1);
            plan.setName("onlineEquipment");
            plan.setGroup_("group");
            //plan.setCron_expression("00 30 12 * * ?");//每天12:30执行一次
            plan.setCron_expression("0 0 0/2 * * ?");//每隔2小时执行一次
            plan.setDesc_("Trigger time:Execute every two hours");
            plan.setIsTrue("1");
            plan.setJobClass("cn.gilight.task.job.impl.OnlineEquipmentPublicJob");
            try {
                logger.info("plan : " + plan);
                taskService.addJob(plan);
                logger.info("--Added student online device task successfully-----");
            } catch (Exception e) {
                logger.info("---Add student online device task exception-----");
                e.printStackTrace();
            }
        } catch (Exception e) {
            logger.info("-----Task initialization failed------");
            e.printStackTrace();
        }
    }
}

2.自定义的Plan类的书写

package cn.gilight.task.job.bean;
/**
 * job实体类
 */
public class Plan {
    private Integer id;
    private String name;
    private String group_;
    private String cron_expression;
    private String desc_;
    private String isTrue = "1";
    private String jobClass;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getGroup_() {
        return group_;
    }
    public void setGroup_(String group_) {
        this.group_ = group_;
    }
    public String getCron_expression() {
        return cron_expression;
    }
    public void setCron_expression(String cron_expression) {
        this.cron_expression = cron_expression;
    }
    public String getDesc_() {
        return desc_;
    }
    public void setDesc_(String desc_) {
        this.desc_ = desc_;
    }
    public String getIsTrue() {
        return isTrue;
    }
    public void setIsTrue(String isTrue) {
        this.isTrue = isTrue;
    }
    public String getJobClass() {
        return jobClass;
    }
    public void setJobClass(String jobClass) {
        this.jobClass = jobClass;
    }
    @Override
    public String toString() {
        return "Plan [id=" + id + ", name=" + name + ", group_=" + group_ + ", cron_expression=" + cron_expression + ", desc_=" + desc_ + ", isTrue=" + isTrue + ", jobClass=" + jobClass + "]";
    }

}

3. TaskService 任务接口

package cn.gilight.task.service;
import org.quartz.SchedulerException;
import cn.gilight.task.job.bean.Plan;
/**
 * 任务接口
 */
public interface TaskService {
    /**
     * 创建或者更新任务
     * @param job
     * @throws SchedulerException
     * @throws ClassNotFoundException
     */
    public void updateOrInsert(Plan plan) throws Exception;
    /**
     * 创建任务
     * @param job
     * @throws SchedulerException
     * @throws ClassNotFoundException
     */
    public void addJob(Plan plan) throws Exception;
    /**
     * 更新任务
     * @param job
     * @throws SchedulerException
     * @throws ClassNotFoundException
     */
    public void updateOrInsertJob(Plan plan) throws Exception;
    /**
     * 暂停任务
     * @param job
     * @throws SchedulerException
     */
    public void stopJob(Plan plan) throws Exception;
    /**
     * 恢复任务
     * @param job
     * @throws SchedulerException
     */
    public void startJob(Plan plan) throws Exception;
    /**
     * 删除任务
     * @param job
     * @throws SchedulerException
     */
    public void delJob(Plan plan) throws Exception;
    /**
     * 运行计划JOB
     * @param plan
     * @throws SchedulerException
     */
    public void runJob(Plan plan) throws Exception;

}

4.TaskServiceImpl 任务实现类

package cn.gilight.task.service.impl;
import org.quartz.CronScheduleBuilder;
import org.quartz.CronTrigger;
import org.quartz.JobBuilder;
import org.quartz.JobDetail;
import org.quartz.JobKey;
import org.quartz.Scheduler;
import org.quartz.TriggerBuilder;
import org.quartz.TriggerKey;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.quartz.SchedulerFactoryBean;
import org.springframework.stereotype.Service;
import cn.gilight.task.job.bean.Plan;
import cn.gilight.task.service.TaskService;
@Service(value = "taskService")
public class TaskServiceImpl implements TaskService {
    @Autowired
    private SchedulerFactoryBean schedulerFactoryBean;
    private Scheduler scheduler = null;
    public void setSchedulerFactoryBean(SchedulerFactoryBean schedulerFactoryBean) {
        this.schedulerFactoryBean = schedulerFactoryBean;
        scheduler = schedulerFactoryBean.getScheduler();
    }
    @Override
    public void updateOrInsert(Plan plan) throws Exception {
        // 这里获取任务信息数据
        TriggerKey triggerKey = TriggerKey.triggerKey(plan.getName(), plan.getGroup_());
        // 获取trigger，即在spring配置文件中定义的 bean id="myTrigger"
        CronTrigger trigger = (CronTrigger) scheduler.getTrigger(triggerKey);
        if (null == trigger) {
            addJob(plan);
        } else {
            updateOrInsertJob(plan);
        }
    }
    @Override
    public void updateOrInsertJob(Plan plan) throws Exception {
        // 采用的方式是：先删除后新增
        this.delJob(plan);
        this.addJob(plan);
    }
    @SuppressWarnings({ "unchecked", "rawtypes" })
    @Override
    public void addJob(Plan plan) throws Exception {
        // 初始化scheduler
        scheduler = schedulerFactoryBean.getScheduler();
        Class clazz = Class.forName(plan.getJobClass());
        JobDetail jobDetail = JobBuilder.newJob(clazz).withIdentity(plan.getName(), plan.getGroup_()).build();
        jobDetail.getJobDataMap().put("planKey", plan);
        // 表达式调度构建器
        CronScheduleBuilder scheduleBuilder = CronScheduleBuilder.cronSchedule(plan.getCron_expression());
        // 按新的cronExpression表达式构建一个新的trigger
        CronTrigger trigger = TriggerBuilder.newTrigger().withIdentity(plan.getName(), plan.getGroup_()).withSchedule(scheduleBuilder).build();
        scheduler.scheduleJob(jobDetail, trigger);
        // job.getIsTrue()为0表示停止
        if ("0".equals(plan.getIsTrue())) {
            this.stopJob(plan);
        }
    }
    @Override
    public void stopJob(Plan plan) throws Exception {
        scheduler.pauseJob(new JobKey(plan.getName(), plan.getGroup_()));
    }
    @Override
    public void startJob(Plan plan) throws Exception {
        scheduler.resumeJob(new JobKey(plan.getName(), plan.getGroup_()));
    }
    @Override
    public void delJob(Plan plan) throws Exception {
        scheduler.deleteJob(new JobKey(plan.getName(), plan.getGroup_()));
    }
    @Override
    public void runJob(Plan plan) throws Exception {
        scheduler.triggerJob(new JobKey(plan.getName(), plan.getGroup_()));
    }
}

5.SpringBeanUtils

package cn.gilight.utils;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class SpringBeanUtils {
    private static ApplicationContext ac;
    static {
        ac = new ClassPathXmlApplicationContext("classpath:applicationContext.xml");
    }
    public static <T> T getBean(Class<T> clazz, String beanName) {
        return ac.getBean(clazz, beanName);
    }
}

6.PublicJob

package cn.gilight.task.job;
import org.apache.log4j.Logger;
import org.quartz.Job;
public abstract class PublicJob implements Job {
    protected static final Logger logger = Logger.getLogger(Job.class);
}

7. OnlineEquipmentPublicJob 具体任务类的书写

package cn.gilight.task.job.impl;
import org.quartz.JobExecutionContext;
import org.quartz.JobExecutionException;
import cn.gilight.business.service.DataService;
import cn.gilight.task.job.PublicJob;
import cn.gilight.utils.SpringBeanUtils;
/**
 * 在线设备
 */
public class OnlineEquipmentPublicJob  extends PublicJob{
    private DataService dataService = SpringBeanUtils.getBean(DataService.class, "dataService");
    @Override
    public void execute(JobExecutionContext context) throws JobExecutionException {
        executePhoenix();
    }
    public void executePhoenix() {
        dataService.saveOnlineEquipment();//业务层启动任务
    }
}