android四大组件--ContentProvider具体解释

一、相关ContentProvider概念解析：

1、ContentProvider简单介绍

在Android官方指出的Android的数据存储方式总共同拥有五种，各自是：Shared Preferences、网络存储、文件存储、外储存储、SQLite。可是我们知道一般这些存储都仅仅是在单独的一个应用程序之中达到一个数据的共享，有时候我们须要操作其它应用程序的一些数据，比如我们须要操作系统里的媒体库、通讯录等，这时我们就可能通过ContentProvider来满足我们的需求了。

2、为什么要选择ContentProvider？

ContentProvider向我们提供了我们在应用程序之前共享数据的一种机制，而我们知道每个应用程序都是执行在不同的应用程序的，数据和文件在不同应用程序之间达到数据的共享不是没有可能，而是显得比較复杂，而正好Android中的ContentProvider则达到了这一需求，比方有时候我们须要操作手机里的联系人，手机里的多媒体等一些信息，我们都能够用到这个ContentProvider来达到我们所需。

1）、ContentProvider为存储和获取数据提供了统一的接口。ContentProvide对数据进行封装，不用关心数据存储的细节。使用表的形式来组织数据。

  2）、使用ContentProvider能够在不同的应用程序之间共享数据。 

  3）、Android为常见的一些数据提供了默认的ContentProvider（包含音频、视频、图片和通讯录等）。   

总的来说使用ContentProvider对外共享数据的优点是统一了数据的訪问方式。

3、Uri介绍

为系统的每个资源给其一个名字，例如说通话记录。

1）、每个ContentProvider都拥有一个公共的URI，这个URI用于表示这个ContentProvider所提供的数据。 

2）、Android所提供的ContentProvider都存放在android.provider包中。 将其分为A，B，C，D 4个部分：





 A：标准前缀，用来说明一个Content Provider控制这些数据，无法改变的；"content://"

 B：URI 的标识，用于唯一标识这个ContentProvider，外部调用者能够依据这个标识来找到它。它定义了是哪个Content Provider提供这些数据。对于第三方应用程序，为了保证URI标识的唯一性，它必须是一个完整的、小写的类名。这个标识在 元素的 authorities属性中说明：通常是定义该ContentProvider的包.类的名称

 C：路径（path），通俗的讲就是你要操作的数据库中表的名字，或者你也能够自定义，记得在使用的时候保持一致就能够了；"content://com.bing.provider.myprovider/tablename"

 D：假设URI中包括表示须要获取的记录的ID；则就返回该id相应的数据，假设没有ID，就表示返回所有； "content://com.bing.provider.myprovider/tablename/#" #表示数据id。

PS：

路径（path）能够用来表示我们要操作的数据，路径的构建应依据业务而定，例如以下:

1、要操作person表中id为10的记录，能够构建这种路径:/person/10

2、要操作person表中id为10的记录的name字段， person/10/name

3、要操作person表中的全部记录，能够构建这种路径:/person

4、要操作xxx表中的记录，能够构建这种路径:/xxx

5、当然要操作的数据不一定来自数据库，也能够是文件、xml或网络等其它存储方式，例如以下:

要操作xml文件里person节点下的name节点，能够构建这种路径：/person/name

6、假设要把一个字符串转换成Uri，能够使用Uri类中的parse()方法，例如以下：Uri uri = Uri.parse("content://com.bing.provider.personprovider/person")

4、UriMatcher类使用介绍

由于Uri代表了要操作的数据，所以我们常常须要解析Uri，并从Uri中获取数据。Android系统提供了两个用于操作Uri的工具类，分别为UriMatcher和ContentUris
。掌握它们的使用，会便于我们的开发工作。

UriMatcher类用于匹配Uri，它的使用方法例如以下：

首先第一步把你须要匹配Uri路径所有给注冊上，例如以下：

//常量UriMatcher.NO_MATCH表示不匹配不论什么路径的返回码
UriMatcher  sMatcher = new UriMatcher(UriMatcher.NO_MATCH);
//假设match()方法匹配content://com.bing.procvide.personprovider/person路径，返回匹配码为1
sMatcher.addURI("com.bing.procvide.personprovider", "person", 1);//加入须要匹配uri，假设匹配就会返回匹配码
//假设match()方法匹配content://com.bing.provider.personprovider/person/230路径，返回匹配码为2
sMatcher.addURI("com.bing.provider.personprovider", "person/#", 2);//#号为通配符
switch (sMatcher.match(Uri.parse("content://com.ljq.provider.personprovider/person/10"))) {
   case 1
     break;
   case 2
     break;
   default://不匹配
     break;
}

注冊完须要匹配的Uri后，就能够使用sMatcher.match(uri)方法对输入的Uri进行匹配，如果匹配就返回匹配码，匹配码是调用addURI()方法传入的第三个參数，如果匹配content://com.ljq.provider.personprovider/person路径，返回的匹配码为1

5、ContentUris类使用介绍

ContentUris类用于操作Uri路径后面的ID部分，它有两个比較有用的方法：

withAppendedId(uri, id)用于为路径加上ID部分：

Uri uri = Uri.parse("content://com.bing.provider.personprovider/person")
Uri resultUri = ContentUris.withAppendedId(uri, 10);
//生成后的Uri为：content://com.bing.provider.personprovider/person/10

parseId(uri)方法用于从路径中获取ID部分：

Uri uri = Uri.parse("content://com.ljq.provider.personprovider/person/10")
long personid = ContentUris.parseId(uri);//获取的结果为:10

6、使用ContentProvider共享数据

1）ContentProvider类主要方法的作用：

public boolean onCreate()：该方法在ContentProvider创建后就会被调用，Android开机后，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中获取数据。

public String getType(Uri uri)：该方法用于返回当前Url所代表数据的MIME类型。



2）假设操作的数据属于集合类型，那么MIME类型字符串应该以vnd.android.cursor.dir/开头，



比如：要得到全部person记录的Uri为content://com.bing.provider.personprovider/person，那么返回的MIME类型字符串应该为："vnd.android.cursor.dir/person"。



3）假设要操作的数据属于非集合类型数据，那么MIME类型字符串应该以vnd.android.cursor.item/开头，



比如：得到id为10的person记录，Uri为content://com.bing.provider.personprovider/person/10，那么返回的MIME类型字符串为："vnd.android.cursor.item/person"。

7、ContentResolver操作ContentProvider中的数据

1）当外部应用须要对ContentProvider中的数据进行加入、删除、改动和查询操作时，能够使用ContentResolver
类来完毕，要获取ContentResolver 对象，能够使用Activity提供的getContentResolver()方法。

2）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和对当中的什么数据进行操作，

事实上和contentprovider里面的方法是一样的.他们所相应的数据,终于是会被传到我们在之前程序里面定义的那个contentprovider类的方法,

如果给定的是：Uri.parse("content://com.bing.providers.personprovider/person/10")，那么将会对主机名为com.bing.providers.personprovider的ContentProvider进行操作，操作的数据为person表中id为10的记录。



使用ContentResolver对ContentProvider中的数据进行加入、删除、改动和查询操作：

ContentResolver resolver =  getContentResolver();
Uri uri = Uri.parse("content://com.bing.provider.personprovider/person");
//加入一条记录
ContentValues values = new ContentValues();
values.put("name", "bingxin");
values.put("age", 25);
resolver.insert(uri, values);
//获取person表中全部记录
Cursor cursor = resolver.query(uri, null, null, null, "personid desc");
while(cursor.moveToNext()){
   Log.i("ContentTest", "personid="+ cursor.getInt(0)+ ",name="+ cursor.getString(1));
}
//把id为1的记录的name字段值更改新为zhangsan
ContentValues updateValues = new ContentValues();
updateValues.put("name", "zhangsan");
Uri updateIdUri = ContentUris.withAppendedId(uri, 2);
resolver.update(updateIdUri, updateValues, null, null);
//删除id为2的记录
Uri deleteIdUri = ContentUris.withAppendedId(uri, 2);
resolver.delete(deleteIdUri, null, null);

8、监听ContentProvider中数据的变化



假设ContentProvider的訪问者须要知道ContentProvider中的数据发生变化，能够在ContentProvider发生数据变化时调用getContentResolver().notifyChange(uri, null)来通知注冊在此URI上的訪问者，样例例如以下：

public class PersonContentProvider extends ContentProvider {
   public Uri insert(Uri uri, ContentValues values) {
      db.insert("person", "personid", values);
      getContext().getContentResolver().notifyChange(uri, null);
   }
}

假设ContentProvider的訪问者须要得到数据变化通知，必须使用ContentObserver对数据（数据採用uri描写叙述）进行监听，当监听到数据变化通知时，系统就会调用ContentObserver的onChange()方法：

getContentResolver().registerContentObserver(Uri.parse("content://com.ljq.providers.personprovider/person"),
       true, new PersonObserver(new Handler()));
public class PersonObserver extends ContentObserver{
   public PersonObserver(Handler handler) {
      super(handler);
   }
   public void onChange(boolean selfChange) {
      //此处能够进行对应的业务处理
   }
}

二、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訪问的不同资源的类型。

      比如：

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

这里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其中进行声明。

<!-- android:name是完毕ContentProvider类的全称
             android:authorities是和FirstProvidermetaData中的常量AUTHORITY的值一样，否则会报错
         -->
        <provider android:name="com.bj.FirstContentProvider"
            android:authorities="com.bj.firstcontentprovider"
            />

三、实例

1、常量类

/**
 * 提供ContentProvider对外的各种常量，当外部数据须要訪问的时候，就能够參考这些常量操作数据。
 * @author HB
 *
 */
public class ContentData {
	public static final String AUTHORITY = "hb.android.contentProvider";
	public static final String DATABASE_NAME = "teacher.db";
	//创建 数据库的时候，都必须加上版本号信息；而且必须大于4
	public static final int DATABASE_VERSION = 4;
	public static final String USERS_TABLE_NAME = "teacher";

	public static final class UserTableData implements BaseColumns {
		public static final String TABLE_NAME = "teacher";
		//Uri，外部程序须要訪问就是通过这个Uri訪问的，这个Uri必须的唯一的。
		public static final Uri CONTENT_URI = Uri.parse("content://"+ AUTHORITY + "/teacher");
		// 数据集的MIME类型字符串则应该以vnd.android.cursor.dir/开头
		public static final String CONTENT_TYPE = "vnd.android.cursor.dir/hb.android.teachers";
		// 单一数据的MIME类型字符串应该以vnd.android.cursor.item/开头
		public static final String CONTENT_TYPE_ITME = "vnd.android.cursor.item/hb.android.teacher";
		/* 自己定义匹配码 */
	    public static final int TEACHERS = 1;
	    /* 自己定义匹配码 */
	    public static final int TEACHER = 2;  

		public static final String TITLE = "title";
		public static final String NAME = "name";
		public static final String DATE_ADDED = "date_added";
		public static final String SEX = "SEX";
		public static final String DEFAULT_SORT_ORDER = "_id desc";

		public static final UriMatcher uriMatcher;
	    static {
	        // 常量UriMatcher.NO_MATCH表示不匹配不论什么路径的返回码
	        uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
	        // 假设match()方法匹配content://hb.android.teacherProvider/teachern路径,返回匹配码为TEACHERS
	        uriMatcher.addURI(ContentData.AUTHORITY, "teacher", TEACHERS);
	        // 假设match()方法匹配content://hb.android.teacherProvider/teacher/230,路径，返回匹配码为TEACHER
	        uriMatcher.addURI(ContentData.AUTHORITY, "teacher/#", TEACHER);
	    }
	}
}

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

/**
 * 这个类继承SQLiteOpenHelper抽象类，用于创建数据库和表。创建数据库是调用它的父类构造方法创建。
 * @author HB
 */
public class DBOpenHelper extends SQLiteOpenHelper {

	// 在SQLiteOepnHelper的子类其中，必须有该构造函数，用来创建一个数据库；
	public DBOpenHelper(Context context, String name, CursorFactory factory,
			int version) {
		// 必须通过super调用父类其中的构造函数
		super(context, name, factory, version);
		// TODO Auto-generated constructor stub
	}

	// public DBOpenHelper(Context context, String name) {
	// this(context, name, VERSION);
	// }

	public DBOpenHelper(Context context, String name, int version) {
		this(context, name, null, version);
	}

	/**
	 * 仅仅有当数据库运行创建 的时候，才会运行这种方法。假设更改表名，也不会创建，仅仅有当创建数据库的时候，才会创建改表名之后 的数据表
	 */
	@Override
	public void onCreate(SQLiteDatabase db) {
System.out.println("create table");
		db.execSQL("create table " + ContentData.UserTableData.TABLE_NAME
				+ "(" + ContentData.UserTableData._ID
				+ " INTEGER PRIMARY KEY autoincrement,"
				+ ContentData.UserTableData.NAME + " varchar(20),"
				+ ContentData.UserTableData.TITLE + " varchar(20),"
				+ ContentData.UserTableData.DATE_ADDED + " long,"
				+ ContentData.UserTableData.SEX + " boolean)" + ";");
	}

	@Override
	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {

	}

}

3、内容提供者代码

/**
 * 这个类给外部程序提供訪问内部数据的一个接口
 * @author HB
 *
 */
public class TeacherContentProvider extends ContentProvider {

	private DBOpenHelper dbOpenHelper = null;
	// UriMatcher类用来匹配Uri，使用match()方法匹配路径时返回匹配码  

    /**
     * 是一个回调函数，在ContentProvider创建的时候，就会运行,第二个參数为指定数据库名称，假设不指定，就会找不到数据库；
     * 假设数据库存在的情况下是不会再创建一个数据库的。（当然首次调用 在这里也不会生成数据库必须调用SQLiteDatabase的 getWritableDatabase,getReadableDatabase两个方法中的一个才会创建数据库）
     */
    @Override
    public boolean onCreate() {
    	//这里会调用 DBOpenHelper的构造函数创建一个数据库；
        dbOpenHelper = new DBOpenHelper(this.getContext(), ContentData.DATABASE_NAME, ContentData.DATABASE_VERSION);
        return true;
    }
    /**
     * 当运行这种方法的时候，假设没有数据库，他会创建，同一时候也会创建表，可是假设没有表，以下在运行insert的时候就会出错
     * 这里的插入数据也全然能够用sql语句书写，然后调用 db.execSQL(sql)运行。
     */
    @Override
    public Uri insert(Uri uri, ContentValues values){
    	//获得一个可写的数据库引用，假设数据库不存在，则依据onCreate的方法里创建；
        SQLiteDatabase db = dbOpenHelper.getWritableDatabase();
        long id = 0;  

        switch (uriMatcher.match(uri)) {
        case TEACHERS:
            id = db.insert("teacher", null, values);	// 返回的是记录的行号，主键为int，实际上就是主键值
            return ContentUris.withAppendedId(uri, id);
        case TEACHER:
            id = db.insert("teacher", null, values);
            String path = uri.toString();
            return Uri.parse(path.substring(0, path.lastIndexOf("/"))+id); // 替换掉id
        default:
            throw new IllegalArgumentException("Unknown URI " + uri);
        }
    }  

    @Override
    public int delete(Uri uri, String selection, String[] selectionArgs) {
        SQLiteDatabase db = dbOpenHelper.getWritableDatabase();
        int count = 0;
        switch (uriMatcher.match(uri)) {
        case TEACHERS:
            count = db.delete("teacher", selection, selectionArgs);
            break;
        case TEACHER:
            // 以下的方法用于从URI中解析出id，对这种路径content://hb.android.teacherProvider/teacher/10
            // 进行解析，返回值为10
            long personid = ContentUris.parseId(uri);
            String where = "_ID=" + personid;	// 删除指定id的记录
            where += !TextUtils.isEmpty(selection) ? " and (" + selection + ")" : "";	// 把其他条件附加上
            count = db.delete("teacher", where, selectionArgs);
            break;
        default:
            throw new IllegalArgumentException("Unknown URI " + uri);
        }
        db.close();
        return count;
    }  

    @Override
    public int update(Uri uri, ContentValues values, String selection,
            String[] selectionArgs) {
        SQLiteDatabase db = dbOpenHelper.getWritableDatabase();
        int count = 0;
        switch (uriMatcher.match(uri)) {
        case TEACHERS:
            count = db.update("teacher", values, selection, selectionArgs);
            break;
        case TEACHER:
            // 以下的方法用于从URI中解析出id，对这种路径content://com.ljq.provider.personprovider/person/10
            // 进行解析，返回值为10
            long personid = ContentUris.parseId(uri);
            String where = "_ID=" + personid;// 获取指定id的记录
            where += !TextUtils.isEmpty(selection) ? " and (" + selection + ")" : "";// 把其他条件附加上
            count = db.update("teacher", values, where, selectionArgs);
            break;
        default:
            throw new IllegalArgumentException("Unknown URI " + uri);
        }
        db.close();
        return count;
    }  

    @Override
    public String getType(Uri uri) {
        switch (uriMatcher.match(uri)) {
        case TEACHERS:
            return CONTENT_TYPE;
        case TEACHER:
            return CONTENT_TYPE_ITME;
        default:
            throw new IllegalArgumentException("Unknown URI " + uri);
        }
    }  

    @Override
    public Cursor query(Uri uri, String[] projection, String selection,
            String[] selectionArgs, String sortOrder) {
        SQLiteDatabase db = dbOpenHelper.getReadableDatabase();
        switch (uriMatcher.match(uri)) {
        case TEACHERS:
            return db.query("teacher", projection, selection, selectionArgs, null, null, sortOrder);
        case TEACHER:
            // 进行解析，返回值为10
            long personid = ContentUris.parseId(uri);
            String where = "_ID=" + personid;// 获取指定id的记录
            where += !TextUtils.isEmpty(selection) ? " and (" + selection + ")" : "";// 把其他条件附加上
            return db.query("teacher", projection, where, selectionArgs, null, null, sortOrder);
        default:
            throw new IllegalArgumentException("Unknown URI " + uri);
        }
    }
}

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

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
      package="hb.android.contentProvider"
      android:versionCode="1"
      android:versionName="1.0">
    <uses-sdk android:minSdkVersion="8" />
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".TeacherActivity"
                  android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
<provider android:name=".TeacherContentProvider" android:authorities="hb.android.contentProvider" android:multiprocess="false" />
    </application>
</manifest>

PS：

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

6、布局文件

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="vertical"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    >
<Button
	android:id="@+id/insert"
	android:text="@string/insert"
	android:layout_width="fill_parent"
	android:layout_height="wrap_content"/>
<Button
	android:id="@+id/query"
	android:text="@string/query"
	android:layout_width="fill_parent"
	android:layout_height="wrap_content"/>
<Button
	android:id="@+id/querys"
	android:text="@string/querys"
	android:layout_width="fill_parent"
	android:layout_height="wrap_content"/>
<Button
	android:id="@+id/update"
	android:text="@string/update"
	android:layout_width="fill_parent"
	android:layout_height="wrap_content"/>
<Button
	android:id="@+id/delete"
	android:text="@string/delete"
	android:layout_width="fill_parent"
	android:layout_height="wrap_content"/>
</LinearLayout>

7、activity

package hb.android.contentProvider;

import java.util.Date;

import android.app.Activity;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.database.Cursor;
import android.net.Uri;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;

/**
 * 这个类用来測试ContentProvider是否可用。通过 给定的uri訪问，数据库；
 *
 * @author HB
 *
 */
public class TeacherActivity extends Activity {
	Button insert;
	Button query;
	Button update;
	Button delete;
	Button querys;
	Uri uri = Uri.parse("content://hb.android.contentProvider/teacher");

	/** Called when the activity is first created. */
	@Override
	public void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.main);

		insert = (Button) findViewById(R.id.insert);
		query = (Button) findViewById(R.id.query);
		update = (Button) findViewById(R.id.update);
		delete = (Button) findViewById(R.id.delete);
		querys = (Button) findViewById(R.id.querys);
		// 绑定监听器的两种方法一；
		insert.setOnClickListener(new InsertListener());
		query.setOnClickListener(new QueryListener());
		// 方法二
		update.setOnClickListener(new OnClickListener() {
			public void onClick(View v) {
				// TODO Auto-generated method stub
				ContentResolver cr = getContentResolver();
				ContentValues cv = new ContentValues();
				cv.put("name", "huangbiao");
				cv.put("date_added", (new Date()).toString());
				int uri2 = cr.update(uri, cv, "_ID=?", new String[]{"3"});
System.out.println("updated"+":"+uri2);
			}
		});

		delete.setOnClickListener(new OnClickListener() {

			public void onClick(View v) {
				ContentResolver cr = getContentResolver();
				cr.delete(uri, "_ID=?", new String[]{"2"});
			}
		});

		querys.setOnClickListener(new OnClickListener() {

			public void onClick(View v) {
				// TODO Auto-generated method stub
				ContentResolver cr = getContentResolver();
				// 查找id为1的数据
				Cursor c = cr.query(uri, null, null,null, null);
				System.out.println(c.getCount());
				c.close();
			}
		});
	}

	class InsertListener implements OnClickListener {

		public void onClick(View v) {
			// TODO Auto-generated method stub
			ContentResolver cr = getContentResolver();

			ContentValues cv = new ContentValues();
			cv.put("title", "jiaoshou");
			cv.put("name", "jiaoshi");
			cv.put("sex", true);
			Uri uri2 = cr.insert(uri, cv);
			System.out.println(uri2.toString());
		}

	}

	class QueryListener implements OnClickListener {

		public void onClick(View v) {
			// TODO Auto-generated method stub
			ContentResolver cr = getContentResolver();
			// 查找id为1的数据
			Cursor c = cr.query(uri, null, "_ID=?", new String[] { "1" }, null);
			//这里必需要调用 c.moveToFirst将游标移动到第一条数据,不然会出现index -1 requested , with a size of 1错误；cr.query返回的是一个结果集。
			if (c.moveToFirst() == false) {
				// 为空的Cursor
				return;
			}
			int name = c.getColumnIndex("name");
			System.out.println(c.getString(name));
			c.close();
		}
	}
}

终于的效果例如以下：

PS：Content Provider中的数据更新通知机制

Android应用程序组件Content Provider中的数据更新通知机制和Android系统中的广播（Broadcast）通知机制的实现思路是相似的。

在Android的广播机制中，首先是接收者对自己感兴趣的广播进行注冊，接着当发送者发出这些广播时，接收者就会得到通知了。很多其它关于Android系统的广播机制的知识，能够參考前面Android四大组件--Broadcast
Receiver具体解释这一文章。

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

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

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

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

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