内容提供者ContentProvider例子

ContentProvider的实现过程

1、定义一个CONTENT_URI常量，提供了访问ContentProvider的标识符。

public static final Uri CONTENT_URI = Uri.parse("content://com.example.codelab.transportationprovider");

其中：content是协议
Com.exmaple.codelab.transportationprovider是类名，包含完整的包名。
Uri.parse将一个字符串转换成Uri类型。
如果Provider包含子表，同样定义包含字表的CONTENT_URI。
content://com.example.codelab.transportationprovider/train
content://com.example.codelab.transportationprovider/air/domestic
content://com.example.codelab.transportationprovider/air/international
然后定义列，确保里面包含一个_id的列。
2、定义一个类，继承ContentProvider。

public class FirstContentProvider extends ContentProvider

先介绍一下ContentProvider用到的UriMatcher。UriMatcher的一个重要的函数是match(Uri uri)。这个函数可以匹配Uri，根据传入的不同Uri返回不同的自定义整形值，以表明Uri访问的不同资源的类型。
例如：

1 public static final UriMatcher uriMatcher; 
2       static { 
3                      uriMatcher = new UriMatcher(UriMatcher.NO_MATCH); 
4                      uriMatcher.addURI(Book.AUTHORITY, "item", Book.ITEM); 
5                      uriMatcher.addURI(Book.AUTHORITY, "item/#", Book.ITEM_ID); 
6               }

这里UriMatcher类型的静态字段是用来匹配传入到ContentProvider中的Uri的类。其构造方法传入的匹配码是使用match()方法匹配根路径时返回的值;，这个匹配码可以为一个大于零的数表示匹配根路径或传入-1，即常量UriMatcher.NO_MATCH表示不匹配根路径。

addURI()方法是用来增加其他URI匹配路径的，

第一个参数传入标识ContentProvider的AUTHORITY字符串。

第二个参数传入需要匹配的路径，这里的#号为通配符，代表匹配任意数字，另外还可以用*来匹配任意文本。

第三个参数必须传入一个大于零的匹配码，用于match()方法对相匹配的URI返回相对应的匹配码。例如：sMatcher.addURI(“com.test.provider.personprovider”, “person”, 1);如果match()方法匹配content://com.test.provider.personprovider/person路径，返回匹配码为1。

3、实现query,insert,update,delete,getType和onCreate方法。
4、在AndroidManifest.xml当中进行声明。

1 <!-- android:name是完成ContentProvider类的全称
2              android:authorities是和FirstProvidermetaData中的常量AUTHORITY的值一样，否则会报错  exported代表提供出口
3          -->
4 <provider android:name="com.bj.FirstContentProvider" 
5  　　android:exported="true"
6 　　android:authorities="com.bj.firstcontentprovider"></provider>

三、实例

1、常量类

 1 /**
 2  * 提供ContentProvider对外的各种常量，当外部数据需要访问的时候，就可以参考这些常量操作数据。
 3  * @author HB
 4  *
 5  */
 6 public class ContentData {
 7     public static final String AUTHORITY = "hb.android.contentProvider";
 8     public static final String DATABASE_NAME = "teacher.db";
 9     //创建 数据库的时候，都必须加上版本信息
10     public static final int DATABASE_VERSION = 4;
11     public static final String USERS_TABLE_NAME = "teacher";
12     
13     public static final class UserTableData implements BaseColumns {
14         public static final String TABLE_NAME = "teacher";
15         //Uri，外部程序需要访问就是通过这个Uri访问的，这个Uri必须的唯一的。
16         public static final Uri CONTENT_URI = Uri.parse("content://"+ AUTHORITY + "/teacher");
17         // 数据集的MIME类型字符串则应该以vnd.android.cursor.dir/开头  
18         public static final String CONTENT_TYPE = "vnd.android.cursor.dir/hb.android.teachers";
19         // 单一数据的MIME类型字符串应该以vnd.android.cursor.item/开头  
20         public static final String CONTENT_TYPE_ITME = "vnd.android.cursor.item/hb.android.teacher";
21         /* 自定义匹配码 */  
22         public static final int TEACHERS = 1;  
23         /* 自定义匹配码 */  
24         public static final int TEACHER = 2;  
25         
26         public static final String TITLE = "title";
27         public static final String NAME = "name";
28         public static final String DATE_ADDED = "date_added";
29         public static final String SEX = "SEX";
30         public static final String DEFAULT_SORT_ORDER = "_id desc";
31         
32         public static final UriMatcher uriMatcher;  
33         static {  
34             // 常量UriMatcher.NO_MATCH表示不匹配任何路径的返回码  
35             uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);  
36             // 如果match()方法匹配content://hb.android.teacherProvider/teachern路径,返回匹配码为TEACHERS  
37             uriMatcher.addURI(ContentData.AUTHORITY, "teacher", TEACHERS);  
38             // 如果match()方法匹配content://hb.android.teacherProvider/teacher/230,路径，返回匹配码为TEACHER  
39             uriMatcher.addURI(ContentData.AUTHORITY, "teacher/#", TEACHER);  
40         }
41     }
42 }

PS：

在创建UriMatcher对象uriMatcher时，我们传给构造函数的参数为UriMatcher.NO_MATCH，它表示当uriMatcher不能匹配指定的URI时，就返回代码UriMatcher.NO_MATCH。接下来增加了三个匹配规则，分别是uriMatcher = new UriMatcher(UriMatcher.NO_MATCH); uriMatcher.addURI(ContentData.AUTHORITY, "teacher", TEACHERS); uriMatcher.addURI(ContentData.AUTHORITY, "teacher/#", TEACHER);

它们的匹配码分别是teacher.ITEM、teacher.ITEM_ID和teacher.ITEM_POS，其中，符号#表示匹配任何数字。

2、SQLite操作类DBOpenHelper

 1 /**
 2  * 这个类继承SQLiteOpenHelper抽象类，用于创建数据库和表。创建数据库是调用它的父类构造方法创建。
 3  * @author HB
 4  */
 5 public class DBOpenHelper extends SQLiteOpenHelper {
 6 
 7     // 在SQLiteOepnHelper的子类当中，必须有该构造函数，用来创建一个数据库；
 8     public DBOpenHelper(Context context, String name, CursorFactory factory,
 9             int version) {
10         // 必须通过super调用父类当中的构造函数
11         super(context, name, factory, version);
12         // TODO Auto-generated constructor stub
13     }
14 
15     // public DBOpenHelper(Context context, String name) {
16     // this(context, name, VERSION);
17     // }
18 
19     public DBOpenHelper(Context context, String name, int version) {
20         this(context, name, null, version);
21     }
22     
23     /**
24      * 只有当数据库执行创建 的时候，才会执行这个方法。如果更改表名，也不会创建，只有当创建数据库的时候，才会创建改表名之后 的数据表
25      */
26     @Override
27     public void onCreate(SQLiteDatabase db) {
28 System.out.println("create table");
29         db.execSQL("create table " + ContentData.UserTableData.TABLE_NAME
30                 + "(" + ContentData.UserTableData._ID
31                 + " INTEGER PRIMARY KEY autoincrement,"
32                 + ContentData.UserTableData.NAME + " varchar(20),"
33                 + ContentData.UserTableData.TITLE + " varchar(20),"
34                 + ContentData.UserTableData.DATE_ADDED + " long,"
35                 + ContentData.UserTableData.SEX + " boolean)" + ";");
36     }
37 
38     @Override
39     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
40 
41     }
42 
43 }

3、内容提供者代码

  1 /**
  2  * 这个类给外部程序提供访问内部数据的一个接口
  3  * @author HB
  4  *
  5  */
  6 public class TeacherContentProvider extends ContentProvider {
  7     
  8     private DBOpenHelper dbOpenHelper = null;  
  9     // UriMatcher类用来匹配Uri，使用match()方法匹配路径时返回匹配码  
 10       
 11       
 12     /**
 13      * 是一个回调函数，在ContentProvider创建的时候，就会运行,第二个参数为指定数据库名称，如果不指定，就会找不到数据库；
 14      * 如果数据库存在的情况下是不会再创建一个数据库的。（当然首次调用 在这里也不会生成数据库必须调用SQLiteDatabase的 getWritableDatabase,getReadableDatabase两个方法中的一个才会创建数据库）
 15      */
 16     @Override  
 17     public boolean onCreate() { 
 18         //这里会调用 DBOpenHelper的构造函数创建一个数据库；
 19         dbOpenHelper = new DBOpenHelper(this.getContext(), ContentData.DATABASE_NAME, ContentData.DATABASE_VERSION);
 20         return true;  
 21     }  
 22     /**
 23      * 当执行这个方法的时候，如果没有数据库，他会创建，同时也会创建表，但是如果没有表，下面在执行insert的时候就会出错
 24      * 这里的插入数据也完全可以用sql语句书写，然后调用 db.execSQL(sql)执行。
 25      */
 26     @Override  
 27     public Uri insert(Uri uri, ContentValues values){  
 28         //获得一个可写的数据库引用，如果数据库不存在，则根据onCreate的方法里创建；
 29         SQLiteDatabase db = dbOpenHelper.getWritableDatabase();  
 30         long id = 0;  
 31         
 32         switch (uriMatcher.match(uri)) {  
 33         case TEACHERS:  
 34             id = db.insert("teacher", null, values);    // 返回的是记录的行号，主键为int，实际上就是主键值  
 35             return ContentUris.withAppendedId(uri, id);  
 36         case TEACHER:  
 37             id = db.insert("teacher", null, values); 
 38             String path = uri.toString();  
 39             return Uri.parse(path.substring(0, path.lastIndexOf("/"))+id); // 替换掉id  
 40         default:  
 41             throw new IllegalArgumentException("Unknown URI " + uri);  
 42         }
 43     }  
 44       
 45     @Override  
 46     public int delete(Uri uri, String selection, String[] selectionArgs) {  
 47         SQLiteDatabase db = dbOpenHelper.getWritableDatabase();  
 48         int count = 0;  
 49         switch (uriMatcher.match(uri)) {  
 50         case TEACHERS:  
 51             count = db.delete("teacher", selection, selectionArgs);  
 52             break;  
 53         case TEACHER:  
 54             // 下面的方法用于从URI中解析出id，对这样的路径content://hb.android.teacherProvider/teacher/10  
 55             // 进行解析，返回值为10  
 56             long personid = ContentUris.parseId(uri);  
 57             String where = "_ID=" + personid;    // 删除指定id的记录  
 58             where += !TextUtils.isEmpty(selection) ? " and (" + selection + ")" : "";    // 把其它条件附加上  
 59             count = db.delete("teacher", where, selectionArgs);  
 60             break;  
 61         default:  
 62             throw new IllegalArgumentException("Unknown URI " + uri);  
 63         }  
 64         db.close();  
 65         return count;  
 66     }  
 67   
 68     @Override  
 69     public int update(Uri uri, ContentValues values, String selection,  
 70             String[] selectionArgs) {  
 71         SQLiteDatabase db = dbOpenHelper.getWritableDatabase();  
 72         int count = 0;  
 73         switch (uriMatcher.match(uri)) {  
 74         case TEACHERS:  
 75             count = db.update("teacher", values, selection, selectionArgs);  
 76             break;  
 77         case TEACHER:  
 78             // 下面的方法用于从URI中解析出id，对这样的路径content://com.ljq.provider.personprovider/person/10  
 79             // 进行解析，返回值为10  
 80             long personid = ContentUris.parseId(uri);  
 81             String where = "_ID=" + personid;// 获取指定id的记录  
 82             where += !TextUtils.isEmpty(selection) ? " and (" + selection + ")" : "";// 把其它条件附加上  
 83             count = db.update("teacher", values, where, selectionArgs);  
 84             break;  
 85         default:  
 86             throw new IllegalArgumentException("Unknown URI " + uri);  
 87         }  
 88         db.close();  
 89         return count;  
 90     }  
 91       
 92     @Override  
 93     public String getType(Uri uri) {  
 94         switch (uriMatcher.match(uri)) {  
 95         case TEACHERS:  
 96             return CONTENT_TYPE;  
 97         case TEACHER:  
 98             return CONTENT_TYPE_ITME;  
 99         default:  
100             throw new IllegalArgumentException("Unknown URI " + uri);  
101         }  
102     }  
103   
104     @Override  
105     public Cursor query(Uri uri, String[] projection, String selection,  
106             String[] selectionArgs, String sortOrder) {  
107         SQLiteDatabase db = dbOpenHelper.getReadableDatabase();  
108         switch (uriMatcher.match(uri)) {  
109         case TEACHERS:  
110             return db.query("teacher", projection, selection, selectionArgs, null, null, sortOrder);  
111         case TEACHER:  
112             // 进行解析，返回值为10  
113             long personid = ContentUris.parseId(uri);  
114             String where = "_ID=" + personid;// 获取指定id的记录  
115             where += !TextUtils.isEmpty(selection) ? " and (" + selection + ")" : "";// 把其它条件附加上  
116             return db.query("teacher", projection, where, selectionArgs, null, null, sortOrder);  
117         default:  
118             throw new IllegalArgumentException("Unknown URI " + uri);  
119         }  
120     }  
121 }

PS：

1、这里我们在ArticlesProvider类的内部中定义了一个DBHelper类，它继承于SQLiteOpenHelper类，它用是用辅助我们操作数据库的。使用这个DBHelper类来辅助操作数据库的好处是只有当我们第一次对数据库时行操作时，系统才会执行打开数据库文件的操作。拿我们这个例子来说，只有第三方应用程序第一次调用query、insert、update或者delete函数来操作数据库时，我们才会真正去打开相应的数据库文件。这样在onCreate函数里，就不用执行打开数据库的操作，因为这是一个耗时的操作，而在onCreate函数中，要避免执行这些耗时的操作。

2、我们在实现自己的Content Provider时，必须继承于ContentProvider类，并且实现以下六个函数：

-- onCreate()，用来执行一些初始化的工作。

-- query(Uri, String[], String, String[], String)，用来返回数据给调用者。

-- insert(Uri, ContentValues)，用来插入新的数据。

-- update(Uri, ContentValues, String, String[])，用来更新已有的数据。

-- delete(Uri, String, String[])，用来删除数据。

-- getType(Uri)，用来返回数据的MIME类型。

4、manifest

 1 <!--?xml version="1.0" encoding="utf-8"?-->
 2 <manifest xmlns:android="http://schemas.android.com/apk/res/android" package="hb.android.contentProvider" android:versioncode="1" android:versionname="1.0">
 3     <uses-sdk android:minsdkversion="8">
 4      
 5          
 6             <intent-filter>
 7                  
 8                 <category android:name="android.intent.category.LAUNCHER">
 9             </category></action></intent-filter>
10         </activity>
11 <provider android:name=".TeacherContentProvider" android:authorities="hb.android.contentProvider" 
12 android:exported="true" android:multiprocess="false">
13     </provider></application>
14 </uses-sdk></manifest>

PS：

在配置Content Provider的时候，最重要的就是要指定它的authorities属性了，只有配置了这个属性，第三方应用程序才能通过它来找到这个Content Provider。这要需要注意的，这里配置的authorities属性的值是和我们前面在Articles.java文件中定义的AUTHORITY常量的值是一致的。另外一个属性multiprocess是一个布尔值，它表示这个Content Provider是否可以在每个客户进程中创建一个实例，这样做的目的是为了减少进程间通信的开销。这里我们为了减少不必要的内存开销，把属性multiprocess的值设置为false，使得系统只能有一个Content Provider实例存在，它运行在自己的进程中。在这个配置文件里面，我们还可以设置这个Content Provider的访问权限，
6、布局文件

1 <!--?xml version="1.0" encoding="utf-8"?-->
2 <linearlayout xmlns:android="http://schemas.android.com/apk/res/android" android:orientation="vertical" android:layout_width="fill_parent" android:layout_height="fill_parent">
3 <button android:id="@+id/insert" android:text="@string/insert" android:layout_width="fill_parent" android:layout_height="wrap_content">
4 </button><button android:id="@+id/query" android:text="@string/query" android:layout_width="fill_parent" android:layout_height="wrap_content">
5 </button><button android:id="@+id/querys" android:text="@string/querys" android:layout_width="fill_parent" android:layout_height="wrap_content">
6 </button><button android:id="@+id/update" android:text="@string/update" android:layout_width="fill_parent" android:layout_height="wrap_content">
7 </button><button android:id="@+id/delete" android:text="@string/delete" android:layout_width="fill_parent" android:layout_height="wrap_content">
8  
9 </button></linearlayout>

7、activity

  1 package hb.android.contentProvider;
  2 
  3 import java.util.Date;
  4 
  5 import android.app.Activity;
  6 import android.content.ContentResolver;
  7 import android.content.ContentValues;
  8 import android.database.Cursor;
  9 import android.net.Uri;
 10 import android.os.Bundle;
 11 import android.view.View;
 12 import android.view.View.OnClickListener;
 13 import android.widget.Button;
 14 
 15 /**
 16  * 这个类用来测试ContentProvider是否可用。通过 给定的uri访问，数据库；
 17  * 
 18  * @author HB
 19  * 
 20  */
 21 public class TeacherActivity extends Activity {
 22     Button insert;
 23     Button query;
 24     Button update;
 25     Button delete;
 26     Button querys;
 27     Uri uri = Uri.parse("content://hb.android.contentProvider/teacher");
 28 
 29     /** Called when the activity is first created. */
 30     @Override
 31     public void onCreate(Bundle savedInstanceState) {
 32         super.onCreate(savedInstanceState);
 33         setContentView(R.layout.main);
 34 
 35         insert = (Button) findViewById(R.id.insert);
 36         query = (Button) findViewById(R.id.query);
 37         update = (Button) findViewById(R.id.update);
 38         delete = (Button) findViewById(R.id.delete);
 39         querys = (Button) findViewById(R.id.querys);
 40         // 绑定监听器的两种方法一；
 41         insert.setOnClickListener(new InsertListener());
 42         query.setOnClickListener(new QueryListener());
 43         // 方法二
 44         update.setOnClickListener(new OnClickListener() {
 45             public void onClick(View v) {
 46                 // TODO Auto-generated method stub
 47                 ContentResolver cr = getContentResolver();
 48                 ContentValues cv = new ContentValues();
 49                 cv.put("name", "huangbiao");
 50                 cv.put("date_added", (new Date()).toString());
 51                 int uri2 = cr.update(uri, cv, "_ID=?", new String[]{"3"});
 52 System.out.println("updated"+":"+uri2);
 53             }
 54         });
 55 
 56         delete.setOnClickListener(new OnClickListener() {
 57             
 58             public void onClick(View v) {
 59                 ContentResolver cr = getContentResolver();
 60                 cr.delete(uri, "_ID=?", new String[]{"2"});
 61             }
 62         });
 63 
 64         querys.setOnClickListener(new OnClickListener() {
 65 
 66             public void onClick(View v) {
 67                 // TODO Auto-generated method stub
 68                 ContentResolver cr = getContentResolver();
 69                 // 查找id为1的数据
 70                 Cursor c = cr.query(uri, null, null,null, null);
 71                 System.out.println(c.getCount());
 72                 c.close();
 73             }
 74         });
 75     }
 76 
 77     class InsertListener implements OnClickListener {
 78 
 79         public void onClick(View v) {
 80             // TODO Auto-generated method stub
 81             ContentResolver cr = getContentResolver();
 82 
 83             ContentValues cv = new ContentValues();
 84             cv.put("title", "jiaoshou");
 85             cv.put("name", "jiaoshi");
 86             cv.put("sex", true);
 87             Uri uri2 = cr.insert(uri, cv);
 88             System.out.println(uri2.toString());
 89         }
 90 
 91     }
 92 
 93     class QueryListener implements OnClickListener {
 94 
 95         public void onClick(View v) {
 96             // TODO Auto-generated method stub
 97             ContentResolver cr = getContentResolver();
 98             // 查找id为1的数据
 99             Cursor c = cr.query(uri, null, "_ID=?", new String[] { "1" }, null);
100             //这里必须要调用 c.moveToFirst将游标移动到第一条数据,不然会出现index -1 requested , with a size of 1错误；cr.query返回的是一个结果集。
101             if (c.moveToFirst() == false) {
102                 // 为空的Cursor
103                 return;
104             }
105             int name = c.getColumnIndex("name");
106             System.out.println(c.getString(name));
107             c.close();
108         }
109     }
110 }

最终的效果如下：

n峨�
夗z{O畫鈛觊wk�'Z喎� 组件Content Provider中的数据更新通知机制和Android系统中的广播（Broadcast）通知机制的实现思路是相似的。

在Android的广播机制中，首先是接收者对自己感兴趣的广播进行注册，接着当发送者发出这些广播时，接收者就会得到通知了。更多关于Android系统的广播机制的知识，可以参考前面Android四大组件--Broadcast Receiver详解这一文章。

然而，Content Provider中的数据监控机制与Android系统中的广播机制又有三个主要的区别，

一是前者是通过URI来把通知的发送者和接收者关联在一起的，而后者是通过Intent来关联的，

二是前者的通知注册中心是由ContentService服务来扮演的，而后者是由ActivityManagerService服务来扮演的，

三是前者负责接收数据更新通知的类必须要继承ContentObserver类，而后者要继承BroadcastReceiver类。

之所以会有这些区别，是由于Content Proivder组件的数据共享功能本身就是建立在URI的基础之上的，因此专门针对URI来设计另外一套通知机制会更实用和方便，而Android系统的广播机制是一种更加通用的事件通知机制，它的适用范围会更广泛一些。

posted @ 2016-04-15 12:58 ts-android 阅读(480) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

ts-android

内容提供者ContentProvider例子

公告