零星瓢虫
零星瓢虫

探究EventBus的运行原理

1 EventBus简介

EventBus是由greenrobot组织贡献的一个Android事件发布/订阅轻量级框架。它的github地址是：
https://github.com/greenrobot/EventBus

看看github上面的简（吹）介（捧）：

EventBus...
simplifies the communication between components
decouples event senders and receivers
performs well with Activities, Fragments, and background threads
avoids complex and error-prone dependencies and life cycle issues
makes your code simpler
is fast
is tiny (~60k jar)
is proven in practice by apps with 1,000,000,000+ installs
has advanced features like delivery threads, subscriber priorities, etc.

EventBus简化了应用程序内各个组件之间进行通信的复杂度，尤其是碎片之间进行通信的问题，可以避免由于使用广播通信而带来的诸多不便。而且它很快，包只有60k已经安装在了1,000,000,000+个应用中广泛使用了。

2 EventBus的简单使用

1 gradle中添加依赖

implementation 'org.greenrobot:eventbus:3.2.0'

火星瓢虫_001.png

2 添加混淆到混淆文件中。
*-keepattributes Annotation
-keepclassmembers class * {
@org.greenrobot.eventbus.Subscribe ;
}
-keep enum org.greenrobot.eventbus.ThreadMode { *; }

如果你有用到AsyncExecutor类
-keepclassmembers class * extends org.greenrobot.eventbus.util.ThrowableFailureEvent {
(java.lang.Throwable);
}*

3 开始使用:
定义一个事件：

public  class MessageEvent {
    /* Additional fields if needed */
    public String message;

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

准备订阅者的事件接收方法：

    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onMessageEvent(MessageEvent event) {
        Toast.makeText(this,event.message,Toast.LENGTH_LONG).show();
    }

注册和解除订阅者的订阅事件：

  @Override
    protected void onStart() {
        super.onStart();
        EventBus.getDefault().register(this);
    }

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

发送事件：

findViewById(R.id.hello_eventBus).setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                EventBus.getDefault().post(new MessageEvent("this is  an event"));
            }
        });

现在我们点击hello_eventBus这个控件，就是弹出Toast对话框。接下来一步步分析EventBus是如何实现这样的工作的：

先看一下EventBus.getDefault().register(this);这个方法;

3. EventBus的初始化

进入EventBus类中：

 //使用单例模式构造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;
    }
   // 建造者模式
    private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();

    public EventBus() {
        this(DEFAULT_BUILDER);
    }

    //初始化EventBus内部的一些组件 
    EventBus(EventBusBuilder builder) {

        logger = builder.getLogger();
        // Event为key，Subscription为Value的发布者
        subscriptionsByEventType = new HashMap<>();
        //Subscriber为key，Event为Value
        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;
        //没有事件处理 是否发送      NoSubscriberEvent事件  
        sendNoSubscriberEvent = builder.sendNoSubscriberEvent;
        //是否抛出异常      
        throwSubscriberException = builder.throwSubscriberException;
        eventInheritance = builder.eventInheritance;
        executorService = builder.executorService;
    }

可以看到EventBus使用了单例模式创建，同时使用了构建者模式创建了一些必要的组件集合。

    // key 为 Class 对象，value 为被订阅者的集合 
    private final Map, CopyOnWriteArrayList> subscriptionsByEventType;
    // key 为 Object 对象，value 为订阅者的集合 
    private final Map>> typesBySubscriber;
   // key 为 Class 对象，value 为 Object 对象
    private final Map, Object> stickyEvents;

上述几个集合先简单进行描述；

接下来先重点关注到几个相关的 Poster 是做什么？

MainThreadSupport

mainThreadSupport = builder.getMainThreadSupport();

  // 获取looper
  MainThreadSupport getMainThreadSupport() {
        if (mainThreadSupport != null) {
            return mainThreadSupport;
        } else if (AndroidLogger.isAndroidLogAvailable()) {
            Object looperOrNull = getAndroidMainLooperOrNull();
            return looperOrNull == null ? null :
                    new MainThreadSupport.AndroidHandlerMainThreadSupport((Looper) looperOrNull);
        } else {
            return null;
        }
    }

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

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

}

可以看到 MainThreadSupport 主要获取的是主线程的 Looper（通过 Looper.getMainLooper() 方法），AndroidHandlerMainThreadSupport 顾名思义，也是想要支持一些主线程将要进行的操作；

继续查看 createPoster 方法 创建了一个 HandlerPoster 的实例；

public class HandlerPoster extends Handler implements Poster {
    private final PendingPostQueue queue;  //PendingPostQueue 队列
    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) {
     
    }
    //处理消息
    @Override
    public void handleMessage(Message msg) {
     
}

HandlerPoster 类实现了 Handler 类，这里肯定和消息的处理有关，即实例中对应的 Toast 响应；

这里先对 enqueue 方法进行分析；

    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");
                }
            }
        }
    }

了解 enqueue 方法之前，看来得先看看 PendingPost 是干嘛的；

PendingPost

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

    Object event;
    Subscription subscription;
    PendingPost next;

    private PendingPost(Object event, Subscription subscription) {
        this.event = event;
        this.subscription = subscription;
    }
   
    // 相当于组装一个 PendingPost 对象返回
    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);
    }
  
   // 重置 pendingPost 数据 加入到池子中
    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);
            }
        }
    }

}

可以看到 PendingPost 类维护了一个 PendingPost 的池子，每次调用 obtainPendingPost 其实就是组装一个 PendingPost 数据进行返回；

拿到了 PendingPost 之后，enqueue 方法会继续调用 queue.enqueue(pendingPost)，这里就要继续查看 PendingPostQueue 类；

PendingPostQueue

final class PendingPostQueue {
    private PendingPost head;
    private PendingPost tail;
    
    synchronized void enqueue(PendingPost 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 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();
    }

}

PendingPostQueue 维护了一个 PendingPost 队列，用来添加以及取 PendingPost；PendingPost 添加完成了之后，调用 sendMessage 发送消息；

sendMessage 已经将消息发送出去，接下来继续看 HandlerPoster 的 handlerMessage 方法；

    @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();// 取出 PendingPost
                        if (pendingPost == null) {
                            handlerActive = false;
                            return;
                        }
                    }
                }
                eventBus.invokeSubscriber(pendingPost); // 调用  invokeSubscriber 处理事件
                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;
        }
    }

到这里，就可以发现了，其实 HandlerPoster 只是利用了 Handler ，当收到消息时候，组装PendingPost，并放入队列中，同时 Handler 发送一个消息，当 Handler 收到消息，则会从队列中取出 PendingPost ，然后最终通过 eventBus.invokeSubscriber(pendingPost) 调用处理事件；

到这里 MainThreadSupport 类介绍完毕，其中涉及到 HandlerPoster、PendingPost、PendingPostQuene 之间的相关操作，简单用以下示意图进行描述：

MainThreadSupport.png

BackgroundPoster

接下来，继续查看 BackgroundPoster 类

final class BackgroundPoster implements Runnable, Poster {

    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);// 开启线程池执行 run 方法；
            }
        }
    }
  // 从队列取出事件去执行
    @Override
    public void run() {
        try {
            try {
                while (true) {
                    PendingPost pendingPost = queue.poll(1000);// 等待1000ms 去取PendingPost
                    if (pendingPost == null) {
                        synchronized (this) { // 保证同步性，所以下面再次调用 poll 方法确认
                            // Check again, this time in synchronized
                            pendingPost = queue.poll();
                            if (pendingPost == null) { // 没有数据了 返回
                                executorRunning = false;
                                return;
                            }
                        }
                    }
                    eventBus.invokeSubscriber(pendingPost);
                }
            } catch (InterruptedException e) {
                eventBus.getLogger().log(Level.WARNING, Thread.currentThread().getName() + " was interruppted", e);
            }
        } finally {
            executorRunning = false;
        }
    }

}

BackgroundPoster 中 PendingPost 的构造过程与 HandlerPost 一致，与 MainThreadSupport 的 HandlerPoster 不同的是 ，BackgroundPoster 实现了 Runnale 方法；BackgroundPoster 对事件的分发调用处理应该是在 run 的方法中；

BackgroundPoster 构造完成了 PendingPost 后，通过线程池来执行 Runnale ，而 最后处理事件则是通过调用 EventBus 的 invokeSubscriber 方法；

所以 HandlerPoster 主要应用了 Handler 的机制在主线程处理，而 BackgroundPoster 则是直接在子线程取 PendingPost 进行 invokeSubscriber 调用处理；

同样，对 BackgroundPoster 进行示意图简单描述；

BackgroundPoster.png

AsyncPoster

同理 asyncPoster = new AsyncPoster(this):

class AsyncPoster implements Runnable, Poster {

    private final PendingPostQueue queue;
    private final EventBus eventBus;

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

    public void enqueue(Subscription subscription, Object event) {
        PendingPost pendingPost = PendingPost.obtainPendingPost(subscription, event);
        queue.enqueue(pendingPost);
        eventBus.getExecutorService().execute(this);
    }

    @Override
    public void run() {
        PendingPost pendingPost = queue.poll();
        if(pendingPost == null) {
            throw new IllegalStateException("No pending post available");
        }
        eventBus.invokeSubscriber(pendingPost);
    }

}

AsyncPoster 和 BackgroundPoster 基本一致，区别在于 AsyncPoster 每次线程池只会取出一条 PendingPost 进行处理；

到这里 MainThreadSupport 中的 HandlerPoster 、BackgroundPoster、AsyncPoster 已经分析完成；

通过分析，以上三个 Poster 主要用于接收到消息信息后的 PendingPost 组装，区别在与主线程去处理消息则需要通过 Handler 机制，而对于子线程，直接开启线程在 run 方法进行处理即可；

接下来我们继续看下进行注解的方法：

    @Subscribe(threadMode = ThreadMode.MAIN,sticky = true)
    public void onMessageEvent(MessageEvent event) {
        Toast.makeText(this,event.message,Toast.LENGTH_LONG).show();
    }

View层进行注解

@Documented
@Retention(RetentionPolicy.RUNTIME) // 运行期间有效
@Target({ElementType.METHOD}) // 方法注解
public @interface Subscribe {
    // 处理事件的所在线程
    ThreadMode threadMode() default ThreadMode.POSTING;
    
    // 是否是粘性事件，
    boolean sticky() default false;

    //时间的优先级
    int priority() default 0;
}

Subscribe 注解方法定义了时间响应的线程、是否为粘性事件、以及事件的优先级。后面发送事件过程会继续进行详细分析；

几种处理事件的线程方式：

public enum ThreadMode {

    POSTING, // 发送event事件的线程进行处理

    MAIN, // 主线程处理，会阻塞 需要防止阻塞主线程

    MAIN_ORDERED,// 主线程处理，不会在主线程阻塞

    BACKGROUND, // 会在后台线程处理事件

    ASYNC // 会创建一个新的线程处理
}

可以看到这里注解主要定义了运行区间以及处理事件的线程，这里的线程和之前分析的HandlerPoster、BackgroundPoster、AsyncPoster 对应；

4 register 注册事件订阅

EventBus.getDefault().register(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 方法会找到注册所在类（例如BaseActivity），通过 subscriberClass 找到所有的注册方法；通过subscribe 进行绑定；

查看 findSubscriberMethods 方法；

private static final Map, List> METHOD_CACHE = new ConcurrentHashMap<>();

  List findSubscriberMethods(Class subscriberClass) {
       
        List subscriberMethods = METHOD_CACHE.get(subscriberClass); // 通过缓存去取
        if (subscriberMethods != null) {// 缓存拿到了数据即返回
            return subscriberMethods;
        }

        if (ignoreGeneratedIndex) {// 默认为false
            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;
        }
    }

如果缓存中有则去缓存中取出数据，如果没有，会通过 findUsingInfo 方法去查找类中的订阅方法，继续查看 findUsingInfo 方法：

 private List findUsingInfo(Class subscriberClass) {
        FindState findState = prepareFindState();  // FindState 对象获取
        findState.initForSubscriber(subscriberClass); // 赋值Class
        while (findState.clazz != null) {
            findState.subscriberInfo = getSubscriberInfo(findState); // 获取subscriberInfo 
            if (findState.subscriberInfo != null) {
                SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods();  // 获取方法集合
                for (SubscriberMethod subscriberMethod : array) {
                    if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {            // 检查方法 
                              findState.subscriberMethods.add(subscriberMethod);  // 添加方法到findState
                    }
                }
            } else { // 获取 SubscriberInfo
                findUsingReflectionInSingleClass(findState);
            }
            findState.moveToSuperclass(); // 去父类查找
        }
       
        return getMethodsAndRelease(findState); // 释放相关资源
    }

findUsingInfo 查找订阅方法主要通过 FindState 类进行操作；

FindState

查看 FindState 类

   static class FindState {
        final List subscriberMethods = new ArrayList<>();  // 订阅的方法集合
        final Map anyMethodByEventType = new HashMap<>(); // EventType事件对应的方法的HashMap集合
        final Map subscriberClassByMethodKey = new HashMap<>();   // methodKey对应的class的HashMap集合
        final StringBuilder methodKeyBuilder = new StringBuilder(128);

        Class subscriberClass;// 注册方法所在的类 class
        Class clazz;
        boolean skipSuperClasses;
        SubscriberInfo subscriberInfo;

        void initForSubscriber(Class subscriberClass) {// 初始化 subscriberClass
            this.subscriberClass = clazz = subscriberClass;
            skipSuperClasses = false;
            subscriberInfo = null;
        }

FindState 主要保存了注册的类Class，以及相关订阅方法信息；

下图所示 FindState 和 SubscriberMethod 的关联；

SubscriberMethod.png

继续往下查看 getSubscriberInfo 方法 ；

    private SubscriberInfo getSubscriberInfo(FindState findState) {
        if (findState.subscriberInfo != null && findState.subscriberInfo.getSuperSubscriberInfo() != null) {
            SubscriberInfo superclassInfo = findState.subscriberInfo.getSuperSubscriberInfo();
            if (findState.clazz == superclassInfo.getSubscriberClass()) {
                return superclassInfo;
            }
        }
        if (subscriberInfoIndexes != null) {
            for (SubscriberInfoIndex index : subscriberInfoIndexes) {
                SubscriberInfo info = index.getSubscriberInfo(findState.clazz);
                if (info != null) {
                    return info;
                }
            }
        }
        return null;
    }

FindState 在初始化完成的时候并没有 SubscriberInfo 信息，实际这里执行了 findUsingReflectionInSingleClass 去获取的；

在这之前还是先看看 SubscriberInfo 类都有什么信息：

public interface SubscriberInfo {
    Class getSubscriberClass();

    SubscriberMethod[] getSubscriberMethods();

    SubscriberInfo getSuperSubscriberInfo();

    boolean shouldCheckSuperclass();
}

是一个接口，那么后面肯定有实现 SubscriberInfo 的类，继续看 findUsingReflectionInSingleClass 方法；

    private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
            // This is faster than getMethods, especially when subscribers are fat classes like Activities
            methods = findState.clazz.getDeclaredMethods();// 获取注册类中的所有方法
        } catch (Throwable th) {
            // Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
            try {
                methods = findState.clazz.getMethods();// 获取注册类中的所有方法
            } catch (LinkageError error) { // super class of NoClassDefFoundError to be a bit more broad...
                String msg = "Could not inspect methods of " + findState.clazz.getName();
                if (ignoreGeneratedIndex) {
                    msg += ". Please consider using EventBus annotation processor to avoid reflection.";
                } else {
                    msg += ". Please make this class visible to EventBus annotation processor to avoid reflection.";
                }
                throw new EventBusException(msg, error);
            }
            findState.skipSuperClasses = true;
        }
        for (Method method : methods) { // 遍历方法
            int modifiers = method.getModifiers();
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) { // public 方法
                Class[] parameterTypes = method.getParameterTypes();
                if (parameterTypes.length == 1) {
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);// 获取注解的方法
                    if (subscribeAnnotation != null) {
                        Class eventType = parameterTypes[0];// 注解方法的传参
                        if (findState.checkAdd(method, eventType)) {// 
                            ThreadMode threadMode = subscribeAnnotation.threadMode();// 获取注解方法的线程声明
                            findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                    subscribeAnnotation.priority(), subscribeAnnotation.sticky()));// 添加到 FindState 中，包含传参，处理事件的线程，优先级，是否是粘性事件
                        }
                    }
                } 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");
            }
        }
    }

findUsingReflectionInSingleClass 方法通过反射会找到注册类中所有的 subscribe 方法，然后将相关信息构造成 SubscriberMethod 类存到 FindState 的 subscriberMethods 中；

当前注册类 class 中执行完成后，会继续转移到注册类的父类中重复操作。找到父类中所有的订阅方法；直到没有父类了，最后将查找到的 subscriberMethods 返回，并释放 FindState 资源；

以上为默认 FindState.subscriberInfo 为空的情况的逻辑，实则当 subscriberInfo 不为空的情况下，有个 checkAdd 方法也会去查找父类，最终添加 subscriberMethod ；

拿到了所有的 subscriberMethods 方法，接下来则会调用到 subscribe(subscriber, subscriberMethod) 对获取的方法进行绑定：


    private final Map, CopyOnWriteArrayList> subscriptionsByEventType;
    private final Map>> typesBySubscriber;
    private final Map, Object> stickyEvents;
   
    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class eventType = subscriberMethod.eventType; // 获取事件类型 例如 MessageEvent
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);//通过subscriber(例如:activity)和 subscriberMethod 组装Subscription对象
        CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType);   // key：EventType  value：subscriptions查找subscriptions
        if (subscriptions == null) { // 为空新建并加入subscriptions，
            subscriptions = new CopyOnWriteArrayList<>();
            subscriptionsByEventType.put(eventType, subscriptions); // 按照 eventType 分类(example MessageEvent)
        } else {
            if (subscriptions.contains(newSubscription)) { // 不为空且已经有该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;
            }
        }

        // key ：subscriber（例如：activity） value：eventType(例如：MessageEvent) 进行添加数据
        List> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents); // 按照 subscriber 分类(example : BaseActivity)
        }
        subscribedEvents.add(eventType);


        
        if (subscriberMethod.sticky) {// 粘性事件会直接去执行相关响应
            if (eventInheritance) { // EventType 的父类 ，实现类的对应 方法同样会被调用
                // 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();
                    if (eventType.isAssignableFrom(candidateEventType)) {// 查找父类，实现类对应的EventType 进行调用执行
                        Object stickyEvent = entry.getValue();
                        checkPostStickyEventToSubscription(newSubscription, stickyEvent);
                    }
                }
            } else { // 只会调用这一个事件 马上被调用执行
                Object stickyEvent = stickyEvents.get(eventType);
                checkPostStickyEventToSubscription(newSubscription, stickyEvent);
            }
        }
    }

根据 类中注册的方法，subscribe 方法会根据 EventType 以及 subscriber 注册所在类进行分类；用 Map 结构进行保存数据；

粘性事件会通过 checkPostStickyEventToSubscription 方法马上进行发送；同时根据 eventInheritance 判断是否调用 EventType 对应的父类 以及 实现类的响应方法；

如下述方法中 A、B、C事件对应方法均会执行；

public class MainActivity extends Activity {
    private static final String TAG="EventBus";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
    @Override
    protected void onStart() {
        super.onStart();
        Log.v(TAG, "onStart()");
        EventBus.getDefault().register(this);
        EventBus.getDefault().post(new A());
    }
    @Override
    protected void onStop() {
        super.onStop();
        EventBus.getDefault().unregister(this);
        Log.v(TAG, "onStop()");
    }
    public void onEvent(A msg){
        Log.v(TAG, "onEvent(A msg)");
    }
    public void onEvent(B msg){
        Log.v(TAG,"onEvent(B msg)");
    }
    public void onEvent(C msg){
        Log.v(TAG,"onEvent(C msg)");
    }
    public void onEvent(D msg){
        Log.v(TAG,"onEvent(D msg)");
    }
}

到此，总结 EventBus.getDefalut().register(this) 方法主要做了以下工作：
1、创建HandlerPoster、BackgroundPoster、AsyncPoster去对应处理发送的消息；
2、获取注册类中的 subscriberMethod 方法，并且按照分类对应存储在 Map 中；
3、获取粘性事件，直接进行发送处理事件；

在上述 subscribe 方法中，粘性事件的处理方法 checkPostStickyEventToSubscription 还未进行查看，这里先放着，待后续分析发送事件后一起查看；

接下来继续看发送事件的方法

5 事件的返送

EventBus.getDefault().post(new MessageEvent("this is an event"));

    public void post(Object event) {
        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;
            }
        }
    }

 
 
可以看到的是 eventQueue 维护了事件队列，并从 eventQueue 中取事件进行发送；
 
 
eventQueue 由 PostingThreadState 提供，查看 PostingThreadState 类；
 
 
PostingThreadState
 
 
    final static class PostingThreadState {
        final List eventQueue = new ArrayList<>(); // 队列
        boolean isPosting;// 是否发送中
        boolean isMainThread;// 是否在主线程
        Subscription subscription;// 封装了subscriber 和 subscriberMethod
        Object event; // 事件
        boolean canceled; // 是否被取消
    }
 
 
很简单，维护了一些基础数据；
 
 
查看 postSingleEvent 发送方法；
 
 
    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);
                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(new NoSubscriberEvent(this, event));
            }
        }
    }

 
 
lookupAllEventTypes 方法会查找到对应注册了 事件类的 父类的相关信息，同时进行发送；
 
 
postSingleEventForEventType 进行发送事件；
 
 
    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;
                try {
                    postToSubscription(subscription, event, postingState.isMainThread); // 发送事件
                    aborted = postingState.canceled;
                } finally {
                    postingState.event = null;
                    postingState.subscription = null;
                    postingState.canceled = false;
                }
                if (aborted) {
                    break;
                }
            }
            return true;
        }
        return false;
    }

 
 
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
     * {@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();
    }
}

 
 
这里的 subscriptions 的获取就和之前 subscribe 绑定方法存储的信息关联上了，通过 subscriptions 可以找到，对应发送事件的 EventType 都在哪些类中进行注册了，同时获取到了注册方法的相关信息（也就是注解信息）；
 
 
最后遍历集合，通过 postToSubscription 发送事件；
 
 
    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 ，即处理消息事件在主线程；
 1 当我们的发送事件也是主线程的时候，调用 invokeSubscriber；
 2 当我们的发送事件不是主线程，则要借用 Handler 进行处理了，这里就使用到了之前初始化的 mainThreadPoster；
 
 
实质上在 mainThreadPoster 的 HandlerPost 中，处理事件消息依然会调用到 invokeSubscriber，mainThreadPoster 只是作为消息机制的一个线程切换来使用；
 
 
其他的情况大同小异，可自行分析；
 
 
接下来，就查看 invokeSubscriber 方法了；对应的传参分别是：
 1 subscription -- 包含注册事件所在类以及注册的方法；
 2 event -- 事件本身；
 
 
    void invokeSubscriber(Subscription subscription, Object event) {
        try {
            subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
        } catch (InvocationTargetException e) {
            handleSubscriberException(subscription, event, e.getCause());
        } catch (IllegalAccessException e) {
            throw new IllegalStateException("Unexpected exception", e);
        }
    }

 
 
通过反射调用执行事件，完成整个发送-接收过程；
 
 
现在再回到之前没有继续查看的粘性事件中，有个 checkPostStickyEventToSubscription 方法，这里应该是直接调用执行粘性事件对应的绑定方法；我们查看源代码确认是否是这样的呢？
 
 
        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.
            postToSubscription(newSubscription, stickyEvent, isMainThread());
        }

 
 
可以看到这里调用了 postToSubscription ，和上述发送事件的方法一致，所以当我们对一个响应事件定义为粘性事件，实则相当于系统自动帮我们执行了发送事件方法。会直接调用响应事件中的处理；
 
 
到这里，EventBus的注册，到事件的处理整个基本流程就已经走完了；这里可以总结一下哪些重要步骤以及主要都是做了什么工作：
 1 EventBus.getDefault()，创建响应 Poster ,对应 Poster 实则是为了处理线程的切换问题；
 2 EventBus.getDefault().register()；去查找项目中注解的方法，方法类型，方法名，注解所在类等集合数据，存储在本地并返回；
 3 EventBus.getDefault().post(new MessageEvent("this is an event"));发送事件，对比对应本地存储的数据，同时依赖初始化建立的 Poster 切换线程；
 4 粘性事件会在注册类初始化的时候立刻进行响应事件；
 
 
到这里EventBus的主要流程以及方法已经总结完了，可以看到EventBus主要用了java里面的反射方法以及Android中的handler处理机制，这里进行过多研究。
 如果对handler有所疑惑；可查看探究Handler的运行机制.
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(探究EventBus的运行原理)

        

            

                
    
                    
  • 斤斤计较的婚姻到底有多难？
                        白心之岂必有为

                        
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
    
                    
    • 
                    
  • 情绪觉察日记第37天
                        露露_e800

                        
    今天是家庭关系规划师的第二阶最后一天，慧萍老师帮我做了个案，帮我处理了埋在心底好多年的一份恐惧，并给了我深深的力量！这几天出来学习，爸妈过来婆家帮我带小孩，妈妈出于爱帮我收拾东西，并跟我先生和婆婆产生矛盾，妈妈觉得他们没有照顾好我…。今晚回家见到妈妈，我很欣赏她并赞扬她，妈妈说今晚要跟我睡我说好，当我们俩躺在床上准备睡觉的时候，我握着妈妈的手对她说:妈妈这几天辛苦你了，你看你多利害把我们的家收拾得
    
                    
    • 
                    
  • 芦花鞋一四
                        许叶晗

                        
    又是在一个寒冷的夏日里，青铜和葵花决定今天一起去卖芦花鞋，奶奶亲手给他们做了一碗热乎乎的粥对他们说:“就靠你们两挣生活费了这碗粥赶紧趁热喝了吧！”于是青铜和葵花喝完了奶奶给她们做的粥，就准备去镇上卖卢花鞋，这回青铜和葵花穿着新的芦花鞋来到了镇上。青铜这回看到了很多人都在卖，用手势表达对葵花说:“这回有好多人在抢我们生意呢！我们必须得吆喝起来。”葵花点了点头。可是谁知他们也大声的叫，卖芦花喽！卖芦花
    
                    
    • 
                    
  • QQ群采集助手，精准引流必备神器
                        2401_87347160
其他经验分享
                        
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
    
                    
    • 
                    
  • 关于沟通这件事，项目经理不需要每次都面对面进行
                        流程大师兄

                        
    很多项目经理都会遇到这样的问题，项目中由于事情太多，根本没有足够的时间去召开会议，那在这种情况下如何去有效地管理项目中的利益相关者？当然，不建议电子邮件也不需要开会的话，建议可以采取下面几种方式来形成有效的沟通，这几种方式可以帮助你努力的通过各种办法来保持和各方面的联系。项目经理首先要问自己几个问题，项目中哪些利益相关者是必须要进行沟通的？可以列出项目中所有的利益相关者清单，同时也整理出项目中哪些
    
                    
    • 
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • 铭刻于星（四十二）
                        随风至

                        
    69夜晚，绍敏同学做完功课后，看了眼房外，没听到动静才敢从书包的夹层里拿出那个心形纸团。折痕压得很深，都有些旧了，想来是已经写好很久了。绍敏同学慢慢地、轻轻地捏开折叠处，待到全部拆开后，又反复抚平纸张，然后仔细地一字字默看。只是开头的三个字是第一次看到，让她心漏跳了几拍。“亲爱的绍敏：从四年级的时候，我就喜欢你了，但是我一直不敢说，怕影响你学习。六年级的时候听说有人跟你表白，你接受了，我很难过，但
    
                    
    • 
                    
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说
                        造命者说

                        
    底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说我叫吴起，生于公元前440年的战国初期，正是群雄并起、天下纷争不断的时候。后人说我是军事家、政治家、改革家，是兵家代表人物。评价我一生历仕鲁、魏、楚三国，通晓兵家、法家、儒家三家思想，在内政军事上都有极高的成就。周安王二十一年（公元前381年），因变法得罪守旧贵族，被人乱箭射死。我出生在卫国一个“家累万金”的富有家庭，从年轻时候起就不甘平凡
    
                    
    • 
                    
  • 2020-01-25
                        晴岚85

                        
    郑海燕坚持分享590天2020.1.24在生活中只存在两个问题。一个问题是：你知道想要达成的目标是什么，但却不知道如何才能达成；另一个问题是：你不知道你的目标是什么。前一个是行动的问题，后一个是结果的问题。通过制定具体的下一步行动，可以解决不知道如何开始行动的问题。而通过去想象结果，对结果做预估，可以解决找不着目标的问题。对于所有吸引我们注意力，想要完成的任务，你可以先想象一下，预期的结果究竟是什
    
                    
    • 
                    
  • 随笔 | 仙一般的灵气
                        海思沧海

                        
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
    
                    
    • 
                    
  • 想家
                        爆米花机

                        
    也许不同于大家对家乡的思念，我对家乡甚至是疯狂的不舍。还未踏出车站就感觉到幸福，我享受这里的夕阳、这里的浓烈柴火味、这里每一口家常菜。我是宅女，我贪恋家的安逸。刚刚踏出大学校门，初出茅庐，无法适应每年只能国庆和春节回家。我焦虑、失眠、无端发脾气，是无法适应工作的节奏，是无法接受我将一步步离开家乡的事实。我不想承认自己胸无大志，选择再次踏上征程。图片发自App
    
                    
    • 
                    
  • 【iOS】MVC设计模式
                        Magnetic_h
iosmvc设计模式objective-c学习ui
                        
    MVC前言如何设计一个程序的结构，这是一门专门的学问，叫做"架构模式"（architecturalpattern），属于编程的方法论。MVC模式就是架构模式的一种。它是Apple官方推荐的App开发架构，也是一般开发者最先遇到、最经典的架构。MVC各层controller层Controller/ViewController/VC（控制器）负责协调Model和View，处理大部分逻辑它将数据从Mod
    
                    
    • 
                    
  • OC语言多界面传值五大方式
                        Magnetic_h
iosui学习objective-c开发语言
                        
    前言在完成暑假仿写项目时，遇到了许多需要用到多界面传值的地方，这篇博客来总结一下比较常用的五种多界面传值的方式。属性传值属性传值一般用前一个界面向后一个界面传值，简单地说就是通过访问后一个视图控制器的属性来为它赋值，通过这个属性来做到从前一个界面向后一个界面传值。首先在后一个界面中定义属性@interfaceBViewController:UIViewController@propertyNSSt
    
                    
    • 
                    
  • 一百九十四章. 自相矛盾
                        巨木擎天

                        
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
    
                    
    • 
                    
  • UI学习——cell的复用和自定义cell
                        Magnetic_h
ui学习
                        
    目录cell的复用手动（非注册）自动（注册）自定义cellcell的复用在iOS开发中，单元格复用是一种提高表格（UITableView）和集合视图（UICollectionView）滚动性能的技术。当一个UITableViewCell或UICollectionViewCell首次需要显示时，如果没有可复用的单元格，则视图会创建一个新的单元格。一旦这个单元格滚动出屏幕，它就不会被销毁。相反，它被添
    
                    
    • 
                    
  • element实现动态路由+面包屑
                        软件技术NINI
vue案例vue.js前端
                        
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
    
                    
    • 
                    
  • 10月|愿你的青春不负梦想-读书笔记-01
                        Tracy的小书斋

                        
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
    
                    
    • 
                    
  • C语言宏函数
                        南林yan
C语言c语言
                        
    一、什么是宏函数？通过宏定义的函数是宏函数。如下，编译器在预处理阶段会将Add(x,y)替换为((x)*(y))#defineAdd(x,y)((x)*(y))#defineAdd(x,y)((x)*(y))intmain(){inta=10;intb=20;intd=10;intc=Add(a+d,b)*2;cout<
                    
    • 
                    
  • 地推话术，如何应对地推过程中家长的拒绝
                        校师学

                        
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
    
                    
    • 
                    
  • 谢谢你们，爱你们！
                        鹿游儿

                        
    昨天家人去泡温泉，二个孩子也带着去，出发前一晚，匆匆下班，赶回家和孩子一起收拾。饭后，我拿出笔和本子（上次去澳门时做手帐的本子）写下了1\2\3\4\5\6\7\8\9,让后让小壹去思考，带什么出发去旅游呢？她在对应的数字旁边画上了，泳衣、泳圈、肖恩、内衣内裤、tapuy、拖鞋……画完后，就让她自己对着这个本子，将要带的，一一带上，没想到这次带的书还是这本《便便工厂》(晚上姑婆发照片过来，妹妹累得
    
                    
    • 
                    
  • C语言如何定义宏函数？
                        小九格物
c语言
                        
    在C语言中，宏函数是通过预处理器定义的，它在编译之前替换代码中的宏调用。宏函数可以模拟函数的行为，但它们不是真正的函数，因为它们在编译时不会进行类型检查，也不会分配存储空间。宏函数的定义通常使用#define指令，后面跟着宏的名称和参数列表，以及宏展开后的代码。宏函数的定义方式：1.基本宏函数：这是最简单的宏函数形式，它直接定义一个表达式。#defineSQUARE(x)((x)*(x))2.带参
    
                    
    • 
                    
  • 微服务下功能权限与数据权限的设计与实现
                        nbsaas-boot
微服务java架构
                        
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    
                    
    • 
                    
  • 理解Gunicorn：Python WSGI服务器的基石
                        范范0825
ipythonlinux运维
                        
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
    
                    
    • 
                    
  • 小丽成长记（四十三）
                        玲玲54321

                        
    小丽发现，即使她好不容易调整好自己的心态下一秒总会有不确定的伤脑筋的事出现，一个接一个的问题，人生就没有停下的时候，小问题不断出现。不过她今天看的书，她接受了人生就是不确定的，厉害的人就是不断创造确定性，在Ta的领域比别人多的确定性就能让自己脱颖而出，显示价值从而获得的比别人多的利益。正是这样的原因，因为从前修炼自己太少，使得她现在在人生道路上打怪起来困难重重，她似乎永远摆脱不了那种无力感，有种习
    
                    
    • 
                    
  • 学点心理知识，呵护孩子健康
                        静候花开_7090

                        
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
    
                    
    • 
                    
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹
                        黄错错加油

                        
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
    
                    
    • 
                    
  • Cell Insight | 单细胞测序技术又一新发现，可用于HIV-1和Mtb共感染个体诊断
                        尐尐呅

                        
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
    
                    
    • 
                    
  • c++ 的iostream 和 c++的stdio的区别和联系
                        黄卷青灯77
c++算法开发语言iostreamstdio
                        
    在C++中，iostream和C语言的stdio.h都是用于处理输入输出的库，但它们在设计、用法和功能上有许多不同。以下是两者的区别和联系：区别1.编程风格iostream（C++风格）：C++标准库中的输入输出流类库，支持面向对象的输入输出操作。典型用法是cin（输入）和cout（输出），使用>操作符来处理数据。更加类型安全，支持用户自定义类型的输入输出。#includeintmain(){in
    
                    
    • 
                    
  • 瑶池防线
                        谜影梦蝶

                        
    冥华虽然逃过了影梦的军队，但他是一个忠臣，他选择上报战况。败给影梦后成逃兵，高层亡尔还活着，七重天失守......随便一条，即可处死冥华。冥华自然是知道以仙界高层的习性此信一发自己必死无疑，但他还选择上报实情，因为责任。同样此信送到仙宫后，知道此事的人，大多数人都认定冥华要完了，所以上到仙界高层，下到扫大街的，包括冥华自己，全都准备好迎接冥华之死。如果仙界现在还属于两方之争的话，冥华必死无疑。然而
    
                    
    • 
                    
  • 爬山后遗症
                        璃绛

                        
    爬山，攀登，一步一步走向制高点，是一种挑战。成功抵达是一种无法言语的快乐，在山顶吹吹风，看看风景，这是从未有过的体验。然而，爬山一时爽，下山腿打颤，颠簸的路，一路向下走，腿部力量不够，走起来抖到不行，停不下来了！第二天必定腿疼，浑身酸痛，坐立难安！
    
                    
    • 
                                
  • 多线程编程之卫生间
                                    周凡杨
java并发卫生间线程厕所
                                    
    如大家所知，火车上车厢的卫生间很小，每次只能容纳一个人，一个车厢只有一个卫生间，这个卫生间会被多个人同时使用，在实际使用时，当一个人进入卫生间时则会把卫生间锁上，等出来时打开门，下一个人进去把门锁上，如果有一个人在卫生间内部则别人的人发现门是锁的则只能在外面等待。问题分析：首先问题中有两个实体，一个是人，一个是厕所，所以设计程序时就可以设计两个类。人是多数的，厕所只有一个（暂且模拟的是一个车厢）。
    
                                
    • 
                                
  • How to Install GUI to Centos Minimal
                                    sunjing
linuxInstallDesktopGUI
                                    
    http://www.namhuy.net/475/how-to-install-gui-to-centos-minimal.html 
  
I have centos 6.3 minimal running as web server. I’m looking to install gui to my server to vnc to my server. You can insta
    
                                
    • 
                                
  • Shell 函数
                                    daizj
shell函数
                                    
    Shell 函数 
linux shell 可以用户定义函数，然后在shell脚本中可以随便调用。 
shell中函数的定义格式如下： 
[function] funname [()]{

    action;
  
     [return int;]

} 
说明： 
 
 1、可以带function fun() 定义，也可以直接fun() 定义,不带任何参数。 
 2、参数返回
    
                                
    • 
                                
  • Linux服务器新手操作之一
                                    周凡杨
Linux 简单 操作
                                    
    1.whoami 
     当一个用户登录Linux系统之后，也许他想知道自己是发哪个用户登录的。 
     此时可以使用whoami命令。 
     [ecuser@HA5-DZ05 ~]$ whoami 
      e
    
                                
    • 
                                
  • 浅谈Socket通信（一）
                                    朱辉辉33
socket
                                    
    在java中ServerSocket用于服务器端，用来监听端口。通过服务器监听，客户端发送请求，双方建立链接后才能通信。当服务器和客户端建立链接后，两边都会产生一个Socket实例，我们可以通过操作Socket来建立通信。 
   首先我建立一个ServerSocket对象。当然要导入java.net.ServerSocket包 
   ServerSock
    
                                
    • 
                                
  • 关于框架的简单认识
                                    西蜀石兰
框架
                                    
    入职两个月多，依然是一个不会写代码的小白，每天的工作就是看代码，写wiki。 
前端接触CSS、HTML、JS等语言，一直在用的CS模型，自然免不了数据库的链接及使用，真心涉及框架，项目中用到的BootStrap算一个吧，哦，JQuery只能算半个框架吧，我更觉得它是另外一种语言。 
后台一直是纯Java代码，涉及的框架是Quzrtz和log4j。 
 
都说学前端的要知道三大框架，目前node.
    
                                
    • 
                                
  • You have an error in your SQL syntax; check the manual that corresponds to your
                                    林鹤霄

                                    
    You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'option,changed_ids  ) values('0ac91f167f754c8cbac00e9e3dc372
    
                                
    • 
                                
  • MySQL5.6的my.ini配置
                                    aigo
mysql
                                    
    注意：以下配置的服务器硬件是：8核16G内存  
  
[client] 
  
port=3306 
  
[mysql] 
  
default-character-set=utf8 
  
  
[mysqld] 
  
port=3306 
  
basedir=D:/mysql-5.6.21-win
    
                                
    • 
                                
  • mysql 全文模糊查找 便捷解决方案
                                    alxw4616
mysql
                                    
    mysql 全文模糊查找 便捷解决方案 
2013/6/14 by 半仙 [email protected] 
 
目的: 项目需求实现模糊查找. 
原则: 查询不能超过 1秒. 
 
问题: 目标表中有超过1千万条记录. 使用like '%str%' 进行模糊查询无法达到性能需求. 
解决方案: 使用mysql全文索引. 
 1.全文索引 : MySQL支持全文索引和搜索功能。MySQL中的全文索
    
                                
    • 
                                
  • 自定义数据结构 链表(单项 ,双向,环形)
                                    百合不是茶
单项链表双向链表
                                    
      
   链表与动态数组的实现方式差不多,    数组适合快速删除某个元素    链表则可以快速的保存数组并且可以是不连续的 
  
    
单项链表;数据从第一个指向最后一个 
  
实现代码: 
  
     
//定义动态链表
clas
    
                                
    • 
                                
  • threadLocal实例
                                    bijian1013
javathreadjava多线程threadLocal
                                    
    实例1： 
package com.bijian.thread;

public class MyThread extends Thread {

	private static ThreadLocal tl = new ThreadLocal() {
		protected synchronized Object initialValue() {
			return new Inte
    
                                
    • 
                                
  • activemq安全设置—设置admin的用户名和密码
                                    bijian1013
javaactivemq
                                    
            ActiveMQ使用的是jetty服务器, 打开conf/jetty.xml文件，找到 
<bean id="adminSecurityConstraint" class="org.eclipse.jetty.util.security.Constraint">
        <p
    
                                
    • 
                                
  • 【Java范型一】Java范型详解之范型集合和自定义范型类
                                    bit1129
java
                                    
    本文详细介绍Java的范型，写一篇关于范型的博客原因有两个，前几天要写个范型方法(返回值根据传入的类型而定)，竟然想了半天，最后还是从网上找了个范型方法的写法；再者，前一段时间在看Gson, Gson这个JSON包的精华就在于对范型的优雅简单的处理，看它的源代码就比较迷糊，只其然不知其所以然。所以，还是花点时间系统的整理总结下范型吧。 
  范型内容 
 
 范型集合类 
 范型类 
 
    
                                
    • 
                                
  • 【HBase十二】HFile存储的是一个列族的数据
                                    bit1129
hbase
                                    
    在HBase中，每个HFile存储的是一个表中一个列族的数据，也就是说，当一个表中有多个列簇时，针对每个列簇插入数据，最后产生的数据是多个HFile，每个对应一个列族，通过如下操作验证 
  
1. 建立一个有两个列族的表 
  
create 'members','colfam1','colfam2' 
  
2. 在members表中的colfam1中插入50*5
    
                                
    • 
                                
  • Nginx 官方一个配置实例
                                    ronin47
nginx 配置实例
                                    
    user       www www;
worker_processes  5;
error_log  logs/error.log;
pid        logs/nginx.pid;
worker_rlimit_nofile 8192;

events {
  worker_connections  4096;}

http {
  include    conf/mim
    
                                
    • 
                                
  • java-15.输入一颗二元查找树，将该树转换为它的镜像， 即在转换后的二元查找树中，左子树的结点都大于右子树的结点。 用递归和循环
                                    bylijinnan
java
                                    
    
//use recursion
	public static void mirrorHelp1(Node node){
		if(node==null)return;
		swapChild(node);
		mirrorHelp1(node.getLeft());
		mirrorHelp1(node.getRight());
	}
	//use no recursion bu
    
                                
    • 
                                
  • 返回null还是empty
                                    bylijinnan
javaapachespring编程
                                    
    第一个问题，函数是应当返回null还是长度为0的数组（或集合）？ 
第二个问题，函数输入参数不当时，是异常还是返回null？ 
 
先看第一个问题 
 
有两个约定我觉得应当遵守： 
 
1.返回零长度的数组或集合而不是null（详见《Effective Java》） 
 
理由就是，如果返回empty，就可以少了很多not-null判断： 
 

List<Person> list
    
                                
    • 
                                
  • [科技与项目]工作流厂商的战略机遇期
                                    comsci
工作流
                                    
     
 
      在新的战略平衡形成之前，这里有一个短暂的战略机遇期，只有大概最短6年，最长14年的时间，这段时间就好像我们森林里面的小动物，在秋天中，必须抓紧一切时间存储坚果一样，否则无法熬过漫长的冬季。。。。 
 
 
        在微软，甲骨文，谷歌，IBM,SONY
    
                                
    • 
                                
  • 过度设计-举例
                                    cuityang
过度设计
                                    
    过度设计，需要更多设计时间和测试成本，如无必要，还是尽量简洁一些好。 
未来的事情，比如 访问量，比如数据库的容量，比如是否需要改成分布式  都是无法预料的 
 
再举一个例子，对闰年的判断逻辑： 
　　1、 if($Year%4==0) return True; else return Fasle; 
　　2、if (   ($Year%4==0  &am
    
                                
    • 
                                
  • java进阶，《Java性能优化权威指南》试读
                                    darkblue086
java性能优化
                                    
    记得当年随意读了微软出版社的.NET 2.0应用程序调试，才发现调试器如此强大，应用程序开发调试其实真的简单了很多，不仅仅是因为里面介绍了很多调试器工具的使用，更是因为里面寻找问题并重现问题的思想让我震撼，时隔多年，Java已经如日中天，成为许多大型企业应用的首选，而今天，这本《Java性能优化权威指南》让我再次找到了这种感觉，从不经意的开发过程让我刮目相看，原来性能调优不是简单地看看热点在哪里，
    
                                
    • 
                                
  • 网络学习笔记初识OSI七层模型与TCP协议
                                    dcj3sjt126com
学习笔记
                                    
       协议：在计算机网络中通信各方面所达成的、共同遵守和执行的一系列约定   　　计算机网络的体系结构：计算机网络的层次结构和各层协议的集合。   　　两类服务：   　　面向连接的服务通信双方在通信之前先建立某种状态，并在通信过程中维持这种状态的变化，同时为服务对象预先分配一定的资源。这种服务叫做面向连接的服务。   　　面向无连接的服务通信双方在通信前后不建立和维持状态，不为服务对象
    
                                
    • 
                                
  • mac中用命令行运行mysql
                                    dcj3sjt126com
mysqllinuxmac
                                    
    参考这篇博客：http://www.cnblogs.com/macro-cheng/archive/2011/10/25/mysql-001.html  感觉workbench不好用（有点先入为主了）。 
1，安装mysql 
在mysql的官方网站下载 mysql 5.5.23 http://www.mysql.com/downloads/mysql/，根据我的机器的配置情况选择了64
    
                                
    • 
                                
  • MongDB查询（1）——基本查询[五]
                                    eksliang
mongodbmongodb 查询mongodb find
                                    
    MongDB查询 
转载请出自出处：http://eksliang.iteye.com/blog/2174452 一、find简介 
MongoDB中使用find来进行查询。 
API:如下 
function ( query , fields , limit , skip, batchSize, options ){.....} 
 参数含义： 
 
 query:查询参数 
 fie
    
                                
    • 
                                
  • base64，加密解密 经融加密，对接
                                    y806839048
经融加密对接
                                    
    String data0 = new String(Base64.encode(bo.getPaymentResult().getBytes(("GBK")))); 
 String data1 = new String(Base64.decode(data0.toCharArray()),"GBK"); 
 
// 注意编码格式，注意用于加密，解密的要是同
    
                                
    • 
                                
  • JavaWeb之JSP概述
                                    ihuning
javaweb
                                    
      
什么是JSP？为什么使用JSP？ 
JSP表示Java Server Page，即嵌有Java代码的HTML页面。使用JSP是因为在HTML中嵌入Java代码比在Java代码中拼接字符串更容易、更方便和更高效。 
  
JSP起源  
  
在很多动态网页中，绝大部分内容都是固定不变的，只有局部内容需要动态产生和改变。  
如果使用Servl
    
                                
    • 
                                
  • apple watch 指南
                                    啸笑天
apple
                                    
    1. 文档 
 
  WatchKit Programming Guide（中译在线版 By @CocoaChina）    译文 译者 原文   概览 - 开始为 Apple Watch 进行开发 @星夜暮晨 Overview - Developing for Apple Watch   概览 - 配置 Xcode 项目 - Overview - Configuring Yo
    
                                
    • 
                                
  • java经典的基础题目
                                    macroli
java编程
                                    
    1.列举出 10个JAVA语言的优势 a:免费，开源，跨平台(平台独立性)，简单易用，功能完善，面向对象，健壮性，多线程，结构中立，企业应用的成熟平台, 无线应用 2.列举出JAVA中10个面向对象编程的术语 a:包，类，接口，对象，属性，方法，构造器，继承，封装，多态，抽象，范型 3.列举出JAVA中6个比较常用的包 Java.lang;java.util;java.io;java.sql;ja
    
                                
    • 
                                
  • 你所不知道神奇的js replace正则表达式
                                    qiaolevip
每天进步一点点学习永无止境纵观千象regex
                                    
    var v = 'C9CFBAA3CAD0';
console.log(v);
var arr = v.split('');
for (var i = 0; i < arr.length; i ++) {
  if (i % 2 == 0) arr[i] = '%' + arr[i];
}
console.log(arr.join(''));

console.log(v.r
    
                                
    • 
                                
  • [一起学Hive]之十五-分析Hive表和分区的统计信息(Statistics)
                                    superlxw1234
hivehive分析表hive统计信息hive Statistics
                                    
    关键字：Hive统计信息、分析Hive表、Hive Statistics 
  
类似于Oracle的分析表，Hive中也提供了分析表和分区的功能，通过自动和手动分析Hive表，将Hive表的一些统计信息存储到元数据中。 
  
表和分区的统计信息主要包括：行数、文件数、原始数据大小、所占存储大小、最后一次操作时间等； 
  14.1 新表的统计信息 
对于一个新创建
    
                                
    • 
                                
  • Spring Boot 1.2.5 发布
                                    wiselyman
spring boot
                                    
      
  
Spring Boot 1.2.5已在7月2日发布，现在可以从spring的maven库和maven中心库下载。 
  
这个版本是一个维护的发布版，主要是一些修复以及将Spring的依赖提升至4.1.7(包含重要的安全修复)。 
  
官方建议所有的Spring Boot用户升级这个版本。 
  
项目首页 | 源
    
                                
    •