Java使用Java函数表达式提取公共代码

除一行代码外，有两个函数具有相同的代码段

public ResponseEntity<String> deleteJob(String jobName, String jobGroup) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(jobGroup, jobName);

        if (!schedulerFactoryBean.getScheduler().checkExists(jobKey))
            return new ResponseEntity<>(format(JOBNAME_JOBGROUP_COMMON_LOG.concat("does not exists"), jobName, jobGroup), HttpStatus.BAD_REQUEST);

        schedulerFactoryBean.getScheduler().deleteJob(jobKey);//Different Code line
        return new ResponseEntity<>(format(JOBNAME_JOBGROUP_COMMON_LOG.concat("deleted Successfully"), jobName, jobGroup), HttpStatus.OK);
    }

public ResponseEntity<String> resumeJob(String jobName, String jobGroup) throws SchedulerException {
        JobKey jobKey = JobKey.jobKey(jobGroup, jobName);

        if (!schedulerFactoryBean.getScheduler().checkExists(jobKey))
            return new ResponseEntity<>(format(JOBNAME_JOBGROUP_COMMON_LOG.concat("does not exists"), jobName, jobGroup), HttpStatus.BAD_REQUEST);

        schedulerFactoryBean.getScheduler().resumeJob(jobKey);//Different Code line
        return new ResponseEntity<>(format(JOBNAME_JOBGROUP_COMMON_LOG.concat("deleted Successfully"), jobName, jobGroup), HttpStatus.OK);
    }

public ResponseEntity deleteJob（字符串jobName，字符串jobGroup）引发ScheduleException{
JobKey JobKey=JobKey.JobKey（作业组，作业名称）；
如果（！schedulerFactoryBean.getScheduler（）.checkExists（jobKey））
返回新的响应属性（格式（JOBNAME\u JOBGROUP\u COMMON\u LOG.concat（“不存在”）、JOBNAME、JOBGROUP）、HttpStatus.BAD\u请求）；
schedulerFactoryBean.getScheduler（）.deleteJob（jobKey）；//不同的代码行
返回新的响应属性（格式（JOBNAME\u JOBGROUP\u COMMON\u LOG.concat（“已成功删除”）、JOBNAME、JOBGROUP）、HttpStatus.OK）；
}
public ResponseEntity resumeJob（字符串jobName，字符串jobGroup）引发ScheduleException{
JobKey JobKey=JobKey.JobKey（作业组，作业名称）；
如果（！schedulerFactoryBean.getScheduler（）.checkExists（jobKey））
返回新的响应属性（格式（JOBNAME\u JOBGROUP\u COMMON\u LOG.concat（“不存在”）、JOBNAME、JOBGROUP）、HttpStatus.BAD\u请求）；
schedulerFactoryBean.getScheduler（）.resumeJob（jobKey）；//不同的代码行
返回新的响应属性（格式（JOBNAME\u JOBGROUP\u COMMON\u LOG.concat（“已成功删除”）、JOBNAME、JOBGROUP）、HttpStatus.OK）；
}

我想从这两个函数中删除重复的代码

一个简单的解决方案是编写第三个公共函数并从两个函数调用它。不过，我想知道是否有办法，我可以使用Lambda表达式传递不同的代码功能

差不多

public ResponseEntity<String> processJob(String jobName, String jobGroup, Function<String,String> jobfunction) {
        JobKey jobKey = JobKey.jobKey(jobGroup, jobName);

        if (!schedulerFactoryBean.getScheduler().checkExists(jobKey))
            return new ResponseEntity<>(format(JOBNAME_JOBGROUP_COMMON_LOG.concat("does not exists"), jobName, jobGroup), HttpStatus.BAD_REQUEST);

        jobfunction.apply(jobKey);//Apply the required code behaviour
        return new ResponseEntity<>(format(JOBNAME_JOBGROUP_COMMON_LOG.concat("deleted Successfully"), jobName, jobGroup), HttpStatus.OK);
    }

public ResponseEntity processJob（字符串jobName、字符串jobGroup、函数jobfunction）{
JobKey JobKey=JobKey.JobKey（作业组，作业名称）；
如果（！schedulerFactoryBean.getScheduler（）.checkExists（jobKey））
返回新的响应属性（格式（JOBNAME\u JOBGROUP\u COMMON\u LOG.concat（“不存在”）、JOBNAME、JOBGROUP）、HttpStatus.BAD\u请求）；
jobfunction.apply（jobKey）；//应用所需的代码行为
返回新的响应属性（格式（JOBNAME\u JOBGROUP\u COMMON\u LOG.concat（“已成功删除”）、JOBNAME、JOBGROUP）、HttpStatus.OK）；
}

然后调用函数作为

processJob(jobName,jobGroup, <lambda expression with delete/resume function calling>)

processJob（作业名称、作业组）

您可以使用java中的

函数

类型：

表示接受一个参数并生成结果的函数

---

也许不是最好的，但这可能是一种方法，您可以将布尔值添加到参数列表中，以决定要执行的操作

public ResponseEntity<String> processJob(String jobName, String jobGroup,boolean wantDelete) throws SchedulerException {
    JobKey jobKey = JobKey.jobKey(jobGroup, jobName);

    if (!schedulerFactoryBean.getScheduler().checkExists(jobKey))
        return new ResponseEntity<>(format(JOBNAME_JOBGROUP_COMMON_LOG.concat("does not exists"), jobName, jobGroup), HttpStatus.BAD_REQUEST);

    if(wantDelete)
    schedulerFactoryBean.getScheduler().deleteJob(jobKey);
    else 
       schedulerFactoryBean.getScheduler().resumeJob(jobKey);

    return new ResponseEntity<>(format(JOBNAME_JOBGROUP_COMMON_LOG.concat("deleted Successfully"), jobName, jobGroup), HttpStatus.OK);
}

public ResponseEntity processJob（字符串jobName、字符串jobGroup、布尔wantDelete）引发ScheduleException{
JobKey JobKey=JobKey.JobKey（作业组，作业名称）；
如果（！schedulerFactoryBean.getScheduler（）.checkExists（jobKey））
返回新的响应属性（格式（JOBNAME\u JOBGROUP\u COMMON\u LOG.concat（“不存在”）、JOBNAME、JOBGROUP）、HttpStatus.BAD\u请求）；
if（wantDelete）
schedulerFactoryBean.getScheduler（）.deleteJob（jobKey）；
其他的
schedulerFactoryBean.getScheduler（）.resumeJob（jobKey）；
返回新的响应属性（格式（JOBNAME\u JOBGROUP\u COMMON\u LOG.concat（“已成功删除”）、JOBNAME、JOBGROUP）、HttpStatus.OK）；
}

如何使用枚举来简化调度程序可以执行的所有可能操作

enum Action {
    DELETE, RESUME
}

并进一步将如何处理作业的意识作为一个参数传递下去--

---

请告诉我你是如何使用这些函数的。这里没有第三种处理状态，比如

开始

，

删除

，

恢复

。@Naman它只是结合了OP给出的两种方法，如果有第三件事要做，它就不起作用了，我为什么说这可能不是最好的解决方案，我不是一个专家的想法，所以在我的回答中我想指出OP应该寻找更好的解决方案，如果他没有得到，那么他可以选择我的

public ResponseEntity<String> processJob(String jobName, String jobGroup, Action action) throws SchedulerException {
    JobKey jobKey = JobKey.jobKey(jobGroup, jobName);

    if (!schedulerFactoryBean.getScheduler().checkExists(jobKey))
        return new ResponseEntity<>(format(JOBNAME_JOBGROUP_COMMON_LOG.concat("does not exists"), jobName, jobGroup), HttpStatus.BAD_REQUEST);

    performSchedulerAction(schedulerFactoryBean.getScheduler(), jobKey, action);
    return new ResponseEntity<>(format(JOBNAME_JOBGROUP_COMMON_LOG.concat("deleted Successfully"), jobName, jobGroup), HttpStatus.OK);
}

private void performSchedulerAction(Scheduler scheduler, JobKey jobKey, Action action) {
    switch (action) {
        case DELETE -> scheduler.deleteJob(jobKey);
        case RESUME -> scheduler.resumeJob(jobKey);
        default -> throw new IllegalArgumentException("no such case");
    }
}