[Android]EventBus-来一趟快速公交初体验[下]

接着上文《[Android]EventBus-来一趟快速公交初体验[上]》，我们继续说说EventBus3.0的其他Point。

Subscriber index

因为EventBus3使用了 如@subscriber 这样的注解的方式来实现订阅方法的检索和调用，众所周知，这种方式是消耗性能的，所以这个版本的效率应该会比之前的版本慢一些（虽然我们感觉不到），然后，EventBus3的开发者提供了一个小插件，Subscriber index ，我这就称它“加速索引”吧，这玩意提升了效率，看图就能感受到。

那如何使用它呢？

步骤一：在我们总项目的公共的build.gradle中加入下面这段（注意：这个是最外面的那个build.gradle，不是app里的，⊙﹏⊙我刚用AS还不太懂这个构建工具）

buildscript {
    dependencies {
        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
    }
}

我的是这样的，仅作参考

// Top-level build file where you can add configuration options common to all sub-projects/modules.

buildscript {
    repositories {
        jcenter()
        mavenCentral()
    }
    dependencies {
        classpath 'com.android.tools.build:gradle:2.1.0'
        //这边我们要引用apt插件
        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
        // NOTE: Do not place your application dependencies here; they belong
        // in the individual module build.gradle files
    }
}

allprojects {
    repositories {
        jcenter()
    }

}

步骤二：在app里的那个build.gradle加入以下配置

apply plugin: 'com.neenbedankt.android-apt'
dependencies {
    compile 'org.greenrobot:eventbus:3.0.0'
    apt 'org.greenrobot:eventbus-annotation-processor:3.0.1'
}
apt {
    arguments {
        eventBusIndex "com.example.myapp.MyEventBusIndex"
    }
}

我的是这样的，不懂的可以参考一下

apply plugin: 'com.android.application'
apply plugin: 'com.neenbedankt.android-apt'

android {
    compileSdkVersion 23
    buildToolsVersion "23.0.3"

    defaultConfig {
        applicationId "com.example.myapp"
        minSdkVersion 15
        targetSdkVersion 23
        versionCode 1
        versionName "1.0"
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}
dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    //编译已导入的Project(MyLib)  跟本次demo无关，请忽略
    compile project(":MyLib:crazy-lib")
    apt 'org.greenrobot:eventbus-annotation-processor:3.0.1'
}
apt {
    arguments {
        eventBusIndex "com.example.myapp.event.MyEventBusIndex"
    }
}

步骤三：as应该会自己build项目的，也可以手动在菜单栏Build->Rebuild Project 生成我们在脚本里写的“com.example.myapp.event.MyEventBusIndex”类，注意：这个类的生成位置在MyApp\app\build\generated\source\apt\debug\com\example\myapp\event里，这个是我的项目MyApp

步骤四：最后的就是在代码里配置一下即可，我这写的方式比较粗简，在自己的Application里统一给所有的EventBus单例设置统一配置加速索引

public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        EventBus.builder().addIndex(new MyEventBusIndex()).installDefaultEventBus();
    }
}

如果你想单独的使用这个，当然也可以单独配置加速索引

EventBus.builder().addIndex(new MyEventBusIndex()).installDefaultEventBus();
// Now the default instance uses the given index. Use it like this:
EventBus eventBus = EventBus.getDefault();

嗯，这个就讲完了，基本不会影响我们程序员开发效率的。

Sticky Events

以下是个人观点：

我觉得这个Sticky Event 听起来就像是“粘性事件”，第一感觉还以为是发送的事件具有持久性而已，鄙人粗陋，写了个demo才发现其实就是缓存一些我们需要的数据或者说是变量，然后在关键点发布出去，在其他地方都能获取到这个事件，就很像我们在Activity之间传输数据的Intgent 的Bundle.，话不多说看实际代码就明了。

场景：两个Activity(A,B)，两个实体类（Teacher、StudentBean）,实现A向B分别传递Teacher对象和StudentBean对象，一会儿注意下两种方式即可理解。

   btn1.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                //这里测试Activity之间的实体变量传递
                //方案一：利用Intent内的Bundle/Extra来存储并传递到目标Activity中
                Teacher teacher = new Teacher();
                teacher.id = "1";
                teacher.name = "苍老师";
                teacher.age = 33;
                Intent data1 = new Intent(HomeActivity.this,DetaiActivity.class);
                data1.putExtra("data",teacher);
                startActivity(data1);
                //方案二：使用EventBus的StickEvent来缓存Student对象
//                StudentBean student = new StudentBean();
//                student.name = "wowo小白";
//                student.headImageUrl  = "http://images.rednet.cn/articleimage/2013/10/14/1006204957.jpg";
//                student.age = Integer.MAX_VALUE;
//                EventBus.getDefault().postSticky(student);
//                Intent data2 = new Intent(HomeActivity.this,DetaiActivity.class);
//                startActivity(data2);

方式一用的是Intent 来传递我们的苍老师，在B中显示她的属性

方式二是发布StickyEvent，缓存学生对象，意在B中取出这个对象

转眼看下 DetailActivty的主要的代码

public class DetaiActivity extends BaseActivity {
    private TextView mDetailTv;
    private Button mShowBtn;
    private Teacher mTeacher;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_detail);
        mDetailTv = (TextView) findViewById(R.id.tv_detail);
        mShowBtn = (Button) findViewById(R.id.btn_show);
        mShowBtn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                StudentBean studentBean = null;
                //在之前的Activity上我用bus post了一个Sticky的事件，这个事件就是这里的StudentBean对象
                //1.可以先通过ventBus.getDefault().getStickyEvent(StudentBean.class) 的方式来取值
                studentBean = EventBus.getDefault().getStickyEvent(StudentBean.class);
                //如下方式是移除这个StudentBean对象，先取出了这个值，下次调用将会返回Null，因为已经被移除了。
//                studentBean = EventBus.getDefault().removeStickyEvent(StudentBean.class);
                if(studentBean!=null){
                    mDetailTv.setText("姓名:"+studentBean.name+",年龄:"+studentBean.age);
                }else {
                    mDetailTv.setText("studentBean is null");
                }
            }
        });
        initData();
    }

    private void initData(){
        Intent data = getIntent();
        if(data.hasExtra("data")){
            mTeacher = data.getParcelableExtra("data");
            mDetailTv.setText("姓名:"+mTeacher.name+",年龄:"+mTeacher.age);
        }
    }

效果基本是差不多的，区别就是我们的实体类的差别了，Teacher类是需要序列化的，而我们用EventBus的话就无需序列化StudentBean

Teacher.java

package com.example.myapp.bean;

import android.os.Parcel;
import android.os.Parcelable;

/**
 * Created by jan on 2016/6/13.
 */
public class Teacher implements Parcelable {  //简单点的话直接实现Serializable接口即可
    public String id;
    public String name;
    public int age;

    public Teacher() {
    }

    protected Teacher(Parcel in) {
        id = in.readString();
        name = in.readString();
        age = in.readInt();
    }

    public static final Creator<Teacher> CREATOR = new Creator<Teacher>() {
        @Override
        public Teacher createFromParcel(Parcel in) {
            return new Teacher(in);
        }

        @Override
        public Teacher[] newArray(int size) {
            return new Teacher[size];
        }
    };

    @Override
    public int describeContents() {
        return 0;
    }

    @Override
    public void writeToParcel(Parcel dest, int flags) {
        dest.writeString(id);
        dest.writeString(name);
        dest.writeInt(age);
    }
}

StudentBean.java

package com.example.myapp.bean;

/**
 * Created by jan on 2016/6/13.
 */
public class StudentBean {
    public String name;
    public int age;
    public String headImageUrl;

    public StudentBean() {
    }
}

效果图，这个是这个demo的实现效果，在点击传递按钮的时候，我修改成把两个事件同时释放。

Proguard混淆设置

这边不管你有没有配置加速索引，我们一律如下配置

-keepattributes *Annotation*
-keepclassmembers class ** {
    @org.greenrobot.eventbus.Subscribe <methods>;
}
-keep enum org.greenrobot.eventbus.ThreadMode { *; }

# Only required if you use AsyncExecutor
-keepclassmembers class * extends org.greenrobot.eventbus.util.ThrowableFailureEvent {
    <init>(java.lang.Throwable);
}

Ok,Thank you look look My boke.

如有幸被转载(http://blog.csdn.net/jan_s/article/details/51671180)请记得留言哦