Android开发之内容提供者——创建自己的ContentProvider(详解)

悠悠 2022-05-31 02:23 270阅读 0赞

转载请注明出处：[http://blog.csdn.net/dmk877/article/details/50387741][http_blog.csdn.net_dmk877_article_details_50387741]

苦心人天不负卧薪尝胆三千越甲可吞吴,有志者天不负釜底抽薪百二秦川终属楚。这是一对非常励志的名言，每当读这句话都会被震撼一下，然后接着颓废，哈哈，最近的工作比较忙，也在这里提醒自己，一定要坚持下去，一定要坚持一件对自己有益的事情。

装逼到此进入正题，今天要讨论的主要内容是ContentProvider(内容提供者)，ContentProvider也是android的四大组件之一，可见其在android中的重要性，可能大家用ContentProvider比其他三个组件用的少一点，但是ContentProvider同样的非常重要，有的人知道怎么使用ContentProvider，但是对于ContentProvider的原理等，并没有搞清楚，没关系，通过本篇博客相信你会对ContentProvider有一个全新的认识。

通过本篇博客你将学到以下知识

①什么是内容提供者

②为什么会有内容提供者

③怎样使用内容提供者

④ContentProvider中的Uri的详细介绍

⑤ContentResolver讲解

⑥UriMatch用法介绍

⑦ContentObserver用法详解

⑧通过一个案例来讲解自定义ContentProvider的执行过程(下一篇将给大家带来调用系统的ContentProvider)

**1.什么是内容提供者？**

首先我们必须要明白的是ContentProvider(内容提供者)是android中的四大组件之一，但是在一般的开发中，可能使用比较少。ContentProvider为不同的软件之间数据共享，提供统一的接口。而且ContentProvider是以类似数据库中表的方式将数据暴露，也就是说ContentProvider就像一个“数据库”。那么外界获取其提供的数据，也就应该与从数据库中获取数据的操作基本一样，只不过是采用URI来表示外界需要访问的“数据库”。至于如何从URI中识别出外界需要的是哪个“数据库”这就是Android底层需要做的事情了，也就是说，如果我们想让其他的应用使用我们自己程序内的数据，就可以使用ContentProvider定义一个对外开放的接口，从而使得其他的应用可以使用我们自己应用中的文件、数据库内存储的信息。当然，自己开发的应用需要给其他应用共享信息的需求可能比较少见，但是在Android系统中，很多数据如：联系人信息、短信信息、图片库、音频库等，这些信息在开发中还是经常用到的，这些信息谷歌工程师已经帮我们封装好了，我们可以使用谷歌给我的Uri去直接访问这些数据。所以对于ContentProvider我们还是需要认真的学习的，在遇到获取联系人信息，图片库，音视频库等需求的时候，才能更好的实现功能。

**2.为什么会有内容提供者？**

当应用继承ContentProvider类，并重写该类用于提供数据和存储数据的方法，就可以向其他应用共享其数据。虽然使用其他方法也可以对外共享数据，但数据访问方式会因数据存储的方式而不同，如：采用文件方式对外共享数据，需要进行文件操作读写数据；采用sharedpreferences共享数据，需要使用sharedpreferences API读写数据。而使用ContentProvider共享数据的好处是统一了数据访问方式，这也是为什么会有内容提供者的原因。

**3.怎么使用内容提供者？**

在理解了什么是内容提供者，为什么会有内容提供者之后，我想在大家脑海中的浮现的一个问题就是怎么使用内容提供者，这也是今天我们要讨论的重点内容。在前面的博客我也说到学习这种东西的最好方法是看谷歌给出的官方文档，那么好我们先来翻译一段谷歌给出的介绍(注：这是本地的文档，我采用的是脱机工作地址(file:///D:/adt-bundle-windows-x86\_64\_20140101/sdk/docs/reference/android/content/ContentProvider.html))。

翻译：

内容提供者是android应用程序的基本构建块之一，它们封装数据并将封装的数据通过单一的ContentResolver接口提供给应用程序。当你需要在多个应用之间共享数据的时候就需要用到内容提供者。例如，手机中的联系人数据会被多个应用所用到所以必须要用内容提供者存储起来。如果你不需要在多个应用之间共享数据，你可以使用一个数据库，直接通过SQLite数据库。 当通过content resolver发送一个请求时，系统会检查给定的URI并把请求传给有注册授权的Contentprovider。 UriMatcher类有助于解析uri。

需要实现的主要方法是：

public boolean onCreate () 在创建ContentProvider时调用

public Cursor query (Uri, String\[\], String, String\[\], String) 用于查询指定Uri的ContentProvider，返回一个Cursor

public Uri insert (Uri, ContentValues) 用于添加数据到指定Uri的ContentProvider中，(外部应用向ContentProvider中添加数据)

public int update (Uri, ContentValues, String, String\[\]) 用于更新指定Uri的ContentProvider中的数据

public int delete (Uri, String, String\[\]) 用于从指定Uri的ContentProvider中删除数据

public String getType (Uri) 用于返回指定的Uri中的数据的MIME类型

数据访问的方法（如：insert(Uri, ContentValues) and update(Uri, ContentValues, String, String\[\])）可能被多个线程同时调用，此时必须是线程安全的。其他方法(如： onCreate())只能被应用的主线程调用，它应当避免冗长的操作。 ContentResolver（内容解析者）请求被自动转发到合适的内容提供者实例 ,所以子类不需要担心跨进程调用的细节。

唉，每次最头疼的就是看全英文的文档，发现自己的英语水平太差，最近也在空闲时间学习学习英语，但是对于英语从来就没感兴趣过，希望自己可以坚持一段时间吧，其实在开发过程中遇到那些比较难解决的问题，在国外的有名的网站中基本都是可以查找到的，但是对于我这样一个英语水平差的人来说，说多了其实都是眼泪。。。，我先哭一会。。。

关于怎样使用ContentProvider后面有实例帮助大家理解。

**4.Uri详解**

在上面的翻译中如果你认真看的话你会发现在谷歌的官方文档中提到了ContentResolver(内容解析者)，外界可以通过ContentResolver接口来访问ContentProvider(内容提供者)中的数据。但是在详细了解ContentResolver之前有一项工作是必须要做的，那就是先理解Uri，在谷歌文档中也有介绍，接下来我们就来详细的学习下Uri这个类

Uri 通用资源标志符（Universal Resource Identifier）Uri代表要操作的数据，Android中可用的每种资源 - 图像、视频片段等都可以用Uri来表示。Uri的结构由以下几个部分组成

scheme、authority、path、query和fragment组成。其中authority又分为host和port。它的格式根据划分的详细程度可以分为三种

如下：

\[scheme:\]\[scheme-specific-part\]\[\#fragment\]

\[scheme:\]\[//authority\]\[path\]\[?query\]\[\#fragment\]

\[scheme:\]\[//host:port\]\[path\]\[?query\]\[\#fragment\]——最详细的划分形式

看到这里肯定有人糊里糊涂的，接着我们就来举一个例子来帮助大家详细的理解Uri这个类的结构

假如有这么一个Uri: [http://www.baidu.com:8080/][http_www.baidu.com_8080]yourpath/fileName.html?id=15&name=du\#dmk

你能将上述Uri进行提取吗？接着我们就比着标准的格式\[scheme:\]\[//host:port\]\[path\]\[?query\]\[\#fragment\]来将这个Uri各个部分提取出来

scheme:根据标准格式可以看出这里的scheme就是Uri前面//前面的部分这里也就是 **http:。**

fragment:dmk这个也是比较容易找到的，在\#后面

query:id=15&name=du\#dmk。从标准格式可以看到在”\#”之前”?”之后的部分是query，在这里当然就是id=15&name=du\#dmk了。

authority:从格式二中可以看到authority是在//后的部分，它的终点就是在path之前所以这里的authority就是 [www.baidu.com:8080][http_www.baidu.com_8080]

path：path就是？之前，主机之后的部分那就是yourpath/fileName.html

host和port:因为主机可以分为host和port所以这里的host和port分别为： [www.baidu.com][http_www.baidu.com_8080]和8080

这里要提醒大家注意的是：在Uri中并不是上述所有的字段都必须有的除了scheme、authority是必须要有的，其它的几个path、query、fragment，它们每一个可以选择性的要或不要，但顺序不能变，比方说在上述Uri中没有path那它的格式就为： [http://www.baidu.com:8080/][http_www.baidu.com_8080]?id=15&name=du\#dmk。

在理解了Uri的格式之后，有的人可能会说Uri的各个字段能否用代码获取？答案是肯定的

这里我们同样以 [http://www.baidu.com:8080/][http_www.baidu.com_8080]yourpath/fileName.html?id=15&name=du\#dmk为例

*  **getScheme() :**获取Uri中的scheme字符串部分，在这里是http
 *  **getSchemeSpecificPart():**获取Uri中的scheme-specific-part:部分，这里是:[http://www.baidu.com:8080/][http_www.baidu.com_8080]yourpath/fileName.html?
 *  **getFragment():**获取Uri中的fragment部分，即dmk
 *  **getAuthority():**获取Uri中Authority部分，即[www.baidu.com:8080][http_www.baidu.com_8080]
 *  **getPath():**获取Uri中path部分，即/yourpath/fileName.html
 *  **getQuery():**获取Uri中的query部分，即id=15&name=du
 *  **getHost():**获取Authority中的Host字符串，即[www.baidu.com][http_www.baidu.com_8080]
 *  **getPost():**获取Authority中的Port字符串，即8080

到这里关于Uri的介绍就完了(这里的关于Uri的介绍的内容主要来自： [Uri详解之——Uri结构与代码提取][Uri_Uri] 和 [Java魔法堂：URI、URL（含URL Protocol Handler][Java_URI_URL_URL Protocol Handler] )

**5.ContentResolver讲解**

在了解了Uri之后就可以来学习学习ContentResolver了，前面我们说到ContentProvider共享数据是通过定义一个对外开放的统一的接口来实现的。 然而，应用程序并不直接调用这些方法，而是使用一个 ContentResolver 对象，调用它的方法作为替代。ContentResolver可以与任意内容提供者进行会话，与其合作来对所有相关交互通讯进行管理。 当外部应用需要对ContentProvider中的数据进行添加、删除、修改和查询操作时，可以使用ContentResolver类来完成，要获取ContentResolver对象，可以使用Context提供的getContentResolver()方法。 ContentResolver cr = getContentResolver();在上面我们提到ContentProvider可以向其他应用程序提供数据，与之对应的ContentResolver则负责获取ContentProvider提供的数据，修改、添加、删除更新数据等；

ContentResolver 类也提供了与ContentProvider类相对应的四个方法：

public Uri insert(Uri uri, ContentValues values) 该方法用于往ContentProvider添加数据。

public int delete(Uri uri, String selection, String\[\] selectionArgs) 该方法用于从ContentProvider删除数据。

public int update(Uri uri, ContentValues values, String selection, String\[\] selectionArgs) 该方法用于更新ContentProvider中的数据。

public Cursor query(Uri uri, String\[\] projection, String selection, String\[\] selectionArgs, String sortOrder) 该方法用于从ContentProvider中获取数据。

这些方法的第一个参数为Uri，代表要操作的是哪个ContentProvider和对其中的什么数据进行操作，假设给定的是 Uri.parse(“content://com.qstingda.provider.personprovider/contact/15”)，那么将会对主机名为com.qstingda.provider.personprovider的ContentProvider进行操作，path为contact/15的数据，看到这如果你之前没有接触过ContentProvider肯定一头雾水，没有关系，这很正常，等我们把理论知识讲完后会有实例，相信你看过实例后就会很明白了。

**6.UriMatch**

UriMatcher 类主要用于匹配Uri.这里的匹配是发生在ContentProvider中的，假如我们向ContentProvider中插入一条数据，不可能为所欲为的想怎么干就怎么干，在ContentProvider肯定要做一个判断，只有在符合条件下才会去执行你想要执行的操作，这里的判断就是用UriMatch进行匹配，假如是系统的ContentProvider如联系人、图库、视频库等，这些系统都提供了Uri我们可以根据系统提供的Uri来操作相应的数据。其实UriMatch的用法非常简单，查阅谷歌官方文档你会发现有这么几个方法

① public UriMatcher (int code) 它的作用就是创建一个UriMatch对象

② public void addURI (String authority,String path, int code)

它的作用是在ContentProvider添加一个用于匹配的Uri，当匹配成功时返回code。Uri可以是精确的字符串，Uri中带有\*表示可匹配任意text，\#表示只能匹配数字。

③public int match(Uri uri) 这里的Uri就是传过来的要进行验证，匹配的Uri假如传过来的是：content://com.example.test/student/\#,则content://com.example.test/student/10可以匹配成功，这里的10可以使任意的数字。

**7.ContentObserver用法**

ContentObserver——内容观察者，从其名字我们可以看出它的作用就是观察，观察什么？观察指定的Uri引起的数据库的变化，然后通知主线程，根据需求做我们想要做的处理。这样说大家可能理解的不是特别透彻，这样跟大家说它可以实现类似于Adapter的notifyDataSetChanged()这个方法的作用，比方说当观察到ContentProvider的数据变化时会自动调用谷歌工程师给我们提供的好的方法，可以在此方法中通知主线程数据改变等等。那么问题来了，应该怎样实现这样的功能呢？首先要做的就是注册这个观察者，这里的注册是在需要监测ContentProvider的应用中进行注册并不是在ContentProvider中而在ContentProvider中要做的就是当数据变化时进行通知，这里的通知的方法谷歌已经帮我们写好，直接调用就行了，查看谷歌文档你会发现在ContentResolver中有这样的介绍：

public final void registerContentObserver (Uri uri, boolean notifyForDescendents, ContentObserver observer)

注册一个观察者实例，当指定的Uri发生改变时，这个实例会回调实例对象做相应处理。

参数：uri:需要观察的Uri

notifyForDescendents：如果为true表示以这个Uri为开头的所有Uri都会被匹配到，

如果为false表示精确匹配，即只会匹配这个给定的Uri。

举个例子，假如有这么几个Uri：

①content://com.example.studentProvider/student

②content://com.example.studentProvider/student/\#

③content://com.example.studentProvider/student/10

④content://com.example.studentProvider/student/teacher

假如观察的Uri为content://com.example.studentProvider/student，当notifyForDescendents为true时则以这个Uri开头的Uri的数据变化时都会被捕捉到，在这里也就是①②③④的Uri的数据的变化都能被捕捉到，当notifyForDescendents为false时则只有①中Uri变化时才能被捕捉到。

看到registerContentObserver 这个方法，根据语言基础我想大家能够想到ContentResolver中的另一个方法

public final voidunregisterContentObserver(ContentObserverobserver)它的作用就是取消对注册的那个Uri的观察，这里传进去的就是在registerContentObserver中传递进去的ContentObserver对象。到这关于注册和解除注册的ContentObserver可能大家都比较清楚了，那么问题来了，怎么去写一个ContentObserver呢？其实它的实现很简单，直接创建一个类继承ContentObserver需要注意的是这里必须要实现它的构造方法

public ContentObserver(Handlerhandler)

这里传进去的是一个Handler对象，这个Handler对象的作用一般要依赖于ContentObserver的另一个方法即

public void onChange(boolean selfChange)

这个方法的作用就是当指定的Uri的数据发生变化时会回调该方法，此时可以借助构造方法中的Handler对象将这个变化的消息发送给主线程，当主线程接收到这个消息之后就可以按照我们的需求来完成相应的操作，比如上面提到的类似于Adapter的notifyDataSetChanged()的作用，下面的案例也是完成了这个功能，准备工作完成之后来看一个案例，相信这个案例会让你对以上知识了解的更加深入。

**8.案例(自定义ContentProvider)**

在真正的开发中我们很少去自定义一个ContentProvider因为ContentProvider是为了更好的去共享数据，我们在开发中很少会遇到这种情况，而遇到更多的则是访问系统的ContentProvider，系统的ContentProvider谷歌工程师已经帮我们写好了，我们直接使用就可以了，这里为了让大家能够理解ContentProvider更加彻底，我们自定义一个ContentProvider然后在其它应用中来访问自定义的ContentProvider的数据这个案例的运行效果如下：

![Center][]

这里的插入数据，是在一个项目中向另一个项目中的ContentProvider中插入一条数据，其他的操作也是，接下来就来看看怎么实现上述的效果。

在上面我们提到在自定义ContentProvider时需要继承ContentProvider并实现3中所述的那几个方法(系统会自动帮你将要复写的方法罗列出来)，那么我们自定义的PeopleContentProvider的代码如下

**\[java\]** view plain copy

print ?

1.  package com.example.contentproviderpractice;
2.  
3.  import android.content.ContentProvider;
4.  import android.content.ContentUris;
5.  import android.content.ContentValues;
6.  import android.content.UriMatcher;
7.  import android.database.Cursor;
8.  import android.database.sqlite.SQLiteDatabase;
9.  import android.net.Uri;
10. 
11. public class PeopleContentProvider extends ContentProvider \{
12. 
13. //这里的AUTHORITY就是我们在AndroidManifest.xml中配置的authorities，这里的authorities可以随便写
14. private static final String AUTHORITY = “com.example.studentProvider”;
15. //匹配成功后的匹配码
16. private static final int MATCH\_ALL\_CODE = 100;
17. private static final int MATCH\_ONE\_CODE = 101;
18. private static UriMatcher uriMatcher;
19. private SQLiteDatabase db;
20. private DBOpenHelper openHelper;
21. private Cursor cursor = null;
22. //数据改变后指定通知的Uri
23. private static final Uri NOTIFY\_URI = Uri.parse(“content://” \+ AUTHORITY + “/student”);
24. 
25. //在静态代码块中添加要匹配的 Uri
26. static \{
27. //匹配不成功返回NO\_MATCH(-1)
28. uriMatcher = new UriMatcher(UriMatcher.NO\_MATCH);
29. /\*\*
30.  \* uriMatcher.addURI(authority, path, code); 其中
31.  \* authority：主机名(用于唯一标示一个ContentProvider,这个需要和清单文件中的authorities属性相同)
32.  \* path:路径路径(可以用来表示我们要操作的数据，路径的构建应根据业务而定)
33.  \* code:返回值(用于匹配uri的时候，作为匹配成功的返回值)
34.  \*/
35. uriMatcher.addURI(AUTHORITY, ”student”, MATCH\_ALL\_CODE);// 匹配记录集合
36. uriMatcher.addURI(AUTHORITY, ”student/\#”, MATCH\_ONE\_CODE);// 匹配单条记录
37. \}
38. 
39. @Override
40. public boolean onCreate() \{
41. 
42. openHelper = new DBOpenHelper(getContext());
43. db = openHelper.getWritableDatabase();
44. return false;
45. \}
46. 
47. @Override
48. public int delete(Uri uri, String selection, String\[\] selectionArgs) \{
49. 
50. switch (uriMatcher.match(uri)) \{
51. /\*\*
52.  \* 这里如果匹配是uriMatcher.addURI(AUTHORITY, “student”,
53.  \* MATCH\_SUCCESS\_CODE);中的Uri，则我们可以在这里对这个ContentProvider中的数据库
54.  \* 进行删除等操作。这里如果匹配成功，我们将删除所有的数据
55.  \*/
56. case MATCH\_ALL\_CODE:
57. int count=db.delete(“personData”, null, null);
58. if(count>0)\{
59. notifyDataChanged();
60. return count;
61. \}
62. break;
63. /\*\*
64.  \* 这里如果匹配是uriMatcher.addURI(AUTHORITY,
65.  \* “student/\#”,MATCH\_ONE\_CODE);中的Uri，则说明我们要操作单条记录
66.  \*/
67. case MATCH\_ONE\_CODE:
68. // 这里可以做删除单条数据的操作。
69. break;
70. default:
71. throw new IllegalArgumentException(“Unkwon Uri:” \+ uri.toString());
72. \}
73. return 0;
74. \}
75. 
76. @Override
77. public String getType(Uri uri) \{
78. return null;
79. \}
80. 
81. /\*\*
82.  \* 插入 使用UriMatch的实例中的match方法对传过来的 Uri进行匹配。 这里通过ContentResolver传过来一个Uri，
83.  \* 用这个传过来的Uri跟在ContentProvider中静态代码块中uriMatcher.addURI加入的Uri进行匹配
84.  \* 根据匹配的是否成功会返回相应的值，在上述静态代码块中调用uriMatcher.addURI(AUTHORITY,
85.  \* “student”,MATCH\_CODE)这里的MATCH\_CODE
86.  \* 就是匹配成功的返回值，也就是说假如返回了MATCH\_CODE就表示这个Uri匹配成功了
87.  \* ，我们就可以按照我们的需求就行操作了,这里uriMatcher.addURI(AUTHORITY,
88.  \* “person/data”,MATCH\_CODE)加入的Uri为：
89.  \* content://com.example.studentProvider/student
90.  \* ，如果传过来的Uri跟这个Uri能够匹配成功，就会按照我们设定的步骤去执行相应的操作
91.  \*/
92. @Override
93. public Uri insert(Uri uri, ContentValues values) \{
94. 
95. int match=uriMatcher.match(uri);
96. if(match!=MATCH\_ALL\_CODE)\{
97. throw new IllegalArgumentException(“Unkwon Uri:” \+ uri.toString());
98. \}
99. 
100. long rawId = db.insert(“personData”, null, values);
101. Uri insertUri = ContentUris.withAppendedId(uri, rawId);
102. if(rawId>0)\{
103. notifyDataChanged();
104. return insertUri;
105. \}
106. return null;
107. 
108. \}
109. 
110. /\*\*
111.  \* 查询 如果uri为
112.  \* content://com.example.studentProvider/student则能匹配成功，然后我们可以按照需求执行匹配成功的操作
113.  \*/
114. @Override
115. public Cursor query(Uri uri, String\[\] projection, String selection,
116. String\[\] selectionArgs, String sortOrder) \{
117. switch (uriMatcher.match(uri)) \{
118. /\*\*
119.  \* 如果匹配成功，就根据条件查询数据并将查询出的cursor返回
120.  \*/
121. case MATCH\_ALL\_CODE:
122. cursor = db.query(”personData”, null, null, null, null, null, null);
123. break;
124. case MATCH\_ONE\_CODE:
125. // 根据条件查询一条数据。。。。
126. break;
127. default:
128. throw new IllegalArgumentException(“Unkwon Uri:” \+ uri.toString());
129. \}
130. 
131. return cursor;
132. \}
133. 
134. @Override
135. public int update(Uri uri, ContentValues values, String selection,
136. String\[\] selectionArgs) \{
137. 
138. switch (uriMatcher.match(uri)) \{
139. case MATCH\_ONE\_CODE:
140. long age = ContentUris.parseId(uri);
141. selection = ”age = ?”;
142. selectionArgs = new String\[\] \{ String.valueOf(age) \};
143. int count = db.update(“personData”, values, selection,selectionArgs);
144. if(count>0)\{
145. notifyDataChanged();
146. \}
147. break;
148. case MATCH\_ALL\_CODE:
149. // 如果有需求的话，可以对整个表进行操作
150. break;
151. default:
152. throw new IllegalArgumentException(“Unkwon Uri:” \+ uri.toString());
153. \}
154. return 0;
155. \}
156. 
157. //通知指定URI数据已改变 
158. private void notifyDataChanged() \{
159. getContext().getContentResolver().notifyChange(NOTIFY\_URI, null);
160. \}
161. 
162. \}

package com.example.contentproviderpractice;
    
    import android.content.ContentProvider;
    import android.content.ContentUris;
    import android.content.ContentValues;
    import android.content.UriMatcher;
    import android.database.Cursor;
    import android.database.sqlite.SQLiteDatabase;
    import android.net.Uri;
    
    public class PeopleContentProvider extends ContentProvider {
    
        //这里的AUTHORITY就是我们在AndroidManifest.xml中配置的authorities，这里的authorities可以随便写
        private static final String AUTHORITY = "com.example.studentProvider";
        //匹配成功后的匹配码
        private static final int MATCH_ALL_CODE = 100;
        private static final int MATCH_ONE_CODE = 101;
        private static UriMatcher uriMatcher;
        private SQLiteDatabase db;
        private DBOpenHelper openHelper;
        private Cursor cursor = null;
        //数据改变后指定通知的Uri
        private static final Uri NOTIFY_URI = Uri.parse("content://" + AUTHORITY + "/student");
    
        //在静态代码块中添加要匹配的 Uri
        static {
            //匹配不成功返回NO_MATCH(-1)
            uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
            /**
             * uriMatcher.addURI(authority, path, code); 其中
             * authority：主机名(用于唯一标示一个ContentProvider,这个需要和清单文件中的authorities属性相同)
             * path:路径路径(可以用来表示我们要操作的数据，路径的构建应根据业务而定)
             * code:返回值(用于匹配uri的时候，作为匹配成功的返回值)
             */
            uriMatcher.addURI(AUTHORITY, "student", MATCH_ALL_CODE);// 匹配记录集合
            uriMatcher.addURI(AUTHORITY, "student/#", MATCH_ONE_CODE);// 匹配单条记录
        }
    
        @Override
        public boolean onCreate() {
    
            openHelper = new DBOpenHelper(getContext());
            db = openHelper.getWritableDatabase();
            return false;
        }
    
        @Override
        public int delete(Uri uri, String selection, String[] selectionArgs) {
    
            switch (uriMatcher.match(uri)) {
            /**
             * 这里如果匹配是uriMatcher.addURI(AUTHORITY, "student",
             * MATCH_SUCCESS_CODE);中的Uri，则我们可以在这里对这个ContentProvider中的数据库
             * 进行删除等操作。这里如果匹配成功，我们将删除所有的数据
             */
            case MATCH_ALL_CODE:
                int count=db.delete("personData", null, null);
                if(count>0){
                    notifyDataChanged();
                    return count;
                }
                break;
            /**
             * 这里如果匹配是uriMatcher.addURI(AUTHORITY,
             * "student/#",MATCH_ONE_CODE);中的Uri，则说明我们要操作单条记录
             */
            case MATCH_ONE_CODE:
                // 这里可以做删除单条数据的操作。
                break;
            default:
                throw new IllegalArgumentException("Unkwon Uri:" + uri.toString());
            }
            return 0;
        }
    
        @Override
        public String getType(Uri uri) {
            return null;
        }
    
        /**
         * 插入 使用UriMatch的实例中的match方法对传过来的 Uri进行匹配。 这里通过ContentResolver传过来一个Uri，
         * 用这个传过来的Uri跟在ContentProvider中静态代码块中uriMatcher.addURI加入的Uri进行匹配
         * 根据匹配的是否成功会返回相应的值，在上述静态代码块中调用uriMatcher.addURI(AUTHORITY,
         * "student",MATCH_CODE)这里的MATCH_CODE
         * 就是匹配成功的返回值，也就是说假如返回了MATCH_CODE就表示这个Uri匹配成功了
         * ，我们就可以按照我们的需求就行操作了,这里uriMatcher.addURI(AUTHORITY,
         * "person/data",MATCH_CODE)加入的Uri为：
         * content://com.example.studentProvider/student
         * ，如果传过来的Uri跟这个Uri能够匹配成功，就会按照我们设定的步骤去执行相应的操作
         */
        @Override
        public Uri insert(Uri uri, ContentValues values) {
    
            int match=uriMatcher.match(uri);
            if(match!=MATCH_ALL_CODE){
                throw new IllegalArgumentException("Unkwon Uri:" + uri.toString());
            }
    
            long rawId = db.insert("personData", null, values);
            Uri insertUri = ContentUris.withAppendedId(uri, rawId);
            if(rawId>0){
                notifyDataChanged();
                return insertUri;
            }
            return null;
    
        }
    
        /**
         * 查询 如果uri为
         * content://com.example.studentProvider/student则能匹配成功，然后我们可以按照需求执行匹配成功的操作
         */
        @Override
        public Cursor query(Uri uri, String[] projection, String selection,
                String[] selectionArgs, String sortOrder) {
            switch (uriMatcher.match(uri)) {
            /**
             * 如果匹配成功，就根据条件查询数据并将查询出的cursor返回
             */
            case MATCH_ALL_CODE:
                cursor = db.query("personData", null, null, null, null, null, null);
                break;
            case MATCH_ONE_CODE:
                // 根据条件查询一条数据。。。。
                break;
            default:
                throw new IllegalArgumentException("Unkwon Uri:" + uri.toString());
            }
    
            return cursor;
        }
    
        @Override
        public int update(Uri uri, ContentValues values, String selection,
                String[] selectionArgs) {
    
            switch (uriMatcher.match(uri)) {
            case MATCH_ONE_CODE:
                long age = ContentUris.parseId(uri);
                selection = "age = ?";
                selectionArgs = new String[] { String.valueOf(age) };
                int count = db.update("personData", values, selection,selectionArgs);
                if(count>0){
                    notifyDataChanged();
                }
                break;
            case MATCH_ALL_CODE:
                // 如果有需求的话，可以对整个表进行操作
                break;
            default:
                throw new IllegalArgumentException("Unkwon Uri:" + uri.toString());
            }
            return 0;
        }
    
        //通知指定URI数据已改变  
        private void notifyDataChanged() {  
            getContext().getContentResolver().notifyChange(NOTIFY_URI, null);         
        }
    
    }

可以看到在onCreate()方法中创建了一个数据库，关于数据库的操作大家可以看此博客 [http://blog.csdn.net/dmk877/article/details/44876805][http_blog.csdn.net_dmk877_article_details_44876805]。这里就不多做介绍了。 注意这个案例牵扯到两个项目，一个是包含我们自定义的ContentProvider，另一个项目是访问这个包含ContentProvider项目中的数据。

写好PeopleContentProvider之后千万不要忘了在清单文件中注册

**\[java\]** view plain copy

print ?

1.  <provider
2.  android:name=”com.example.contentproviderpractice.PeopleContentProvider”
3.  android:authorities=”com.example.student”
4.  android:exported=”true” >
5.  </provider>

这里的 authorities就是它是唯一标识内容提供者的， 为内容提供者指定一个唯一的标识，这样别的应用才可以唯一获取此provider，exported的值为\[flase|true\]当为true时： 当前提供者可以被其它应用使用。任何应用可以使用Provider通过URI 来获得它，也可以通过相应的权限来使用Provider。 当为false时： 当前提供者不能被其它应用使用，默认为true。 注册好之后运行到手机上，此时其它的应用就可以通过ContentResolver来访问这个PeopleContentProvider了，具体怎么操作呢？我们 再新建一个项目 在MainActivity的代码如下：

**\[java\]** view plain copy

print ?

1.  package com.example.otherapplication;
2.  
3.  import java.util.ArrayList;
4.  
5.  import com.example.otherapplication.adapter.MyAdapter;
6.  import com.example.otherapplication.bean.Student;
7.  import com.example.otherapplication.observer.PersonOberserver;
8.  
9.  import android.net.Uri;
10. import android.os.Bundle;
11. import android.os.Handler;
12. import android.app.Activity;
13. import android.content.ContentResolver;
14. import android.content.ContentUris;
15. import android.content.ContentValues;
16. import android.database.Cursor;
17. import android.view.View;
18. import android.view.View.OnClickListener;
19. import android.widget.Button;
20. import android.widget.ListView;
21. 
22. public class MainActivity extends Activity implements OnClickListener \{
23. 
24. private ContentResolver contentResolver;
25. private ListView lvShowInfo;
26. private MyAdapter adapter;
27. private Button btnInit;
28. private Button btnInsert;
29. private Button btnDelete;
30. private Button btnUpdate;
31. private Button btnQuery;
32. private Cursor cursor;
33. 
34. private static final String AUTHORITY = “com.example.studentProvider”;
35. private static final Uri STUDENT\_ALL\_URI = Uri.parse(“content://” \+ AUTHORITY + “/student”);
36. protected static final String TAG = “MainActivity”;
37. 
38. private Handler handler=new Handler()\{
39. public void handleMessage(android.os.Message msg) \{
40. //在此我们可以针对数据改变后做一些操作，比方说Adapter.notifyDataSetChanged()等，根据业务需求来定。。
41. cursor = contentResolver.query(STUDENT\_ALL\_URI, null, null, null,null);
42. 
43. adapter.changeCursor(cursor);
44. \};
45. \};
46. 
47. @Override
48. protected void onCreate(Bundle savedInstanceState) \{
49. super.onCreate(savedInstanceState);
50. setContentView(R.layout.activity\_main);
51. lvShowInfo=(ListView) findViewById(R.id.lv\_show\_info);
52. initData();
53. \}
54. 
55. private void initData() \{
56. btnInit=(Button) findViewById(R.id.btn\_init);
57. btnInsert=(Button) findViewById(R.id.btn\_insert);
58. btnDelete=(Button) findViewById(R.id.btn\_delete);
59. btnUpdate=(Button) findViewById(R.id.btn\_update);
60. btnQuery=(Button) findViewById(R.id.btn\_query);
61. 
62. btnInit.setOnClickListener(this);
63. btnInsert.setOnClickListener(this);
64. btnDelete.setOnClickListener(this);
65. btnUpdate.setOnClickListener(this);
66. btnQuery.setOnClickListener(this);
67. 
68. contentResolver = getContentResolver();
69. //注册内容观察者
70. contentResolver.registerContentObserver(STUDENT\_ALL\_URI,true,new PersonOberserver(handler));
71. 
72. adapter=new MyAdapter(MainActivity.this,cursor);
73. lvShowInfo.setAdapter(adapter);
74. \}
75. 
76. @Override
77. public void onClick(View v) \{
78. switch (v.getId()) \{
79. //初始化
80. case R.id.btn\_init:
81. ArrayList<Student> students = new ArrayList<Student>();
82. 
83. Student student1 = new Student(“苍老师”,25,“一个会教学的好老师”);
84. Student student2 = new Student(“柳岩”,26,“大方”);
85. Student student3 = new Student(“杨幂”,27,“漂亮”);
86. Student student4 = new Student(“张馨予”,28,“不知道怎么评价”);
87. Student student5 = new Student(“范冰冰”,29,“。。。”);
88. 
89. students.add(student1);
90. students.add(student2);
91. students.add(student3);
92. students.add(student4);
93. students.add(student5);
94. 
95. for (Student Student : students) \{
96. ContentValues values = new ContentValues();
97. values.put(”name”, Student.getName());
98. values.put(”age”, Student.getAge());
99. values.put(”introduce”, Student.getIntroduce());
100. contentResolver.insert(STUDENT\_ALL\_URI, values);
101. \}
102. break;
103. 
104. //增
105. case R.id.btn\_insert:
106. 
107. Student student = new Student(“小明”, 26, “帅气男人”);
108. 
109. //实例化一个ContentValues对象
110. ContentValues insertContentValues = new ContentValues();
111. insertContentValues.put(”name”,student.getName());
112. insertContentValues.put(”age”,student.getAge());
113. insertContentValues.put(”introduce”,student.getIntroduce());
114. 
115. //这里的uri和ContentValues对象经过一系列处理之后会传到ContentProvider中的insert方法中，
116. //在我们自定义的ContentProvider中进行匹配操作
117. contentResolver.insert(STUDENT\_ALL\_URI,insertContentValues);
118. break;
119. 
120. //删
121. case R.id.btn\_delete:
122. 
123. //删除所有条目
124. contentResolver.delete(STUDENT\_ALL\_URI, null, null);
125. //删除\_id为1的记录 
126. Uri delUri = ContentUris.withAppendedId(STUDENT\_ALL\_URI,1);
127. contentResolver.delete(delUri, null, null);
128. break;
129. 
130. //改
131. case R.id.btn\_update:
132. 
133. ContentValues contentValues = new ContentValues();
134. contentValues.put(”introduce”,“性感”);
135. //更新数据，将age=26的条目的introduce更新为”性感”，原来age=26的introduce为”大方”.
136. //生成的Uri为：content://com.example.studentProvider/student/26
137. Uri updateUri = ContentUris.withAppendedId(STUDENT\_ALL\_URI,26);
138. contentResolver.update(updateUri,contentValues, null, null);
139. 
140. break;
141. 
142. //查
143. case R.id.btn\_query:
144. //通过ContentResolver获得一个调用ContentProvider对象
145. Cursor cursor = contentResolver.query(STUDENT\_ALL\_URI, null, null, null,null);
146. //CursorAdapter的用法，参考此博客：http://blog.csdn.net/dmk877/article/details/44983491
147. adapter=new MyAdapter(MainActivity.this,cursor);
148. lvShowInfo.setAdapter(adapter);
149. cursor = contentResolver.query(STUDENT\_ALL\_URI, null, null, null,null);
150. adapter.changeCursor(cursor);
151. break;
152. \}
153. \}
154. \}

package com.example.otherapplication;
    
    import java.util.ArrayList;
    
    import com.example.otherapplication.adapter.MyAdapter;
    import com.example.otherapplication.bean.Student;
    import com.example.otherapplication.observer.PersonOberserver;
    
    import android.net.Uri;
    import android.os.Bundle;
    import android.os.Handler;
    import android.app.Activity;
    import android.content.ContentResolver;
    import android.content.ContentUris;
    import android.content.ContentValues;
    import android.database.Cursor;
    import android.view.View;
    import android.view.View.OnClickListener;
    import android.widget.Button;
    import android.widget.ListView;
    
    public class MainActivity extends Activity implements OnClickListener {
    
        private ContentResolver contentResolver;
        private ListView lvShowInfo;
        private MyAdapter adapter;
        private Button btnInit;
        private Button btnInsert;
        private Button btnDelete;
        private Button btnUpdate;
        private Button btnQuery;
        private Cursor cursor;
    
        private static final String AUTHORITY = "com.example.studentProvider";  
        private static final Uri STUDENT_ALL_URI = Uri.parse("content://" + AUTHORITY + "/student");
        protected static final String TAG = "MainActivity"; 
    
        private Handler handler=new Handler(){
            public void handleMessage(android.os.Message msg) {
                //在此我们可以针对数据改变后做一些操作，比方说Adapter.notifyDataSetChanged()等，根据业务需求来定。。
                cursor = contentResolver.query(STUDENT_ALL_URI, null, null, null,null);
    
                adapter.changeCursor(cursor);
            };
        };
    
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            lvShowInfo=(ListView) findViewById(R.id.lv_show_info);
            initData();
        }
    
        private void initData() {
            btnInit=(Button) findViewById(R.id.btn_init);
            btnInsert=(Button) findViewById(R.id.btn_insert);
            btnDelete=(Button) findViewById(R.id.btn_delete);
            btnUpdate=(Button) findViewById(R.id.btn_update);
            btnQuery=(Button) findViewById(R.id.btn_query);
    
            btnInit.setOnClickListener(this);
            btnInsert.setOnClickListener(this);
            btnDelete.setOnClickListener(this);
            btnUpdate.setOnClickListener(this);
            btnQuery.setOnClickListener(this);
    
            contentResolver = getContentResolver();
            //注册内容观察者
            contentResolver.registerContentObserver(STUDENT_ALL_URI,true,new PersonOberserver(handler));
    
            adapter=new MyAdapter(MainActivity.this,cursor);
            lvShowInfo.setAdapter(adapter);
        }
    
        @Override
        public void onClick(View v) {
            switch (v.getId()) {
            //初始化
            case R.id.btn_init:
                ArrayList<Student> students = new ArrayList<Student>();  
    
                Student student1 = new Student("苍老师",25,"一个会教学的好老师");  
                Student student2 = new Student("柳岩",26,"大方");  
                Student student3 = new Student("杨幂",27,"漂亮");  
                Student student4 = new Student("张馨予",28,"不知道怎么评价");  
                Student student5 = new Student("范冰冰",29,"。。。");
    
                students.add(student1);  
                students.add(student2);  
                students.add(student3);  
                students.add(student4); 
                students.add(student5); 
    
                for (Student Student : students) {  
                    ContentValues values = new ContentValues();  
                    values.put("name", Student.getName());  
                    values.put("age", Student.getAge());  
                    values.put("introduce", Student.getIntroduce());  
                    contentResolver.insert(STUDENT_ALL_URI, values);  
                }
                break;
    
            //增
            case R.id.btn_insert:
    
                Student student = new Student("小明", 26, "帅气男人");  
    
                //实例化一个ContentValues对象
                ContentValues insertContentValues = new ContentValues();  
                insertContentValues.put("name",student.getName());  
                insertContentValues.put("age",student.getAge());  
                insertContentValues.put("introduce",student.getIntroduce());  
    
                //这里的uri和ContentValues对象经过一系列处理之后会传到ContentProvider中的insert方法中，
                //在我们自定义的ContentProvider中进行匹配操作
                contentResolver.insert(STUDENT_ALL_URI,insertContentValues);
                break;
    
            //删
            case R.id.btn_delete:
    
                //删除所有条目
                contentResolver.delete(STUDENT_ALL_URI, null, null); 
                //删除_id为1的记录  
                Uri delUri = ContentUris.withAppendedId(STUDENT_ALL_URI,1);  
                contentResolver.delete(delUri, null, null);
                break;
    
            //改
            case R.id.btn_update:
    
                ContentValues contentValues = new ContentValues();
                contentValues.put("introduce","性感");
                //更新数据，将age=26的条目的introduce更新为"性感"，原来age=26的introduce为"大方".
                //生成的Uri为：content://com.example.studentProvider/student/26
                Uri updateUri = ContentUris.withAppendedId(STUDENT_ALL_URI,26);
                contentResolver.update(updateUri,contentValues, null, null);
    
                break;
    
            //查
            case R.id.btn_query:
                //通过ContentResolver获得一个调用ContentProvider对象
                Cursor cursor = contentResolver.query(STUDENT_ALL_URI, null, null, null,null);
                //CursorAdapter的用法，参考此博客：http://blog.csdn.net/dmk877/article/details/44983491
                adapter=new MyAdapter(MainActivity.this,cursor);
                lvShowInfo.setAdapter(adapter);
                cursor = contentResolver.query(STUDENT_ALL_URI, null, null, null,null);
                adapter.changeCursor(cursor);
                break;
            }
        }
    }

可以看出若想操作我们想操作的ContentProvider，必须要知道内容提供者的Uri，再正确得到Uri之后，就可以通过ContentResolver对象来操作ContentProvider中的数据了，假如你需要插入数据只需要调用contentResolver.insert(uri, contentValues);把正确的uri和ContentValues键值对传过去就行了。执行这句话系统就会根据我们提供的uri找到对应的ContentProvider,因为我们的uri中包含了authority(主机等各种信息)，得到对应的ContentProvider后将调用ContentResolver的与之对应的增删改查方法，并将参数通过ContentResolver的增删改查方法传递到ContentProvider中。在上面用到了CursorAdapter关于CursorAdapter的用法可以参考此博客 [http://blog.csdn.net/dmk877/article/details/44983491][http_blog.csdn.net_dmk877_article_details_44983491]

PersonObserver的代码如下

**\[java\]** view plain copy

print ?

1.  package com.example.otherapplication.observer;
2.  
3.  import android.database.ContentObserver;
4.  import android.os.Handler;
5.  import android.os.Message;
6.  
7.  public class PersonOberserver extends ContentObserver \{
8.  
9.  private Handler handler;
10. 
11. public PersonOberserver(Handler handler) \{
12. super(handler);
13. this.handler=handler;
14. \}
15. 
16. @Override
17. public void onChange(boolean selfChange) \{
18. super.onChange(selfChange);
19. 
20. //向handler发送消息,更新查询记录 
21. Message msg = new Message();
22. handler.sendMessage(msg);
23. \}
24. 
25. \}

package com.example.otherapplication.observer;
    
    import android.database.ContentObserver;
    import android.os.Handler;
    import android.os.Message;
    
    public class PersonOberserver extends ContentObserver {
    
        private Handler handler;
    
        public PersonOberserver(Handler handler) {
            super(handler);
            this.handler=handler;
        }
    
        @Override
        public void onChange(boolean selfChange) {
            super.onChange(selfChange);
    
            //向handler发送消息,更新查询记录  
            Message msg = new Message();  
            handler.sendMessage(msg);
        }
    
    }

可以看到，在构造方法中接收了Handler然后当监听到指定的Uri的数据变化时就会通过Handler消息机制发送一条消息，然后的操作就由我们自行完成了。

到这里我们来理一理整个操作的运行流程：首先有两个项目，一个是有ContentProvider的，在这个ContentProvider中初始化了一个数据库，我们的目的就是在另一个项目中来操作这个项目中ContentProvider中的数据，例如插入一条数据，查询等。对于怎么在另一个项目中操作ContentProvider中的数据，是通过ContentResolver(内容解析者)对象来操作的，假如我们要进行insert操作，那么需要调用ContentResolver的insert(uri, ContentValues);将Uri和ContentValues对象经过一系列操作传递到ContentProvider的中，然后在ContentProvider会对这个Uri进行匹配，如果匹配成功则按照我们的需求去执行相应的操作，如：插入数据、查询数据等。如果想进一步理解ContentProvider和ContentResolver之间的关系 [http://blog.csdn.net/u010961631/article/details/14227421][http_blog.csdn.net_u010961631_article_details_14227421] (对这个过程从源码进行了解析，不建议初学者阅读)。下面我们来画一张图再来说一下这个过程

![Center 1][]

从图中可以看出在OtherApplication中注册了ContentObserver之后，当Application1中的数据库发生了变化时，只需要在ContentProvider中调用ContentResolver的notifyChange(Uri, ContentObserver observer),由于在OtherApplication中注册了ContentObserver(注册时用的Uri和ContentProvider中发生变化的Uri一样)因此在ContentObserver中会收到这个变化信息，它就可以将这个消息通过Handler发送给OtherApplication。

好了，本篇关于ContentProvider的介绍主要是ContentProvider的基础知识，以及自定义一个ContentProvider并操作它的执行过程， 如果大家发现博客中有错误的地方，欢迎批评指正，如有疑问欢迎留言，谢谢

如果你觉着本篇博客对你有帮助，就赞一个，顶一下呗。。。。

[案例源码地址][Link 1] （注意案例应先运行含有ContentProvider的项目。）

转载请注明出处：[http://blog.csdn.net/dmk877/article/details/50387741][http_blog.csdn.net_dmk877_article_details_50387741]

参考链接：

[http://blog.csdn.net/harvic880925/article/details/44679239][Uri_Uri](Uri详解)

[http://www.cnblogs.com/fsjohnhuang/p/4280369.html][Java_URI_URL_URL Protocol Handler]

[http://blog.csdn.net/whyrjj3/article/details/7852800][http_blog.csdn.net_whyrjj3_article_details_7852800]

[http://www.androiddesignpatterns.com/2012/06/content-resolvers-and-content-providers.html][http_www.androiddesignpatterns.com_2012_06_content-resolvers-and-content-providers.html]

[http://blog.csdn.net/liuhe688/article/details/7050868][http_blog.csdn.net_liuhe688_article_details_7050868]

[http://blog.csdn.net/qinjuning/article/details/7047607][http_blog.csdn.net_qinjuning_article_details_7047607](ContentObserver用法详解)

[http://blog.csdn.net/u010961631/article/details/14227421][http_blog.csdn.net_u010961631_article_details_14227421](对ContentProvider源码解析)

[http_blog.csdn.net_dmk877_article_details_50387741]: http://blog.csdn.net/dmk877/article/details/50387741
[http_www.baidu.com_8080]: http://www.baidu.com:8080/
[Uri_Uri]: http://blog.csdn.net/harvic880925/article/details/44679239
[Java_URI_URL_URL Protocol Handler]: http://www.cnblogs.com/fsjohnhuang/p/4280369.html
[Center]: /images/20220531/046f542bd8554d16bc5f6a2fcbee6f89.png
[http_blog.csdn.net_dmk877_article_details_44876805]: http://blog.csdn.net/dmk877/article/details/44876805
[http_blog.csdn.net_dmk877_article_details_44983491]: http://blog.csdn.net/dmk877/article/details/44983491
[http_blog.csdn.net_u010961631_article_details_14227421]: http://blog.csdn.net/u010961631/article/details/14227421
[Center 1]: /images/20220531/45c3968cf2bb42468ede01b39c22fd6a.png
[Link 1]: http://download.csdn.net/detail/dmk877/9381338
[http_blog.csdn.net_whyrjj3_article_details_7852800]: http://blog.csdn.net/whyrjj3/article/details/7852800
[http_www.androiddesignpatterns.com_2012_06_content-resolvers-and-content-providers.html]: http://www.androiddesignpatterns.com/2012/06/content-resolvers-and-content-providers.html
[http_blog.csdn.net_liuhe688_article_details_7050868]: http://blog.csdn.net/liuhe688/article/details/7050868
[http_blog.csdn.net_qinjuning_article_details_7047607]: http://blog.csdn.net/qinjuning/article/details/7047607