Question

我有生产者获取数据 A，生产数据 B 并发送它

    public interface Producer<T>{
        void produce(T data);
        void flush();
    }

    public class DataBaseProducer implements Producer<String>{
        List<String> producedData = new ArrayList<>();

        // create data
        public void produce(String data){
            producedData.add(transformData(data));
        }

       // send created data
        public void flush(){
           sendDataToDatabase(producedData);
        }
    }

   
   public class MessageProducer implements Producer<String>{
        public void produce(String data){
           String line =transformData(data)
           sendDataToMessageQueue(line);
        }

        public void flush(){
        }
   }

public static void main(String[] args) {
    // get producer
    Producer producer = getProducer(producerName)
    BufferedReader reader;
    try {
        reader = new BufferedReader(new FileReader(file..));
        String line = reader.readLine();
        while (line != null) {
            producer.produce(line)
            line = reader.readLine();
        }
        reader.close();
        producer.flush()
    } catch (IOException e) {
        e.printStackTrace();
    }
}

为了证明我的问题，假设我有上面这样的制作人。第一个加载所有数据，然后在完成后立即批量发送，第二个立即发送数据（因此它不会批量发送数据，但是每当创建新数据时它都会立即发送）

大多数生产者会在每次加载数据后发送数据，但很少有人会立即发送。如果生产者立即发送数据，那么 flush() 方法保持为空。然而，这似乎是一种不好的做法，并且可能违反了一些 OOP 原则。实现此目的的正确方法是什么？

感谢您的回答！

Answer 1

在我看来，在检查 main() 代码后，我认为 MessageProducer 并不是真正的 Producer，因为方法 produce 实际上是 produces 和flushes 同时。

但是，既然您似乎需要以同样的方式独立对待从 getProducer(producerName) 获得的东西，那么您可以这样做：

public class MessageProducer implements Producer<String> {

    private boolean flushNeeded;
    private String line;

    public void produce(String data){
       line =transformData(data)
       flushNeeded = true;
       flush();
    }

    public void flush(){
        if (flushNeeded) {
            sendDataToMessageQueue(line);
            flushNeeded = false;
        }
    }
 }

但以我的拙见，将 flush() 实现留空并没有真正产生任何显着不同，如果不是简单地使代码对读者更清晰一点（阅读空的 flush()实际上可能会导致错误地认为您的实现永远不会刷新，而它会刷新但只是进入 produce 方法）。

一个类不实现方法的接口

1 个答案: