吃透 Android ContentProvider：从数据共享到跨应用访问的实战指南

class 卑微码农:
    def __init__(self):
        self.技能 = ['能读懂十年前祖传代码', '擅长用Ctrl+C/V搭建世界', '信奉"能跑就别动"的玄学']
        self.发量 = 100  # 初始发量
        self.咖啡因耐受度 = '极限'
        
    def 修Bug(self, bug):
        try:
            # 试图用玄学解决问题
            if bug.严重程度 == '离谱':
                print("这一定是环境问题！")
            else:
                print("让我看看是谁又没写注释...哦，是我自己。")
        except Exception as e:
            # 如果try块都救不了，那就...
            print("重启一下试试？")
            self.发量 -= 1  # 每解决一个bug，头发-1
 
 
# 实例化一个我
我 = 卑微码农()

前言：为什么 ContentProvider 是 Android 数据共享的 “终极方案”？

刚入门 Android 时，我曾困扰于 “如何让两个应用共享数据”——Activity 和 Service 通信能用 Binder，组件间简单通知能用广播，但涉及大量结构化数据（如用户信息、商品列表）的跨应用共享，总找不到安全又高效的方式。

直到接触了 ContentProvider，才发现它的核心价值：Android 系统提供的 “数据共享标准接口” 。它就像一个 “数据服务员”，统一管理数据源（数据库、文件、网络数据等），对外提供标准化的 CRUD（增删改查）操作，既解决了跨应用数据访问的安全问题，又屏蔽了底层数据源的实现细节。

但很多开发者用不好 ContentProvider，要么被 “URI 匹配”“权限配置” 搞得头大，要么遇到 “跨应用访问失败”“数据更新不通知” 的问题。其实 ContentProvider 的逻辑很清晰，关键是掌握 “URI 设计→CRUD 实现→权限配置→数据监听” 这四大核心步骤。

本文会把 ContentProvider 的基础概念、核心原理、实战示例、进阶用法、避坑指南全讲透。全文包含 8 个完整可运行的原创示例，从基础入门到进阶实战，新手能直接上手，进阶开发者能夯实基础、避开坑点。

建议先收藏，再跟着示例一步步实操，遇到问题可以在评论区交流～

一、ContentProvider 基础认知：到底什么是内容提供者？

1.1 一句话搞懂 ContentProvider 的核心作用

ContentProvider（简称 “CP”）是 Android 四大组件之一，核心作用是统一管理结构化数据，为跨应用、跨组件提供安全的标准化数据访问接口。

简单说：ContentProvider 就像一个 “公共数据仓库”—— 它封装了数据源（比如 SQLite 数据库、JSON 文件），对外暴露统一的 “增删改查” 方法，其他应用或组件无需知道数据存在哪里、如何存储，只需通过标准接口就能访问数据，同时还能通过权限控制确保数据安全。

举个实际场景：你的应用需要读取手机通讯录、相册图片、日历事件，这些数据都由系统内置的 ContentProvider 管理，你只需通过对应的 URI 调用接口，就能安全访问，无需直接操作系统数据库。

1.2 必须澄清的 3 个常见误解

误解 1：ContentProvider 就是数据库？—— 错！CP 是 “数据访问接口”，不是数据源本身，底层可对接 SQLite、文件、网络数据、Room 等；
误解 2：ContentProvider 只能跨应用共享数据？—— 错！同一应用内的组件（Activity、Service、Fragment）也能通过 CP 访问数据，优势是解耦数据源和业务逻辑；
误解 3：用 FileProvider 就是 ContentProvider？—— 对！FileProvider 是 ContentProvider 的子类，专门用于跨应用共享文件（如拍照、安装 APK），本质是 CP 的特殊实现。

1.3 ContentProvider 的核心特性

标准化接口：提供统一的 CRUD 方法（insert、delete、update、query），所有访问者都按同一规则操作；
跨应用访问：支持不同应用间数据共享，无需暴露数据源细节，安全性高；
权限控制：可通过 AndroidManifest 配置访问权限，限制哪些应用能读写数据；
数据监听：支持通过 ContentObserver 监听数据变化，数据更新时自动通知观察者；
兼容多数据源：底层可对接 SQLite、Room、文件、ContentResolver、网络数据等。

1.4 ContentProvider 的典型适用场景

跨应用数据共享：如通讯录、相册、日历等系统数据共享，第三方应用间数据互通；
应用内组件解耦：Activity、Service、Fragment 通过 CP 访问数据，避免直接操作数据库，降低耦合；
数据安全访问：需要严格控制读写权限的场景（如用户隐私数据、商业数据）；
多进程数据共享：同一应用的不同进程间数据通信（比 AIDL 更简单）。

二、ContentProvider 核心原理：URI、CRUD 与权限机制

要用好 ContentProvider，必须先掌握 3 个核心概念：URI（数据地址）、CRUD 方法（数据操作）、权限机制（数据安全），这是理解 CP 工作流程的基础。

2.1 URI：ContentProvider 的数据 “地址”

URI（Uniform Resource Identifier）是 ContentProvider 中数据的唯一标识，就像互联网上的 URL，用于定位具体的数据资源。

1. URI 的组成结构

标准的 CP URI 格式如下：

content://authority/path/segment

content://：固定前缀，表明这是 ContentProvider 的 URI（必须）；
authority：权威名，用于唯一标识一个 ContentProvider（通常用应用包名，如 com.example.provider），避免不同 CP 冲突；
path：路径，用于区分 CP 管理的不同数据集合（如 user、order、product）；
segment：片段，用于定位具体的数据记录（如单个用户 ID、单个订单 ID）。

2. 示例 URI 解析

URI 示例	含义
content://com.example.provider/user	定位 “用户” 数据集合（所有用户）
content://com.example.provider/user/1	定位 “用户” 集合中 ID 为 1 的单个用户记录
content://com.example.provider/order	定位 “订单” 数据集合（所有订单）

3. URI 匹配工具：UriMatcher

ContentProvider 接收 URI 后，需要通过UriMatcher判断 URI 对应的数据源和操作类型，这是 CP 的核心解析工具。

使用步骤：

创建 UriMatcher 实例（传入NO_MATCH表示不匹配时的返回值）；
通过addURI()方法添加需要匹配的 URI 模板；
在 CRUD 方法中调用match(uri)，根据返回的匹配码执行对应逻辑。

示例：

// 1. 创建UriMatcher实例
private static final UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
// 2. 定义匹配码（自定义，用于区分不同URI）
private static final int USER = 1; // 匹配“所有用户”
private static final int USER_ID = 2; // 匹配“单个用户”
private static final int ORDER = 3; // 匹配“所有订单”

static {
    // 3. 添加URI模板（参数：authority、path、匹配码）
    // 匹配 content://com.example.provider/user
    sUriMatcher.addURI("com.example.provider", "user", USER);
    // 匹配 content://com.example.provider/user/1（#表示数字占位符）
    sUriMatcher.addURI("com.example.provider", "user/#", USER_ID);
    // 匹配 content://com.example.provider/order
    sUriMatcher.addURI("com.example.provider", "order", ORDER);
}

// 4. 在CRUD方法中匹配URI
@Override
public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
    int matchCode = sUriMatcher.match(uri);
    switch (matchCode) {
        case USER:
            // 查询所有用户
            break;
        case USER_ID:
            // 查询单个用户（通过uri.getPathSegments().get(1)获取ID）
            String userId = uri.getPathSegments().get(1);
            break;
        case ORDER:
            // 查询所有订单
            break;
        default:
            // 不匹配的URI，抛出异常
            throw new IllegalArgumentException("未知的URI：" + uri);
    }
    // ... 执行查询逻辑
}

2.2 CRUD 核心方法：数据操作的标准化接口

ContentProvider 对外暴露 4 个核心方法，对应数据的增删改查，所有访问者都通过这 4 个方法操作数据，无需关心底层实现。

方法名	作用	参数说明	返回值
insert(Uri uri, ContentValues values)	插入数据	uri：数据地址；values：待插入的数据（键值对）	新插入数据的 URI（包含新记录 ID）
delete(Uri uri, String selection, String[] selectionArgs)	删除数据	selection：查询条件（如 “id=?”）；selectionArgs：条件参数	被删除的记录数
update(Uri uri, ContentValues values, String selection, String[] selectionArgs)	更新数据	values：要更新的数据；selection+selectionArgs：更新条件	被更新的记录数
query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder)	查询数据	projection：要查询的列；selection+selectionArgs：查询条件；sortOrder：排序规则	查询结果（Cursor 对象）

关键说明：

所有方法的第一个参数都是 URI，用于定位数据；
方法运行在主线程，不能做耗时操作（如网络请求），否则会触发 ANR；
数据操作的核心是 “匹配 URI→执行对应数据源操作”，底层数据源由开发者自行实现。

2.3 权限机制：控制数据访问安全

ContentProvider 的权限控制是其核心优势之一，通过配置可限制 “哪些应用能读数据、哪些能写数据”，避免敏感数据泄露。

1. 权限配置方式（在 AndroidManifest 中）

<!-- 1. 声明ContentProvider时配置权限 -->
<provider
    android:name=".MyContentProvider"
    android:authorities="com.example.provider" <!-- 与URI中的authority一致 -->
    android:readPermission="com.example.provider.READ_PERMISSION" <!-- 读权限 -->
    android:writePermission="com.example.provider.WRITE_PERMISSION" <!-- 写权限 -->
    android:exported="true" <!-- 允许跨应用访问（必须） --> />

<!-- 2. 定义自定义权限（需在manifest根节点下声明） -->
<permission
    android:name="com.example.provider.READ_PERMISSION"
    android:protectionLevel="normal" /> <!-- normal：普通权限，安装时授予 -->
<permission
    android:name="com.example.provider.WRITE_PERMISSION"
    android:protectionLevel="normal" />

2. 权限使用规则

其他应用要访问该 CP，需在其 Manifest 中声明对应的权限：

<!-- 其他应用声明读权限 -->
<uses-permission android:name="com.example.provider.READ_PERMISSION" />
<!-- 其他应用声明写权限 -->
<uses-permission android:name="com.example.provider.WRITE_PERMISSION" />

若未声明权限，访问时会抛出SecurityException；
可单独配置读 / 写权限（如只允许读、不允许写），实现精细化控制；
android:exported="true"表示允许跨应用访问，若仅应用内使用，可设为 false。

三、实战：自定义 ContentProvider（完整示例）

掌握核心原理后，我们通过 “用户数据管理” 场景，实现一个完整的自定义 ContentProvider，包含数据库封装、CRUD 方法实现、跨应用访问，新手可直接复制运行。

3.1 步骤 1：创建数据库帮助类（SQLite 数据源）

ContentProvider 底层需要数据源，这里用 SQLite 作为示例（最常用的结构化数据源），创建数据库帮助类管理数据库的创建和升级。

public class DBHelper extends SQLiteOpenHelper {
    // 数据库名
    private static final String DB_NAME = "UserDB";
    // 数据库版本
    private static final int DB_VERSION = 1;
    // 用户表名
    public static final String TABLE_USER = "user";
    // 用户表字段（id、姓名、年龄、地址）
    public static final String COL_ID = "_id"; // CP查询时，_id是默认的唯一标识列
    public static final String COL_NAME = "name";
    public static final String COL_AGE = "age";
    public static final String COL_ADDRESS = "address";

    // 创建用户表的SQL语句
    private static final String CREATE_TABLE_USER = "CREATE TABLE " + TABLE_USER + " (" +
            COL_ID + " INTEGER PRIMARY KEY AUTOINCREMENT, " +
            COL_NAME + " TEXT NOT NULL, " +
            COL_AGE + " INTEGER, " +
            COL_ADDRESS + " TEXT)";

    public DBHelper(Context context) {
        super(context, DB_NAME, null, DB_VERSION);
    }

    // 数据库首次创建时调用
    @Override
    public void onCreate(SQLiteDatabase db) {
        // 创建用户表
        db.execSQL(CREATE_TABLE_USER);
    }

    // 数据库版本升级时调用
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // 简单升级逻辑：删除旧表，创建新表（实际开发中需保留数据）
        db.execSQL("DROP TABLE IF EXISTS " + TABLE_USER);
        onCreate(db);
    }
}

3.2 步骤 2：自定义 ContentProvider（实现 CRUD 方法）

创建UserContentProvider类，继承ContentProvider，实现 URI 匹配、CRUD 方法、数据通知等核心逻辑。

public class UserContentProvider extends ContentProvider {
    // 1. 常量定义
    private static final String AUTHORITY = "com.example.provider"; // 与Manifest中一致
    private static final UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
    // 匹配码
    private static final int USER = 1; // 所有用户
    private static final int USER_ID = 2; // 单个用户
    // 基础URI（所有用户）
    public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/user");

    // 2. 成员变量
    private DBHelper mDbHelper;
    private SQLiteDatabase mDatabase;

    // 3. 静态代码块：初始化URI匹配规则
    static {
        // 匹配所有用户：content://com.example.provider/user
        sUriMatcher.addURI(AUTHORITY, "user", USER);
        // 匹配单个用户：content://com.example.provider/user/1
        sUriMatcher.addURI(AUTHORITY, "user/#", USER_ID);
    }

    // 4. ContentProvider创建时调用（仅一次）
    @Override
    public boolean onCreate() {
        // 初始化数据库帮助类
        mDbHelper = new DBHelper(getContext());
        mDatabase = mDbHelper.getWritableDatabase();
        return mDatabase != null;
    }

    // 5. 查询数据（核心方法）
    @Override
    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
        Cursor cursor;
        // 匹配URI
        int matchCode = sUriMatcher.match(uri);
        switch (matchCode) {
            case USER:
                // 查询所有用户（sortOrder：排序规则，如"_id DESC"）
                cursor = mDatabase.query(
                        DBHelper.TABLE_USER,
                        projection,
                        selection,
                        selectionArgs,
                        null,
                        null,
                        sortOrder
                );
                break;
            case USER_ID:
                // 查询单个用户（从URI中获取ID）
                String userId = uri.getPathSegments().get(1);
                // 拼接查询条件：_id = ?
                String singleSelection = DBHelper.COL_ID + " = ?";
                String[] singleArgs = new String[]{userId};
                cursor = mDatabase.query(
                        DBHelper.TABLE_USER,
                        projection,
                        singleSelection,
                        singleArgs,
                        null,
                        null,
                        sortOrder
                );
                break;
            default:
                throw new IllegalArgumentException("未知的URI：" + uri);
        }

        // 设置数据变化监听：当数据变化时，通知观察者
        if (getContext() != null) {
            cursor.setNotificationUri(getContext().getContentResolver(), uri);
        }
        return cursor;
    }

    // 6. 获取数据类型（MIME类型）
    @Override
    public String getType(Uri uri) {
        int matchCode = sUriMatcher.match(uri);
        switch (matchCode) {
            // 多个数据：vnd.android.cursor.dir/自定义类型
            case USER:
                return "vnd.android.cursor.dir/vnd." + AUTHORITY + ".user";
            // 单个数据：vnd.android.cursor.item/自定义类型
            case USER_ID:
                return "vnd.android.cursor.item/vnd." + AUTHORITY + ".user";
            default:
                throw new IllegalArgumentException("未知的URI：" + uri);
        }
    }

    // 7. 插入数据（核心方法）
    @Override
    public Uri insert(Uri uri, ContentValues values) {
        long newRowId; // 新插入记录的ID
        int matchCode = sUriMatcher.match(uri);
        switch (matchCode) {
            case USER:
                // 插入数据到用户表
                newRowId = mDatabase.insert(DBHelper.TABLE_USER, null, values);
                break;
            default:
                throw new IllegalArgumentException("不支持的插入URI：" + uri);
        }

        // 数据插入成功后，通知观察者（参数：uri表示变化的数据地址）
        if (getContext() != null && newRowId > 0) {
            getContext().getContentResolver().notifyChange(uri, null);
            // 返回新插入数据的URI（包含ID）
            return ContentUris.withAppendedId(CONTENT_URI, newRowId);
        }
        return null;
    }

    // 8. 删除数据（核心方法）
    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        int deletedCount; // 被删除的记录数
        int matchCode = sUriMatcher.match(uri);
        switch (matchCode) {
            case USER:
                // 删除符合条件的所有用户
                deletedCount = mDatabase.delete(DBHelper.TABLE_USER, selection, selectionArgs);
                break;
            case USER_ID:
                // 删除单个用户
                String userId = uri.getPathSegments().get(1);
                String singleSelection = DBHelper.COL_ID + " = ?";
                String[] singleArgs = new String[]{userId};
                deletedCount = mDatabase.delete(DBHelper.TABLE_USER, singleSelection, singleArgs);
                break;
            default:
                throw new IllegalArgumentException("不支持的删除URI：" + uri);
        }

        // 数据删除成功后，通知观察者
        if (getContext() != null && deletedCount > 0) {
            getContext().getContentResolver().notifyChange(uri, null);
        }
        return deletedCount;
    }

    // 9. 更新数据（核心方法）
    @Override
    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
        int updatedCount; // 被更新的记录数
        int matchCode = sUriMatcher.match(uri);
        switch (matchCode) {
            case USER:
                // 更新符合条件的所有用户
                updatedCount = mDatabase.update(DBHelper.TABLE_USER, values, selection, selectionArgs);
                break;
            case USER_ID:
                // 更新单个用户
                String userId = uri.getPathSegments().get(1);
                String singleSelection = DBHelper.COL_ID + " = ?";
                String[] singleArgs = new String[]{userId};
                updatedCount = mDatabase.update(DBHelper.TABLE_USER, values, singleSelection, singleArgs);
                break;
            default:
                throw new IllegalArgumentException("不支持的更新URI：" + uri);
        }

        // 数据更新成功后，通知观察者
        if (getContext() != null && updatedCount > 0) {
            getContext().getContentResolver().notifyChange(uri, null);
        }
        return updatedCount;
    }
}

3.3 步骤 3：在 Manifest 中注册 ContentProvider

这是关键步骤，必须配置 authority、权限、exported 等属性，否则 CP 无法被访问。

<!-- 1. 声明自定义权限（manifest根节点下） -->
<permission
    android:name="com.example.provider.READ_PERMISSION"
    android:protectionLevel="normal" />
<permission
    android:name="com.example.provider.WRITE_PERMISSION"
    android:protectionLevel="normal" />

<!-- 2. 注册ContentProvider -->
<provider
    android:name=".UserContentProvider"
    android:authorities="com.example.provider" <!-- 与CP中的AUTHORITY一致 -->
    android:readPermission="com.example.provider.READ_PERMISSION"
    android:writePermission="com.example.provider.WRITE_PERMISSION"
    android:exported="true" <!-- 允许跨应用访问 -->
    android:multiprocess="true" /> <!-- 支持多进程访问 -->

3.4 步骤 4：应用内访问 ContentProvider（ContentResolver）

ContentProvider 的访问入口是ContentResolver（内容解析器），所有组件（Activity、Service 等）都通过它调用 CP 的 CRUD 方法，无需直接操作 CP 实例。

示例 1：应用内插入、查询、更新、删除用户数据

public class MainActivity extends AppCompatActivity {
    private ContentResolver mContentResolver;
    private TextView tvResult;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        tvResult = findViewById(R.id.tv_result);
        // 获取ContentResolver实例（通过Context获取）
        mContentResolver = getContentResolver();

        // 1. 插入用户数据
        findViewById(R.id.btn_insert).setOnClickListener(v -> insertUser());
        // 2. 查询所有用户
        findViewById(R.id.btn_query_all).setOnClickListener(v -> queryAllUsers());
        // 3. 更新用户数据（更新ID=1的用户）
        findViewById(R.id.btn_update).setOnClickListener(v -> updateUser(1));
        // 4. 删除用户数据（删除ID=1的用户）
        findViewById(R.id.btn_delete).setOnClickListener(v -> deleteUser(1));
    }

    // 插入用户
    private void insertUser() {
        ContentValues values = new ContentValues();
        values.put(DBHelper.COL_NAME, "张三");
        values.put(DBHelper.COL_AGE, 25);
        values.put(DBHelper.COL_ADDRESS, "北京市海淀区");

        // 调用ContentResolver.insert()，传入CP的CONTENT_URI
        Uri newUri = mContentResolver.insert(UserContentProvider.CONTENT_URI, values);
        if (newUri != null) {
            Toast.makeText(this, "插入成功：" + newUri.toString(), Toast.LENGTH_SHORT).show();
        } else {
            Toast.makeText(this, "插入失败", Toast.LENGTH_SHORT).show();
        }
    }

    // 查询所有用户
    private void queryAllUsers() {
        // 要查询的列（null表示查询所有列）
        String[] projection = {
                DBHelper.COL_ID,
                DBHelper.COL_NAME,
                DBHelper.COL_AGE,
                DBHelper.COL_ADDRESS
        };
        // 查询条件（null表示查询所有记录）
        String selection = null;
        String[] selectionArgs = null;
        // 排序规则（按ID升序）
        String sortOrder = DBHelper.COL_ID + " ASC";

        // 调用query()查询数据，返回Cursor
        Cursor cursor = mContentResolver.query(
                UserContentProvider.CONTENT_URI,
                projection,
                selection,
                selectionArgs,
                sortOrder
        );

        // 解析Cursor数据
        StringBuilder result = new StringBuilder();
        if (cursor != null && cursor.moveToFirst()) {
            do {
                int id = cursor.getInt(cursor.getColumnIndexOrThrow(DBHelper.COL_ID));
                String name = cursor.getString(cursor.getColumnIndexOrThrow(DBHelper.COL_NAME));
                int age = cursor.getInt(cursor.getColumnIndexOrThrow(DBHelper.COL_AGE));
                String address = cursor.getString(cursor.getColumnIndexOrThrow(DBHelper.COL_ADDRESS));

                result.append("ID：").append(id)
                        .append("，姓名：").append(name)
                        .append("，年龄：").append(age)
                        .append("，地址：").append(address)
                        .append("\n");
            } while (cursor.moveToNext());
            cursor.close(); // 必须关闭Cursor，避免内存泄漏
        }

        tvResult.setText("查询结果：\n" + result);
    }

    // 更新用户（根据ID）
    private void updateUser(int userId) {
        ContentValues values = new ContentValues();
        values.put(DBHelper.COL_NAME, "张三（已更新）");
        values.put(DBHelper.COL_AGE, 26);

        // 更新条件：_id = ?
        String selection = DBHelper.COL_ID + " = ?";
        String[] selectionArgs = new String[]{String.valueOf(userId)};

        // 调用update()，返回更新的记录数
        int updatedCount = mContentResolver.update(
                UserContentProvider.CONTENT_URI,
                values,
                selection,
                selectionArgs
        );

        Toast.makeText(this, "更新成功：" + updatedCount + "条记录", Toast.LENGTH_SHORT).show();
    }

    // 删除用户（根据ID）
    private void deleteUser(int userId) {
        // 删除条件：_id = ?
        String selection = DBHelper.COL_ID + " = ?";
        String[] selectionArgs = new String[]{String.valueOf(userId)};

        // 调用delete()，返回删除的记录数
        int deletedCount = mContentResolver.delete(
                UserContentProvider.CONTENT_URI,
                selection,
                selectionArgs
        );

        Toast.makeText(this, "删除成功：" + deletedCount + "条记录", Toast.LENGTH_SHORT).show();
    }
}

3.5 关键说明：

ContentResolver是访问 CP 的唯一入口，所有 CRUD 操作都通过它调用，无需直接实例化 CP；
Cursor 使用后必须关闭，否则会导致内存泄漏；
插入 / 更新 / 删除数据后，CP 会调用notifyChange()通知观察者，后续会讲如何监听数据变化；
代码中所有常量（如 AUTHORITY、表名、列名）建议统一定义，避免拼写错误。

四、进阶用法：跨应用访问、数据监听与批量操作

基础用法只能满足应用内数据访问，实际开发中还会用到跨应用访问、数据变化监听、批量操作等进阶场景，下面结合示例详细讲解。

4.1 跨应用访问 ContentProvider（完整示例）

跨应用访问 CP 的核心是 “声明权限 + 使用正确的 URI”，下面创建一个新应用（接收方），访问上面应用（提供方）的用户数据。

步骤 1：接收方应用配置（Manifest）

在接收方应用的 AndroidManifest 中声明访问权限：

<!-- 声明访问提供方的读/写权限 -->
<uses-permission android:name="com.example.provider.READ_PERMISSION" />
<uses-permission android:name="com.example.provider.WRITE_PERMISSION" />

步骤 2：接收方应用访问 CP 数据

public class CrossAppActivity extends AppCompatActivity {
    private ContentResolver mContentResolver;
    private TextView tvCrossResult;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_cross_app);
        tvCrossResult = findViewById(R.id.tv_cross_result);
        mContentResolver = getContentResolver();

        // 跨应用查询提供方的用户数据
        findViewById(R.id.btn_cross_query).setOnClickListener(v -> crossQueryUsers());
        // 跨应用插入数据到提供方
        findViewById(R.id.btn_cross_insert).setOnClickListener(v -> crossInsertUser());
    }

    // 跨应用查询用户
    private void crossQueryUsers() {
        // 注意：URI必须与提供方的CP一致
        Uri providerUri = Uri.parse("content://com.example.provider/user");
        String[] projection = {
                "_id", // 提供方用户表的列名（必须与提供方一致）
                "name",
                "age",
                "address"
        };

        Cursor cursor = mContentResolver.query(
                providerUri,
                projection,
                null,
                null,
                "_id ASC"
        );

        StringBuilder result = new StringBuilder();
        if (cursor != null && cursor.moveToFirst()) {
            do {
                int id = cursor.getInt(cursor.getColumnIndexOrThrow("_id"));
                String name = cursor.getString(cursor.getColumnIndexOrThrow("name"));
                int age = cursor.getInt(cursor.getColumnIndexOrThrow("age"));
                String address = cursor.getString(cursor.getColumnIndexOrThrow("address"));

                result.append("跨应用查询结果：\n")
                        .append("ID：").append(id)
                        .append("，姓名：").append(name)
                        .append("，年龄：").append(age)
                        .append("，地址：").append(address)
                        .append("\n");
            } while (cursor.moveToNext());
            cursor.close();
        }

        tvCrossResult.setText(result);
    }

    // 跨应用插入用户
    private void crossInsertUser() {
        Uri providerUri = Uri.parse("content://com.example.provider/user");
        ContentValues values = new ContentValues();
        values.put("name", "李四（跨应用插入）");
        values.put("age", 30);
        values.put("address", "上海市浦东新区");

        Uri newUri = mContentResolver.insert(providerUri, values);
        if (newUri != null) {
            Toast.makeText(this, "跨应用插入成功：" + newUri, Toast.LENGTH_SHORT).show();
        } else {
            Toast.makeText(this, "跨应用插入失败", Toast.LENGTH_SHORT).show();
        }
    }
}

跨应用访问关键注意事项：

接收方必须声明提供方定义的权限，否则会抛出安全异常；
URI 必须与提供方的 CP 完全一致（authority、path 都不能错）；
提供方的 CP 必须设置android:exported="true"，否则拒绝跨应用访问；
列名、表结构必须与提供方一致，建议提供方对外暴露列名常量（如通过 SDK）。

4.2 数据变化监听：ContentObserver

ContentProvider 的数据变化后，可通过ContentObserver（内容观察者）监听，实现 “数据更新→UI 自动刷新” 的效果，无需手动查询。

示例 2：监听用户数据变化，自动刷新 UI

public class ObserverActivity extends AppCompatActivity {
    private ContentResolver mContentResolver;
    private TextView tvObserverResult;
    // 自定义ContentObserver
    private UserDataObserver mDataObserver;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_observer);
        tvObserverResult = findViewById(R.id.tv_observer_result);
        mContentResolver = getContentResolver();

        // 初始化并注册观察者
        initObserver();
        // 初始查询一次数据
        queryUsers();
    }

    // 初始化ContentObserver
    private void initObserver() {
        mDataObserver = new UserDataObserver(new Handler(Looper.getMainLooper()));
        // 注册观察者：监听CP的用户数据URI，true表示监听子URI（如user/1）
        mContentResolver.registerContentObserver(
                UserContentProvider.CONTENT_URI,
                true,
                mDataObserver
        );
    }

    // 查询用户数据（用于刷新UI）
    private void queryUsers() {
        Uri uri = UserContentProvider.CONTENT_URI;
        String[] projection = {"_id", "name", "age", "address"};
        Cursor cursor = mContentResolver.query(uri, projection, null, null, "_id ASC");

        StringBuilder result = new StringBuilder();
        if (cursor != null && cursor.moveToFirst()) {
            do {
                int id = cursor.getInt(cursor.getColumnIndexOrThrow("_id"));
                String name = cursor.getString(cursor.getColumnIndexOrThrow("name"));
                result.append("ID：").append(id).append("，姓名：").append(name).append("\n");
            } while (cursor.moveToNext());
            cursor.close();
        }

        tvObserverResult.setText("当前用户列表（自动刷新）：\n" + result);
    }

    // 自定义ContentObserver（监听数据变化）
    private class UserDataObserver extends ContentObserver {
        public UserDataObserver(Handler handler) {
            super(handler);
        }

        // 数据变化时触发（运行在Handler指定的线程，这里是主线程）
        @Override
        public void onChange(boolean selfChange, Uri uri) {
            super.onChange(selfChange, uri);
            Log.d("ObserverTest", "数据变化，URI：" + uri);
            // 数据变化后，重新查询并刷新UI
            queryUsers();
        }
    }

    // 注销观察者（避免内存泄漏）
    @Override
    protected void onDestroy() {
        super.onDestroy();
        mContentResolver.unregisterContentObserver(mDataObserver);
    }
}

关键说明：

ContentObserver的onChange()方法运行在registerContentObserver()时指定的 Handler 线程，这里用主线程 Handler，可直接刷新 UI；
注册时notifyForDescendants参数设为 true，表示监听 URI 的子 URI（如user/1、user/2）变化；
必须在组件销毁时注销观察者，否则会导致内存泄漏；
只有 CP 中调用了notifyChange()，观察者才会收到通知，否则无法监听。

4.3 批量操作：高效处理多条数据

如果需要插入、更新、删除多条数据，逐个调用insert()/update()/delete()效率较低，可使用ContentResolver.applyBatch()实现批量操作。

示例 3：批量插入 10 条用户数据

public class BatchOperationActivity extends AppCompatActivity {
    private ContentResolver mContentResolver;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_batch);
        mContentResolver = getContentResolver();

        // 批量插入10条数据
        findViewById(R.id.btn_batch_insert).setOnClickListener(v -> batchInsertUsers());
    }

    private void batchInsertUsers() {
        Uri uri = UserContentProvider.CONTENT_URI;
        ArrayList<ContentProviderOperation> operations = new ArrayList<>();

        // 添加10条插入操作
        for (int i = 0; i < 10; i++) {
            ContentValues values = new ContentValues();
            values.put("name", "批量用户" + (i + 1));
            values.put("age", 20 + i);
            values.put("address", "批量地址" + (i + 1));

            // 创建插入操作（参数：URI、null、ContentValues）
            ContentProviderOperation operation = ContentProviderOperation.newInsert(uri)
                    .withValues(values)
                    .build();
            operations.add(operation);
        }

        try {
            // 执行批量操作，返回操作结果
            ContentProviderResult[] results = mContentResolver.applyBatch(uri.getAuthority(), operations);
            Toast.makeText(this, "批量插入成功：" + results.length + "条数据", Toast.LENGTH_SHORT).show();
        } catch (Exception e) {
            e.printStackTrace();
            Toast.makeText(this, "批量插入失败：" + e.getMessage(), Toast.LENGTH_SHORT).show();
        }
    }
}

关键说明：

批量操作通过ContentProviderOperation封装单个操作，支持 insert、update、delete；
调用applyBatch()时，参数是 CP 的 authority，而非具体 URI；
批量操作是原子性的，要么全部成功，要么全部失败（避免部分数据操作成功）；
适用于批量导入数据、批量更新状态等场景，比逐个操作效率高 50% 以上。

4.4 访问系统 ContentProvider：读取通讯录、相册

Android 系统内置了多个 ContentProvider，用于管理通讯录、相册、日历、短信等系统数据，开发者可通过标准接口访问，无需关心底层实现。

示例 4：读取系统通讯录（需权限）

步骤 1：添加权限（Manifest）

<!-- 读取通讯录权限 -->
<uses-permission android:name="android.permission.READ_CONTACTS" />
<!-- Android 13+需添加以下权限 -->
<uses-permission android:name="android.permission.READ_CONTACTS" android:maxSdkVersion="32" />
<uses-permission android:name="android.permission.READ_CONTACTS" />

步骤 2：动态申请权限并读取通讯录

public class SystemProviderActivity extends AppCompatActivity {
    private static final int REQUEST_READ_CONTACTS = 100;
    private ContentResolver mContentResolver;
    private TextView tvContacts;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_system_provider);
        tvContacts = findViewById(R.id.tv_contacts);
        mContentResolver = getContentResolver();

        // 读取通讯录（先申请权限）
        findViewById(R.id.btn_read_contacts).setOnClickListener(v -> readContacts());
    }

    private void readContacts() {
        // 检查权限
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.READ_CONTACTS)
                != PackageManager.PERMISSION_GRANTED) {
            // 未授权，动态申请
            ActivityCompat.requestPermissions(
                    this,
                    new String[]{Manifest.permission.READ_CONTACTS},
                    REQUEST_READ_CONTACTS
            );
            return;
        }

        // 权限已授权，读取通讯录
        // 系统通讯录的URI（固定）
        Uri contactsUri = ContactsContract.CommonDataKinds.Phone.CONTENT_URI;
        // 要查询的列（姓名、电话号码）
        String[] projection = {
                ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME,
                ContactsContract.CommonDataKinds.Phone.NUMBER
        };

        Cursor cursor = mContentResolver.query(
                contactsUri,
                projection,
                null,
                null,
                null
        );

        StringBuilder result = new StringBuilder();
        if (cursor != null && cursor.moveToFirst()) {
            do {
                String name = cursor.getString(cursor.getColumnIndexOrThrow(
                        ContactsContract.CommonDataKinds.Phone.DISPLAY_NAME));
                String number = cursor.getString(cursor.getColumnIndexOrThrow(
                        ContactsContract.CommonDataKinds.Phone.NUMBER));
                result.append("姓名：").append(name).append("，电话：").append(number).append("\n");
            } while (cursor.moveToNext());
            cursor.close();
        }

        tvContacts.setText("通讯录列表：\n" + result);
    }

    // 权限申请结果回调
    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == REQUEST_READ_CONTACTS) {
            if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                // 权限通过，读取通讯录
                readContacts();
            } else {
                Toast.makeText(this, "请授予读取通讯录权限", Toast.LENGTH_SHORT).show();
            }
        }
    }
}

系统常用 ContentProvider URI 汇总：

系统数据	URI（固定）	核心列名
通讯录	ContactsContract.CommonDataKinds.Phone.CONTENT_URI	DISPLAY_NAME（姓名）、NUMBER（电话）
相册图片	MediaStore.Images.Media.EXTERNAL_CONTENT_URI	DATA（路径）、DISPLAY_NAME（文件名）
日历事件	Events.CONTENT_URI（需导入 Calendar Provider）	TITLE（标题）、DTSTART（开始时间）
短信	Telephony.Sms.CONTENT_URI	ADDRESS（号码）、BODY（内容）、DATE（时间）

五、ContentProvider 与 Room 的结合（现代 Android 开发推荐）

Room 是 Google 推荐的 ORM（对象关系映射）框架，简化了 SQLite 的使用，同时支持与 ContentProvider 无缝结合，兼顾数据共享和开发效率。

5.1 核心优势：Room + ContentProvider

Room 负责数据库的创建、升级、CRUD 操作，无需手动写 SQL；
ContentProvider 负责对外暴露接口、权限控制、跨应用共享；
两者结合，既保留了 Room 的开发效率，又具备了 ContentProvider 的数据共享能力。

5.2 实战示例：Room + ContentProvider 实现数据共享

步骤 1：添加 Room 依赖（build.gradle）

dependencies {
    // Room核心依赖
    implementation 'androidx.room:room-runtime:2.5.2'
    annotationProcessor 'androidx.room:room-compiler:2.5.2'
    // 可选：KTX扩展（Java项目可省略）
    implementation 'androidx.room:room-ktx:2.5.2'
}

步骤 2：创建 Room 实体类（对应数据库表）

// 用户实体类（Room自动生成表结构）
@Entity(tableName = "room_user")
public class RoomUser {
    @PrimaryKey(autoGenerate = true)
    private long id; // 主键，自动增长
    private String name;
    private int age;
    private String address;

    // 构造方法、getter/setter
    public RoomUser(String name, int age, String address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    // getter/setter（必须）
    public long getId() { return id; }
    public void setId(long id) { this.id = id; }
    public String getName() { return name; }
    public void setName(String name) { this.name = name; }
    public int getAge() { return age; }
    public void setAge(int age) { this.age = age; }
    public String getAddress() { return address; }
    public void setAddress(String address) { this.address = address; }
}

步骤 3：创建 Room DAO（数据访问接口）

// DAO：定义数据库操作方法（Room自动实现）
@Dao
public interface UserDao {
    // 插入用户
    @Insert
    long insertUser(RoomUser user);

    // 查询所有用户
    @Query("SELECT * FROM room_user ORDER BY id ASC")
    List<RoomUser> getAllUsers();

    // 根据ID查询用户
    @Query("SELECT * FROM room_user WHERE id = :userId")
    RoomUser getUserById(long userId);

    // 更新用户
    @Update
    int updateUser(RoomUser user);

    // 根据ID删除用户
    @Delete
    int deleteUser(RoomUser user);
}

步骤 4：创建 Room 数据库实例

// 数据库实例（单例模式）
@Database(entities = {RoomUser.class}, version = 1, exportSchema = false)
public abstract class AppDatabase extends RoomDatabase {
    // 单例实例
    private static volatile AppDatabase INSTANCE;
    // 获取DAO接口
    public abstract UserDao userDao();

    // 获取数据库实例
    public static AppDatabase getInstance(Context context) {
        if (INSTANCE == null) {
            synchronized (AppDatabase.class) {
                if (INSTANCE == null) {
                    INSTANCE = Room.databaseBuilder(
                            context.getApplicationContext(),
                            AppDatabase.class,
                            "RoomUserDB" // 数据库名
                    ).allowMainThreadQueries() // 允许主线程查询（仅示例用，实际开发不推荐）
                            .build();
                }
            }
        }
        return INSTANCE;
    }
}

步骤 5：自定义 ContentProvider（基于 Room）

public class RoomContentProvider extends ContentProvider {
    private static final String AUTHORITY = "com.example.room.provider";
    private static final UriMatcher sUriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
    private static final int ROOM_USER = 1;
    private static final int ROOM_USER_ID = 2;
    public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORITY + "/room_user");

    private AppDatabase mAppDatabase;
    private UserDao mUserDao;

    static {
        sUriMatcher.addURI(AUTHORITY, "room_user", ROOM_USER);
        sUriMatcher.addURI(AUTHORITY, "room_user/#", ROOM_USER_ID);
    }

    @Override
    public boolean onCreate() {
        // 初始化Room数据库
        mAppDatabase = AppDatabase.getInstance(getContext());
        mUserDao = mAppDatabase.userDao();
        return true;
    }

    @Override
    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder) {
        List<RoomUser> userList;
        int matchCode = sUriMatcher.match(uri);
        switch (matchCode) {
            case ROOM_USER:
                userList = mUserDao.getAllUsers();
                break;
            case ROOM_USER_ID:
                long userId = Long.parseLong(uri.getPathSegments().get(1));
                RoomUser user = mUserDao.getUserById(userId);
                userList = new ArrayList<>();
                if (user != null) {
                    userList.add(user);
                }
                break;
            default:
                throw new IllegalArgumentException("未知URI：" + uri);
        }

        // 将Room查询结果（List）转换为Cursor（CP要求返回Cursor）
        MatrixCursor cursor = new MatrixCursor(new String[]{"_id", "name", "age", "address"});
        for (RoomUser user : userList) {
            cursor.addRow(new Object[]{
                    user.getId(),
                    user.getName(),
                    user.getAge(),
                    user.getAddress()
            });
        }

        // 设置数据变化监听
        if (getContext() != null) {
            cursor.setNotificationUri(getContext().getContentResolver(), uri);
        }
        return cursor;
    }

    @Override
    public String getType(Uri uri) {
        int matchCode = sUriMatcher.match(uri);
        switch (matchCode) {
            case ROOM_USER:
                return "vnd.android.cursor.dir/vnd." + AUTHORITY + ".room_user";
            case ROOM_USER_ID:
                return "vnd.android.cursor.item/vnd." + AUTHORITY + ".room_user";
            default:
                throw new IllegalArgumentException("未知URI：" + uri);
        }
    }

    @Override
    public Uri insert(Uri uri, ContentValues values) {
        int matchCode = sUriMatcher.match(uri);
        if (matchCode != ROOM_USER) {
            throw new IllegalArgumentException("不支持插入URI：" + uri);
        }

        // 从ContentValues转换为RoomUser对象
        String name = values.getAsString("name");
        int age = values.getAsInteger("age");
        String address = values.getAsString("address");
        RoomUser user = new RoomUser(name, age, address);

        // 调用Room DAO插入数据
        long newUserId = mUserDao.insertUser(user);

        // 通知数据变化
        if (getContext() != null && newUserId > 0) {
            getContext().getContentResolver().notifyChange(uri, null);
            return ContentUris.withAppendedId(CONTENT_URI, newUserId);
        }
        return null;
    }

    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        int deletedCount = 0;
        int matchCode = sUriMatcher.match(uri);
        switch (matchCode) {
            case ROOM_USER_ID:
                long userId = Long.parseLong(uri.getPathSegments().get(1));
                RoomUser user = mUserDao.getUserById(userId);
                if (user != null) {
                    deletedCount = mUserDao.deleteUser(user);
                }
                break;
            default:
                throw new IllegalArgumentException("不支持删除URI：" + uri);
        }

        if (getContext() != null && deletedCount > 0) {
            getContext().getContentResolver().notifyChange(uri, null);
        }
        return deletedCount;
    }

    @Override
    public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs) {
        int updatedCount = 0;
        int matchCode = sUriMatcher.match(uri);
        switch (matchCode) {
            case ROOM_USER_ID:
                long userId = Long.parseLong(uri.getPathSegments().get(1));
                RoomUser user = mUserDao.getUserById(userId);
                if (user != null) {
                    // 更新用户信息
                    if (values.containsKey("name")) {
                        user.setName(values.getAsString("name"));
                    }
                    if (values.containsKey("age")) {
                        user.setAge(values.getAsInteger("age"));
                    }
                    if (values.containsKey("address")) {
                        user.setAddress(values.getAsString("address"));
                    }
                    updatedCount = mUserDao.updateUser(user);
                }
                break;
            default:
                throw new IllegalArgumentException("不支持更新URI：" + uri);
        }

        if (getContext() != null && updatedCount > 0) {
            getContext().getContentResolver().notifyChange(uri, null);
        }
        return updatedCount;
    }
}

步骤 6：注册 CP（Manifest）

<permission
    android:name="com.example.room.provider.READ_PERMISSION"
    android:protectionLevel="normal" />
<permission
    android:name="com.example.room.provider.WRITE_PERMISSION"
    android:protectionLevel="normal" />

<provider
    android:name=".RoomContentProvider"
    android:authorities="com.example.room.provider"
    android:readPermission="com.example.room.provider.READ_PERMISSION"
    android:writePermission="com.example.room.provider.WRITE_PERMISSION"
    android:exported="true" />

关键说明：

Room 负责数据库底层操作，CP 负责对外暴露接口，两者职责分离；
Room 查询结果是 List 对象，需转换为 Cursor（CP 要求返回 Cursor），可使用MatrixCursor手动构建；
实际开发中，避免在主线程执行 Room 查询，可通过ViewModel+Coroutine或AsyncTask切换到子线程。

六、ContentProvider 常见坑点与避坑指南（实战经验总结）

6.1 坑点 1：URI 匹配错误，导致 CRUD 方法无法执行

现象：调用 CP 的 query/insert 方法时，抛出IllegalArgumentException（未知 URI）；
原因：
1. URI 的 authority 与 CP 中定义的 AUTHORITY 不一致；
2. URI 的 path 与UriMatcher中添加的模板不匹配；
3. 单个数据的 URI 缺少 ID（如user而非user/1）；
解决方案：
1. 统一定义 AUTHORITY 常量，确保 URI 中的 authority 与 CP、Manifest 一致；
2. 检查UriMatcher.addURI()的 path 参数与实际 URI 的 path 是否一致；
3. 单个数据操作时，确保 URI 包含 ID（通过ContentUris.withAppendedId()构建）。

6.2 坑点 2：跨应用访问失败，权限配置错误

现象：其他应用访问 CP 时，抛出SecurityException（权限拒绝）；
原因：
1. 提供方未定义权限，或接收方未声明对应权限；
2. 提供方的 CP 未设置android:exported="true"；
3. 权限的protectionLevel设置为dangerous，但未动态申请；
解决方案：
1. 提供方定义权限，接收方必须声明对应权限；
2. 提供方的 CP 设置android:exported="true"；
3. 若权限为dangerous（如访问通讯录、定位），接收方需动态申请。

6.3 坑点 3：CRUD 方法耗时导致 ANR

现象：调用 CP 的 query/insert 方法后，应用无响应，弹出 ANR 提示；
原因：CP 的 CRUD 方法运行在主线程，执行了耗时操作（如网络请求、大量数据查询）；
解决方案：
1. 耗时操作（如数据库查询、文件读写）移到子线程执行；
2. 可使用AsyncTask、Thread、Coroutine等工具切换线程；
3. Room+CP 场景中，使用Room.databaseBuilder().allowMainThreadQueries()仅用于示例，实际开发需禁用，通过子线程查询。

6.4 坑点 4：Cursor 未关闭导致内存泄漏

现象：应用长期运行后，内存占用持续升高，通过 LeakCanary 检测到 Cursor 泄漏；
原因：调用ContentResolver.query()后，未关闭 Cursor；

解决方案：

Cursor 使用完毕后，必须调用cursor.close()；
推荐使用try-with-resources语法（自动关闭 Cursor）：

try (Cursor cursor = mContentResolver.query(uri, projection, selection, selectionArgs, sortOrder)) {
    // 解析Cursor数据
} catch (Exception e) {
    e.printStackTrace();
}

6.5 坑点 5：数据变化后，ContentObserver 未收到通知

现象：CP 中的数据更新了，但观察者的onChange()方法未触发；
原因：
1. CP 的 CRUD 方法中未调用notifyChange()；
2. 注册观察者时，notifyForDescendants参数设为 false，且数据变化的 URI 是子 URI；
解决方案：
1. 在 CP 的 insert、update、delete 方法中，数据操作成功后调用notifyChange()；
2. 注册观察者时，根据需求设置notifyForDescendants为 true（监听子 URI）。

6.6 坑点 6：Room 与 CP 结合时，Cursor 转换错误

现象：Room 查询结果转换为 Cursor 后，接收方解析不到数据；
原因：
1. Cursor 的列名与接收方预期的列名不一致；
2. MatrixCursor构建时，列名数组与添加行数据的顺序不一致；
解决方案：
1. 统一列名定义（如_id、name），确保 CP 和接收方使用相同的列名；
2. MatrixCursor的列名数组与addRow()的参数顺序必须一致。

七、总结：ContentProvider 核心知识点图谱

到这里，ContentProvider 的核心内容已经全部讲完，我们用一张图谱梳理重点：

ContentProvider核心知识点
├── 基础认知：跨应用/跨组件数据共享接口、3个核心特性、典型场景
├── 核心原理：
│   - URI：数据地址（authority+path+segment）、UriMatcher匹配
│   - CRUD：insert/delete/update/query标准化方法
│   - 权限：自定义权限、读/写权限控制、exported属性
├── 实战用法：
│   - 自定义CP：SQLite数据源、CRUD实现、Manifest注册
│   - 数据访问：ContentResolver调用CP接口
│   - 跨应用访问：权限声明+正确URI
│   - 数据监听：ContentObserver监听数据变化
│   - 批量操作：ContentProviderOperation高效处理多条数据
│   - 系统CP：访问通讯录、相册等系统数据
│   - Room+CP：现代开发推荐方案（ORM+数据共享）
├── 避坑指南：URI匹配错误、权限问题、ANR、内存泄漏、数据监听失效

其实 ContentProvider 的学习关键是 “理解接口本质 + 掌握标准化流程”—— 它本质是一个 “数据访问中间层”，屏蔽了底层数据源，对外提供统一接口。不管是自定义 CP，还是访问系统 CP，核心都是 “通过 URI 定位数据，通过 ContentResolver 调用 CRUD 方法”。

把文中的示例逐个敲一遍，结合日志观察执行流程，再在实际项目中应用，很快就能熟练掌握。如果遇到具体问题，可以在评论区留言，我会第一时间回复～