Android前端架构设计：基于观察者模式的架构设计（欢迎各路高手点评）

Android前端架构设计：基于观察者模式的架构设计

今天有个想法，但是没有实际实践过，欢迎各路大哥批评指点。基于“凡事皆事件”的原理，我把所有的事件都统一起来，并且给每个事件一个名称，通过java观察者模式的方式监听事件，从而把业务逻辑集中起来进行处理。

先来看看我的观察者类

public class ActionBuilding {

    private static ActionBuilding building;
    public static ActionBuilding getInstance(){
        if (building==null)building=new ActionBuilding();
        return building;
    }
    private ActionBuilding() { }

    private List<ActionDo> actionDos =new ArrayList<>();
    public void register(ActionDo actionDo){
        if (!actionDos.contains(actionDo)){
            actionDos.add(actionDo);
        }
    }

    public void unRegister(ActionDo actionDo){
        if (actionDos.contains(actionDo)){
            actionDos.remove(actionDo);
        }
    }

    public void setAction(String actionStr,Object o){
        for (ActionDo actionDo : actionDos){
            actionDo.toDo(actionStr,o);
        }
    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

提供注册监听、注销监听和发出Action的方法，其中ActionDo是一个接口，代码如下：

public interface ActionDo {

    void toDo(String actionStr,Object object);

}
1
2
3
4
5

基于观察者类，activity就这么写

public class MainActivity extends AppCompatActivity implements View.OnClickListener {

    private MyButton my_button;
    private ThisAction allAction;
    private ThisAction myButtonAction;
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        //上报onCreate事件
        ActionBuilding.getInstance().setAction(Action.main.MAIN_ACTIVITY_ON_CREATE,savedInstanceState);
        
        initView();
    }

    private void initView() {
        my_button=findViewById(R.id.my_button);
        my_button.setOnClickListener(this::onClick);

        myButtonAction=new ThisAction();
        allAction=new ThisAction();

        my_button.getAction(myButtonAction);
        ActionBuilding.getInstance().register(allAction);
    }

    @Override
    protected void onResume() {
        super.onResume();
        //上报onResume事件
        ActionBuilding.getInstance().setAction(Action.main.MAIN_ACTIVITY_ON_RESUME,null);
    }

    @Override
    protected void onRestart() {
        super.onRestart();
        //上报onRestart事件
        ActionBuilding.getInstance().setAction(Action.main.MAIN_ACTIVITY_ON_RESTART,null);
    }

    @Override
    protected void onPause() {
        super.onPause();
        //上报onPause事件
        ActionBuilding.getInstance().setAction(Action.main.MAIN_ACTIVITY_ON_PAUSE,null);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //上报onDestroy事件
        ActionBuilding.getInstance().setAction(Action.main.MAIN_ACTIVITY_ON_DESTROY,null);
    }

    @Override
    protected void onStop() {
        super.onStop();
        //上报onStop事件
        ActionBuilding.getInstance().setAction(Action.main.MAIN_ACTIVITY_ON_STOP,null);
    }

    @Override
    public void onClick(View view) {
        switch (view.getId()){
            case R.id.my_button:
                //上报my_button点击事件
                ActionBuilding.getInstance().setAction(Action.main.MAIN_ACTIVITY_MY_BUTTON_ON_CLICK,null);
                break;
        }
    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {
        if (keyCode==KeyEvent.KEYCODE_BACK){
            //上报返回键点击事件
            ActionBuilding.getInstance().setAction(Action.main.MAIN_ACTIVITY_KEY_BACK,null);
            return false;
        }

        if (keyCode==KeyEvent.KEYCODE_HOME){
            //上报Home键点击事件
            ActionBuilding.getInstance().setAction(Action.main.MAIN_ACTIVITY_KEY_HOME,null);
            return false;
        }

        if (keyCode==KeyEvent.KEYCODE_MENU){
            //上报MENU键点击事件
            ActionBuilding.getInstance().setAction(Action.main.MAIN_ACTIVITY_KEY_MENU,null);
            return false;
        }

        return super.onKeyDown(keyCode, event);
    }

    private class ThisAction implements ActionDo {

        @Override
        public void toDo(String actionStr, Object object) {
            switch (actionStr){
                case Action.main.UPDATE_MY_BUTTON_VIEW:
                    my_button.setData((List<String>) object);
                    break;
                case Action.myButtonView.my_button_view_do:
                    // TODO:2022/9/6 MyButtonView执行的结果，或者点击事件的返回
                    break;
            }
        }

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

所有事件都不在Activity中进行处理，而是通过ActionBuilding（观察者类）把事件都分发出去，包括按钮的点击事件等等。同时Activity中也通过ThisAction 监听ActionBuilding的事件，实现外部操控这个Activity，主要是数据传输给UI刷新这样的逻辑。

然后加一个控制类，实现业务逻辑，代码如下：

public class MainController {

    public MainController() {
        ActionBuilding.getInstance().register(new ThisAction());
    }

    private class ThisAction implements ActionDo {

        @Override
        public void toDo(String actionStr, Object o) {
            switch (actionStr){
                case Action.main.MAIN_ACTIVITY_ON_CREATE:
                    CallbackData.getData(new ActionDo() {
                        @Override
                        public void toDo(String actionStr, Object object) {
                            List<String> list=(List<String>) object;//模仿
                            ActionBuilding.getInstance().setAction(Action.main.UPDATE_MY_BUTTON_VIEW,list);
                        }
                    });
                    break;
                case Action.main.MAIN_ACTIVITY_ON_RESUME:
                    break;
                case Action.main.MAIN_ACTIVITY_ON_PAUSE:
                    break;
                case Action.main.MAIN_ACTIVITY_ON_RESTART:
                    break;
                case Action.main.MAIN_ACTIVITY_ON_DESTROY:
                    break;
                case Action.main.MAIN_ACTIVITY_ON_STOP:
                    break;
                case Action.main.MAIN_ACTIVITY_KEY_BACK:
                    break;
                case Action.main.MAIN_ACTIVITY_KEY_HOME:
                    break;
                case Action.main.MAIN_ACTIVITY_KEY_MENU:
                    break;
            }
        }

    }

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

通过这个类拿到事件，并进行各种业务逻辑，例如代码中MAIN_ACTIVITY_ON_CREATE这个事件，这个事件中通过CallbackData.getData获取到一个结果List, 然后这个结果要给谁去处理？ 依然是通过ActionBuilding.getInstance().setAction把结果丢出去，谁需要这个结果自己去监听这个事件即可，这里发出的是Action.main.UPDATE_MY_BUTTON_VIEW，也就是被上面的MainActivity领取了，并把这个结果给了my_button这个控件。

......这里省略了MainActivity的其他内容
private class ThisAction implements ActionDo {

        @Override
        public void toDo(String actionStr, Object object) {
            switch (actionStr){
                case Action.main.UPDATE_MY_BUTTON_VIEW:
                    my_button.setData((List<String>) object);
                    break;
                case Action.myButtonView.my_button_view_do:
                    // TODO:2022/9/6 MyButtonView执行的结果，或者点击事件的返回
                    break;
            }
        }
    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

这样实现我们的代码结构就呈现出这样的效果：

aController：接收Action，实现各种业务逻辑，同时把执行结果也当做Action发出去。
aData： 负责获取数据，http请求或者别的数据源。
aView： 就负责把各种触摸事件上报，以及监听刷新指令进行UI渲染。

优点：

1. 随时随地轻松获取各种你需要的事件
2. 结构分成3层，数据层——控制层——View层，三层之间的交互都依赖“事件”，实现解耦。利于合作开发。

缺点：还请各位大哥指出来。