java事件、处理程序和侦听器问题

Question

编辑:在我的作品中，我实际上能够让它发挥作用，形成一个很好的例子。接受的答案是我的例子，如果您需要帮助或有建议，请随时留言。。

我对java非常陌生，刚刚被介绍给事件、处理程序和侦听器。我已经在网上找到了3个很好的参考资料，但是我仍然不知道如何实现它来解决我的问题。(同时，这也是在android上开发的。我怀疑这会改变这个例子，但我想我会让你知道)

链接到我发现有帮助的站点：

快乐对象

样库

爪哇世界

下面是我所需要的，使用任意的名称和示例，而不是在这里重复我的数百行代码：

这里是我的班级和他们的用途：

MainUI -这将创建用户界面

连接-该类执行到套接字的连接并开始接收数据

DataRobot -这个类对接收到的数据执行计算，并决定如何处理它。

DataBuilder -这个类从datarobot收集数据，一旦达到一定数量，它就将该块发送到远程数据库。

DataSender -这个类发送由数据库程序发送给它的数据。

我用线程实现了这个..。=(

我认识的人建议我用活动。他给了我一个很好的解释，然而，在30分钟内，我不知道如何实现它，除非看到一些更好的例子(他也是在C#背景下发言)。我想知道，在java方面有一些很好经验的人是否可以使用上面的内容，并向我展示我需要做的事情。

以下是我计划好的活动：

dataReceived -此事件发生在connect中，当connect收到数据时，该事件触发，当该事件触发时，它将数据发送给数据机器人处理程序()函数。

dataAnalyzed -此事件发生在datarobot中，当datarobot处理给它的数据时，此事件触发，当此事件触发时，该事件将数据发送给数据库程序。

databuilder --此事件发生在databuilder中，当databuilder接收到一定数量的数据并准备发送数据时，此事件触发，当此事件触发时，该事件将数据发送到datasender。

我在这里寻找一个例子，或者至少讨论一下应该做什么。我找到的例子之一就是“开心脸对象”的例子，它非常好。但是，由于我对java和事件非常陌生，在我的设计中实现它仍然有困难。如有可能，请协助我，我们将不胜感激。此示例还将帮助整个社区，因为缺少优秀的java事件示例。

谢谢，如果您需要更多的信息，请告诉我。

Answer 1

我已经做到这一点，这似乎是一个很好的例子。我会在下面发布代码，希望有一天它能帮助到某人！如果你看到我做错了什么，或者知道更好的方法，发表一些评论，这样我就能改正它。谢谢

基本上，您要创建的每个事件都需要一个事件对象、侦听器接口、AddListener函数、RemoveListener函数、FireEvent函数和E 110侦听器E 211。所有这些都可以在下面的例子中看到。如果您有任何问题，请在评论中发表意见，如果这对您有帮助，请随意投票！

/* 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 2

您对Java非常陌生--我认为您使这件事变得过于复杂，并试图一次吞下太多东西。

忘了你的宏伟设计吧。忘了UI吧。别管机器人了。

从一个玩具问题开始，然后建立起来。

您能否创建一个响应事件的侦听器类和一个生产者类来发送该事件？你能看到正在采取的行动吗？如果你做不到，你就走不了多远。当您有一个工作，转移到下一个，看看您的设计是否可以使这些更简单的对象。只有当整个工作正常时，您才应该担心绑定Android和UI元素。

从简单的POJO模型开始，您将获得更快的速度。