mvp思想设计- handler主导

mvp是一种设计思想，但是我确实也见过不少的架构，各种各样，最近发现了一种新的写法，应该是一种旧写法，主要是我以前没有这么写过，打算写下来总结下。

以前过多的使用Rxjava来做的m层和p层之间的通信问题，这个是通过handler+接口 的方式处理。可以研究下；

首先看看v层

public class MainActivity extends AppCompatActivity implements MainPresenter.MainInterface {

    public MainPresenter presenter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        this.findViewById(R.id.viewBtn).setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View v) {
                presenter = new MainPresenter();
                presenter.setMainInterface(MainActivity.this);
                presenter.exe();
            }
        });
    }

    @Override
    public void refreshUi() {
        ((TextView)this.findViewById(R.id.tv)).setText("成功");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        presenter.onDestroy();
    }
}

下面是p层

public class MainPresenter {
    private MainInterface mListener;
    private LocalEvent mLocalEvent;
    private HashMap<Integer, LocalEvent.RunnableEvent> mEvents;
    private static final int UPDATE_BADGE = 0x000001;

    public interface MainInterface{
        void refreshUi();
    }
    public void setMainInterface(MainInterface listener){
        mListener = listener;
    }

    private Handler mHandler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            int what = msg.what;
            switch (what) {
                case UPDATE_BADGE:
                    // 接收到消息后刷新红点
                    mListener.refreshUi();
                    break;
                default:
                    break;
            }
        }
    };

    public MainPresenter(){
        // TODO: 2018/5/31 初始化事件容器
        mLocalEvent = new LocalEvent() {
            @Override
            protected Map<Integer, LocalEvent.RunnableEvent> registerEvents() {
                if (mEvents == null) {
                    mEvents = new HashMap<>();
                }
                registerRunnableEvents(mEvents);
                return mEvents;
            }
        };
        // TODO: 2018/5/31 注册该事件 去执行该任务，通过LocalEventManager调用LocalEvent内部方法来判断是否存在
        LocalEventManager.getInstance().registerLocalEvent(mLocalEvent);
    }

    public void exe(){
        MainDao dao = new MainDao();
        dao.exe();
    }

    // TODO: 2018/5/31 处理每一个事件完成的回调
    protected void registerRunnableEvents(Map<Integer, LocalEvent.RunnableEvent> events) {
        // TODO: 2018/5/31 将key和对应的回调方到集合中
        events.put(LocalEvent.Events.EVENT_UPDATE_UI, new LocalEvent.RunnableEvent() {
            @Override
            public void run(Object data) {
                // 延迟刷新，主要解决同时大量收到消息时，页面卡顿的问题
                mHandler.sendEmptyMessage(UPDATE_BADGE);
            }
        });
    }

    public void onDestroy() {
        mHandler.removeCallbacksAndMessages(null);
        LocalEventManager.getInstance().unregisterLocalEvent(mLocalEvent);
    }
}

而p层设计了两个类，来处理与m层的通信。

/**
 * Created by malei on 2018/5/31.
 */
// TODO: 2018/5/31 这相当于一个记事本，每一个任务和一页做对应
public abstract class LocalEvent {

    private Map<Integer, RunnableEvent> mEvents; //内部存放了所有的p层工作的任务
    protected abstract Map<Integer, RunnableEvent> registerEvents();

    public interface RunnableEvent {
        void run(Object data);
    }

    // TODO: 2018/5/31 执行一个任务 ，然后完成后通过回调进行通知
    public void executeEvents(int event, Object data) {
        if (mEvents == null) {
            mEvents = registerEvents();
        }
        if (mEvents != null && !mEvents.isEmpty() && mEvents.containsKey(event)) {
            RunnableEvent runnable = mEvents.get(event);
            runnable.run(data);
        }
    }

    // TODO: 2018/5/31 通过key判断是否有该任务
    public boolean containsEvent(int event) {
        if (mEvents == null) {
            mEvents = registerEvents();
        }
        if (mEvents != null && !mEvents.isEmpty()) {
            if (mEvents.containsKey(event)) {
                return true;
            }
        }
        return false;
    }

    // TODO: 2018/5/31 任务的分类
    public interface Events {
        int EVENT_UPDATE_UI                        = 0x10000001;
    }
}

/**
 * Created by malei on 2018/5/31.
 */
public class LocalEventManager {

    private static final int MSG = 1;
    private final ArrayList<LocalEvent> mLocalEvents = new ArrayList<>();
    private final Handler mHandler;

    private LocalEventManager() {
        mHandler = new Handler(Looper.getMainLooper()) {
            @Override
            public void handleMessage(Message msg) {
                switch (msg.what) {
                    case MSG:
                        executePendingEvents(msg.arg1,msg.obj);
                        break;
                }
            }
        };
    }

    private static class LocalEventManagerHolder {
        private static final LocalEventManager sInstance = new LocalEventManager();
    }

    public static LocalEventManager getInstance() {
        return LocalEventManagerHolder.sInstance;
    }

    // TODO: 2018/5/31 注册一个事件
    public void registerLocalEvent(LocalEvent event) {
        synchronized (mLocalEvents) {
            if (!mLocalEvents.contains(event)) {
                mLocalEvents.add(event);
            }
        }
    }

    // TODO: 2018/5/31 移除所有事件
    public void unregisterLocalEvent(LocalEvent event) {
        synchronized (mLocalEvents) {
            if (mLocalEvents.contains(event)) {
                mLocalEvents.remove(event);
            }
        }
    }

    public void sendEvent(int event) {
        sendEvent(event, null);
    }

    public void sendEvent(int key, Object data) {
        sendEventDelay(key, 0, data);
    }

    public void sendEventDelay(int event, long delayMillis, Object data) {
        Message message = mHandler.obtainMessage(MSG, event, 0, data);
        mHandler.sendMessageDelayed(message, delayMillis);
    }

    private void executePendingEvents(int key, Object obj) {
        for (LocalEvent event : mLocalEvents) {
            if (event.containsEvent(key)) {
                event.executeEvents(key, obj);
            }
        }
    }
}

m层

/**
 * Created by malei on 2018/5/31.
 */
public class MainDao {

    private Handler mUIHandler = new Handler(Looper.getMainLooper()) {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
                case LocalEvent.Events.EVENT_UPDATE_UI:  //更新ui
                    LocalEventManager.getInstance().sendEvent(LocalEvent.Events.EVENT_UPDATE_UI, msg.obj);
                    break;
                default:
                    break;
            }
        }
    };
    public void exe() {
        new Thread(new Runnable() {
            @Override
            public void run() {
                mUIHandler.obtainMessage(LocalEvent.Events.EVENT_UPDATE_UI, "xx").sendToTarget();
            }
        }).start();
    }
}