观察者模式抽取的工具类

最近项目有很多需要在Activity中传送数据、数据更改后刷新界面、异步更新数据的地方，所以对观察者模式做了一个抽取，做了一个工具包，使用的时候非常简单，下面上代码~

例如，以某个类作为数据进行公布：

public class Task implements Publisher.Publishable{}

需要注意作为数据的类要实现这个Publishable接口，然后创建TaskPublisher

public class TaskPublisher {
public static final Publisher publisher = new Publisher();
public static final PublishableHolder<Task> task = new PublishableHolder<>(publisher);
}

这里publisher变量是用来注册和注销的入口，它本身实现了观察者模式的通知方法，Publishable接口也在Publisher类中

public class Publisher {

private final List<Observer> observers;

public Publisher() {
this.observers = new ArrayList<>();
}

/**
* 注册
*
* @param observer
*/
public void register(Observer observer) {
if (!isRegistered(observer)) {
observers.add(observer);
}
}

/**
* 注销
*
* @param observer
*/
public void unRegister(Observer observer) {
if (isRegistered(observer)) {
observers.remove(observer);
}
}

public boolean isRegistered(Observer observer) {
return observers.contains(observer);
}

/**
* 获取注册听众数量
*
* @return
*/
public int getObserversCount() {
return observers.size();
}

/**
* 通知所有听众
*/
public void notifyObservers(Object data) {
if (observers.size() > 0) {
for (Observer observer : observers) {
if (observer != null) {
observer.update(data);
}
}
}
}

public interface Observer {
void update(Object data);
}

public interface Publishable {
}

}

当你在某个类中实现了Publisher.Observer接口的update方法后，就可以调用注册方法进行注册了

public class TaskObserver implements Publisher.Observer{
public void update(Object data){
// do something
}
}

在合适的地方进行注册和注销

TaskObserver taskObserver = new TaskObserver();

//注册
TaskPublisher.publisher.register(taskObserver);

//注销
TaskPublisher.publisher.unRegister(taskObserver);

进行注册之后，获取需要的数据

Task task = TaskPublisher.task.getData();

之后就可以使用该数据进行界面初始化之类的工作

需要注意，一定要在注册之后获取数据，否则异步操作有可能让你错过一次数据更新！

那么剩下的就是PublishableHolder了，见代码

public class PublishableHolder<P extends Publisher.Publishable> {
private final Publisher publisher;
private P data;

public PublishableHolder(Publisher publisher) {
this.publisher = publisher;
}

public P getData() {
return data;
}

public void setData(P data) {
this.data = data;
publisher.notifyObservers(this.data);
}

/**
* 在data的引用地址不改变的情况下修改data内部的数据推荐调用此方法
* 否则需要自行通知publisher
*
* @param changer
*/
public void modifyData(DataChanger changer) {
if (changer != null) {
changer.doChange(data);
publisher.notifyObservers(data);
}
}

/**
* 修改数据接口
*/
public interface DataChanger<P extends Publisher.Publishable> {
void doChange(P data);
}

}

另外还可以使用List<Publishable>的数据，用到了另一个类PublishableListHolder

public class PublishableListHolder<P extends Publisher.Publishable> {
private final List<P> list;
private final Publisher publisher;

public PublishableListHolder(Publisher publisher) {
list = new ArrayList<>();
this.publisher = publisher;
}

public void setList(List<P> list) {
this.list.clear();
this.list.addAll(list);
publisher.notifyObservers(this.list);
}

public List<P> getList(Publisher.Observer observer) {
return list;
}

public void addItem(P publishable) {
list.add(publishable);
publisher.notifyObservers(list);
}

public void removeItem(P publishable) {
if (list.contains(publishable)) {
list.remove(publishable);
publisher.notifyObservers(list);
}
}

public void addAll(List<P> publishableList) {
list.addAll(publishableList);
publisher.notifyObservers(list);
}

public void removeAll(List<P> publishableList) {
list.removeAll(publishableList);
publisher.notifyObservers(list);
}

public void clear() {
list.clear();
publisher.notifyObservers(list);
}
}