Android设计模式（十一）－－观察者模式

问题：

在Android中，根据Android的事件树，我们知道：在与屏幕按键、触摸、滑动等操作与应用进行交互时触发的相关事件中，交互事件是沿着事件树自顶向下传播的；

当位于事件树上层的父控件接受到事件后，判断事件的所属，若需要，则截获事件，否则，向下子控件传播。

那么我们在编写各种Listener，在View各种事件函数接受和处理各类交互事件，这种处理模式，是否就是一种观察者模式呢？

问题，先放于此处。

言归正传：

观察者模式：

1、定义：

Define a one-to-many dependency between objects so that when one object changes state, all its dependents aer notified and updated automatically. 
定义对象间一种一对多的依赖关系，使得当一个对象改变状态，则所有依赖于它的对象都会得到通知并被自动更新。

2、适用：
当一个对象的改变需要同时改变其他对象的时候，并且他不知道有多少对象需要改变的时候，考虑使用观察者模式；

3、目的：

观察者模式所做的工作其实就是在解耦合，让耦合的双方都依赖与抽象，而不依赖于具体使得双方的变化都不影响另一方的变化；

4、原则：

观察者模式符合依赖倒转原则；

5、其他：

观察者模式是一种对象的行为模式，又叫发布-订阅(Publish/Subscribe)模式、模型-视图(Model/View)模式、源-监听器(Source/Listener)模式或从属者(Dependents)模式。

6、简单的demo：

demo 的业务是：一个按钮对象，当按钮点击时，通知两个视图的改变；

首先是：观察者：

package com.example.demo.Observer;
/**
 * 抽象观察者(Observer)角色
 * @author qubian
 * @data 2015年6月11日
 * @email naibbian@163.com
 *
 */
public interface Observer {

	public void upadteView(String info);
}
package com.example.demo.Observer;

import android.util.Log;
/**
 * 具体观察者角色
 * @author qubian
 * @data 2015年6月11日
 * @email naibbian@163.com
 *
 */
public class Observer_View1 implements Observer{

	@Override
	public void upadteView(String info) {
		Log.i("upadteView", "Observer_View1,视图1发生变化，变化的内容是："+info);
		
	}

}
package com.example.demo.Observer;

import android.util.Log;
/**
 * 具体观察者角色
 * @author qubian
 * @data 2015年6月11日
 * @email naibbian@163.com
 *
 */
public class Observer_View2  implements Observer{

	@Override
	public void upadteView(String info) {
		Log.i("upadteView", "Observer_View2,视图2发生变化，变化的内容是："+info);
	}

}

主题角色：

package com.example.demo.Observer;

import java.util.ArrayList;
import java.util.List;

/**
 * 抽象主题(Subject)角色
 * @author qubian
 * @data 2015年6月11日
 * @email naibbian@163.com
 *
 */
public abstract class Subject {

	private List<Observer> list;
	/**
	 * 添加观察者，面向接口，面向抽象编程
	 * @param observer
	 */
	public void  addObserver(Observer observer)
	{
		if (list==null) {
			list = new ArrayList<Observer>();
		}
		list.add(observer);
	}
	/**
	 * 通知视图改变
	 * @param info
	 */
	public void notifyDataSetChange(String info)
	{
		for (Observer observer : list) {
			observer.upadteView(info);
		}
	}
	
}
package com.example.demo.Observer;

import android.util.Log;
/**
 * 具体被观察者角色
 * 比如说我，点击了按钮，我希望，视图发生变化
 * @author qubian
 * @data 2015年6月11日
 * @email naibbian@163.com
 *
 */
public class Subject_Button extends Subject{

	/**
	 * 点击了按钮，我希望，视图发生变化
	 */
	public void Click()
	{
		Log.i("Subject_Button", "点击了按钮");
		
		String tag ="101";
		notifyDataSetChange(tag);
	}
	
	
}

使用：

package com.example.demo.Observer;


/**
 *  使用
 * @author qubian
 * @data 2015年6月11日
 * @email naibbian@163.com
 *
 */
public class UseObserver {

	public void use()
	{
		// 业务是这样的：我，点击了按钮，我希望绑定在这个按钮上的视图发生变化
		
		// 首先 是有两个视图的观察者：
		
		Observer  obj1 = new Observer_View1();
		Observer  obj2 = new Observer_View2();
		
		// 按钮
		Subject_Button sub = new Subject_Button();
		sub.addObserver(obj1);
		sub.addObserver(obj2);
		// 点击按钮 视图变化
		sub.Click();
	}
}

7、java库：

在java中的java.util库里面，提供了一个Observable类以及一个Observer接口，构成java语言对观察者模式的支持。

使用比较简单，具体观察对象实现Observer接口，被观察者继承Observable类，即可。

比较简单，不再说明了；

/*
 *  Licensed to the Apache Software Foundation (ASF) under one or more
 *  contributor license agreements.  See the NOTICE file distributed with
 *  this work for additional information regarding copyright ownership.
 *  The ASF licenses this file to You under the Apache License, Version 2.0
 *  (the "License"); you may not use this file except in compliance with
 *  the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 */

package java.util;


/**
 * {@code Observer} is the interface to be implemented by objects that
 * receive notification of updates on an {@code Observable} object.
 *
 * @see Observable
 */
public interface Observer {

    /**
     * This method is called if the specified {@code Observable} object's
     * {@code notifyObservers} method is called (because the {@code Observable}
     * object has been updated.
     *
     * @param observable
     *            the {@link Observable} object.
     * @param data
     *            the data passed to {@link Observable#notifyObservers(Object)}.
     */
    void update(Observable observable, Object data);
}


package android.database;

import java.util.ArrayList;

/**
 * Provides methods for registering or unregistering arbitrary observers in an {@link ArrayList}.
 *
 * This abstract class is intended to be subclassed and specialized to maintain
 * a registry of observers of specific types and dispatch notifications to them.
 *
 * @param T The observer type.
 */
public abstract class Observable<T> {
    /**
     * The list of observers.  An observer can be in the list at most
     * once and will never be null.
     */
    protected final ArrayList<T> mObservers = new ArrayList<T>();

    /**
     * Adds an observer to the list. The observer cannot be null and it must not already
     * be registered.
     * @param observer the observer to register
     * @throws IllegalArgumentException the observer is null
     * @throws IllegalStateException the observer is already registered
     */
    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);
        }
    }

    /**
     * Removes a previously registered observer. The observer must not be null and it
     * must already have been registered.
     * @param observer the observer to unregister
     * @throws IllegalArgumentException the observer is null
     * @throws IllegalStateException the observer is not yet registered
     */
    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);
        }
    }

    /**
     * Remove all registered observers.
     */
    public void unregisterAll() {
        synchronized(mObservers) {
            mObservers.clear();
        }
    }
}

8、android的运用：

回归到，上面的问题；

很明显，上述的Android事件树的传递，交互事件的监听，我们所写的Listener回调，整个监听部分就是一种观察者模式。

在我们最熟悉的点击事件中，初始化时，我们设置视图的监听：

    /**
     * Register a callback to be invoked when this view is clicked. If this view is not
     * clickable, it becomes clickable.
     *
     * @param l The callback that will run
     *
     * @see #setClickable(boolean)
     */
    public void setOnClickListener(OnClickListener l) {
        if (!isClickable()) {
            setClickable(true);
        }
        getListenerInfo().mOnClickListener = l;
    }

OnClickListener接口的描述：

    /**
     * Interface definition for a callback to be invoked when a view is clicked.
     */
    public interface OnClickListener {
        /**
         * Called when a view has been clicked.
         *
         * @param v The view that was clicked.
         */
        void onClick(View v);
    }

OnclickListener 是在View 视图内部类ListenerInfo中：

static class ListenerInfo {

        protected OnFocusChangeListener mOnFocusChangeListener;

        private ArrayList<OnLayoutChangeListener> mOnLayoutChangeListeners;

        private CopyOnWriteArrayList<OnAttachStateChangeListener> mOnAttachStateChangeListeners;

        /**
         * Listener used to dispatch click events.
         * This field should be made private, so it is hidden from the SDK.
         * {@hide}
         */
        public OnClickListener mOnClickListener;

        protected OnLongClickListener mOnLongClickListener;

        protected OnCreateContextMenuListener mOnCreateContextMenuListener;

        private OnKeyListener mOnKeyListener;

        private OnTouchListener mOnTouchListener;

        private OnHoverListener mOnHoverListener;

        private OnGenericMotionListener mOnGenericMotionListener;

        private OnDragListener mOnDragListener;

        private OnSystemUiVisibilityChangeListener mOnSystemUiVisibilityChangeListener;
    }

调用：

    public boolean performClick() {
        sendAccessibilityEvent(AccessibilityEvent.TYPE_VIEW_CLICKED);

        ListenerInfo li = mListenerInfo;
        if (li != null && li.mOnClickListener != null) {
            playSoundEffect(SoundEffectConstants.CLICK);
            li.mOnClickListener.onClick(this);
            return true;
        }

        return false;
    }
    public boolean callOnClick() {
        ListenerInfo li = mListenerInfo;
        if (li != null && li.mOnClickListener != null) {
            li.mOnClickListener.onClick(this);
            return true;
        }
        return false;
    }

至于PerformClick的调用，则是在视图的监听OnTouchEvent等有具体的体现：

 public boolean onTouchEvent(MotionEvent event) {

        if (((viewFlags & CLICKABLE) == CLICKABLE ||
                (viewFlags & LONG_CLICKABLE) == LONG_CLICKABLE)) {
            switch (event.getAction()) {
                case MotionEvent.ACTION_UP:
                    boolean prepressed = (mPrivateFlags & PFLAG_PREPRESSED) != 0;
                    if ((mPrivateFlags & PFLAG_PRESSED) != 0 || prepressed) {
                        // take focus if we don't have it already and we should in
                        // touch mode.
                        boolean focusTaken = false;
                        if (isFocusable() && isFocusableInTouchMode() && !isFocused()) {
                            focusTaken = requestFocus();
                        }

                        if (prepressed) {
                            // The button is being released before we actually
                            // showed it as pressed.  Make it show the pressed
                            // state now (before scheduling the click) to ensure
                            // the user sees it.
                            setPressed(true);
                       }

                        if (!mHasPerformedLongPress) {
                            // This is a tap, so remove the longpress check
                            removeLongPressCallback();

                            // Only perform take click actions if we were in the pressed state
                            if (!focusTaken) {
                                // Use a Runnable and post this rather than calling
                                // performClick directly. This lets other visual state
                                // of the view update before click actions start.
                                if (mPerformClick == null) {
                                    mPerformClick = new PerformClick();
                                }
                                if (!post(mPerformClick)) {
                                    performClick();
                                }
                            }
                        }

                        if (mUnsetPressedState == null) {
                            mUnsetPressedState = new UnsetPressedState();
                        }

                        if (prepressed) {
                            postDelayed(mUnsetPressedState,
                                    ViewConfiguration.getPressedStateDuration());
                        } else if (!post(mUnsetPressedState)) {
                            // If the post failed, unpress right now
                            mUnsetPressedState.run();
                        }
                        removeTapCallback();
                    }
                    break;

                case MotionEvent.ACTION_DOWN:
                   
                    break;

                case MotionEvent.ACTION_CANCEL:
                   
                case MotionEvent.ACTION_MOVE:
                   
                    break;
            }
            return true;
        }

        return false;
    }