设计模式（五）RecyclerView中的观察者模式
1、基本概念
一、定义：
定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，全部依赖于它的对象都能获得通知并被自动更新。 例如：天气预报服务，一旦你订阅该服务，，天天一旦有天气信息更新，它就会及时向你发送最新的天气信息。java
二、使用场景
- 关联行为场景
- 时间多级触发场景
三、结构图
- Subject：抽象被观察者，会将全部观察者对象保存到一个集合中，提供方法来添加和删除观察者。
- ConcreteSubject：具体被观察者，如自身发生改变，给全部注册过的观察者发通知。
- Observer：抽象观察者，定义更新接口，若是接受到被观察者的通知后，自身进行更新。
- ConcreteObserver：具体观察者，实现抽象观察者锁定义的更新接口
2、相关实例
定义天气做为被观察者，若是天气更新，观察者进行数据更新bash
一、Subject
/**
* 被观察者接口
*/
public interface Subject {
//注册观察者
void registObserver(Observer observer);
//取消注册
void unRegistObserver(Observer observer);
//通知观察者
void notifiObservers();
}
复制代码
二、Observer
/**
* 观察者接口
*/
public interface Observer<T> {
//数据更新
void update(T t);
}
复制代码
三、ConcreteSubject
public class Weather implements Subject {
private Vector<Observer> mObservers = new Vector<>();
public int mTemp;
@Override
public void registObserver(Observer observer) {
this.mObservers.add(observer);
}
@Override
public void unRegistObserver(Observer observer) {
this.mObservers.remove(observer);
}
@Override
public void notifiObservers() {
for (Observer observer : mObservers) {
observer.update(this);
}
}
/**
* 温度更新后，通知被观察者
* @param temp
*/
public void updateTemp(int temp){
this.mTemp = temp;
notifiObservers();
}
}
复制代码
四、ConcreteObserver
public class Forecast implements Observer<Weather>{
@Override
public void update(Weather weather) {
System.out.println("温度调整为:"+weather.mTemp);
}
}
复制代码
五、使用：
public class ObserverTest {
public static void main(String[] args){
Weather weather = new Weather();
Forecast forecast = new Forecast();
//注册观察者
weather.registObserver(forecast);
//被观察者数据有更新
weather.updateTemp(15);
}
}
复制代码
当天气有温度更新时，天气预报会收到相应的通知，并进行对应的更新。ide
3、java.util.Observable源码解析
java中提供了Observerable和Observer相关实现类ui
一、java.util.Observable 被观察者
public class Observable {
private boolean changed = false;
private final ArrayList<Observer> observers;
public Observable() {
observers = new ArrayList<>();
}
//添加观察者
public synchronized void addObserver(Observer o) {
if (o == null)
throw new NullPointerException();
if (!observers.contains(o)) {
observers.add(o);
}
}
//删除观察者
public synchronized void deleteObserver(Observer o) {
observers.remove(o);
}
//通知观察者
public void notifyObservers() {
notifyObservers(null);
}
public void notifyObservers(Object arg) {
Observer[] arrLocal;
synchronized (this) {
//当changed为true的时候才通知观察者
if (!hasChanged())
return;
arrLocal = observers.toArray(new Observer[observers.size()]);
clearChanged();
}
for (int i = arrLocal.length - 1; i >= 0; i--)
arrLocal[i].update(this, arg);
}
public synchronized void deleteObservers() {
observers.clear();
}
//将changed设为true
protected synchronized void setChanged() {
changed = true;
}
//清除状态
protected synchronized void clearChanged() {
changed = false;
}
//查询状态
public synchronized boolean hasChanged() {
return changed;
}
public synchronized int countObservers() {
return observers.size();
}
}
复制代码
二、java.util.Observer
public interface Observer {
void update(Observable o, Object arg);
}
复制代码
观察者接口，定义了更新的方法this
三、实例调用：
（1）被观察者spa
public class Weather extends Observable {
public int mTemp;
/**
* 温度更新后，通知被观察者
* @param temp
*/
public void updateTemp(int temp){
this.mTemp = temp;
setChanged();
notifyObservers(this);
}
}
复制代码
（2）观察者code
public class Forecast implements Observer {
@Override
public void update(Observable o, Object arg) {
if (arg instanceof Weather) {
System.out.println("温度调整为:"+((Weather) arg).mTemp);
}
}
}
复制代码
（3）使用cdn
public class ObserverTest {
public static void main(String[] args) {
Weather weather = new Weather();
Forecast forecast = new Forecast();
weather.addObserver(forecast);
weather.updateTemp(20);
}
}
复制代码
观察者接受到了通知并进行了更新server
4、RecycleView中的观察者
一、Adapter
public static abstract class Adapter<VH extends ViewHolder> {
//建立一个被观察者，用来添加、删除、通知观察者
private final AdapterDataObservable mObservable = new AdapterDataObservable();
......
/**
* 注册观察者
* @param observer
*/
public void registerAdapterDataObserver(AdapterDataObserver observer) {
mObservable.registerObserver(observer);
}
/**
* 取消注册观察者
* @param observer
*/
public void unregisterAdapterDataObserver(AdapterDataObserver observer) {
mObservable.unregisterObserver(observer);
}
/**
* 通知已注册的观察者更新数据
*/
public final void notifyDataSetChanged() {
mObservable.notifyChanged();
}
/**
* 通知已注册的观察者某个索引的数据发生改变
*/
public final void notifyItemChanged(int position) {
mObservable.notifyItemRangeChanged(position, 1);
}
......
}
复制代码
- 能够进行注册和取消注册观察者，内部实如今AdapterDataObservable中
- 在adapter数据更新时，通知观察者数据已发生改变
二、AdapterDataObservable
static class AdapterDataObservable extends Observable<AdapterDataObserver> {
public boolean hasObservers() {
return !mObservers.isEmpty();
}
/**
* 遍历观察者，调用其onChanged方法
*/
public void notifyChanged() {
for (int i = mObservers.size() - 1; i >= 0; i--) {
mObservers.get(i).onChanged();
}
}
/**
* 遍历观察者，调用其onItemRangeChanged方法
* @param positionStart
* @param itemCount
* @param payload
*/
public void notifyItemRangeChanged(int positionStart, int itemCount, Object payload) {
for (int i = mObservers.size() - 1; i >= 0; i--) {
mObservers.get(i).onItemRangeChanged(positionStart, itemCount, payload);
}
}
......
}
复制代码
AdapterDataObservable做为一个被观察者，继承了Observable，在数据发生改变时，遍历通知观察者调用其回调方法。对象
public abstract class Observable<T> {
protected final ArrayList<T> mObservers = new ArrayList<T>();
/**
* 注册就是将观察者存入集合
*/
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);
}
}
/**
* 取消注册将观察者移除
*/
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);
}
}
/**
* 移除全部观察者
*/
public void unregisterAll() {
synchronized(mObservers) {
mObservers.clear();
}
}
}
复制代码
三、观察者AdapterDataObserver
public static abstract class AdapterDataObserver {
public void onChanged() {
}
public void onItemRangeChanged(int positionStart, int itemCount) {
}
public void onItemRangeChanged(int positionStart, int itemCount, Object payload) {
onItemRangeChanged(positionStart, itemCount);
}
public void onItemRangeInserted(int positionStart, int itemCount) {
}
public void onItemRangeRemoved(int positionStart, int itemCount) {
}
public void onItemRangeMoved(int fromPosition, int toPosition, int itemCount) {
}
}
复制代码
做为观察者，定义一些回调方法，在被观察者发生改变时会被调用
四、观察者注册
经过Adapter的registerAdapterDataObserver进行注册
(1)RecyclerView的setAdapter
#RecyclerView
public void setAdapter(Adapter adapter) {
// bail out if layout is frozen
setLayoutFrozen(false);
setAdapterInternal(adapter, false, true);
requestLayout();
}
private void setAdapterInternal(RecyclerView.Adapter adapter, boolean compatibleWithPrevious,
boolean removeAndRecycleViews) {
//先经过以前的adapter将观察者取消注册
if (mAdapter != null) {
mAdapter.unregisterAdapterDataObserver(mObserver);
mAdapter.onDetachedFromRecyclerView(this);
}
if (!compatibleWithPrevious || removeAndRecycleViews) {
removeAndRecycleViews();
}
mAdapterHelper.reset();
final RecyclerView.Adapter oldAdapter = mAdapter;
mAdapter = adapter;
//注册新的观察者
if (adapter != null) {
adapter.registerAdapterDataObserver(mObserver);
adapter.onAttachedToRecyclerView(this);
}
......
}
复制代码
相关文章
- 1. 设计模式（五）观察者模式
- 2. 设计模式--观察者模式（五）
- 3. 【转】设计模式-观察者模式 设计模式-观察者模式
- 4. 观察者模式 JAVA设计模式之观察者模式
- 5. RecyclerView中的观察者模式
- 6. 观察者设计模式
- 7. 设计模式——观察者
- 8. 设计模式--观察者
- 9. 设计模式-观察者
- 10. 设计模式（5）---观察者模式
- 更多相关文章...
- • Scala 模式匹配 - Scala教程
- • SVN 启动模式 - SVN 教程
- • 委托模式
- • IntelliJ IDEA代码格式化设置
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
欢迎关注本站公众号,获取更多信息
相关文章
- 1. 设计模式（五）观察者模式
- 2. 设计模式--观察者模式（五）
- 3. 【转】设计模式-观察者模式 设计模式-观察者模式
- 4. 观察者模式 JAVA设计模式之观察者模式
- 5. RecyclerView中的观察者模式
- 6. 观察者设计模式
- 7. 设计模式——观察者
- 8. 设计模式--观察者
- 9. 设计模式-观察者
- 10. 设计模式（5）---观察者模式