Davisxy
Davisxy

EventBus源码解读文档

顺序前后有些乱，请见谅：

###EventBus源码解析

先看一个使用的例子：

public class MainActivity extends AppCompatActivity {

    private TextView tvShow;
    private Button btnShow;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        EventBus.getDefault().register(this);

        tvShow = findViewById(R.id.tv_show);
        btnShow = findViewById(R.id.btn_show);
        btnShow.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                Random random = new Random();
                int num = random.nextInt();
                UserBean userBean = new UserBean("00001", "bb", "man");
                EventBus.getDefault().post(userBean);
            }
        });

    }

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void event(UserBean info) {
        tvShow.setText(info.getName());
    }


    @Override
    protected void onStop() {
        super.onStop();
        EventBus.getDefault().unregister(this);
    }
}

简单使用也就比较简单：
先注册，然后定义订阅事件，解注册,发送事件

EventBus.getDefault().register(this);

EventBus.getDefault().post(userBean);

EventBus.getDefault().unregister(this);

@Subscribe(threadMode = ThreadMode.MAIN)
public void event(UserBean info) {
    tvShow.setText(info.getName());
}

从EventBus的入口进入

EventBus.getDefault().register(this);

首先看getDefault(),是一个double check的单例

static volatile EventBus defaultInstance;
public static EventBus getDefault() {
    if (defaultInstance == null) {
        synchronized (EventBus.class) {
            if (defaultInstance == null) {
                defaultInstance = new EventBus();
            }
        }
    }
    return defaultInstance;
}

public EventBus() {
    this(DEFAULT_BUILDER);
}

private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();

EventBus(EventBusBuilder builder) {
    logger = builder.getLogger();
    subscriptionsByEventType = new HashMap<>();
    typesBySubscriber = new HashMap<>();
    stickyEvents = new ConcurrentHashMap<>();
    mainThreadSupport = builder.getMainThreadSupport();
    mainThreadPoster = mainThreadSupport != null ? mainThreadSupport.createPoster(this) : null;
    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;
}

EventBusBuilder

public class EventBusBuilder {
    //开辟一个线程池
    private final static ExecutorService DEFAULT_EXECUTOR_SERVICE = Executors.newCachedThreadPool();
    //log
    boolean logSubscriberExceptions = true;
    boolean logNoSubscriberMessages = true;
    boolean sendSubscriberExceptionEvent = true;
    boolean sendNoSubscriberEvent = true;
    boolean throwSubscriberException;
    
    boolean eventInheritance = true;
    //注解
    boolean ignoreGeneratedIndex;
    boolean strictMethodVerification;
    ExecutorService executorService = DEFAULT_EXECUTOR_SERVICE;
    List> skipMethodVerificationForClasses;
    List subscriberInfoIndexes;
    Logger logger;
    //主线程的支持类
    MainThreadSupport mainThreadSupport;

    EventBusBuilder() {
    }

    /** Default: true */
    public EventBusBuilder logSubscriberExceptions(boolean logSubscriberExceptions) {
        this.logSubscriberExceptions = logSubscriberExceptions;
        return this;
    }

    /** Default: true */
    public EventBusBuilder logNoSubscriberMessages(boolean logNoSubscriberMessages) {
        this.logNoSubscriberMessages = logNoSubscriberMessages;
        return this;
    }

    /** Default: true */
    public EventBusBuilder sendSubscriberExceptionEvent(boolean sendSubscriberExceptionEvent) {
        this.sendSubscriberExceptionEvent = sendSubscriberExceptionEvent;
        return this;
    }

    /** Default: true */
    public EventBusBuilder sendNoSubscriberEvent(boolean sendNoSubscriberEvent) {
        this.sendNoSubscriberEvent = sendNoSubscriberEvent;
        return this;
    }

    /**
     * Fails if an subscriber throws an exception (default: false).
     * 

     * Tip: Use this with BuildConfig.DEBUG to let the app crash in DEBUG mode (only). This way, you won't miss
     * exceptions during development.
     */
    public EventBusBuilder throwSubscriberException(boolean throwSubscriberException) {
        this.throwSubscriberException = throwSubscriberException;
        return this;
    }

    /**
     * By default, EventBus considers the event class hierarchy (subscribers to super classes will be notified).
     * Switching this feature off will improve posting of events. For simple event classes extending Object directly,
     * we measured a speed up of 20% for event posting. For more complex event hierarchies, the speed up should be
     * >20%.
     * 

     * However, keep in mind that event posting usually consumes just a small proportion of CPU time inside an app,
     * unless it is posting at high rates, e.g. hundreds/thousands of events per second.
     */
    public EventBusBuilder eventInheritance(boolean eventInheritance) {
        this.eventInheritance = eventInheritance;
        return this;
    }


    /**
     * Provide a custom thread pool to EventBus used for async and background event delivery. This is an advanced
     * setting to that can break things: ensure the given ExecutorService won't get stuck to avoid undefined behavior.
     */
    public EventBusBuilder executorService(ExecutorService executorService) {
        this.executorService = executorService;
        return this;
    }

    /**
     * Method name verification is done for methods starting with onEvent to avoid typos; using this method you can
     * exclude subscriber classes from this check. Also disables checks for method modifiers (public, not static nor
     * abstract).
     */
    public EventBusBuilder skipMethodVerificationFor(Class clazz) {
        if (skipMethodVerificationForClasses == null) {
            skipMethodVerificationForClasses = new ArrayList<>();
        }
        skipMethodVerificationForClasses.add(clazz);
        return this;
    }

    /** Forces the use of reflection even if there's a generated index (default: false). */
    public EventBusBuilder ignoreGeneratedIndex(boolean ignoreGeneratedIndex) {
        this.ignoreGeneratedIndex = ignoreGeneratedIndex;
        return this;
    }

    /** Enables strict method verification (default: false). */
    public EventBusBuilder strictMethodVerification(boolean strictMethodVerification) {
        this.strictMethodVerification = strictMethodVerification;
        return this;
    }

    /** Adds an index generated by EventBus' annotation preprocessor. */
    public EventBusBuilder addIndex(SubscriberInfoIndex index) {
        if (subscriberInfoIndexes == null) {
            subscriberInfoIndexes = new ArrayList<>();
        }
        subscriberInfoIndexes.add(index);
        return this;
    }

    /**
     * Set a specific log handler for all EventBus logging.
     * 

     * By default all logging is via {@link android.util.Log} but if you want to use EventBus
     * outside the Android environment then you will need to provide another log target.
     */
    public EventBusBuilder logger(Logger logger) {
        this.logger = logger;
        return this;
    }

    Logger getLogger() {
        if (logger != null) {
            return logger;
        } else {
            // also check main looper to see if we have "good" Android classes (not Stubs etc.)
            return Logger.AndroidLogger.isAndroidLogAvailable() && getAndroidMainLooperOrNull() != null
                    ? new Logger.AndroidLogger("EventBus") :
                    new Logger.SystemOutLogger();
        }
    }

    //不为空则直接返回，为空则判断日志的可使用状态，可使用则获取当前主线程的Looper，将Looper传入到MainThreadSupport的实现类AndroidHandlerMainThreadSupport中
    MainThreadSupport getMainThreadSupport() {
        if (mainThreadSupport != null) {
            return mainThreadSupport;
        } else if (Logger.AndroidLogger.isAndroidLogAvailable()) {
            Object looperOrNull = getAndroidMainLooperOrNull();
            return looperOrNull == null ? null :
                    new MainThreadSupport.AndroidHandlerMainThreadSupport((Looper) looperOrNull);
        } else {
            return null;
        }
    }

    Object getAndroidMainLooperOrNull() {
        try {
            return Looper.getMainLooper();
        } catch (RuntimeException e) {
            // Not really a functional Android (e.g. "Stub!" maven dependencies)
            return null;
        }
    }

    /**
     * Installs the default EventBus returned by {@link EventBus#getDefault()} using this builders' values. Must be
     * done only once before the first usage of the default EventBus.
     *
     * @throws EventBusException if there's already a default EventBus instance in place
     */
    public EventBus installDefaultEventBus() {
        synchronized (EventBus.class) {
            if (EventBus.defaultInstance != null) {
                throw new EventBusException("Default instance already exists." +
                        " It may be only set once before it's used the first time to ensure consistent behavior.");
            }
            EventBus.defaultInstance = build();
            return EventBus.defaultInstance;
        }
    }

    /** Builds an EventBus based on the current configuration. */
    public EventBus build() {
        return new EventBus(this);
    }

}

然后看register

public void register(Object subscriber) {
    Class subscriberClass = subscriber.getClass();
    List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
    synchronized (this) {
        for (SubscriberMethod subscriberMethod : subscriberMethods) {
            subscribe(subscriber, subscriberMethod);
        }
    }
}

register的参数是Object，（这意思就是能注册的多了去了，这里我就拿MainActivity说事了）

Class subscriberClass = subscriber.getClass();

获取当前的Class，（这里也就是com.xiey94.eventbusstudy.MainActivity的Class）

List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);

这里涉及到了三个东西
SubscriberMethod:订阅方法的包装类
subscriberMethodFinder:(private final SubscriberMethodFinder subscriberMethodFinder;):unknow
findSubscriberMethods:根据方法名可以看出是寻找订阅方法的；

SubscriberMethod

/** Used internally by EventBus and generated subscriber indexes. */
public class SubscriberMethod {
    //订阅的方法
    final Method method;
    //将要运行的线程
    final ThreadMode threadMode;
    //参数类型（这里也就是com.xiey94.eventbusstudy.UserBean）
    final Class eventType;
    //优先级
    final int priority;
    //是否为粘性事件(例：A跳转到C，按照启动流程，先启动A，A注册了，然后在A中post通知，在C中定义订阅方法，但是这时A还没启动（跳转）到C，也就是说C还没有onCreate，也就还没register，所以也就接收不到这个订阅事件了；这是普通事件，有了粘性事件就不一样了，哪怕你还没有注册，只要有post的，那当你register之后还是会接收到这个post的通知)
    final boolean sticky;
    /** Used for efficient comparison */
    //用于拼接，然后对比比较
    String methodString;

    //构造
    public SubscriberMethod(Method method, Class eventType, ThreadMode threadMode, int priority, boolean sticky) {
        this.method = method;
        this.threadMode = threadMode;
        this.eventType = eventType;
        this.priority = priority;
        this.sticky = sticky;
    }

    //覆写，比较他们的拼接是否相同（当前：MainActivity#event(com.xiey94.eventbusstudy.UserBean）
    @Override
    public boolean equals(Object other) {
        if (other == this) {
            return true;
        } else if (other instanceof SubscriberMethod) {
            checkMethodString();
            SubscriberMethod otherSubscriberMethod = (SubscriberMethod)other;
            otherSubscriberMethod.checkMethodString();
            // Don't use method.equals because of http://code.google.com/p/android/issues/detail?id=7811#c6
            return methodString.equals(otherSubscriberMethod.methodString);
        } else {
            return false;
        }
    }

    private synchronized void checkMethodString() {
        if (methodString == null) {
            // Method.toString has more overhead, just take relevant parts of the method
            StringBuilder builder = new StringBuilder(64);
            builder.append(method.getDeclaringClass().getName());
            builder.append('#').append(method.getName());
            builder.append('(').append(eventType.getName());
            methodString = builder.toString();
        }
    }

    @Override
    public int hashCode() {
        return method.hashCode();
    }
}

整体还是没有难理解的地方

SubscriberMethodFinder
暂时只涉及到这个类的一个方法，所以先放放

List findSubscriberMethods(Class subscriberClass) {
    /*METHOD_CACHE：private static final Map, List> METHOD_CACHE = new ConcurrentHashMap<>();
    *这个是缓存整个App所有的订阅方法，以Class为key，将当前Class中所有的订阅方法都分别包装为SubscriberMethod，然后放到List中；（当前就是MainActivity为key，List中目前就一个订阅方法，就是event）
    *这里根据当前传进来的Class，也就是MainActivity的class，来查找所有订阅方法，如果找到的就返回所有的订阅方法
    不存在的情况暂时先不分析
    **/
    List subscriberMethods = METHOD_CACHE.get(subscriberClass);
    if (subscriberMethods != null) {
        return subscriberMethods;
    }

    if (ignoreGeneratedIndex) {
        subscriberMethods = findUsingReflection(subscriberClass);
    } else {
        subscriberMethods = findUsingInfo(subscriberClass);
    }
    if (subscriberMethods.isEmpty()) {
        throw new EventBusException("Subscriber " + subscriberClass
                + " and its super classes have no public methods with the @Subscribe annotation");
    } else {
        METHOD_CACHE.put(subscriberClass, subscriberMethods);
        return subscriberMethods;
    }
}

再回到register方法中：

public void register(Object subscriber) {
    Class subscriberClass = subscriber.getClass();
    List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
    synchronized (this) {
        for (SubscriberMethod subscriberMethod : subscriberMethods) {
            subscribe(subscriber, subscriberMethod);
        }
    }
}

加个一个同步锁，然后开始针对当前的订阅者找到所有的订阅方法，开始订阅
subscribe:

// Must be called in synchronized block：必须在同步锁中调用
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
    //获取当前参数类型，也就是UserBean
    Class eventType = subscriberMethod.eventType;
    //将传来的class和方法进行包装
    Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
    //对参数类型进行判断，如果没有这个参数类型则添加到list中，如果当前参数类型已经有了，就不可以再注册这个方法，会抛异常；如果已经有event(UserBean userBean)方法了，就不能再定义一个同参数类型的event2(UserBean userBean)方法了，不然发通知的时候，就不知道当前Class中那个事件去响应了
    //subscriptionsByEventType:Map, CopyOnWriteArrayList> subscriptionsByEventType;针对整个App的，以参数类型为key，将不同Class中的该参数类型的订阅方法结合所属的Class包装成Subscription作为集合作为value；
    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);
        }
    }
    //对同参数类型的所有订阅方法进行优先级排序
    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;
        }
    }
    
    //Map>> typesBySubscriber;以Class为Key，然后将该Class中的订阅方法的所有参数类型放到list中
    List> subscribedEvents = typesBySubscriber.get(subscriber);
    if (subscribedEvents == null) {
        subscribedEvents = new ArrayList<>();
        typesBySubscriber.put(subscriber, subscribedEvents);
    }
    subscribedEvents.add(eventType);
    
    //判断该订阅方法是否为粘性事件，如果是的话则
    if (subscriberMethod.sticky) {
        //是否可继承，相当于super，父类的订阅事件子类也会先执行一下，默认true
        if (eventInheritance) {
                // Existing sticky events of all subclasses of eventType have to be considered.
                // Note: Iterating over all events may be inefficient with lots of sticky events,
                // thus data structure should be changed to allow a more efficient lookup
                // (e.g. an additional map storing sub classes of super classes: Class -> List).
            //如果继承，则取出
            Set, Object>> entries = stickyEvents.entrySet();
            for (Map.Entry, Object> entry : entries) {
                Class candidateEventType = entry.getKey();
                //去所有的粘性事件中查找所有的参数类型，判断当前参数类型是否是某个订阅事件同一类型或者是它的父类，如果是，则取出粘性事件；这里也就是说，如果在整个App中，如果有订阅事件的参数为当前参数类型的子类，则触发所有参数为该子类的订阅事件
                if (eventType.isAssignableFrom(candidateEventType)) {
                    Object stickyEvent = entry.getValue();
                    //触发事件
                    checkPostStickyEventToSubscription(newSubscription, stickyEvent);
                }
            }
        } else {
            //private final Map, Object> stickyEvents;以参数类型作为Key，粘性事件参数作Value，根据当前订阅方法的参数类型，取出粘性事件
            Object stickyEvent = stickyEvents.get(eventType);
            //触发事件，参数为包装了的Subscription（Class+方法）、粘性事件
            checkPostStickyEventToSubscription(newSubscription, stickyEvent);
        }
    }
}

private void checkPostStickyEventToSubscription(Subscription newSubscription, Object stickyEvent) {
    if (stickyEvent != null) {
        // If the subscriber is trying to abort the event, it will fail (event is not tracked in posting state)
        // --> Strange corner case, which we don't take care of here.
        //判断该粘性事件是否为空，不为空则触发，参数多了一个判断主线程（UI线程）
        postToSubscription(newSubscription, stickyEvent, isMainThread());
    }
}

private boolean isMainThread() {
    //当为空时为主线程，否则看mainThreadSupport.isMainThread()
    return mainThreadSupport != null ? mainThreadSupport.isMainThread() : true;
}


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, 10);
        }
    }

}

HandlerPoster

public class HandlerPoster extends Handler implements Poster {
    //发射中队列
    private final PendingPostQueue queue;
    //最长等待注册时长；当10秒后没有注册成功，则去掉重新开始，防止阻塞主线程
    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；检查两次，如果两次都是null，则说明没有，直接返回
                        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;
        }
    }
}

    void invokeSubscriber(PendingPost pendingPost) {
        //取出包装方法类，和参数
        Object event = pendingPost.event;
        Subscription subscription = pendingPost.subscription;
        //处理PendingPost，里面的值清空；如果发射池小于10000，则重新添加进去，免了创建新对象的开销
        PendingPost.releasePendingPost(pendingPost);
        
        if (subscription.active) {
            invokeSubscriber(subscription, event);
        }
    }

发送器接口

interface Poster {

    /**
     * Enqueue an event to be posted for a particular subscription.
     *
     * @param subscription Subscription which will receive the event.
     * @param event        Event that will be posted to subscribers.
     * 参数为包装类（Class+event），
     */
    void enqueue(Subscription subscription, Object event);
}

Subscription

final class Subscription {
    //参数类型
    final Object subscriber;
    //包装后的方法
    final SubscriberMethod subscriberMethod;
    /**
     * Becomes false as soon as {@link EventBus#unregister(Object)} is called, which is checked by queued event delivery：当unregister被调用时，active=false,当队列分发时被调用
     * {@link EventBus#invokeSubscriber(PendingPost)} to prevent race conditions.
     */
    volatile boolean active;

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

    @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.methodString.hashCode();
    }
}

回到发射事件那边

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 MAIN_ORDERED:
            if (mainThreadPoster != null) {
                mainThreadPoster.enqueue(subscription, event);
            } else {
            // temporary: technically not correct as poster not decoupled from subscriber
                invokeSubscriber(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);
        }
    }

这里我们是Main

case MAIN:
    if (isMainThread) {
        invokeSubscriber(subscription, event);
    } else {
        mainThreadPoster.enqueue(subscription, event);
    }
break;

如果是主线程，则invokeSubscriber；否则就是发射器异步发射粘性事件

    void invokeSubscriber(Subscription subscription, Object event) {
        try {
            //method为订阅方法，subscription.subscriber为实例对象,event为Subscription中的粘性事件参数
            subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
        } catch (InvocationTargetException e) {
            handleSubscriberException(subscription, event, e.getCause());
        } catch (IllegalAccessException e) {
            throw new IllegalStateException("Unexpected exception", e);
        }
    }

如果在主线程，则反射执行粘性事件，否则异步执行

    public void enqueue(Subscription subscription, Object event) {
        //构建一个发射包装器
        PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
        synchronized (this) {
        
            queue.enqueue(pendingPost);
            //将handlerActive状态更换
            if (!handlerActive) {
                handlerActive = true;
                //
                if (!sendMessage(obtainMessage())) {
                    throw new EventBusException("Could not send handler message");
                }
            }
        }
    }

PendingPost

final class PendingPost {
    private final static List pendingPostPool = new ArrayList();

    Object event;
    Subscription subscription;
    PendingPost next;

    private PendingPost(Object event, Subscription subscription) {
        this.event = event;
        this.subscription = subscription;
    }
    
    //传进来类包装方法，和方法参数类型
    static PendingPost obtainPendingPost(Subscription subscription, Object event) {
        synchronized (pendingPostPool) {
            //拿取最后加入的发射器，将包装方法和参数包装成一个发射器并返回
            int size = pendingPostPool.size();
            if (size > 0) {
                PendingPost pendingPost = pendingPostPool.remove(size - 1);
                pendingPost.event = event;
                pendingPost.subscription = subscription;
                pendingPost.next = null;
                return pendingPost;
            }
        }
        return new PendingPost(event, subscription);
    }

    //释放用过的发射器，清空内容，重回发射池
    static void releasePendingPost(PendingPost pendingPost) {
        pendingPost.event = null;
        pendingPost.subscription = null;
        pendingPost.next = null;
        synchronized (pendingPostPool) {
            // Don't let the pool grow indefinitely
            if (pendingPostPool.size() < 10000) {
                pendingPostPool.add(pendingPost);
            }
        }
    }

}

PendingPostQueue

//构建一个发射器队列
final class PendingPostQueue {
    private PendingPost head;
    private PendingPost tail;

    synchronized void enqueue(PendingPost pendingPost) {
        if (pendingPost == null) {
            throw new NullPointerException("null cannot be enqueued");
        }
        if (tail != null) {
            tail.next = pendingPost;
            tail = pendingPost;
        } else if (head == null) {
            head = tail = pendingPost;
        } else {
            throw new IllegalStateException("Head present, but no tail");
        }
        //唤醒线程，随时抢占时间片
        notifyAll();
    }

    synchronized PendingPost poll() {
        PendingPost pendingPost = head;
        if (head != null) {
            head = head.next;
            if (head == null) {
                tail = null;
            }
        }
        return pendingPost;
    }

    synchronized PendingPost poll(int maxMillisToWait) throws InterruptedException {
        if (head == null) {
            wait(maxMillisToWait);
        }
        return poll();
    }

}

回溯一下：
1、首先从register进去，然后将当前Class中的订阅方法包装成一个SubscriberMethod；
2、将Class作为Key，Class所属的订阅方法都放到一个List中作为Value，放到了SubscriberMethodFinder中的METHOD_CACHE（Map, List>）中；
3、然后开始订阅所有的订阅事件，在订阅事件方法中，有包装了一个东西，将Class和SubscriberMethod包装成了Subscription；
4、又构建了一个Map，以参数类型作为Key，将所有Class中属于该参数类型的订阅方法放到一个List中subscriptionsByEventType（Map, CopyOnWriteArrayList>）；
5、将传进来的订阅事件按照优先级排序添加进来；
6、又构建了一个Map（Map>> typesBySubscriber），将Class作为Key，将当前Class中订阅方法的所有参数添加到List中作为Value；
7、按照道理讲，如果暂时不管粘性事件，则register就结束了；但是有了粘性事件就不一样了，当你register好了之后，跟随而来的粘性事件就要响应；
8、构建了一个stickyEvents（Map, Object> stickyEvents;）用参数类型作为Key，用参数值作为Value，
9、如果eventInheritance==true，也就是如果该粘性事件的类型参数有子类也作为某个订阅方法的参数，则子类订阅方法也响应该通知；
10、判断当前订阅事件指定的线程，也就是threadMode，如果是MAIN，判断当前是否是主线程，如果是则将stickEvents中的传进来对应的参数数据进行反射执行订阅方法；如果不是主线程，则在Handler中构建PendingPost发射器（从PendingPostQueue中获取，并包装对应参数），唤醒线程，抢占时间片，然后发送异步消息，因为HandlerPoster是在主线程中创建的，所以响应是在主线程；

现在到post方法：

    public void post(Object event) {
        //获取post线程的状态值
        PostingThreadState postingState = currentPostingThreadState.get();
        //获取状态中的参数队列
        List eventQueue = postingState.eventQueue;
        //将参数放到队列中
        eventQueue.add(event);
        
        //是否正在发送
        if (!postingState.isPosting) {
            //判断当前线程
            postingState.isMainThread = isMainThread();
            //设置当前正处于发送状态
            postingState.isPosting = true;
            //发送的事件是否取消了
            if (postingState.canceled) {
                throw new EventBusException("Internal error. Abort state was not reset");
            }
            try {
                //如果当前状态中的参数队列不为空，则发送单个事件
                while (!eventQueue.isEmpty()) {
                    postSingleEvent(eventQueue.remove(0), postingState);
                }
            } finally {
                //值还原
                postingState.isPosting = false;
                postingState.isMainThread = false;
            }
        }
    }
 
  
//做了一个线程并发变量保存处理
private final ThreadLocal currentPostingThreadState = new ThreadLocal() {
    @Override
    protected PostingThreadState initialValue() {
        return new PostingThreadState();
    }
};

 
  
/** For ThreadLocal, much faster to set (and get multiple values). */
//可以快速设置值
final static class PostingThreadState {
        final List eventQueue = new ArrayList<>();
        boolean isPosting;
        boolean isMainThread;
        Subscription subscription;
        Object event;
        boolean canceled;
    }
 
  
private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
        Class eventClass = event.getClass();
        boolean subscriptionFound = false;
        //针对参数集继承的发射，否则只发射当前参数的订阅事件
        if (eventInheritance) {
            //找到该参数对应的所有类型
            List> eventTypes = lookupAllEventTypes(eventClass);
            int countTypes = eventTypes.size();
            for (int h = 0; h < countTypes; h++) {
                Class clazz = eventTypes.get(h);
                //针对所有的类型都进行事件处理，只要有事件发射就会返回true
                subscriptionFound |= postSingleEventForEventType(event, postingState, clazz);
            }
        } else {
            subscriptionFound = postSingleEventForEventType(event, postingState, eventClass);
        }
        //如果该参数类型的订阅方法为空则做空处理
        if (!subscriptionFound) {
            if (logNoSubscriberMessages) {
                logger.log(Level.FINE, "No subscribers registered for event " + eventClass);
            }
            if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
                    eventClass != SubscriberExceptionEvent.class) {
                //这个有点绕：当从post进来的时候，设置了isPosting进行拦截，所以这里再调用的时候，具体的内容就执行不了了，这个方法就结束了，最终将isPosting撤销拦截；但是这里有个问题，因为这里调用post的时候，状态中的参数队列又增加了一个，这时while里的循环就又有了一个执行事件，然后再一次这样，当再次到达post之前时，有一个判断条件eventClass != NoSubscriberEvent.class，这个时候就可以跳出循环了；
                post(new NoSubscriberEvent(this, event));
            }
        }
    }

 
  
/** Looks up all Class objects including super classes and interfaces. Should also work for interfaces. */
//查找所有该参数类型的事件
    private static List> lookupAllEventTypes(Class eventClass) {
        synchronized (eventTypesCache) {
            //以该参数作为依据，添加自己，添加该参数所实现的接口，还有接口的父接口，都添加进去，还有该参数的父类
            List> eventTypes = eventTypesCache.get(eventClass);
            if (eventTypes == null) {
                eventTypes = new ArrayList<>();
                Class clazz = eventClass;
                while (clazz != null) {
                    //添加自己
                    eventTypes.add(clazz);
                    //添加所有接口
                    addInterfaces(eventTypes, clazz.getInterfaces());
                    //找到自己的父类，再来找父类自己以及父类的接口，循环
                    clazz = clazz.getSuperclass();
                }
                //将所有的类型都放到eventTypesCache中，参数类型作为Key
                eventTypesCache.put(eventClass, eventTypes);
            }
            return eventTypes;
        }
    }

 
  
/** Recurses through super interfaces. */
//将所有接口以及父接口都添加进来
    static void addInterfaces(List> eventTypes, Class[] interfaces) {
        for (Class interfaceClass : interfaces) {
            if (!eventTypes.contains(interfaceClass)) {
                eventTypes.add(interfaceClass);
                addInterfaces(eventTypes, interfaceClass.getInterfaces());
            }
        }
    }

 
  
//以参数类型作为key，该参数类型的父类，接口，父父类，父父接口等等一直往上接口的List作为Value
private static final Map, List>> eventTypesCache = new HashMap<>();

 
  
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class eventClass) {
        CopyOnWriteArrayList subscriptions;
        synchronized (this) {
            //找到该参数对应的所有包装事件
            subscriptions = subscriptionsByEventType.get(eventClass);
        }
        if (subscriptions != null && !subscriptions.isEmpty()) {
            //循环处理所有事件
            for (Subscription subscription : subscriptions) {
                //赋值给状态
                postingState.event = event;
                postingState.subscription = subscription;
                boolean aborted = false;
                try {
                    //进行事件发射，后续相同
                    postToSubscription(subscription, event, postingState.isMainThread);
                    aborted = postingState.canceled;
                } finally {
                    //状态归位
                    postingState.event = null;
                    postingState.subscription = null;
                    postingState.canceled = false;
                }
                //如果发射事件终止，则停止for循环，直接返回true
                if (aborted) {
                    break;
                }
            }
            return true;
        }
        return false;
    }

 
  
回溯一下：
 1、发送一个事件；为了防止线程间错乱，使用了线程本地变量ThreadLocal来管理当前线程中所需要的参数，并将这些参数包装为一个状态类PostingThreadState；
 2、将事件参数加入到状态参数的队列中；
 3、用isPosting来拦截入口；
 4、赋值到状态中；
 5、如果状态为取消，则发射终止并抛出异常；
 6、对状态中的参数队列进行循环操作；并发射
 7、如果参数继承关系是开启状态则遍历参数的所有接口类型以及继承的父类型，依次往上获取所有类型，然后开始循环发送事件；
 8、如果该参数类型的订阅事件存在则直接发射执行；后续同之前的粘性事件相同，判断是否是在主线程中，或者子线程中，最终反射执行订阅方法；
 9、如果该参数类型的订阅事件不存在，则再次发送一个空参数事件，然后被自己的isPosting拦截在执行外面，但是状态的参数队列将空参数事件加入到了队列，又发射事件，辗转又到了post，但是这次会判断该参数事件是否是空事件来判断是否终止，最终终止，释放isPosting拦截；
 10、如果继承关系关闭则只执行当前参数的订阅事件。
 
  
最后就到了解注册unregister
 
  
/** Unregisters the given subscriber from all event classes. */
    public synchronized void unregister(Object subscriber) {
        //获取当前Class中的所有订阅事件的参数类型
        List> subscribedTypes = typesBySubscriber.get(subscriber);
        if (subscribedTypes != null) {
            for (Class eventType : subscribedTypes) {
                unsubscribeByEventType(subscriber, eventType);
            }
            //解注册完所有的订阅事件，然后从map中移除该Class
            typesBySubscriber.remove(subscriber);
        } else {
            logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
        }
    }

 
  
    /** Only updates subscriptionsByEventType, not typesBySubscriber! Caller must update typesBySubscriber. */
    private void unsubscribeByEventType(Object subscriber, Class eventType) {
        //根据参数类型拿到所有的类包装方法
        List subscriptions = subscriptionsByEventType.get(eventType);
        if (subscriptions != null) {
            int size = subscriptions.size();
            for (int i = 0; i < size; i++) {
                Subscription subscription = subscriptions.get(i);
                //判断类包装方法中的类是否是当前类（不能误伤）
                if (subscription.subscriber == subscriber) {
                    //active=false宣告解注册，并且移除类包装方法
                    subscription.active = false;
                    subscriptions.remove(i);
                    i--;
                    size--;
                }
            }
        }
    }

 
  
已经解注册了，再来单独说一下黏性事件sticky
 有如下几个方法：
 
  
 
    
    
 
     黏性事件 
     作用 
    
 
    
    
    
 
     postSticky 
     发送黏性事件,将之记录到stickyEvents中，然后发送post事件，但是找不到订阅Class，所以无用,只能等订阅Class订阅了才能跟随过去 
    
 
    
 
     getStickyEvent 
     获取参数类型的值，如果参数类型没有实例化或者类型不对则抛出异常 
    
 
    
 
     removeStickyEvent 
     根据参数类型从stickyEvents中移除，并返回该参数类型的对象，同上，没有实例化或者类型不对则抛出异常 
    
 
    
 
     removeStickyEvent 
     根据某类型对象找到该类型，然后判断移除，并返回成功失败操作（Boolean） 
    
 
    
 
     removeAllStickyEvents 
     清空stickyEvents； 
    
 
    
  
 
  
参考：
 EventBus3.0源码解读
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(源码学习,EventBus,EventBus)

        

            

                
    
                    
  • Spring 源码学习(九) Transaction 事务
                        带鱼真好吃

                        
    spring系列转载自掘金VipAugushttps://juejin.cn/user/2348212565601415/postsSpringTransaction事务的使用和实现原理前言业务系统的数据，一般最后都会落入到数据库中，例如MySQL、Oracle等主流数据库，不可避免的，在数据更新时，有可能会遇到错误，这时需要将之前的数据更新操作撤回，避免错误数据。Spring的声明式事务能帮我们
    
                    
    • 
                    
  • mysql hashcode函数_Mysql源码学习——没那么简单的Hash
                        weixin_39793794
mysqlhashcode函数
                        
    Hash链表的应用比较常见，其目的就是为了将不同的值映射到不同的位置，查找的时候直接找到相应的位置，而不需要传统的顺序遍历或是二分查找，从而达到减少查询时间的目的。常规的hash是预定义一定的桶(bucket)，规定一个hash函数，然后进行散列。然而Mysql中的hash没有固定的bucket，hash函数也是动态变化的，本文就进行非深入介绍。基本结构体Hash的结构体定义以及相关的函数接口定义
    
                    
    • 
                    
  • java源码学习-Mybatis(2)与数据库建立连接
                        子波zibo
源码学习java基础mybatisjavajdbc
                        
    Mybatis与数据库建立连接jdbc执行流程图Mybatis初始化Hikari连接池的启动Mybatis获取数据库连接后记前文:Mybatis加载mapper流程由于mybatis是在jdbc的基础上进行封装的,所以jdbc执行流程获取连接->创建statements->resultSet这些步骤mybatis都是存在的,本篇学习一下Mybatis获取Connection的步骤jdbc执行流程图
    
                    
    • 
                    
  • Eventbus3.0源码解析
                        超威蓝猫l

                        
    根据官方demo首先你需要先在activity中注册EventBus.getDefault().register(this);register所以我们先从getDefault方法开始看起/**Conveniencesingletonforappsusingaprocess-wideEventBusinstance.*/publicstaticEventBusgetDefault(){EventBu
    
                    
    • 
                    
  • NVIDIA NCCL 源码学习（八）- 数据通信链路transport的建立
                        KIDGINBROOK
ncclncclgpucuda
                        
    上节以ringGraph为例介绍了机器间channel的连接过程，现在环里每个rank都知道了从哪个rank接收数据以及将数据发送给哪个rank，本节具体介绍下P2P和rdmaNET场景下数据通信链路的建立过程。上节说到nccl通过ncclTransportP2pSetup完成了数据通信链路的建立，还是以上节两机十六卡的环为例：第一台机器的环：graph->intra:GPU/0GPU/7GPU/
    
                    
    • 
                    
  • WHAT - 通过 react-use 源码学习 React（Lifecycles 篇）
                        @PHARAOH
react.js学习前端
                        
    目录一、官方介绍1.Sensors2.UI3.Animations4.Side-Effects5.Lifecycles6.State7.Miscellaneous二、源码学习示例：n.xx-yyLifecycles-useEffectOnceLifecycles-useEventLifecycles-useLifecyclesLifecycles-useMountedState&useUnmoun
    
                    
    • 
                    
  • 十,当前Activity发送事件给上一个Activity
                        CarlosLynn

                        
    当前Activity发送事件给上一个Activity当前的Activity关闭后给打开它的上一个Activity发送事件,这个类似与startActivityForResult()方法,能够实现页面关闭的回调首先我们在第一个Activity中注册注销订阅者事件其次我们定义订阅者方法接收事件EventBusAActivity代码如下publicclassEventBusAActivityextend
    
                    
    • 
                    
  • Java源码学习之高并发编程基础——AQS源码剖析之阻塞队列（下）
                        永往不庭
java学习后端性能优化
                        
    1.前言&目录前言：在上一篇文章AQS源码剖析之阻塞队列（上）中介绍了以独占锁模式下AQS的基本原理，AQS仅仅起到了一个“维持线程等待秩序”的作用，那么本篇文章继续讲解共享锁模式下的特点。AQS不操纵锁的获取或者释放，仅仅提供一个由双向链表组成的队列，让抢不到锁的线程进入队列排队并阻塞起来、持有锁的线程释放锁后“通知”（即从阻塞态中唤醒）排名最靠前的有效（非CANCELLED状态）节点去重新竞争
    
                    
    • 
                    
  • 基于事件总线EventBus实现邮件推送功能
                        快乐非自愿
邮件架构
                        
    什么是事件总线事件总线是对发布-订阅模式的一种实现。它是一种集中式事件处理机制，允许不同的组件之间进行彼此通信而又不需要相互依赖，达到一种解耦的目的。关于这个概念，网上有很多讲解的，这里我推荐一个讲的比较好的（事件总线知多少）什么是RabbitMQRabbitMQ这个就不用说了，想必到家都知道。粗糙流程图简单来解释就是：1、定义一个事件抽象类publicabstractclassEventData
    
                    
    • 
                    
  • vue3+ts 中使用mitt进行跨组件通信
                        我胡为喜呀
vue.js前端框架前端
                        
    mitt插件的使用安装插件进行封装一个模块，对外暴露一个Mitt实例使用安装插件官方文档pnpmimitt--s//我用的pnpm或npmi--smitt或yarnaddmitt进行封装一个模块，对外暴露一个Mitt实例1、在utils文件夹下新建mitt（例如mitt.ts），用于初始化并导出mitt实例：//src/eventBus.tsimportmittfrom'mitt';//定义事件类
    
                    
    • 
                    
  • java eventbus_【bird-java】分布式服务间的事件总线EventBus
                        一山同学
javaeventbus
                        
    什么是EventBusEventBus是对发布-订阅模式的一种实现。其以一种非常优雅的方式实现了组件间的解耦与通信，在Android开发、DDD等领域都有非常广泛的应用。事件流大致如下：Producer向EventBus发送事件。EventBus向所有监听了该事件的Consumer推送事件。监听了该事件的Consumer消费事件。注：一个组件即可以是Producer，也可以是Consumer。分布
    
                    
    • 
                    
  • 2021-10-21 vue笔记-组件化开发(四) 组建通信:非父子通信-事件总线,在vue项目中使用eventbus的例子
                        前端OnTheRun
vue学习笔记vue.js组件非父子通信组建通信eventBus
                        
    文章目录1.事件总线(eventBus)定义用途原理2.eventBus使用步骤3.在HTML网页中使用事件总线:模拟公众号和用户之间信息的发送和接收代码结果4.在vue项目中使用事件总线:点击增加减小按钮实现数值的增减4.1.初始化:创建一个事件总线4.2.发送事件:导入eventBus，使用`$emit`发送数据；子组件IncrementCount子组件DecreaseCountIncreme
    
                    
    • 
                    
  • EventBus(事件总线)的使用和源码的简单解析
                        Tai_Monster
Android开发笔记java开发语言android
                        
    GoogleGuavaEventBus(事件总线)的使用和源码的简单解析什么是EventBus？事件总线（EventBus）是一种广泛用于软件架构中的设计模式，用于实现解耦和松散耦合的通信机制。它可以帮助组织和管理应用程序中不同组件之间的通信，以提高应用程序的可维护性、可扩展性和灵活性。在事件总线模式中，不同的组件通过订阅和发布事件来进行通信。发布者发布一个事件，订阅者可以订阅该事件并在事件发生时
    
                    
    • 
                    
  • 简易Python：xlrd 和 openpyxl 库读取Excel单元格数据几种方式
                        PythonKaiser
pythonwindowsexcel
                        
    xlrd库是比较经典的一个库了，经典到vscode都没有代码提示，也没有高亮显示，堪称古典。xlrd也是很轻量的库，用起来不难。初步了解面向对象编码后，也可以尝试阅读源码学习代码组织方式。以下进入正题。首先当然是下载安装xlrd库了，然后import该库。在链式调用的各个函数中填入相应参数：文件路径和工作表序号（或名称），以上都是读取同一个单元格的数据，可以看出，几种读取方式的代码数量是一样的。而
    
                    
    • 
                    
  • Spark-第三周
                        fightingD&W
Sparkspark大数据分布式
                        
    1.sparkcontext初始化源码分析Spark源码（7）-SparkContext初始化源码分析_太与旅spark源码-CSDN博客Spark源码学习(一)：SparkContext初始化源码分析_sparkinitialize-CSDN博客2.任务调度源码分析job提交spark提交job运行流程_请详述spark核心执行流程,如何使用sparksubmit在客户端提交job后如何通过st
    
                    
    • 
                    
  • Java基础——System系统类
                        风之彼端
Java学习java开发语言
                        
    System系统类（在职的人不去看）跟着源码学习，不看api，一般是给学习者看常用方法：//学习数组的时候，自己写过数组拷贝的代码，工具类publicstaticnativevoidarraycopy(Objectsrc,intsrcPos（开始的索引）,Objectdest,intdestPos（开始拷贝的数组索引位置）,intlength（要拷贝多长）);//查询当前系统时间System.cu
    
                    
    • 
                    
  • 【小程序】小程序的eventBus
                        陈大左
小程序
                        
    小程序组件跨组件通讯没有比较好的方案，小程序原生的方法也不支持eventBus，只能自己开发一个源码网上看了些，加gpt修改一下varEventBus=function(){functionEventBus(){this.events={};}EventBus.prototype.on=function(eventName,callback){if(!this.events[eventName])
    
                    
    • 
                    
  • Gin 框架源码学习（一） -- 服务启动前
                        
gogin框架
                        
    官方简介GinisawebframeworkwritteninGo(Golang).Itfeaturesamartini-likeAPIwithperformancethatisupto40timesfasterthankstohttprouter.Ifyouneedperformanceandgoodproductivity,youwillloveGin.一些核心的结构*Enginegin实例结
    
                    
    • 
                    
  • vue 中provide的用法_聊聊Vue中provide/inject的应用详解
                        weixin_39796238
vue中provide的用法
                        
    众所周知，在组件式开发中，最大的痛点就在于组件之间的通信。在Vue中，Vue提供了各种各样的组件通信方式，从基础的props/$emit到用于兄弟组件通信的EventBus，再到用于全局数据管理的Vuex。在这么多的组件通信方式中，provide/inject显得十分阿卡林(毫无存在感)。但是，其实provide/inject也有它们的用武之地。今天，我们就来聊聊Vue中provide/injec
    
                    
    • 
                    
  • vue新特性provide/inject深入学习
                        C972325584
前端vue.js
                        
    阅读本文帮你你可以在使用provide/inject传递响应式数据时记住一个特性:provide传递的每一个响应式数据都需要值是一个引用不变的可监听对象。在开发vue项目时，不可避免的需要进行组件之间的相互通信。如果是在一个实际的业务项目中，组件间的通信可以采用采用像vuex,EventBus等机制实现跨组件通信。但如果在开发基础组件库时，需要跟业务项目外部环境(vuex，EventBus)解耦，
    
                    
    • 
                    
  • 「连载」边缘计算（十七）02-20：边缘部分源码（源码分析篇）
                        十越科技
边缘计算人工智能
                        
    （接上篇）EdgeCore之edged下面对EdgeCore组件进行剖析，因为EdgeCore中的功能组件比较多，共包括devicetwin、edged、edgehub、eventbus、edgemesh、metamanager、servicebus和test共8个功能模块。限于篇幅，本文只对edged的具体逻辑以及edged调用容器运行时进行剖析。1.edged的具体逻辑剖析从EdgeCore模
    
                    
    • 
                    
  • c# 自己造轮子之——EventBus事件总线的使用-自己实现事件总线（一）
                        漫游者码农
c#
                        
    背景：之前公司由于开发人员少，相对业务并没有那么复杂，并没有涉及到事件总线EventBus，而到了新公司，看到类似发送邮件，发送短信的业务，调用非常方便，吸引了兴趣去一探究竟，当然看起来很高深，但一旦搞懂原理后，它就没那么高深，这里写下来学习过程，一方面方便以后复习，另一个方面也希望能帮到别人强烈建议大家亲自多写几遍，关于反射，泛型，接口，抽象类，抽象方法，虚方法，有一个深刻的认识强烈建议大家亲自
    
                    
    • 
                    
  • 事件总线知多少（1）
                        weixin_33779515
ui
                        
    源码路径：Github-EventBus事件总线知多少（1）事件总线知多少（2）1.引言事件总线这个概念对你来说可能很陌生，但提到观察者（发布-订阅）模式，你也许就很熟悉。事件总线是对发布-订阅模式的一种实现。它是一种集中式事件处理机制，允许不同的组件之间进行彼此通信而又不需要相互依赖，达到一种解耦的目的。我们来看看事件总线的处理流程：了解了事件总线的基本概念和处理流程，下面我们就来分析下如何去实
    
                    
    • 
                    
  • C#&.NET 使用RabbitMQ实现一个分布式事件总线(二)
                        郭麻花
RabbitMQEventBus.NET
                        
    在上文我们介绍了本地事件总线的一个简单实现，这次我们通过借助RabbitMQ,来完成分布式事件总线的设计。代码仓库：MaH.EventBusNuget:Install-PackageMaH.EventBus-Version0.7.0设计思路我希望可以通过指定交换器名称、接收队列名称、连接信息，自动创建MQ连接与基础内容建设，以此来简化使用。当然，对于单纯的生产者来说，队列名称不是必须的，因此Add
    
                    
    • 
                    
  • C# 如何实现一个事件总线
                        Archy_Wang_1
.NETCorec#.netcore.net
                        
    EventBus（事件总线）是一种用于在应用程序内部或跨应用程序组件之间进行事件通信的机制。它允许不同的组件通过发布和订阅事件来进行解耦和通信。在给定的代码片段中，我们可以看到一个使用C#实现的EventBus。它定义了一些接口和类来实现事件的发布和订阅。首先，我们有两个基本的约束接口：IEvent和IAsyncEventHandler。IEvent是一个空接口，用于约束事件的类型。IAsyncE
    
                    
    • 
                    
  • 121 Linux C++ 通讯架构实战 nginx源码学习目的，学习源码前期准备
                        hunandede
linux架构nginx
                        
    零nginx源码学习的目的把nginx中最要的，有用的，代码提取出来作为我们自己知识库的一部分，以备将来使用一，nginx源码在windows上也可以下载下来。我们下载下来，注意下载的是nginx的linux源码，只是我们存放在windows下。然后解压就好，winrar就可以解压二，nginx源码查看工具。visualstudiocode解压后，我们发现源码文件不少，用什么工具比较好呢？这里我们
    
                    
    • 
                    
  • Android源码剖析----EventBus的工作原理
                        简书不简单iiii

                        
    现实开发中用到的框架为了方便更好的理解加深记忆，归纳如下：在开发中使用eventbus主要是为了进行传值和传递一些意图，第一次使用后就被这个框架的灵活和解耦性给折服。。。去熟悉eventbus的工作原理之前得首先知道一个设计模式那就是观察者模式，什么是观察者模式呢？就是为了定义对象间的一种一对多的依赖关系，即当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。整个eventbus
    
                    
    • 
                    
  • 解决 android-apt plugin is incompatible with the Android Gradle plugin. Please use 'annotationProcesso
                        lycknight

                        
    在使用EventBus3.0的时候，在AndroidStudio执行SyncProject的时候出现了这个错误android-aptpluginisincompatiblewiththeAndroidGradleplugin.Pleaseuse'annotationProcessor'由于网上很多介绍EventBus3.0是基于gradle2.2.0之前的的版本，而Gradle3.0之后，Andr
    
                    
    • 
                    
  • controller-manager学习三部曲之三：deployment的controller启动分析
                        程序员欣宸
client-gokubernetes实战kubernetesclient-go
                        
    欢迎访问我的GitHub这里分类和汇总了欣宸的全部原创(含配套源码)：https://github.com/zq2599/blog_demos《controller-manager学习三部曲》完整链接通过脚本文件寻找程序入口源码学习deployment的controller启动分析本篇概览本文是《controller-manager学习三部曲》的终篇，前面咱们从启动到运行已经分析了controll
    
                    
    • 
                    
  • 【前端高频面试题--Vue组件通信篇】
                        码上有前
前端前端vue.jsjavascript
                        
    作者：“码上有前”文章简介：前端高频面试题欢迎小伙伴们点赞、收藏⭐、留言前端高频面试题--Vue组件通信篇props/$emit父子组件传值父子组件传值案例EventBus事件总线依赖注入（provide/inject）ref/$refs$parent/$children$attrs/$listeners总结props/$emitprops和$emit是Vue.js中用于实现父子组件通信的两个关键
    
                    
    • 
                                
  • mondb入手
                                    木zi_鸣
mongodb
                                    
    windows 启动mongodb  编写bat文件， 
 
mongod --dbpath D:\software\MongoDBDATA 
mongod --help  查询各种配置 
配置在mongob 
 
打开批处理，即可启动，27017原生端口，shell操作监控端口  扩展28017，web端操作端口 
 
启动配置文件配置， 
 
数据更灵活 
    
                                
    • 
                                
  • 大型高并发高负载网站的系统架构
                                    bijian1013
高并发负载均衡
                                    
            扩展Web应用程序 
一.概念 
        简单的来说，如果一个系统可扩展，那么你可以通过扩展来提供系统的性能。这代表着系统能够容纳更高的负载、更大的数据集，并且系统是可维护的。扩展和语言、某项具体的技术都是无关的。扩展可以分为两种： 
        1.
    
                                
    • 
                                
  • DISPLAY变量和xhost(原创)
                                    czmmiao
display
                                    
    DISPLAY 
在Linux/Unix类操作系统上, DISPLAY用来设置将图形显示到何处. 直接登陆图形界面或者登陆命令行界面后使用startx启动图形, DISPLAY环境变量将自动设置为:0:0, 此时可以打开终端, 输出图形程序的名称(比如xclock)来启动程序, 图形将显示在本地窗口上, 在终端上输入printenv查看当前环境变量, 输出结果中有如下内容:DISPLAY=:0.0
    
                                
    • 
                                
  • 获取B/S客户端IP
                                    周凡杨
java编程jspWeb浏览器
                                    
       最近想写个B/S架构的聊天系统，因为以前做过C/S架构的QQ聊天系统，所以对于Socket通信编程只是一个巩固。对于C/S架构的聊天系统，由于存在客户端Java应用，所以直接在代码中获取客户端的IP，应用的方法为： 
   String ip = InetAddress.getLocalHost().getHostAddress(); 
然而对于WEB
    
                                
    • 
                                
  • 浅谈类和对象
                                    朱辉辉33
编程
                                    
        类是对一类事物的总称，对象是描述一个物体的特征，类是对象的抽象。简单来说，类是抽象的，不占用内存，对象是具体的， 
占用存储空间。 
    类是由属性和方法构成的，基本格式是public  class 类名{ 
 
 //定义属性 
 private/public 数据类型 属性名； 
 
 //定义方法 
 publ
    
                                
    • 
                                
  • android activity与viewpager+fragment的生命周期问题
                                    肆无忌惮_
viewpager
                                    
    有一个Activity里面是ViewPager，ViewPager里面放了两个Fragment。 
第一次进入这个Activity。开启了服务，并在onResume方法中绑定服务后，对Service进行了一定的初始化，其中调用了Fragment中的一个属性。 
		super.onResume();
		bindService(intent, conn, BIND_AUTO_CREATE);

    
                                
    • 
                                
  • base64Encode对图片进行编码
                                    843977358
base64图片encoder
                                    
    /**
	 * 对图片进行base64encoder编码
	 * 
	 * @author mrZhang
	 * @param path
	 * @return
	 */
	public static String encodeImage(String path) {
		BASE64Encoder encoder = null;
		byte[] b = null;
		I
    
                                
    • 
                                
  • Request Header简介
                                    aigo
servlet
                                    
    当一个客户端(通常是浏览器)向Web服务器发送一个请求是，它要发送一个请求的命令行，一般是GET或POST命令，当发送POST命令时，它还必须向服务器发送一个叫“Content-Length”的请求头(Request   Header)   用以指明请求数据的长度，除了Content-Length之外，它还可以向服务器发送其它一些Headers，如：    
    
                                
    • 
                                
  • HttpClient4.3 创建SSL协议的HttpClient对象
                                    alleni123
httpclient爬虫ssl
                                    
    public class HttpClientUtils
{
	public static CloseableHttpClient createSSLClientDefault(CookieStore cookies){
		SSLContext sslContext=null;
		
		try
		{
			sslContext=new SSLContextBuilder().l
    
                                
    • 
                                
  • java取反 -右移-左移-无符号右移的探讨
                                    百合不是茶
位运算符 位移
                                    
    取反：
		在二进制中第一位，1表示符数，0表示正数
		byte a = -1;
		原码：10000001
		反码：11111110
		补码：11111111
      //异或: 00000000
		byte b = -2;
		原码：10000010
		反码：11111101
		补码：11111110
      //异或: 00000001
		
	
    
                                
    • 
                                
  • java多线程join的作用与用法
                                    bijian1013
java多线程
                                    
            对于JAVA的join，JDK 是这样说的：join public final void join （long millis ）throws InterruptedException Waits at most millis milliseconds for this thread to die. A timeout of 0 means t
    
                                
    • 
                                
  • Java发送http请求(get 与post方法请求)
                                    bijian1013
javaspring
                                    
    PostRequest.java 
package com.bijian.study;

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURL
    
                                
    • 
                                
  • 【Struts2二】struts.xml中package下的action配置项默认值
                                    bit1129
struts.xml
                                    
    在第一部份，定义了struts.xml文件，如下所示： 
  
<!DOCTYPE struts PUBLIC
        "-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
        "http://struts.apache.org/dtds/struts
    
                                
    • 
                                
  • 【Kafka十三】Kafka Simple Consumer
                                    bit1129
simple
                                    
    代码中关于Host和Port是割裂开的，这会导致单机环境下的伪分布式Kafka集群环境下，这个例子没法运行。 
实际情况是需要将host和port绑定到一起， 
  
package kafka.examples.lowlevel;

import kafka.api.FetchRequest;
import kafka.api.FetchRequestBuilder;
impo
    
                                
    • 
                                
  • nodejs学习api
                                    ronin47
nodejs api
                                    
    NodeJS基础 什么是NodeJS 
JS是脚本语言，脚本语言都需要一个解析器才能运行。对于写在HTML页面里的JS，浏览器充当了解析器的角色。而对于需要独立运行的JS，NodeJS就是一个解析器。 
每一种解析器都是一个运行环境，不但允许JS定义各种数据结构，进行各种计算，还允许JS使用运行环境提供的内置对象和方法做一些事情。例如运行在浏览器中的JS的用途是操作DOM，浏览器就提供了docum
    
                                
    • 
                                
  • java-64.寻找第N个丑数
                                    bylijinnan
java
                                    
    


public class UglyNumber {

	/**
	 * 64.查找第N个丑数
具体思路可参考 [url] http://zhedahht.blog.163.com/blog/static/2541117420094245366965/[/url]
	 * 
题目：我们把只包含因子
2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14
    
                                
    • 
                                
  • 二维数组（矩阵）对角线输出
                                    bylijinnan
二维数组
                                    
    

/**
二维数组 对角线输出 两个方向
例如对于数组：
{ 1, 2, 3, 4 }, 
{ 5, 6, 7, 8 },
{ 9, 10, 11, 12 }, 
{ 13, 14, 15, 16 },

slash方向输出：
1 
5 2 
9 6 3 
13 10 7 4 
14 11 8 
15 12 
16 

backslash输出：
4 
3
    
                                
    • 
                                
  • [JWFD开源工作流设计]工作流跳跃模式开发关键点(今日更新)
                                    comsci
工作流
                                    
       既然是做开源软件的,我们的宗旨就是给大家分享设计和代码,那么现在我就用很简单扼要的语言来透露这个跳跃模式的设计原理 
 
   大家如果用过JWFD的ARC-自动运行控制器,或者看过代码,应该知道在ARC算法模块中有一个函数叫做SAN(),这个函数就是ARC的核心控制器,要实现跳跃模式,在SAN函数中一定要对LN链表数据结构进行操作,首先写一段代码,把
    
                                
    • 
                                
  • redis常见使用
                                    cuityang
redis常见使用
                                    
    redis 通常被认为是一个数据结构服务器，主要是因为其有着丰富的数据结构 strings、map、 list、sets、 sorted sets 
 
引入jar包 jedis-2.1.0.jar  (本文下方提供下载) 
 
package redistest; 
 
import redis.clients.jedis.Jedis; 
 
public class Listtest
    
                                
    • 
                                
  • 配置多个redis
                                    dalan_123
redis
                                    
    配置多个redis客户端 
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi=&quo
    
                                
    • 
                                
  • attrib命令
                                    dcj3sjt126com
attr
                                    
         
attrib指令用于修改文件的属性.文件的常见属性有:只读.存档.隐藏和系统.      
  只读属性是指文件只可以做读的操作.不能对文件进行写的操作.就是文件的写保护.  
 
  存档属性是用来标记文件改动的.即在上一次备份后文件有所改动.一些备份软件在备份的时候会只去备份带有存档属性的文件.  
 
    
                                
    • 
                                
  • Yii使用公共函数
                                    dcj3sjt126com
yii
                                    
    在网站项目中，没必要把公用的函数写成一个工具类，有时候面向过程其实更方便。   在入口文件index.php里添加   require_once('protected/function.php');   即可对其引用，成为公用的函数集合。   function.php如下：   
   <?php   /**     * This is the shortcut to D
    
                                
    • 
                                
  • linux 系统资源的查看（free、uname、uptime、netstat）
                                    eksliang
netstatlinux unamelinux uptimelinux free
                                    
    linux 系统资源的查看 
转载请出自出处：http://eksliang.iteye.com/blog/2167081 
  
http://eksliang.iteye.com 一、free查看内存的使用情况 
语法如下： 
  
free [-b][-k][-m][-g] [-t]
参数含义
-b:直接输入free时，显示的单位是kb我们可以使用b(bytes),m
    
                                
    • 
                                
  • JAVA的位操作符
                                    greemranqq
位运算JAVA位移<<>>>
                                    
    最近几种进制，加上各种位操作符，发现都比较模糊，不能完全掌握，这里就再熟悉熟悉。 
  
1.按位操作符 ： 
   按位操作符是用来操作基本数据类型中的单个bit,即二进制位，会对两个参数执行布尔代数运算，获得结果。 
   与（&）运算： 
   1&1 = 1, 1&0 = 0, 0&0 &
    
                                
    • 
                                
  • Web前段学习网站
                                    ihuning
Web
                                    
      
Web前段学习网站 
菜鸟学习：http://www.w3cschool.cc/ 
  
JQuery中文网：http://www.jquerycn.cn/ 
  
内存溢出：http://outofmemory.cn/#csdn.blog 
  
http://www.icoolxue.com/ 
  
http://www.jikexue
    
                                
    • 
                                
  • 强强联合：FluxBB 作者加盟 Flarum
                                    justjavac
r
                                    
    原文：FluxBB Joins Forces With Flarum作者：Toby Zerner译文：强强联合：FluxBB 作者加盟 Flarum译者：justjavac  
FluxBB 是一个快速、轻量级论坛软件，它的开发者是一名德国的 PHP 天才 Franz Liedke。FluxBB 的下一个版本(2.0)将被完全重写，并已经开发了一段时间。FluxBB 看起来非常有前途的，
    
                                
    • 
                                
  • java统计在线人数（session存储信息的）
                                    macroli
javaWeb
                                    
    这篇日志是我写的第三次了 前两次都发布失败！郁闷极了！ 
  
由于在web开发中常常用到这一部分所以在此记录一下，呵呵，就到备忘录了！ 
我对于登录信息时使用session存储的，所以我这里是通过实现HttpSessionAttributeListener这个接口完成的。 
1、实现接口类，在web.xml文件中配置监听类，从而可以使该类完成其工作。 
public class Ses
    
                                
    • 
                                
  • bootstrp carousel初体验 快速构建图片播放
                                    qiaolevip
每天进步一点点学习永无止境bootstrap纵观千象
                                    
    img{
			border: 1px solid white;
			box-shadow: 2px 2px 12px #333;
			_width: expression(this.width > 600 ? "600px" : this.width + "px");
			_height: expression(this.width &
    
                                
    • 
                                
  • SparkSQL读取HBase数据，通过自定义外部数据源
                                    superlxw1234
sparksparksqlsparksql读取hbasesparksql外部数据源
                                    
    关键字：SparkSQL读取HBase、SparkSQL自定义外部数据源 
  
  
前面文章介绍了SparSQL通过Hive操作HBase表。 
  
SparkSQL从1.2开始支持自定义外部数据源(External DataSource)，这样就可以通过API接口来实现自己的外部数据源。这里基于Spark1.4.0，简单介绍SparkSQL自定义外部数据源，访
    
                                
    • 
                                
  • Spring Boot 1.3.0.M1发布
                                    wiselyman
spring boot
                                    
        Spring Boot 1.3.0.M1于6.12日发布，现在可以从Spring milestone repository下载。这个版本是基于Spring Framework 4.2.0.RC1,并在Spring Boot 1.2之上提供了大量的新特性improvements and new features。主要包含以下： 
  
1.提供一个新的sprin
    
                                
    •