java事件和侦听器，实现不好吗？

Question

我目前正在根据下面发布的代码实现自定义事件和侦听器。有人告诉我，这是一个非常肮脏的实施，需要加以改变。但是，我对java和android非常陌生，不知道当前实现有什么问题。的方式，我有它下面的工作，似乎正在做一切，我需要它也。我想知道是否有人能看一下我的代码，并就我应该修改什么和做错了什么提出一些建议。举我的例子并修改它，这样我就可以看到您在谈论什么了。

提前感谢！

/* SmartApp.java */
public class SmartApp extends Activity 
{
    private ConnectDevice cD = new ConnectDevice();
    private DataRobot dR = new DataRobot();
    private DataBuilder dB = new DataBuilder();
    private DataSender dS = new DataSender();
    public void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.intro);

    cD.addDataReceivedListener(new DataReceivedListener() {
        @Override
        public void dataReceivedReceived(DataReceivedEvent event) {
            // TODO Auto-generated method stub
            dR.analyzeData(event.getData());
        }
    });
    dR.addDataAnalyzedListener(new DataAnalyzedListener() {
        @Override
        public void dataAnalyzedReceived(DataAnalyzedEvent event) {
            // TODO Auto-generated method stub
            dB.submitData(event.getData());
        }
    });
    dB.addDataBuilderListener(new DataBuilderListener() {
        @Override
        public void dataBuilderReceived(DataBuilderEvent event) {
            // TODO Auto-generated method stub
            dS.sendData(event.getData());
        }
    });
      }
}  

/* ConnectDevice.java
 * This class is implementing runnable because i have a thread running that is checking
 * the contents of a socket. Irrelevant to events. */
public class ConnectDevice implements Runnable {

    private List _listeners = new ArrayList();
    private String data;

    /* Constructor */
    public ConnectDevice() {// does some socket stuff here, irrelevant to the events}
    public void run() {// does some socket stuff here, irrelevant to the events}

    public synchronized void addDataReceivedListener(DataReceivedListener listener) {
        _listeners.add(listener);
    }
    public synchronized void removeDataReceivedListener(DataReceivedListener listener) {
        _listeners.remove(listener);
    }
    private synchronized void fireDataReceivedEvent(String temp) {
        DataReceivedEvent dRE = new DataReceivedEvent(this, temp);
        Iterator listeners = _listeners.iterator();
        while(listeners.hasNext()) {
            ((DataReceivedListener)listeners.next()).dataReceivedReceived(dRE);
        }
    }
    public interface DataReceivedListener {
        public void dataReceivedReceived(DataReceivedEvent event);
    }
}  

/* DataRobot.java */
public class DataRobot {
    /* This class is for analyzing the data */
    private List _listeners = new ArrayList();
    private String data;
    public boolean analyzeData(String temp) {
        /* Analyze the data
         * This function analyzes the data, as explained in the OP
         * This function fires the analyzed data event when finished
             * analyzing the data.
         */
        data = temp;
        fireDataAnalyzedEvent(data); // this fires the dataanalyzedevent
        return true; //for now this will always return true
    }

    public synchronized void addDataAnalyzedListener(DataAnalyzedListener listener) {
        _listeners.add(listener);
    }
    public synchronized void removeDataAnalyzedListener(DataAnalyzedListener listener) {
        _listeners.remove(listener);
    }
    private synchronized void fireDataAnalyzedEvent(String temp) {
        DataAnalyzedEvent dRE = new DataAnalyzedEvent(this, temp);
        Iterator listeners = _listeners.iterator();
        while(listeners.hasNext()) {
            ((DataAnalyzedListener)listeners.next()).dataAnalyzedReceived(dRE);
        }
    }
    public interface DataAnalyzedListener {
        public void dataAnalyzedReceived(DataAnalyzedEvent event);
    }
}  

/* DataBuilder.java */
public class DataBuilder {
    private List _listeners = new ArrayList();
    private String data;
    public boolean submitData(String temp) {
            /* Builds the data
             * This function builds the data, as explained in the OP
             * This function fires the databuilder data event when finished
                     * building the data.
             */
        data = temp;
        fireDataBuilderEvent(data); //firing the databuilder event when finished
        return true;
    }
    public synchronized void addDataBuilderListener(DataBuilderListener listener) {
        _listeners.add(listener);
    }
    public synchronized void removeDataBuilderListener(DataBuilderListener listener) {
        _listeners.remove(listener);
    }
    private synchronized void fireDataBuilderEvent(String temp) {
        DataBuilderEvent dRE = new DataBuilderEvent(this, temp);
        Iterator listeners = _listeners.iterator();
        while(listeners.hasNext()) {
            ((DataBuilderListener)listeners.next()).dataBuilderReceived(dRE);
        }
    }
    public interface DataBuilderListener {
        public void dataBuilderReceived(DataBuilderEvent event);
    }
}  

/* DataSender.java */
/* this class has no event, because it is done firing events at this point */
public class DataSender {
    private String data;
    public boolean sendData(String temp) {
        data = temp;
        return true;
    }
}  

下面是每个事件的事件对象。我在一个单独的文件中定义了其中的每一个，不确定这是否是一个好过程。

/* DataReceivedEvent.java */
public class DataReceivedEvent extends EventObject{
    private String data;
    public DataReceivedEvent(Object source, String temp) {
        super(source);
        // TODO Auto-generated constructor stub
        data = temp;
    }
    public String getData() {
            // this function is just an accessor function
        return data;
    }
}  

/* DataAnalyzedEvent.java */
public class DataAnalyzedEvent extends EventObject{
    private String data;
    public DataAnalyzedEvent(Object source, String temp) {
        super(source);
        // TODO Auto-generated constructor stub
        data = temp;
    }
    public String getData() {
            // this function is just an accessor function
        return data;
    }
}  

/* DataBuilderEvent.java */
public class DataBuilderEvent extends EventObject {
    private String data;
    public DataBuilderEvent(Object source, String temp) {
        super(source);
        // TODO Auto-generated constructor stub
        data = temp;
    }
    public String getData() {
            // this function is just an accessor function
        return data;
    }
}

Answer 1

我不会说这是一个“非常肮脏的实施”。在我看来，使用回调/观察者/侦听器是一个很好的做法。

当我编写Android应用程序时，我喜欢将其分层，使“应用程序”是普通的旧Java，没有任何Android导入，理论上可以用于Swing应用程序、基于Java的网站等。

我使用回调的目的是允许Android代码注册对应用程序中发生的事件的兴趣。例如，在Blackjack游戏中，Activity可能会调用game.getDealer().playHand()来告诉应用程序执行交易商手动播放逻辑。当这个逻辑在应用程序中执行时，事件就会被触发，比如cardDrawn(card)、cardFlipped(card)、handTotalChanged(handTotal)等等。应用程序中的Android部分会监听这些内容，并相应地在屏幕上重新绘制东西(但它对Blackjack一无所知)。

实际上，我只是让我的活动实现了像CardListener、HandListener等接口，这样它们就可以直接接收事件(与您的做法不同)，但是您的风格并不一定是一种糟糕的方式。

Answer 2

从理论上讲，我同意@SingleShot的观点，因为您的Android应用程序中可能与Android无关，而且只要所有间接层引入的开销不会使应用程序慢太多。IMHO，在许多应用程序中，很少有适合这种描述的。

在另一篇文章中，您为一项活动提出了上述解决方案，以便与另一项活动进行沟通。在Android系统中，活动不仅仅是一些Java对象，你可以随意抛出一些Java对象。它们由操作系统管理，并具有特定的生命周期。虽然观察者/可观察的模式在某些地方是非常令人愉快的，但是在观察者/可观察的连接会产生垃圾收集问题的地方，它是不合适的。特别是，一个活动不能也不应该试图在另一个活动上保存某种类型的侦听器接口。

类似地，一个干净的观察者/可观察的模式可能会在数据库、线程、服务和其他Android现实中崩溃。

因此，在与Android隔离的纯Java代码中，您所拥有的可能是可以的。但是，除非你知道它能解决那些特定于Android的问题，否则不要到处推荐它作为解决安卓问题的解决方案。而且，当你开始尝试让你的代码在Android应用程序中工作时，如果你在试图让你的教科书模式实现在Android应用程序的约束范围内工作时遇到问题，请不要感到震惊。