MVP模式+Build模式+Observe模式

    这是小弟我的第一篇博客，最近也是看了几位大神的blog自己尝试写了写几种模式开发软件，用了一下午的时间写了点东西，这里作为总结。

    MVP模式：
    M层：负责定义一个实体类包含对象的属性已经处理这些属性的业务逻辑；
    V层：负责展示界面以及得到Presenter层通知得到相应Model后页面刷新；
    P层：处理V层发送的对应事件与Model，进行业务逻辑处理，将得到的最红Model数据信息通知给V层。

    观察者模式：
    观察者模式定义了一种一对多的依赖关系，让多个观察者对象同时监听某一主题对象。这个主题对象在状态发生变化时，会通知所有观察者对象，
使它们能够自动更新自己。

    Builder模式：
    Builder模式是一种对象构建的设计模式，它可以将复杂对象的建造过程抽象出来，使这个抽象过程的不同实现方法可以构造出不同表现的对象。

    这几个模式大概的意思就是这样，如果我理解的不对请大神批评并加以指导。
    说了这么多说实话还是来个Demo吧，有了Demo更好理解
    下面这段代码是利用Builder模式构造的实体类：
    UserBean.java

    public class UserBean {
    public int age;
    public String name;
    public float bodyWeight;
    public float height;
    public int likeCount;
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public float getBodyWeight() {
        return bodyWeight;
    }
    public void setBodyWeight(float bodyWeight) {
        this.bodyWeight = bodyWeight;
    }
    public float getHeight() {
        return height;
    }
    public void setHeight(float height) {
        this.height = height;
    }
    public int getLikeCount() {
        return likeCount;
    }
    public void setLikeCount(int likeCount) {
        this.likeCount = likeCount;
    }
    public static class Builder {
        UserBean userBean;
        public Builder() {
            this.userBean = new UserBean();
        }
        public Builder setName(String name) {
            this.userBean.setName(name);
            return this;
        }
        public Builder setAge(int age) {
            this.userBean.setAge(age);
            return this;
        }
        public Builder setBodyWeight(float bodyWeight) {
            this.userBean.setBodyWeight(bodyWeight);
            return this;
        }
        public Builder setHeight(float height) {
            this.userBean.setHeight(height);
            return this;
        }
        public UserBean build() {
            return this.userBean;
        }
    }
}

代码很简单，看一眼基本就会用了，调用时如下：

UserBean userBean = new UserBean.Builder().setAge(18)
            .setName("Bernie")
            .setHeight((float) 175.0)
            .setBodyWeight((float) 80.0)
            .build();

好了Buidl模式就基本上这样了：
在看看MVP的具体实现，首先编写一个接口，用来接受P层处理完数据之后刷新页面的回调函数：
Presenter.java

public interface Presenter<T> {
    public void like(T t);
}

然后写一个简单的Activity很简单，一个Button，一个TextView，点击Button将事件发给P层，P层将SP中的点赞数加1，返回被赞总数，然后回调like函数实现页面刷新。
MainActivity .java

public class MainActivity extends Activity implements 
        Presenter<UserBean>, View.OnClickListener {
    Button likeButton;
    TextView likeText;
    SharedPreferences sharedPreferences;
    public SharedPreferences.Editor editor; 
    Context context;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        context = getApplication();
        sharedPreferences =  
             SingleUserBeanSP.getSingleUserBeanSP(contxet);
        editor = sharedPreferences.edit();
        userBean = new UserBean.Builder().setAge(18)
            .setName("Bernie")
            .setHeight((float) 175.0)
            .setBodyWeight((float) 80.0)
            .build();

        likeButton = (Button) findViewById(R.id.likeButton);
        likeText = (TextView) findViewById(R.id.likeText);
        likeButton.setOnClickListener(this);
    }
    @Override
    public void like(UserBean userBean) {
        likeText.setText(userBean.getName() + "\n"
                        + "likeCount = " + userBean.getLikeCount());
            }
    @Override
    public void onClick(View view) {
        switch (view.getId()) {
            case R.id.likeButton:
                new UserBeanPresenter(userBean, this, sharedPreferences,editor);
                break;
            }
        }
}

这里面点击事件使用了UserBeanObserver的构造方法，
看到了Observer这个很明显啊是一个观察者，这个时候我们需要定义一个统一的观察者接口.

public interface Observer<T> {
    public void updateNotify(T t);
}

很简单，我们的UserBeanObserver显然是一个观察者，所以他就要实现观察者这个接口了.
UserBeanPresenter .java

public class UserBeanPresenter implements Observer<UserBean>{
    Presenter<UserBean> presenter;
    public UserBeanPresenter(UserBean userBean,Presenter<UserBean> presenter,SharedPreferences sharedPreferences,SharedPreferences.Editor editor){
        this.presenter = presenter;
        final SubObserver subObserver = new ConcreteSubObserver();
        subObserver.add(this);
        new SetDataToSp(userBean,sharedPreferences,editor,subObserver);
    }
    @Override
    public void updateNotify(UserBean userBean) {
        presenter.like(userBean);
    }
}

UserBeanPresenter构造方法中声明了subObserver这个顾名思义就是被观察者，因为这个别观察者是唯一的所以首先书写一个接口SubObserver
SubObserver .java

public interface SubObserver {
    public void add(Observer observer);
    public void remove(Observer observer);
    public void notifyWatcher(UserBean userBean);
}

三个方法看名字与参数就知道是用来干嘛的了，对了就是加入，去掉，通知观察者这样的操作，而他的具体实现为
ConcreteSubObserver.java

public class ConcreteSubObserver implements  SubObserver{
    private List<Observer> list = new ArrayList<>();
    @Override
    public void add(Observer observer) {
        list.add(observer);
    }
    @Override
    public void remove(Observer observer) {
        list.remove(observer);
    }
    @Override
    public void notifyWatcher(UserBean userBean) {
        for (Observer observer : list) {
            observer.updateNotify(userBean);
        }
    }
}

也是看一眼就知道是用来干嘛的了就不详细说了.
然后回到UserBeanPresenter的构造方法中
UserBeanPresenter.java

final SubObserver subObserver = new ConcreteSubObserver();
subObserver.add(this);    
new  SetDataToSp(userBean,sharedPreferences,editor,subObserver);

这个很好理解把这个观察者加到被观察者的队列中，如果被观察的对象改变这个观察者就会得到通知。
最后一个类，处理被观察对象，实现业务逻辑，被观察者改变时通知所有的观察者：
SetDataToSp.java

public class SetDataToSp {
    public SetDataToSp(UserBean userBean,SharedPreferences sharedPreferences,SharedPreferences.Editor editor,SubObserver subObserver){
        setData(userBean,sharedPreferences,editor,subObserver);
}
    public void setData(UserBean userBean,SharedPreferences sharedPreferences,SharedPreferences.Editor editor,SubObserver subObserver) {
        int likeCount = sharedPreferences.getInt("like",0);
        editor.putInt("like",++likeCount);
        editor.commit();
        userBean.setLikeCount(sharedPreferences.getInt("like",0));
        subObserver.notifyWatcher(userBean);
    }
}

这样观察者得到了被观察者的通知，观察者在回调函数中在通知Activity更新界面，广义上来讲，这种实现的MVP模式Activity是作为P层中某个业务类的观察者存在的。
哦还漏了一个类SingleUserBeanSP.java,这个类我是为了写一个单例模式写的，其实作用不大，采用双重检验锁的方式，这里就不贴出来了。
Demo已经上传到我的Github上面去了，有兴趣的同学可以clone下来看看，多提意见，毕竟本人刚刚开始把这些东西整理成blog，而且技术水平有限欢迎同学指教。
Git地址：https://github.com/ss831116/DesignPatternsDemo.git