在接口的兩個實現之間移動公共代碼

Question

我有一個名為處理器的接口：

public interface Processor {
    MyResponse process(Request request, String id);
}

我有這個處理器的兩種實現，一種是同步的，另一種是異步的（都是 Spring 服務類）：

這是同步版本，完成工作並給出完全填充的響應：

@Service
public class SynchrnousProcess implements Processor {

    @Override
    public MyResponse process(Request request, String id) {
        Job job = getJob(request);
        JobParameters parameter = buildParams(request, id);
        JobExecution jobExecution = kickOfJob(job, request, parameter);
        return buildResponse(request, trackingId, jobExecution);
    }    
}

這是異步版本，它將請求添加到阻塞隊列：

@Service
public class AsyncProcess implements Processor {


     private BlockingQueue<Pair> requestQueue = new ArrayBlockingQueue<>(100);

    @Override
    public MyResponse process(Request request, String id) {
     //add request to requestQueue 
    }    

    public void completeProcess() {
    //take data from queue and process
    log.info("start process !!!!!!!!!!!!!!!");
    if (!CollectionUtils.isEmpty(requestQueue)) {
        requestQueue.stream().forEach(pair -> {
            String trackingId = String.valueOf(pair.getFirst());

            FeedDto feedDto = (FeedDto) pair.getSecond();
            Request request = feedDto.getRequest();
            Job job = getJob(request);

            JobParameters parameter = getJobParameters(request, trackingId);
            JobExecution jobExecution = runJob(job, request, parameter);
    }
}

如您所見， completeProcess()從隊列中取出數據並處理作業。 與獲取工作有關的通用代碼，構建參數在同步運行和異步之間重復。

另一個線程在后台運行completeProcess() 。

我想實現簡潔的設計並將兩個接口實現共享的通用代碼移動到一個地方。 我怎樣才能實現我想要實現的目標？ 看看在這種情況下使用的設計模式的例子真的很有幫助嗎？

此外，任何關於應該在哪里啟動 ExecutorService 來處理排隊的請求以及應該如何啟動處理這些請求的線程的建議都會有很大幫助。

Answer 1

您可以設計接口，因為它必須執行異步操作。 例如：

public interface Callback() {
    void onResponse(MyResponse mr);
}

public void Processor {
    void process(Request request, String id, Callback callback);
}

@Service
public class SynchrnousProcess implements Processor {

    @Override
    public void process(Request request, String id, Callback callback) {
        Job job = getJob(request);
        JobParameters parameter = buildParams(request, id);
        JobExecution jobExecution = kickOfJob(job, request, parameter);
        MyResponse r = buildResponse(request, trackingId, jobExecution);
        callback.onResponse(r);
    }    
}

@Service
public class AsyncProcess implements Processor {


     private BlockingQueue<Pair> requestQueue = new ArrayBlockingQueue<>(100);

    @Override
    public void process(Request request, String id, Callback callback) {
     //add request and callback to requestQueue 
    }    

}

我不知道誰將處理隊列，但肯定誰將使用處理器不必擔心調用是否同步。

這是與您在 C# 中使用異步等待的最相似的方法。 在 C# 中，即使在同步情況下，您也必須返回 Task < MyResponse >。 那么消費者就會一直認為調用是異步的。