时间戳

首页 > 解决方案 > 一个类不实现方法的接口

java - 一个类不实现方法的接口

问题描述

我有生产者获取数据 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 原则。实现这一点的正确方法是什么？

感谢您的回答！

标签： javaoop

解决方案

在我看来，在检查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方法）。

推荐阅读