EventBus 简介
EventBus是一种用于Android的事件发布-订阅总线，由GreenRobot开发，Gihub地址是：EventBus。它简化了应用程序内各个组件之间进行通信的复杂度，尤其是碎片之间进行通信的问题，可以避免由于使用广播通信而带来的诸多不便。
1.1 三个角色
- Event：事件，它可以是任意类型，EventBus会根据事件类型进行全局的通知。
- Subscriber：事件订阅者，在EventBus 3.0之前我们必须定义以onEvent开头的那几个方法，分别是onEvent、onEventMainThread、onEventBackgroundThread和onEventAsync，而在3.0之后事件处理的方法名可以随意取，不过需要加上注解@subscribe，并且指定线程模型，默认是POSTING。
- Publisher：事件的发布者，可以在任意线程里发布事件。一般情况下，使用EventBus.getDefault()就可以得到一个EventBus对象，然后再调用post(Object)方法即可。
1.2 四种线程模型
EventBus3.0有四种线程模型，分别是：
- POSTING：默认，表示事件处理函数的线程跟发布事件的线程在同一个线程。
- MAIN：表示事件处理函数的线程在主线程(UI)线程，因此在这里不能进行耗时操作。
- BACKGROUND：表示事件处理函数的线程在后台线程，因此不能进行UI操作。如果发布事件的线程是主线程(UI线程)，那么事件处理函数将会开启一个后台线程，如果果发布事件的线程是在后台线程，那么事件处理函数就使用该线程。
- ASYNC：表示无论事件发布的线程是哪一个，事件处理函数始终会新建一个子线程运行，同样不能进行UI操作。
先看下以下的一种场景:
现在有在同一个进程的ActivityA和ActivityB,现在的简单需求是点击ActivityB中的按钮，修改ActivityA中TextView中的内容.
public class ActivityA extends Activity implements View.OnClickListener {
private TextView textView;
public static ActivityA activityA;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_a);
textView = findViewById(R.id.tv);
Button button = findViewById(R.id.btnStartB);
button.setOnClickListener(this);
activityA = this;
}
public void setTextView(){
textView.setText("ActivityB set ActivityA");
}
@Override
public void onClick(View v) {
Intent intent = new Intent();
intent.setClass(this,ActivityB.class);
startActivity(intent);
}
public void onDestroy(){
super.onDestroy();
activityA = null;//防止内存漏洞
}
}
public class ActivityB extends Activity implements View.OnClickListener{
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_b);
Button button = findViewById(R.id.btn);
button.setOnClickListener(this);
}
@Override
public void onClick(View v) {
ActivityA.activityA.setTextView();
}
}
以上的代码是以一种,这种方式的问题是直接引用在ActivityB引用了ActivityA类,耦合度高。
现在做以下的优化:
新增ActivityGloble
public class ActivityGloble {
private ActivityA activityA;
public static ActivityGloble activityGloble = new ActivityGloble();
public void setActivityA(ActivityA activityA){
this.activityA = activityA;
}
public void setTextView(){
activityA.setTextView();
}
}
public class ActivityA extends Activity implements View.OnClickListener {
private TextView textView;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_a);
textView = findViewById(R.id.tv);
Button button = findViewById(R.id.btnStartB);
button.setOnClickListener(this);
ActivityGloble.activityGloble.setActivityA(this);
// activityA = this;
}
public void setTextView(){
textView.setText("ActivityB set ActivityA");
}
@Override
public void onClick(View v) {
Intent intent = new Intent();
intent.setClass(this,ActivityB.class);
startActivity(intent);
}
public void onDestroy(){
super.onDestroy();
ActivityGloble.activityGloble.setActivityA(null);//防止内存漏洞
}
}
public class ActivityB extends Activity implements View.OnClickListener{
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_b);
Button button = findViewById(R.id.btn);
button.setOnClickListener(this);
}
@Override
public void onClick(View v) {
ActivityGloble.activityGloble.setTextView();
}
}
现在看起来已经优雅了很多了，但是还有以下一些问题要:
- 如果不是ActivityA变成了其他的ActivityC或者其他的类，要怎么处理?
- 现在是只有一个方法，如果方法多了，ActivityGloble是要手动增加方法的，如何才能做到自动获取方法?
针对以上两点，要做如下的改动:将要引用的类改成Object类型，要被执行的方法通过反射获取。
public class ActivityGloble {
private Object subscriber;//要订阅的类，
public static ActivityGloble activityGloble = new ActivityGloble();
private HashMap<String,Method> methodMap = new HashMap<>();//需要被执行方法map
/*
* @param subscriber//要订阅的类
* @param postMethodNames,订阅类要执行的方法列表
*/
public void register(Object subscriber,String[] postMethodNames){
this.subscriber = subscriber;
if(subscriber == null){
return;
}
if(postMethodNames != null){
Class<?> subscriberClass = subscriber.getClass();//获取类
Method[] methods = subscriberClass.getDeclaredMethods();//获取所有方法
for(int i = 0;i < methods.length;i++){
for(int j = 0;j < postMethodNames.length;j++){
if(methods[i].getName().equals(postMethodNames[j])){
StringBuilder paramTypeBuilde = null;//用于处理函数的重载
Class<?>[] paramTypes = methods[i].getParameterTypes();
if(paramTypes != null && paramTypes.length > 0){
paramTypeBuilde = new StringBuilder();
for(int k = 0; k < paramTypes.length;k++){
paramTypeBuilde.append(paramTypes[k].getName());//取出函数对应的参数
}
}
if(paramTypeBuilde == null){
methodMap.put(postMethodNames[j],methods[i]);//如果这个函数没有参数
}else{
//如果有参数，参数也和方法一起，作为一个key
//比如setTextView(String arg1,Integer arg3)会转化为 setTextViewjava.lang.Stringjava.lang.Integer methodMap.put(postMethodNames[j]+paramTypeBuilde.toString(),methods[i]);
}
}
}
}
}
}
/**
* @param methodName
* @param args,要传入的参数
*/
public void post(String methodName, Object... args) {
if(args != null && args.length > 0){
//如果有参数，对方法进行拼接
StringBuilder builder = new StringBuilder();
builder.append(methodName);
for(int i = 0;i < args.length;i++){
builder.append(args[i].getClass().getName());
}
methodName = builder.toString();
}
Method method = methodMap.get(methodName);
if(method != null){
try {
if(args == null || args.length == 0){
method.invoke(subscriber);
}else{
method.invoke(subscriber,args);
}
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
}
对于post方法，这里要进行说明下:
因为是Object... args这样的方式传参，所以会导致int,long,float,double,boolean,byte转为Integer,Long,Float,Double,Boolean,Byte
所以为了处理这个问题，所以要声名的函数int,long,float,double,boolean,byte这些类型都要转为Integer,Long,Float,Double,Boolean,Byte。
具体的调用:
public class ActivityA extends Activity implements View.OnClickListener {
private TextView textView;
private String[] methods = {"setTextView","setTextView1"};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_a);
textView = findViewById(R.id.tv);
Button button = findViewById(R.id.btnStartB);
button.setOnClickListener(this);
ActivityGloble.activityGloble.register(this,methods);
// activityA = this;
}
public void setTextView(){
textView.setText("ActivityB set ActivityA");
}
public void setTextView1(String arg1,String arg2){
TextView textView = findViewById(R.id.tv1);
textView.setText("ActivityB set ActivityA "+arg1+" "+arg2);
}
public void setTextView(String arg1,Integer arg3){
TextView textView = findViewById(R.id.tv2);
textView.setText("ActivityB set ActivityA "+arg1+" "+" arg3 is "+3);
}
@Override
public void onClick(View v) {
Intent intent = new Intent();
intent.setClass(this,ActivityB.class);
startActivity(intent);
}
public void onDestroy(){
super.onDestroy();
ActivityGloble.activityGloble.register(null,null);//防止内存漏洞
}
}
public class ActivityB extends Activity implements View.OnClickListener{
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_b);
Button button = findViewById(R.id.btn);
button.setOnClickListener(this);
}
@Override
public void onClick(View v) {
ActivityGloble.activityGloble.post("setTextView");
ActivityGloble.activityGloble.post("setTextView1","qaa","bbb");
ActivityGloble.activityGloble.post("setTextView","wwww",1);
}
}
这样看来解决之前提出的两个问题。
现在又有新的问题出现了:
1.是否可以注册多个类？
2.这里是手动把要注册的方法定好了，有没有更方式，让我们不需要提前写好方法,就能知道哪个方法要被执行?
3.执行的时候，可不可以只传个参数就能知道调用哪个方法?
分析问题1：
参照了EventBus里的源码，可以用缓存做处理，如下:
HashMap<Object,HashMap<String,SubscribleMethod>> cacheMap = new HashMap<>();
Object来作Key，就是订阅的类，HashMap<String,SubscribleMethod>这个是类对应订阅的方法。
代码如下：
HashMap<String,SubscribleMethod> methodMap = cacheMap.get(object);//先从缓存中查找。
if(methodMap == null){//缓存里没有找到
methodMap = getSubscribleMethodMap(object);//获取方法map,
cacheMap.put(object,methodMap);//将方法map放入到缓存中
}
分析下问题2:
在反射Method中有一个方法：
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
return super.getAnnotation(annotationClass);
}
这个方法可以获取写在方法上的注解，以此来判断这个方法是否有用到这个注解。所以可以通过注解的方法来查找哪个方法需要被执行。
对于问题3,如果每个函数传入的参数都不一样，这样是可以做到的。但是如果是两个不同的函数，有相同的参数，这时是不参区分的。还有就是如果注册了多个类，每个类都有相同的函数名和参数，这个也是不好区分的。
所以要做到以下三点:
1.定义函数的时候，尽量不要有相同的参数
2.如果同一个类里多个函数有相同的参数，调用的时候还是要把函数名给传递。
3.如果注册了多个类，且类里还要相同的函数，这里还是要传入类名。
现在来看下具体的实现:
先声名一个注解类:
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface EventBusSubscribe {
ThreadMode threadMode() default ThreadMode.POSTING;//判断是运行在哪个线程
}
ThreadMode 是判断函数的运行的类型,具体是参照EventBus源码里的:
public enum ThreadMode {
/**
* Subscriber will be called directly in the same thread, which is posting the event. This is the default. Event delivery
* implies the least overhead because it avoids thread switching completely. Thus this is the recommended mode for
* simple tasks that are known to complete in a very short time without requiring the main thread. Event handlers
* using this mode must return quickly to avoid blocking the posting thread, which may be the main thread.
*/
POSTING,
/**
* On Android, subscriber will be called in Android's main thread (UI thread). If the posting thread is
* the main thread, subscriber methods will be called directly, blocking the posting thread. Otherwise the event
* is queued for delivery (non-blocking). Subscribers using this mode must return quickly to avoid blocking the main thread.
* If not on Android, behaves the same as {@link #POSTING}.
*/
MAIN,
/**
* On Android, subscriber will be called in Android's main thread (UI thread). Different from {@link #MAIN},
* the event will always be queued for delivery. This ensures that the post call is non-blocking.
*/
MAIN_ORDERED,
/**
* On Android, subscriber will be called in a background thread. If posting thread is not the main thread, subscriber methods
* will be called directly in the posting thread. If the posting thread is the main thread, EventBus uses a single
* background thread, that will deliver all its events sequentially. Subscribers using this mode should try to
* return quickly to avoid blocking the background thread. If not on Android, always uses a background thread.
*/
BACKGROUND,
/**
* Subscriber will be called in a separate thread. This is always independent from the posting thread and the
* main thread. Posting events never wait for subscriber methods using this mode. Subscriber methods should
* use this mode if their execution might take some time, e.g. for network access. Avoid triggering a large number
* of long running asynchronous subscriber methods at the same time to limit the number of concurrent threads. EventBus
* uses a thread pool to efficiently reuse threads from completed asynchronous subscriber notifications.
*/
ASYNC}
//对所要订阅的方法进行一些封装。
public class SubscribleMethod {
//注册方法
private Method method;
//线程类型
private ThreadMode threadMode;
//参数类型
private Class<?>[] paramTypes;
public SubscribleMethod(Method method, ThreadMode threadMode, Class<?>[] paramTypes) {
this.method = method;
this.threadMode = threadMode;
this.paramTypes = paramTypes;
}
/**
*
* 获取方法名字
*/
public String getMethodNameKey(){
String methodName = method.getName();
if(paramTypes == null || paramTypes.length ==0){
// return method.getName();
}else{
StringBuilder builder = new StringBuilder();
builder.append(methodName);
for(int k = 0; k < paramTypes.length;k++){
builder.append(paramTypes[k].getName());
}
methodName = builder.toString();
}
return methodName;
}
/**
*
* 参数拼接的字段
*/
public String getParamTypesNameKey(){
if(paramTypes == null || paramTypes.length ==0){
// return method.getName();
return "";
}else{
StringBuilder builder = new StringBuilder();
for(int k = 0; k < paramTypes.length;k++){
builder.append(paramTypes[k].getName());
}
return builder.toString();
}
}
public Method getMethod() {
return method;
}
public void setMethod(Method method) {
this.method = method;
}
public ThreadMode getThreadMode() {
return threadMode;
}
public void setThreadMode(ThreadMode threadMode) {
this.threadMode = threadMode;
}
public Class<?>[] getParamTypes() {
return paramTypes;
}
public void setParamTypes(Class<?>[] paramTypes) {
this.paramTypes = paramTypes;
}
}
public class EventBus {
private static EventBus instance = new EventBus();
private Object subscriber;//要订阅的类，
private HashMap<Object,HashMap<String,SubscribleMethod>> cacheMap ;
private Handler handler;//用于处理需要在主线程中执行的事件
private ExecutorService executorService;//线程池用于处理异步事件
public static EventBus getDefault() {
if(instance == null){
synchronized (EventBus.class){
if(instance == null){
instance = new EventBus();
}
}
}
return instance;
}
public EventBus(){
this.cacheMap = new HashMap<>();
handler = new Handler(Looper.getMainLooper());
executorService = Executors.newCachedThreadPool();
}
public void regisg(Object object){
if(object == null){
return;
}
HashMap<String,SubscribleMethod> methodMap = cacheMap.get(object);//先从缓存中查找。
if(methodMap == null){
methodMap = getSubscribleMethodMap(object);//获取方法map,
cacheMap.put(object,methodMap);//将方法map放入到缓存中
}
}
private HashMap<String,SubscribleMethod> getSubscribleMethodMap(Object subscriber){
Class<?> subscriberClass = subscriber.getClass();//获取类
HashMap<String,SubscribleMethod> methodMap = new HashMap<>();
while (subscriberClass != null) {
//判断分类是在那个包下，（如果是系统的就不需要）
String name = subscriberClass.getName();
if (name.startsWith("java.") ||
name.startsWith("javax.") ||
name.startsWith("android.") ||
name.startsWith("androidx.")) {
break;
}
Method[] declaredMethods = subscriberClass.getDeclaredMethods();
for (Method method : declaredMethods) {
//找相应的注解
EventBusSubscribe annotation = method.getAnnotation(EventBusSubscribe.class);
if(annotation == null){//注解没有找到
continue;
}
ThreadMode threadMode = annotation.threadMode();
Class<?>[] paramTypes = method.getParameterTypes();
SubscribleMethod subscribleMethod = new SubscribleMethod(method,threadMode,paramTypes);
methodMap.put(subscribleMethod.getMethodNameKey(),subscribleMethod);
}
subscriberClass = subscriberClass.getSuperclass();//遍历父类
}
return methodMap;
}
public void post(final Object... event){
postClasssMethod(null,null,event);
}
public void postMethod(final String medhodName,final Object... event){
postClasssMethod(null,medhodName,event);
}
/**
*
* @param className 执行对应的类
* @param methodName 执行对应的方法
* @param event 参数
*/
public void postClasssMethod(final String className,final String methodName,final Object... event){
Set<Object> set = cacheMap.keySet();
Iterator<Object> iterator = set.iterator();
Object invokeObj = null;
SubscribleMethod subscribleMethod= null;
String myClassName = "";
if(className == null){
}else{
myClassName = className;
}
boolean isFindClass = false;
String myMethodName = methodName;
if(methodName == null ){
myMethodName = "";
}
while (iterator.hasNext()) {
//拿到注册类
final Object nextClassObj = iterator.next();
if(nextClassObj.getClass().getName().equals(myClassName)) {//通过类名找到对应的类
isFindClass = true;
}
HashMap<String,SubscribleMethod> methodHashMap = cacheMap.get(nextClassObj);
String tempMethodName = getMethodName(myMethodName,event);
for (Map.Entry<String, SubscribleMethod> entry : methodHashMap.entrySet()) {
subscribleMethod = entry.getValue();
String paramTypesName =subscribleMethod.getParamTypesNameKey();//获取参数的拼接字符
String methodNameKey = subscribleMethod.getMethodNameKey();
if(methodNameKey.equals(tempMethodName)){//通过类名以及参数找到对应的方法了，执行完方法的,就退出循环了
invokeObj = nextClassObj;
invoke(subscribleMethod,invokeObj,event);
break;
}else if(paramTypesName.equals(tempMethodName)){//通过参数找到对应的方法
if(subscribleMethod != null){
invokeObj = nextClassObj;
invoke(subscribleMethod,invokeObj,event);
}
}
}
if(isFindClass){//如果找到对应的类，执行完对应的类中的方法就退出不再执行了
break;
}
}
}
private String getMethodName(String methodName,Object... args){
StringBuilder builder = new StringBuilder();
builder.append(methodName);
if(args != null && args.length > 0){
//如果有参数，对方法进行拼接
for(int i = 0;i < args.length;i++){
builder.append(args[i].getClass().getName());
}
// methodName = builder.toString();
}
return builder.toString();
}
private void invoke(SubscribleMethod subscribleMethod, final Object classObj, final Object ... params) {
final Method method = subscribleMethod.getMethod();
ThreadMode threadMode = subscribleMethod.getThreadMode();
switch (threadMode){
case MAIN:
if(Looper.myLooper() == Looper.getMainLooper()){
invokeMethod(method,classObj,params);
}else{
handler.post(new Runnable() {
@Override
public void run() {
invokeMethod(method,classObj,params);
}
});
}
break;
case POSTING:
invokeMethod(method,classObj,params);
break;
case ASYNC:
//post方法执行在主线程中
if(Looper.myLooper() == Looper.getMainLooper()){
executorService.execute(new Runnable() {
@Override
public void run() {
invokeMethod(method,classObj,params);
}
});
} else {
//post方法执行在子线程中
invokeMethod(method,classObj,params);
}
break;
}
}
private void invokeMethod(Method method,Object classObj, Object ... params){
try {
method.invoke(classObj, params);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
//取消注册
public void unregister(Object subscriber) {
Object hashMap = cacheMap.get(subscriber);
//如果获取到
if (hashMap != null) {
cacheMap.remove(subscriber);
}
}
}
这里说明下post，postMethod,postClasssMethod,这三个方法。
post方法会执行注册过类中相同参数的所有方法。
postMethod，如果有传递方法的名称，则会根据方法名称和参数名字查找到对应的方法进行执行。
postClasssMethod，如果有同时传递注册过的类名以及其中的方法，则只会执行类中对应的方法，
如果只传入类名而没有传入方法，则执行类中有相同参数的方法。
最后
这个只是参考了eventBus源码，实现了一些基本的功能很多EvenbBus源码中的功能没有实现，如事件的顺序执行、切换到后台的线程等。EventBus源码中，传递事件的参数只有一个，这里代码的实现可以传递多个参数,也算是一个不同点。
扫一扫
528
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
