悠嘻侠
悠嘻侠

EventBus3.0源码分析(上)

概述

关于EventBus3.x的用法，本文不再赘述，只分析其实现原理，官方的流程图：


上图是EventBus基于观察者模式的事件发布流程的高度概括，经过下文的源码分析后，再来体会该流程会比较清晰。

订阅流程

需要订阅事件的对象首先需要进行注册,比如Activity中：

EventBus.getDefault().register(activity);

看看EventBus这个类中做了什么：

 /** Convenience singleton for apps using a process-wide EventBus instance. */
    /** 典型的单例模式*/
    public static EventBus getDefault() {
        if (defaultInstance == null) {
            synchronized (EventBus.class) {
                if (defaultInstance == null) {
                    defaultInstance = new EventBus();
                }
            }
        }
        return defaultInstance;
    }

很明显是典型的单例模式，那么看看EventBus的构造方法：

 /**传入建造者进行参数构建*/
    EventBus(EventBusBuilder builder) {
        //eventType作为key,Subscription为value的map集合
        subscriptionsByEventType = new HashMap<>();
        //key为订阅对象,value为该对象中所有的订阅event类型的map集合
        typesBySubscriber = new HashMap<>();
        //黏性事件map集合
        stickyEvents = new ConcurrentHashMap<>();
        //主线程的事件处理器
        mainThreadPoster = new HandlerPoster(this, Looper.getMainLooper(), 10);
        //后台线程的事件处理器
        backgroundPoster = new BackgroundPoster(this);
        //异步的事件处理器
        asyncPoster = new AsyncPoster(this);
        //注解处理器生成的索引数量,如果没用注解处理器那么为0
        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;
        //事件继承 默认true
        eventInheritance = builder.eventInheritance;
        //线程池
        executorService = builder.executorService;
    }

因为参数很多所以使用了建造者模式，这也是许多开源框架经常使用的模式，对这些参数暂时不懂没有关系，继续看下面：

    /**
     * Registers the given subscriber to receive events. Subscribers must call {@link #unregister(Object)} once they
     * are no longer interested in receiving events.
     * 

     * Subscribers have event handling methods that must be annotated by {@link Subscribe}.
     * The {@link Subscribe} annotation also allows configuration like {@link
     * ThreadMode} and priority.
     * 给事件的订阅者进行注册。订阅者一旦不再接受事件后，必须调用{@link #unregister(Object)}这个方法来进行
     * 取消订阅。
     * 订阅者的事件处理方法必须用{@link Subscribe}进行注解，该注解也允许配置 {@link ThreadMode}等属性
     */
    public void register(Object subscriber) {
        Class subscriberClass = subscriber.getClass();//获取订阅者对象的Class
        //根据订阅者对象的Class来获取订阅者的事件处理方法的list集合
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
       //循环对订阅者的方法进行注册
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

这里

 List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);

subscriberMethodFinder 对象主要封装了查找订阅者信息的一系列方法
SubscriberMethod主要封装了订阅方法的信息,比较简单：

public class SubscriberMethod {
    final Method method;//订阅方法
    final ThreadMode threadMode;//线程模式信息
    final Class eventType;//事件类
    final int priority;//优先级
    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;
    }

    @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) {
        //首先从缓存中获取保存的订阅者方法list集合
        List subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {//如果之前缓存过，就直接返回
            return subscriberMethods;
        }
        //ignoreGeneratedIndex 是否忽略由注解处理器生成的索引, 默认false
        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 {
            //将key为订阅者Class,value为subscriberMethods 放入缓存，并返回
            METHOD_CACHE.put(subscriberClass, subscriberMethods);
            return subscriberMethods;
        }
    }

该方法主要是从缓存中查找订阅者的订阅信息,如果没有则通过findUsingInfo(subscriberClass)方法查找：

private List findUsingInfo(Class subscriberClass) {
        //FindState 封装了订阅对象信息和订阅方法检测校验的类,并可以复用
        FindState findState = prepareFindState();
        //进行初始化
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            findState.subscriberInfo = getSubscriberInfo(findState);
            //这里是如果使用了注解处理器的逻辑
            if (findState.subscriberInfo != null) {
                SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods();
                for (SubscriberMethod subscriberMethod : array) {
                    if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {
                        findState.subscriberMethods.add(subscriberMethod);
                    }
                }
            } else {
                //不使用注解处理器的情况
                findUsingReflectionInSingleClass(findState);
            }
            //然后继续对父类进行查找
            findState.moveToSuperclass();
        }
        return getMethodsAndRelease(findState);
    }

这里findState对象其实封装了一些订阅信息和查找方法，简单看下：

static class FindState {
        //SubscriberMethod 订阅方法的集合
        final List subscriberMethods = new ArrayList<>();
        //存储事件类型的集合
        final Map anyMethodByEventType = new HashMap<>();
        //方法签名和订阅类的集合
        final Map subscriberClassByMethodKey = new HashMap<>();
        final StringBuilder methodKeyBuilder = new StringBuilder(128);

        Class subscriberClass;
        Class clazz;
        boolean skipSuperClasses;
        SubscriberInfo subscriberInfo;
...省略
}

看看prepareFindState方法,主要是获取一个FindState对象：

private FindState prepareFindState() {
        synchronized (FIND_STATE_POOL) {
            for (int i = 0; i < POOL_SIZE; i++) {
                FindState state = FIND_STATE_POOL[i];
                //从FindState 的缓存数组中取出一个对象进行复用
                if (state != null) {
                    FIND_STATE_POOL[i] = null;
                    return state;
                }
            }
        }//如果没有就直接new一个
        return new FindState();
    }

继续看看initForSubscriber方法，主要是进行了一些初始化：

static class FindState {
...以上省略
        void initForSubscriber(Class subscriberClass) {
            this.subscriberClass = clazz = subscriberClass;
            skipSuperClasses = false;
            subscriberInfo = null;
        }
...以下省略
}

之后进入while循环，然后先说不使用注解处理器的情况,会调用findUsingReflectionInSingleClass(findState);:

 private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
            // This is faster than getMethods, especially when subscribers are fat classes like Activities
            //注意 getDeclaredMethods 只获取当前类的方法，而不获取父类继承的方法，因此比getMethods方法速度更快
            //比如Activity本身就有大量方法,那么Activity的子类无疑使用getDeclaredMethods更好
            // 获取订阅对象所有的Method对象数组
            methods = findState.clazz.getDeclaredMethods();
        } catch (Throwable th) {
            // Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
            methods = findState.clazz.getMethods();
            findState.skipSuperClasses = true;
        }
        for (Method method : methods) {
            int modifiers = method.getModifiers();
            //判断方法是否为public,对于方法必须为public的设计,应该是为了提高查找速度,否则需要挨个判断方法注解
            //否则报异常
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                //获取方法的参数类型Class数组
                Class[] parameterTypes = method.getParameterTypes();
                //参数只能是一个,否则报错
                if (parameterTypes.length == 1) {
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                    //判断是否是Subscribe注解类型
                    if (subscribeAnnotation != null) {
                        Class eventType = parameterTypes[0];
                        //checkAdd方法主要是检测事件类型在同一个对象或者父类中是否重复注册过
                        if (findState.checkAdd(method, eventType)) {
                            ThreadMode threadMode = subscribeAnnotation.threadMode();
                            //然后将订阅方法的信息封装为SubscriberMethod,并添加到findState.subscriberMethods
                            findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                    subscribeAnnotation.priority(), subscribeAnnotation.sticky()));
                        }
                    }
                } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
                    String methodName = method.getDeclaringClass().getName() + "." + method.getName();
                    throw new EventBusException("@Subscribe method " + methodName +
                            "must have exactly 1 parameter but has " + parameterTypes.length);
                }
            } else if (strictMethodVerification && method.isAnnotationPresent(Subscribe.class)) {
                String methodName = method.getDeclaringClass().getName() + "." + method.getName();
                throw new EventBusException(methodName +
                        " is a illegal @Subscribe method: must be public, non-static, and non-abstract");
            }
        }
    }

方法其实比较清晰，主要是根据反射和注解获取方法上的订阅信息并进行封装操作,然后比较关键的检测操作findState.checkAdd(method, eventType)：

boolean checkAdd(Method method, Class eventType) {
          // 2 level check: 1st level with event type only (fast), 2nd level with complete signature when required.
          // Usually a subscriber doesn't have methods listening to the same event type.
          //2层检测，首先检测eventType,再进行完整的签名检测，一般来讲订阅对象不会重复定义监听同样的event类型的方法
          //但是如果有多个同样event类的订阅方法，那么也是合法的
          Object existing = anyMethodByEventType.put(eventType, method);
          if (existing == null) {
              return true;
          } else {
              if (existing instanceof Method) {
                  //如果之前已经保存过该方法，并且父类也具有同样的订阅方法，那么抛出异常
                  if (!checkAddWithMethodSignature((Method) existing, eventType)) {
                      // Paranoia check
                      throw new IllegalStateException();
                  }
                  // Put any non-Method object to "consume" the existing Method
                  //如果之前有相同event类型的方法存在，那么为了兼容同一个类的多个同样event的方法
                  //放入一个不是Method类型的对象，这样根据不同的判断就能区别是父类还是多方法
                  anyMethodByEventType.put(eventType, this);
              }
              return checkAddWithMethodSignature(method, eventType);
          }
      }

private boolean checkAddWithMethodSignature(Method method, Class eventType) {
          methodKeyBuilder.setLength(0);
          methodKeyBuilder.append(method.getName());
          methodKeyBuilder.append('>').append(eventType.getName());
          //用方法名和event名称组成key
          String methodKey = methodKeyBuilder.toString();
          //获取订阅方法所在的Class
          Class methodClass = method.getDeclaringClass();
          //根据key,添加methodClass到缓存,并且得到methodClassOld
          Class methodClassOld = subscriberClassByMethodKey.put(methodKey, methodClass);
          //如果methodClassOld不存在或者是methodClass自身或methodClass的父类,那么返回true,因为继承关系会继承事件订阅
          //如果子类有重写了继承的订阅方法,那么只会保留子类的订阅方法
          if (methodClassOld == null || methodClassOld.isAssignableFrom(methodClass)) {
              // Only add if not already found in a sub class
              return true;
          } else {
              // Revert the put, old class is further down the class hierarchy
              //检测到父类注册后，否则还是将methodClassOld放回缓存,因为子类重写了，所以返回false，不会再父类方法注册
              subscriberClassByMethodKey.put(methodKey, methodClassOld);
              return false;
          }
      }

该方法主要检测订阅方法的合法性，个人的理解是一种情况是用一个类中注册了多个同样event类型的方法，这种情况是允许的，另一种是子类重写父类的继承方法，如果是这样的情况那只会保留子类的订阅方法，仔细体会这里的写法。
检测完成之后再返回到findUsingReflectionInSingleClass(FindState findState)方法继续看：

ThreadMode threadMode = subscribeAnnotation.threadMode();
                            findState.subscriberMethods.add(new SubscriberMethod(method, eventType, threadMode,
                                    subscribeAnnotation.priority(), subscribeAnnotation.sticky()));

很好理解了，就是将订阅方法封装到findState对象中了，后面是要取出的。
这之后再返回到findUsingInfo(Class subscriberClass)方法中:

private List findUsingInfo(Class subscriberClass) {
        //FindState 封装了订阅对象信息和订阅方法检测校验的类,并可以复用
        FindState findState = prepareFindState();
        //进行初始化
        findState.initForSubscriber(subscriberClass);
        while (findState.clazz != null) {
            findState.subscriberInfo = getSubscriberInfo(findState);
            //这里是如果使用了注解处理器的逻辑
            if (findState.subscriberInfo != null) {
                SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods();
                for (SubscriberMethod subscriberMethod : array) {
                    if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {
                        findState.subscriberMethods.add(subscriberMethod);
                    }
                }
            } else {
                //不使用注解处理器的情况
                findUsingReflectionInSingleClass(findState);
            }
            //然后继续对父类进行查找
            findState.moveToSuperclass();
        }
        return getMethodsAndRelease(findState);
    }

此时还是处在while循环中,下一步findState.moveToSuperclass();再进入父类进行循环,直到结束,之后调用:

private List getMethodsAndRelease(FindState findState) {
        List subscriberMethods = new ArrayList<>(findState.subscriberMethods);
        findState.recycle();
        synchronized (FIND_STATE_POOL) {
            for (int i = 0; i < POOL_SIZE; i++) {
                if (FIND_STATE_POOL[i] == null) {
                    FIND_STATE_POOL[i] = findState;
                    break;
                }
            }
        }
        return subscriberMethods;
    }

该方法的作用是将findState封装的subscriberMethods集合返回，并将findState对象清空，并放入FIND_STATE_POOL缓存数组之中，方便下次使用，个人理解这里是为了优化性能，减少了重复创建对象的开销。
之后返回到findSubscriberMethods(Class subscriberClass)方法:

List findSubscriberMethods(Class subscriberClass) {

         ...上面代码省略
        //如果找不到注解方法抛出异常
        if (subscriberMethods.isEmpty()) {
            throw new EventBusException("Subscriber " + subscriberClass
                    + " and its super classes have no public methods with the @Subscribe annotation");
        } else {
            //将key为订阅者Class,value为subscriberMethods 放入缓存，并返回
            METHOD_CACHE.put(subscriberClass, subscriberMethods);
            return subscriberMethods;
        }
    }

这里METHOD_CACHE是ConcurrentHashMap集合，key是订阅对象的Class，value是该对象中所有的订阅方法集合,下次查找的时候如果存在了就可以直接从缓存中取出了。
之后再返回到:

    public void register(Object subscriber) {
        Class subscriberClass = subscriber.getClass();//获取订阅者对象的Class
        //根据订阅者对象的Class来获取订阅者的事件处理方法的list集合
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
       //循环对订阅者的方法进行注册
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

进入for循环,逐个遍历订阅者和订阅方法,看看subscribe(subscriber, subscriberMethod)方法:

    // Must be called in synchronized block
    private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class eventType = subscriberMethod.eventType;
        //Subscription 就是订阅对象和订阅方法的再次封装
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        //subscriptionsByEventType 就是eventType作为key,Subscription为value的map集合缓存,这里是取出之前的保存Subscription类型的List
        CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType);
        //subscriptions 是Null就new一个,subscriptionsByEventType并将eventType,subscriptions保存起来
        //但subscriptions此时还没有任何Subscription对象
        if (subscriptions == null) {
            subscriptions = new CopyOnWriteArrayList<>();
            subscriptionsByEventType.put(eventType, subscriptions);
        } else {//如果subscriptions已经包含了再次封装的Subscription,那么抛出异常提示
            if (subscriptions.contains(newSubscription)) {
                throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
                        + eventType);
            }
        }

        //这里会根据event的优先级来插入到subscriptions中，如果优先级相同就插入到最后
        int size = subscriptions.size();
        for (int i = 0; i <= size; i++) {
            if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {
                subscriptions.add(i, newSubscription);
                break;
            }
        }

        //typesBySubscriber 是key为订阅对象,value为该对象中所有的event的map集合
        //该集合作用是后续取消订阅的时候,方便移除订阅对象
        List> subscribedEvents = typesBySubscriber.get(subscriber);
        //subscribedEvents为null的话就new一个,然后typesBySubscriber将订阅对象和event加入进来
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        //subscribedEvents 将eventType加入进来
        subscribedEvents.add(eventType);
        //判断是不是黏性事件
        if (subscriberMethod.sticky) {
            //eventInheritance 事件继承,默认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();
                    if (eventType.isAssignableFrom(candidateEventType)) {
                        Object stickyEvent = entry.getValue();
                        checkPostStickyEventToSubscription(newSubscription, stickyEvent);
                    }
                }
            } else {
                Object stickyEvent = stickyEvents.get(eventType);
                checkPostStickyEventToSubscription(newSubscription, stickyEvent);
            }
        }
    }

该方法并不难理解，Subscription就是Object subscriber, SubscriberMethod subscriberMethod这两个对象的再封装,subscriptionsByEventType就是eventType作为key,Subscription为value的map集合缓存，设计用意就是根据事件类型找出所有的订阅者信息，这样当事件发布的时候能够方便给所有的订阅者进行方法的调用，subscribedEvents就是以订阅者subscriber为key，事件class为value的map集合缓存，在取消注册的时候可以方便进行订阅事件的删除。
然后判断是不是黏性事件，如果是黏性事件，那么首先会判断是否支持事件继承，默认true，意思就是如果订阅方法中的事件类如果实现了某些接口，那么其他实现了这些接口的订阅事件类或者是订阅事件类的父类同样会接收到事件信息，检测通过后就会直接发送事件，这个在post流程中可以体现出来，后面再进行分析，那么注册流程基本就是这样。

发布事件流程

再来看看发布流程，先看发布方法post(Object event)：

/** Posts the given event to the event bus. */
    public void post(Object event) {
       //首先获取当前线程保存的事件队列
        PostingThreadState postingState = currentPostingThreadState.get();
        List eventQueue = postingState.eventQueue;
       //将事件加入队列
        eventQueue.add(event);
        //如果没有在发布状态
        if (!postingState.isPosting) {
       //利用当前线程的Looper是否是主线程的Looper来判断当前线程是否为主线程
            postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper();
           //发布状态为true
            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;
            }
        }
    }
 
 
该方法的主要作用就是将发布的事件加入队列然后，再将当前线程保存的事件队列全部发布出去，看下currentPostingThreadState：
 
 
    private final ThreadLocal currentPostingThreadState = new ThreadLocal() {
        @Override
        protected PostingThreadState initialValue() {
            return new PostingThreadState();
        }
    };

 
 
很明显是保存了PostingThreadState的ThreadLocal对象，利用了ThreadLocal的线程特性来获取当前线程的PostingThreadState对象,关于ThreadLocal的讨论网上已经很多，个人也曾做过相关分析Android ThreadLocal及InheritableThreadLocal分析,如有需要可参考。
 这个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;
    }
 
 
明白了这些，之后回到post方法中的while循环方法postSingleEvent(eventQueue.remove(0), postingState):
 
 
   private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
        Class eventClass = event.getClass();
        boolean subscriptionFound = false;
        //默认true，支持事件继承
        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);
        }
        //如果没有找到订阅者那么做出提示，并发布一个NoSubscriberEvent事件
        if (!subscriptionFound) {
            if (logNoSubscriberMessages) {
                Log.d(TAG, "No subscribers registered for event " + eventClass);
            }
            if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
                    eventClass != SubscriberExceptionEvent.class) {
                post(new NoSubscriberEvent(this, event));
            }
        }
    }

 
 
该方法主要是找出当前事件类的所有接口类，并进行循环发布事件，如果没有订阅者，那么发布一个默认的NoSubscriberEvent事件。先看看是如何查找事件类的所有接口的lookupAllEventTypes(eventClass)：
 
 
 /** Looks up all Class objects including super classes and interfaces. Should also work for interfaces. */
    private static List> lookupAllEventTypes(Class eventClass) {
        synchronized (eventTypesCache) {
            //eventTypesCache 就是以事件类为key,以对应的接口类集合为value的map缓存
            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.put(eventClass, eventTypes);
            }
            return eventTypes;
        }
    }

 
 
这里clazz.getInterfaces()可以找出所有对应的接口集合,看看addInterfaces(eventTypes, clazz.getInterfaces())方法：
 
 
   /** 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());
            }
        }
    }

 
 
该方法递归调用获取到所有的接口类并添加到缓存，看完这里继续返回到post方法中的subscriptionFound = postSingleEventForEventType(event, postingState, eventClass)，看看该方法中做了什么：
 
 
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class eventClass) {
        CopyOnWriteArrayList subscriptions;
        synchronized (this) {
            //subscriptionsByEventType缓存中根据事件类取出订阅者集合
            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;
                }
                if (aborted) {
                    break;
                }
            }
            return true;
        }
        return false;
    }

 
 
该方法非常简单，就是根据事件类取出之前缓存的订阅着集合然后进行事件的发布，看看postToSubscription(subscription, event, postingState.isMainThread)方法：
 
 
    private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
         //根据不同的订阅线程，进行不通的处理
        switch (subscription.subscriberMethod.threadMode) {
            case POSTING:
                //post行程的话就直接发布
                invokeSubscriber(subscription, event);
                break;
            case MAIN:
                //主线程的话就直接发布，否则加入队列
                if (isMainThread) {
                    invokeSubscriber(subscription, event);
                } else {
                    mainThreadPoster.enqueue(subscription, event);
                }
                break;
            case BACKGROUND:
               //后台线程的话，如果在主线程就加入后台队列，如果不是主线程就直接发布
                if (isMainThread) {
                    backgroundPoster.enqueue(subscription, event);
                } else {
                    invokeSubscriber(subscription, event);
                }
                break;
            case ASYNC:
                //如果是异步线程都是加入异步队列
                asyncPoster.enqueue(subscription, event);
                break;
            default:
                throw new IllegalStateException("Unknown thread mode: " + subscription.subscriberMethod.threadMode);
        }
    }

 
 
这个方法就是根据不通的线程属性做相应的处理，先看下最终的调用方法：
 
 
    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);
        }
    }

 
 
就是利用反射调用方法了，很简单，然后看下黏性方法的调用过程，之后我们分析下几个不同的Poster。
 发送黏性事件的方法：
 
 
   public void postSticky(Object event) {
       synchronized (stickyEvents) {
           stickyEvents.put(event.getClass(), event);
       }
       // Should be posted after it is putted, in case the subscriber wants to remove immediately
       post(event);
   }

 
 
非常简单，首先加入stickyEvents这个黏性事件的map集合，然后再调用普通的post方法，这样保证先注册该事件的会被调用，然后再有相关事件被注册的时候，就回到register(Object subscriber)中，从stickyEvents中找到相关的事件消息再直接调用，保证后注册的的方法也能被立即调用到。
 明白了这些我们再看看不同的poster吧，这里看看HandlerPoster为例，分析之前先看看相关的封装对象：
 
 
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;
    }
    //从缓存池中取出对象，如果缓冲池没有，则new一个返回
    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);
            }
        }
    }

}

 
 
这个PendingPost对象，很明显是链表设计，next指向的就是下一个PendingPost对象，其中的几个方法也简单易懂，并设计了缓存池实现复用，考虑细致。
 再看看链表的设计：
 
 
final class PendingPostQueue {
    private PendingPost head;//链表头对象
    private PendingPost tail;//链表尾对象
    //对象入队操作
    synchronized void enqueue(PendingPost pendingPost) {
        if (pendingPost == null) {
            throw new NullPointerException("null cannot be enqueued");
        }
         //如果尾部对象不为空，那么将尾部next对象指向当前对象
         //然后尾部对象再指向当前对象，这样就将对象插入到尾部
        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();
    }

}

 
 
该对象主要实现了单链表，入队出队操作也比较简单明了。
 弄明白了这个链表结构，再看看HandlerPoster就比较清晰了：
 
 
final class HandlerPoster extends Handler {

    private final PendingPostQueue queue;//事件队列
    private final int maxMillisInsideHandleMessage;//处理耗时阈值
    private final EventBus eventBus;
    private boolean handlerActive;//是否在处理中

    HandlerPoster(EventBus eventBus, Looper looper, int maxMillisInsideHandleMessage) {
        super(looper);
        this.eventBus = eventBus;
        this.maxMillisInsideHandleMessage = maxMillisInsideHandleMessage;
        queue = new PendingPostQueue();
    }
    //主要完成入队，并发送消息功能
    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) {
                    //如果为null就进行再次同步检测
                    synchronized (this) {
                        // Check again, this time in synchronized
                        pendingPost = queue.poll();
                        if (pendingPost == null) {
                            //如果还是空，那么结束循环
                            handlerActive = false;
                            return;
                        }
                    }
                }
                //事件不为空则进行事件的调用
                eventBus.invokeSubscriber(pendingPost);
               //这里如果while循环进行的时间超过规定时间，那么会退出下，同时再发送
               //发送个消息，这样应该是防止长时间阻塞主线程，考虑到了事件过多的情况
                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会把消息入队并在主线程处理，handlerActive用来控制是否正在处理消息的状态，防止发送过快，并细致地考虑到主线程阻塞的可能性，这样就完成了消息的处理。
 另外BackgroundPoster看下：
 
 
final class BackgroundPoster implements Runnable {

    private final PendingPostQueue queue;
    private final EventBus eventBus;

    private volatile boolean executorRunning;

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

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

    @Override
    public void run() {
        try {
            try {
                while (true) {
                    //这里设定了一个等待时间，如果队列为null了，那么等待1000ms
                    PendingPost pendingPost = queue.poll(1000);
                    if (pendingPost == null) {
                        synchronized (this) {
                            // Check again, this time in synchronized
                            pendingPost = queue.poll();
                            if (pendingPost == null) {
                                executorRunning = false;
                                return;
                            }
                        }
                    }
                    eventBus.invokeSubscriber(pendingPost);
                }
            } catch (InterruptedException e) {
                Log.w("Event", Thread.currentThread().getName() + " was interruppted", e);
            }
        } finally {
            executorRunning = false;
        }
    }

}

 
 
代码和HandlerPoster比较类似，实现了Runnable接口，加入了一个等待时间，如果队列为空了等待1000ms后已经取不到对象，那么久真正退出了，也就是说尽量在同一个后台线程处理完所有的消息。
 看看``AsyncPoster```吧：
 
 
class AsyncPoster implements Runnable {

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

}

 
 
非常简单，每次入队都会在新的线程执行一次，而不是进行while循环，这样总是在新的线程进行消息的处理，并且不能保证调用顺序，这三个poster的区别可以再慢慢体会。
 
 
取消订阅流程
 
 
public synchronized void unregister(Object subscriber) {
    //首先根据注册类找到所有的注册事件类型
    List> subscribedTypes = typesBySubscriber.get(subscriber);
    if (subscribedTypes != null) {
        //遍历事件类型，从事件对应的subscriptions集合中，移除订阅者
        for (Class eventType : subscribedTypes) {
            unsubscribeByEventType(subscriber, eventType);
        }
        //然后移除订阅者所有对应的事件类
        typesBySubscriber.remove(subscriber);
    } else {
        Log.w(TAG, "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) {
                subscription.active = false;
                subscriptions.remove(i);
                i--;
                size--;
            }
        }
    }
}

 
 
取消注册流程较为简单，主要是移除订阅者自身和所对应的事件信息。
 以上就是在不使用注解处理器的情况下的事件发布和调用流程，下篇来分析下使用注解处理器的执行过程。
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(EventBus3.0源码分析(上))

        

            

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

                        
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
    
                    
    • 
                    
  • 底层逆袭到底有多难，不甘平凡的你准备好了吗？让吴起给你说说
                        造命者说

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

                        
    本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
    
                    
    • 
                    
  • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹
                        黄错错加油

                        
    感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
    
                    
    • 
                    
  • 如何在 Fork 的 GitHub 项目中保留自己的修改并同步上游更新？github_fork_update
                        iBaoxing
github
                        
    如何在Fork的GitHub项目中保留自己的修改并同步上游更新？在GitHub上Fork了一个项目后，你可能会对项目进行一些修改，同时原作者也在不断更新。如果想要在保留自己修改的基础上，同步原作者的最新更新，很多人会不知所措。本文将详细讲解如何在不丢失自己改动的情况下，将上游仓库的更新合并到自己的仓库中。问题描述假设你在GitHub上Fork了一个项目，并基于该项目做了一些修改，随后你发现原作者对
    
                    
    • 
                    
  • 30天风格练习-DAY2
                        黄希夷

                        
    Day2（重义）在一个周日/一周的最后一天，我来到位于市中心/市区繁华地带的一家购物中心/商场，中心内人很多/熙熙攘攘。我注意到/看见一个独行/孤身一人的年轻女孩/，留着一头引人注目/长过腰际的头发，上身穿一件暗红色/比正红色更深的衣服/穿在身体上的东西。走下扶梯的时候，她摔倒了/跌向地面，在她正要站起来/让身体离开地面的时候，过长/超过一般人长度的头发被支撑身体/躯干的手掌压/按在下面，她赶紧用
    
                    
    • 
                    
  • 向内而求
                        陈陈_19b4

                        
    10月27日，阴。阅读书目:《次第花开》。作者:希阿荣博堪布，是当今藏传佛家宁玛派最伟大的上师法王，如意宝晋美彭措仁波切颇具影响力的弟子之一。多年以来，赴海内外各地弘扬佛法，以正式授课、现场开示、发表文章等多种方法指导佛学弟子修行佛法。代表作《寂静之道》、《生命这出戏》、《透过佛法看世界》自出版以来一直是佛教类书籍中的畅销书。图片发自App金句:1.佛陀说，一切痛苦的根源在于我们长期以来对自身及外
    
                    
    • 
                    
  • 那个抄袭的大张伟
                        猫小努

                        
    最近一直在追《即刻电音》这个综艺，除了觉得出场节目的音乐制作人有意思之外，也觉得有两个导师挺有趣的（另外一个就忽略了吧）。孙艺兴在上一篇文章里面已经说过了，那么这篇就说说我们的大老师，大张伟吧。其实在节目刚开始大张伟出来的时候，我以为他是属于导师里面来活跃气氛负责搞笑的，毕竟孙艺兴属于卖萌卖傻卖老实的，尚雯婕一般负责装逼耍狠的，而大张伟一贯以来上综艺的形象基本上都是蹦蹦跳跳带动气氛的。谁知道，两期
    
                    
    • 
                    
  • 第一场雪
                        岁月静好_nx

                        
    早晨起来，外面白茫茫的一片，总算是下雪了，这还是今年第一场雪呢！走在路上，踩着雪“咯吱咯吱”的，空气很湿润。树上、草坪上、屋顶上都落了白白的一层，天上还零星漂着几点雪。慢慢走在路上，呼吸着清新的空气，感受着冬天的美好，心情也好多了。
    
                    
    • 
                    
  • 《大清方方案》| 第二话
                        谁佐清欢

                        
    和珅究竟说了些什么？竟能令堂堂九五之尊龙颜失色！此处暂且按下不表；单说这位乾隆皇帝，果真不愧是康熙从小带过的，一旦决定了要做的事，便杀伐决断毫不含糊。他当即亲自拟旨，着令和珅为钦差大臣，全权负责处理方方事件，并钦赐尚方宝剑，遇急则三品以下官员可先斩后奏。和珅身负皇上重托，岂敢有半点怠慢，当夜即率领相关人等，马不停蹄杀奔江汉。这一路上，和珅的几位幕僚一直在商讨方方事件的处置方案。有位年轻幕僚建议快刀
    
                    
    • 
                    
  • 【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数
                        广龙宇
一起学Rust#Rust设计模式rust设计模式开发语言
                        
    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
    
                    
    • 
                    
  • 放下是一段成长的修行
                        小莳玥

                        
    人来到这个世界上，只有两件事：生和死。一件事已经做完了，另一件你还急什么呢?是人，都有七情六欲。是心，都有喜怒哀乐，这些再正常不过了。别总抱怨自己活得累，过得辛苦。永远记住：舒坦是留给死人的。苦，才是生活；累，才是工作；变，才是命运；忍，才是历练；容，才是智慧；静，才是修养；舍，才会得到；做，才会拥有。人生，活得太清楚，才是最大的不明白。有些事，看得很清，却说不清；有些人，了解很深，却猜不透；有些
    
                    
    • 
                    
  • 从鸡肉高汤到记忆的魔法再到有效提示的艺术
                        步子哥
人工智能
                        
    还记得小时候那些天马行空的白日梦吗？也许只要按下键盘上的某个神奇组合，电脑就会发出滴滴的声响，一个隐藏的世界突然在你眼前展开，让你获得超凡的能力，摆脱平凡的生活。这听起来像是玩过太多电子游戏的幻想，但实际上，间隔重复系统给人的感觉惊人地相似。在最佳状态下，这些系统就像魔法一样神奇。本文将以一个看似平凡的鸡肉高汤食谱为例，深入浅出地探讨如何编写有效的间隔重复提示，让你像掌握烹饪技巧一样轻松地掌握记忆
    
                    
    • 
                    
  • 今天我破防了
                        sin信仰

                        
    今天本来是大年初一，新年的第一天，应该是高高兴兴的一天，但是我怎么也高兴不起来。具体原因很简单，原本计划年后去县城找了一份会计的工作，被公公婆婆否定了，我心里立马就不舒服了，但是当时刚好肚子疼，我去了厕所，等我上完厕所，公公由于喝了酒还在那里和婆婆唠叨个没完。然后我就在心情极度压抑的情况下把午饭吃完的碗筷和锅给刷了。边刷碗筷和锅，边在那里难受，感觉自己在这个家里真的是过的憋屈死了，公婆不让我去上班
    
                    
    • 
                    
  • PHP环境搭建详细教程
                        好看资源平台
前端php
                        
    PHP是一个流行的服务器端脚本语言，广泛用于Web开发。为了使PHP能够在本地或服务器上运行，我们需要搭建一个合适的PHP环境。本教程将结合最新资料，介绍在不同操作系统上搭建PHP开发环境的多种方法，包括Windows、macOS和Linux系统的安装步骤，以及本地和Docker环境的配置。1.PHP环境搭建概述PHP环境的搭建主要分为以下几类：集成开发环境：例如XAMPP、WAMP、MAMP，这
    
                    
    • 
                    
  • 2020.11.19
                        隆非凡

                        
    日精进，今日体验：在维修过程中遇到的问题，把源头找到，在进行下一步开始。不要停留在一个点上，合理调整心态，把当下事做好。
    
                    
    • 
                    
  • 关于提高复杂业务逻辑代码可读性的思考
                        编程经验分享
开发经验java数据库开发语言
                        
    目录前言需求场景常规写法拆分方法领域对象总结前言实际工作中大部分时间都是在写业务逻辑，一般都是三层架构，表示层（Controller）接收客户端请求，并对入参做检验，业务逻辑层（Service）负责处理业务逻辑，一般开发都是在这一层中写具体的业务逻辑。数据访问层（Dao）是直接和数据库交互的，用于查数据给业务逻辑层，或者是将业务逻辑层处理后的数据写入数据库。简单的增删改查接口不用多说，基本上写好一
    
                    
    • 
                    
  • 山东大学小树林支教调研团青青仓木队——翟晓楠
                        山东大学青青仓木队

                        
    过了半年，又一次启程，又一次回到支教的初心之地。比起上一次的试探与不安，我更多了一丝稳重与熟练。心境、处境也都随着半个学期的过去而变得不同，半个学期中，身体上的，心理上的，太多的逆境让我变得步履维艰，曲曲折折，弯弯绕绕，我仿佛打不起精神，没有胃口，没有动力。感觉走的不顺畅的时候，支教这个旅程，给了我力量。自告奋勇承担起队长这一职务的我，从组织时的复杂和困难的经历，协调各种问题，从无到有，和校长和队
    
                    
    • 
                    
  • 【夜读】提升生活品质的8个建议
                        茳淮秀水

                        
    停止攀比很多人之所以感觉疲惫，部分原因是来自于跟别人攀比。殊不知，攀比得到的满足只是片刻的，过后往往会感到空虚。过分在意别人的评价，丢失的是自己原有的审美，扰乱的是自己最初的节奏。不妨活得洒脱些，自己内心丰盈了，快乐就能更持久。停止自责想改变自己，先从接纳自己开始。越是过分自责，就越难改变现状，因为如果把精力全耗在自责上，就没有精力用来改变了。遇到问题，我们要用正确的心态去面对。与其一味自责，不如
    
                    
    • 
                    
  • 拥有断舍离的心态，过精简生活--《断舍离》读书笔记
                        爱吃丸子的小樱桃

                        
    不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
    
                    
    • 
                    
  • 如果做到轻松在股市赚钱？只要坚持这三个原则。
                        履霜之人

                        
    大A股里向来就有七亏二平一赚的说法，能赚钱的都是少数人。否则股市就成了慈善机构，人人都有钱赚，谁还要上班？所以说亏钱是正常的，或者说是应该的。那么那些赚钱的人又是如何做到的呢？普通人能不能找到捷径去分一杯羹呢？方法是有的，但要做到需要你有极高的自律。第一，控制仓位，散户最大的问题是追涨杀跌，只要涨起来，就把钱往股票上砸，然后被套，隔天跌的受不了，又一刀切，全部割肉。来来回回间，遍体鳞伤。所以散户首
    
                    
    • 
                    
  • 凤凰公园
                        吴侬暖语sym

                        
    凤凰公园距离我们家880米，大概步行12分钟就到了，这是我们每天饭后散步或者闲暇时的去处。现在夏季徬晚时分广场舞大妈们总是热情非凡，那里的大门口就是一个好地方，每天总有两拨人在那踩着节奏翩翩起舞呢！而且一路上，从我们小区到公园，或者从昆仑西苑沿河到公园，都是饭后锻炼的人们，川流不息，老人小孩，年轻人，…！哪哪都是。最早家乡的公园，所有公园都是要收门票的，那时候也就是休息天会有人花钱去转转，平时一般
    
                    
    • 
                    
  • GitHub上克隆项目
                        bigbig猩猩
github
                        
    从GitHub上克隆项目是一个简单且直接的过程，它允许你将远程仓库中的项目复制到你的本地计算机上，以便进行进一步的开发、测试或学习。以下是一个详细的步骤指南，帮助你从GitHub上克隆项目。一、准备工作1.安装Git在克隆GitHub项目之前，你需要在你的计算机上安装Git工具。Git是一个开源的分布式版本控制系统，用于跟踪和管理代码变更。你可以从Git的官方网站（https://git-scm.
    
                    
    • 
                    
  • 每日算法&面试题，大厂特训二十八天——第二十天（树）
                        肥学
⚡算法题⚡面试题每日精进java算法数据结构
                        
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
    
                    
    • 
                    
  • MongoDB Oplog 窗口
                        喝醉酒的小白
MongoDB运维
                        
    在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
    
                    
    • 
                    
  • Faiss Tips：高效向量搜索与聚类的利器
                        焦习娜Samantha

                        
    FaissTips：高效向量搜索与聚类的利器faiss_tipsSomeusefultipsforfaiss项目地址:https://gitcode.com/gh_mirrors/fa/faiss_tips项目介绍Faiss是由FacebookAIResearch开发的一个用于高效相似性搜索和密集向量聚类的库。它支持多种硬件平台，包括CPU和GPU，能够在海量数据集上实现快速的近似最近邻搜索（AN
    
                    
    • 
                    
  • 人怎么才能认识自己？
                        阿尚青子自由写作人

                        
    人怎么才能认识自己？（原问题）我从不愿意上纲上线地确定偌大的话题，就直接说吧。纵使你能认识世界上的万事万物，你很难做到真实地认识自己。因为即使就这个世界，基本上每个人也很难做到客观、公正、科学地认识。对你好的人就是好吗？一件事情是否能够保持永远原来的样子？借不到钱的男友，女友想离开他就理直气壮？父母对子女有几分慷慨，又有几分是无私？工作的意义究竟是什么？是工作需要你，还是你需要工作呢？诸如此类的问
    
                    
    • 
                    
  • 没有邀请码怎么注册买手妈妈?
                        氧惠评测

                        
    买手妈妈怎么注册小编为大家带来买手妈妈没有邀请码怎么注册。打开买手妈妈APP，点击“马上注册”，输入邀请信息“邀请码”点击下一步，没有邀请码是登录不上的，所以这个必须要填写，那我们没有怎么办？填写成功就可以登录下一步。这里面有手机登录和淘宝登录，手机登录以后也需要用淘宝授权的，所以基本上都是淘宝登录。购物、看电影、点外卖、用氧惠APP！更优惠！氧惠（全网优惠上氧惠）——是与以往完全不同的抖客+淘客
    
                    
    • 
                    
  • 百善孝为先
                        杜友顺

                        
    2018年11月29日天气~晴星期四找点空闲找点时间领着孩子常回家看看带上笑容带上祝福陪同爱人常回家看看家，永远是儿女们幸福温暖的港湾，那里有我们日夜思念的父母，有着彼此的牵挂，无论走到哪里，家永远是避风雨的港湾。今天没事，和媳妇回了趟老家，看看父母，回到家，房间里不算凌乱，可是细心的我发现有的地方已经沾满了灰尘，桌子上父亲不离手的烟灰缸也弹满了烟灰。几个马上就要腐烂掉的水果蔫耷的搭拉着脑袋躺在了
    
                    
    • 
                    
  • 如何成为段子手
                        欣雅阅读

                        
    我是一个尬聊大师，与朋友聊天经常把话题聊死，留我一个人在群里，望着自己打下的最后一句话无语凝噎。看到风趣幽默的朋友与人聊天，很是艳羡，觉得自己何时才能成为这样的段子手呢？一、段子是什么？“段子”一词在百度百科上的解释：本是相声中的一个艺术术语，指的是相声作品中一节或一段艺术内容。我的理解：段子就是一些搞笑的故事或者笑话。二、为什么要会说段子？不知道大家有没有这样的朋友，本来很无趣的聚会，只要有他参
    
                    
    • 
                                
  • java解析APK
                                    3213213333332132
javaapklinux解析APK
                                    
    解析apk有两种方法 
1、结合安卓提供apktool工具，用java执行cmd解析命令获取apk信息 
2、利用相关jar包里的集成方法解析apk 
 
这里只给出第二种方法，因为第一种方法在linux服务器下会出现不在控制范围之内的结果。 
 
 

public class ApkUtil
{
	/**
	 * 日志对象
	 */
	private static Logger	 
    
                                
    • 
                                
  • nginx自定义ip访问N种方法
                                    ronin47
nginx 禁止ip访问
                                    
    　　　因业务需要，禁止一部分内网访问接口，　由于前端架了F5，直接用deny或allow是不行的，这是因为直接获取的前端Ｆ５的地址。 
　　　所以开始思考有哪些主案可以实现这样的需求，目前可实施的是三种： 
　　　一：把ip段放在redis里，写一段lua 
          二：利用geo传递变量，写一段
    
                                
    • 
                                
  • mysql timestamp类型字段的CURRENT_TIMESTAMP与ON UPDATE CURRENT_TIMESTAMP属性
                                    dcj3sjt126com
mysql
                                    
    timestamp有两个属性，分别是CURRENT_TIMESTAMP 和ON UPDATE CURRENT_TIMESTAMP两种，使用情况分别如下： 
  
1. 
  
CURRENT_TIMESTAMP  
  
当要向数据库执行insert操作时，如果有个timestamp字段属性设为 
  
CURRENT_TIMESTAMP，则无论这
    
                                
    • 
                                
  • struts2+spring+hibernate分页显示
                                    171815164
Hibernate
                                    
    分页显示一直是web开发中一大烦琐的难题，传统的网页设计只在一个JSP或者ASP页面中书写所有关于数据库操作的代码，那样做分页可能简单一点，但当把网站分层开发后，分页就比较困难了，下面是我做Spring+Hibernate+Struts2项目时设计的分页代码，与大家分享交流。 
 
　　1、DAO层接口的设计，在MemberDao接口中定义了如下两个方法： 
 
 
 
 
 
public in
    
                                
    • 
                                
  • 构建自己的Wrapper应用
                                    g21121
rap
                                    
            我们已经了解Wrapper的目录结构，下面可是正式利用Wrapper来包装我们自己的应用，这里假设Wrapper的安装目录为:/usr/local/wrapper。 
  
        首先，创建项目应用 
  
&nb
    
                                
    • 
                                
  • [简单]工作记录_多线程相关
                                    53873039oycg
多线程
                                    
         最近遇到多线程的问题,原来使用异步请求多个接口(n*3次请求)     方案一 使用多线程一次返回数据,最开始是使用5个线程,一个线程顺序请求3个接口,超时终止返回     缺点       测试发现必须3个接
    
                                
    • 
                                
  • 调试jdk中的源码，查看jdk局部变量
                                    程序员是怎么炼成的
jdk 源码
                                    
    转自：http://www.douban.com/note/211369821/ 
  
 学习jdk源码时使用-- 
    学习java最好的办法就是看jdk源代码，面对浩瀚的jdk（光源码就有40M多，比一个大型网站的源码都多）从何入手呢，要是能单步调试跟进到jdk源码里并且能查看其中的局部变量最好了。 
 
可惜的是sun提供的jdk并不能查看运行中的局部变量
    
                                
    • 
                                
  • Oracle RAC Failover 详解
                                    aijuans
oracle
                                    
    Oracle RAC 同时具备HA(High Availiablity) 和LB(LoadBalance). 而其高可用性的基础就是Failover(故障转移). 它指集群中任何一个节点的故障都不会影响用户的使用，连接到故障节点的用户会被自动转移到健康节点，从用户感受而言， 是感觉不到这种切换。 
 
 Oracle 10g RAC 的Failover 可以分为3种： 
 1. Client-Si
    
                                
    • 
                                
  • form表单提交数据编码方式及tomcat的接受编码方式
                                    antonyup_2006
JavaScripttomcat浏览器互联网servlet
                                    
    原帖地址：http://www.iteye.com/topic/266705 
 
form有2中方法把数据提交给服务器，get和post,分别说下吧。 
（一）get提交 
1.首先说下客户端（浏览器）的form表单用get方法是如何将数据编码后提交给服务器端的吧。 
   
对于get方法来说，都是把数据串联在请求的url后面作为参数，如：http://localhost:
    
                                
    • 
                                
  • JS初学者必知的基础
                                    百合不是茶
js函数js入门基础
                                    
    JavaScript是网页的交互语言,实现网页的各种效果, 
JavaScript 是世界上最流行的脚本语言。

JavaScript 是属于 web 的语言，它适用于 PC、笔记本电脑、平板电脑和移动电话。

JavaScript 被设计为向 HTML 页面增加交互性。

许多 HTML 开发者都不是程序员，但是 JavaScript 却拥有非常简单的语法。几乎每个人都有能力将小的 
    
                                
    • 
                                
  • iBatis的分页分析与详解
                                    bijian1013
javaibatis
                                    
            分页是操作数据库型系统常遇到的问题。分页实现方法很多，但效率的差异就很大了。iBatis是通过什么方式来实现这个分页的了。查看它的实现部分，发现返回的PaginatedList实际上是个接口，实现这个接口的是PaginatedDataList类的对象，查看PaginatedDataList类发现，每次翻页的时候最
    
                                
    • 
                                
  • 精通Oracle10编程SQL(15)使用对象类型
                                    bijian1013
oracle数据库plsql
                                    
    /*
 *使用对象类型
 */
--建立和使用简单对象类型
--对象类型包括对象类型规范和对象类型体两部分。
--建立和使用不包含任何方法的对象类型
CREATE OR REPLACE TYPE person_typ1 as OBJECT(
  name varchar2(10),gender varchar2(4),birthdate date
);

drop type p
    
                                
    • 
                                
  • 【Linux命令二】文本处理命令awk
                                    bit1129
linux命令
                                    
    awk是Linux用来进行文本处理的命令，在日常工作中，广泛应用于日志分析。awk是一门解释型编程语言，包含变量，数组，循环控制结构，条件控制结构等。它的语法采用类C语言的语法。 
  awk命令用来做什么？ 
1.awk适用于具有一定结构的文本行，对其中的列进行提取信息 
2.awk可以把当前正在处理的文本行提交给Linux的其它命令处理，然后把直接结构返回给awk 
3.awk实际工
    
                                
    • 
                                
  • JAVA(ssh2框架)+Flex实现权限控制方案分析
                                    白糖_
java
                                    
      
目前项目使用的是Struts2+Hibernate+Spring的架构模式，目前已经有一套针对SSH2的权限系统，运行良好。但是项目有了新需求：在目前系统的基础上使用Flex逐步取代JSP，在取代JSP过程中可能存在Flex与JSP并存的情况，所以权限系统需要进行修改。 
【SSH2权限系统的实现机制】 
权限控制分为页面和后台两块：不同类型用户的帐号分配的访问权限是不同的，用户使
    
                                
    • 
                                
  • angular.forEach
                                    boyitech
AngularJSAngularJS APIangular.forEach
                                    
    angular.forEach   描述:   循环对obj对象的每个元素调用iterator, obj对象可以是一个Object或一个Array. Iterator函数调用方法: iterator(value, key, obj), 其中obj是被迭代对象，key是obj的property key或者是数组的index，value就是相应的值啦. (此函数不能够迭代继承的属性.)   
    
                                
    • 
                                
  • java-谷歌面试题-给定一个排序数组，如何构造一个二叉排序树
                                    bylijinnan
二叉排序树
                                    
    
import java.util.LinkedList;

public class CreateBSTfromSortedArray {

	/**
	 * 题目:给定一个排序数组，如何构造一个二叉排序树
	 * 递归
	 */

	public static void main(String[] args) {
		int[] data = { 1, 2, 3, 4, 
    
                                
    • 
                                
  • action执行2次
                                    Chen.H
JavaScriptjspXHTMLcssWebwork
                                    
    xwork 写道   <action name="userTypeAction" 
class="com.ekangcount.website.system.view.action.UserTypeAction"> 
<result name="ssss" type="dispatcher"> 
    
                                
    • 
                                
  • [时空与能量]逆转时空需要消耗大量能源
                                    comsci
能源
                                    
     
 
        无论如何,人类始终都想摆脱时间和空间的限制....但是受到质量与能量关系的限制,我们人类在目前和今后很长一段时间内,都无法获得大量廉价的能源来进行时空跨越..... 
 
        在进行时空穿梭的实验中,消耗超大规模的能源是必然
    
                                
    • 
                                
  • oracle的正则表达式(regular expression)详细介绍
                                    daizj
oracle正则表达式
                                    
        正则表达式是很多编程语言中都有的。可惜oracle8i、oracle9i中一直迟迟不肯加入，好在oracle10g中终于增加了期盼已久的正则表达式功能。你可以在oracle10g中使用正则表达式肆意地匹配你想匹配的任何字符串了。 
正则表达式中常用到的元数据(metacharacter)如下： 
^ 匹配字符串的开头位置。 
$ 匹配支付传的结尾位置。 
* 
    
                                
    • 
                                
  • 报表工具与报表性能的关系
                                    datamachine
报表工具birt报表性能润乾报表
                                    
    在选择报表工具时，性能一直是用户关心的指标，但是，报表工具的性能和整个报表系统的性能有多大关系呢？ 
要回答这个问题，首先要分析一下报表的处理过程包含哪些环节，哪些环节容易出现性能瓶颈，如何优化这些环节。 
  
一、报表处理的一般过程分析 
1、用户选择报表输入参数后，报表引擎会根据报表模板和输入参数来解析报表，并将数据计算和读取请求以SQL的方式发送给数据库。 
  
2、
    
                                
    • 
                                
  • 初一上学期难记忆单词背诵第一课
                                    dcj3sjt126com
wordenglish
                                    
    what 什么  
your 你 
name 名字 
my 我的 
am 是 
one 一 
two 二 
three 三 
four 四 
five 五 
class 班级，课 
  
six 六 
seven 七 
eight 八 
nince 九 
ten 十 
zero 零 
how 怎样 
old 老的 
eleven 十一 
twelve 十二 
thirteen 
    
                                
    • 
                                
  • 我学过和准备学的各种技术
                                    dcj3sjt126com
技术
                                    
    语言VB https://msdn.microsoft.com/zh-cn/library/2x7h1hfk.aspxJava http://docs.oracle.com/javase/8/C# https://msdn.microsoft.com/library/vstudioPHP http://php.net/manual/en/Html 
    
                                
    • 
                                
  • struts2中token防止重复提交表单
                                    蕃薯耀
重复提交表单struts2中token
                                    
    struts2中token防止重复提交表单 
  
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 
蕃薯耀 2015年7月12日 11:52:32 星期日 
ht
    
                                
    • 
                                
  • 线性查找二维数组
                                    hao3100590
二维数组
                                    
    1.算法描述 
  
有序（行有序，列有序，且每行从左至右递增，列从上至下递增）二维数组查找，要求复杂度O(n) 
  
2.使用到的相关知识： 
结构体定义和使用，二维数组传递（http://blog.csdn.net/yzhhmhm/article/details/2045816） 
  
3.使用数组名传递 
这个的不便之处很明显，一旦确定就是不能设置列值 
  
//使
    
                                
    • 
                                
  • spring security 3中推荐使用BCrypt算法加密密码
                                    jackyrong
Spring Security
                                    
    spring security 3中推荐使用BCrypt算法加密密码了，以前使用的是md5， 
Md5PasswordEncoder 和 ShaPasswordEncoder，现在不推荐了，推荐用bcrpt 
Bcrpt中的salt可以是随机的，比如： 
 
 
 

int i = 0;
	while (i < 10) {
		String password = "1234
    
                                
    • 
                                
  • 学习编程并不难,做到以下几点即可!
                                    lampcy
javahtml编程语言
                                    
    不论你是想自己设计游戏，还是开发iPhone或安卓手机上的应用，还是仅仅为了娱乐，学习编程语言都是一条必经之路。编程语言种类繁多，用途各 异，然而一旦掌握其中之一，其他的也就迎刃而解。作为初学者，你可能要先从Java或HTML开始学，一旦掌握了一门编程语言，你就发挥无穷的想象，开发 各种神奇的软件啦。 
1、确定目标 
学习编程语言既充满乐趣，又充满挑战。有些花费多年时间学习一门编程语言的大学生到
    
                                
    • 
                                
  • 架构师之mysql----------------用group+inner join,left join ,right join 查重复数据（替代in)
                                    nannan408
right join
                                    
    1.前言。 
  如题。 
2.代码 
(1)单表查重复数据,根据a分组 
  


SELECT m.a,m.b, INNER   JOIN （select a,b,COUNT(*) AS rank FROM test.`A` A   GROUP BY a HAVING rank>1 )k ON m.a=k.a



 
（2）多表查询 ， 
 使用改为le
    
                                
    • 
                                
  • jQuery选择器小结 VS 节点查找（附css的一些东西）
                                    Everyday都不同
jquerycssname选择器追加元素查找节点
                                    
    最近做前端页面，频繁用到一些jQuery的选择器，所以特意来总结一下： 
  
测试页面： 
<html>
	<head>
		<script src="jquery-1.7.2.min.js"></script>
		<script>
		/*$(function() {
			$(documen
    
                                
    • 
                                
  • 关于EXT
                                    tntxia
ext
                                    
      
ExtJS是一个很不错的Ajax框架，可以用来开发带有华丽外观的富客户端应用，使得我们的b/s应用更加具有活力及生命力。ExtJS是一个用 javascript编写，与后台技术无关的前端ajax框架。因此，可以把ExtJS用在.Net、Java、Php等各种开发语言开发的应用中。 
  
  
  
ExtJs最开始基于YUI技术，由开发人员Jack 
    
                                
    • 
                                
  • 一个MIT计算机博士对数学的思考
                                    xjnine
Math
                                    
     在过去的一年中，我一直在数学的海洋中游荡，research进展不多，对于数学世界的阅历算是有了一些长进。为什么要深入数学的世界？作为计算机的学生，我没有任何企图要成为一个数学家。我学习数学的目的，是要想爬上巨人的肩膀，希望站在更高的高度，能把我自己研究的东西看得更深广一些。说起来，我在刚来这个学校的时候，并没有预料到我将会有一个深入数学的旅程。我的导师最初希望我去做的题目，是对appe
    
                                
    •