单向时间轴
单向时间轴

事件传递EventBus

目录

概念

EventBus：是一个Android事件发布/订阅框架,通过解耦发布者与订阅者的方式,大大的简化了Activity与Activity，Activity与Fragment，Fragment与Fragment等之间的数据传递，从而使得代码更简洁明了。

使用

1，配置

  • 打开App的build.gradle，在dependencies中添加最新的EventBus依赖：
    3.0以下版本的AndroidStudio : compile 'org.greenrobot:eventbus:3.1.1'
    3.0及以上版本的AndroidStudio : implementation 'org.greenrobot:eventbus:3.1.1'>
  • 索引加速模式(在AndroidStudio3.1.3上配置成功，在2.2.2版本上使用网上的两种方案均无MyEventBusIndex文件生成) 。成功配置的步骤如下（针对AndroidStudio3.1.3）
1，在app的build.gradle文件的dependencies中添加：
annotationProcessor 'org.greenrobot:eventbus-annotation-processor:3.0.1'
2，在app的build.gradle文件的defaultConfig中添加：(com.learn.study：当前的包名，可以自己配置)
javaCompileOptions {
    annotationProcessorOptions {
        arguments = [ eventBusIndex : 'com.learn.study.MyEventBusIndex' ]
    }
}
3，rebuiid项目后在app的build/generated/source/apt/debug中找到：MyEventBusIndex文件

2，注册与注销

//注册(一般在Activity或Fragment的onCreate中进行)
if (!EventBus.getDefault().isRegistered(this)) {
    EventBus.getDefault().register(this);
}
//注销(一般是在Activity或Fragment的onDestory中进行)
if (EventBus.getDefault().isRegistered(this)) {
    EventBus.getDefault().unregister(this);
}

//补充(如果使用了索引加速)：在Application中配置：
EventBus.builder().addIndex(new MyEventBusIndex()).installDefaultEventBus();

3，接收事件

//3.0以后方法名可以任意，但必须加上@Subscribe的标识，同时设置参数为：
threadMode：当前接收事件的执行线程
sticky：是否接收粘性事件；
priority：设置优先级
方法的参数与发送的数据类型一致，必须为对象类型，如：必须使用Integer而不能使用int
@Subscribe(threadMode = ThreadMode.MAIN, sticky = true, priority = 0)
public void getMainData(Integer number) {
    Log.d(TAG, "ThreadMode : getMainData: " + number + " ;; " + Thread.currentThread().getName());
}

四种线程模型（ThreadMode：定义线程类型的枚举类）说明：

  • POSTING ： 在当前发送的线程中执行（不用切换线程，最轻量级）
  • MAIN：在主线程中执行
  • MAIN_ORDERED：在主线程中执行，但事件始终排队等候确保调用为非阻塞（不常用）
  • BACKGROUND：后台线程，当在UI线程时中发布时才会新建一个后台线程执行
  • ASYNC：交给线程池来管理，直接通过asyncPoster调度。

4，发送事件

//发送普通事件
EventBus.getDefault().post(10);
//发送粘性事件
EventBus.getDefault().postSticky(20);

5，注意事项

1，有注册必须有注销，保证一一对应，同时调用的生命周期方法也对应
2，注册页面必须有接收方法，主要是需要识别到有Subscribe的注解，发送界面不需要注册。
3，同一个事件可以定义多个接收，参数必须是对象类型。如：发送的是int但接收参数必须为Interger
4，使用普通的post发送事件时，必须先注册才能收到。而postSticky可以在发送后注册也能收到

//1，验证普通事件与粘性事件的发送与注册顺序
private void testEventBus() {
    EventBus.getDefault().postSticky(20);
    if (!EventBus.getDefault().isRegistered(this)) {
        EventBus.getDefault().register(this);
    }
}
@Subscribe(threadMode = ThreadMode.MAIN, sticky = true, priority = 0)
public void getMainData(Integer number) {
    Log.d(TAG, "ThreadMode : getMainData: " + number + " ;; " + Thread.currentThread().getName());
}
//打印结果：(即事件能够收到并处理)
10-24 21:13:52.574 5913-5913/com.learn.study D/MainActivity: ThreadMode : getMainData: 20 ;; main

private void testEventBus() {
    EventBus.getDefault().post(10);
    if (!EventBus.getDefault().isRegistered(this)) {
        EventBus.getDefault().register(this);
    }
}
@Subscribe(threadMode = ThreadMode.MAIN, sticky = true, priority = 0)
public void getMainData(Integer number) {
    Log.d(TAG, "ThreadMode : getMainData: " + number + " ;; " + Thread.currentThread().getName());
}
//无打印,即事件未接收

//2，验证线程模型
@Subscribe(threadMode = ThreadMode.MAIN)
public void getMainData(Integer number) {
    Log.d(TAG, "ThreadMode : getMainData: " + number + " ;; " + Thread.currentThread().getName());
}
@Subscribe(threadMode = ThreadMode.BACKGROUND)
public void getThreadData(Integer number) {
    Log.d(TAG, "ThreadMode : getThreadData: " + number + " ;; " + Thread.currentThread().getName());
}
@Subscribe(threadMode = ThreadMode.POSTING)
public void getPostData(Integer number) {
    Log.d(TAG, "ThreadMode : getPostData: " + number + " ;; " + Thread.currentThread().getName());
}
@Subscribe(threadMode = ThreadMode.ASYNC)
public void getAsyncData(Integer number) {
    Log.d(TAG, "ThreadMode : getAsyncData: " + number + " ;; " + Thread.currentThread().getName());
}
EventBus.getDefault().post(10);
Log.d("MainActivity", "ThreadMode : sendData :" + Thread.currentThread().getName());
//在主线程中发送结果打印：
10-24 21:28:19.490 6837-6837/com.learn.study D/MainActivity: ThreadMode : getMainData: 10 ;; main
    ThreadMode : getPostData: 10 ;; main
10-24 21:28:19.491 6837-7309/com.learn.study D/MainActivity: ThreadMode : getThreadData: 10 ;; pool-1-thread-1
10-24 21:28:19.491 6837-6837/com.learn.study D/MainActivity: ThreadMode : sendData :main
10-24 21:28:19.491 6837-7310/com.learn.study D/MainActivity: ThreadMode : getAsyncData: 10 ;; pool-1-thread-2

//在子线程中发送结果打印：
10-24 21:33:22.969 7800-7859/com.learn.study D/MainActivity: ThreadMode : getThreadData: 10 ;; Thread-4
    ThreadMode : getPostData: 10 ;; Thread-4
10-24 21:33:22.970 7800-7860/com.learn.study D/MainActivity: ThreadMode : getAsyncData: 10 ;; pool-1-thread-1
10-24 21:33:22.970 7800-7859/com.learn.study D/MainActivity: ThreadMode : sendData :Thread-4
10-24 21:33:23.028 7800-7800/com.learn.study D/MainActivity: ThreadMode : getMainData: 10 ;; main

//3，验证接收事件的优先级(相同的线程中才存在优先级问题，同时拦截才有效果)
10-24 22:04:43.762 10532-10596/com.learn.study D/MainActivity: ThreadMode : getThreadData: 10 ;; Thread-4;; 优先级:6
    ThreadMode : getPostData: 10 ;; Thread-4;; 优先级:3
10-24 22:04:43.763 10532-10596/com.learn.study D/MainActivity: ThreadMode : sendData :Thread-4
10-24 22:04:43.763 10532-10597/com.learn.study D/MainActivity: ThreadMode : getAsyncData: 10 ;; pool-1-thread-1;; 优先级:0
10-24 22:04:43.810 10532-10532/com.learn.study D/MainActivity: ThreadMode : getMainData: 10 ;; main;; 优先级:10
    ThreadMode : getMain1Data: 10 ;; main;; 优先级:7

原理（针对3.1.1版本的源码）

1，注册的流程

//1,使用双重校验的单例创建对象：EventBus.getDefault()
public static EventBus getDefault() {
    if (defaultInstance == null) {
        synchronized (EventBus.class) {
            if (defaultInstance == null) {
                defaultInstance = new EventBus();
            }
        }
    }
    return defaultInstance;
}
//2，register()调用注册的方法
public void register(Object subscriber) {
    Class subscriberClass = subscriber.getClass();
    //查找当前注册类所有的接收方法
    List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
    synchronized (this) {
        for (SubscriberMethod subscriberMethod : subscriberMethods) {
            subscribe(subscriber, subscriberMethod);
        }
    }
}
//具体实现查找接收方法:
List findSubscriberMethods(Class subscriberClass) {
    //1,从Map集合METHOD_CACHE(键：注册的类class对象，值：当前注册类里面的接收方法)中查找方法，如果查询到方法则直接返回方法集合List，否则重新获取
    List subscriberMethods = METHOD_CACHE.get(subscriberClass);
    if (subscriberMethods != null) {
        return subscriberMethods;
    }
    if (ignoreGeneratedIndex) {
        //2，忽视索引加速的方式，直接使用反射的方式获取的注册类下的所有接受方法:最后还是调用findUsingReflectionInSingleClass()方法
        subscriberMethods = findUsingReflection(subscriberClass);
    } else {
        //3，获取到注册类里面的接收方法
        subscriberMethods = findUsingInfo(subscriberClass);
    }
    if (subscriberMethods.isEmpty()) {
        throw new EventBusException("Subscriber " + subscriberClass
                    + " and its super classes have no public methods with the @Subscribe annotation");
    } else {
        METHOD_CACHE.put(subscriberClass, subscriberMethods);
        return subscriberMethods;
    }
}

private List findUsingInfo(Class subscriberClass) {
    //1，这里存在一个查找状态池：FIND_STATE_POOL，大小为4，减少对象的创建。
    FindState findState = prepareFindState();
    findState.initForSubscriber(subscriberClass);
    while (findState.clazz != null) {
        //2，查找注册类的接受方法，如果添加了索引加速，而返回接受方法，否则返回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);
}
//使用索引加速获取方法
private SubscriberInfo getSubscriberInfo(FindState findState) {
        if (findState.subscriberInfo != null && findState.subscriberInfo.getSuperSubscriberInfo() != null) {
            SubscriberInfo superclassInfo = findState.subscriberInfo.getSuperSubscriberInfo();
            if (findState.clazz == superclassInfo.getSubscriberClass()) {
                return superclassInfo;
            }
        }
        if (subscriberInfoIndexes != null) {
            for (SubscriberInfoIndex index : subscriberInfoIndexes) {
                SubscriberInfo info = index.getSubscriberInfo(findState.clazz);
                if (info != null) {
                    //使用了索引加速则info返回索引的接收方法,否则返回null
                    return info;
                }
            }
        }
        return null;
    }

//使用反射获取接收方法
private void findUsingReflectionInSingleClass(FindState findState) {
        Method[] methods;
        try {
            //1,使用反射先获取到注册类里面的所有方法
            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;
        }
        //2,遍历所有方法,找到接收事件的方法
        for (Method method : methods) {
            int modifiers = method.getModifiers();
            if ((modifiers & Modifier.PUBLIC) != 0 && (modifiers & MODIFIERS_IGNORE) == 0) {
                Class[] parameterTypes = method.getParameterTypes();
                if (parameterTypes.length == 1) {
                    //3,通过获取方法上的注解Subscribe来区分接收事件的方法.
                    Subscribe subscribeAnnotation = method.getAnnotation(Subscribe.class);
                    if (subscribeAnnotation != null) {
                        Class eventType = parameterTypes[0];
                        if (findState.checkAdd(method, eventType)) {
                            ThreadMode threadMode = subscribeAnnotation.threadMode();
                            //4,将接收事件的方法信息添加到查询状态的对象中
                            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");
            }
        }
    }

//查找完成接收事件的方法后,调用subscribe(),将注册类,接收方法,接收事件的类型等添加到对应的Map集合中进行保存,避免相应信息每次获取
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
        Class eventType = subscriberMethod.eventType;
        Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
        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();
        //根据接收事件的优先级,将订阅事件存放到subscriptionsByEventType集合中
        for (int i = 0; i <= size; i++) {
            if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {
                subscriptions.add(i, newSubscription);
                break;
            }
        }

        List> subscribedEvents = typesBySubscriber.get(subscriber);
        if (subscribedEvents == null) {
            subscribedEvents = new ArrayList<>();
            typesBySubscriber.put(subscriber, subscribedEvents);
        }
        subscribedEvents.add(eventType);
        //这里用来处理粘性事件
        if (subscriberMethod.sticky) {
            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);
            }
        }
    }

2，注销流程

EventBus.getDefault().unregister(this);
//1,与注册相同,使用单例获取到EventBus对象.
public synchronized void unregister(Object subscriber) {
        //typesBySubscriber这是一个Map集合,键为:注册的类,值为当前类中处理的事件类型集合
        List> subscribedTypes = typesBySubscriber.get(subscriber);
        if (subscribedTypes != null) {
            for (Class eventType : subscribedTypes) {
                unsubscribeByEventType(subscriber, eventType);
            }
            //从存放注册类与事件类型的对照集合中移除注册类,这样也可以防止对象引用无法释放.
            typesBySubscriber.remove(subscriber);
        } else {
            logger.log(Level.WARNING, "Subscriber to unregister was not registered before: " + subscriber.getClass());
        }
    }

private void unsubscribeByEventType(Object subscriber, Class eventType) {
        //subscriptionsByEventType这也是一个Map集合,键:事件类型,值:事件类型对应的接收方法.
        //Subscription:将注册类与接收方法封装为了一个数据结构
        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--;
                }
            }
        }
    }

3，发布事件

//发送粘性事件
public void postSticky(Object event) {
        synchronized (stickyEvents) {
            //将粘性事件存入stickyEvents集合中,键为:事件类型,值:事件的具体值
            stickyEvents.put(event.getClass(), event);
        }
        // Should be posted after it is putted, in case the subscriber wants to remove immediately
        post(event);
    }

//发送普通事件
public void post(Object event) {
        //使用ThreadLocal存放当前线程状态对象:PostingThreadState
        PostingThreadState postingState = currentPostingThreadState.get();
        List eventQueue = postingState.eventQueue;
        //1,将事件加入到事件集合中
        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()) {
                   //2,事件处理的方法
                    postSingleEvent(eventQueue.remove(0), postingState);
                }
            } finally {
                postingState.isPosting = false;
                postingState.isMainThread = false;
            }
        }
    }

private void postSingleEvent(Object event, PostingThreadState postingState) throws Error {
        //3,获取事件类型的class对象,如:int 10 ,最终获取的是:java.lang.Integer
        Class eventClass = event.getClass();
        boolean subscriptionFound = false;
        if (eventInheritance) {
            List> eventTypes = lookupAllEventTypes(eventClass);
            int countTypes = eventTypes.size();
            for (int h = 0; h < countTypes; h++) {
                Class clazz = eventTypes.get(h);
                //4,发布事件调用方法:postSingleEventForEventType()
                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));
            }
        }
    }

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 {
                    //5,根据不同的线程模型来处理发布的事件
                    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;
    }

    //根据接收处理事件的线程模型不同,分别在对应的线程中处理事件.
    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);
        }
    }

void invokeSubscriber(Subscription subscription, Object event) {
        try {
            //6,最终调用method的invoke方法来处理
            subscription.subscriberMethod.method.invoke(subscription.subscriber, event);
        } catch (InvocationTargetException e) {
            handleSubscriberException(subscription, event, e.getCause());
        } catch (IllegalAccessException e) {
            throw new IllegalStateException("Unexpected exception", e);
        }
    }
 
 
4，索引加速的原理
 
 
 
  
在编译期生成类用来记录所有的接收事件方法，将运行期的反射提前到编译期，避免了运行期使用反射增加的性能开销。编译期生成的类如下：
 
 
 
 
public class MyEventBusIndex implements SubscriberInfoIndex {
    //用来存放所有的接收事件方法，避免后面需要通过反射获取，减小运行的性能开销
    private static final Map, SubscriberInfo> SUBSCRIBER_INDEX;

    static {
        SUBSCRIBER_INDEX = new HashMap, SubscriberInfo>();
        putIndex(new SimpleSubscriberInfo(MainActivity.class, true, new SubscriberMethodInfo[] {
            new SubscriberMethodInfo("getMainData", Integer.class, ThreadMode.MAIN, 10, false),
            new SubscriberMethodInfo("getMain2Data", Integer.class, ThreadMode.MAIN, 7, false),
            new SubscriberMethodInfo("getThreadData", Integer.class, ThreadMode.BACKGROUND, 6, false),
            new SubscriberMethodInfo("getPostData", Integer.class, ThreadMode.POSTING, 3, false),
            new SubscriberMethodInfo("getAsyncData", Integer.class, ThreadMode.ASYNC),
        }));

    }

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

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

 
 
参考：
 
 
https://www.cnblogs.com/bugly/p/5475034.html
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(事件传递EventBus)

        

            

                
    
                    
  • Eventbus3.0源码解析
                        超威蓝猫l

                        
    根据官方demo首先你需要先在activity中注册EventBus.getDefault().register(this);register所以我们先从getDefault方法开始看起/**Conveniencesingletonforappsusingaprocess-wideEventBusinstance.*/publicstaticEventBusgetDefault(){EventBu
    
                    
    • 
                    
  • 【iOS】—— 事件传递链和响应者链总结
                        《杯莫停》
iosmacoscocoa
                        
    事件传递链和响应者链总结1.事件传递链：事件传递链：传递流程：总结第一响应者：2.响应者链响应者链传递流程总结响应者链流程总结：之前也学习过这个内容这次在复习的时候，就想着写一下总结：初始事件传递链和响应者链1.事件传递链：事件传递链：将用户在应用程序中的进行交互的事件发送到视图层次中的适当对象。在这个事件的传递过程中，从根视图开始查找，并递归向下查找最合适的处理该事件的视图（第一响应者）。传递流
    
                    
    • 
                    
  • iOS事件响应链和事件传递原理
                        good7ob
应用程序ioscocoamacos事件响应链事件传递
                        
    在iOS应用程序中，用户与界面进行交互的核心机制之一是事件响应。当用户触摸屏幕、点击按钮或进行其他操作时，应用程序需要准确地捕获、处理和响应这些事件。为了实现这一目标，iOS引入了事件响应链和事件传递机制。本文将深入探讨iOS的事件响应链和事件传递原理，包括其基本概念、实现过程、代码示例以及实际应用场景。第一步：什么是事件响应链和事件传递？事件响应链是一种将事件从事件源（例如触摸屏幕）传递到最终处
    
                    
    • 
                    
  • iOS 中，用户点击一个按钮到响应的全部流程
                        ilycyq
ioscocoamacos网络objective-c
                        
    在iOS中，当用户点击一个按钮（或其他UI控件）时，会触发一系列复杂的操作流程，从硬件到软件，再到应用层的事件处理。以下是从用户点击一个按钮到应用响应的完整流程：硬件层：触摸事件的生成•用户用手指点击屏幕。•屏幕（电容式触摸屏）检测到用户的触摸事件。触摸屏幕的电容变化会被屏幕的传感器检测到。•触摸控制器（TouchController）将这些电容变化转化为电信号。硬件驱动层：事件传递到操作系统内核
    
                    
    • 
                    
  • 十,当前Activity发送事件给上一个Activity
                        CarlosLynn

                        
    当前Activity发送事件给上一个Activity当前的Activity关闭后给打开它的上一个Activity发送事件,这个类似与startActivityForResult()方法,能够实现页面关闭的回调首先我们在第一个Activity中注册注销订阅者事件其次我们定义订阅者方法接收事件EventBusAActivity代码如下publicclassEventBusAActivityextend
    
                    
    • 
                    
  • 基于事件总线EventBus实现邮件推送功能
                        快乐非自愿
邮件架构
                        
    什么是事件总线事件总线是对发布-订阅模式的一种实现。它是一种集中式事件处理机制，允许不同的组件之间进行彼此通信而又不需要相互依赖，达到一种解耦的目的。关于这个概念，网上有很多讲解的，这里我推荐一个讲的比较好的（事件总线知多少）什么是RabbitMQRabbitMQ这个就不用说了，想必到家都知道。粗糙流程图简单来解释就是：1、定义一个事件抽象类publicabstractclassEventData
    
                    
    • 
                    
  • vue3+ts 中使用mitt进行跨组件通信
                        我胡为喜呀
vue.js前端框架前端
                        
    mitt插件的使用安装插件进行封装一个模块，对外暴露一个Mitt实例使用安装插件官方文档pnpmimitt--s//我用的pnpm或npmi--smitt或yarnaddmitt进行封装一个模块，对外暴露一个Mitt实例1、在utils文件夹下新建mitt（例如mitt.ts），用于初始化并导出mitt实例：//src/eventBus.tsimportmittfrom'mitt';//定义事件类
    
                    
    • 
                    
  • java eventbus_【bird-java】分布式服务间的事件总线EventBus
                        一山同学
javaeventbus
                        
    什么是EventBusEventBus是对发布-订阅模式的一种实现。其以一种非常优雅的方式实现了组件间的解耦与通信，在Android开发、DDD等领域都有非常广泛的应用。事件流大致如下：Producer向EventBus发送事件。EventBus向所有监听了该事件的Consumer推送事件。监听了该事件的Consumer消费事件。注：一个组件即可以是Producer，也可以是Consumer。分布
    
                    
    • 
                    
  • 2021-10-21 vue笔记-组件化开发(四) 组建通信:非父子通信-事件总线,在vue项目中使用eventbus的例子
                        前端OnTheRun
vue学习笔记vue.js组件非父子通信组建通信eventBus
                        
    文章目录1.事件总线(eventBus)定义用途原理2.eventBus使用步骤3.在HTML网页中使用事件总线:模拟公众号和用户之间信息的发送和接收代码结果4.在vue项目中使用事件总线:点击增加减小按钮实现数值的增减4.1.初始化:创建一个事件总线4.2.发送事件:导入eventBus，使用`$emit`发送数据；子组件IncrementCount子组件DecreaseCountIncreme
    
                    
    • 
                    
  • VUE子组件传递父组件
                        凌涑
学习Vue3知识点vue.jsjavascript前端
                        
    背景：子组件传递父组件，是指子组件页面中相关事件操作触发需要在父组件处理才能完成，需要在子组件页面中把这个事件传递给父组件页面中，父组件接收到子组件的事件后就可以完成数据处理了。知识点1.在子组件页面中使用emits声明好要传递的事件和事件会用到的参数2.在父组件页面中，在子组件的标签上，接收组件传递过来的函数实战例子父组件结果：{{count}}importChildfrom"./Child";
    
                    
    • 
                    
  • EventBus(事件总线)的使用和源码的简单解析
                        Tai_Monster
Android开发笔记java开发语言android
                        
    GoogleGuavaEventBus(事件总线)的使用和源码的简单解析什么是EventBus？事件总线（EventBus）是一种广泛用于软件架构中的设计模式，用于实现解耦和松散耦合的通信机制。它可以帮助组织和管理应用程序中不同组件之间的通信，以提高应用程序的可维护性、可扩展性和灵活性。在事件总线模式中，不同的组件通过订阅和发布事件来进行通信。发布者发布一个事件，订阅者可以订阅该事件并在事件发生时
    
                    
    • 
                    
  • 【小程序】小程序的eventBus
                        陈大左
小程序
                        
    小程序组件跨组件通讯没有比较好的方案，小程序原生的方法也不支持eventBus，只能自己开发一个源码网上看了些，加gpt修改一下varEventBus=function(){functionEventBus(){this.events={};}EventBus.prototype.on=function(eventName,callback){if(!this.events[eventName])
    
                    
    • 
                    
  • 什么是单向数据流
                        嘘~！
前端
                        
    单向数据流是一种数据流动的模式，通常用于前端框架（如React、Vue等）中。在单向数据流中，数据只能从一个方向流向另一个方向，不会出现数据的双向流动。这种模式有助于简化数据的管理和状态的维护，提高代码的可维护性和可预测性。在单向数据流的模式中，数据通常是从父组件流向子组件，子组件可以接收父组件传递的数据进行渲染。子组件可以通过回调函数将事件传递给父组件，父组件再更新数据并重新渲染子组件，形成数据
    
                    
    • 
                    
  • Android UI：ViewTree中的事件传递
                        liufeismart2024
androidui
                        
    文章目录ViewTree:组合模式measure事件的传递事件传递:View/ViewGroup的measure和onMeasureLinearLayout重写onMeasureRelativeLayout重写onMeasurelayout事件的传递事件传递:View/ViewGroup的layout和onLayoutLinearLayout重写onLayoutRelativeLayout重写on
    
                    
    • 
                    
  • flink如何利用checkpoint保证数据状态一致性
                        Direction_Wind
flink技术原理flink大数据
                        
    flink数据状态一致性1状态一致性级别1.1AT-MOST-ONCE(最多一次)：1.2AT-LEAST-ONCE(至少一次)：1.3EXACTLY-ONCE(精确一次)：1.4分布式快照与至少一次事件传递和重复数据删除的比较2flink内部实现状态一致性3端到端的一致性3.1Source3.2Sink3.2.1幂等写入3.2.2事务写入3.2.2.1两阶段提交3.2.2.2flink的两阶段提
    
                    
    • 
                    
  • Qt事件处理机制（一）事件过滤器的使用
                        三颗橘子
QT笔记总结qt开发语言
                        
    目录1.事件传递大致流程图：2.安装事件过滤器步骤及相应例子。3.结语1.事件传递大致流程图：事件的传递大致流程如上图所示，事件发生，经过一系列函数，来到QAppliction::notify()，然后经过事件过滤器QObject::eventFilter(),经过QObject::event()发送给各个对象，各个对象在调用自己相应的事件处理函数。在大多数情况下，想要对事件做自己的处理，都从上图
    
                    
    • 
                    
  • vue 中provide的用法_聊聊Vue中provide/inject的应用详解
                        weixin_39796238
vue中provide的用法
                        
    众所周知，在组件式开发中，最大的痛点就在于组件之间的通信。在Vue中，Vue提供了各种各样的组件通信方式，从基础的props/$emit到用于兄弟组件通信的EventBus，再到用于全局数据管理的Vuex。在这么多的组件通信方式中，provide/inject显得十分阿卡林(毫无存在感)。但是，其实provide/inject也有它们的用武之地。今天，我们就来聊聊Vue中provide/injec
    
                    
    • 
                    
  • vue新特性provide/inject深入学习
                        C972325584
前端vue.js
                        
    阅读本文帮你你可以在使用provide/inject传递响应式数据时记住一个特性:provide传递的每一个响应式数据都需要值是一个引用不变的可监听对象。在开发vue项目时，不可避免的需要进行组件之间的相互通信。如果是在一个实际的业务项目中，组件间的通信可以采用采用像vuex,EventBus等机制实现跨组件通信。但如果在开发基础组件库时，需要跟业务项目外部环境(vuex，EventBus)解耦，
    
                    
    • 
                    
  • 「连载」边缘计算（十七）02-20：边缘部分源码（源码分析篇）
                        十越科技
边缘计算人工智能
                        
    （接上篇）EdgeCore之edged下面对EdgeCore组件进行剖析，因为EdgeCore中的功能组件比较多，共包括devicetwin、edged、edgehub、eventbus、edgemesh、metamanager、servicebus和test共8个功能模块。限于篇幅，本文只对edged的具体逻辑以及edged调用容器运行时进行剖析。1.edged的具体逻辑剖析从EdgeCore模
    
                    
    • 
                    
  • c# 自己造轮子之——EventBus事件总线的使用-自己实现事件总线（一）
                        漫游者码农
c#
                        
    背景：之前公司由于开发人员少，相对业务并没有那么复杂，并没有涉及到事件总线EventBus，而到了新公司，看到类似发送邮件，发送短信的业务，调用非常方便，吸引了兴趣去一探究竟，当然看起来很高深，但一旦搞懂原理后，它就没那么高深，这里写下来学习过程，一方面方便以后复习，另一个方面也希望能帮到别人强烈建议大家亲自多写几遍，关于反射，泛型，接口，抽象类，抽象方法，虚方法，有一个深刻的认识强烈建议大家亲自
    
                    
    • 
                    
  • 事件总线知多少（1）
                        weixin_33779515
ui
                        
    源码路径：Github-EventBus事件总线知多少（1）事件总线知多少（2）1.引言事件总线这个概念对你来说可能很陌生，但提到观察者（发布-订阅）模式，你也许就很熟悉。事件总线是对发布-订阅模式的一种实现。它是一种集中式事件处理机制，允许不同的组件之间进行彼此通信而又不需要相互依赖，达到一种解耦的目的。我们来看看事件总线的处理流程：了解了事件总线的基本概念和处理流程，下面我们就来分析下如何去实
    
                    
    • 
                    
  • C#&.NET 使用RabbitMQ实现一个分布式事件总线(二)
                        郭麻花
RabbitMQEventBus.NET
                        
    在上文我们介绍了本地事件总线的一个简单实现，这次我们通过借助RabbitMQ,来完成分布式事件总线的设计。代码仓库：MaH.EventBusNuget:Install-PackageMaH.EventBus-Version0.7.0设计思路我希望可以通过指定交换器名称、接收队列名称、连接信息，自动创建MQ连接与基础内容建设，以此来简化使用。当然，对于单纯的生产者来说，队列名称不是必须的，因此Add
    
                    
    • 
                    
  • C# 如何实现一个事件总线
                        Archy_Wang_1
.NETCorec#.netcore.net
                        
    EventBus（事件总线）是一种用于在应用程序内部或跨应用程序组件之间进行事件通信的机制。它允许不同的组件通过发布和订阅事件来进行解耦和通信。在给定的代码片段中，我们可以看到一个使用C#实现的EventBus。它定义了一些接口和类来实现事件的发布和订阅。首先，我们有两个基本的约束接口：IEvent和IAsyncEventHandler。IEvent是一个空接口，用于约束事件的类型。IAsyncE
    
                    
    • 
                    
  • 首次出现中学生无症状感染者，意味着什么？
                        戚老师说

                        
    黑龙江出现了首例中学生无症状感染者，这对当前的抗疫及开学来说意味着什么呢？4月16日，黑龙江13岁中学生龚某确诊为新冠肺炎无症状感染者。在庆幸龚某所在的学校还为开学之余，很多人对学生开学又开始担心起来。我们来分析此事件传递出的信息：1.抗疫斗争更加复杂化、长期化，不可掉以轻心。战疫斗争在我国取得了阶段性胜利，但还远未结束。随着境外病例的持续输入，和国内无症状感染者的发现和报告，我们已经看到了抗疫斗
    
                    
    • 
                    
  • Android源码剖析----EventBus的工作原理
                        简书不简单iiii

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

                        
    在使用EventBus3.0的时候，在AndroidStudio执行SyncProject的时候出现了这个错误android-aptpluginisincompatiblewiththeAndroidGradleplugin.Pleaseuse'annotationProcessor'由于网上很多介绍EventBus3.0是基于gradle2.2.0之前的的版本，而Gradle3.0之后，Andr
    
                    
    • 
                    
  • 2024-02-13 Unity 编辑器开发之编辑器拓展4 —— EditorGUIUtility
                        蔗理苦
Unity学习unity编辑器c#
                        
    文章目录1EditorGUIUtility介绍2加载资源2.1EidtorDefaultResources2.2不存在返回null2.3不存在则报错2.4代码示例3搜索框查询、对象选中提示3.1ShowObjectPicker3.2PingObject3.3代码示例4窗口事件传递、坐标转换4.1CommandEvent4.2GUIPoint和ScreenPoint4.3代码示例5指定区域使用对应鼠
    
                    
    • 
                    
  • 【前端高频面试题--Vue组件通信篇】
                        码上有前
前端前端vue.jsjavascript
                        
    作者：“码上有前”文章简介：前端高频面试题欢迎小伙伴们点赞、收藏⭐、留言前端高频面试题--Vue组件通信篇props/$emit父子组件传值父子组件传值案例EventBus事件总线依赖注入（provide/inject）ref/$refs$parent/$children$attrs/$listeners总结props/$emitprops和$emit是Vue.js中用于实现父子组件通信的两个关键
    
                    
    • 
                    
  • iOS开发：浅谈响应链与事件传递
                        MiniCoder

                        
    基本概念响应者:在iOS中，响应者为能响应事件的UIResponder子类对象，如UIButton、UIView等。响应链:响应链是由链接在一起的响应者（UIResponse子类）组成的。默认情况下，响应链是由第一响应者，到application对象以及中间所有响应者一起组成的。事件传递:获得响应链后，将事件由第一响应者往application传递的过程即为事件传递。14477290-74a39a
    
                    
    • 
                    
  • 设计模式
                        灰溜溜的小王子

                        
    一、编程中的六大设计原则？1.单一职责原则通俗地讲就是一个类只做一件事1.CALayer：动画和视图的显示。2.UIView：只负责事件传递、事件响应。2.开闭原则对修改关闭，对扩展开放。要考虑到后续的扩展性，而不是在原有的基础上来回修改3.接口隔离原则使用多个专门的协议、而不是一个庞大臃肿的协议，例如tableView的代理和数据源代理：UITableviewDelegate，UITableVi
    
                    
    • 
                                
  • java工厂模式
                                    3213213333332132
java抽象工厂
                                    
    工厂模式有 
1、工厂方法 
2、抽象工厂方法。 
 
下面我的实现是抽象工厂方法, 
 
给所有具体的产品类定一个通用的接口。 
 

package 工厂模式;

/**
 * 航天飞行接口
 * 
 * @Description
 * @author FuJianyong
 * 2015-7-14下午02:42:05
 */
public interface SpaceF
    
                                
    • 
                                
  • nginx频率限制+python测试
                                    ronin47
nginx 频率 python
                                    
           
部分内容参考：http://www.abc3210.com/2013/web_04/82.shtml 
首先说一下遇到这个问题是因为网站被攻击，阿里云报警，想到要限制一下访问频率，而不是限制ip（限制ip的方案稍后给出）。nginx连接资源被吃空返回状态码是502，添加本方案限制后返回599，与正常状态码区别开。步骤如下：
    
                                
    • 
                                
  • java线程和线程池的使用
                                    dyy_gusi
ThreadPoolthreadRunnabletimer
                                    
    java线程和线程池 
一、创建多线程的方式 
    java多线程很常见，如何使用多线程，如何创建线程，java中有两种方式，第一种是让自己的类实现Runnable接口，第二种是让自己的类继承Thread类。其实Thread类自己也是实现了Runnable接口。具体使用实例如下： 
1、通过实现Runnable接口方式          1   2   
    
                                
    • 
                                
  • Linux
                                    171815164
linux
                                    
    ubuntu kernel 
http://kernel.ubuntu.com/~kernel-ppa/mainline/v4.1.2-unstable/ 
 
安卓sdk代理 
mirrors.neusoft.edu.cn        80 
 
输入法和jdk 
sudo apt-get install fcitx 
su
    
                                
    • 
                                
  • Tomcat JDBC Connection Pool
                                    g21121
Connection
                                    
           Tomcat7 抛弃了以往的DBCP 采用了新的Tomcat Jdbc Pool 作为数据库连接组件，事实上DBCP已经被Hibernate 所抛弃，因为他存在很多问题，诸如：更新缓慢，bug较多，编译问题，代码复杂等等。 
       Tomcat Jdbc P
    
                                
    • 
                                
  • 敲代码的一点想法
                                    永夜-极光
java随笔感想
                                    
                  入门学习java编程已经半年了,一路敲代码下来,现在也才1w+行代码量,也就菜鸟水准吧,但是在整个学习过程中,我一直在想,为什么很多培训老师,网上的文章都是要我们背一些代码?比如学习Arraylist的时候,教师就让我们先参考源代码写一遍,然
    
                                
    • 
                                
  • jvm指令集
                                    程序员是怎么炼成的
jvm 指令集
                                    
    转自：http://blog.csdn.net/hudashi/article/details/7062675#comments 
  
  
  
将值推送至栈顶时 const ldc  push   load指令 
const系列 
该系列命令主要负责把简单的数值类型送到栈顶。(从常量池或者局部变量push到栈顶时均使用) 
0x02 &nbs
    
                                
    • 
                                
  • Oracle字符集的查看查询和Oracle字符集的设置修改
                                    aijuans
oracle
                                    
     本文主要讨论以下几个部分：如何查看查询oracle字符集、 修改设置字符集以及常见的oracle utf8字符集和oracle exp 字符集问题。 
一、什么是Oracle字符集  
 Oracle字符集是一个字节数据的解释的符号集合,有大小之分,有相互的包容关系。ORACLE 支持国家语言的体系结构允许你使用本地化语言来存储，处理，检索数据。它使数据库工具，错误消息，排序次序，日期，时间，货
    
                                
    • 
                                
  • png在Ie6下透明度处理方法
                                    antonyup_2006
css浏览器FirebugIE
                                    
    由于之前到深圳现场支撑上线，当时为了解决个控件下载，我机器上的IE8老报个错，不得以把ie8卸载掉，换个Ie6,问题解决了，今天出差回来，用ie6登入另一个正在开发的系统，遇到了Png图片的问题，当然升级到ie8(ie8自带的开发人员工具调试前端页面JS之类的还是比较方便的，和FireBug一样，呵呵)，这个问题就解决了，但稍微做了下这个问题的处理。 
 
我们知道PNG是图像文件存储格式，查询资
    
                                
    • 
                                
  • 表查询常用命令高级查询方法(二)
                                    百合不是茶
oracle分页查询分组查询联合查询
                                    
    ----------------------------------------------------分组查询 group by    having   --平均工资和最高工资   select avg(sal)平均工资,max(sal)  from emp ;  --每个部门的平均工资和最高工资
    
                                
    • 
                                
  • uploadify3.1版本参数使用详解
                                    bijian1013
JavaScriptuploadify3.1
                                    
    使用： 
    绑定的界面元素<input id='gallery'type='file'/>$("#gallery").uploadify({设置参数，参数如下}); 
设置的属性： 
id: jQuery(this).attr('id'),//绑定的input的ID
      langFile: 'http://ww
    
                                
    • 
                                
  • 精通Oracle10编程SQL(17)使用ORACLE系统包
                                    bijian1013
oracle数据库plsql
                                    
    /*
 *使用ORACLE系统包
 */
--1.DBMS_OUTPUT
--ENABLE:用于激活过程PUT,PUT_LINE,NEW_LINE,GET_LINE和GET_LINES的调用
--语法：DBMS_OUTPUT.enable(buffer_size in integer default 20000);

--DISABLE:用于禁止对过程PUT,PUT_LINE,NEW
    
                                
    • 
                                
  • 【JVM一】JVM垃圾回收日志
                                    bit1129
垃圾回收
                                    
    将JVM垃圾回收的日志记录下来，对于分析垃圾回收的运行状态，进而调整内存分配(年轻代，老年代，永久代的内存分配)等是很有意义的。JVM与垃圾回收日志相关的参数包括： 
 
 -XX:+PrintGC 
 -XX:+PrintGCDetails 
 -XX:+PrintGCTimeStamps  
 -XX:+PrintGCDateStamps 
 -Xloggc 
 -XX:+PrintGC 
通
    
                                
    • 
                                
  • Toast使用
                                    白糖_
toast
                                    
    Android中的Toast是一种简易的消息提示框，toast提示框不能被用户点击，toast会根据用户设置的显示时间后自动消失。 
  
  
 
 创建Toast 
   两个方法创建Toast   
makeText(Context context, int resId, int duration)  
  
  参数：context是toast显示在
    
                                
    • 
                                
  • angular.identity
                                    boyitech
AngularJSAngularJS API
                                    
    angular.identiy   描述:   返回它第一参数的函数. 此函数多用于函数是编程.    使用方法:   angular.identity(value);   参数详解:      Param Type Details   value 
*  
to be returned.      返回值:   传入的value   实例代码:   
<!DOCTYPE HTML>

    
                                
    • 
                                
  • java-两整数相除，求循环节
                                    bylijinnan
java
                                    
    
import java.util.ArrayList;
import java.util.List;

public class CircleDigitsInDivision {

	/**
	 * 题目：求循环节，若整除则返回NULL，否则返回char*指向循环节。先写思路。函数原型：char*get_circle_digits(unsigned k,unsigned j) 

    
                                
    • 
                                
  • Java 日期 周 年
                                    Chen.H
javaC++cC#
                                    
    

/**
 * java日期操作(月末、周末等的日期操作)
 * 
 * @author 
 * 
 */
public class DateUtil {
	
    /** */
    /**
     * 取得某天相加(减)後的那一天
     * 
     * @param date
     * @param num
     *           
    
                                
    • 
                                
  • [高考与专业]欢迎广大高中毕业生加入自动控制与计算机应用专业
                                    comsci
计算机
                                    
     
 
      不知道现在的高校还设置这个宽口径专业没有,自动控制与计算机应用专业,我就是这个专业毕业的,这个专业的课程非常多,既要学习自动控制方面的课程,也要学习计算机专业的课程,对数学也要求比较高.....如果有这个专业,欢迎大家报考...毕业出来之后,就业的途径非常广..... 
 
     以后
    
                                
    • 
                                
  • 分层查询（Hierarchical Queries）
                                    daizj
oracle递归查询层次查询
                                    
    Hierarchical Queries 
 
If a table contains hierarchical data, then you can select rows in a hierarchical order using the hierarchical query clause: 
 
hierarchical_query_clause::= 
 
start with condi
    
                                
    • 
                                
  • 数据迁移
                                    daysinsun
数据迁移
                                    
    最近公司在重构一个医疗系统，原来的系统是两个.Net系统，现需要重构到java中。数据库分别为SQL Server和Mysql，现需要将数据库统一为Hana数据库，发现了几个问题，但最后通过努力都解决了。 
1、原本通过Hana的数据迁移工具把数据是可以迁移过去的，在MySQl里面的字段为TEXT类型的到Hana里面就存储不了了，最后不得不更改为clob。 
 
2、在数据插入的时候有些字段特别长
    
                                
    • 
                                
  • C语言学习二进制的表示示例
                                    dcj3sjt126com
cbasic
                                    
    进制的表示示例 
# include <stdio.h>

int main(void)
{
	int i = 0x32C;

	printf("i = %d\n", i);
	/*
		printf的用法
		%d表示以十进制输出
		%x或%X表示以十六进制的输出
		%o表示以八进制输出
	*/

	return 0;
}
 

    
                                
    • 
                                
  • NsTimer 和 UITableViewCell 之间的控制
                                    dcj3sjt126com
ios
                                    
    情况是这样的: 
一个UITableView, 每个Cell的内容是我自定义的 viewA viewA上面有很多的动画, 我需要添加NSTimer来做动画, 由于TableView的复用机制, 我添加的动画会不断开启, 没有停止, 动画会执行越来越多. 
  
解决办法: 
在配置cell的时候开始动画, 然后在cell结束显示的时候停止动画 
  
查找cell结束显示的代理
    
                                
    • 
                                
  • MySql中case when then 的使用
                                    fanxiaolong
casewhenthenend
                                    
    select "主键",  "项目编号", "项目名称","项目创建时间", "项目状态","部门名称","创建人"

union

(select
	pp.id as "主键",
	pp.project_number as &
    
                                
    • 
                                
  • Ehcache（01）——简介、基本操作
                                    234390216
cacheehcache简介CacheManagercrud
                                    
    Ehcache简介 
目录 
1       CacheManager 
1.1      构造方法构建 
1.2      静态方法构建 
2       Cache 
2.1&
    
                                
    • 
                                
  • 最容易懂的javascript闭包学习入门
                                    jackyrong
JavaScript
                                    
    http://www.ruanyifeng.com/blog/2009/08/learning_javascript_closures.html 
 
闭包（closure）是Javascript语言的一个难点，也是它的特色，很多高级应用都要依靠闭包实现。 
下面就是我的学习笔记，对于Javascript初学者应该是很有用的。 
一、变量的作用域 
要理解闭包，首先必须理解Javascript特殊
    
                                
    • 
                                
  • 提升网站转化率的四步优化方案
                                    php教程分享
数据结构PHP数据挖掘Google活动
                                    
    网站开发完成后,我们在进行网站优化最关键的问题就是如何提高整体的转化率，这也是营销策略里最最重要的方面之一，并且也是网站综合运营实例的结果。文中分享了四大优化策略：调查、研究、优化、评估，这四大策略可以很好地帮助用户设计出高效的优化方案。 
PHP开发的网站优化一个网站最关键和棘手的是，如何提高整体的转化率，这是任何营销策略里最重要的方面之一，而提升网站转化率是网站综合运营实力的结果。今天，我就分
    
                                
    • 
                                
  • web开发里什么是HTML5的WebSocket？
                                    naruto1990
Webhtml5浏览器socket
                                    
    当前火起来的HTML5语言里面，很多学者们都还没有完全了解这语言的效果情况，我最喜欢的Web开发技术就是正迅速变得流行的 WebSocket API。WebSocket 提供了一个受欢迎的技术，以替代我们过去几年一直在用的Ajax技术。这个新的API提供了一个方法，从客户端使用简单的语法有效地推动消息到服务器。让我们看一看6个HTML5教程介绍里 的 WebSocket API：它可用于客户端、服
    
                                
    • 
                                
  • Socket初步编程——简单实现群聊
                                    Everyday都不同
socket网络编程初步认识
                                    
    初次接触到socket网络编程，也参考了网络上众前辈的文章。尝试自己也写了一下，记录下过程吧： 
  
服务端：（接收客户端消息并把它们打印出来） 
  
public class SocketServer {
	private List<Socket> socketList = new ArrayList<Socket>();
	 public s
    
                                
    • 
                                
  • 面试：Hashtable与HashMap的区别（结合线程）
                                    toknowme

                                    
    昨天去了某钱公司面试，面试过程中被问道 
Hashtable与HashMap的区别？当时就是回答了一点，Hashtable是线程安全的，HashMap是线程不安全的，说白了，就是Hashtable是的同步的，HashMap不是同步的，需要额外的处理一下。 
  
今天就动手写了一个例子，直接看代码吧 
package com.learn.lesson001;

import java
    
                                
    • 
                                
  • MVC设计模式的总结
                                    xp9802
设计模式mvc框架IOC
                                    
    随着Web应用的商业逻辑包含逐渐复杂的公式分析计算、决策支持等，使客户机越 
来越不堪重负，因此将系统的商业分离出来。单独形成一部分，这样三层结构产生了。 
其中‘层’是逻辑上的划分。 
三层体系结构是将整个系统划分为如图2.1所示的结构[3] 
 
 
（1）表现层（Presentation layer）：包含表示代码、用户交互GUI、数据验证。 
该层用于向客户端用户提供GUI交互，它允许用户
    
                                
    •