android观察者
‘壹’ android 观察者模式 我被观察的信息在activity中 但是他要继承Observable，但是他要继承Activity的阿 这
两个解决办法，
1、多谢一个类，作为中间类，这个类，继承Observable，然后，让这个类，再继承Activity。我没试过这种方式。
2、这种方式肯定可行，就是自己构建一个观察者模式。如果你对观察者模式很了解。这个很容易。
‘贰’ android设计模式中的观察者模式能说一下吗
java">/*
*观察者模式
*定义对象间的一种一个(Subject)对多(Observer)的依赖关系，当一个对象的状态发送改变时，所以依赖于它的
*对象都得到通知并被自动更新
*
*当然，MVC只是Observer模式的一个实例。Observer模式要解决的问题为：
*建立一个一（Subject）对多（Observer）的依赖关系，并且做到当“一”变化的时候，
*依赖这个“一”的多也能够同步改变。最常见的一个例子就是：对同一组数据进行统计分析时候，
*我们希望能够提供多种形式的表示（例如以表格进行统计显示、柱状图统计显示、百分比统计显示等）。
*这些表示都依赖于同一组数据，我们当然需要当数据改变的时候，所有的统计的显示都能够同时改变。
*Observer模式就是解决了这一个问题。
*
*适用性：
*1.当一个抽象模型有两个方面，其中一个方面依赖于另一方面
*将这两者封装成独立的对象中以使它们可以各自独立的改变和服用
*
*2.当对一个对象的改变需要同时改变其他对象，而不知道具体有多少对象有待改变
*
*3.当一个对象必须通知其它对象，而它又不能假定其它对象是谁
*
*参与者：
*1.Subject（目标）
*目标知道它的观察者，可以有任意多个观察者观察同一个目标
*提供注册和删除观察者对象的接口
*
*2.Observer（观察者）
*为那些在目标发生改变时需获得通知的对象定义个更新的接口
*
*3.ConcreteSubject（具体目标）
*将有关状态存入各ConcreteObserver对象
*当它的状态发送改变时，向它的各个观察者发出通知
*
*4.ConcreteObserver（具体观察者）
*维护一个指向ConcreteObserver对象的引用
*存储有关状态，这些状态应与目标的状态保持一致
*实现Observer的更新接口是自身状态与目标的状态保持一致
*
*
**/
‘叁’ Android中有没有对多个对象的监听方法，就像观察者模式一样
Android
中的监听器模式与观察者模式
1、 观察者模式与监听器机制
1.1 观察者模式
1.2 监听器（Listener）机制
代码的基本框架：
* 被监控着
package com.wonders.group;
import java.util.Collection;
public class ModelTie {
private Collection<Object> dataSet;
public interface DataSetSupervioer {
public void onChange();
}
private DataSetSupervioer dataSetChangeListener;
public void setDataSetChangeListener(DataSetSupervioer
dataSetChangeListener) {
this.dataSetChangeListener = dataSetChangeListener;
}
public void notifyDataSetChange() {
if (null != dataSetChangeListener) {
dataSetChangeListener.onChange();
}
}
public Collection<Object> getDataSet() {
return dataSet;
}
public ModelTie setDataSet(Collection<Object> dataSet)
{
this.dataSet = dataSet;
this.notifyDataSetChange(); // 数据设置完毕要通知监听器进行更新操作
return this;
}
}
* 监控者
package com.wonders.group;
import java.util.Collection;
import java.util.Iterator;
import com.wonders.group.ModelTie.DataSetSupervioer;
public class PresentationTie {
private ModelTie model;
public PresentationTie() {
super();
// 添加监听器
model.setDataSetChangeListener(new DataSetSupervioer()
{
public void onChange() {
// 填写一些前置操作，如更新数据
DisplayModel(); // 重新绘制
// 填写一些后置操作，如更新状态
}
});
}
public void DisplayModel() {
Collection<Object> collection =
model.getDataSet();
if (collection != null) {
for (Iterator iterator = collection.iterator();
iterator.hasNext();) {
System.out.println(((Object)
iterator.next()).toString());
// 其他等等操作
}
}
}
public ModelTie getModel() {
return model;
}
public void setModel(ModelTie model) {
this.model = model;
}
}
2、
ArrayAdapter的观察者实现机制
以下仅罗列关键代码：
public class ArrayAdapter<T> extends BaseAdapter implements Filterable
{
private boolean mNotifyOnChange = true;
/**
* Adds the specified object at the end of the array.
*/
public void add(T object) {
if (mOriginalValues != null) {
synchronized (mLock) {
mOriginalValues.add(object);
if (mNotifyOnChange) notifyDataSetChanged();
}
} else {
mObjects.add(object);
if (mNotifyOnChange) notifyDataSetChanged();
}
}
/**
* Inserts the specified object at the specified index in the
array.
*/
public void insert(T object, int index) {
if (mOriginalValues != null) {
synchronized (mLock) {
mOriginalValues.add(index, object);
if (mNotifyOnChange) notifyDataSetChanged();
}
} else {
mObjects.add(index, object);
if (mNotifyOnChange) notifyDataSetChanged();
}
}
/**
* Removes the specified object from the array.
*/
public void remove(T object) {
if (mOriginalValues != null) {
synchronized (mLock) {
mOriginalValues.remove(object);
}
} else {
mObjects.remove(object);
}
if (mNotifyOnChange) notifyDataSetChanged();
}
/**
* Remove all elements from the list.
*/
public void clear() {
if (mOriginalValues != null) {
synchronized (mLock) {
mOriginalValues.clear();
}
} else {
mObjects.clear();
}
if (mNotifyOnChange) notifyDataSetChanged();
}
/**
* Sorts the content of this adapter using the specified
comparator.
*/
public void sort(Comparator<? super T> comparator) {
Collections.sort(mObjects, comparator);
if (mNotifyOnChange) notifyDataSetChanged();
}
@Override
public void notifyDataSetChanged() {
super.notifyDataSetChanged(); //
关键代码，这个notifyDataSetChanged()是从父类BaseAdapter继承过来的，所以看看在父类中它干了些什么
mNotifyOnChange = true;
}
}
/**
* Common base class of common implementation for an {@link
Adapter} that can be
* used in both {@link ListView} (by implementing the
specialized
* {@link ListAdapter} interface} and {@link Spinner} (by
implementing the
* specialized {@link SpinnerAdapter} interface.
*/
public abstract class BaseAdapter implements ListAdapter,
SpinnerAdapter {
private final DataSetObservable mDataSetObservable = new
DataSetObservable();
public void registerDataSetObserver(DataSetObserver observer)
{
这对方法用来注册或注销
观察ArrayAdapter的观察者的
mDataSetObservable.registerObserver(observer);
}
public void unregisterDataSetObserver(DataSetObserver
observer) {
mDataSetObservable.unregisterObserver(observer);
}
/**
* Notifies the attached View that the underlying data has
been changed
* and it should refresh itself.
*/
public void notifyDataSetChanged() {
mDataSetObservable.notifyChanged(); //
关键代码：说明调的是成员变量mDataSetObservable的方法，所以进入DataSetObservable看看具体是如何操作的
}
public void notifyDataSetInvalidated() {
mDataSetObservable.notifyInvalidated();
}
}
package android.database;
/**
* A specialization of Observable for DataSetObserver that
provides methods for
* invoking the various callback methods of DataSetObserver.
*/
public class DataSetObservable extends
Observable<DataSetObserver> {
/**
* Invokes onChanged on each observer. Called when the data
set being observed has
* changed, and which when read contains the new state of the
data.
*/
public void notifyChanged() {
synchronized(mObservers) {
for (DataSetObserver observer : mObservers) { //
这里的mObservers是哪来的呢?继续追踪，但首先可以判断是来自Observable<DataSetObserver>的。进入看看
observer.onChanged();
}
}
}
/**
* Invokes onInvalidated on each observer. Called when the
data set being monitored
* has changed such that it is no longer valid.
*/
public void notifyInvalidated() {
synchronized (mObservers) {
for (DataSetObserver observer : mObservers) {
observer.onInvalidated();
}
}
}
}
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>();
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);
}
}
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);
}
}
public void unregisterAll() {
synchronized(mObservers) {
mObservers.clear();
}
}
}
‘肆’ 观察者模式 在android中什么时候会用到
android中注册短信和联系人的变更,就会用到观察者模式
通过ContentProvider注册一个observer实现的
‘伍’ android eventbus 底层是什么实现的
参考csdn的博客：
尊重原创：http://blog.csdn.net/yuanzeyao/article/details/38174537
代码下载：http://download.csdn.net/detail/yuanzeyao2008/7684041
在编程过程中，当我们想通知其他组件某些事情发生时，我们通常使用观察者模式，正式因为观察者模式非常常见，所以在jdk1.5中已经帮助我们实现了观察者模式，我们只需要简单的继承一些类就可以快速使用观察者模式，在Android中也有一个类似功能的开源库EventBus，可以很方便的帮助我们实现观察者模式，那么我们就开始学习如何使用EventBus.
在接下来的内容中，我首先会介绍如何使用EventBus,然后再简单的学习一下EventBus的底层实现原理，因为仅仅学习如何使用总是感觉内心不够踏实，万一哪天出了Bug也无从下手，了解了它的基本实现后，就会用得游刃有余。好了 废话不多说，下面开始学习吧
1、下载EventBus库：
EvnetBus的下载地址：https://github.com/greenrobot/EventBus.git
2、将EventBus.jar放入自己工程的libs目录即可
3、定义一个事件，这个事件一旦被EventBus分发出去就是代表某一件事情发生了，这个事件就是某个观察者关心的事情(不需要继承任何类)
4、定义观察者，然后将该观察者注册到EventBus
5、由EventBus分发事件，告知观察者某一件事情发生了
6、使用完成后从EventBus中反注册观察者。
熟悉观察者模式的朋友肯定对于上面的流程非常熟悉，其实和观察模式基本是一样的。但是也是有区别的。在观察者模式中，所有的观察者都需要实现一个接口，这个接口有一个统一的方法如:
public void onUpdate()；
然后当某一个事件发生时，某个对象会调用观察者的onUpdate方法通知观察者某件事情发生了，但是在EventBus中不需要这样，EventBus中是这样实现的：
在EventBus中的观察者通常有四种订阅函数（就是某件事情发生被调用的方法）
1、onEvent
2、onEventMainThread
3、onEventBackground
4、onEventAsync
这四种订阅函数都是使用onEvent开头的，它们的功能稍有不同,在介绍不同之前先介绍两个概念：
告知观察者事件发生时通过EventBus.post函数实现，这个过程叫做事件的发布，观察者被告知事件发生叫做事件的接收，是通过下面的订阅函数实现的。
‘陆’ android内容观察者有哪些
拦截短信，比如当发短信的时候，就把短信读取出来，当系统的短信发生变化的时候，大叫一声，把数据发送到公共的消息邮箱里面，我们的应用通过内容观察者观察公共的消息邮箱
获取ContentResolver对象，调用函数getContentResolver()，
调用ContentResolver对象的
registerContentObserver(uri,notifyForDescendents,observer)方法，参数：Uri对象，是否
精确uri（true不精确，false精确），observer对象 ContentObserver对象
因为ContentObserver是抽象类，因此我们写一个内部类来继承这个抽象类，必须实现构造函数，构造函数的Handler对象消息处理器
稍后会讲，定义一个内部类MyObserver，实现父类的onChange()回调方法，观察到消息邮箱发生变化的时候会回调这个方法。
在这个回调函数里面，使用获取到短信内容，取最后一条，调用Cursor对象的moveToFirst()指针指向最后一条
系统应用是如何发出这个叫声的呢，获取ContentResolver对象，通过getContentResolver()方法，调用
ContentResolver对象的notifyChange(uri,observer)方法，参数：uri随便定义，observer指定谁处理默
认null
系统的很多应用进行通知通信都是通过这个公共消息邮箱机制来实现的
接下来实战一下，接着《Android 内容提供者的实现》中使用的项目作为基础，新建一个项目，并添加代码如下：
package com.wuyudong.observer;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.app.Activity;
import android.content.ContentResolver;
import android.content.Context;
import android.database.ContentObserver;
import android.view.Menu;
public class MainActivity extends Activity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Uri uri = Uri.parse("content://com.wuyudong.db.personprovider/");
getContentResolver().registerContentObserver(uri, true,
new MyObserver(new Handler()));
}
private class MyObserver extends ContentObserver {
public MyObserver(Handler handler) { // handler 是一个消息处理器
super(handler);
}
@Override
public void onChange(boolean selfChange) {
// TODO Auto-generated method stub
System.out.println("haha,数据库的内容变化了！！！");
super.onChange(selfChange);
}
}
}
并修改PersonDBProvider.java中的代码：
public Uri insert(Uri uri, ContentValues values) {
if (matcher.match(uri) == INSERT) {
// 返回查询的结果集
SQLiteDatabase db = helper.getWritableDatabase();
db.insert("person", null, values);
getContext().getContentResolver().notifyChange(uri, null);
} else {
throw new IllegalArgumentException("路径不匹配，不能执行插入操作");
}
return null;
}
@Override
public int delete(Uri uri, String selection, String[] selectionArgs) {
if (matcher.match(uri) == DELETE) {
// 返回查询的结果集
SQLiteDatabase db = helper.getWritableDatabase();
int result = db.delete("person", selection, selectionArgs);
db.close();
if (result > 0) {
getContext().getContentResolver().notifyChange(uri, null);
}
} else {
throw new IllegalArgumentException("路径不匹配，不能执行删除操作");
}
return 0;
}
这样在每次点击按钮的时候，都会打印相关数据库数据被修改的提示
‘柒’ 内容观察者可以删除短信么android
//删除短信（单条）
public void delSMS(String id){
getContentResolver().delete(Uri.parse("content://sms"),
"_id=" + id, null);
Log.i(TAG, "删除短信_id = " + id );
}
‘捌’ android源码里哪些地方用到了观察者模式
1. Subject被观察者。是一个接口或者是抽象类，定义被观察者必须实现的职责，它必须能偶动态地增加、取消观察者，管理观察者并通知观察者。
2. Observer观察者。观察者接收到消息后，即进行update更新操作，对接收到的信息进行处理。
3. ConcreteSubject具体的被观察者。定义被观察者自己的业务逻辑，同时定义对哪些事件进行通知。
4. ConcreteObserver具体观察者。每个观察者在接收到信息后处理的方式不同，各个观察者有自己的处理逻辑。
观察者模式有什么优点呢：
观察者和被观察者之间是抽象耦合的，不管是增加观察者还是被观察者都非常容易扩展。
根据单一职责原则，每个类的职责是单一的，那么怎么把各个单一的职责串联成真实的复杂的逻辑关系呢，观察者模式可以起到桥梁作用。
观察者模式是松耦合的典型。
在Android源码中，其中一个经典的使用到观察者模式的就是Android控件的事件监听模型。
‘玖’ android中观察者模式的应用场景是什么
你说的场景是符合这个模式的：
观察者模式的应用场景：
1、 对一个对象状态的更新，需要其他对象同步更新，而且其他对象的数量动态可变。
2、 对象仅需要将自己的更新通知给其他对象而不需要知道其他对象的细节。
观察者模式的优点：
1、 Subject和Observer之间是松偶合的，分别可以各自独立改变。
2、 Subject在发送广播通知的时候，无须指定具体的Observer，Observer可以自己决定是否要订阅Subject的通知。
3、 遵守大部分GRASP原则和常用设计原则，高内聚、低偶合。