1. Introducción al uso de EventBus
Introducción a EventBus
EventBus es una biblioteca de código abierto desarrollada por GreenRobot. Es una "publicación de eventos - bus de suscripción"
para el desarrollo de Android, que se utiliza
para la comunicación y el desacoplamiento entre módulos. Puede usar muy poco código para realizar la comunicación entre múltiples componentes.
La comunicación de eventos integrada del sistema Android tiene desventajas:
La comunicación de eventos en el sistema Android es el controlador ( mecanismo de mensajes ) y BroadCastReceiver (mecanismo de transmisión),
a través de los cuales se puede realizar la comunicación de eventos entre los componentes. La desventaja es que hay una gran cantidad de código y los componentes son fáciles de generar referencias acopladas.
Fondo generado por EventBus
Cuando desarrollamos proyectos, a menudo encontramos comunicación entre componentes y entre componentes y subprocesos en segundo plano.
Por ejemplo, las solicitudes de datos se ejecutan en subprocesos. Una vez que las solicitudes de datos son exitosas, las actualizaciones de la interfaz de usuario se notifican a través de Handler o BroadCast.
Dos Fragments pueden comunicarse a través del Listener, pero el problema es que cuando el programa se vuelve más y más grande, se escribirá mucho código, lo que conducirá
a serios problemas de acoplamiento del código. Por esta razón nació EventBus.
Diagrama de flujo de trabajo de EventBus
El editor usa la publicación para enviar un evento de evento y el suscriptor recibe el evento en la función onEvent().
Ventajas de EventBus
1. Simplificar el método de comunicación entre componentes
2. Desacoplamiento de las partes de comunicación
3. Use ThreadMode para cambiar de forma flexible los subprocesos de trabajo
4. Velocidad rápida y buen rendimiento.
5. La biblioteca es relativamente pequeña y no ocupa memoria
Desventajas de EventBus
1. Cuando se usa, hay muchas clases de eventos definidas
2. Cuando se registra el evento, llamará a la reflexión para atravesar el método del objeto registrado para encontrar el método con la etiqueta @subscriber, y el rendimiento no es alto.
3. Debe registrarse y cancelar el registro usted mismo. Si olvida cancelar el registro, se producirán pérdidas de memoria.
Configuración del entorno EventBus
1. Importación de dependencia
Importe la biblioteca dependiente en el archivo builde.gradle del módulo de la aplicación:
imlementation ‘org.greenrobot:eventbus:3.2.0’
2. Confusión de configuración
Debe estar configurado, de lo contrario habrá un problema de que el entorno de depuración es normal, pero el entorno de lanzamiento no puede recibir eventos.
-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);
}Uso de EventBus
Trilogía de eventos de EventBus : suscriptor, evento, editor.
Suscriptor: el método de registro de EventBus recibirá un objeto Object.
Evento —— El tipo de evento pasado en el método post() de EventBus (puede ser de cualquier tipo).
Publisher: el método post() de EventBus.
1. Crea una clase de evento
public class EventMessage {
private int type;
private String message;
public EventMessage(int type, String message) {
this.type = type;
this.message = message;
}
public int getType() {
return type;
}
public void setType(int type) {
this.type = type;
}
public String getMessage() {
return message;
}
public void setMessage(String message) {
this.message = message;
}
@Override
public String toString() {
return "type="+type+"--message= "+message;
}
}
2. En el módulo que necesita para suscribirse al evento, registre EventBus
Precauciones:1. Este método tiene un único parámetro2. Debe modificarse con público, y no se puede usar estático o abstracto.3. Necesita agregar la anotación @Subscribe()
public class EventBusActivity extends AppCompatActivity {
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
}
@Override
protected void onStart() {
super.onStart();
//注册EventBus
EventBus.getDefault().register(this);
}
//接收事件
@Subscribe(threadMode = ThreadMode.POSTING, sticky = true, priority = 1)
public void onReceiveMsg(EventMessage message){
Log.e("EventBus_Subscriber", "onReceiveMsg_POSTING: " + message.toString());
}
//接收事件
@Subscribe(threadMode = ThreadMode.MAIN, sticky = true, priority = 1)
public void onReceiveMsg1(EventMessage message){
Log.e("EventBus_Subscriber", "onReceiveMsg_MAIN: " + message.toString());
}
//接收事件
@Subscribe(threadMode = ThreadMode.MAIN_ORDERED, sticky = true, priority = 1)
public void onReceiveMsg2(EventMessage message){
Log.e("EventBus_Subscriber", "onReceiveMsg_MAIN_ORDERED: " + message.toString());
}
//接收事件
@Subscribe(threadMode = ThreadMode.BACKGROUND, sticky = true, priority = 1)
public void onReceiveMsg3(EventMessage message){
Log.e("EventBus_Subscriber", "onReceiveMsg_BACKGROUND: " + message.toString());
}
//接收事件
@Subscribe(threadMode = ThreadMode.ASYNC, sticky = true, priority = 1)
public void onReceiveMsg4(EventMessage message){
Log.e("EventBus_Subscriber", "onReceiveMsg__ASYNC: " + message.toString());
}
@Override
protected void onDestroy() {
super.onDestroy();
//取消事件
EventBus.getDefault().unregister(this);
}
}
3. Crea un suscriptor para iniciar una notificación
Use eventbus.post(eventMessage) o eventbus.postSticky(eventMessage) para iniciar un evento
@OnClick(R2.id.send_event_common)
public void clickCommon(){
EventMessage message = new EventMessage(1, "这是一条普通事件");
EventBus.getDefault().post(message);
}
@OnClick(R2.id.send_event_sticky)
public void clickSticky(){
EventMessage message = new EventMessage(1, "这是一条黏性事件");
EventBus.getDefault().postSticky(message);
}Introducción a las anotaciones de suscripción
Subscribe es una anotación personalizada de EventBus, que tiene tres parámetros ( opcionales ): threadMode, boolean sticky y prioridad int.
El escrito completo es el siguiente :
@Subscribe(threadMode = ThreadMode.MAIN,sticky = true,priority = 1)
public void onReceiveMsg(EventMessage message) {
Log.e(TAG, "onReceiveMsg: " + message.toString());
}1. modo ThreadMode
Se utiliza para configurar el método onReceiveMsg(), a qué entorno de hilo se llamará, hay cinco modos:
1.1 PUBLICACIÓN: modo por defecto
Indica en qué subproceso se produce el evento de envío post() y en qué entorno de subproceso se produce el evento de recepción onReceiveMsg().
Escenas a utilizar:
Este modo no requiere una lógica de juicio para el cambio de subprocesos y
se distribuye directamente al mismo entorno de subprocesos, lo que es rápido y requiere mucho tiempo.
订阅处：
@Subscribe()
public void onReceiveMsg(EventMessage message) {
Log.e(TAG, "onReceiveMsg: " + message.toString());
Log.e(TAG, "onReceiveMsg: current thread name ="+Thread.currentThread().getName() );
}
发布处：
private View.OnClickListener mSendListener = new View.OnClickListener() {
@Override
public void onClick(View v) {
Log.e(TAG, "onClick: " );
new Thread(new Runnable() {
@Override
public void run() {
String name = Thread.currentThread().getName();
Log.e(TAG, "run: thread name = "+name );
EventMessage msg = new EventMessage(1,"Hello MainActivity");
EventBus.getDefault().post(msg);
}
}).start();
}
};1.2 MAIN / MAIN_ODERED: El hilo principal recibe eventos
Indica que no importa en qué entorno de subproceso se publique el evento en post(), la recepción del evento siempre se ejecuta en el entorno de subproceso principal.
La diferencia entre los dos:
1.2.1 Para el modo PRINCIPAL:
Si el evento de publicación también está en el entorno del hilo principal, el entorno del hilo donde se encuentra el evento de publicación se bloqueará. En términos generales, en el caso de varios eventos de publicación consecutivos, la siguiente publicación solo se ejecutará después del método de recepción del evento. se ejecuta el evento event.
Si el evento de publicación no está en el entorno del subproceso principal y hay operaciones que consumen mucho tiempo en el evento de recepción del subproceso principal, no es un bloqueo.
1.2.2 Para el modo MAIN_ORDERED, sin importar en qué entorno de subproceso se encuentre el evento de publicación, su flujo de ejecución es sin bloqueo.
1.3 ANTECEDENTES:
Independientemente del entorno del subproceso en el que se produzca el evento de publicación,
la recepción del evento siempre se ejecuta en un subproceso secundario.
1.4 ASINCRONIZADO:
Este modo significa que no importa en qué entorno de subproceso se encuentre el evento de publicación, el proceso de recepción de eventos siempre está en el subproceso secundario.
2. pegajoso
Sticky es un tipo booleano, el valor predeterminado es falso y la función Sticky no está habilitada de forma predeterminada, entonces, ¿cuál es la función Sticky?
Todos los ejemplos anteriores registran suscriptores (reciben eventos) primero y luego publican eventos. Entonces, la función de Sticky es: el suscriptor no puede registrarse primero, si se envió el evento de publicación y luego registrar al suscriptor, el evento también puede recibirse y procesarse .
De hecho, en la escena fija, EventBus solo guarda el evento.
private View.OnClickListener mGoListener = new View.OnClickListener() {
@Override
public void onClick(View v) {
Log.e(TAG, "onClick: post");
EventMessage message = new EventMessage(233, "post message before");
EventBus.getDefault().postSticky(message);
}
};
private View.OnClickListener mRegisterListener = new View.OnClickListener() {
@Override
public void onClick(View v) {
Log.e(TAG, "onClick: start register" );
//当触发点击事件的时候，才进行注册，这个时候，可同样可以接收到上个点击事件中发出的 事件。
EventBus.getDefault().register(MainActivity.this);
}
};3, prioridad
La prioridad es la prioridad, es un tipo int y el valor predeterminado es 0. Cuanto mayor sea el valor, mayor será la prioridad y mayor la prioridad para recibir el evento.
Vale la pena señalar que solo tiene sentido cuando el evento de publicación y el proceso de recepción de eventos están en el mismo entorno de hilo.
Dos, el principio de EventBus
Explicación clara: el principio central de EventBus se puede entender guardando estas tres imágenes y guárdelas.
Análisis del código fuente: análisis del principio de EventBus - libro corto