Kerwin1321
Kerwin1321

EventBus3.0 源码解析

EventBus，是一个基于Publish/Subscribe的事件总线框架。更通俗的讲，EventBus就是一个基于观察者模式的框架，但是EventBus在观察者模式的基础上有很大一部分改进，基本是实现了Publish/Subscribe的解耦。

这里主要对EventBus3.0的实现原理及源码进行分析，关于EventBus的具体用法，可以去GitHub具体查看，这里不做过多介绍。

通过对EventBus的使用，我们知道要想使用EventBus，必须要有三个步骤：

  1. 定义事件
  2. 定义事件处理方法并注册（取消注册）
  3. 发送事件

所以，分析源码的过程也将从这三个步骤中逐一分析。

关于Eventbus3.0的新特性，通过注解处理器创建索引，优化Subscriber的注册，将在下一个篇幅中具体讲解，这里不做过多介绍。
在下面的源码分析中只要涉及到该特性的也暂时忽略。

创建Event及订阅方法

定义Event

定义Event，就是定义一个普通类，这个类将作为消息体通过Publisher发送到Subscriber，这里对于定义事件就不做过多说明了，这个将会在下面的过程中有具体提到。

public static class MessageEvent { 
    // 如果需要可以定义字段
}

定义订阅方法

要想通过该Event完成具体事件，就必须要声明一个订阅方法，这个方法必须使用注解@Subscribe注释（EventBus只能处理@Subscribe注释的方法），并且该方法有且仅有一个Event的参数，这个在后面的源码分析中会具体提到为什么只能有一个参数。

@Subscribe(threadMode = ThreadMode.MAIN)  
public void onMessageEvent(MessageEvent event) {
/* Do something */
};

创建EventBus

订阅方法声明之后，通过EventBus.getDefault().register(this)注册后订阅方法才可以在运行过程中被处理，下面我们看看EventBus.getDefault().register(this)具体完成了那些功能。

getDefault()

EventBus.getDefault()主要是获取一个EventBus实例。

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

可以看出，这里获取EventBus实例使用一个单例模式并且使用了DCL机制。但是在查看源码时发现EventBusy声明了两个构造方法：一个是公共的无参构造方法、一个是默认类型的带有一个EventBusBuilder参数的构造方法。如下：

    /**
     * Creates a new EventBus instance; each instance is a separate scope in which events are delivered. To use a
     * central bus, consider {@link #getDefault()}.
     */
    public EventBus() {
        this(DEFAULT_BUILDER);
    }

    EventBus(EventBusBuilder builder) {
        logger = builder.getLogger();
        subscriptionsByEventType = new HashMap<>();
        typesBySubscriber = new HashMap<>();
        stickyEvents = new ConcurrentHashMap<>();
        mainThreadSupport = builder.getMainThreadSupport();
        mainThreadPoster = mainThreadSupport != null ? mainThreadSupport.createPoster(this) : null;
        backgroundPoster = new BackgroundPoster(this);
        asyncPoster = new AsyncPoster(this);
        indexCount = builder.subscriberInfoIndexes != null ? builder.subscriberInfoIndexes.size() : 0;
        subscriberMethodFinder = new SubscriberMethodFinder(builder.subscriberInfoIndexes,
                builder.strictMethodVerification, builder.ignoreGeneratedIndex);
        logSubscriberExceptions = builder.logSubscriberExceptions;
        logNoSubscriberMessages = builder.logNoSubscriberMessages;
        sendSubscriberExceptionEvent = builder.sendSubscriberExceptionEvent;
        sendNoSubscriberEvent = builder.sendNoSubscriberEvent;
        throwSubscriberException = builder.throwSubscriberException;
        eventInheritance = builder.eventInheritance;
        executorService = builder.executorService;
    }

如果我们通过无参构造方法创建一个EventBus实例，这将始终调用构造方法EventBus(EventBusBuilder builder)。
DEFAULT_BUILDER就是一个EventBusBuilder的实例，而这种创建方式和通过getDefault方法创建的EventBus实例没有差别。

默认类型的构造方法具有包级访问权限，对于开发者一般是无法通过该构造方法创建实例的。

通过EventBusBuilder的命名我们就可以看出，这里使用了一个建造者模式，这里我们看看EventBusBuilder的源码。

public class EventBusBuilder {

    private final static ExecutorService DEFAULT_EXECUTOR_SERVICE = Executors.newCachedThreadPool();

    boolean logSubscriberExceptions = true;
    boolean logNoSubscriberMessages = true;
    boolean sendSubscriberExceptionEvent = true;
    boolean sendNoSubscriberEvent = true;
    boolean throwSubscriberException;
    boolean eventInheritance = true;
    boolean ignoreGeneratedIndex;
    boolean strictMethodVerification;
    ExecutorService executorService = DEFAULT_EXECUTOR_SERVICE;
    List> skipMethodVerificationForClasses;
    List subscriberInfoIndexes;
    Logger logger;
    MainThreadSupport mainThreadSupport;

    // 省略

    EventBusBuilder() {
    }

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

}

在EventBusBuilder中定义了一系列的属性，这些都是EventBus的一些配置参数，如果想要通过建造者模式创建一个EventBus实例，我们需要通过以下方式：

EventBus eventBus = EventBus.builder()
    .logNoSubscriberMessages(false)
    .sendNoSubscriberEvent(false)
    .build();

一般情况下，如果没有一些特殊的要求，都是不需要通过这种方式创建实例的，在官方文档中都是推荐通过EventBus.getDefault()获取实例。所以对于该种获取EventBus的方法也就不多讲了。

注册Subscriber

在获取EventBus实例后，就可以通过register()注册Subscriber了。

这里我们先说下一个类SubscriberMethod，该类代表了一个订阅方法，在该类中封装了一个订阅方法相关的所有属性。

下面所有的订阅方法都用SubscriberMethod表示以便于理解。

public class SubscriberMethod {
    // 方法
    final Method method;
    // 线程模式
    final ThreadMode threadMode;
    // 事件类型
    final Class eventType;
    // 优先级
    final int priority;
    // 粘性事件标记
    final boolean sticky;
}

register()

    /**
     * 注册subscriber，subscriber必须要调用unregister取消注册

     * subscriber中的事件处理方法必须被 @Subscribe 注解修饰
     */
    public void register(Object subscriber) {
        // 获取subscriber的具体类型
        Class subscriberClass = subscriber.getClass();
        // 获取subscriber中所有的事件方法
        List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
        synchronized (this) {
            for (SubscriberMethod subscriberMethod : subscriberMethods) {
                subscribe(subscriber, subscriberMethod);
            }
        }
    }

在register()中，首先获取subscriber的class类型，这就代表了一个Subscriber订阅者。

然后通过subscriberMethodFinder获取该Subscriber中所有的。subscriberMethodFinder是一个SubscriberMethodFinder实例，该类的作用就是用户获取指定Subscriber中所有SubscriberMethod。

findSubscriberMethods

findSubscriberMethods方法的作用就是获取一个Subscriber中所有的SubscriberMethod。

    /**
     * 获取subscriber中所有的注解方法
     *
     * @param subscriberClass
     * @return
     */
    List findSubscriberMethods(Class subscriberClass) {

        // 缓存该subscriber类中的所有事件方法
        List subscriberMethods = METHOD_CACHE.get(subscriberClass);
        if (subscriberMethods != null) {
            return subscriberMethods;
        }

        if (ignoreGeneratedIndex) {
            // 这是直接通过反射获取Subscriber
            subscriberMethods = findUsingReflection(subscriberClass);
        } else {
            // 这是添加了Eventbus3.0新特性，通过注解处理器在编译期间通过创建索引优化Subscriber的注册，
            subscriberMethods = findUsingInfo(subscriberClass);
        }

        // 在subscriber类中如果没有注解方法，会抛出异常
        if (subscriberMethods.isEmpty()) {
            throw new EventBusException("Subscriber中必须定义Event处理方法。 " + subscriberClass
                    + " and its super classes have no public methods with the @Subscribe annotation");
        } else {
            // 存储到Map中
            METHOD_CACHE.put(subscriberClass, subscriberMethods);
            return subscriberMethods;
        }
    }

在第一次调用register()时，一般会执行findUsingInfo(subscriberClass)。在findSubscriberMethods中，我们可以看到会抛出一个EventBusException异常，这是一个运行时异常，在Subscriber中不存在@Subscribe注解的方法即时会抛出该异常，这表示在Subscriber中必须声明SubscriberMethod。

findUsingInfo

    /**
     * 获取Subscriber中的事件方法
     *
     * @param subscriberClass
     * @return
     */
    private List findUsingInfo(Class subscriberClass) {
        // 1、缓存类，将一些相关的属性封装
        FindState findState = prepareFindState();
        findState.initForSubscriber(subscriberClass);

        while (findState.clazz != null) {

            // 3.0特性，通过编译器生成的索引获取事件方法
            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 {
                // 如果没有配置注解，就会通过反射获取事件方法，最后被存储到(findState.subscriberMethods)
                findUsingReflectionInSingleClass(findState);
            }

            // 寻找父类，如果不存在父类，退出循环
            findState.moveToSuperclass();
        }

        return getMethodsAndRelease(findState);
    }

在上面方法中，有一个FindState类，该类是一个静态类，主要的作用就是存储Subscriber中SubscriberMethod。

通过上面第24行代码，通过调用findUsingReflectionInSingleClass()方法，将所有的SubscriberMethod都存储到findState中，最有通过调用getMethodsAndRelease()获取findState中缓存的SubscriberMethod。

findUsingReflectionInSingleClass

这个方法的作用就是通过反射获取SubscriberMethod，具体的逻辑在下面的代码中都有注释，这里就不多做处理了。

    /**
     * 通过反射获取类中的事件方法
     *
     * @param findState
     */
    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
            methods = findState.clazz.getMethods();
            findState.skipSuperClasses = true;
        }
        for (Method method : methods) {
            int modifiers = method.getModifiers();
            // 事件方法必须是public的，并且不能MODIFIERS_IGNORE这几个关键字修饰
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {

                // 获取方法的参数类型
                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()));
                        }
                    }
                } 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");
            }
        }
    }

getMethodsAndRelease

    /**
     * 返回Event处理方法并清除findstate的状态
     *
     * @param findState
     * @return
     */
    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;
    }

这是获取SubscriberMethod的最后一步，主要就是获取通过反射获取并缓存在FindState中的SubscriberMethod列表。
并且释放FindState，这里使用了一个缓冲池，主要目的不言而喻，就是为了避免FindState对象的频繁创建。

subscribe()

通过上面SubscriberMethodFinder中一系列的方法，就可以获取到Subscriber中所有的SubscriberMethod。
在register()方法中最后一步，通过调用subscribe()方法，完成Subscriber和具体SubscriberMethod关联。

在说subscribe()之前，这里说明几个EventBus中定义的静态成员变量。如下:


    /**
     * 存放指定EventType相关联的所有超类或接口的EventType，这个在消息继承的机制中会使用到。
     * 

     * key：EventType（事件类型）
     * Value：EventType下所有超类或接口的EventType集合
     */
    private static final Map, List>> eventTypesCache = new HashMap<>();

    /**
     * 所有使用到指定EventType的Subscription集合（Subscription：只要包括subscriber和subscriberMethod）。
     * 最后在通过post(event)方法发送事件时，就是通过在该集合中找到指定类型EventType的Subscription，最后通过反射调用subscriber的subscriberMethod方法
     * 

     * key：EventType（事件类型）
     * Value：EventType相关的所有Subscription
     */
    private final Map, CopyOnWriteArrayList> subscriptionsByEventType;

    /**
     * 同一个Subscriber中所有的事件方法
     * 

     * 
     */
    private final Map>> typesBySubscriber;
    /**
     * 存储sticky事件
     */
    private final Map, Object> stickyEvents;

其中集合subscriptionsByEventType和typesBySubscriber变量是处理事件方法的核心变量，这个在post()方法中会说明。

/**
 * @param subscriber
 * @param subscriberMethod
 */
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
    // 获取事件处理方法的参数类型
    Class eventType = subscriberMethod.eventType;

    // 创建subscriber和事件方法的关系
    Subscription newSubscription = new Subscription(subscriber, subscriberMethod);

    /**
     * 1、相同事件类型的事件方法按照priority排序
     *
     * 这段代码的整体逻辑是为了
     * 创建具有相同事件类型的方法的集合，并根据priority排序，在处理事件时按照优先级处理
     *
     * **/
    CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType);
    if (subscriptions == null) {
        subscriptions = new CopyOnWriteArrayList<>();
        subscriptionsByEventType.put(eventType, subscriptions);
    } else {
        if (subscriptions.contains(newSubscription)) {
            throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
                    + eventType);
        }
    }
    int size = subscriptions.size();
    for (int i = 0; i <= size; i++) {
        // 按照事件方法的优先级排序（最高的放在前面）
        if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {
            subscriptions.add(i, newSubscription);
            break;
        }
    }


    /**
     *  2、同一个subscriber中，存储所有事件方法（创建）
     *
     *  存储key-value：>，存储subscriber类中所有的EventType
     */
    List> subscribedEvents = typesBySubscriber.get(subscriber);
    if (subscribedEvents == null) {
        subscribedEvents = new ArrayList<>();
        typesBySubscriber.put(subscriber, subscribedEvents);
    }
    subscribedEvents.add(eventType);


    /**
     * 3、粘性事件的处理
     *
     *  如果事件方法为sticky方法，那么在注册的时候需要处理sticky事件
     */
    if (subscriberMethod.sticky) {
        if (eventInheritance) { // 默认true
            // 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).

            /**
             *  如果没有通过postSticky发送event，stickyEvents为空。
             */
            Set, Object>> entries = stickyEvents.entrySet();
            for (Map.Entry, Object> entry : entries) {
                Class candidateEventType = entry.getKey();
                // 判断事件类型eventType和stickyEvents中的事件类型(包括超类、接口)相同
                if (eventType.isAssignableFrom(candidateEventType)) {

                    // 存储的事件
                    Object stickyEvent = entry.getValue();
                    checkPostStickyEventToSubscription(newSubscription, stickyEvent);
                }
            }
        } else {
            Object stickyEvent = stickyEvents.get(eventType);
            checkPostStickyEventToSubscription(newSubscription, stickyEvent);
        }
    }
}

在subscribe()方法中，主要完成了以下工作：

  1. 在subscriptionsByEventType集合中存储统一个EventType的所有订阅者，并按照Event的priority排序
  2. 在typesBySubscriber集合中存储同一个Subscriber中所有的EventType
  3. 对StickyEvent进行处理

发送Event

post()

发送Event事件同时也是处理Event的过程，在该流程中主要的功能就是：
通过发送的EventType获取所有使用该EventType的Subscriber，最后通过反射实现Subscriber对指定EventType方法的调用。

这个过程主要有以下方法：
post()->postSingleEvent()->postSingleEventForEventType()->postToSubscription()->invokeSubscriber()

最终通过反射完成方法的调用，由于该逻辑的代码篇幅较长，这里贴出相关代码，在代码中有具体的说明。

    /**
     * 发送特定事件到 event bus
     */
    public void post(Object event) {
        // 线程本地变量，这种做法类似Looper机制，一个线程维护一个事件集合，所以eventbus支持多线程事件处理
        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;
            }
        }
    }

        /**
     * 发送单一事件
     *
     * @param event        事件类型参数
     * @param postingState
     * @throws Error
     */
    private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
        // 获取事件参数类型
        Class eventClass = event.getClass();
        boolean subscriptionFound = false;

        /**
         *  默认eventInheritance是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);
        }
        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));
            }
        }
    }

        /**
     * @param event        事件类型参数
     * @param postingState
     * @param eventClass
     * @return
     */
    private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class eventClass) {
        // 获取同一个事件类型的方法的集合
        CopyOnWriteArrayList subscriptions;
        synchronized (this) {
            subscriptions = subscriptionsByEventType.get(eventClass);
        }

        if (subscriptions != null && !subscriptions.isEmpty()) {

            for (Subscription subscription : subscriptions) {
                postingState.event = event;
                postingState.subscription = subscription;
                boolean aborted = false;
                try {
                    // 调用具体事件方法
                    postToSubscription(subscription, event, postingState.isMainThread);
                    aborted = postingState.canceled;
                } finally {
                    postingState.event = null;
                    postingState.subscription = null;
                    postingState.canceled = false;
                }
                if (aborted) {
                    break;
                }
            }
            return true;
        }
        return false;
    }


    /**
     * 根据线程类型调用方法
     *
     * @param subscription
     * @param event
     * @param isMainThread
     */
    private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
        switch (subscription.subscriberMethod.threadMode) {
            case POSTING:
                invokeSubscriber(subscription, event);
                break;
            case MAIN:
                if (isMainThread) {
                    invokeSubscriber(subscription, event);
                } else {
                    mainThreadPoster.enqueue(subscription, event);
                }
                break;
            case 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);
        }
    }


    /**
     * 调用subscriber类中的方法
     *
     * @param subscription
     * @param 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);
        }
    }

postSticky()


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



发送Sticky事件，主要就是在内存中保存该Event，等到具有该Event类型的方法被订阅，也就是调用register()方法时会被处理，这个流程可以在subscribe()方法中看到具体实现。


从subscribe()方法中可以看出，只有SubscriberMethod的sticky为true时，这个方法才会被当做粘性事件被处理。


取消注册Subscriber


unregister


关于取消注册Subscriber，其实就是将上面subscriptionsByEventType和typesBySubscriber集合中存储的有关指定Subscriber的事件移除即可。这样在处理事件时该Subscriber就不会订阅方法就不会被调用了。


/**
 * Unregisters the given subscriber from all event classes.
 */
public synchronized void unregister(Object subscriber) {
    List> subscribedTypes = typesBySubscriber.get(subscriber);
    if (subscribedTypes != null) {
        for (Class eventType : subscribedTypes) {
            unsubscribeByEventType(subscriber, eventType);
        }
        // 删除该subscriber
        typesBySubscriber.remove(subscriber);
    } else {
        logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
    }
}


/**
 * 移除事件类型集合中的相关事件方法
 * 

 * Only updates subscriptionsByEventType, not typesBySubscriber! Caller must update typesBySubscriber.
 */
private void unsubscribeByEventType(Object subscriber, Class eventType) {
    // 获取
    List subscriptions = subscriptionsByEventType.get(eventType);
    if (subscriptions != null) {
        int size = subscriptions.size();
        for (int i = 0; i < size; i++) {
            // 移除集合中指定的subscriber
            Subscription subscription = subscriptions.get(i);
            if (subscription.subscriber == subscriber) {
                subscription.active = false;
                subscriptions.remove(i);
                i--;
                size--;
            }
        }
    }
}


这样EventBus的基本工作原理及源码源码分析就到此为止了。

























你可能感兴趣的:(Android,开源项目)






    

  • android系统selinux中添加新属性property
辉色投像

    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
    

    • 

  • 2.2.6 通知类控件 Toast、Menu
常思行

    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
    

    • 

  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）...
weixin_39762838
mac备份android手机通讯录导入iphone

    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
    

    • 

  • android 更改窗口的层次,浮窗开发之窗口层级
Ms.Bu
android更改窗口的层次

    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
    

    • 

  • Android应用性能优化
轻口味
Android

    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
    

    • 

  • 浅谈MapReduce
Android路上的人
Hadoop分布式计算mapreduce分布式框架hadoop

    从今天开始，本人将会开始对另一项技术的学习，就是当下炙手可热的Hadoop分布式就算技术。目前国内外的诸多公司因为业务发展的需要，都纷纷用了此平台。国内的比如BAT啦，国外的在这方面走的更加的前面，就不一一列举了。但是Hadoop作为Apache的一个开源项目，在下面有非常多的子项目，比如HDFS，HBase,Hive，Pig,等等，要先彻底学习整个Hadoop，仅仅凭借一个的力量，是远远不够的。
    

    • 

  • Android实现监听事件的方法
Amy木婉清

    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
    

    • 

  • 高级UI<第二十四篇>：Android中用到的矩阵常识
NoBugException

    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
    

    • 

  • RK3229_Android9.0_Box 4G模块EC200A调试
suifen_
网络

    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
    

    • 

  • kt文件和java文件_Java与Kotlin之间怎样进行互操作
铭空间
kt文件和java文件

    Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
    

    • 

  • Android shell 常用 debug 命令
晨春计
Audiodebugandroidlinux

    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
    

    • 

  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面
2401_84544531
程序员android面试学习

    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
    

    • 

  • Github 2024-09-12 Go开源项目日报Top10
老孙正经胡说
githubgolang开源Github趋势分析开源项目PythonGolang

    根据GithubTrendings的统计，今日(2024-09-12统计)共有10个项目上榜。根据开发语言中项目的数量，汇总情况如下：开发语言项目数量Go项目10C项目1Terraform：基础设施即代码的开源工具创建周期：3626天开发语言：Go协议类型：OtherStar数量：40393个Fork数量：9397次关注人数：40393人贡献人数：358人OpenIssues数量：1943个Git
    

    • 

  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT)
计算机源码社
Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设

    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
    

    • 

  • 快速进入新领域的4种方式与3个视角
自在普拉斯

    4种方式：多条腿走路跟人学：针对性强，时效性好，能获取第一手信息。推荐：在行、公众号、社群等。做事学：目标明确，可模仿。推荐：做助教、开源项目、工作实践。上网学：时效性较高，信息庞杂需筛选，可快速建了概念。推荐：知乎、云课堂、得到。看书学：知识系统化，时效性差，干扰小。推荐：亚马逊评论、豆瓣读书、图书馆。新入门领域如果比较庞大，可考虑4种方式结合着来，一般2-3种方式即足够。建立概念和轮廓：上网学
    

    • 

  • Humanize 项目教程
尤嫒冰

    Humanize项目教程humanizeAJSlibraryforaddinga“humantouch”todata.项目地址:https://gitcode.com/gh_mirrors/humani/humanize项目介绍Humanize是一个开源项目，旨在将机器生成的文本转换为更加自然、人性化的文本。该项目通过先进的算法和自然语言处理技术，使得AI生成的内容更加贴近人类的表达方式，从而提高
    

    • 

  • android ndk 开发jni调用对象方法，数组参数
wulongkou
开发问题安卓的事ndkandroidstudiojni

    一、JNI和NDK关系JNI是Java语言提供的Java和C/C++相互沟通的机制，Java可以通过JNI调用本地的C/C++代码，本地的C/C++的代码也可以调用java代码。JNI是本地编程接口，Java和C/C++互相通过的接口。Java通过C/C++使用本地的代码的一个关键性原因在于C/C++代码的高效性。NDK是一系列工具的集合。它提供了一系列的工具，帮助开发者快速开发C（或C++）的动
    

    • 

  • Android jni中数组参数的传递方式
lokeyme
Andriodandroid开发JNINDKjavac语言

    1、背景今天调试了一下Androidjni关于Java中调用C代码的程序，发现我的数组参数传递方式不对，导致值传递不正确，我的方法是：C代码，入口函数#include#includejintJava_sony_MedicalRecordDemo_MainActivity_decryptionSuccess(JNIEnv*env,jobjectthiz,jintAttr[]){returnAttr[
    

    • 

  • 1-1.Jetpack 之 Navigation 简单编码模板
我命由我12345
Android-Jetpack简化编程javajava-eeandroid-studioandroidstudio安卓androidjetpack

    一、Navigation1、Navigation概述Navigation是Jetpack中的一个重要成员，它主要是结合导航图（NavigationGraph）来控制和简化Fragment之间的导航，即往哪里走，该怎么走2、Navigate引入在模块级build.gradle中引入相关依赖implementation'androidx.navigation:navigation-fragment:2
    

    • 

  • Github官方桌面客户端
zwb_jianshu

    GitHub是一个面向开源及私有软件项目的托管平台，因为只支持git作为唯一的版本库格式进行托管，故名gitHub。如果你是一名程序员，那么一定会听过或用过现在最流行的版本控制工具GIT！而GitHub.com则是目前全球最热门的公共代码仓库网站，多到数不清的知名开源项目源代码都是托管在它上面。GitHubDesktop免费的Github官方桌面客户端首先，我先对GitHub来一个简单的介绍，Gi
    

    • 

  • 推荐开源项目：Zotero引用计数管理器——学术研究的智能助手
蔡鸿烈Hope

    推荐开源项目：Zotero引用计数管理器——学术研究的智能助手zotero-citationcountsZoteropluginforauto-fetchingcitationcountsfromvarioussources项目地址:https://gitcode.com/gh_mirrors/zo/zotero-citationcounts项目介绍在学术界，每篇论文背后都承载着学者们辛勤的研究成
    

    • 

  • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用
erhtre
程序员androidjetpack架构sqlite

    为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
    

    • 

  • Android干净架构MVI模板使用指南
井美婵Toby

    Android干净架构MVI模板使用指南android-clean-architecture-mvi-boilerplateAforkofourcleanarchitectureboilerplateusingtheModel-View-Intentpattern项目地址:https://gitcode.com/gh_mirrors/an/android-clean-architecture-mv
    

    • 

  • ⭐Unity 安卓环境中正确地读取和处理 XML 文件
惊鸿醉
Unityunityandroidxml

    写了一个选择题Demo，电脑包和编辑器内无问题，但是打包安卓手机之后题目无法正常使用，想到的是安卓环境中正确地读取文件的问题改进方案：1.由于XmlDocument.Load方法在Android上的路径问题（由于文件位于APK内部，无法像在文件系统中那样直接访问），需要先使用UnityWebRequest来异步加载文件内容，然后再解析XML。2.异步处理：修改你的代码，以支持异步文件加载和处理，这
    

    • 

  • 前端使用react-intl-universal进行国际化
Stephy_Yy
#调研reactjsjavascriptcss

    一、国际化/i18n目前国际化，就是开发者写对象，一个key关联若干语种的翻译。相比于浏览器自带的翻译功能，语义更加准确。“国际化”的简称：i18n（其来源是英文单词internationalization的首末字符i和n，18为中间的字符数）二、react项目国际化react-intl是业界最受欢迎的软件包之一：React-intl是雅虎的语言国际化开源项目FormatJS的一部分，通过其提供的
    

    • 

  • 《Android进阶之光》读书笔记
soleil雪寂
读书笔记#Android进阶之光

    文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
    

    • 

  • 《Android进阶之光》— Android 书籍
王睿丶
Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发

    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
    

    • 

  • 《android进阶之光》——多线程编程（上）
TAING要一直努力
读书笔记

    今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
    

    • 

  • android进阶之光！Android面试必备的集合源码详解，系列篇
程序员Sunbu
程序员Android

    前言面试：如果不准备充分的面试，完全是浪费时间，更是对自己的不负责。文末会给大家分享下我整理的Android面试专题及答案其中大部分都是大企业面试常问的面试题，可以对照这查漏补缺，当然了，这里所列的肯定不可能覆盖全部方式，不过对大家找工作肯定是有帮助！本月飞机到达上海，到今天第6天了，四家大公司华为，小米，映客，抖音，还有二家中小型公司。有几家已经面了几轮，下周还要面，挂了几家，不过目前已经选择了
    

    • 

  • Android-悬浮窗功能的实现（附Java、KT实现源码）(1)
egrhef
程序员androidjava开发语言

    //获取服务的操作对象valbinder=serviceasFloatWinfowServices.MyBinderbinder.service}overridefunonServiceDisconnected(name:ComponentName){}}overridefunonActivityResult(requestCode:Int,resultCode:Int,data:Intent){
    

    • 

  • VMware Workstation 11 或者 VMware Player 7安装MAC OS X 10.10 Yosemite
iwindyforest
vmwaremac os10.10workstationplayer

    最近尝试了下VMware下安装MacOS 系统，
安装过程中发现网上可供参考的文章都是VMware Workstation 10以下， MacOS X 10.9以下的文章，
只能提供大概的思路， 但是实际安装起来由于版本问题， 走了不少弯路， 所以我尝试写以下总结， 希望能给有兴趣安装OSX的人提供一点帮助。
 
 
写在前面的话：
其实安装好后发现， 由于我的th
    

    • 

  • 关于《基于模型驱动的B/S在线开发平台》源代码开源的疑虑？
deathwknight
JavaScriptjava框架

    本人从学习Java开发到现在已有10年整，从一个要自学 java买成javascript的小菜鸟，成长为只会java和javascript语言的老菜鸟（个人邮箱：[email protected]）
一路走来，跌跌撞撞。用自己的三年多业余时间，瞎搞一个小东西（基于模型驱动的B/S在线开发平台，非MVC框架、非代码生成）。希望与大家一起分享，同时有许些疑虑，希望有人可以交流下
平台
    

    • 

  • 如何把maven项目转成web项目
Kai_Ge
mavenMyEclipse

    创建Web工程，使用eclipse ee创建maven web工程 1.右键项目,选择Project Facets,点击Convert to faceted from 2.更改Dynamic Web Module的Version为2.5.(3.0为Java7的,Tomcat6不支持). 如果提示错误,可能需要在Java Compiler设置Compiler compl
    

    • 

  • 主管？？？
Array_06
工作

    转载：http://www.blogjava.net/fastzch/archive/2010/11/25/339054.html
很久以前跟同事参加的培训，同事整理得很详细，必须得转！
前段时间，公司有组织中高阶主管及其培养干部进行了为期三天的管理训练培训。三天的课程下来，虽然内容较多，因对老师三天来的课程内容深有感触，故借着整理学习心得的机会，将三天来的培训课程做了一个
    

    • 

  • python内置函数大全
2002wmj
python

    最近一直在看python的document，打算在基础方面重点看一下python的keyword、Build-in Function、Build-in Constants、Build-in Types、Build-in Exception这四个方面，其实在看的时候发现整个《The Python Standard Library》章节都是很不错的，其中描述了很多不错的主题。先把Build-in Fu
    

    • 

  • JSP页面通过JQUERY合并行
357029540
JavaScriptjquery

    在写程序的过程中我们难免会遇到在页面上合并单元行的情况，如图所示
如果对于会的同学可能很简单，但是对没有思路的同学来说还是比较麻烦的，提供一下用JQUERY实现的参考代码
function mergeCell(){
        var trs = $("#table tr");
&nb
    

    • 

  • Java基础
冰天百华
java基础

    学习函数式编程
package base;
import java.text.DecimalFormat;
public class Main {
public static void main(String[] args) {
// Integer a = 4;
// Double aa = (double)a / 100000;
// Decimal
    

    • 

  • unix时间戳相互转换
adminjun
转换unix时间戳

    如何在不同编程语言中获取现在的Unix时间戳(Unix timestamp)？ Java time JavaScript Math.round(new Date().getTime()/1000)
getTime()返回数值的单位是毫秒 Microsoft .NET / C# epoch = (DateTime.Now.ToUniversalTime().Ticks - 62135
    

    • 

  • 作为一个合格程序员该做的事
aijuans
程序员

    作为一个合格程序员每天该做的事 1、总结自己一天任务的完成情况 最好的方式是写工作日志，把自己今天完成了什么事情，遇见了什么问题都记录下来，日后翻看好处多多
2、考虑自己明天应该做的主要工作 把明天要做的事情列出来，并按照优先级排列，第二天应该把自己效率最高的时间分配给最重要的工作
3、考虑自己一天工作中失误的地方，并想出避免下一次再犯的方法 出错不要紧，最重
    

    • 

  • 由html5视频播放引发的总结
ayaoxinchao
html5视频video

    前言
 
项目中存在视频播放的功能，前期设计是以flash播放器播放视频的。但是现在由于需要兼容苹果的设备，必须采用html5的方式来播放视频。我就出于兴趣对html5播放视频做了简单的了解，不了解不知道，水真是很深。本文所记录的知识一些浅尝辄止的知识，说起来很惭愧。
 
视频结构
 
本该直接介绍html5的<video>的，但鉴于本人对视频
    

    • 

  • 解决httpclient访问自签名https报javax.net.ssl.SSLHandshakeException: sun.security.validat
bewithme
httpclient

         如果你构建了一个https协议的站点，而此站点的安全证书并不是合法的第三方证书颁发机构所签发，那么你用httpclient去访问此站点会报如下错误
 
javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: PKIX path bu
    

    • 

  • Jedis连接池的入门级使用
bijian1013
redisredis数据库jedis

    Jedis连接池操作步骤如下：
        a.获取Jedis实例需要从JedisPool中获取；
        b.用完Jedis实例需要返还给JedisPool；
        c.如果Jedis在使用过程中出错，则也需要还给JedisPool；
packag
    

    • 

  • 变与不变
bingyingao
不变变亲情永恒

    变与不变
   周末骑车转到了五年前租住的小区，曾经最爱吃的西北面馆、江西水饺、手工拉面早已不在，
   各种店铺都换了好几茬，这些是变的。
   三年前还很流行的一款手机在今天看起来已经落后的不像样子。
   三年前还运行的好好的一家公司，今天也已经不复存在。
   一座座高楼拔地而起，
    

    • 

  • 【Scala十】Scala核心四：集合框架之List
bit1129
scala

    Spark的RDD作为一个分布式不可变的数据集合，它提供的转换操作，很多是借鉴于Scala的集合框架提供的一些函数，因此，有必要对Scala的集合进行详细的了解
 
1. 泛型集合都是协变的，对于List而言，如果B是A的子类，那么List[B]也是List[A]的子类，即可以把List[B]的实例赋值给List[A]变量
 
2. 给变量赋值(注意val关键字，a，b
    

    • 

  • Nested Functions in C
bookjovi
cclosure

     
Nested Functions 又称closure，属于functional language中的概念，一直以为C中是不支持closure的，现在看来我错了，不过C标准中是不支持的，而GCC支持。
 
既然GCC支持了closure，那么 lexical scoping自然也支持了，同时在C中label也是可以在nested functions中自由跳转的
    

    • 

  • Java-Collections Framework学习与总结-WeakHashMap
BrokenDreams
Collections

            总结这个类之前，首先看一下Java引用的相关知识。Java的引用分为四种：强引用、软引用、弱引用和虚引用。
       
强引用：就是常见的代码中的引用，如Object o = new Object();存在强引用的对象不会被垃圾收集
    

    • 

  • 读《研磨设计模式》-代码笔记-解释器模式-Interpret
bylijinnan
java设计模式

    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
package design.pattern;
/*
* 解释器（Interpreter）模式的意图是可以按照自己定义的组合规则集合来组合可执行对象
*
* 代码示例实现XML里面1.读取单个元素的值 2.读取单个属性的值
* 多
    

    • 

  • After Effects操作&快捷键
cherishLC
After Effects

    1、快捷键官方文档
中文版：https://helpx.adobe.com/cn/after-effects/using/keyboard-shortcuts-reference.html
英文版：https://helpx.adobe.com/after-effects/using/keyboard-shortcuts-reference.html
2、常用快捷键
    

    • 

  • Maven 常用命令
crabdave
maven

    Maven 常用命令
 
mvn archetype:generate
mvn install
mvn clean
mvn clean complie
mvn clean test
mvn clean install
mvn clean package
mvn test
mvn package
mvn site
 
mvn dependency:res
    

    • 

  • shell bad substitution
daizj
shell脚本

    #!/bin/sh
/data/script/common/run_cmd.exp 192.168.13.168 "impala-shell -islave4 -q 'insert OVERWRITE table imeis.${tableName} select ${selectFields}, ds, fnv_hash(concat(cast(ds as string), im
    

    • 

  • Java SE 第二讲（原生数据类型 Primitive Data Type）
dcj3sjt126com
java

    Java SE  第二讲：
1.   Windows: notepad, editplus, ultraedit, gvim
Linux: vi, vim, gedit
2.   Java 中的数据类型分为两大类：
1）原生数据类型  （Primitive Data Type）
2）引用类型（对象类型）  （R
    

    • 

  • CGridView中实现批量删除
dcj3sjt126com
PHPyii

    1，CGridView中的columns添加
array(
'selectableRows' => 2,
'footer' => '<button type="button" onclick="GetCheckbox();" style=&
    

    • 

  • Java中泛型的各种使用
dyy_gusi
java泛型

    Java中的泛型的使用：1.普通的泛型使用
在使用类的时候后面的<>中的类型就是我们确定的类型。
public class MyClass1<T> {//此处定义的泛型是T
private T var;
public T getVar() {
return var;
}
public void setVa
    

    • 

  • Web开发技术十年发展历程
gcq511120594
Web浏览器数据挖掘

    回顾web开发技术这十年发展历程：
Ajax
03年的时候我上六年级，那时候网吧刚在小县城的角落萌生。传奇，大话西游第一代网游一时风靡。我抱着试一试的心态给了网吧老板两块钱想申请个号玩玩，然后接下来的一个小时我一直在，注，册，账，号。
彼时网吧用的512k的带宽，注册的时候，填了一堆信息，提交，页面跳转，嘣，”您填写的信息有误，请重填”。然后跳转回注册页面，以此循环。我现在时常想，如果当时a
    

    • 

  • openSession()与getCurrentSession()区别：
hetongfei
javaDAOHibernate

    来自 http://blog.csdn.net/dy511/article/details/6166134
1.getCurrentSession创建的session会和绑定到当前线程,而openSession不会。
2. getCurrentSession创建的线程会在事务回滚或事物提交后自动关闭,而openSession必须手动关闭。
这里getCurrentSession本地事务(本地
    

    • 

  • 第一章 安装Nginx+Lua开发环境
jinnianshilongnian
nginxluaopenresty

    首先我们选择使用OpenResty，其是由Nginx核心加很多第三方模块组成，其最大的亮点是默认集成了Lua开发环境，使得Nginx可以作为一个Web Server使用。借助于Nginx的事件驱动模型和非阻塞IO，可以实现高性能的Web应用程序。而且OpenResty提供了大量组件如Mysql、Redis、Memcached等等，使在Nginx上开发Web应用更方便更简单。目前在京东如实时价格、秒
    

    • 

  • HSQLDB In-Process方式访问内存数据库
liyonghui160com

     
 
HSQLDB一大特色就是能够在内存中建立数据库，当然它也能将这些内存数据库保存到文件中以便实现真正的持久化。
 
先睹为快！
 
下面是一个In-Process方式访问内存数据库的代码示例：
 
 
下面代码需要引入hsqldb.jar包 （hsqldb-2.2.8）
 
import java.s
    

    • 

  • Java线程的5个使用技巧
pda158
java数据结构

    Java线程有哪些不太为人所知的技巧与用法？ 　　萝卜白菜各有所爱。像我就喜欢Java。学无止境，这也是我喜欢它的一个原因。日常
工作中你所用到的工具，通常都有些你从来没有了解过的东西，比方说某个方法或者是一些有趣的用法。比如说线程。没错，就是线程。或者确切说是Thread这个类。当我们在构建高可扩展性系统的时候，通常会面临各种各样的并发编程的问题，不过我们现在所要讲的可能会略有不同。 
    

    • 

  • 开发资源大整合：编程语言篇——JavaScript（1）
shoothao
JavaScript

    概述：本系列的资源整合来自于github中各个领域的大牛，来收藏你感兴趣的东西吧。  
  程序包管理器
  管理javascript库并提供对这些库的快速使用与打包的服务。
Bower - 用于web的程序包管理。
component - 用于客户端的程序包管理，构建更好的web应用程序。
spm - 全新的静态的文件包管
    

    • 

  • 避免使用终结函数
vahoa.ma
javajvmC++

    终结函数（finalizer）通常是不可预测的，常常也是很危险的，一般情况下不是必要的。使用终结函数会导致不稳定的行为、更差的性能，以及带来移植性问题。不要把终结函数当做C++中的析构函数（destructors）的对应物。
 
    我自己总结了一下这一条的综合性结论是这样的：
1）在涉及使用资源，使用完毕后要释放资源的情形下，首先要用一个显示的方
    

    •