Java/Android设计模式<二>观察者模式

在android中观察者模式比较常见比如eventBus Rxjava等 也都是观察者模式;下面来介绍一下观察者模式:

1.观察者模式简单介绍:

在android中观察者模式分为观察者和被观察者两部分:

观察者:就是Observer;在rxjava中被称为Sucscriber;
被观察者:就是Observ’a’bvable,有时候会被称为主题:Sububject;

一般情况下被观察者会通知观察者跟新;从而实现被观察者订阅观察者;
举一个简单的例子:(button的点击事件订阅)

 mLogin.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {

            }
        });

button:mLogin就是被观察者 —->通过setOnClickListener来订阅View.OnClickListener—–>当button:mLogin呗点击时候,通知OnClickListener调用onClick()方法

2.代码实现观察者模式:

在开始之前先介绍要实现的功能:
1.设置两个观察者;
2.被观察者订阅观察者的逻辑和取消订阅的逻辑;
3.被观察者notifyData()时候 观察者做出响应

2.1
作为数据载体先设置javabean:

package com.example.test.bean;

/**
 * Created by houruixiang on 2017/8/22.
 */

public class SimpleInfo {

    private String name;
    private String sex;
    private String age;
    private String state;

    public SimpleInfo(Builder builder) {
        this.name = builder.name;
        this.sex = builder.sex;
        this.age = builder.age;
        this.state = builder.state;
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getAge() {
        return age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }


    @Override
    public String toString() {
        return "SimpleInfo{" +
                "name='" + name + '\'' +
                ", sex='" + sex + '\'' +
                ", age='" + age + '\'' +
                ", state='" + state + '\'' +
                '}';
    }


    public static class Builder{

        private String name;
        private String sex;
        private String age;
        private String state;


        //这里之所以有返回值是为了支持链式编程

        public Builder name(String name){
            this.name = name;
            return this;

        }

        public Builder sex(String sex){
            this.sex = sex;
            return this;
        }

        public Builder age(String age){
            this.age = age;
            return this;
        }

        public Builder state(String state){
            this.state = state;
            return this;
        }

        public SimpleInfo build(){
            return new SimpleInfo(this);
        }



    }
}

2.2
设置观察者和被观察者:
//被观察者:

public class Observable<T> {

    private List<Observer<T>> mObservers = new ArrayList<>();

    //注册被观察者
    public void register(Observer<T> observer){
        if (observer == null){
            throw new NullPointerException("observer 不能等于 null");
        }
        synchronized (this){
            if (!mObservers.contains(observer)){
                mObservers.add(observer);
            }
        }
    }


    //解锁被观察者
    public synchronized void unregister(Observer<T> observer){
        if (observer != null){
            mObservers.remove(observer);
        }
    }


    public void notifyData(T data){
        for (int i = 0; i < mObservers.size(); i++) {
            Observer<T> observer = mObservers.get(i);
            observer.onUpdataData(data);
        }
    }



}

在被观察者中自定义了 register 和unregister—>相当于被观察者订阅观察者的绑定和解绑;
//观察者:

public interface Observer<T> {
    void onUpdataData(T data);
}

2.3
核心逻辑
在这里自定义的被观察者和观察者就全部定义完成;然后再来看MainActivity的实现逻辑;
首先是注册两个观察者–>完成注册:

infoObservable = new Observable<>();
        //创建被观察者
        Observer<SimpleInfo> firstObserver = new Observer<SimpleInfo>() {
            @Override
            public void onUpdataData(SimpleInfo data) {
                mFirst.setText("观察者1: " + data.toString());
            }
        };
        Observer<SimpleInfo> secondObserver = new Observer<SimpleInfo>() {
            @Override
            public void onUpdataData(SimpleInfo data) {
                mSecond.setText("观察者2: " + data.toString());
            }
        };


        //注册
        infoObservable.register(firstObserver);
        infoObservable.register(secondObserver);

被观察者更新data,观察者做出响应:

   SimpleInfo simpleInfo = new SimpleInfo.Builder()
                .name("小白")
                .sex("男")
                .age("15")
                .state("AC_Ml")
                .build();
        infoObservable.notifyData(simpleInfo);

实际结果如下:

//然后再notifyData之前 对第二个观察者解除注册的绑定:

SimpleInfo simpleInfo = new SimpleInfo.Builder()
                .name("小白")
                .sex("男")
                .age("15")
                .state("AC_Ml")
                .build();

        infoObservable.unregister(secondObserver);
        infoObservable.notifyData(simpleInfo);

结果如下:

这样 观察者模式就一目了然:

首先被观察者注册观察者—–>当被观察者notifyData时候,注册过的观察者做出相关响应—–>解除注册则:被观察者notifyData()观察者的数据不更新

到此就介绍完了 个人认为思路还算清晰 希望可以对大家有所帮助