MVP实战心得(二)---Base基类的封装

基类:

在开发中有着很重要的地位,基类设计封装的好,不管是对app的性能,还是对开发的效率都有着很重要的作用

基类可以简单几个字概况,一个良好的父类.

结构:

不管你的app是多个acitivity,还是1个activity+n个fragment,还是多个acitivity多个fragment.

始终都是用的acitivity和fragment.

根据项目的不同,基类不可能完全相同,但很多还是可以通用的.

抽取:

既然是mvp,那么不管是acitivity还是fragment.都归于v 

既然是v,那么就应该有相对应的presenter,view 

那么基类应该有: 

BaseActivityView 

BaseFragmentView 

BaseView 

BasePresenter

具体代码:

BaseActivity

public abstract class BaseActivity<T extends BasePresenter> extends AppCompatActivity implements BaseActivityView {

protected T mPresenter;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//创建Presenter
mPresenter = initPresenter();
//类似fragment的与view进行绑定.拿到引用
mPresenter.onAttch(this);
//初始化acitivity,
onCreateActivity(savedInstanceState);
//初始化Presenter
mPresenter.onCreate();
}

@Override
public void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
mPresenter.onSaveInstanceState(outState);
}

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

@Override
public BaseActivity getActivity() {
return this;
}

/**
* 创建prensenter
* @return <T extends BasePresenter> 必须是BasePresenter的子类
*/
protected abstract T initPresenter();

/**
* 子类必须实现,并初始化Activity,比如setContentView()
*/
protected abstract void onCreateActivity(Bundle savedInstanceState);
@Override
public void isNightMode(boolean isNight) {

}
}

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
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

BaseFragment

稍微复杂一点.

public abstract class BaseFragment<T extends BasePresenter> extends Fragment implements BaseFragmentView {
protected T mPresenter;
protected Context mContext;//activity的上下文对象
protected Bundle mBundle;

@Override
public void onSaveInstanceState(Bundle outState) {
super.onSaveInstanceState(outState);
if (mBundle != null) {
outState.putBundle("bundle", mBundle);
}
}
/**
* 绑定activity
*
* @param context
*/
@Override
public void onAttach(Context context) {
super.onAttach(context);
mContext = context;
}

/**
* 运行在onAttach之后
* 可以接受别人传递过来的参数,实例化对象.
*
* @param savedInstanceState
*/
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//获取bundle,并保存起来
if (savedInstanceState != null) {
mBundle = savedInstanceState.getBundle("bundle");
} else {
mBundle = getArguments() == null ?
new Bundle() : getArguments();
}
//创建presenter
mPresenter = initPresenter();
}

/**
* 运行在onCreate之后
* 生成view视图
*/
@Nullable
@Override
public View onCreateView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState) {
return initView(inflater, container, savedInstanceState);
}

/**
* 运行在onCreateView之后
* 加载数据
*/
@Override
public void onActivityCreated(@Nullable Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
//由于fragment生命周期比较复杂,所以Presenter在onCreateView创建视图之后再进行绑定,不然会报空指针异常
mPresenter.onAttch(this);
//presenter进行初始化.
mPresenter.onCreate();
}

@Override
public void onDestroyView() {
mPresenter.onDestroy();
super.onDestroyView();
}

/**
* 跳转fragment
*
* @param tofragment
*/
@Override
public void startFragment(Fragment tofragment) {
startFragment(tofragment, null);
}

/**
* @param tofragment 跳转的fragment
* @param tag        fragment的标签
*/
@Override
public void startFragment(Fragment tofragment, String tag) {
FragmentTransaction fragmentTransaction = getFragmentManager().beginTransaction();
fragmentTransaction.hide(this).add(android.R.id.content, tofragment, tag);
fragmentTransaction.addToBackStack(tag);
fragmentTransaction.commitAllowingStateLoss();
}

/**
* 类似Activity的OnBackgress
* fragment进行回退
*/
public void onBack() {
getFragmentManager().popBackStack();
}

/**
* 初始化Fragment应有的视图
*
* @return
*/
public abstract View initView(LayoutInflater inflater, @Nullable ViewGroup container, @Nullable Bundle savedInstanceState);

/**
* 创建prensenter
*
* @return <T extends BasePresenter> 必须是BasePresenter的子类
*/
public abstract T initPresenter();

@Override
public Context getContext() {
return mContext;
}

@Override
public Bundle getBundle() {
return mBundle;
}

@Override
public BaseFragment getFragment() {
return this;
}

}

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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

再看看BaseView

public interface BaseView {
/**
* 切换夜间模式
* @param isNight 是否切换为夜间模式
*/
void isNightMode(boolean isNight);
}

1
2
3
4
5
6
7
1
2
3
4
5
6
7

BaseView得想好做什么事,必须是你的项目里所有view都有的共性

不仅是acitivity和fragment,还有控件

—————————————————————————————————–

关键的BasePresenter来了

/**
* @author jlanglang  2016/11/11 15:10
*/
public abstract class BasePresenter<T extends BaseView> {
protected T mView;

/**
* 绑定View
*/
public void onAttch(T view) {
this.mView = view;
}
/**
* 做初始化的操作,需要在view的视图初始化完成之后才能调用
*/
public abstract void onCreate();

/**
* 默认在view销毁的时候调用,解除绑定
*在view销毁前释放presenter中的对象,资源.
*/
public void onDestroy() {
mView = null;
}
/**
* 容易被回收掉时保存数据
*/
public abstract void onSaveInstanceState(Bundle outState);
}

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
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

看看Acitivity的使用:

//创建的时候写好泛型实现好抽象方法就行,多么简单.
public class MainActivity extends BaseActivity<MainActivityPresenterImpl> implements MainActivityContract.View {
@Override
protected MainActivityPresenterImpl initPresenter() {
return new MainActivityPresenterImpl();
}

@Override
protected void onCreateActivity(Bundle savedInstanceState) {
setContentView(R.layout.activity_main);
}
}

1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12

最后是对应的MainActivityPresenterImpl

,MainActivityContract

public class MainActivityPresenterImpl extends BasePresenter<MainActivityContract.View>
implements MainActivityContract.Presenter {

@Override
public void onCreate() {

}
@Override
public void onSaveInstanceState(Bundle outState) {

}
}

1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12

public class MainActivityContract {
public interface View extends BaseActivityView {
}

public interface Presenter{
}

public interface Model {
}

}

1
2
3
4
5
6
7
8
9
10
11
1
2
3
4
5
6
7
8
9
10
11

总结:

对于BasePresenter一开始我是写成接口形式的.

后来使用过程中,发现很麻烦,每次绑定View,释放View都需要重复造轮子. 

仔细想想,写成抽象类更适合.

每个Presenter继承BasePresenter,实现Contract中的接口为其补充

最后会发现,view和presenter的结构一样.基类作为复用,接口作为补充.

转载地址：http://blog.csdn.net/jlanglang/article/details/53436642