Spring 通过配置向 Quartz定时任务注入service

最新推荐文章于 2024-04-12 16:07:45 发布

转载最新推荐文章于 2024-04-12 16:07:45 发布 · 937 阅读

文章标签：

#spring #quartz

Spring 专栏收录该内容

2 篇文章

订阅专栏

本文介绍如何在Spring环境中正确配置Quartz定时任务，确保Service能够成功注入。通过配置SchedulerFactoryBean的schedulerContextAsMap属性，可以实现Spring管理的Service注入；而jobDataAsMap属性则用于非Spring管理的Service注入。

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

写了一个定时任务，但是调用service会报空，原因是service注入不进去，解决办法如下：

<bean name="quartzScheduler" class="org.springframework.scheduling.quartz.SchedulerFactoryBean">   
        <property name="dataSource" ref="dataSource" />    
            
        <property name="schedulerContextAsMap">    
            <map>    
                <!-- spring 管理的service需要放到这里，才能够注入成功 -->    
                <description>schedulerContextAsMap</description>    
                <entry key="webSiteService" value-ref="webSiteService"/>    
                <entry key = "mappingService" value-ref="mappingService"/>    
                <entry key="detailService" value-ref = "detailService"></entry>   
            </map>    
        </property>    
        <property name="applicationContextSchedulerContextKey" value="applicationContextKey" />   
        <property name="configLocation" value="classpath:quartz.properties" />   
    </bean>    
        
    <bean id="jobDetail" class="org.springframework.scheduling.quartz.JobDetailBean">   
        <property name="jobClass" value = "com.fangjia.dc.quartz.MyQuartzJob"/>   
        <property name="jobDataAsMap">    
            <map>    
                <!-- 非spring管理的service放到这里，就可以注入进去 -->    
                <description>jobDataAsMap</description>    
                <!-- key 属性值，value 对应的bean -->    
                <entry key="uploader" value-ref="uploader" />    
            </map>    
        </property>    
    </bean>

这里一共注入了 bean，分别是webSiteService，mappingService，detailService和uploader，然后在MyQuartzJob中使用注入的service

public class MyQuartzJob extends QuartzJobBean {   
  
    private static final Logger logger = Logger.getLogger(MyQuartzJob.class);   
    private Uploader uploader;     
    private IService<WebSite> webSiteService;   
    private IService<Mapping> mappingService;   
    private IService<MappingDetail> detailService;   
       
    @Override  
    protected void executeInternal(JobExecutionContext context) throws JobExecutionException {  
           
        try {   
            //获取JobExecutionContext中的service对象  
            SchedulerContext skedCtx = context.getScheduler().getContext();   
            //获取SchedulerContext中的service  
            //这里的service就是通过配置文件 配置的  
            webSiteService = (IService<WebSite>)skedCtx.get("webSiteService");   
            mappingService = (IService<Mapping>)skedCtx.get("mappingService");   
            detailService = (IService<MappingDetail>)skedCtx.get("detailService");  
               
            //获取 当前的trigger 名称，  
            Trigger trigger = context.getTrigger();   
            String name = trigger.getName();   
  
            //从trigger中的jobDataMap中获取uploader  
            uploader = (Uploader) context.getJobDetail.getJobDataMap().get("uploader");   
  
            WebSite webSite = webSiteService.findByName(name);   
            logger.info("webSite id:" + webSite.getId());   
            loadMappingConfiguration(webSite);   
            uploader.process(webSite, typeXpathFiels, domainMap);   
        } catch (SchedulerException e) {   
            e.printStackTrace();   
        } catch (Exception e) {   
            e.printStackTrace();   
        }   
           
    }   
    //属性的 get set方法  
}

//---------------------------割割割割割割--------------------------------下面这部分我没有用到---------------------------
定时任务的动态管理，没有配置的spring文件中
采用页面传值，实现quartz定时任务的CRUD

public void schedule(String name, CronExpression cronExpression,String group) throws SchedulerException {  
           
        //添加Job 给scheduler,允许 replace  
           
        jobDetail.setRequestsRecovery(true);   
        //孤立线程 不再保存在DB中  
        jobDetail.setDurability(false);   
        jobDetail.setName(name);   
        logger.info(" is  durable:" + jobDetail.isDurable());   
        //设置replace为true，相同名字的job存在，则替换  
        scheduler.addJob(jobDetail, true);   
           
        CronTrigger cronTrigger = new CronTrigger(name, group, jobDetail.getName(), Scheduler.DEFAULT_GROUP);  
        cronTrigger.setCronExpression(cronExpression);   
        scheduler.scheduleJob(cronTrigger);   
        scheduler.rescheduleJob(cronTrigger.getName(), cronTrigger.getGroup(), cronTrigger);  
    }   
  
    public void pauseTrigger(String triggerName, String group) throws SchedulerException {  
        logger.info("pause triggerName:" + triggerName);   
        scheduler.pauseTrigger(triggerName, group);   
    }   
  
    public void resumeTrigger(String triggerName, String group) throws SchedulerException {  
        logger.info("resume trigger:" + triggerName + " group:" + group);   
        scheduler.resumeTrigger(triggerName, group);   
    }   
  
    public boolean removeTrigdger(String triggerName, String group) throws SchedulerException {  
        scheduler.pauseTrigger(triggerName, group);   
        return scheduler.unscheduleJob(triggerName, group);   
    }

quartz.properties设置

org.quartz.scheduler.instanceName = DefaultQuartzScheduler     
org.quartz.scheduler.rmi.export = false    
org.quartz.scheduler.rmi.proxy = false    
org.quartz.scheduler.wrapJobExecutionInUserTransaction = false    
    
org.quartz.threadPool.class = org.quartz.simpl.SimpleThreadPool     
org.quartz.threadPool.threadCount = 10    
org.quartz.threadPool.threadPriority = 5    
org.quartz.threadPool.threadsInheritContextClassLoaderOfInitializingThread = true   
    
org.quartz.jobStore.misfireThreshold = 60000    
    
#org.quartz.jobStore.class = org.quartz.simpl.RAMJobStore     
    
org.quartz.jobStore.class = org.quartz.impl.jdbcjobstore.JobStoreTX     
org.quartz.jobStore.driverDelegateClass=org.quartz.impl.jdbcjobstore.StdJDBCDelegate    
org.quartz.jobStore.tablePrefix = QRTZ_       
org.quartz.jobStore.isClustered = false       
org.quartz.jobStore.maxMisfiresToHandleAtATime=1      
#org.quartz.jobStore.txIsolationLevelReadCommitted = true