定义：
观察者模式（Observer）完美的将观察者和被观察的对象分离开。
举个例子，用户界面可以作为一个观察者，业务数据是被观察者，用户界面观察业务数据的变化，发现数据变化后，就显示在界面上。
面向对象设计的一个原则是：系统中的每个类将重点放在某一个功能上，而不是其他方面。一个对象只做一件事情，并且将他做好。
观察者模式在模块之间划定了清晰的界限，提高了应用程序的可维护性和重用性。
观察者设计模式定义了对象间的一种一对多的组合关系，以便一个对象的状态发生变化时，所有依赖于它的对象都得到通知并自动刷新。这个定义可能要简洁些:
观察者模式又叫发布-订阅模式。观察者模式（Observer）定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。
这个主题对象在状态发生变化时，会通知所有观察者对象，使它们能够自动更新自己。实现方式：
观察者模式有很多实现方式，从根本上说，该模式必须包含两个角色：观察者和被观察对象。
在刚才的例子中，业务数据是被观察对象，用户界面是观察者。
观察者和被观察者之间存在“观察”的逻辑关联，当被观察者发生改变的时候，观察者就会观察到这样的变化，并且做出相应的响应。
如果在用户界面、业务数据之间使用这样的观察过程，可以确保界面和数据之间划清界限，假定应用程序的需求发生变化，需要修改界面的表现，
只需要重新构建一个用户界面，业务数据不需要发生变化。代码实现呀：
观察者模式使用三个类 Subject、Observer 和 Client。Subject 对象带有绑定观察者到 Client 对象和从 Client 对象解绑观察者的方法。
我们创建 Subject 类、Observer 抽象类和扩展了抽象类 Observer 的实体类。小萌新刚入门了下RxJava2.x，所以觉得想这样：
观察者模式使用三个类 Observable、Observer 和 Client。Observable对象带有绑定观察者到 Client 对象和从 Client 对象解绑观察者的方法。
我们创建 Observable类、Observer 抽象类和扩展了抽象类 Observer 的实体类。
Client是存储Observer的链表ArrayList<Observer>，负责添加/移除观察者Observer
Observer是可以观察对象（或者可以叫做主题对象），供观察者进行观察监听，以便收到更新通知！就是一顿看概念吧。。看了之后就来个案例啥的，很多资料解释不太一样，或者案例不太相同，但是表达的核心思想是一致的。
观察者模式 | 菜鸟教程
https://blog.csdn.net/u012771445/article/details/81273103
观察者模式_百度百科
我们也来仿个案例啥的，中间夹杂点自己的想法：
首先定义一个观察者接口：
Observer.java
package com.hl.rxnettest.design_pattern.observer_pattern;
public interface Observer {
String function(); // 返回一个请求方法
void update(String body); // 通知更新回调，body是网络请求成功后的结果
}
Observable.java - 再来个可观察对象/主题对象
package com.hl.rxnettest.design_pattern.observer_pattern;
import java.util.ArrayList;
public class Observable {
private final ArrayList<Observer> observerArrayList = new ArrayList<>();
public void registerObserver(Observer observer){
if (null == observer) throw new NullPointerException();
observerArrayList.add(observer);
}
public void unRegisterObserver(Observer observer){
if (null == observer) throw new NullPointerException();
if (observerArrayList.contains(observer)){
observerArrayList.remove(observer);
}
}
public void unRegisterAll(){
if (null != observerArrayList){
observerArrayList.clear();
}
}
public void subcribe(){
for (final Observer item : observerArrayList){
// 获取请求方法，然后进行子线程网络请求
new Thread(new Runnable() {
@Override
public void run() {
String requestFunction = item.function();
System.out.println("请求方法" + requestFunction);
// 请求成功回调
item.update("{"code": 0, "message": "OK", "method": "" + requestFunction + ""}");
}
}).start();
}
}
}
里面提供了注册/注销观察者，以及触发状态更新的方法，subcribe是想着rxjava，所以就起了这个名称。 里面也假设性的做了一个网络请求，并将结果返回了。
OberverA.java
package com.hl.rxnettest.design_pattern.observer_pattern;
public class OberverA implements Observer{
@Override
public String function() {
return "/people/repoa";
}
@Override
public void update(String body) {
System.out.println("OberverA'body=" + body);
}
}
OberverB.java
package com.hl.rxnettest.design_pattern.observer_pattern;
public class OberverB implements Observer{
@Override
public String function() {
return "/people/repob";
}
@Override
public void update(String body) {
System.out.println("OberverB'body=" + body);
}
}
然后就可以测试一下：
package com.hl.rxnettest.design_pattern.observer_pattern;
public class ObserverPatternDemo {
public static void main(String[] args){
Observable observable = new Observable();
observable.registerObserver(new OberverA());
observable.registerObserver(new OberverB());
observable.registerObserver(new Observer() {
@Override
public String function() {
return "/people/repo_匿名";
}
@Override
public void update(String body) {
System.out.println("Observer'body=" + body);
}
});
observable.subcribe();
}
}
当然，这里是遍历了所有的注册对象，并做了请求，然后返回。实际我们的设计肯定不是这样。是一个请求，对应了一个结果响应，已经做了结果响应的，则不再响应，除非再次做请求。 比如我们用的EventBus， 它Post的时候提交了一个Test()对象，那么此时subcribe方法应该修改为:
1. 首先链表存储就再是一个单纯的Observer，而是一个类类型
private final ArrayList<Class<?>> classArrayList = new ArrayList<>();
2. subcribe处理也修改为根据Class<?>来处理
public void subcribe(final Class<?> cls){
if (null == cls) throw new NullPointerException();
if (classArrayList.contains(cls)){
// To do something...
}
}此时我们就如果要做一些事情，就得利用反射知识了呀。。小萌新之前有实践过反射，注解，不过时间略久，需要复习下：
MonkeyLei：Android-自定义注解-反射基础
https://blog.csdn.net/ZhoumingCSDN/article/details/79972279
了解了反射就可以改造下之前的方法，增加新的处理方式，针对性的进行通知啦...
Observable.java - Class<? extends Observer>作为观察者被存起到链表中
package com.hl.rxnettest.design_pattern.observer_pattern;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.ArrayList;
public class Observable {
private final ArrayList<Observer> observerArrayList = new ArrayList<>();
private final ArrayList<Class<? extends Observer>> classArrayList = new ArrayList<>();
public void registerObserver(Observer observer){
if (null == observer) throw new NullPointerException();
observerArrayList.add(observer);
}
public void registerObserver(Class<? extends Observer> _class){
if (null == _class) throw new NullPointerException();
classArrayList.add(_class);
}
public void unRegisterObserver(Observer observer){
if (null == observer) throw new NullPointerException();
if (observerArrayList.contains(observer)){
observerArrayList.remove(observer);
}
}
public void unRegisterObserver(Class<? extends Observer> _class){
if (null == _class) throw new NullPointerException();
if (classArrayList.contains(_class)){
classArrayList.remove(_class);
}
}
public void unRegisterAll(){
if (null != observerArrayList){
observerArrayList.clear();
}
}
public void unRegisterAllClass(){
if (null != classArrayList){
classArrayList.clear();
}
}
public void subcribe(){
for (final Observer item : observerArrayList){
// 获取请求方法，然后进行子线程网络请求
new Thread(new Runnable() {
@Override
public void run() {
String requestFunction = item.function();
System.out.println("请求方法" + requestFunction);
// 请求成功回调
item.update("{"code": 0, "message": "OK", "method": "" + requestFunction + ""}");
}
}).start();
}
}
public void subcribe(final Class<? extends Observer> cls){
if (null == cls) throw new NullPointerException();
if (classArrayList.contains(cls)){
// 获取请求方法，然后进行子线程网络请求
new Thread(new Runnable() {
@Override
public void run() {
// Method[] methods = cls.getDeclaredMethods();
try {
Method function = cls.getMethod("function");
Method update = cls.getMethod("update", String.class);
// 创建一个实施对象
Object obj = cls.newInstance();
Object requestFunction = function.invoke(obj);
System.out.println("请求方法" + requestFunction);
// 根据请求方法进行网络请求requestFunction
// 请求成功回调
update.invoke(obj, "{"code": 0, "message": "OK", "method": "" + requestFunction + ""}");
} catch (NoSuchMethodException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
} catch (InstantiationException e) {
e.printStackTrace();
}
}
}).start();
}
}
}
反射的一点知识...了解一下
Then，可以这样了哟
Observable observable = new Observable();
observable.registerObserver(OberverA.class);
observable.registerObserver(OberverB.class);
observable.subcribe(OberverA.class);
observable.subcribe(OberverB.class);结果：
然后你说还想怎么扩展，怎么完善，怎么接近人家的东东。。。我觉得除了实践，深入，学习，还得看看人家的框架，人家的设计思想方可！
从观察者模式出发，聊聊RxJava - 哎呦，不错哟！小菜鸡的我看遍了呀..
先到这里吧。。一方面算是设计模式之观察者的认识，一方面对于后面封装网络库也有帮助。再努力吧。。。努力努力就发现认知又被纠正完善了...
扫一扫
151
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
