陈李冠
陈李冠

Android源码分析之EventBus框架

1 EventBus简介

1.1 什么是EventBus？

EventBus是Android和java的发布/订阅事件总线。

1.2 作用

事件总线是对发布-订阅模式的一种实现，它是一种集中式事件处理机制，允许不同的组件之间彼此通信，而又不需要相互依赖，达到解耦的目的。

1.3 优点

（1）简单Android组件之间的通信，避免了Android四大组件复杂的生命周期处理；
（2）在Android四大组件间，以及线程间传递大数据时的唯一选择。因为序列化大数据进行传递时，是十分耗时缓慢的，用EventBus是最优解法；
（3）使用class传递数据，可以携带各种各样的数据，摆脱了用Bundle传递list和数组的麻烦；
（4）清晰明了的主子线程，让你的代码更为简洁；

1.4 缺点

（1）EventBus可以大量解耦项目，但是滥用它，会产生一个非常危险的后果：需要定义大量的常量或者新的实体类来区分接收者，管理EventBus的消息类别将会让你很痛苦；
（2）不要在非前台组件中使用它，因为将它使用到每一个工具类或者后台业务类，会让数据发送与接收更加复杂。别忘记了Java本身就是面对对象语言，它有接口、抽象可以实现来发送与接收数据。我们可以用各种设计模式，比如观察者模式，来更好的优化与独立自己的业务，不需要依赖EventBus；
（3）EventBus，并不是真正的解耦，不要在独立的模块里使用EventBus来分发。这个模块如果那天要直接放入另外一个项目里，你怎么解耦EventBus？ 最好，还是多使用接口与Activity本身的数据传递方式。。

1.5 EventBus2.x与EventBus3.x的版本有哪些区别呢？

（1）EventBus2.x使用的是运行时注解，它采用了反射的方式对整个注册的类的所有方法进行扫描来完成注册，因而会对性能有一定影响；
（2）EventBus3.x使用的是编译时注解，Java文件会编译成.class文件，再对class文件进行打包等一系列处理。在编译成.class文件时，EventBus会使用EventBusAnnotationProcessor注解处理器读取@Subscribe()注解并解析、处理其中的信息，然后生成Java类来保存所有订阅者的订阅信息。这样就创建出了对文件或类的索引关系，并将其编入到apk中；
（3）从EventBus3.0开始使用了对象池缓存减少了创建对象的开销；

2 EventBus使用3步骤

（1）定义事件

public class MessageEvent {
    public final String message;
    public MessageEvent(String message) {
        this.message = message;
    }
}

（2）准备订阅者

@Override
public void onStart() {
    super.onStart();
    EventBus.getDefault().register(this);
}
@Override
public void onStop() {
    EventBus.getDefault().unregister(this);
    super.onStop();
}

// 这个方法将在MessageEvent被发布时被调用(在Toast的UI线程中)
@Subscribe (threadMode = ThreadMode.MAIN)
public void onMessageEvent(MessageEvent event) {
	Toast.makeText(getActivity(), event.message, Toast.LENGTH_SHORT).show();
}
// 这个方法将在SomeOtherEvent发布时被调用
@Subscribe
public void handleSomethingElse(SomeOtherEvent event) {
	doSomethingWith(event);
}

（3）发布事件

EventBus.getDefault().post(new MessageEvent("Hello everyone!"));

（4）学习链接
如何开始与EventBus在3个步骤

3 EventBus原理

3.1 最核心的原理

利用了subscriptionsByEventType这个重要的HashMap对象，将订阅者们，即接收事件的方法存储在这个列表，发布事件的时候在列表中查询出相对应的方法并执行。

Map, CopyOnWriteArrayList> subscriptionsByEventType;

3.2 EventBus框架原理

Android源码分析之EventBus框架_第1张图片

3.2.1 关键对象分析

（1）Publisher是发布者：通过post()方法将消息事件Event发布到事件总线；

（2）EventBus是事件总线： 核心模块；

（3）Subscriber是订阅者：收到事件总线发下来的消息，即onEvent方法被执行。注意参数类型必须和发布者发布的参数一致；

3.2.2 关键方法的分析

（1）register(Object object)： 将所在类作为订阅者，框架会通过反射机制获取所有方法以及其参数，并将订阅者和订阅的方法以及其参数保存到Map中，key为Object,value为Subscription类型的ArrayList，下次从Map中获取。

（2）post(Object event)：去遍历所有已经注册事件的订阅者们（即是Map中的key值），然后在根据订阅者对象找到它内部被注解方法（onEvent()），再匹配“被注解方法的参数类型”和“发布者发送的事件类型”是否是同一类型或者父类，就进行反射调用。线程切换用handler和线程池结合runnable进行切换。。

（3）postSticky(Object event)： 最后还是调用的post()方法，只是多加了一个添加到粘滞Map中（Map, Object> stickyEvents）步骤；每次调用register(this)时，会检查粘滞Map中是否有订阅对象，然后进行发送；粘滞事件接收后一定要记得移除。

4 造轮子的方式分析EventBus原理

4.1 基本实体类

// 订阅者类的方法实体
public class SubscriberMethod {
    /** 回调方法 */
    public Method method;
    /** 线程模式 */
    public ThreadMode threadMode;
    /** 方法中的参数 */
    public Class eventType;
    /** 是否是粘滞事件 */
    public final boolean sticky;

    public SubscriberMethod(Method method, ThreadMode threadMode, Class eventType, boolean sticky) {
        this.method = method;
        this.threadMode = threadMode;
        this.eventType = eventType;
        this.sticky = sticky;
    }
}

// 包装了订阅者+订阅者类的方法的对象
public class Subscription {
    public final Object subscriber;
    public final SubscriberMethod subscriberMethod;

    Subscription(Object subscriber, SubscriberMethod subscriberMethod) {
        this.subscriber = subscriber;
        this.subscriberMethod = subscriberMethod;
    }

    @Override
    public boolean equals(Object other) {
        if (other instanceof Subscription) {
            Subscription otherSubscription = (Subscription) other;
            return subscriber == otherSubscription.subscriber
                    && subscriberMethod.equals(otherSubscription.subscriberMethod);
        } else {
            return false;
        }
    }

    @Override
    public int hashCode() {
        return subscriber.hashCode() + subscriberMethod.eventType.hashCode();
    }
}

// 包装了订阅者+订阅者类的方法的对象 + 事件对象
public class PendingPost {
    public Object event;
    public Subscription subscription;

    public PendingPost(Object event, Subscription subscription) {
        this.event = event;
        this.subscription = subscription;
    }
}

4.2 辅助类

// 方法执行的线程
public enum ThreadMode {
    /**
     * 订阅者将在发布事件的同一线程中被直接调用。这是默认值。事件传递意味着开销最小，因为它完全避免了线程切换。
     * 因此，对于可以在很短的时间内完成而不需要主线程的简单任务，推荐使用这种模式。使用此模式的事件处理程序必须快速返回，
     * 以避免阻塞可能是主线程的发布线程。
     */
    POSTING,
    /**
     * 订阅者将在Android的主线程(UI线程)中被调用。如果发布线程是主线程、订阅方方法将被直接调用，阻塞发布线程。
     * 否则事件正在排队等待交付(非阻塞)。使用此模式的订阅者必须快速返回，以避免阻塞主线程。
     */
    MAIN,
    /**
     * 订阅者将在后台线程中被调用。如果发布线程不是主线程，订阅方方法将在发布线程中直接调用。
     * 如果提交线程是主线程，则EventBus使用单个线程后台线程，它将按顺序交付其所有事件。
     * 使用此模式的订户应尝试这样做快速返回，避免阻塞后台线程。
     */
    BACKGROUND
}

// 注解类，只有被注解订阅的方法才会被添加到集合中
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Subscribe {
     /** 线程模式 */
    ThreadMode threadMode() default ThreadMode.POSTING;
    
    /** 如果为true，则post最近的粘滞事件 */
    boolean sticky() default false;
}

// 判断是否是主线程，通常在Android上使用Android的主线程
public interface MainThreadSupport {
    boolean isMainThread();
    Poster createPoster(EventBus eventBus);

    class AndroidHandlerMainThreadSupport implements MainThreadSupport {

        private final Looper looper;

        public AndroidHandlerMainThreadSupport(Looper looper) {
            this.looper = looper;
        }

        @Override
        public boolean isMainThread() {
            return looper == Looper.myLooper();
        }

        @Override
        public Poster createPoster(EventBus eventBus) {
            return new HandlerPoster(eventBus, looper);
        }
    }
}

4.3 线程切换发布事件类

// post事件接口
interface Poster {
    /**
     * 为特定订阅加入要发布的事件队列
     *
     * @param subscription 订阅将会收到事件的订阅
     * @param event        事件将会发布给订阅者.
     */
    void enqueue(Subscription subscription, Object event);
}

// 主线程中post事件
public class HandlerPoster extends Handler implements Poster {

    private final LinkedList queue;
    private final EventBus eventBus;
    private boolean handlerActive;

    protected HandlerPoster(EventBus eventBus, Looper looper) {
        super(looper);
        this.eventBus = eventBus;
        this.queue = new LinkedList<>();
    }

    public void enqueue(Subscription subscription, Object event) {
        synchronized (this) {
            PendingPost pendingPost = new PendingPost(event, subscription);
            queue.offer(pendingPost);
            if (!handlerActive) {
                handlerActive = true;
                if (!sendMessage(obtainMessage())) {
                    Log.e(EventBus.TAG, "Could not send handler message");
                }
            }
        }
    }

    @Override
    public void handleMessage(Message msg) {
        boolean rescheduled = false;
        try {
            while (true) {
                PendingPost pendingPost = queue.poll();
                if (pendingPost == null) {
                    synchronized (this) {
                        // 再次检查，这次是同步的
                        pendingPost = queue.poll();
                        if (pendingPost == null) {
                            handlerActive = false;
                            return;
                        }
                    }
                }

                eventBus.invokeSubscriber(pendingPost.subscription, pendingPost.event);
                rescheduled = true;
            }
        } finally {
            handlerActive = rescheduled;
        }
    }
}

// 子线程中post事件
public class BackgroundPoster implements Runnable, Poster {

    private final LinkedList queue;
    private final EventBus eventBus;

    private volatile boolean executorRunning;

    BackgroundPoster(EventBus eventBus) {
        this.eventBus = eventBus;
        queue = new LinkedList<>();
    }

    public void enqueue(Subscription subscription, Object event) {
        synchronized (this) {
            PendingPost pendingPost = new PendingPost(event, subscription);
            queue.offer(pendingPost);
            if (!executorRunning) {
                executorRunning = true;
                eventBus.getExecutorService().execute(this);
            }
        }
    }

    @Override
    public void run() {
        try {
            while (true) {
                PendingPost pendingPost = queue.poll();
                if (pendingPost == null) {
                    synchronized (this) {
                        // 再次检查，这次是同步的
                        pendingPost = queue.poll();
                        if (pendingPost == null) {
                            executorRunning = false;
                            return;
                        }
                    }
                }

                eventBus.invokeSubscriber(pendingPost.subscription, pendingPost.event);
            }
        } finally {
            executorRunning = false;
        }
    }
}

4.4 EventBus

/**
 * EventBus发布/订阅事件总线
 */
public class EventBus {

    public static String TAG = "Tag_EventBus";
    private final static ExecutorService DEFAULT_EXECUTOR_SERVICE = Executors.newCachedThreadPool();
    private static volatile EventBus defaultInstance;
    /**
     * 判断是否是主线程
     */
    private final MainThreadSupport mainThreadSupport;
    private final Poster mainThreadPoster;
    private final BackgroundPoster backgroundPoster;
    /**
     * 接收 订阅者+订阅者类的方法的对象 存储在这个列表中
     */
    private final Map> subscriptionsByEventType;
    /**
     * 接收订阅者存储在这个列表中
     */
    private final Map>> typesBySubscriber;
    /**
     * 接收粘滞事件订阅者存储在这个列表中
     */
    private final Map, Object> stickyEvents;

    private EventBus() {
        this.mainThreadSupport = new MainThreadSupport.AndroidHandlerMainThreadSupport(Looper.getMainLooper());;
        this.mainThreadPoster = mainThreadSupport != null ? mainThreadSupport.createPoster(this) : null;
        this.backgroundPoster = new BackgroundPoster(this);
        this.subscriptionsByEventType = new HashMap<>();
        this.typesBySubscriber = new HashMap<>();
        this.stickyEvents = new ConcurrentHashMap<>();
    }

    /**
     * 使用一个进程范围的EventBus实例为应用程序提供方便的单例
     */
    public static EventBus getDefault() {
        if (defaultInstance == null) {
            synchronized (EventBus.class) {
                if (defaultInstance == null) {
                    defaultInstance = new EventBus();
                }
            }
        }
        return defaultInstance;
    }

    /**
     * 注册订阅者
     *
     * @param subscriber
     */
    public void register(Object subscriber) {
        List subscriptions = findSubscriberMethods(subscriber);
        synchronized (this) {
            for (Subscription subscription : subscriptions) {
                subscribe(subscriber, subscription.subscriberMethod);
            }
        }
    }

    /**
     * 订阅：Must be called in synchronized block
     *
     * @param subscriber
     * @param subscriberMethod
     */
    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class eventType = subscriberMethod.eventType;
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(subscriber);
        if (subscriptions == null) {
            subscriptions = findSubscriberMethods(subscriber);
            subscriptionsByEventType.put(subscriber, subscriptions);
        }

        List> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);

        // 如果是粘滞事件
        if (subscriberMethod.sticky) {
            Object stickyEvent = stickyEvents.get(eventType);
            if (stickyEvent != null) {
                // 如果订阅者试图中止事件，它将失败(在发布状态中不跟踪事件)
                postToSubscription(newSubscription, stickyEvent, isMainThread());
            }
        }
    }

    /**
     * 遍历订阅者类的方法
     * 通过反射获取订阅者+订阅者类的方法对象的集合，找到被SubScribe注解订阅的方法，如:onEvent()
     *
     * @param subscriber
     * @return
     */
    private CopyOnWriteArrayList findSubscriberMethods(Object subscriber) {
        CopyOnWriteArrayList subscriptions = new CopyOnWriteArrayList<>();
        Class clazz = subscriber.getClass();
        // 通过getDeclaredMethods()来获取类中所有方法而并不是通过getMethods()，由于前者只反射当前类的方法(不包括隐式继承的父类方法)，所以前者的效率较后者更高些
        Method[] methods = clazz.getDeclaredMethods();

        while (clazz != null) {
            // 找父类的时候 需要先判断一下是否是 系统级别的父类
            String name = clazz.getName();
            if (name.startsWith("java.") || name.startsWith("javax.") || name.startsWith("android.")) {
                break;
            }

            for (Method method : methods) {
                // 找到被SubScribe注解订阅的方法
                Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                if (subscribeAnnotation == null) {
                    continue;
                }
                // 判断带有Subscribe注解方法中的参数类型
                Class[] types = method.getParameterTypes();
                if (types.length != 1) {
                    Log.e(EventBus.TAG, "EventBus只接受一个参数");
                    continue;
                }

                ThreadMode threadMode = subscribeAnnotation.threadMode();
                SubscriberMethod subscriberMethod = new SubscriberMethod(method, threadMode, types[0], subscribeAnnotation.sticky());
                Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
                subscriptions.add(newSubscription);
            }

            clazz = clazz.getSuperclass();
        }

        return subscriptions;
    }


    /**
     * 发布事件
     * 匹配"被SubScribe注解订阅的方法的参数"和"发布者发布的对象"一致，即可分发Event
     *
     * @param event
     */
    public void post(final Object event) {
        // 直接循环 Map 里面的方法 找到"被SubScribe注解订阅的方法的参数"和"发布者发布的对象"一致的方法
        Set subscribers = subscriptionsByEventType.keySet();

        // 遍历所有订阅者对象，包括接口
        for (final Object subscriber : subscribers) {
            List subscriptions = subscriptionsByEventType.get(subscriber);
            if (subscriptions == null) {
                return;
            }

            // 遍历此订阅者+订阅者类的方法对象的所有方法
            for (final Subscription subscription : subscriptions) {
                // 类Class1所对应的类信息是不是Class2所对应的类信息的父类或接口，或类Class1和Class2是否相同
                if (subscription.subscriberMethod.eventType.isAssignableFrom(event.getClass())) {

                    postToSubscription(subscription, event, isMainThread());
                }
            }
        }
    }

    private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
        switch (subscription.subscriberMethod.threadMode) {
            case POSTING:
                invokeSubscriber(subscription, event);
                break;
            case MAIN:
                if (isMainThread) {
                    invokeSubscriber(subscription, event);
                } else {
                    mainThreadPoster.enqueue(subscription, event);
                }
                break;
            case BACKGROUND:
                if (isMainThread) {
                    backgroundPoster.enqueue(subscription, event);
                } else {
                    invokeSubscriber(subscription, event);
                }
                break;
            default:
                throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
        }
    }

    /**
     * 执行订阅者订阅的方法，参数是event
     *
     * @param subscription
     * @param event
     */
    public void invokeSubscriber(Subscription subscription, Object event) {
        try {
            subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            throw new IllegalStateException("Unexpected exception", e);
        }
    }

    /**
     * 将给定事件发布到事件总线并持有该事件(因为它具有粘性)。事件类型的最新粘贴事件保存在内存中，
     * 供订阅者使用{@link Subscribe#sticky()}将来访问。
     */
    public void postSticky(Object event) {
        synchronized (stickyEvents) {
            stickyEvents.put(event.getClass(), event);
        }
        // 是否应在发布后发布，以防订阅者想立即删除
        post(event);
    }

    /**
     * 获取给定类型的最新粘贴事件
     *
     * @see #postSticky(Object)
     */
    public  T getStickyEvent(Class eventType) {
        synchronized (stickyEvents) {
            return eventType.cast(stickyEvents.get(eventType));
        }
    }

    /**
     * 删除并获取给定事件类型的最近粘贴事件
     *
     * @see #postSticky(Object)
     */
    public  T removeStickyEvent(Class eventType) {
        synchronized (stickyEvents) {
            return eventType.cast(stickyEvents.remove(eventType));
        }
    }

    /**
     * 删除与给定事件相等的粘滞事件
     *
     * @return true 如果事件匹配并且粘性事件被删除
     */
    public boolean removeStickyEvent(Object event) {
        synchronized (stickyEvents) {
            Class eventType = event.getClass();
            Object existingEvent = stickyEvents.get(eventType);
            if (event.equals(existingEvent)) {
                stickyEvents.remove(eventType);
                return true;
            } else {
                return false;
            }
        }
    }

    /**
     * 删除所有粘滞事件
     */
    public void removeAllStickyEvents() {
        synchronized (stickyEvents) {
            stickyEvents.clear();
        }
    }

    /**
     * 反注册：移除订阅者和它的事件方法
     *
     * @param subscriber
     */
    public void unregister(Object subscriber) {
        List> subscribedTypes = typesBySubscriber.get(subscriber);
        if (subscribedTypes != null) {
            subscriptionsByEventType.remove(subscriber);
            typesBySubscriber.remove(subscriber);
            subscribedTypes.clear();
        } else {
            Log.e(EventBus.TAG, "Subscriber to unregister was not registered before: " + subscriber.getClass());
        }
    }

    /**
     * 检查当前线程是否在主线程中运行。如果没有主线程支持(例如非android)，总是返回“true”。
     * 在这种情况下，主线程订阅者总是在发布线程中调用，而后台订阅者总是从后台海报中调用
     */
    public boolean isMainThread() {
        return mainThreadSupport == null || mainThreadSupport.isMainThread();
    }

    /**
     * 获取线程池
     *
     * @return
     */
    public ExecutorService getExecutorService() {
        return DEFAULT_EXECUTOR_SERVICE;
    }
}
 
  
4.5 实践
 
  
// 定义事件
public class MessageEvent {
    public String name;
    public String num;
    public MessageEvent(String name, String num) {
        this.name = name;
        this.num = num;
    }
}

 
  
// EventBus发布事件页面
public class EventBusPostActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_eventbus_post);
    }

    /**
     * 在子线程中发布事件
     */
    public void postInThread(View view) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                // 在子线程中发布事件
                Log.d(EventBus.TAG, "子线程中发布 threadName :" + Thread.currentThread().getName());
                EventBus.getDefault().post(new MessageEvent("小小", "123"));
            }
        }).start();
    }

    /**
     * 在主线程中发布事件
     */
    public void postInMain(View view) {
        Log.d(EventBus.TAG, "主线程中发布 threadName :" + Thread.currentThread().getName());
        EventBus.getDefault().post(new MessageEvent("大大","456"));
    }

    /**
     * 发布粘性事件
     *
     * @param view
     */
    public void postSticky(View view) {
        Log.d(EventBus.TAG, "发布 postSticky threadName :" + Thread.currentThread().getName());
        // 粘性事件，在发送事件之后再订阅该事件也能收到。并且，粘性事件会保存在内存中，每次进入都会去内存中查找获取最新的粘性事件，除非你手动解除注册。
        EventBus.getDefault().postSticky(new MessageEvent("发布 postSticky：Hello everyone!", "789"));
    }

    /**
     * 手动获取和删除粘性事件
     *
     * @param view
     */
    public void removeStickyEvent(View view) {
        MessageEvent stickyEvent = EventBus.getDefault().getStickyEvent(MessageEvent.class);
        if(stickyEvent != null) {
            EventBus.getDefault().removeStickyEvent(stickyEvent);
        }
    }

    /**
     * 注册
     *
     * @param view
     */
    public void register(View view) {
        EventBus.getDefault().register(this);
    }

    /**
     * 反注册
     *
     * @param view
     */
    public void unRegister(View view) {
        EventBus.getDefault().unregister(this);
    }

    /**
     * 当MessageEvent被发布时将调用此方法
     *
     * 默认情况下，EventBus捕获从订阅者方法抛出的异常，并发送不强制要求处理的SubscriberExceptionEvent。
     * Caused by: EventBusException: Subscriber class ...EventBusActivity and its super classes have no public methods with the @Subscribe annotation
     *
     * @param event
     */
    @Subscribe(sticky = true, threadMode = ThreadMode.MAIN)
    public void onEventBus(MessageEvent event) {
        Log.e(EventBus.TAG,"onEventBus + 接收到EventBus事件：" + event.name);
    }

    /**
     * EventBus 是为已经存在的activity传递消息，而且订阅者必须要注册且不能被注销了，
     * 如果你在onStop里面注销了，栈中虽然有这个activity，但是EventBus并没有被注册，所以也接收不到消息，
     */
//    @Override
//    public void onStop() {
//        EventBus.getDefault().unregister(this);
//        super.onStop();
//    }

    @Override
    public void onDestroy() {
        EventBus.getDefault().unregister(this);
        super.onDestroy();
    }
}

 
  
D/Tag_EventBus: 主线程中发布 threadName :main
D/Tag_EventBus: onEvent: com.example.rxjava_example.MessageEvent@48b101b
D/Tag_EventBus: onEvent threadName :main
D/Tag_EventBus: onMessageEvent: com.example.rxjava_example.MessageEvent@48b101b
D/Tag_EventBus: onMessageEvent threadName :pool-1-thread-1

D/Tag_EventBus: 发布 postSticky threadName :main
E/Tag_EventBus: onEventBus + 接收到EventBus事件：发布 postSticky：Hello everyone!
D/Tag_EventBus: onEvent: com.example.rxjava_example.MessageEvent@a595ef6
D/Tag_EventBus: onEvent threadName :main
D/Tag_EventBus: onMessageEvent: com.example.rxjava_example.MessageEvent@a595ef6
D/Tag_EventBus: onMessageEvent threadName :pool-1-thread-1

 
  
5 EventBus源码分析
 
  
5.1 初始化
 
  
（1）EventBus.getDefault()：通过单例模式获得EventBus对象
 
  
public static EventBus getDefault() {
	EventBus instance = defaultInstance;
    if (instance == null) {
    	synchronized (EventBus.class) {
        	instance = EventBus.defaultInstance;
            if (instance == null) {
                instance = EventBus.defaultInstance = new EventBus();
            }
        }
    }
    return instance;
}

 
  
（2）通过构建EventBusBuilder来设置参数
 
  
private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();
// 保存事件参数类和Subscription List的Map
private final Map, CopyOnWriteArrayList> subscriptionsByEventType;
// 保存注册对象和事件参数类
private final Map>> typesBySubscriber;
// 粘性事件
private final Map, Object> stickyEvents;

public class EventBusBuilder {
    private final static ExecutorService DEFAULT_EXECUTOR_SERVICE = Executors.newCachedThreadPool();
    // 异常的设置
    boolean logSubscriberExceptions = true;
    boolean logNoSubscriberMessages = true;
    boolean sendSubscriberExceptionEvent = true;
    boolean sendNoSubscriberEvent = true;
    boolean throwSubscriberException;
    boolean eventInheritance = true;
    // 是否忽略生成的Index，默认为false，不忽略
    boolean ignoreGeneratedIndex;
    boolean strictMethodVerification;
    ExecutorService executorService = DEFAULT_EXECUTOR_SERVICE;
    List> skipMethodVerificationForClasses;
    List subscriberInfoIndexes;

    EventBusBuilder() {
    }
}

public EventBus() {
    this(DEFAULT_BUILDER);
}

EventBus(EventBusBuilder builder) {
    subscriptionsByEventType = new HashMap<>();
    typesBySubscriber = new HashMap<>();
    stickyEvents = new ConcurrentHashMap<>();
    // 主线程发送器
    mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
    // 后台线程发送器
    backgroundPoster = new BackgroundPoster(this);
    // 异步线程发送器
    asyncPoster = new AsyncPoster(this);
    indexCount = builder.subscriberInfoIndexes != null ? builder.subscriberInfoIndexes.size() : 0;
    subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
            builder.strictMethodVerification, builder.ignoreGeneratedIndex);
    // 异常设置
    logSubscriberExceptions = builder.logSubscriberExceptions;
    logNoSubscriberMessages = builder.logNoSubscriberMessages;
    sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;
    sendNoSubscriberEvent = builder.sendNoSubscriberEvent;
    throwSubscriberException = builder.throwSubscriberException;
    eventInheritance = builder.eventInheritance;
    executorService = builder.executorService;
}

 
  
EventBus初始化的步骤，直观上看用到单例模式和Builder模式，将构造参数给分离了出来，实际上还用到了策略模式，其中Builder中有些参数用于代码执行的策略，就说，你传的参数不一样，我执行的方式不一样，像ignoreGeneratedIndex作用就是让EventBus如何查找出订阅方法的策略。
 
  
（3）最重要的是一些缓存对象：
 
  
subscriptionsByEventType : 内部是一个Map集合，可以根据 EventType 查找订阅事件；

typesBySubscriber : 根据我们的订阅对象找到 EventType；

stickyEvents : 粘滞事件的缓存；

事件投递者 : mainThreadPoster, backgroundPoster, asyncPoster根据订阅注解ThreadMode去选择不同的投递者，不同投递者投递事件，接收函数会执行在不同的线程中；

subscriberMethodFinder ：查找方法用的，内部维护了一个订阅方法的集合。

 
  
5.2 注册register()
 
  
// Eventbus.java:
public void register(Object subscriber) {
    // 获得注册对象的class
    Class subscriberClass = subscriber.getClass();
    // 5.2.1 查找订阅者被订阅的方法
    List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
    synchronized (this) {
        for (SubscriberMethod subscriberMethod : subscriberMethods) {
            // 5.2.2 订阅
            subscribe(subscriber, subscriberMethod);
        }
    }
}

 
  
Android源码分析之EventBus框架_第2张图片
 
  
5.2.1 findSubscriberMethods()找出一个SubscriberMethod的集合
 
  
当我们调用register(this)的时候就把订阅者给传了进来，主要就两个步骤：第一个findSubscriberMethods()找出一个SubscriberMethod的集合，然后就遍历 SubscriberMethod的集合去订阅事件，我们先看**findSubscriberMethods()**里面到底做了什么，返回的是什么？
 
  
// SubscriberMethodFinder.java:
List findSubscriberMethods(Class subscriberClass) {
    // 5.2.1.1 从方法缓存中查找
    List subscriberMethods = METHOD_CACHE.get(subscriberClass);
    // 找到直接返回
    if (subscriberMethods != null) {
        return subscriberMethods;
    }

    // 是否忽略生成的Index（高级用法会通过编译时注解生成，这里不会）
    // ignoreGeneratedIndex默认为false，进入下面的代码
    if (ignoreGeneratedIndex) {
        // 5.2.1.3 通过反射获取方法
        subscriberMethods = findUsingReflection(subscriberClass);
    } else {
        // 5.2.1.2 通过subscriberInfo获取方法
        subscriberMethods = findUsingInfo(subscriberClass);
    }
    // 如果没有找到方法，抛出异常（常见的这个异常，没有@Subscribe方法）
    if (subscriberMethods.isEmpty()) {
        throw new EventBusException("Subscriber " + subscriberClass+ " and its super classes have no public methods with the @Subscribe annotation");
    } else {
        // 5.2.1.4 找到订阅方法后放入缓存，以免下次继续重新查找
        METHOD_CACHE.put(subscriberClass, subscriberMethods);
        return subscriberMethods;
    }
}

 
  
5.2.1.1 首先，从缓存METHOD_CACHE中检查是否拥有当前订阅类，找到直接返回；
 
  
5.2.1.4 最后，找到订阅方法后放入缓存METHOD_CACHE中，以免下次重新查找订阅方法；
 
  
5.2.1.3 通过反射获取方法，ignoreGeneratedIndex为true，那会执行findUsingReflection()方法通过反射来调用
 
  
// SubscriberMethodFinder.java
private List findUsingReflection(Class subscriberClass) {
        FindState findState = prepareFindState();
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            // 5.2.1.2（3）第3步，进入**findUsingReflectionInSingleClass通过反射来调用**
            findUsingReflectionInSingleClass(findState);
            findState.moveToSuperclass();
        }
        return getMethodsAndRelease(findState);
    }

 
  
findUsingReflectionInSingleClass(findState)的分析请看：5.2.1.2（3）第3步，进入findUsingReflectionInSingleClass通过反射来调用。
 
  
5.2.1.2 通过subscriberInfo获取方法，ignoreGeneratedIndex默认就是false，那会执行findUsingInfo()方法：
 
  
// SubscriberMethodFinder.java:
private List findUsingInfo(Class subscriberClass) {
    // 第1步：从池中或创建或使用
    FindState findState = prepareFindState();
    // 初始化
    findState.initForSubscriber(subscriberClass);
    while (findState.clazz != null) {
        // 第2步：调用getSubscriberInfo查找是否有添加的SubscriberInfoIndex，这个是需要添加编译器支持，
        // 并且在编译器自动生成，需要手动添加的，默认是没有添加的
        findState.subscriberInfo = getSubscriberInfo(findState);
        if (findState.subscriberInfo != null) {
            SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods();
            for (SubscriberMethod subscriberMethod : array) {
                if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {
                    findState.subscriberMethods.add(subscriberMethod);
                }
            }
        } else {
            // 第3步：如果没有找到，通过反射来查找
            findUsingReflectionInSingleClass(findState);
        }
        // 获得其父类
        findState.moveToSuperclass();
    }
    // 第4步：获得方法并释放FindState对象
    return getMethodsAndRelease(findState);
}

 
  
第1步，通过池取出或创建一个FindState对象，FindState中维护的就是我们对订阅方法查找结果的封装，initForSubscriber()就是将我们的订阅者传给FindState对象
 
  
private FindState prepareFindState() {
        synchronized (FIND_STATE_POOL) {
            for (int i = 0; i < POOL_SIZE; i++) {
                FindState state = FIND_STATE_POOL[i];
                if (state != null) {
                    FIND_STATE_POOL[i] = null;
                    return state;
                }
            }
        }
        return new FindState();
    }

 
  
第3步，进入findUsingReflectionInSingleClass通过反射来调用
 
  
// SubscriberMethodFinder.java:
private void findUsingReflectionInSingleClass(FindState findState) {
    Method[] methods;
    try {
        // 1、获得类的方法
        methods = findState.clazz.getDeclaredMethods();
    } catch (Throwable th) {
        methods = findState.clazz.getMethods();
        findState.skipSuperClasses = true;
    }
    for (Method method : methods) {
        int modifiers = method.getModifiers();
        // 2、如果方法的修饰符是public并且不是 Modifier.ABSTRACT | Modifier.STATIC | BRIDGE | SYNTHETIC
        if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
            // 获得参数类型数组
            Class[] parameterTypes = method.getParameterTypes();
            // 如果参数是一个
            if (parameterTypes.length == 1) {
                // 判断该方法是否被Subscribe注解修饰
                Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                // 如果还有Subscribe注解，则将参数类型
                if (subscribeAnnotation != null) {
                    Class eventType = parameterTypes[0];
                    // 3、检验下是否之前已经添加了SubscriberMethod对象
                    if (findState.checkAdd(method, eventType)) {
                        // 返回false，说明其父类也有这个方法
                        // 返回true，说明其父类没有这个方法，findState.subscriberMethods中添加SubscriberMethod对象
                        ThreadMode threadMode = subscribeAnnotation.threadMode();
                        findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
                    }
                }
            } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
                // 抛出参数过多的异常
                String methodName = method.getDeclaringClass().getName() + "." + method.getName();
                throw new EventBusException("@Subscribe method " + methodName +
                        "must have exactly 1 parameter but has " + parameterTypes.length);
            }
        } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
            // 抛出方法修饰符不正确异常
            String methodName = method.getDeclaringClass().getName() + "." + method.getName();
            throw new EventBusException(methodName +
                    " is a illegal @Subscribe method: must be public, non-static, and non-abstract");
        }
    }
}

 
  
（1）反射的3个步骤：
 
  
1、获得类的方法；
2、遍历类，并且检查：
（1）检查方法修饰符是不是public；
（2）检查参数数量是不是等于1；
（3）检查方法是否还有Subscribe注解；
三个条件都满足的话，则需要检查方法和参数类型是否已经存在，是否此方法需要添加threadMode；
3、根据检查结果来判断是否添加SubscriberMethod对象；

 
  
（2）添加订阅方法前有个检查checkAdd方法：
 
  
// SubscriberMethodFinder.java:
boolean checkAdd(Method method, Class eventType) {
    // 分两步检查：
    // 1. 检查参数类型是不是已经存在
    // 2. 通过方法签名（可以说是名称拼接）来判断
    Object existing = anyMethodByEventType.put(eventType, method);
    // 不存在接收该参数类型的方法
    if (existing == null) {
        return true;
    } else {
        // 存在接收该参数类型的方法，这里应该比较少见。应该就是不同的方法但是都有相同的参数
        if (existing instanceof Method) {
            if (!checkAddWithMethodSignature((Method) existing, eventType)) {
                throw new IllegalStateException();
            }
            // Put any non-Method object to "consume" the existing Method
            anyMethodByEventType.put(eventType, this);
        }
        return checkAddWithMethodSignature(method, eventType);
    }
}

// SubscriberMethodFinder.java:
private boolean checkAddWithMethodSignature(Method method, Class eventType) {
    methodKeyBuilder.setLength(0);
    methodKeyBuilder.append(method.getName());
    methodKeyBuilder.append('>').append(eventType.getName());

    // 将方法名和事件类型当作key，来保存方法
    String methodKey = methodKeyBuilder.toString();
    Class methodClass = method.getDeclaringClass();
    Class methodClassOld = subscriberClassByMethodKey.put(methodKey, methodClass);
    // 如果我们保存的是父类，就返回 true
    if (methodClassOld == null || methodClassOld.isAssignableFrom(methodClass)) {
        // Only add if not already found in a sub class
        return true;
    } else {
        // 如果是子类，就将传来的方法保存起来，返回 false
        subscriberClassByMethodKey.put(methodKey, methodClassOld);
        return false;
    }
}

 
  
这里又做了一个优化，将方法名和事件类型当作key，来保存方法，将传来的方法类型和我们签名的保存的比较；如果我们保存的是父类，就返回true，如果是子类，就将传来的方法保存起来，返回false。这样做的意图是：如果有父类的方法了，就没有必要添加子类的方法了，因为继承会执行到的。
 
  
第2步，从subscriberInfoIndexes中查找订阅信息的，在编译期创建索引并找到我们的订阅信息了，不会在运行期做任何事情，所以这个效率是非常高的，这也是EventBus3.0中增加了一个新特性。
 
  
EventBus提供了一个EventBusAnnotationProcessor注解处理器来在编译期通过读取@Subscribe()注解并解析，处理其中所包含的信息，然后生成java类来保存所有订阅者关于订阅的信息，这样就比在运行时使用反射来获得这些订阅者的信息速度要快。
 
  
private SubscriberInfo getSubscriberInfo(FindState findState) {
        // 查找FindState的缓存是否有订阅信息，有则直接返回
        if (findState.subscriberInfo != null && findState.subscriberInfo.getSuperSubscriberInfo() != null) {
            SubscriberInfo superclassInfo = findState.subscriberInfo.getSuperSubscriberInfo();
            if (findState.clazz == superclassInfo.getSubscriberClass()) {
                return superclassInfo;
            }
        }
        
        // 从subscriberInfoIndexes中查找订阅信息（EventBusBuilder的subscriberInfoIndexes）
        if (subscriberInfoIndexes != null) {
            for (SubscriberInfoIndex index : subscriberInfoIndexes) {
                SubscriberInfo info = index.getSubscriberInfo(findState.clazz);
                if (info != null) {
                    return info;
                }
            }
        }
        return null;
    }

 
  
（1）在项目的app的build.gradle中添加如下配置：
 
  
android {
    defaultConfig {
        // EventBus processor
        javaCompileOptions {
            // 注解处理器参数配置
            annotationProcessorOptions {
                // 配置参数名和值
                arguments = [eventBusIndex: 'com.seniorlibs.thirdlib.MyEventBusIndex']
            }
        }
    }
}

dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    // EventBus
    api 'org.greenrobot:eventbus:3.2.0'
    // EventBus processor
    annotationProcessor 'org.greenrobot:eventbus-annotation-processor:3.2.0'
}

 
  
（2）然后rebulid，在\build\generated\source\apt\com.seniorlibs.thirdlib\下看到通过注解分析生成的索引类MyEventBusIndex
 
  
public class MyEventBusIndex implements SubscriberInfoIndex {
    private static final Map, SubscriberInfo> SUBSCRIBER_INDEX;

    static {
        SUBSCRIBER_INDEX = new HashMap, SubscriberInfo>();

        putIndex(new SimpleSubscriberInfo(com.seniorlibs.thirdlib.eventbus.EventBusActivity.class, true,
                new SubscriberMethodInfo[] {
            new SubscriberMethodInfo("onMessageEvent", com.seniorlibs.thirdlib.eventbus.MessageEvent.class,
                    ThreadMode.MAIN, 0, true),
        }));
    }

    private static void putIndex(SubscriberInfo info) {
        SUBSCRIBER_INDEX.put(info.getSubscriberClass(), info);
    }

    @Override
    public SubscriberInfo getSubscriberInfo(Class subscriberClass) {
        SubscriberInfo info = SUBSCRIBER_INDEX.get(subscriberClass);
        if (info != null) {
            return info;
        } else {
            return null;
        }
    }
}

 
  
（3）在Application中通过EventBus初始化，将这个类给传进去：
 
  
EventBus.builder().addIndex(new MyEventBusIndex()).installDefaultEventBus().register(this);

 
  
（4）MyEventBusIndex在初始化时，直接会将订阅者相关信息缓存在Map中，并实现了SubscriberInfoIndex接口，在实现方法getSubscriberInfo中根据订阅类返回对应的订阅者信息。在编译过程中就已经找到我们的订阅信息了，不会在运行期做任何事情，所以这个效率是非常高的。
 
  
第4步，获得方法并释放FindState对象：
 
  
// SubscriberMethodFinder.java:
private List getMethodsAndRelease(FindState findState) {
    // 创建List并返回
    List subscriberMethods = new ArrayList<>(findState.subscriberMethods);
    
    // 池回收并将给池中的为空的位置赋值，方便findState下次使用，不需要
    findState.recycle();
    synchronized (FIND_STATE_POOL) {
        for (int i = 0; i < POOL_SIZE; i++) {
            if (FIND_STATE_POOL[i] == null) {
                FIND_STATE_POOL[i] = findState;
                break;
            }
        }
    }
    return subscriberMethods;
}

 
  
从这里，我们就知道作者设计FindState池的初心了，解析完了之后，将订阅方法赋给List集合，再回收FindState，继续接收解析，内存没有半点浪费。
 
  
5.2.2 需要订阅的方法已经找到，接下来将方法订阅-subscribe()
 
  
// EventBus.java
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
    // 参数类型
    Class eventType = subscriberMethod.eventType;
    // 根据订阅者和订阅方法构造一个订阅事件
    Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
    // subscriptionsByEventType是根据eventType去查找subscriptions集合
    CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType);
 
    // 看看缓存中有没有，没有则放进缓存 
    if (subscriptions == null) {
        subscriptions = new CopyOnWriteArrayList<>();
        subscriptionsByEventType.put(eventType, subscriptions);
    } else {
        // 已经存在的话，抛出异常
        if (subscriptions.contains(newSubscription)) {
            throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event " + eventType);
        }
    }
    
    // 遍历订阅事件，找到比subscriptions中订阅事件大的优先级，然后插入。就可以根据优先级依次投递事件了
    int size = subscriptions.size();
    for (int i = 0; i <= size; i++) {
        if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {
            subscriptions.add(i, newSubscription);
            break;
        }
    }

    // typesBySubscriber是根据订阅者去查找EventType的缓存，并保存起来。为的是unregister(this)，根据this去解绑事件
    List> subscribedEvents = typesBySubscriber.get(subscriber);
    if (subscribedEvents == null) {
        subscribedEvents = new ArrayList<>();
        typesBySubscriber.put(subscriber, subscribedEvents);
    }
    // 添加新的参数类型
    subscribedEvents.add(eventType);
    
    // 如果是粘性，就立刻处理
    if (subscriberMethod.sticky) {
        // 构造是默认为true
        if (eventInheritance) {
            // EventType的子类也应该考虑
            Set, Object>> entries = stickyEvents.entrySet();
            for (Map.Entry, Object> entry : entries) {
                Class candidateEventType = entry.getKey();
                // 参数类型是存储的父类或者相同
                if (eventType.isAssignableFrom(candidateEventType)) {
                    Object stickyEvent = entry.getValue();
                    // 如果有值的话发送事件
                    // 意味着如果粘性事件的参数类型存在，并且对应的值也存在的话将发送事件
                    checkPostStickyEventToSubscription(newSubscription, stickyEvent);
                }
            }
        } else {
            Object stickyEvent = stickyEvents.get(eventType);
            checkPostStickyEventToSubscription(newSubscription, stickyEvent);
        }
    }
}

 
  
订阅其实里面就做了两件事：
 （1）第1件事：遍历订阅方法和订阅者，订阅者和订阅方法的参数类型保存起来，封装到subscriptionsByEventType和typesBySubscriber，至于这两个对象是干什么的呢？subscriptionsByEventType是我们投递订阅事件的时候，就是根据订阅方法参数类型EventType找到订阅事件subscriberMethod，从而去分发处理事件；typesBySubscriber是在调用unregister(this) 的时候，根据订阅者subscriber找到订阅方法参数类型EventType，又根据EventType找到订阅事件，从而解绑。
 Android源码分析之EventBus框架_第3张图片
 （2）第2件事：如果是粘性事件的话，就立马投递并执行。
 
  
5.3 发布post
 
  
public void post(Object event) {
    // 使用ThreadLocal来确保每个线程都维护了一个投递状态PostingThreadState
    PostingThreadState postingState = currentPostingThreadState.get();
    // 获取事件队列
    List eventQueue = postingState.eventQueue;
    // 将最新的事件添加到队尾
    eventQueue.add(event);
    
    // 如果当前没有进行中的事件
    if (!postingState.isPosting) {
        // 设置当前线程是否为主线程
        postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper();
        // 设置正在发送状态
        postingState.isPosting = true;
        if (postingState.canceled) {
            throw new EventBusException("Internal error. Abort state was not reset");
        }
        try {
            // PostingThreadState是维护了投递的状态，最后循环投递，直到PostingThreadState中的EventQueue为空
            while (!eventQueue.isEmpty()) {
                // 发送事件
                postSingleEvent(eventQueue.remove(0), postingState);
            }
        } finally {
            postingState.isPosting = false;
            postingState.isMainThread = false;
        }
    }
}
 
  
Android源码分析之EventBus框架_第4张图片
 
  
5.3.1 调用postToSubscription()通过策略模式实现线程模式
 
  
调用post(Object object) 的方法的时候就执行了上面的代码，PostingThreadState是维护了投递的状态，最后循环投递，直到 PostingThreadState中的EventQueue为空。那么代码最终执行到postToSubscription()，根据ThreadMode去处理事件，通过策略模式实现线程模式：
 
  
private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
    // 根据订阅方法的threadMode来判断如何执行
    switch (subscription.subscriberMethod.threadMode) {
        // 默认，在哪个线程发送在哪个线程执行
        case POSTING:
            invokeSubscriber(subscription, event);
            break;
        // 最终执行在主线程中
        case MAIN:
            if (isMainThread) {
                invokeSubscriber(subscription, event);
            } else {
                mainThreadPoster.enqueue(subscription, event);
            }
            break;
        // 后台线程
        case BACKGROUND:
            if (isMainThread) {
                backgroundPoster.enqueue(subscription, event);
            } else {
                invokeSubscriber(subscription, event);
            }
            break;
        // 异步线程
        case ASYNC:
            asyncPoster.enqueue(subscription, event);
            break;
        default:
            throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
    }
}

 
  
Android源码分析之EventBus框架_第5张图片
 
  
5.3.2 主线程模式HandlerPoster
 
  
当线程模式是主线程的时候，意味着需要执行的代码在主线程中操作，就是通过反射，直接运行订阅的方法；如果不是主线程，需要mainThreadPoster将订阅事件入队列。一起看看mainThreadPoster的工作原理：
 
  
//  HandlerPoster.java
public class HandlerPoster extends Handler implements Poster {
    private final PendingPostQueue queue;
    private final int maxMillisInsideHandleMessage;
    private final EventBus eventBus;
    private boolean handlerActive;

    protected HandlerPoster(EventBus eventBus, Looper looper, int maxMillisInsideHandleMessage) {
        super(looper);
        this.eventBus = eventBus;
        this.maxMillisInsideHandleMessage = maxMillisInsideHandleMessage;
        queue = new PendingPostQueue();
    }

    public void enqueue(Subscription subscription, Object event) {
        PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
        synchronized (this) {
            queue.enqueue(pendingPost);
            if (!handlerActive) {
                handlerActive = true;
                if (!sendMessage(obtainMessage())) {
                    throw new EventBusException("Could not send handler message");
                }
            }
        }
    }

    @Override
    public void handleMessage(Message msg) {
        boolean rescheduled = false;
        try {
            long started = SystemClock.uptimeMillis();
            while (true) {
                PendingPost pendingPost = queue.poll();
                if (pendingPost == null) {
                    synchronized (this) {
                        // Check again, this time in synchronized
                        pendingPost = queue.poll();
                        if (pendingPost == null) {
                            handlerActive = false;
                            return;
                        }
                    }
                }
                eventBus.invokeSubscriber(pendingPost);
                long timeInMethod = SystemClock.uptimeMillis() - started;
                if (timeInMethod >= maxMillisInsideHandleMessage) {
                    if (!sendMessage(obtainMessage())) {
                        throw new EventBusException("Could not send handler message");
                    }
                    rescheduled = true;
                    return;
                }
            }
        } finally {
            handlerActive = rescheduled;
        }
    }
}

 
  
其实在EventBus初始化的时候，mainThreadPoster就已经获取主线程的Looper了，就是用到了Android的消息处理机制：Looper、Handler，至于消息队列是自己维护的一个单向的链表。每次向Andorid的主线程Looper投递一个空消息，然后在 HandlerMessage()方法里面从自己维护的队列中取出PendingPost 进行处理。而PendingPost中维护的是订阅事件，EventType 和下一个PendingPost的地址：
 
  
final class PendingPost {
    private final static List pendingPostPool = new ArrayList();
    Object event;
    Subscription subscription;
    PendingPost next;
}

 
  
5.3.3 子线程模式BackgroundPoster
 
  
// BackgroundPoster.java:
final class BackgroundPoster implements Runnable {
    private final PendingPostQueue queue;
    private final EventBus eventBus;
    private volatile boolean executorRunning;

    BackgroundPoster(EventBus eventBus) {
        this.eventBus = eventBus;
        queue = new PendingPostQueue();
    }

    public void enqueue(Subscription subscription, Object event) {
        PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
        synchronized (this) {
            // 入队操作
            queue.enqueue(pendingPost);
            if (!executorRunning) {
                executorRunning = true;
                // 这里用到了线程池去执行
                eventBus.getExecutorService().execute(this);
            }
        }
    }

    @Override
    public void run() {
        try {
            try {
                // 出队，执行队列中所有的事件
                while (true) {
                    PendingPost pendingPost = queue.poll(1000);
                    if (pendingPost == null) {
                        synchronized (this) {
                            // 再次检测，如果还没有则执行结束
                            pendingPost = queue.poll();
                            if (pendingPost == null) {
                                executorRunning = false;
                                return;
                            }
                        }
                    }
                    // 存在PendingPost对象，调用EventBus去执行订阅者订阅的方法
                    eventBus.invokeSubscriber(pendingPost);
                }
            } catch (InterruptedException e) {
                Log.w("Event", Thread.currentThread().getName() + " was interruppted", e);
            }
        } finally {
            executorRunning = false;
        }
    }
}

// executorService的默认值是下面的线程池
public static ExecutorService newCachedThreadPool() {
    return new ThreadPoolExecutor(0, Integer.MAX_VALUE, 60L, TimeUnit.SECONDS, new SynchronousQueue());
}

 
  
BackgroundPoster这里面维护了一个队列，如果此发送器正在执行，则将此次事件的PendingPost（将要发送的事件）对象加入队列的尾部，在子线程的run方法中通过PendingPostQueue.poll()方法获得第一个PendingPost对象，并且调用eventBus.invokeSubscriber(pendingPost)去执行订阅的方法。
 
  
5.3.4 最终反射调用方法invokeSubscriber()执行订阅的方法
 
  
// EventBus.java:
void invokeSubscriber(PendingPost pendingPost) {
    Object event = pendingPost.event;
    Subscription subscription = pendingPost.subscription;
    PendingPost.releasePendingPost(pendingPost);
    if (subscription.active) {
        // 如果没有取消注册，这个变量是volatile修饰，每次都会取最新值
        // 调用invokeSubscriber方法执行订阅的方法
        invokeSubscriber(subscription, event);
    }
}

void invokeSubscriber(Subscription subscription, Object event) {
    try {
        // 执行订阅者订阅的方法，参数是event
        subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
    } catch (InvocationTargetException e) {
        handleSubscriberException(subscription, event, e.getCause());
    } catch (IllegalAccessException e) {
        throw new IllegalStateException("Unexpected exception", e);
    }
}

 
  
5.4 反注册unregister()
 
  
public synchronized void unregister(Object subscriber) {
        List> subscribedTypes = typesBySubscriber.get(subscriber);
        if (subscribedTypes != null) {
            for (Class eventType : subscribedTypes) {
                unsubscribeByEventType(subscriber, eventType);
            }
            typesBySubscriber.remove(subscriber);
        } else {
            logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
        }
    }

 
  
**反注册就是通过EventBus中typesBySubscriber这个属性，通过订阅者subscriber去查找订阅事件eventType，然后去一一解绑的。**当然，反注册主要是为了提高效率的，不然订阅的事件太多，非常影响性能。
 
  
5.5 新特性-粘滞事件
 
  
看订阅中的最后一段代码呢？5.2.2 需要订阅的方法已经找到，接下来将方法订阅-subscribe()
 
  
// EventBus.java
 // 如果是粘性，就立刻处理
    if (subscriberMethod.sticky) {
        // 构造是默认为true
        if (eventInheritance) {
            // EventType的子类也应该考虑
            Set, Object>> entries = stickyEvents.entrySet();
            for (Map.Entry, Object> entry : entries) {
                Class candidateEventType = entry.getKey();
                // 参数类型是存储的父类或者相同
                if (eventType.isAssignableFrom(candidateEventType)) {
                    Object stickyEvent = entry.getValue();
                    // 如果有值的话发送事件
                    // 意味着如果粘性事件的参数类型存在，并且对应的值也存在的话将发送事件
                    checkPostStickyEventToSubscription(newSubscription, stickyEvent);
                }
            }
        } else {
            Object stickyEvent = stickyEvents.get(eventType);
            checkPostStickyEventToSubscription(newSubscription, stickyEvent);
        }
    }
    
private void checkPostStickyEventToSubscription(Subscription newSubscription, Object stickyEvent) {
        if (stickyEvent != null) {
            postToSubscription(newSubscription, stickyEvent, isMainThread());
        }
    }

 
  
// 发布粘性事件
public void postSticky(Object event) {
    synchronized (stickyEvents) {
        stickyEvents.put(event.getClass(), event);
    }
    post(event);
}

 
  
// 手动获取和删除粘性事件
public boolean removeStickyEvent(Object event) {
        synchronized (stickyEvents) {
            Class eventType = event.getClass();
            Object existingEvent = stickyEvents.get(eventType);
            if (event.equals(existingEvent)) {
                stickyEvents.remove(eventType);
                return true;
            } else {
                return false;
            }
        }
    }

 
  
6 优秀的思想和设计
 
  
6.1
 
  
6.2
 
  
7 EventBus面试题解答
 
  
7.1
 
  
7.2
 
  
8 学习链接
 
  
Android——EventBus源码分析
 
  
EventBus 3.0源码解析
 
  
Android主流三方库源码分析（九、深入理解EventBus源码）
 
  
EventBus3.0使用及源码分析（包含UML图）
 
  
EventBus3.0解析之注解处理器分析
 
  
GitHub-EventBus仓库
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(源码分析)

        

            

                
    
                    
  • 鸿蒙轻内核M核源码分析系列二一 05 文件系统FatFS
                        愿天堂没有996
OpenHarmony鸿蒙内核移动开发harmonyos鸿蒙开发移动开发鸿蒙内核LiteOS-M鸿蒙源码轻内核
                        
    3、LiteOS-MFATFS的文件系统操作接口快速记录下各个操作接口，对每个接口的用途用法不再描述。可以参考之前的系列文章，《鸿蒙轻内核M核源码分析系列十九MuslLibC》中介绍了相关的接口，那些接口会调用VFS文件系统中操作接口，然后进一步调用FatFS文件操作接口。3.1挂载和卸载操作先看下挂载操作，FatFS支持重新挂载操作。如果挂载选项包含MS_REMOUNT时，会调用函数Remoun
    
                    
    • 
                    
  • Ubuntu 下 nginx-1.24.0 源码分析 - ngx_conf_add_dump
                        若云止水
nginxlinux
                        
    ngx_conf_add_dump定义在src\core\ngx_conf_file.cstaticngx_int_tngx_conf_add_dump(ngx_conf_t*cf,ngx_str_t*filename){off_tsize;u_char*p;uint32_thash;ngx_buf_t*buf;ngx_str_node_t*sn;ngx_conf_dump_t*cd;hash=n
    
                    
    • 
                    
  • Ubuntu 下 nginx-1.24.0 源码分析 - ngx_fd_info
                        若云止水
nginx运维
                        
    ngx_fd_info定义在src\os\unix\ngx_files.h#definengx_fd_info(fd,sb)fstat(fd,sb)fstat()是POSIX标准中定义的一个系统调用函数，用于获取与已打开文件描述符关联的文件状态信息。它通过填充一个structstat结构体来返回文件的元数据（如大小、权限、时间戳等）。以下是详细解释：函数原型#include#include#inc
    
                    
    • 
                    
  • Ubuntu 下 nginx-1.24.0 源码分析 - ngx_conf_t
                        若云止水
ubuntunginx数据库
                        
    ngx_conf_t定义在src/core/ngx_core.htypedefstructngx_conf_sngx_conf_t;ngx_conf_s定义在src/core/ngx_conf_file.hstructngx_conf_s{char*name;ngx_array_t*args;ngx_cycle_t*cycle;ngx_pool_t*pool;ngx_pool_t*temp_poo
    
                    
    • 
                    
  • Ubuntu 下 nginx-1.24.0 源码分析 - ngx_get_full_name 函数
                        若云止水
nginx运维
                        
    ngx_get_full_name声明在src/core/ngx_file.hngx_int_tngx_get_full_name(ngx_pool_t*pool,ngx_str_t*prefix,ngx_str_t*name);定义在src\core\ngx_file.cngx_int_tngx_get_full_name(ngx_pool_t*pool,ngx_str_t*prefix,ngx
    
                    
    • 
                    
  • Ubuntu 下 nginx-1.24.0 源码分析 - ngx_file_t
                        若云止水
nginx数据库运维
                        
    ngx_file_t定义在src/core/ngx_core.htypedefstructngx_file_sngx_file_t;ngx_file_s定义在src/core/ngx_file.hstructngx_file_s{ngx_fd_tfd;ngx_str_tname;ngx_file_info_tinfo;off_toffset;off_tsys_offset;ngx_log_t*lo
    
                    
    • 
                    
  • 【十二】Golang 映射
                        张胤尘
Golanggolang开发语言后端
                        
    欢迎来到张胤尘的开源技术站开源如江河，汇聚众志成。代码似星辰，照亮行征程。开源精神长，传承永不忘。携手共前行，未来更辉煌文章目录映射映射的定义映射初始化`make`函数使用字面量源码分析数据结构`hmap``bmap`数据存储键值访问竞态检测`Sanitizer`检测空检查并发写检查哈希值计算桶定位扩容情况处理桶内查找键值插入、扩容机制参数检查竞态检测`Sanitizer`检测并发检测哈希值计算初
    
                    
    • 
                    
  • 【llm对话系统】大模型源码分析之 LLaMA 模型的 Masked Attention
                        kakaZhui
llama人工智能AIGCchatgptpython
                        
    在大型语言模型（LLM）中，注意力机制（AttentionMechanism）是核心组成部分。然而，在自回归（autoregressive）模型中，例如LLaMA，我们需要对注意力进行屏蔽（Masking），以防止模型“偷看”未来的信息。本文将深入探讨LLaMA模型中MaskedAttention的实现逻辑，并对比其他类型大模型中常用的MaskedAttention方案。1.什么是MaskedAt
    
                    
    • 
                    
  • ArrayList 源码分析
                        2401_85327573
java开发语言
                        
    ArrayList简介ArrayList的底层是数组队列，相当于动态数组。与Java中的数组相比，它的容量能动态增长。在添加大量元素前，应用程序可以使用ensureCapacity操作来增加ArrayList实例的容量。这可以减少递增式再分配的数量。ArrayList继承于AbstractList，实现了List,RandomAccess,Cloneable,java.io.Serializabl
    
                    
    • 
                    
  • 鸿蒙OH源码分析——分布式软总线：trans_service模块(2)/会话管理之新会话
                        彭家大少
嵌入式硬件openHarmony鸿蒙南向harmonyos分布式OpenHarmony嵌入式开发软总线c语言
                        
    往期学习笔录：鸿蒙（OpenHarmony）南向开发保姆级知识点汇总~鸿蒙应用开发与鸿蒙系统开发哪个更有前景？嵌入式开发适不适合做鸿蒙南向开发？看完这篇你就了解了~鸿蒙岗位需求突增！移动端、PC端、IoT到底该怎么选？记录一场鸿蒙开发岗位面试经历~持续更新中……一、概述trans_service模块基于系统内核提供的socket通信，向authmanager模块提供设备认证通道管理和设备认证数据的
    
                    
    • 
                    
  • 【Java设计模式】Java设计模式之（十五）策略模式（Strategy Pattern）
                        No8g攻城狮
Java设计模式设计模式java开发语言
                        
    本文目录一、策略模式介绍1.1含义1.2适用场景1.3主要解决1.4应用实例1.5优缺点二、策略模式实现2.1类图2.2代码实现第一个案例：策略模式代码实现第二个案例：策略模式代码实现2.3角色分析三、源码分析这种类型的设计模式属于行为型模式。一、策略模式介绍1.1含义在策略模式（StrategyPattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。在策略模式
    
                    
    • 
                    
  • Spring MVC 之父子容器详解
                        码农爱java
【SpringMVC】springmvcjava父子容器SpringMVC面试
                        
    前言：前面在分析SpringMVC初始化源码的时候也提到过父容器的概念，当时我们只是对源码进行解析，并没有去深究为什么要有父容器和子容器，本篇我们将对SpringMVC中的父子容器进行分析。SpringMVC知识传送门：详解SpringMVC（SpringMVC简介）SpringMVC初始化源码分析SpringMVC工作流程源码分析SpringMVC源码分析之DispatcherServlet#g
    
                    
    • 
                    
  • 恢复更新--vue源码系列1之如何看源码
                        @LitterFisher
vuevue.jsjavascript前端
                        
    年过完了，是时候学习了（狗头）。文章目录前言一、前提二、如何看1.学会断点debuger2.整体看代码3.结合别人的vue源码解释总结前言本系列为vue2.6版本的源码分析系列一、前提你总不能一个vue的项目也没写过吧二、如何看1.学会断点debuger巧妙运用这个你会发现看源码会轻松很多。（相信我如果不是很快你就从入门到放弃）为什么？vue里面做了很多性能优化，参数初始化的工作，如果你全部看完，
    
                    
    • 
                    
  • 深入剖析 Spring Boot 中 @EnableAutoConfiguration：从源码到实际应用
                        狂飙程序员
springboot后端javaspring开发语言
                        
    引言SpringBoot以其“约定优于配置”的先进理念，极大地简化了Spring应用的开发流程。其中，@EnableAutoConfiguration注解作为SpringBoot自动配置机制的核心，发挥着举足轻重的作用。它允许SpringBoot根据项目中添加的依赖自动配置Spring应用，大大减少了开发者手动配置的工作量。本文将从架构师和源码分析的角度出发，深入探讨@EnableAutoConf
    
                    
    • 
                    
  • Ubuntu 下 nginx-1.24.0 源码分析 - ngx_set_inherited_sockets
                        若云止水
nginx运维
                        
    ngx_set_inherited_sockets声明在src/core/ngx_connection.hngx_int_tngx_set_inherited_sockets(ngx_cycle_t*cycle);实现在src/core/ngx_connection.cngx_int_tngx_set_inherited_sockets(ngx_cycle_t*cycle){size_tlen;n
    
                    
    • 
                    
  • Qt源码解析4-事件系统
                        道格拉斯范朋克
Qtqt开发语言QEvent
                        
    Qt源码解析索引本文介绍事件系统的理论说明，代码相关在专栏的其他博客Qt源码解析4-事件系统-事件循环原理源码分析_xinqingwuji的博客-CSDN博客在Qt中，事件是由抽象类QEvent派生而来的对象，它表示应用程序内部发生的事情或应用程序需要知道的外部活动的结果。QObject子类的任何实例都可以接收和处理事件，但它们与小部件特别相关。本文档描述了在典型应用程序中如何交付和处理事件。1、
    
                    
    • 
                    
  • 如何系统成为高级Qt工程师？
                        Qt历险记
Qt高级开发工程师qt开发语言qt6.3linux
                        
    要系统性地成为高级Qt工程师，需要从基础到进阶逐步构建知识体系，并结合实战经验、源码分析和架构设计能力的提升。以下是分阶段的系统性学习路径和建议：一、夯实基础阶段C++深度掌握精通C++11/14/17特性（智能指针、lambda、移动语义等）理解面向对象设计、设计模式（如观察者模式与Qt信号槽的关联）熟悉内存管理、多线程编程（std::thread、锁机制）Qt核心机制深入理解Qt元对象系统（M
    
                    
    • 
                    
  • 【go语言之http server源码分析】
                        不爱学习的王小小
golanghttpjava
                        
    go语言之http源码分析go原生服务端ListenAndServeservereadRequeststartBackgroundReadfinishRequest在前面的文章go实现tcp升级到http中描述了如何从tcp升级到http。熟悉tcp都是知道，实现tcp需要socket，bind,listen，然后accept。然后对于io来说，有阻塞，非阻塞，多路复用，异步几种模式。对于阻塞和非
    
                    
    • 
                    
  • 【QT教程】QT6硬件高级编程实战案例 QT硬件高级编程
                        QT性能优化QT原理源码QT界面美化
qtqt6.3qt5c++QT教程
                        
    QT6硬件高级编程实战案例使用AI技术辅助生成QT界面美化视频课程QT性能优化视频课程QT原理与源码分析视频课程QTQMLC++扩展开发视频课程免费QT视频课程您可以看免费1000+个QT技术视频免费QT视频课程QT统计图和QT数据可视化视频免费看免费QT视频课程QT性能优化视频免费看免费QT视频课程QT界面美化视频免费看1QT6硬件连接与配置1.1硬件平台选择与搭建1.1.1硬件平台选择与搭建硬
    
                    
    • 
                    
  • 华为云专家出品《深入理解边缘计算》电子书上线
                        华为云PaaS服务小智
华为云边缘计算人工智能
                        
    华为开发者大会PaaS生态电子书推荐，助你成为了不起的开发者！什么是边缘计算？边缘计算的应用场景有哪些？华为云出品《深入理解边缘计算》电子书上线带你系统理解云、边、端协同的相关原理了解开源项目的源码分析流程学成能够对云、边、端主流开源实现进行定制开发！【适用人群】1.对云原生感兴趣的开发者2.对边缘计算有学习需求或想拓展业务之外开发技能的开发者【精彩导读】首先，介绍边缘计算概念、边缘计算系统具体组
    
                    
    • 
                    
  • Spring Bean 生命周期
                        金州小铁匠
springpythonjava
                        
    SpringBean生命周期一、Bean的创建方式与底层实现Spring中Bean的创建方式及其底层源码实现是理解生命周期的关键。以下是常见的Bean注册方式及其源码层面的核心逻辑：1.XML配置方式源码分析：解析阶段：XmlBeanDefinitionReader解析XML文件，生成BeanDefinition并注册到BeanFactory的beanDefinitionMap。注册逻辑：Defa
    
                    
    • 
                    
  • 【Hive】学习路线：架构、运维、Hsql实战、源码分析
                        roman_日积跬步-终至千里
#hivehive学习架构
                        
    文章目录一.Hive基础学习1.基础知识2.安装与配置3.数据存储与表结构二.hive运维三.Hive实战1.HiveSQL基础2.高级查询与数据分析3.数据存储优化4.性能调优四.Hive源码分析一.Hive基础学习1.基础知识hive简介架构说明【hive-design】hive架构详解：描述了hive架构，hive主要组件的作用、hsql在hive执行过程中的底层细节、hive各组件作用2.
    
                    
    • 
                    
  • Ubuntu 下 nginx-1.24.0 源码分析 - ngx_process_options
                        若云止水
nginx运维
                        
    ngx_process_options声明在src\core\nginx.cstaticngx_int_tngx_process_options(ngx_cycle_t*cycle);定义在src\core\nginx.cstaticngx_int_tngx_process_options(ngx_cycle_t*cycle){u_char*p;size_tlen;if(ngx_prefix){l
    
                    
    • 
                    
  • Ubuntu 下 nginx-1.24.0 源码分析 - ngx_atoi 函数
                        若云止水
nginx运维
                        
    ngx_atoi声明在src/core/ngx_string.hngx_int_tngx_atoi(u_char*line,size_tn);定义在src/core/ngx_string.cngx_int_tngx_atoi(u_char*line,size_tn){ngx_int_tvalue,cutoff,cutlim;if(n==0){returnNGX_ERROR;}cutoff=NGX_
    
                    
    • 
                    
  • 深入源码分析 kotlin的CoroutineExceptionHandler机制
                        古苏
kotlinandroid
                        
    启动一个协程，然后内部启动子协程，那么最内层如果发生异常，是怎么传递异常的？valrootExceptionHandler=CoroutineExceptionHandler{_,throwable->println("调用【根】协程异常处理器：${throwable.message}")}valparentExceptionHandler=CoroutineExceptionHandler{_,
    
                    
    • 
                    
  • QT OpenGL高级编程
                        QT性能优化QT原理源码QT界面美化
qtqt6.3qt5QT教程c++
                        
    QTOpenGL高级编程使用AI技术辅助生成QT界面美化视频课程QT性能优化视频课程QT原理与源码分析视频课程QTQMLC++扩展开发视频课程免费QT视频课程您可以看免费1000+个QT技术视频免费QT视频课程QT统计图和QT数据可视化视频免费看免费QT视频课程QT性能优化视频免费看免费QT视频课程QT界面美化视频免费看1QT_OpenGL基础1.1OpenGL简介1.1.1OpenGL简介Ope
    
                    
    • 
                    
  • QT 3D光照与阴影
                        QT性能优化QT原理源码QT界面美化
qtqt6.3qt5QT教程c++3d
                        
    QT3D光照与阴影使用AI技术辅助生成QT界面美化视频课程QT性能优化视频课程QT原理与源码分析视频课程QTQMLC++扩展开发视频课程免费QT视频课程您可以看免费1000+个QT技术视频免费QT视频课程QT统计图和QT数据可视化视频免费看免费QT视频课程QT性能优化视频免费看免费QT视频课程QT界面美化视频免费看1QT_3D光照基础1.1光照概念与重要性1.1.1光照概念与重要性光照概念与重要性
    
                    
    • 
                    
  • Ubuntu 下 nginx-1.24.0 源码分析 - ngx_crc32_table_init 函数
                        若云止水
nginx运维
                        
    ngx_crc32_table_init声明在src/core/ngx_crc32.hngx_int_tngx_crc32_table_init(void);实现在src/core/ngx_crc32.cngx_int_tngx_crc32_table_init(void){void*p;if(((uintptr_t)ngx_crc32_table_short&~((uintptr_t)ngx_c
    
                    
    • 
                    
  • Ubuntu 下 nginx-1.24.0 源码分析 - ngx_os_init 函数
                        若云止水
nginx运维
                        
    ngx_os_init声明在src/os/unix/ngx_os.hngx_int_tngx_os_init(ngx_log_t*log);定义在src\os\unix\ngx_posix_init.cngx_int_tngx_os_init(ngx_log_t*log){ngx_time_t*tp;ngx_uint_tn;#if(NGX_HAVE_LEVEL1_DCACHE_LINESIZE)l
    
                    
    • 
                    
  • Spark源码分析
                        陈同学�
sparkbigdatascala
                        
    Spark源码分析SparkonYarnclientCluster本质区别，driver位置不同1)有哪些不同得进程？2)分别有什么作用？3)Spark作业执行流程是什么样的跑yarn有--masteryarnCoarseGrainedExecutorBackend默认executor有两个CoarseGrainedExecutorBackendSparkSubmitApplicationMast
    
                    
    • 
                                
  • 分享100个最新免费的高匿HTTP代理IP
                                    mcj8089
代理IP代理服务器匿名代理免费代理IP最新代理IP
                                    
      
推荐两个代理IP网站： 
  
1. 全网代理IP：http://proxy.goubanjia.com/ 
  
2. 敲代码免费IP：http://ip.qiaodm.com/ 
  
  
120.198.243.130:80,中国/广东省
58.251.78.71:8088,中国/广东省
183.207.228.22:83,中国/
    
                                
    • 
                                
  • mysql高级特性之数据分区
                                    annan211
java数据结构mongodb分区mysql
                                    
    


mysql高级特性
  1 以存储引擎的角度分析，分区表和物理表没有区别。是按照一定的规则将数据分别存储的逻辑设计。器底层是由多个物理字表组成。
  
  2 分区的原理
     分区表由多个相关的底层表实现，这些底层表也是由句柄对象表示，所以我们可以直接访问各个分区。存储引擎管理分区的各个底层
	 表和管理普通表一样(所有底层表都必须使用相同的存储引擎)，分区表的索引只是
    
                                
    • 
                                
  • JS采用正则表达式简单获取URL地址栏参数
                                    chiangfai
js地址栏参数获取
                                    
    GetUrlParam:function GetUrlParam(param){
		var reg = new RegExp("(^|&)"+ param +"=([^&]*)(&|$)");
		var r = window.location.search.substr(1).match(reg);
		if(r!=null
    
                                
    • 
                                
  • 怎样将数据表拷贝到powerdesigner (本地数据库表)
                                    Array_06
powerDesigner
                                    
    ================================================== 
 
1、打开PowerDesigner12，在菜单中按照如下方式进行操作 
file->Reverse Engineer->DataBase 
点击后，弹出 New Physical Data Model 的对话框 
2、在General选项卡中 
Model name:模板名字，自
    
                                
    • 
                                
  • logbackのhelloworld
                                    飞翔的马甲
日志logback
                                    
    一、概述 
 
1.日志是啥？ 
当我是个逗比的时候我是这么理解的：log.debug()代替了system.out.print(); 
当我项目工作时，以为是一堆得.log文件。 
这两天项目发布新版本，比较轻松，决定好好地研究下日志以及logback。 
传送门1：日志的作用与方法： 
http://www.infoq.com/cn/articles/why-and-how-log 
上面的作
    
                                
    • 
                                
  • 新浪微博爬虫模拟登陆
                                    随意而生
新浪微博
                                    
    转载自：http://hi.baidu.com/erliang20088/item/251db4b040b8ce58ba0e1235 
  
  
近来由于毕设需要，重新修改了新浪微博爬虫废了不少劲，希望下边的总结能够帮助后来的同学们。 
     现行版的模拟登陆与以前相比，最大的改动在于cookie获取时候的模拟url的请求
    
                                
    • 
                                
  • synchronized
                                    香水浓
javathread
                                    
        Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍然
    
                                
    • 
                                
  • maven 简单实用教程
                                    AdyZhang
maven
                                    
    1. Maven介绍  1.1. 简介 java编写的用于构建系统的自动化工具。目前版本是2.0.9，注意maven2和maven1有很大区别，阅读第三方文档时需要区分版本。 1.2. Maven资源 见官方网站；The 5 minute test，官方简易入门文档；Getting Started Tutorial，官方入门文档；Build Coo
    
                                
    • 
                                
  • Android 通过 intent传值获得null
                                    aijuans
android
                                    
    我在通过intent 获得传递兑现过的时候报错，空指针,我是getMap方法进行传值，代码如下        1   2   3   4   5   6   7   8   9      
public 
void 
getMap(View view){       
         
Intent i =
    
                                
    • 
                                
  • apache 做代理 报如下错误：The proxy server received an invalid response from an upstream
                                    baalwolf
response
                                    
    网站配置是apache＋tomcat,tomcat没有报错，apache报错是： 
The proxy server received an invalid response from an upstream server. The proxy server could not handle the request GET /. Reason: Error reading fr
    
                                
    • 
                                
  • Tomcat6 内存和线程配置
                                    BigBird2012
tomcat6
                                    
    1、修改启动时内存参数、并指定JVM时区 （在windows server 2008 下时间少了8个小时） 
在Tomcat上运行j2ee项目代码时，经常会出现内存溢出的情况，解决办法是在系统参数中增加系统参数：  
window下， 在catalina.bat最前面 
  set JAVA_OPTS=-XX:PermSize=64M -XX:MaxPermSize=128m -Xms5
    
                                
    • 
                                
  • Karam与TDD
                                    bijian1013
KaramTDD
                                    
    一.TDD 
        测试驱动开发（Test-Driven Development,TDD）是一种敏捷（AGILE）开发方法论，它把开发流程倒转了过来，在进行代码实现之前，首先保证编写测试用例，从而用测试来驱动开发（而不是把测试作为一项验证工具来使用）。 
        TDD的原则很简单： 
a.只有当某个
    
                                
    • 
                                
  • [Zookeeper学习笔记之七]Zookeeper源代码分析之Zookeeper.States
                                    bit1129
zookeeper
                                    
        public enum States {
        CONNECTING, //Zookeeper服务器不可用，客户端处于尝试链接状态
        ASSOCIATING, //？？？
        CONNECTED, //链接建立，可以与Zookeeper服务器正常通信
        CONNECTEDREADONLY, //处于只读状态的链接状态，只读模式可以在
    
                                
    • 
                                
  • 【Scala十四】Scala核心八：闭包
                                    bit1129
scala
                                    
    Free variable A free variable of an expression is a variable that’s used inside the expression but not defined inside the expression. For instance, in the function literal expression (x: Int) => (x
    
                                
    • 
                                
  • android发送json并解析返回json
                                    ronin47
android
                                    
    package com.http.test; 
 
 
import org.apache.http.HttpResponse; 
import org.apache.http.HttpStatus; 
import org.apache.http.client.HttpClient; 
import org.apache.http.client.methods.HttpGet; 
import 
    
                                
    • 
                                
  • 一份IT实习生的总结
                                    brotherlamp
PHPphp资料php教程php培训php视频
                                    
    今天突然发现在不知不觉中自己已经实习了 3 个月了，现在可能不算是真正意义上的实习吧，因为现在自己才大三，在这边撸代码的同时还要考虑到学校的功课跟期末考试。让我震惊的是，我完全想不到在这 3 个月里我到底学到了什么，这是一件多么悲催的事情啊。同时我对我应该 get 到什么新技能也很迷茫。所以今晚还是总结下把，让自己在接下来的实习生活有更加明确的方向。最后感谢工作室给我们几个人这个机会让我们提前出来
    
                                
    • 
                                
  • 据说是2012年10月人人网校招的一道笔试题-给出一个重物重量为X,另外提供的小砝码重量分别为1，3，9。。。3^N。 将重物放到天平左侧，问在两边如何添加砝码
                                    bylijinnan
java
                                    
    
public class ScalesBalance {

	/**
	 * 题目：
	 * 给出一个重物重量为X,另外提供的小砝码重量分别为1，3，9。。。3^N。 （假设N无限大，但一种重量的砝码只有一个）
	 * 将重物放到天平左侧，问在两边如何添加砝码使两边平衡
	 * 
	 * 分析：
	 * 三进制
	 * 我们约定括号表示里面的数是三进制，例如 47=(1202
    
                                
    • 
                                
  • dom4j最常用最简单的方法
                                    chiangfai
dom4j
                                    
    要使用dom4j读写XML文档,需要先下载dom4j包,dom4j官方网站在 http://www.dom4j.org/目前最新dom4j包下载地址:http://nchc.dl.sourceforge.net/sourceforge/dom4j/dom4j-1.6.1.zip 
解开后有两个包,仅操作XML文档的话把dom4j-1.6.1.jar加入工程就可以了,如果需要使用XPath的话还需要
    
                                
    • 
                                
  • 简单HBase笔记
                                    chenchao051
hbase
                                    
     一、Client-side write buffer 客户端缓存请求   描述：可以缓存客户端的请求，以此来减少RPC的次数，但是缓存只是被存在一个ArrayList中，所以多线程访问时不安全的。   可以使用getWriteBuffer()方法来取得客户端缓存中的数据。 默认关闭。      二、Scan的Caching   描述： next( )方法请求一行就要使用一次RPC,即使
    
                                
    • 
                                
  • mysqldump导出时出现when doing LOCK TABLES
                                    daizj
mysqlmysqdump导数据
                                    
    　　执行　mysqldump -uxxx -pxxx -hxxx -Pxxxx database tablename > tablename.sql　 
导出表时，会报 
 
mysqldump: Got error: 1044: Access denied for user 'xxx'@'xxx' to database 'xxx' when doing LOCK TABLES 
 
解决
    
                                
    • 
                                
  • CSS渲染原理
                                    dcj3sjt126com
Web
                                    
       从事Web前端开发的人都与CSS打交道很多，有的人也许不知道css是怎么去工作的，写出来的css浏览器是怎么样去解析的呢？当这个成为我们提高css水平的一个瓶颈时，是否应该多了解一下呢？   
  
       一、浏览器的发展与CSS      
  
   
    
                                
    • 
                                
  • 《阿甘正传》台词
                                    dcj3sjt126com

                                    
    Part Ⅰ: 
《阿甘正传》Forrest Gump经典中英文对白 
Forrest: Hello! My names Forrest. Forrest Gump. You wanna Chocolate? I could eat about a million and a half othese. My momma always said life was like a box ochocol
    
                                
    • 
                                
  • Java处理JSON
                                    dyy_gusi
json
                                    
    Json在数据传输中很好用，原因是JSON 比 XML 更小、更快，更易解析。 
在Java程序中，如何使用处理JSON，现在有很多工具可以处理，比较流行常用的是google的gson和alibaba的fastjson，具体使用如下： 
1、读取json然后处理 
class ReadJSON
{
    public static void main(String[] args)
    
    
                                
    • 
                                
  • win7下nginx和php的配置
                                    geeksun
nginx
                                    
    1.  安装包准备 
nginx :  从nginx.org下载nginx-1.8.0.zip 
php： 从php.net下载php-5.6.10-Win32-VC11-x64.zip， php是免安装文件。 
RunHiddenConsole: 用于隐藏命令行窗口 
  
2. 配置 
# java用8080端口做应用服务器，nginx反向代理到这个端口即可 
p
    
                                
    • 
                                
  • 基于2.8版本redis配置文件中文解释
                                    hongtoushizi
redis
                                    
    转载自： http://wangwei007.blog.51cto.com/68019/1548167 
       在Redis中直接启动redis-server服务时, 采用的是默认的配置文件。采用redis-server   xxx.conf 这样的方式可以按照指定的配置文件来运行Redis服务。下面是Redis2.8.9的配置文
    
                                
    • 
                                
  • 第五章 常用Lua开发库3-模板渲染
                                    jinnianshilongnian
nginxlua
                                    
    动态web网页开发是Web开发中一个常见的场景，比如像京东商品详情页，其页面逻辑是非常复杂的，需要使用模板技术来实现。而Lua中也有许多模板引擎，如目前我在使用的lua-resty-template，可以渲染很复杂的页面，借助LuaJIT其性能也是可以接受的。 
  
如果学习过JavaEE中的servlet和JSP的话，应该知道JSP模板最终会被翻译成Servlet来执行；而lua-r
    
                                
    • 
                                
  • JZSearch大数据搜索引擎
                                    颠覆者
JavaScript
                                    
    系统简介： 
 
 大数据的特点有四个层面：第一，数据体量巨大。从TB级别，跃升到PB级别；第二，数据类型繁多。网络日志、视频、图片、地理位置信息等等。第三，价值密度低。以视频为例，连续不间断监控过程中，可能有用的数据仅仅有一两秒。第四，处理速度快。最后这一点也是和传统的数据挖掘技术有着本质的不同。业界将其归纳为4个“V”——Volume，Variety，Value，Velocity。大数据搜索引
    
                                
    • 
                                
  • 10招让你成为杰出的Java程序员
                                    pda158
java编程框架
                                    
    如果你是一个热衷于技术的  
Java 程序员， 那么下面的 10 个要点可以让你在众多 Java 开发人员中脱颖而出。   　　 
1. 拥有扎实的基础和深刻理解 OO 原则   　　对于 Java 程序员，深刻理解 Object Oriented Programming（面向对象编程）这一概念是必须的。没有 OOPS 的坚实基础，就领会不了像 Java 这些面向对象编程语言
    
                                
    • 
                                
  • tomcat之oracle连接池配置
                                    小网客
oracle
                                    
    tomcat版本7.0 
配置oracle连接池方式： 
修改tomcat的server.xml配置文件： 
 <GlobalNamingResources>
 
			  <Resource name="utermdatasource" auth="Container"  
 type="javax.sql.DataSou
    
                                
    • 
                                
  • Oracle 分页算法汇总
                                    vipbooks
oraclesql算法.net
                                    
        这是我找到的一些关于Oracle分页的算法，大家那里还有没有其他好的算法没？我们大家一起分享一下！ 
 
 

-- Oracle 分页算法一
select * from (
       select page.*,rownum rn from (select * from help) page 
       -- 20 = (currentPag
    
                                
    •