无法自动装配JobLauncher，始终返回null

Question

我试图将每个作业与一个线程链接，以便我可以用不同的cron值同时启动多个作业，但jobLauncher总是为空。

我试图在configuartion类中将jobLauncher创建为bean，但它从未起作用。

@Component
public class MyTask extends Thread {

   @Autowired
   private ApplicationContext context;

   @Autowired
   private JobLauncher jobLauncher;

   @Autowired
   private Batchconfig config;


   public void run() {
     Jobs job = Scheduler.listLinked.get(this);
     if (job != null && job.isState()) {
        JobParameters jobParameters = new JobParametersBuilder().addLong("time", System.currentTimeMillis())
                .addString("param", job.getParam()).toJobParameters();
        try {
            JobExecution jobExecution = jobLauncher.run(config.execute(job.getName()), jobParameters);
            System.out.println("Job's Status:::" + jobExecution.getStatus());
        } catch (JobExecutionAlreadyRunningException | JobRestartException | JobInstanceAlreadyCompleteException
                | JobParametersInvalidException e) {
            e.printStackTrace();
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
  }

}

@Component
public class Scheduler implements SchedulingConfigurer {


   @Override
   public void configureTasks(ScheduledTaskRegistrar taskRegistrar) {
     set();
     for (Jobs j : list) {
        MyTask th = new MyTask();
        listLinkedInverse.put(j, th);
        listLinked.put(th, j);
        taskRegistrar.addCronTask(th, j.getCron());
     }
   }

}

例外：

java.lang.NullPointerException
   at com.generator.config.batch.scheduler.MyTask.run(MyTask.java:39)
   at org.springframework.scheduling.support.DelegatingErrorHandlingRunnable.run(DelegatingErrorHandlingRunnable.java:54)
   at org.springframework.scheduling.concurrent.ReschedulingRunnable.run(ReschedulingRunnable.java:93)
   at java.util.concurrent.Executors$RunnableAdapter.call(Unknown Source)
   at java.util.concurrent.FutureTask.run(Unknown Source)
   at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.access$201(Unknown Source)
   at java.util.concurrent.ScheduledThreadPoolExecutor$ScheduledFutureTask.run(Unknown Source)
   at java.util.concurrent.ThreadPoolExecutor.runWorker(Unknown Source)
   at java.util.concurrent.ThreadPoolExecutor$Worker.run(Unknown Source)
   at java.lang.Thread.run(Unknown Source)

Answer 1

MyTask实例是手动创建的（在MyTask th = new MyTask()中），不是由Spring创建的，因此将不会执行依赖注入，并且自动装配的JobLauncher将为null。

您需要创建一个类型为MyTask的bean（以便正确注入其依赖项，然后将其作为协作者注入到您的Scheduler类中。

作为旁注，这不是同时启动多个作业的理想方法。您正在为每个线程创建一个JobLauncher，默认情况下，该线程又使用SyncTaskExecutor。您可以做的是创建一个JobLauncher并配置一个线程池以同时启动作业，例如：

@Bean
public JobLauncher jobLauncher() {
   SimpleJobLauncher jobLauncher = new SimpleJobLauncher();
   jobLauncher.setJobRepository(jobRepository());
   jobLauncher.setTaskExecutor(new SimpleAsyncTaskExecutor()); // or use ThreadPoolTaskExecutor
   jobLauncher.afterPropertiesSet();
   return jobLauncher;
}

您可以在参考文档的Configuring a JobLauncher部分中找到更多详细信息。

Answer 2

我尝试过此解决方案，并且有效

@Component
public class Scheduler {
        @Autowired
private ApplicationContext context;


@Autowired
public static JobLauncher jobLauncher;

@Autowired
public static Batchconfig config;

@Autowired
private JobService jobService;

private final ScheduledExecutorService scheduler =
         Executors.newScheduledThreadPool(1);

public static Map<ScheduledFuture<Jobs>, Jobs> listLinked = new HashMap<>();
public static Map<Jobs, ScheduledFuture<Jobs>> listLinkedInverse = new HashMap<>();
List<Jobs> list;

@PostConstruct
public void init() {
    list = jobService.findAll();
    for (Jobs j : list) {
        if(j.isState()) {
            MyTask th = new MyTask(j);
            context.getAutowireCapableBeanFactory().autowireBean(th);
            ScheduledFuture<Jobs> jobHandler = (ScheduledFuture<Jobs>) scheduler.scheduleAtFixedRate(th, 0, 2, TimeUnit.SECONDS);
            listLinkedInverse.put(j, jobHandler);
            listLinked.put(jobHandler, j);
        }

    }
}

public void launchJob(Jobs myJob){
    MyTask th = new MyTask(myJob);
    context.getAutowireCapableBeanFactory().autowireBean(th);
    ScheduledFuture<Jobs> jobHandler = (ScheduledFuture<Jobs>) scheduler.scheduleAtFixedRate(th, 0, 2, TimeUnit.SECONDS);
    listLinkedInverse.put(myJob, jobHandler);
    listLinked.put(jobHandler, myJob);

}

public void cancelJob(Jobs j) {
    listLinkedInverse.get(j).cancel(true);
    listLinked.remove(listLinkedInverse.get(j));
    listLinkedInverse.remove(j);


}
}



@Component
public class MyTask extends Thread {

    @Autowired
    private JobLauncher jobLauncher;

    private Jobs job;

    @Autowired
    private Batchconfig config;

    public MyTask() {
    }

    public MyTask(Jobs job) {
        this.job = job;
    }
    public void run() {
            JobParameters jobParameters = new JobParametersBuilder().addLong("time", System.currentTimeMillis())
                    .addString("param", job.getParam()).toJobParameters();
            try {
                JobExecution jobExecution = jobLauncher.run(config.execute(job.getName()), jobParameters);
                System.out.println("Job's Status:::" + jobExecution.getStatus());
            } catch (JobExecutionAlreadyRunningException | JobRestartException | JobInstanceAlreadyCompleteException
                    | JobParametersInvalidException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
    }

}