观察者模式：顾名思义，就是众多观察者（observers）对被观察者（observable）的状态、行为等进行监听，
当被观察者（observable）的状态、行为等发生改变后，向观察者（observers）发出通知，告知观察者（observers），
观察者可以对这些通知进行处理或者不处理。
举个例子：
比如在上课的时候，老师可以看成一个被观察者（observable），所有学生可以看成观察者（observers）。
老师（observable）喊上课之后，所有同学（observers）的注意力都集中在老师身上，这时候相当于给被观察者（observable）添加了许多观察者（observers）;
被观察者（老师）（observable）的一言一行都会通过光或者声音反馈给到同学们（observers），当然同学们（observers）对
老师（observable）的言行可能有所反应或者不做任何响应。比如在看到老师（observable）走过来的时候，没认真听讲的同学（observers）赶紧坐好，集中注意（响应），认真听讲的同学（observers）则可以不做反应。
当然在收到老师（observable）【放学】的通知后，同学们都背起书包回家，即都响应了。
从上面例子可以看出，观察者（observers）一定要有接收被观察者（observable）通知的能力；
被观察者（observable）一定要有增加观察者（observers）的和通知观察者（observers）的能力；
那么我们可以将这些能力抽象出来，让具体的实现必须实现这些能力，然后添加观察者（observers）的时候
只关心他有没有接收通知的能力（即是否是抽象观察者类observers的实现类）。至此，以及结合高内聚低耦合的思想，我们可以看到，
观察者模式有4个必要元素：
1.观察者抽象类
2.观察者具体实现类
3.被观察者抽象类
4.被观察者具体实现类
下面来具体实现以下：
观察者抽象类:
public abstract class Observerabstract {
/**
* 必须有接收通知的能力
* @param msg
*/
abstract void update(String msg);
}观察者具体实现类:
public class MyObserver extends Observerabstract {
//传入名称，区分不同的观察者
private String name;
public MyObserver(String name) {
this.name = name;
}
@Override
public void update(String msg) {
System.out.print(String.format("%s 收到了新消息: %s \n",name,msg));
// System.out.print(name+ "收到特急书信: "+msg);
// Log.i("魔教求助信",name+ "收到特急书信: "+msg);
}
}被观察者抽象类:
public abstract class Observableabstract {
/**
* 增加观察者
* @param observer 观察者实例对象
*/
abstract void add(Observerabstract observer);
/**
* 移除观察者
* @param observer 需要移除的观察者对象
*/
abstract void move(Observerabstract observer);
/**
* 数据变更是通知观察者
*/
abstract void notifyObserver();
}被观察者具体实现类:
public class MyObservable extends Observableabstract {
//保存有多少个观察者要对此被观察者进行观察
private List<Observerabstract> observerList;
private String message;
public MyObservable() {
observerList = new ArrayList<>();
}
@Override
public void add(Observerabstract observer) {
observerList.add(observer);
}
@Override
public void move(Observerabstract observer) {
observerList.remove(observer);
}
@Override
public void notifyObserver() {
for (Observerabstract observer:observerList){
observer.update(message);
}
}
public void setMessage(String message) {
this.message = message;
notifyObserver();
}
}再来看看咱们recycleview的adapter中的源码
观察者抽象类:
/**
* Observer base class for watching changes to an {@link Adapter}.
* See {@link Adapter#registerAdapterDataObserver(AdapterDataObserver)}.
*/
public abstract static class AdapterDataObserver {
public void onChanged() {
// Do nothing
}
public void onItemRangeChanged(int positionStart, int itemCount) {
// do nothing
}
public void onItemRangeChanged(int positionStart, int itemCount, @Nullable Object payload) {
// fallback to onItemRangeChanged(positionStart, itemCount) if app
// does not override this method.
onItemRangeChanged(positionStart, itemCount);
}
public void onItemRangeInserted(int positionStart, int itemCount) {
// do nothing
}
public void onItemRangeRemoved(int positionStart, int itemCount) {
// do nothing
}
public void onItemRangeMoved(int fromPosition, int toPosition, int itemCount) {
// do nothing
}
}观察者具体实现类:
private class RecyclerViewDataObserver extends AdapterDataObserver {
RecyclerViewDataObserver() {
}
@Override
public void onChanged() {
assertNotInLayoutOrScroll(null);
mState.mStructureChanged = true;
processDataSetCompletelyChanged(true);
if (!mAdapterHelper.hasPendingUpdates()) {
requestLayout();
}
}
@Override
public void onItemRangeChanged(int positionStart, int itemCount, Object payload) {
assertNotInLayoutOrScroll(null);
if (mAdapterHelper.onItemRangeChanged(positionStart, itemCount, payload)) {
triggerUpdateProcessor();
}
}
@Override
public void onItemRangeInserted(int positionStart, int itemCount) {
assertNotInLayoutOrScroll(null);
if (mAdapterHelper.onItemRangeInserted(positionStart, itemCount)) {
triggerUpdateProcessor();
}
}
@Override
public void onItemRangeRemoved(int positionStart, int itemCount) {
assertNotInLayoutOrScroll(null);
if (mAdapterHelper.onItemRangeRemoved(positionStart, itemCount)) {
triggerUpdateProcessor();
}
}
@Override
public void onItemRangeMoved(int fromPosition, int toPosition, int itemCount) {
assertNotInLayoutOrScroll(null);
if (mAdapterHelper.onItemRangeMoved(fromPosition, toPosition, itemCount)) {
triggerUpdateProcessor();
}
}
void triggerUpdateProcessor() {
if (POST_UPDATES_ON_ANIMATION && mHasFixedSize && mIsAttached) {
ViewCompat.postOnAnimation(RecyclerView.this, mUpdateChildViewsRunnable);
} else {
mAdapterUpdateDuringMeasure = true;
requestLayout();
}
}
}被观察者抽象类:
/**
* Provides methods for registering or unregistering arbitrary observers in an {@link ArrayList}.
*
* This abstract class is intended to be subclassed and specialized to maintain
* a registry of observers of specific types and dispatch notifications to them.
*
* @param T The observer type.
*/
public abstract class Observable<T> {
/**
* The list of observers. An observer can be in the list at most
* once and will never be null.
*/
protected final ArrayList<T> mObservers = new ArrayList<T>();
/**
* Adds an observer to the list. The observer cannot be null and it must not already
* be registered.
* @param observer the observer to register
* @throws IllegalArgumentException the observer is null
* @throws IllegalStateException the observer is already registered
*/
public void registerObserver(T observer) {
if (observer == null) {
throw new IllegalArgumentException("The observer is null.");
}
synchronized(mObservers) {
if (mObservers.contains(observer)) {
throw new IllegalStateException("Observer " + observer + " is already registered.");
}
mObservers.add(observer);
}
}
/**
* Removes a previously registered observer. The observer must not be null and it
* must already have been registered.
* @param observer the observer to unregister
* @throws IllegalArgumentException the observer is null
* @throws IllegalStateException the observer is not yet registered
*/
public void unregisterObserver(T observer) {
if (observer == null) {
throw new IllegalArgumentException("The observer is null.");
}
synchronized(mObservers) {
int index = mObservers.indexOf(observer);
if (index == -1) {
throw new IllegalStateException("Observer " + observer + " was not registered.");
}
mObservers.remove(index);
}
}
/**
* Remove all registered observers.
*/
public void unregisterAll() {
synchronized(mObservers) {
mObservers.clear();
}
}
}被观察者具体实现类:
static class AdapterDataObservable extends Observable<AdapterDataObserver> {
public boolean hasObservers() {
return !mObservers.isEmpty();
}
public void notifyChanged() {
// since onChanged() is implemented by the app, it could do anything, including
// removing itself from {@link mObservers} - and that could cause problems if
// an iterator is used on the ArrayList {@link mObservers}.
// to avoid such problems, just march thru the list in the reverse order.
for (int i = mObservers.size() - 1; i >= 0; i--) {
mObservers.get(i).onChanged();
}
}
public void notifyItemRangeChanged(int positionStart, int itemCount) {
notifyItemRangeChanged(positionStart, itemCount, null);
}
public void notifyItemRangeChanged(int positionStart, int itemCount,
@Nullable Object payload) {
// since onItemRangeChanged() is implemented by the app, it could do anything, including
// removing itself from {@link mObservers} - and that could cause problems if
// an iterator is used on the ArrayList {@link mObservers}.
// to avoid such problems, just march thru the list in the reverse order.
for (int i = mObservers.size() - 1; i >= 0; i--) {
mObservers.get(i).onItemRangeChanged(positionStart, itemCount, payload);
}
}
public void notifyItemRangeInserted(int positionStart, int itemCount) {
// since onItemRangeInserted() is implemented by the app, it could do anything,
// including removing itself from {@link mObservers} - and that could cause problems if
// an iterator is used on the ArrayList {@link mObservers}.
// to avoid such problems, just march thru the list in the reverse order.
for (int i = mObservers.size() - 1; i >= 0; i--) {
mObservers.get(i).onItemRangeInserted(positionStart, itemCount);
}
}
public void notifyItemRangeRemoved(int positionStart, int itemCount) {
// since onItemRangeRemoved() is implemented by the app, it could do anything, including
// removing itself from {@link mObservers} - and that could cause problems if
// an iterator is used on the ArrayList {@link mObservers}.
// to avoid such problems, just march thru the list in the reverse order.
for (int i = mObservers.size() - 1; i >= 0; i--) {
mObservers.get(i).onItemRangeRemoved(positionStart, itemCount);
}
}
public void notifyItemMoved(int fromPosition, int toPosition) {
for (int i = mObservers.size() - 1; i >= 0; i--) {
mObservers.get(i).onItemRangeMoved(fromPosition, toPosition, 1);
}
}
}很像吧，还有很多地方都用的观察者模式呢，比如jetpack里面！
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
