Android中如何检测数据变更？求类似iOS NotificationCenter的方案

嘿，这个需求我太熟了！Android里确实有好几种类似iOS NotificationCenter的实现方式，刚好能解决你在其他类里监听数据控制器增删改操作的问题，我给你梳理几个常用的方案，按需选就行：

这是Google Jetpack组件里的核心成员，自带生命周期感知能力，能自动根据组件（比如Activity/Fragment）的生命周期状态调整回调，完全不用担心内存泄漏问题，非常适合组件间的状态监听。

实现步骤： #

1. 在你的数据控制器类里，定义一个MutableLiveData来承载数据变化的事件（可以自定义事件类，区分新增/更新/删除），然后封装成不可变的LiveData暴露给外部：

public class DataController {
    // 自定义事件类，区分操作类型和数据
    public static class DataChangeEvent {
        public enum Type {ADD, UPDATE, DELETE}
        public Type type;
        public Object data; // 可以换成你实际的数据类型

        public DataChangeEvent(Type type, Object data) {
            this.type = type;
            this.data = data;
        }
    }

    private MutableLiveData<DataChangeEvent> mDataChangeLiveData = new MutableLiveData<>();

    // 暴露不可变的LiveData给外部
    public LiveData<DataChangeEvent> getDataChangeLiveData() {
        return mDataChangeLiveData;
    }

    // 你的新增方法，完成后发送事件
    public void addData(Object data) {
        // 执行新增逻辑...
        mDataChangeLiveData.postValue(new DataChangeEvent(DataChangeEvent.Type.ADD, data));
    }

    // 更新方法同理
    public void updateData(Object data) {
        // 执行更新逻辑...
        mDataChangeLiveData.postValue(new DataChangeEvent(DataChangeEvent.Type.UPDATE, data));
    }

    // 删除方法同理
    public void deleteData(Object data) {
        // 执行删除逻辑...
        mDataChangeLiveData.postValue(new DataChangeEvent(DataChangeEvent.Type.DELETE, data));
    }
}

2. 在需要监听的类（比如Activity/Fragment）里，观察这个LiveData，当数据变化时就会收到回调：

public class MyActivity extends AppCompatActivity {
    private DataController mDataController;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_my);
        mDataController = new DataController();

        // 观察数据变化
        mDataController.getDataChangeLiveData().observe(this, event -> {
            switch (event.type) {
                case ADD:
                    // 处理新增事件，比如更新UI
                    Log.d("DataChange", "新增了数据：" + event.data);
                    break;
                case UPDATE:
                    // 处理更新事件
                    Log.d("DataChange", "更新了数据：" + event.data);
                    break;
                case DELETE:
                    // 处理删除事件
                    Log.d("DataChange", "删除了数据：" + event.data);
                    break;
            }
        });
    }
}

这是一个非常流行的发布/订阅框架，用法和iOS的NotificationCenter几乎一模一样，代码量少，上手快，适合快速实现跨组件的事件通知。

实现步骤： #

1. 先在build.gradle里添加依赖（最新版本可按需替换）：

implementation 'org.greenrobot:eventbus:3.3.1'

2. 定义一个事件类，用来传递操作类型和数据：

public class DataChangeEvent {
    public enum Type {ADD, UPDATE, DELETE}
    public Type type;
    public Object data;

    public DataChangeEvent(Type type, Object data) {
        this.type = type;
        this.data = data;
    }
}

3. 在数据控制器里，当完成增删改操作后，发送事件：

public class DataController {
    public void addData(Object data) {
        // 执行新增逻辑...
        EventBus.getDefault().post(new DataChangeEvent(DataChangeEvent.Type.ADD, data));
    }

    public void updateData(Object data) {
        // 执行更新逻辑...
        EventBus.getDefault().post(new DataChangeEvent(DataChangeEvent.Type.UPDATE, data));
    }

    public void deleteData(Object data) {
        // 执行删除逻辑...
        EventBus.getDefault().post(new DataChangeEvent(DataChangeEvent.Type.DELETE, data));
    }
}

4. 在需要监听的类里，注册/注销EventBus，并订阅事件：

public class MyActivity extends AppCompatActivity {
    private DataController mDataController;

    @Override
    protected void onStart() {
        super.onStart();
        // 注册EventBus
        EventBus.getDefault().register(this);
    }

    @Override
    protected void onStop() {
        super.onStop();
        // 注销EventBus，一定要记得，避免内存泄漏
        EventBus.getDefault().unregister(this);
    }

    // 订阅事件，用@Subscribe注解指定线程模式（这里用MAIN线程，方便更新UI）
    @Subscribe(threadMode = ThreadMode.MAIN)
    public void onDataChange(DataChangeEvent event) {
        switch (event.type) {
            case ADD:
                Log.d("DataChange", "新增数据：" + event.data);
                break;
            case UPDATE:
                Log.d("DataChange", "更新数据：" + event.data);
                break;
            case DELETE:
                Log.d("DataChange", "删除数据：" + event.data);
                break;
        }
    }
}

如果不想用任何第三方库，也不想依赖Jetpack，自己实现一套观察者模式也很简单，完全可控，适合轻量级场景。

实现步骤： #

1. 定义一个观察者接口，用来接收数据变化的回调：

public interface DataObserver {
    void onDataAdded(Object data);
    void onDataUpdated(Object data);
    void onDataDeleted(Object data);
}

2. 在数据控制器里维护一个观察者列表，提供注册/注销方法，在增删改时通知所有观察者：

public class DataController {
    private List<DataObserver> mObservers = new ArrayList<>();

    // 注册观察者
    public void registerObserver(DataObserver observer) {
        if (!mObservers.contains(observer)) {
            mObservers.add(observer);
        }
    }

    // 注销观察者
    public void unregisterObserver(DataObserver observer) {
        mObservers.remove(observer);
    }

    private void notifyObserversOnAdd(Object data) {
        for (DataObserver observer : mObservers) {
            observer.onDataAdded(data);
        }
    }

    private void notifyObserversOnUpdate(Object data) {
        for (DataObserver observer : mObservers) {
            observer.onDataUpdated(data);
        }
    }

    private void notifyObserversOnDelete(Object data) {
        for (DataObserver observer : mObservers) {
            observer.onDataDeleted(data);
        }
    }

    // 新增方法
    public void addData(Object data) {
        // 执行新增逻辑...
        notifyObserversOnAdd(data);
    }

    // 更新方法
    public void updateData(Object data) {
        // 执行更新逻辑...
        notifyObserversOnUpdate(data);
    }

    // 删除方法
    public void deleteData(Object data) {
        // 执行删除逻辑...
        notifyObserversOnDelete(data);
    }
}

3. 在需要监听的类里实现观察者接口，注册到数据控制器：

public class MyActivity extends AppCompatActivity implements DataObserver {
    private DataController mDataController;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_my);
        mDataController = new DataController();
        // 注册观察者
        mDataController.registerObserver(this);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        // 注销观察者，避免内存泄漏
        mDataController.unregisterObserver(this);
    }

    @Override
    public void onDataAdded(Object data) {
        Log.d("DataChange", "新增数据：" + data);
    }

    @Override
    public void onDataUpdated(Object data) {
        Log.d("DataChange", "更新数据：" + data);
    }

    @Override
    public void onDataDeleted(Object data) {
        Log.d("DataChange", "删除数据：" + data);
    }
}

小建议 #

• 如果是Jetpack项目，优先选LiveData，符合Android官方架构规范，生命周期安全；
• 如果需要跨进程或者复杂的组件通信，EventBus是不错的选择，但要记得及时注销；
• 自定义观察者模式适合轻量场景，完全可控，但需要自己处理线程切换（比如在UI线程更新UI的话，要手动用runOnUiThread）。

内容的提问来源于stack exchange，提问作者JustANoob