安仔夏天勤奋
安仔夏天勤奋

小点知识——观察者模式，由浅谈到理解

观察者模式

自己对观察者模式的理解：
定义：Define a one-to-many dependency between objects so that when one object changes state, all its dependents aer notified and updated automatically.

意图：定义对象间的一种一对多的依赖关系，当一个对象改变状态时，则所有依赖于它的对象都会得到通知并被自动更新。

主要解决：一个对象状态改变给其他对象通知的问题，而且要考虑到易用和低耦合，保证高度的协作。

使用场景：

1、有多个子类共有的方法，且逻辑相同。
2、重要的、复杂的方法，可以考虑作为模板方法。

优缺点：

优点：

1、观察者和被观察者是抽象耦合的。
2、建立一套触发机制。

缺点：

1、如果一个被观察者对象有很多的直接和间接的观察者的话，将所有的观察者都通知到会花费很多时间。
2、如果在观察者和观察目标之间有循环依赖的话，观察目标会触发它们之间进行循环调用，可能导致系统崩溃。
3、观察者模式没有相应的机制让观察者知道所观察的目标对象是怎么发生变化的，而仅仅只是知道观察目标发生了变化。

注意事项：

  1. JAVA 中已经有了对观察者模式的支持类。
  2. 避免循环引用。
  3. 如果顺序执行，某一观察者错误会导致系统卡壳，一般采用异步方式。

观察者模式的组成：

  1. 观察者，我们称它为Observer，有时候我们也称它为订阅者，即Subscriber。
  2. 被观察者，我们称它为Observable，即可以被观察的东西，有时候还会称之为主题，即Subject。

撸起袖子，为了验证我们的观察者模式，一波观察者模式的场景，首先定义一个Theif为观察目标。


    public class Theif {
        //描述小偷形象
        private String description;
    
        public Theif(String description){
            this.description = description;
        }
    
        public String getDescription() {
            return description;
        }
    
        public void setDescription(String description) {
            this.description = description;
        }
    
        @Override
        public String toString() {
            return "一名"+description+"小偷在进行扒窃";
        }
    }

定义我们的被观察者，我们希望能够通用，所以定义成泛型。泛型指具体的被观察者，内部暴露出register和unRegister方法供观察者订阅和取消订阅，至于观察者们的保存，我们用ArrayList集合储存即可，另外，当小偷发生变化的时候，需要通知观察者来做出响应，还需要一个notifyObservers方法。

public class Observable {
    //|存放观察者们
    List> mObservers = new ArrayList<>();
    //供观察者订阅 传入观察者即可
    public void register(Observer observer) {    
        if (observer == null) {    
            throw new NullPointerException("observer == null");    
        }
        //多线程 添加同步锁
        // 如果线程A进入了该代码，线程B 在等待，这是A线程创建完一个实例出来后，线程B 获得锁进入同步代码，
        // 实例已经存在，木有必要再添加一个
        synchronized (this) {    
            if (!mObservers.contains(observer))    
                mObservers.add(observer);    
        }    
    }
    //根据传入的观察者 供观察者取消订阅
    public synchronized void unregister(Observer observer) {    
        mObservers.remove(observer);    
    }    
    //通知观察者们
    public void notifyObservers(T data) {    
        for (Observer observer : mObservers) {    
            observer.onFindThief(this, data);
        }    
    }    

}

定义Observer接口为观察者，接收到消息后，即进行更新操作，对接收到的信息进行处理。观察者们 只需要实现Observer接口,该接口也是泛型的

public interface Observer {
    //观察者发现目标，通过调用这个方法，并携带被观察者和数据 进行更新
    void onFindThief(Observable observable,T data);
}

一旦订阅，发现小偷有变化，就会调用onFindThief接口。一定要用register方法来注册，否则观察者收不到变化的信息，而一旦不感兴趣，就可以调用unregister方法。

public class TestJava {

    public static void main(String agr[]){

        //一旦订阅，发现小偷有变化，就会调用onFindThief接口
        //Observable被观察者 被观察者的对象是小偷（Theif）
        Observable observable=new Observable<>();
        //为了简便直接在这里创建一个观察者对象。观察者1  对小偷进行观察，一旦发现小偷就打印出目标
        Observer observer1 = new Observer() {
            @Override
            public void onFindThief(Observable observable, Theif data) {
                System.out.println("观察者1——发现目标："+data.toString());
            }
        };
        //观察者2  对小偷进行观察，一旦发现小偷就打印出目标
        Observer observer2 = new Observer() {
            @Override
            public void onFindThief(Observable observable, Theif data) {
                System.out.println("观察者2——发现目标："+data.toString());
            }
        };
        //一定要用register方法来注册，否则观察者收不到变化的信息，而一旦不感兴趣，就可以调用unregister方法
        observable.register(observer1);
        observable.register(observer2);

        //目标
        Theif theif = new Theif("穿红色外套");
        //被观察的目标有变化，通知观察者们
        observable.notifyObservers(theif);
        //观察者1 吃饭时间到，不再观察了 调用unregister方法注销被观察对象，其他观察者还有观察
        observable.unregister(observer1);

        //目标
        Theif theif2 = new Theif("中年男子，染黄头发");
        //被观察的目标有变化，通知观察者们
        observable.notifyObservers(theif2);

    }
}

输出结果为:

观察者1——发现目标：一名穿红色外套小偷在进行扒窃
观察者2——发现目标：一名穿红色外套小偷在进行扒窃
观察者2——发现目标：一名中年男子，染黄头发小偷在进行扒窃

一个简单的观察者模式就出来了，当然上面的代码还可以优化。有兴趣的可以自己进一步优化。

小结

观察者模式主要包括两个部分：

  • Subject被观察者。是一个接口或者是抽象类，定义被观察者必须实现的职责，它必须能偶动态地增加、取消观察者，管理观察者并通知观察者。
  • Observer观察者。观察者接收到消息后，即进行更新操作，对接收到的信息进行处理。
  1. ConcreteSubject具体的被观察者。定义被观察者自己的业务逻辑。
  2. ConcreteObserver具体观察者。每个观察者在接收到信息后处理的方式不同，各个观察者有自己的处理逻辑。
  3. 上面的例子Observable为被观察者 被观察者的对象是小偷（Theif），也即是ConcreteSubject具体的被观察者
  4. 上面的例子：可以自己定义一个类并实现Observer接口，那么这个类就是ConcreteObserver具体观察者。

开源框架EventBus、Rxjava等也是基于观察者模式的，观察者模式的注册，取消，发送事件三个典型方法都有。以EventBus3.0作为例子，分析其源码。

什么是EventBus

EventBus是一个消息总线，以观察者模式实现，用于简化程序的组件、线程通信，可以轻易切换线程、开辟线程。EventBus3.0跟先前版本的区别在于加入了annotation @Subscribe，取代了以前约定命名的方式

优点

开销小，代码优雅。将发送者和接受者解耦。

EventBus的用法——常用的几个方法

EventBus.getDefault().register(Object subscriber);    
EventBus.getDefault().unregister(Object subscriber);    
EventBus.getDefault().post(Object event);  
EventBus.getDefault().postSticky(Object event);

当我们要调用EventBus的功能时，比如注册或者发送事件等，总会调用EventBus.getDefault()来获取EventBus实例

//源码
static volatile EventBus defaultInstance;
/** 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;
}
public EventBus() {
  this(DEFAULT_BUILDER);
}

从源码看出很明显这是一个单例模式。如果对单例模式感兴趣可以去研究一下单例模式。一看构造函数this(DEFAULT_BUILDER)做了些什么。这里DEFAULT_BUILDER是默认的EventBusBuilder用来构造EventBus：

private static final EventBusBuilder DEFAULT_BUILDER = new EventBusBuilder();

进入EventBusBuilder类看看，这么多个可选的配置属性,这里变量含义大家直接看我的注释,就不多作解释了。我们主要看最终的建造方法：

/**
 * 根据参数创建对象,并赋值给EventBus.defaultInstance, 必须在默认的eventbus对象使用以前调用
 *
 * @throws EventBusException if there's already a default EventBus instance in place
 */
public EventBus installDefaultEventBus() {
    synchronized (EventBus.class) {
        if (EventBus.defaultInstance != null) {
            throw new EventBusException("Default instance already exists." +
                    " It may be only set once before it's used the first time to ensure " +
                    "consistent behavior.");
        }
        EventBus.defaultInstance = build();
        return EventBus.defaultInstance;
    }
}

/**
 * 根据参数创建对象
 */
public EventBus build() {
    return new EventBus(this);
}

EventBusBuilder类提供了两种建造方法,还记得之前的getDefault()方法吗,维护了一个单例对象,installDefaultEventBus() 方法建造的EventBus对象最终会赋值给那个单例对象,但是有一个前提就是我们之前并没有创建过那个单例对象.

为什么如果EventBus.defaultInstance不为null程序要抛出异常？先把这个问题留着，继续往下看。

回到EventBus的构造方法中，this(DEFAULT_BUILDER)是指EventBus一个带实参的构造函数：

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

EventBusBuilder类提供了这么多个可选的配置属性,这里Map变量含义大家直接看我的注释。EventBus构造函数也涉及到了构造模式，感兴趣的可以查阅一下，这里就不多说了。

这里说说EventBus中的三个Poster类（HandlerPoster、BackgroundPoster、AsyncPoster）。三个Poster类的作用是什么？Poster应该是发布时候会涉及到，不过我们之后看代码再作解答，先解决这三个类，看代码。

private final HandlerPoster mainThreadPoster; //前台发送者
private final BackgroundPoster backgroundPoster; //后台发送者
private final AsyncPoster asyncPoster;   //后台发送者(只让队列第一个待订阅者去响应)

这几个Poster的设计可以说是整个EventBus的一个经典部分。每个Poster中都有一个发送任务队列,PendingPostQueue queue。进到队列PendingPostQueue里面再看。

private PendingPost head; //待发送对象队列头节点
private PendingPost tail;//待发送对象队列尾节点

接着我们再看这个PendingPost类的实现：

//单例池,复用对象
private final static List pendingPostPool = new ArrayList();

Object event; //事件类型
Subscription subscription; //订阅者
PendingPost next; //队列下一个待发送对象

首先是提供了一个池的设计，类似于我们的线程池，目的是为了减少对象创建的开销，当一个对象不用了，我们可以留着它，下次再需要的时候返回这个保留的而不是再去创建。接着看最后的变量，PendingPost next 非常典型的队列设计，队列中每个节点都有一个指向下一个节点的指针。

/**
 * 首先检查复用池中是否有可用,如果有则返回复用,否则返回一个新的
 *
 * @param subscription 订阅者
 * @param event        订阅事件
 * @return 待发送对象
 */
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);
}

/**
 * 回收一个待发送对象,并加入复用池
 *
 * @param pendingPost 待回收的待发送对象
 */
static void releasePendingPost(PendingPost pendingPost) {
    pendingPost.event = null;
    pendingPost.subscription = null;
    pendingPost.next = null;
    synchronized (pendingPostPool) {
        // 防止池无限增长
        if (pendingPostPool.size() < 10000) {
            pendingPostPool.add(pendingPost);
        }
    }
}

obtainPendingPost()方法中对池复用的实现，每次新创建的节点尾指针都为 null 。细心的人还看到了一个关键字synchronized。Synchronized是Java并发编程中最常用的用于保证线程安全的方式，其使用相对也比较简单。（但是如果能够深入了解其原理，对监视器锁等底层知识有所了解，一方面可以帮助我们正确的使用Synchronized关键字，另一方面也能够帮助我们更好的理解并发编程机制，有助我们在不同的情况下选择更优的并发策略来完成任务。对平时遇到的各种并发问题，也能够从容的应对。不过这都是题个话了，有兴趣可以多了解一下。）

releasePendingPost()，回收pendingPost对象，既然可以从池中取，当然需要可以存。非常细心的可以注意到池的大小小于10000，不禁会想这是为什么呢，想表达什么呢？，if (pendingPostPool.size() < 10000) 其实我觉得10000都很大了，1000就够了，我们一次只可能创建一个pendingPost，如果ArrayList里面存了上千条都没有取走，那么肯定是使用出错了。当然ArrayList里不会存放那么多池，我只能猜测他们也只是预防一下，但也不是不可能不存在这样的情况。

三个Poster类的最底层都是PendingPost类，PendingPost的代码我们就看完了。那么继续往上一级PendingPostQueue类了解。PendingPostQueue这是一个队列的设计。那么我们首先看看PendingPostQueue的入队方法：

synchronized void enqueue(PendingPost pendingPost) {
    if (pendingPost == null) {
        throw new NullPointerException("null cannot be enqueued");
    }
    if (tail != null) {
        tail.next = pendingPost;
        tail = pendingPost;
    } else if (head == null) {
        head = tail = pendingPost;
    } else {
        throw new IllegalStateException("Head present, but no tail");
    }
    notifyAll();
}

从源码可以看出首先来个判空处理。接着将当前节点的上一个节点(入队前整个队列的最后一个节点)的尾指针指向当期正在入队的节点(传入的参数pendingPost)，并将队列的尾指针指向自己(自己变成队列的最后一个节点)，这样就完成了入队。如果是队列的第一个元素(队列之前是空的),那么直接将队列的头尾两个指针都指向自身就行了。

接着看看PendingPostQueue的出队也是类似的队列指针操作：

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

首先将出队前的头节点保留一个临时变量(它就是要出队的节点),拿到这个将要出队的临时变量的下一个节点指针，将出队前的第二个元素(出队后的第一个元素)的赋值为现在队列的头节点，出队完成。

非常细心的人会发现 PendingPostQueue的所有方法都声明了synchronized。这意味着在多线程下它依旧可以正常工作。如果对synchronized还是不太了解的可以查阅资料。

既然所有方法都声明了synchronized，那就必定有他的道理。那么我们往上一级看看就知道方法前添加synchronized关键字是不是存在的意义。接着看HandlerPoster的入队方法enqueue()：

/**
 * @param subscription 订阅者
 * @param event        订阅事件
 */
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");
            }
        }
    }
}

入队方法会根据参数创建，待发送对象pendingPost并加入队列,从代码上可以看出验证了synchronized关键字是有存在的意义。 handleMessage()没有在运行中,则发送一条空消息让handleMessage响应，那继续看看handleMessage()方法里做了些什么：

@Override
public void handleMessage(Message msg) {
    boolean rescheduled = false;
    try {
        long started = SystemClock.uptimeMillis();
        while (true) {
            PendingPost pendingPost = queue.poll();
            if (pendingPost == null) {
                synchronized (this) {
                    // 双重校验,类似单例中的实现
                    pendingPost = queue.poll();
                    if (pendingPost == null) {
                        handlerActive = false;
                        return;
                    }
                }
            }
            //如果订阅者没有取消注册,则分发消息
            eventBus.invokeSubscriber(pendingPost);
            
            //如果在一定时间内仍然没有发完队列中所有的待发送者,则退出
            long timeInMethod = SystemClock.uptimeMillis() - started;
            if (timeInMethod >= maxMillisInsideHandleMessage) {
                if (!sendMessage(obtainMessage())) {
                    throw new EventBusException("Could not send handler message");
                }
                rescheduled = true;
                return;
            }
        }
    } finally {
        handlerActive = rescheduled;
    }
}

handleMessage()不停的在待发送队列queue中去取消息。直得注意的是在循环之外有个临时boolean变量rescheduled,最后是通过这个值去修改了handlerActive。而 handlerActive 是用来判断当前queue中是否有正在发送对象的任务，看到上面的入队方法enqueue(),如果已经有任务在跑着了，就不需要再去sendMessage()唤起我们的handleMessage()。最终通过eventBus对象的invokeSubscriber()最终发送出去，并回收这个pendingPost。那么这里有个问题了，什么时候才会通过eventBus对象的invokeSubscriber()发送出去？HandlePoster类已经看完了，其实三个Poster类里面的实现都很相似易懂的，以HandlePoster类来介绍,另外两个类（BackgroundPoster、AsyncPoster）异步的发送者实现代码也差不多,唯一的区别就是另外两个是工作在异步,实现的Runnable接口。

整理一下上面出现和问题：

  1. 为什么如果EventBus.defaultInstance不为null程序要抛出异常？
  2. 三个Poster类（HandlerPoster、BackgroundPoster、AsyncPoster）的作用是什么？
  3. invokeSubscriber()什么时候才触发发送出去？

回顾一下Poster、PendingPostQueue、PendingPost这三个类，是不是有种似曾相识的感觉。哈哈，没有错。那是Handler、Message、Looper的工作原理。如果不了解Handler可以查阅一下资料。

EventBus注册

获取到EventBus后，可以将订阅者注册到EventBus中，下面来看一下register方法：

public void register(Object subscriber) {
    Class subscriberClass = subscriber.getClass();
    // 用 subscriberMethodFinder 提供的方法，找到在 subscriber 这个类里面订阅的内容。
    List subscriberMethods = subscriberMethodFinder.findSubscriberMethods(subscriberClass);
    synchronized (this) {
        for (SubscriberMethod subscriberMethod : subscriberMethods) {
            subscribe(subscriber, subscriberMethod);
        }
    }
}

通过SubscriberMethodFinder#findSubscriberMethods方法找出一个SubscriberMethod的集合，也就是传进来的订阅者所有的订阅的方法，接下来遍历订阅者的订阅方法来完成订阅者的订阅操作。对于SubscriberMethod（订阅方法）类中，主要就是用保存订阅方法的Method对象、线程模式、事件类型、优先级、是否是粘性事件等属性，就不贴代码了。那说说SubscriberMethodFinder类中的findSubscriberMethods方法吧，SubscriberMethodFinder从字面理解，就是订阅者方法发现者。

List findSubscriberMethods(Class subscriberClass) {
   //从缓存中获取SubscriberMethod集合
   List subscriberMethods = METHOD_CACHE.get(subscriberClass);
   if (subscriberMethods != null) {
       return subscriberMethods;
   }
   //ignoreGeneratedIndex属性表示是否忽略注解器生成的MyEventBusIndex
   if (ignoreGeneratedIndex) {
    //通过反射获取subscriberMethods
       subscriberMethods = findUsingReflection(subscriberClass);
   } else {
       subscriberMethods = findUsingInfo(subscriberClass);
   }
   //在获得subscriberMethods以后，如果订阅者中不存在@Subscribe注解并且为public的订阅方法，则会抛出异常。
   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;
   }
}

首先从缓存中查找，如果找到了就返回subscriberMethods。如果缓存中没有的话，则根据 ignoreGeneratedIndex选择如何查找订阅方法，ignoreGeneratedIndex属性表示是否忽略注解器生成的MyEventBusIndex。ignoreGeneratedIndex 默认就是false，如果ignoreGeneratedIndex是true 那么通反射获取subscriberMethods，可以通过EventBusBuilder来设置它的值。最后，找到订阅方法后，放入缓存，以免下次继续查找。

可以看到其中findUsingInfo()方法就是去索引中查找订阅者的回调方法，我们戳进去看看这个方法的实现：

private List findUsingInfo(Class subscriberClass) {
    // 最新版的EventBus3中，寻找方法时所需的临时变量都被封装到了FindState这个静态内部类中
    FindState findState = prepareFindState(); // 到对象池中取得上下文，避免频繁创造对象，这个设计很赞
    findState.initForSubscriber(subscriberClass); // 初始化寻找方法的上下文
    while (findState.clazz != null) { // 子类找完了，会继续去父类中找
        findState.subscriberInfo = getSubscriberInfo(findState); // 获得订阅者类的相关信息
        if (findState.subscriberInfo != null) { // 上一步能拿到相关信息的话，就开始把方法数组封装成List
            SubscriberMethod[] array = findState.subscriberInfo.getSubscriberMethods();
            for (SubscriberMethod subscriberMethod : array) {
                if (findState.checkAdd(subscriberMethod.method, subscriberMethod.eventType)) {
                    // checkAdd是为了避免在父类中找到的方法是被子类重写的，此时应该保证回调时执行子类的方法
                    findState.subscriberMethods.add(subscriberMethod);
                }
            }
        } else { // 索引中找不到，降级成运行时通过注解和反射去找
            findUsingReflectionInSingleClass(findState);
        }
        findState.moveToSuperclass(); // 上下文切换成父类
    }
    return getMethodsAndRelease(findState); // 找完后，释放FindState进对象池，并返回找到的回调方法
}

通过prepareFindState()找到所需的临时变量都被封装到了FindState这个静态内部类中，初始化寻找方法的上下文，子类找完了，会继续去父类中找。然后getSubscriberInfo方法来获取订阅者信息。如果获得到订阅者类的相关信息，不仅会去遍历父类，而且还会避免因为重写方法导致执行多次回调，过虑了重重保险关卡，然后subscriberMethods添加subscriberMethod。如果没有获得到订阅者类的相关信息，便会执行findUsingReflectionInSingleClass方法，将订阅方法保存到findState中。最后再通过getMethodsAndRelease方法对findState做回收处理并反回订阅方法的List集合。其中需要关心的是getSubscriberInfo()是如何返回索引数据的。

private SubscriberInfo getSubscriberInfo(FindState findState) {
    if (findState.subscriberInfo != null && findState.subscriberInfo.getSuperSubscriberInfo() != null) { // subscriberInfo已有实例，证明本次查找需要查找上次找过的类的父类
        SubscriberInfo superclassInfo = findState.subscriberInfo.getSuperSubscriberInfo();
        if (findState.clazz == superclassInfo.getSubscriberClass()) { // 确定是所需查找的类
            return superclassInfo;
        }
    }
    if (subscriberInfoIndexes != null) { // 从我们传进来的subscriberInfoIndexes中获取相应的订阅者信息
        for (SubscriberInfoIndex index : subscriberInfoIndexes) {
            SubscriberInfo info = index.getSubscriberInfo(findState.clazz);
            if (info != null) { return info; }
        }
    }
    return null;
}

在getSubscriberInfo方法中，传入的实参如果已有实例，证明本次查找需要查找上次找过的类的父类。如果没有实例，应用到了我们生成的索引，避免我们需要在findSubscriberMethods时去调用耗时的findUsingReflection方法。关于注解为我们生成的索引这里先不解答，后面会有代码解说（在我们开始查找订阅方法的时候并没有忽略注解器为我们生成的索引MyEventBusIndex，如果我们通过EventBusBuilder配置了MyEventBusIndex，便会获取到subscriberInfo，调用subscriberInfo的getSubscriberMethods方法便可以得到订阅方法相关的信息，这个时候就不在需要通过注解进行获取订阅方法。如果没有配置MyEventBusIndex，便会执行findUsingReflectionInSingleClass方法，将订阅方法保存到findState中。）

下面就来看一下findUsingReflectionInSingleClass的执行过程：

private void findUsingReflectionInSingleClass(FindState findState) {
    Method[] methods;
    try {
        // This is faster than getMethods, especially when subscribers are fat classes like Activities
        methods = findState.clazz.getDeclaredMethods();
    } catch (Throwable th) {
        // Workaround for java.lang.NoClassDefFoundError, see https://github.com/greenrobot/EventBus/issues/149
        methods = findState.clazz.getMethods();
        findState.skipSuperClasses = true;
    }
    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) {
                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");
        }
    }
}

在这里主要是使用了Java的反射和对注解的解析。首先通过反射来获取订阅者中所有的方法。并根据方法的类型，参数和注解来找到订阅方法。找到订阅方法后将订阅方法相关信息保存到FindState当中。

当获取到了subscriberMethods数据集，接着开始对subscriberMethods数据集遍历，在订阅方法里进行注册：

 private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
    ////根据传入的响应方法名获取到响应事件(参数类型)
    Class eventType = subscriberMethod.eventType;
      //根据订阅者和订阅方法构造一个订阅事件
    Subscription newSubscription = new Subscription(subscriber, subscriberMethod);
      //获取当前订阅事件中Subscription的List集合
        //通过响应事件作为key,并取得这个事件类型将会响应的全部订阅者
        //没个订阅者至少会订阅一个事件,多个订阅者可能订阅同一个事件(多对多)
        //key:订阅的事件,value:订阅这个事件的所有订阅者集合
    CopyOnWriteArrayList subscriptions = subscriptionsByEventType.get(eventType);
     //该事件对应的Subscription的List集合不存在，则重新创建并保存在subscriptionsByEventType中
    if (subscriptions == null) {
        subscriptions = new CopyOnWriteArrayList<>();
        subscriptionsByEventType.put(eventType, subscriptions);
    } else {
    //订阅者已经注册则抛出EventBusException
        if (subscriptions.contains(newSubscription)) {
            throw new EventBusException("Subscriber " + subscriber.getClass() + " already registered to event "
                    + eventType);
        }
    }
    //遍历订阅事件，找到比subscriptions中订阅事件小的位置，优先级插入到订阅者集合中
    int size = subscriptions.size();
    for (int i = 0; i <= size; i++) {
        if (i == size || subscriberMethod.priority > subscriptions.get(i).subscriberMethod.priority) {
            subscriptions.add(i, newSubscription);
            break;
        }
    }
     //通过订阅者获取该订阅者所订阅事件的集合(当前订阅者订阅了哪些事件)
    List> subscribedEvents = typesBySubscriber.get(subscriber);
    if (subscribedEvents == null) {
        subscribedEvents = new ArrayList<>();
        typesBySubscriber.put(subscriber, subscribedEvents);
    }
      //将当前的订阅事件添加到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();
                //如果eventtype是candidateEventType同一个类或是其子类
                if (eventType.isAssignableFrom(candidateEventType)) {
                    Object stickyEvent = entry.getValue();
                    //调用checkPostStickyEventToSubscription()做一次安全判断，就调用
                    checkPostStickyEventToSubscription(newSubscription, stickyEvent);
                }
            }
        } else {
            Object stickyEvent = stickyEvents.get(eventType);
            checkPostStickyEventToSubscription(newSubscription, stickyEvent);
        }
    }
}

checkPostStickyEventToSubscription()#postToSubscription（...）

private void postToSubscription(...) {
    switch (threadMode) {
        case PostThread:
            //直接调用响应方法
            invokeSubscriber(subscription, event);
            break;
        case MainThread:
            //如果是主线程则直接调用响应事件,否则使用handle去在主线程响应事件
            if (isMainThread) {
                invokeSubscriber(subscription, event);
            } else {
                mainThreadPoster.enqueue(subscription, event);
            }
            break;
            //。。。
    }
}

订阅的代码主要就做了两件事，第一件事是将我们的订阅方法和订阅者封装到subscriptionsByEventType和typesBySubscriber中，subscriptionsByEventType是我们投递订阅事件的时候，就是根据我们的EventType找到我们的订阅事件，从而去分发事件，处理事件的；typesBySubscriber在调用unregister(this)的时候，根据订阅者找到EventType，又根据EventType找到订阅事件，从而对订阅者进行解绑。第二件事，如果是粘性事件的话，就立马投递、执行。

我们就知道了 EventBus 中那几个map的全部含义。同时也回答了上面的第一个问题：为什么如果EventBus.defaultInstance不为null以后程序要抛出异常，就是因为这几个Map集合不同了。Map变了以后，订阅的事件就全部变为另一个EventBus对象的了，就没办法响应之前那个EventBus对象的订阅方法了。

如果不是sticky粘性事件都直接不执行了，还怎么响应。如果是sticky粘性事件，最后是调用checkPostStickyEventToSubscription()做一次安全判断，就调用postToSubscription()发送事件了。这里就关联到了我们之前讲的Poster类的作用了。也回答了上面的第二个问题：三个Poster类的作用，Poster类就是只负责粘滞事件的代码。同时也回答了上面的第三个问题：invokeSubscriber（。。。）什么时候触发的。之前我们不知道subscriberMethod是什么，现在我们能看懂了，就是通过反射调用订阅者类subscriber的订阅方法onEventXXX()，并将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);
    }
}

前面提到注解器为我们生成的索引MyEventBusIndex。索引是在初始化EventBus时通过EventBusBuilder.addIndex(SubscriberInfoIndex index)方法传进来的。下面就说说添加事件总线注释预处理器生成的索引。

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

可以看到，传进来的索引信息会保存在subscriberInfoIndexes这个List中，后续会通过EventBusBuilder传到相应EventBus的SubscriberMethodFinder实例中。我们先来分析SubscriberInfoIndex这个参数：

public interface SubscriberInfoIndex {
    SubscriberInfo getSubscriberInfo(Class subscriberClass);
}

可见索引只需要做一件事情——就是能拿到订阅者的信息。而实现这个接口的类如果我们没有编译过，是找不到的。

EventBus3.X新特性Subscriber Index，在默认属性中有一个属性为ignoreGeneratedIndex，在后面的源码
分析中会介绍到这个属性为true时会使用反射方法获取订阅者的事件处理函数，为false时会使用subscriber Index生成的SubscriberInfo来获取订阅者的事件处理函数，具体内容会在源码分析中介绍
首先，Subscriber Index会在编译期间生成SubscriberInfo，然后在运行时使用SubscriberInfo中保存的事件处理函数处理事件，减少了反射时需要是耗时，会有运行速度上的提升，但是用起来会比较麻烦。

注意事项：只有用注解@Subscriber描述的public方法才能被索引，并且由于Java的特性匿名内部类就算用@Subscriber描述也不能被索引，不过别担心，当EventBus不能使用索引时会自动在运行时使用反射方法获取事件处理函数。

要添加事件处理函数到索引需要借助EventBus的注解处理器，添加EventBus的注解处理器到Module的Gradle文件中：

buildscript {
    dependencies {
        classpath 'com.neenbedankt.gradle.plugins:android-apt:1.8'
    }
}
apply plugin: 'com.neenbedankt.android-apt'
dependencies {
    compile 'org.greenrobot:eventbus:3.0.0'
    apt 'org.greenrobot:eventbus-annotation-processor:3.0.1'
}
apt {
    arguments {
        eventBusIndex "包名.MyEventBusIndex"//生成索引的名称
    }
}

在导入这些库没有问题后，Gradle之后build项目。这个时候就可以初始化EventBus，上面讲过，自定义EventBus的两种方式。

我们可以自定义设置自己的EventBus来为其添加MyEventBusIndex对象。代码如下所示：

EventBus eventBus = EventBus.builder().addIndex(new MyEventBusIndex()).build();

我们也能够将MyEventBusIndex对象安装在默认的EventBus对象当中。代码如下所示：

EventBus.builder().addIndex(new MyEventBusIndex()).installDefaultEventBus();
// Now the default instance uses the given index. Use it like this:
EventBus eventBus = EventBus.getDefault();

如果有多个索引文件还可以使用下面的代码：

EventBus eventBus = EventBus.builder()
    .addIndex(new MyEventBusAppIndex())
    .addIndex(new MyEventBusLibIndex()).build();

顺便说一句，MyEventBusIndex的路径为：项目根目录\build\generated\source\apt\debug\包名\MyEventBusIndex.java

EventBus 事件的发送

一、post方式

在获取到EventBus对象以后，可以通过post方法将给定事件发布到事件总线。

public void post(Object event) {
     //PostingThreadState保存着事件队列和线程状态信息
      PostingThreadState postingState = currentPostingThreadState.get();
     //获取事件队列，并将当前事插入到事件队列中
      List eventQueue = postingState.eventQueue;
      eventQueue.add(event);
      if (!postingState.isPosting) {
          postingState.isMainThread = Looper.getMainLooper() == Looper.myLooper();
          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;
          }
      }
  }
 
 
我们知道，对应的值，是通过post去完成的。这里用ThreadLocal的线程包装类，去完成对应的线程记录和操作
 对应的泛型PostingThreadState对象，记录对应的信息，将对应的线程放入一个List中，通过对应的状态，判断Looper.getMainLooper() == Looper.myLooper() 是否是主线程等操作， 将状态存入PostingThreadState的属性中，遍历容器中的Event，最后通过存储的Subscription中的subscriberMethod的method，反射去invoke调用方法。
 
 
先从PostingThreadState对象中取出事件队列，然后再将当前的事件插入到事件队列当中。如果postingState.isPosting为true说明正在发布，则不做处理。如果不是正在发布，则最后将队列中的事件依次交由postSingleEvent方法进行处理，并移除该事件。这里也涉及到了Handler、looper、ThreadLocal就不进行解答了。
 
 
进入postSingleEvent方法中了解其操作过程：
 
 
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) {
               Log.d(TAG, "No subscribers registered for event " + eventClass);
           }
           if (sendNoSubscriberEvent && eventClass != NoSubscriberEvent.class &&
                   eventClass != SubscriberExceptionEvent.class) {
               post(new NoSubscriberEvent(this, event));
           }
       }
   }

 
 
eventInheritance表示是否向上查找事件的父类,它的默认值为true，可以通过在EventBusBuilder中来进行配置。当eventInheritance为true时，则通过lookupAllEventTypes找到所有的父类事件并存在List中，然后通过postSingleEventForEventType方法对事件逐一处理。
 
 
进入postSingleEventForEventType方法看看是怎么进一步对事件处理：
 
 
private boolean postSingleEventForEventType(Object event, PostingThreadState postingState, Class eventClass) {
      CopyOnWriteArrayList subscriptions;
         //取出该事件对应的Subscription集合
      synchronized (this) {
          subscriptions = subscriptionsByEventType.get(eventClass);
      }
      if (subscriptions != null && !subscriptions.isEmpty()) {
      //将该事件的event和对应的Subscription中的信息（包扩订阅者类和订阅方法）传递给postingState
          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;
  }

 
 
同步取出该事件对应的Subscription集合并遍历该集合将事件event和对应Subscription传递给postingState并调用postToSubscription方法对事件进行处理。
 
 
进一步进入postToSubscription方法，了解内部是怎么处理的：
 
 
private void postToSubscription(Subscription subscription, Object event, boolean isMainThread) {
    switch (subscription.subscriberMethod.threadMode) {
        case POSTING:
            //直接调用响应方式
            invokeSubscriber(subscription, event);
            break;
        case MAIN:
            //如果是主线程则直接调用响应事件,否则使用handle去在主线程响应事件
            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);
    }
}

 
 
首先获取threadMode，即订阅方法运行的线程模式，如果是POSTING，那么直接调用invokeSubscriber()方法即可，如果是MAIN，则要判断当前线程是否是MAIN线程，如果是也是直接调用invokeSubscriber()方法，否则会交给mainThreadPoster来处理，其他情况相类似。举个例子，如果线程模式是MAIN，提交事件的线程是主线程的话则通过反射，直接运行订阅的方法，如果不是主线程，我们需要mainThreadPoster将我们的订阅事件入队列，mainThreadPoster是HandlerPoster类型的继承自Handler，通过Handler将订阅方法切换到主线程执行。
 
 
二、postSticky方式
 
 
粘性事件发布
 
 
/**
 * Posts the given event to the event bus and holds on to the event (because it is sticky). The most recent sticky
 * event of an event's type is kept in memory for future access by subscribers using {@link Subscribe#sticky()}.
 */
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来存放粘性事件，并且从这个put我们可以知道stickyEvents的key是event的Class对象，value是event,然后进行Post流程。我们可以去验证一下，在一个对象如Activity中先调用EventBus.getDefault().postSticky(new MessageEvent(“Hello everyone!”));，再调用EventBus.register，结果如何呢？从结果可以预想在register（更准确的说应该是subscribe）中肯定会有post的调用。带着这个设想，我们继续看subcribe方法，里面就有粘性事件的判断。
 
 
private void subscribe(Object subscriber, SubscriberMethod subscriberMethod) {
     
    。。。。

      //将当前的订阅事件添加到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);
        }
    }
}

 
 
在代码端，接收事件时这样。
 
 
@Subscribe(threadMode = ThreadMode.MAIN)
public void onJump(MsgEvent msg){
    
}

//粘性事件
@Subscribe(threadMode = ThreadMode.MAIN，sticky = true)
public void onJump(MsgEvent msg){
    
}   

 
 
注解@Subscribe
 
 
ThreadMode 是enum（枚举）类型，threadMode默认值是POSTING。ThreadMode有四种模式：
 
 
     
  
  1. POSTING :Subscriber会在post event的所在线程回调，故它不需要切换线程来分发事件，因此开销最小。它要求task完成的要快，不能请求MainThread，适用简单的task。
    2.  
  
  2. MAIN :Subscriber会在主线程（有时候也被叫做UI线程）回调，如果post event所在线程是MainThread,则可直接回调。注意不能阻塞主线程。
    3.  
  
  3. BACKGROUND ：Subscriber会在后台线程中回调。如果post event所在线程不是MainThread，那么可直接回调；如果是MainThread,EventBus会用单例background thread来有序地分发事件。注意不能阻塞background thread。
    4.  
  
  4. ASYNC：当处理事件的Method是耗时的，需要使用此模式。尽量避免同时触发大量的耗时较长的异步操作，EventBus使用线程池高效的复用已经完成异步操作的线程。
    5.  
 
 
 
再回到@Subscribe,还有两个参数，sticky（粘性）默认值是false，如果是true,那么可以通过EventBus的postSticky方法分发最近的粘性事件给该订阅者（前提是该事件可获得）。
 
 
EventBus 取消注册
 
 
public synchronized void unregister(Object subscriber) {
    List> subscribedTypes = typesBySubscriber.get(subscriber);
    if (subscribedTypes != null) {
        for (Class eventType : subscribedTypes) {
            unsubscribeByEventType(subscriber, eventType);
        }
        typesBySubscriber.remove(subscriber);
    } else {
        Log.w(TAG, "Subscriber to unregister was not registered before: " + subscriber.getClass());
    }
}


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

 
 
unsubscribeByEventType方法中获取相应事件中的相应列表删除掉该订阅者。typesBySubscriber我们在订阅者注册的过程中讲到过这个属性，他根据订阅者找到EventType，然后根据EventType和订阅者来得到订阅事件来对订阅者进行解绑。
 
 
对EventBus小结
 
 
弄清楚上面的代码之后，我们一起来梳理一下设计者是如何完成观察者模式中的订阅和发送事件以及取消订阅。
 
 
     
  
  • 我们先看subscriber。看到注册方法register(Object subscriber)，传入的就是一个Objec对象。一个subscriber可以订阅多个类型的Event，而且对于同一种类型的Event可以有多个method进行处理（尽管我们一般不会这样做）。
    •  
  
  • 在subscribe方法中，引入Subscription对subscriber、event进行了封装。经过判断之后，把“合格”的subscription加入subscriptionsByEventType中。
    •  
  
  • 当我们分发事件时，也就是post(Object event)时，他会间接调用postSingleEventForEventType这个方法，通过传入的参数event，在subscriptionsByEventType找到event对应的value，再继续相应的操作。
    •  
  
  • 我们取消一个subscriber的订阅是，也就是unregister(Object subscriber).我们会在typesBySubscriber中找到该subsriber对应的evnt。然后再由此event去subscriptionsByEventType找到一系列的subscription，并把他们remove。
    •  
  
  • EventBus订阅了，post发布了事件，就会触发invokeSubscriber（）方法，订阅者类subscriber的订阅方法onEventXXX()，并将event作为参数传递进去。即调用subscription.subscriberMethod.method.invoke(subscription.subscriber, event)方法去响应。那么订阅者类就会收到信息
    •  
 
 

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(小点知识——观察者模式，由浅谈到理解)

        

            

                
    
                    
  • element实现动态路由+面包屑
                        软件技术NINI
vue案例vue.js前端
                        
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
    
                    
    • 
                    
  • 理解Gunicorn：Python WSGI服务器的基石
                        范范0825
ipythonlinux运维
                        
    理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
    
                    
    • 
                    
  • 学点心理知识，呵护孩子健康
                        静候花开_7090

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

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

                        
    结核病是艾滋病合并其他疾病中导致患者死亡的主要原因。其中结核病由结核分枝杆菌（Mycobacteriumtuberculosis,Mtb）感染引起，获得性免疫缺陷综合症（艾滋病）由人免疫缺陷病毒（Humanimmunodeficiencyvirustype1,HIV-1）感染引起。国家感染性疾病临床医学研究中心/深圳市第三人民医院张国良团队携手深圳华大生命科学研究院吴靓团队，共同研究得出单细胞测序
    
                    
    • 
                    
  • 绘本讲师训练营【24期】8/21阅读原创《独生小孩》
                        1784e22615e0

                        
    24016-孟娟《独生小孩》图片发自App今天我想分享一个蛮特别的绘本，讲的是一个特殊的群体，我也是属于这个群体，80后的独生小孩。这是一本中国绘本，作者郭婧，也是一个80厚。全书一百多页，均为铅笔绘制，虽然为黑白色调，但并不显得沉闷。全书没有文字，犹如“默片”，但并不影响读者对该作品的理解，反而显得神秘，梦幻，給读者留下想象的空间。作者在前蝴蝶页这样写到：“我更希望父母和孩子一起分享这本书，使他
    
                    
    • 
                    
  • 我校举行新老教师师徒结对仪式暨名师专业工作室工作交流活动
                        李蕾1229

                        
    为促进我校教师专业发展，发挥骨干教师的引领带头作用，11月6日下午，我校举行新老教师师徒结对仪式暨名师专业工作室工作交流活动。图片发自App会议由教师发展处李蕾主任主持，首先，由范校长宣读新老教师结对名单及双方承担职责。随后，两位新调入教师陈玉萍、莫正杰分别和他们的师傅鲍元美、刘召彬老师签订了师徒结对协议书。图片发自App图片发自App师徒拥抱、握手。有了师傅就有了目标有了方向，相信两位新教师在师
    
                    
    • 
                    
  • 每日一题——第八十四题
                        互联网打工人no1
C语言程序设计每日一练c语言
                        
    题目：编写函数1、输入10个职工的姓名和职工号2、按照职工由大到小顺序排列，姓名顺序也随之调整3、要求输入一个职工号，用折半查找法找出该职工的姓名#define_CRT_SECURE_NO_WARNINGS#include#include#defineMAX_EMPLOYEES10typedefstruct{intid;charname[50];}Empolyee;voidinputEmploye
    
                    
    • 
                    
  • 从鸡肉高汤到记忆的魔法再到有效提示的艺术
                        步子哥
人工智能
                        
    还记得小时候那些天马行空的白日梦吗？也许只要按下键盘上的某个神奇组合，电脑就会发出滴滴的声响，一个隐藏的世界突然在你眼前展开，让你获得超凡的能力，摆脱平凡的生活。这听起来像是玩过太多电子游戏的幻想，但实际上，间隔重复系统给人的感觉惊人地相似。在最佳状态下，这些系统就像魔法一样神奇。本文将以一个看似平凡的鸡肉高汤食谱为例，深入浅出地探讨如何编写有效的间隔重复提示，让你像掌握烹饪技巧一样轻松地掌握记忆
    
                    
    • 
                    
  • linux中sdl的使用教程,sdl使用入门
                        Melissa Corvinus
linux中sdl的使用教程
                        
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
    
                    
    • 
                    
  • LLM 词汇表
                        落难Coder
LLMsNLP大语言模型大模型llama人工智能
                        
    Contextwindow“上下文窗口”是指语言模型在生成新文本时能够回溯和参考的文本量。这不同于语言模型训练时所使用的大量数据集，而是代表了模型的“工作记忆”。较大的上下文窗口可以让模型理解和响应更复杂和更长的提示，而较小的上下文窗口可能会限制模型处理较长提示或在长时间对话中保持连贯性的能力。Fine-tuning微调是使用额外的数据进一步训练预训练语言模型的过程。这使得模型开始表示和模仿微调数
    
                    
    • 
                    
  • 509. 斐波那契数(每日一题)
                        lzyprime

                        
    lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
    
                    
    • 
                    
  • 高端密码学院笔记285
                        柚子_b4b4

                        
    高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
    
                    
    • 
                    
  • 从0到500+，我是如何利用自媒体赚钱？
                        一列脚印

                        
    运营公众号半个多月，从零基础的小白到现在慢慢懂了一些运营的知识。做好公众号是很不容易的，要做很多事情；排版、码字、引流…通通需要自己解决，业余时间全都花费在这上面涨这么多粉丝是真的不容易，对比知乎大佬来说，我们这种没资源，没人脉，还没钱的小透明来说，想要一个月涨粉上万，怕是今天没睡醒（不过你有的方法，算我piapia打脸）至少我是清醒的，自己慢慢努力，实现我的万粉目标！大家快来围观、支持我吧！孩子
    
                    
    • 
                    
  • 使用Faiss进行高效相似度搜索
                        llzwxh888
faisspython
                        
    在现代AI应用中，快速和高效的相似度搜索是至关重要的。Faiss（FacebookAISimilaritySearch）是一个专门用于快速相似度搜索和聚类的库，特别适用于高维向量。本文将介绍如何使用Faiss来进行相似度搜索，并结合Python代码演示其基本用法。什么是Faiss？Faiss是一个由FacebookAIResearch团队开发的开源库，主要用于高维向量的相似性搜索和聚类。Faiss
    
                    
    • 
                    
  • 深入理解 MultiQueryRetriever：提升向量数据库检索效果的强大工具
                        nseejrukjhad
数据库python
                        
    深入理解MultiQueryRetriever：提升向量数据库检索效果的强大工具引言在人工智能和自然语言处理领域，高效准确的信息检索一直是一个关键挑战。传统的基于距离的向量数据库检索方法虽然广泛应用，但仍存在一些局限性。本文将介绍一种创新的解决方案：MultiQueryRetriever，它通过自动生成多个查询视角来增强检索效果，提高结果的相关性和多样性。MultiQueryRetriever的工
    
                    
    • 
                    
  • 利用LangChain的StackExchange组件实现智能问答系统
                        nseejrukjhad
langchainmicrosoft数据库python
                        
    利用LangChain的StackExchange组件实现智能问答系统引言在当今的软件开发世界中，StackOverflow已经成为程序员解决问题的首选平台之一。而LangChain作为一个强大的AI应用开发框架，提供了StackExchange组件，使我们能够轻松地将StackOverflow的海量知识库集成到我们的应用中。本文将详细介绍如何使用LangChain的StackExchange组件
    
                    
    • 
                    
  • 东南林氏之九牧林候选父系
                        祖缘树TheYtree

                        
    渊源介绍东晋初年晋安林始祖林禄公入闽，传十世隋右丞林茂，由晋安迁居莆田北螺村。又五世而至林万宠，唐开元间任高平太守，生三子：韬、披、昌。韬公之孙攒，唐德宗立双阙以旌表其孝，时号"阙下林家"。昌公字茂吉，乃万宠公第三子，官兵部司马，配宋氏，生一子名萍。萍于唐贞元间明经及第，官沣洲司马(后追赠中宪大夫)。唐太和年间归隐后，迁居仙游游洋，世称“游洋林”；其后裔居游洋后迁移漳州漳浦路下，由路下林第四房平和
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • Day1笔记-Python简介&标识符和关键字&输入输出
                        ~在杰难逃~
Pythonpython开发语言大数据数据分析数据挖掘
                        
    大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
    
                    
    • 
                    
  • 读书||陶新华《教育中的积极心理学》1—28
                        流水淙淙2022

                        
    读一本好书，尤如和一位高尚者对话，亦能对人的精神进行洗礼。但是若不能和实践结合起来，也只能落到空读书的状态。读书摘要与感想1、塞利格曼在《持续的幸福》一书中提出了幸福2.0理论，提出幸福由5个元素决定——积极情绪、投入的工作和生活、目标和意义、和谐的人际关系、成就感。2、人的大脑皮层在进行智力活动时，都伴有皮下中枢活动，对这些活动进行体验请假，并由此产生了情感解读。人的情绪情感体验总是优先于大脑的
    
                    
    • 
                    
  • MongoDB Oplog 窗口
                        喝醉酒的小白
MongoDB运维
                        
    在MongoDB中，oplog（操作日志）是一个特殊的日志系统，用于记录对数据库的所有写操作。oplog允许副本集成员（通常是从节点）应用主节点上已经执行的操作，从而保持数据的一致性。它是MongoDB副本集实现数据复制的基础。MongoDBOplog窗口oplog窗口是指在MongoDB副本集中，从节点可以用来同步数据的时间范围。这个窗口通常由以下因素决定：Oplog大小：oplog的大小是有限
    
                    
    • 
                    
  • 走向以教育叙事为载体的教育叙事研究
                        666小飞鱼

                        
    今天我读了吴松超老师的《给教师的68条建写作建议》中的第23条《如何通过教育叙事走向研究》，吴老师在文中与我们分享了一个德育案例，这是一个反面的案例，意在告知我们在处理问题时，不能就考虑的点太窄，思考要全面。走向教育叙事研究，教师要有敏锐的“感知力”，这个感知力来自于背后专业知识的支撑，思维能力以及广阔的视野和见识等。所以对于同一件事处理方法不同，这个就是教师背后“敏锐力”的不同造成的，也就是说是
    
                    
    • 
                    
  • Faiss Tips：高效向量搜索与聚类的利器
                        焦习娜Samantha

                        
    FaissTips：高效向量搜索与聚类的利器faiss_tipsSomeusefultipsforfaiss项目地址:https://gitcode.com/gh_mirrors/fa/faiss_tips项目介绍Faiss是由FacebookAIResearch开发的一个用于高效相似性搜索和密集向量聚类的库。它支持多种硬件平台，包括CPU和GPU，能够在海量数据集上实现快速的近似最近邻搜索（AN
    
                    
    • 
                    
  • 如何成为段子手
                        欣雅阅读

                        
    我是一个尬聊大师，与朋友聊天经常把话题聊死，留我一个人在群里，望着自己打下的最后一句话无语凝噎。看到风趣幽默的朋友与人聊天，很是艳羡，觉得自己何时才能成为这样的段子手呢？一、段子是什么？“段子”一词在百度百科上的解释：本是相声中的一个艺术术语，指的是相声作品中一节或一段艺术内容。我的理解：段子就是一些搞笑的故事或者笑话。二、为什么要会说段子？不知道大家有没有这样的朋友，本来很无趣的聚会，只要有他参
    
                    
    • 
                    
  • 回溯算法-重新安排行程
                        chirou_
算法数据结构图论c++图搜索
                        
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
    
                    
    • 
                    
  • 赠晶晶
                        在平凡中重新出发

                        
    逐伊衫望伊泪伊人雨中别离去莫再想莫再追莫要寸断再回味十六年六十年弹指挥间青鬓颜且浅行且珍惜待到山花烂漫时图片发自App
    
                    
    • 
                    
  • 数据仓库——维度表一致性
                        墨染丶eye
背诵数据仓库
                        
    数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
    
                    
    • 
                    
  • 自我意识
                        徐立华

                        
    ----读帕克.帕尔默《教学勇气》（P18----19）5.铸造我们的学科帕克.帕尔默说学科知识对我们的自身认同和外部世界有启发意义。学科会铸造我们。“在我们与学科的命题概念和学科的生活框架相遇之前，自我意识知识处于潜伏状态，通过回想学科是怎样唤醒自我意识，我们就可以找回教学心灵。”《教学勇气》（P18）我们的自我意识像冰山表面下无限延伸的冰层，常常处于潜伏状态。但是在我们对所教授的学科进行深入思
    
                    
    • 
                                
  • windows下源码安装golang
                                    616050468
golang安装golang环境windows
                                    
             系统： 64位win7， 开发环境：sublime text 2，  go版本： 1.4.1 
  
 1.  安装前准备(gcc, gdb, git) 
       golang在64位系
    
                                
    • 
                                
  • redis批量删除带空格的key
                                    bylijinnan
redis
                                    
    redis批量删除的通常做法： 
 
 
redis-cli keys "blacklist*" | xargs redis-cli del 
 
上面的命令在key的前后没有空格时是可以的，但有空格就不行了： 
 

$redis-cli keys "blacklist*"
1) "blacklist:12: [email protected]
    
                                
    • 
                                
  • oracle正则表达式的用法
                                    0624chenhong
oracle正则表达式
                                    
      方括号表达示 
方括号表达式 
描述 
[[:alnum:]] 
字母和数字混合的字符 
[[:alpha:]] 
字母字符 
[[:cntrl:]] 
控制字符 
[[:digit:]] 
数字字符 
[[:graph:]] 
图像字符 
[[:lower:]] 
小写字母字符 
[[:print:]] 
打印字符 
[[:punct：]] 
标点符号字符 
[[:space:]]
    
                                
    • 
                                
  • 2048源码(核心算法有，缺少几个anctionbar，以后补上)
                                    不懂事的小屁孩
2048
                                    
    2048游戏基本上有四部分组成， 
1：主activity，包含游戏块的16个方格，上面统计分数的模块 
2：底下的gridview，监听上下左右的滑动，进行事件处理， 
3：每一个卡片，里面的内容很简单，只有一个text，记录显示的数字 
4：Actionbar，是游戏用重新开始，设置等功能(这个在底下可以下载的代码里面还没有实现) 
 
写代码的流程 
1：设计游戏的布局，基本是两块，上面是分
    
                                
    • 
                                
  • jquery内部链式调用机理
                                    换个号韩国红果果
JavaScriptjquery
                                    
    只需要在调用该对象合适(比如下列的setStyles)的方法后让该方法返回该对象（通过this  因为一旦一个函数称为一个对象方法的话那么在这个方法内部this（结合下面的setStyles）指向这个对象） 

function  create(type){
var element=document.createElement(type);
    //this=element;

    
                                
    • 
                                
  • 你订酒店时的每一次点击 背后都是NoSQL和云计算
                                    蓝儿唯美
NoSQL
                                    
    全球最大的在线旅游公司Expedia旗下的酒店预订公司，它运营着89个网站，跨越68个国家，三年前开始实验公有云，以求让客户在预订网站上查询假期酒店时得到更快的信息获取体验。 
云端本身是用于驱动网站的部分小功能的，如搜索框的自动推荐功能，还能保证处理Hotels.com服务的季节性需求高峰整体储能。 
Hotels.com的首席技术官Thierry Bedos上个月在伦敦参加“2015 Clou
    
                                
    • 
                                
  • java笔记1
                                    a-john
java
                                    
    1，面向对象程序设计（Object-oriented Propramming，OOP）：java就是一种面向对象程序设计。 
2，对象：我们将问题空间中的元素及其在解空间中的表示称为“对象”。简单来说，对象是某个类型的实例。比如狗是一个类型，哈士奇可以是狗的一个实例，也就是对象。 
3，面向对象程序设计方式的特性： 
    3.1 万物皆为对象。 
   
    
                                
    • 
                                
  • C语言 sizeof和strlen之间的那些事 C/C++软件开发求职面试题 必备考点（一）
                                    aijuans
C/C++求职面试必备考点
                                    
            找工作在即，以后决定每天至少写一个知识点，主要是记录，逼迫自己动手、总结加深印象。当然如果能有一言半语让他人收益，后学幸运之至也。如有错误，还希望大家帮忙指出来。感激不尽。 
       后学保证每个写出来的结果都是自己在电脑上亲自跑过的，咱人笨，以前学的也半吊子。很多时候只能靠运行出来的结果再反过来
    
                                
    • 
                                
  • 程序员写代码时就不要管需求了吗？
                                    asia007
程序员不能一味跟需求走
                                    
          编程也有2年了，刚开始不懂的什么都跟需求走，需求是怎样就用代码实现就行，也不管这个需求是否合理，是否为较好的用户体验。当然刚开始编程都会这样，但是如果有了2年以上的工作经验的程序员只知道一味写代码，而不在写的过程中思考一下这个需求是否合理，那么，我想这个程序员就只能一辈写敲敲代码了。 
      我的技术不是很好，但是就不代
    
                                
    • 
                                
  • Activity的四种启动模式
                                    百合不是茶
android栈模式启动Activity的标准模式启动栈顶模式启动单例模式启动
                                    
    android界面的操作就是很多个activity之间的切换,启动模式决定启动的activity的生命周期 ; 
  
启动模式xml中配置 
    <activity android:name=".MainActivity" android:launchMode="standard&quo
    
                                
    • 
                                
  • Spring中@Autowired标签与@Resource标签的区别
                                    bijian1013
javaspring@Resource@Autowired@Qualifier
                                    
    Spring不但支持自己定义的@Autowired注解，还支持由JSR-250规范定义的几个注解，如：@Resource、 @PostConstruct及@PreDestroy。 
  
1. @Autowired    @Autowired是Spring 提供的，需导入    Package:org.springframewo
    
                                
    • 
                                
  • Changes Between SOAP 1.1 and SOAP 1.2
                                    sunjing
ChangesEnableSOAP 1.1SOAP 1.2
                                    
    JAX-WS 
SOAP Version 1.2 Part 0: Primer (Second Edition) 
SOAP Version 1.2 Part 1: Messaging Framework (Second Edition) 
SOAP Version 1.2 Part 2: Adjuncts (Second Edition) 
  
Which style of WSDL
    
                                
    • 
                                
  • 【Hadoop二】Hadoop常用命令
                                    bit1129
hadoop
                                    
    以Hadoop运行Hadoop自带的wordcount为例， 
  
hadoop脚本位于/home/hadoop/hadoop-2.5.2/bin/hadoop，需要说明的是，这些命令的使用必须在Hadoop已经运行的情况下才能执行 
  Hadoop HDFS相关命令 
 
  hadoop fs -ls 
 
 列出HDFS文件系统的第一级文件和第一级
    
                                
    • 
                                
  • java异常处理（初级）
                                    白糖_
javaDAOspring虚拟机Ajax
                                    
    从学习到现在从事java开发一年多了，个人觉得对java只了解皮毛，很多东西都是用到再去慢慢学习，编程真的是一项艺术，要完成一段好的代码，需要懂得很多。 
最近项目经理让我负责一个组件开发，框架都由自己搭建，最让我头疼的是异常处理，我看了一些网上的源码，发现他们对异常的处理不是很重视，研究了很久都没有找到很好的解决方案。后来有幸看到一个200W美元的项目部分源码，通过他们对异常处理的解决方案，我终
    
                                
    • 
                                
  • 记录整理-工作问题
                                    braveCS
工作
                                    
    1）那位同学还是CSV文件默认Excel打开看不到全部结果。以为是没写进去。同学甲说文件应该不分大小。后来log一下原来是有写进去。只是Excel有行数限制。那位同学进步好快啊。 
2）今天同学说写文件的时候提示jvm的内存溢出。我马上反应说那就改一下jvm的内存大小。同学说改用分批处理了。果然想问题还是有局限性。改jvm内存大小只能暂时地解决问题，以后要是写更大的文件还是得改内存。想问题要长远啊
    
                                
    • 
                                
  • org.apache.tools.zip实现文件的压缩和解压，支持中文
                                    bylijinnan
apache
                                    
    刚开始用java.util.Zip，发现不支持中文（网上有修改的方法，但比较麻烦） 
后改用org.apache.tools.zip 
org.apache.tools.zip的使用网上有更简单的例子 
下面的程序根据实际需求，实现了压缩指定目录下指定文件的方法 
 



import java.io.BufferedReader;
import java.io.BufferedWrit
    
                                
    • 
                                
  • 读书笔记-4
                                    chengxuyuancsdn
读书笔记
                                    
    1、JSTL 核心标签库标签 
2、避免SQL注入 
3、字符串逆转方法 
4、字符串比较compareTo 
5、字符串替换replace 
6、分拆字符串 
 
 
1、JSTL 核心标签库标签共有13个，
学习资料：http://www.cnblogs.com/lihuiyy/archive/2012/02/24/2366806.html
功能上分为4类：
(1)表达式控制标签：out
    
                                
    • 
                                
  • [物理与电子]半导体教材的一个小问题
                                    comsci
问题
                                    
     
 
      各种模拟电子和数字电子教材中都有这个词汇-空穴 
 
      书中对这个词汇的解释是; 当电子脱离共价键的束缚成为自由电子之后,共价键中就留下一个空位,这个空位叫做空穴 
 
      我现在回过头翻大学时候的教材,觉得这个
    
                                
    • 
                                
  • Flashback Database --闪回数据库
                                    daizj
oracle闪回数据库
                                    
    Flashback 技术是以Undo segment中的内容为基础的， 因此受限于UNDO_RETENTON参数。要使用flashback 的特性，必须启用自动撤销管理表空间。 
在Oracle 10g中， Flash back家族分为以下成员： Flashback Database， Flashback Drop，Flashback Query(分Flashback Query,Flashbac
    
                                
    • 
                                
  • 简单排序:插入排序
                                    dieslrae
插入排序
                                    
    
    public void insertSort(int[] array){
        int temp;
        
        for(int i=1;i<array.length;i++){
            temp = array[i];
            
            for(int k=i-1;k>=0;k--)
    
                                
    • 
                                
  • C语言学习六指针小示例、一维数组名含义，定义一个函数输出数组的内容
                                    dcj3sjt126com
c
                                    
    # include <stdio.h>

int main(void)
{
	int * p; //等价于 int *p 也等价于 int* p;
	int i = 5;
	char ch = 'A';

	//p = 5;	//error
	//p = &ch;	//error
	//p = ch;	//error

	p = &i;		// 
    
                                
    • 
                                
  • centos下php redis扩展的安装配置3种方法
                                    dcj3sjt126com
redis
                                    
    方法一 
1.下载php redis扩展包     代码如下 复制代码    
#wget http://redis.googlecode.com/files/redis-2.4.4.tar.gz     
2 tar -zxvf 解压压缩包，cd /扩展包 （进入扩展包然后 运行phpize 一下是我环境中phpize的目录，/usr/local/php/bin/phpize (一定要
    
                                
    • 
                                
  • 线程池(Executors)
                                    shuizhaosi888
线程池
                                    
    在java类库中，任务执行的主要抽象不是Thread，而是Executor，将任务的提交过程和执行过程解耦 
	public interface Executor {

	    void execute(Runnable command);
	}
 
  
public class RunMain implements Executor{

	@Override
	pub
    
                                
    • 
                                
  • openstack 快速安装笔记
                                    haoningabc
openstack
                                    
    前提是要配置好yum源 
版本icehouse，操作系统redhat6.5 
最简化安装，不要cinder和swift 
三个节点 
172 control节点keystone glance horizon 
173 compute节点nova 
173 network节点neutron 
 

control
/etc/sysctl.conf

net.ipv4.ip_forward =
    
                                
    • 
                                
  • 从c面向对象的实现理解c++的对象（二）
                                    jimmee
C++面向对象虚函数
                                    
    1. 类就可以看作一个struct，类的方法，可以理解为通过函数指针的方式实现的，类对象分配内存时，只分配成员变量的，函数指针并不需要分配额外的内存保存地址。 
2. c++中类的构造函数，就是进行内存分配(malloc)，调用构造函数 
3. c++中类的析构函数，就时回收内存(free) 
4. c++是基于栈和全局数据分配内存的，如果是一个方法内创建的对象，就直接在栈上分配内存了。 
专门在
    
                                
    • 
                                
  • 如何让那个一个div可以拖动
                                    lingfeng520240
html
                                    
    
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml
    
                                
    • 
                                
  • 第10章 高级事件（中）
                                    onestopweb
事件
                                    
    index.html 
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/
    
                                
    • 
                                
  • 计算两个经纬度之间的距离
                                    roadrunners
计算纬度LBS经度距离
                                    
    要解决这个问题的时候，到网上查了很多方案，最后计算出来的都与百度计算出来的有出入。下面这个公式计算出来的距离和百度计算出来的距离是一致的。 
	/**
	 * 
	 * @param longitudeA
	 *            经度A点
	 * @param latitudeA
	 *            纬度A点
	 * @param longitudeB
	 *    
    
                                
    • 
                                
  • 最具争议的10个Java话题
                                    tomcat_oracle
java
                                    
    1、Java8已经到来。什么！？ Java8 支持lambda。哇哦，RIP Scala！   　　随着Java8 的发布，出现很多关于新发布的Java8是否有潜力干掉Scala的争论，最终的结论是远远没有那么简单。Java8可能已经在Scala的lambda的包围中突围，但Java并非是函数式编程王位的真正觊觎者。   　 
　2、Java 9 即将到来   　　 
Oracle早在8月份就发布
    
                                
    • 
                                
  • zoj 3826 Hierarchical Notation(模拟)
                                    阿尔萨斯
rar
                                    
     题目链接：zoj 3826 Hierarchical Notation 
 题目大意：给定一些结构体，结构体有value值和key值，Q次询问，输出每个key值对应的value值。 
 解题思路：思路很简单，写个类词法的递归函数，每次将key值映射成一个hash值，用map映射每个key的value起始终止位置，预处理完了查询就很简单了。 这题是最后10分钟出的，因为没有考虑value为{}的情
    
                                
    •