Listeners observer 设计模式与 Handler

Question

我最近在处理一个我不确定如何回答的问题。我为一些我想执行的 AsyncTask 写了一个代码示例。我在网上某处读到有人已经将 AsyncTask 和 Handler 实现为内部 classes，我想稍微扩展一下并减少耦合，所以我将它们分开 class 这样我就可以重复使用它们不止一个 Activity。因为我必须在每个 Activity 上做一些不同的 UI 事情，所以我决定让这些活动实现一个接口，这样我就可以用相同的方法对每个事件做出反应。

我不明白的是为什么我需要处理程序对象来处理事件发生的消息？我不能只使用监听器观察者模式吗？然后我问自己但无法理解网络上的答案的问题是我的侦听器观察器实现与我们从 Android.

获得的处理程序对象之间有什么区别

这是我的代码示例：

Activity 1:

public class SomeActivity extends Activity implements MyListener{

    MyAsyncTask myTask;
    MyHandler handler;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        handler = new MyHandler();
        myTask = new MyAsyncTask(handler);
        // initilize the activity views etc...
    }

    @Override
    public void do1(){
        // DO UI THINGS FOR ACTIVITY 1 IN A CALLBACK TO DO1 EVENT
    }

    @Override
    public void do2(){
        // DO UI THINGS FOR ACTIVITY 1 IN A CALLBACK TO DO2 EVENT
    }
}

Activity 2:

public class OtherActivity extends Activity implements MyListener{

    MyAsyncTask myTask;
    MyHandler handler;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        handler = new MyHandler();
        myTask = new MyAsyncTask(handler);
        // initilize the activity views etc...
    }

    @Override
    public void do1(){
        // DO UI THINGS FOR ACTIVITY 2 IN A CALLBACK TO DO1 EVENT
    }

    @Override
    public void do2(){
        // DO UI THINGS FOR ACTIVITY 2 IN A CALLBACK TO DO2 EVENT
    }
}

侦听器接口：

public interface MyListener{
    void do1();
    void do2();
}

AsyncTask 实现：

public class MyAsyncTask extends AsyncTask<Void,Void,String>{
    private MyModel m;

    public MyAsyncTask(Handler h){
        m = new MyModel();
        m.setHandler(h);
    }

    protected String doInBackground(Void... params) {
        // do something in background with MyModel m
        return null;            
    }
}

处理程序实现：

public class MyHandler extends Handler {

    Vector<MyListener> listeners = new Vector<>();

    @Override
    public void handleMessage(Message msg) {
        switch(msg.what){
            case 1:
                // do something for case 1
                fireMethod1();
                break;
            case 2:
                // do something for case 2
                fireMethod2();
                break;
        } 
    }

    public void registerListener(MyListener l){
        listeners.add(l);
    }

    public void unregisterListener(MyListener l){
        listeners.remove(l);
    }

    private void fireMethod1(){
        for(MyListener l : listeners){
            l.do1();
        }
    }

    private void fireMethod2(){
        for(MyListener l : listeners){
            l.do2();
        }
    }

}

我创建的一些演示模型：

public class MyModel{

    private Handel h;

    public MyModel(){
        // at some point send message 1 or message 2 ...
    }

    public void setHandler(Handler h){
        this.h = h;
    }

    private void sendMessage1(){
        h.obtainMessage(1, null);
    }

    private void sendMessage2(){
        h.obtainMessage(2, null);
    }
}

如果代码太难看可以告诉我，如果不想看代码请帮我解答Handler和listening events有什么区别观察者模式？对于同一个问题，他们的解决方案有很大不同吗？谢谢！

Answer 1

处理程序是 UI 线程组件。如果你想触摸一些UI，使用简单的监听器可能会导致CalledFromWrongThreadException。

AsyncTask 虽然有 onPreExecute、onPostExecute 和 onProgressUpdate，它们只是方法，在 UI 线程上运行。 doInBackground 在单独的线程上运行

Answer 2

what is the difference between Handler and listening to events with the observer pattern?

不同之处在于，当您使用侦听器时，您会在同一线程上同步调用一个方法。当您使用 Handler 时，您会同步向 MessageQueue 添加一条消息，但它仅在队列中已存在的消息之后才被处理。

例如，如果您正在使用 UI 处理程序并且您已经在 activity 上调用了 finish() 然后添加了您的消息，它将被插入到 [=13= 之后] 和 onDestroy()。您无法通过侦听器实现此目的。

处理程序的优点是您只需将消息添加到队列中，而不用关心线程。您可以轻松地从后台线程向 UI 处理程序添加消息。如果您从后台线程使用侦听器，它将在后台线程上同步调用。

are they pretty much different solutions for same problem?

不，他们不是。我认为处理程序可以帮助您解耦 android 对 Android 至关重要的组件。如果您使用侦听器，您将仅依赖强引用，这在某些情况下是不可能的，因为您可能会泄漏内存。

Listeners observer 设计模式与 Handler

Listeners observer design pattern with Handler

java

android

observer-pattern

android-asynctask

android-handler