好记性不如烂笔杆android学习笔记<九> Content Provider 数据共享机制

21，//Content Provider 数据共享机制
<1>//在minifest.xml文件中注册
<provider
android:name="zjq.contentprovider.FirstContentProvider"
android:authorities="zjq.contentprovider.FirstContentProvider"
/>
//main.xml文件中添加一个TextView和两个Button
Java文件
<2>//创建一个数据库的工具类

public class FirstProviderMetaData {
    public static final String AUTHORIY = "zjq.contentprovider.FirstContentProvider";
    //数据库名称
    public static final String DATABASE_NAME = "FirstProvider.db";
    //数据库版本
    public static final int DATABASE_VERSION = 1;
    //表名
    public static final String USERS_TABLE_NAME = "users";
    
    public static final class UserTableMetaData implements BaseColumns{
    //表名
    public static final String TABLE_NAME = "users";
    //访问该ContentProvider的URL
    public static final Uri CONTENT_URI = Uri.parse("content://" + AUTHORIY + "/users");
    //访问该ContentProvider所返回的数据类型的定义
    public static final String CONTENT_TYPE = "vnd.android.cursor.dir/vnd.firstprovider.user";
    public static final String CONTENT_TYPE_ITEM = "vnd.android.cursor.item/vnd.firstprovider.user";
    //列名
    public static final String USER_NAME = "name";
    //默认的排序方法
    public static final String DEFAULT_SORT_ORDER = "_id desc";
    }
}

<3>//创建一个数据库
//DatabaseHelper作为一个访问SQLite的助手类，提供两个方面的功能
//第一，getReadableDatabase(),getWritableDatabase()可以获得SQLiteDatabase对象，通过该对象可以对数据库进行操作
//第二，提供了onCreate和onUpgrade两个回调函数，允许我们创建和升级数据库时，进行自己的操作。

public class DatabaseHelper extends SQLiteOpenHelper {
    private static final int VERSION = 1 ;
    //在SQLiteOpenHelper的子类中，必须有该构造函数
    public DatabaseHelper(Context context, String name, CursorFactory  factory,
            int version){
        //必须通过super调用父类当中的构造函数
        super(context, name, factory, version);
    }
    public DatabaseHelper(Context context, String name){
        //必须通过super调用父类当中的构造函数
        this(context, name,VERSION);
    }
    public DatabaseHelper(Context context, String name,int version){
        //必须通过super调用父类当中的构造函数
        this(context, name,null, version);
    }
    
    //该函数是在第一次创建数据库的时候执行，实际上是在第一次得到SQLiteDatabase对象的时候,才会调用这个方法
    @Override
    public void onCreate(SQLiteDatabase db) {
        System.out.println("create a Database");
        //execSQL函数用于执行SQL语句
        db.execSQL("create table " + FirstProviderMetaData.USERS_TABLE_NAME 
                + "(" + FirstProviderMetaData.UserTableMetaData._ID
                + " INTEGER PRIMARY KEY AUTOINCREMENT,"
                +  FirstProviderMetaData.UserTableMetaData.USER_NAME
                + " varchar(20))");
    }
    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // TODO Auto-generated method stub
        System.out.println("update a Database");
    }
}

<4>//创建一个ContentProvider对象，对数据库的接口进行包装：

public class FirstContentProvider extends ContentProvider {

    public static final UriMatcher uriMatcher;
    public static final int INCOMING_USER_COLLECTION = 1;
    public static final int INCOMING_USER_SINGLE = 2;
    private DatabaseHelper dh;
    static {
        //UriMatcher 在ContentProvider中帮助匹配URL
        uriMatcher = new UriMatcher(UriMatcher.NO_MATCH);
        //FirstProviderMetaData.AUTHORIY部分的值是之前URL中/和/之间的内容，所以这里不需要users前的/
        uriMatcher.addURI( FirstProviderMetaData.AUTHORIY, "users",
                INCOMING_USER_COLLECTION);
        uriMatcher.addURI(FirstProviderMetaData.AUTHORIY, "users/#",
                INCOMING_USER_SINGLE);
    }
    public static HashMap<String,String> userProjectionMap;
    static
    {
        userProjectionMap = new HashMap<String,String>();
        userProjectionMap.put(UserTableMetaData._ID,UserTableMetaData._ID);
        userProjectionMap.put(UserTableMetaData.USER_NAME, UserTableMetaData.USER_NAME);
    }
    @Override
    public int delete(Uri arg0, String arg1, String[] arg2) {
        System.out.println("delete");
        return 0;
    }

    //根据传入的URI，返回该URI所表示的数据类型
    @Override
    public String getType(Uri uri) {
        System.out.println("getType");
        switch(uriMatcher.match(uri)){
        case INCOMING_USER_COLLECTION:
            return UserTableMetaData.CONTENT_TYPE;
        case INCOMING_USER_SINGLE:
            return UserTableMetaData.CONTENT_TYPE_ITEM;
        default:
            throw new IllegalArgumentException("Unknown URI" + uri);
        }
    }
    /**
     * 该函数的返回值是一个URI，这个URI表示的是刚刚使用这个函数所插入的数据
     * content://mars.cp.FirstContentProvider/users/1
    */
    @Override
    public Uri insert(Uri uri, ContentValues values) {
        System.out.println("insert");
        SQLiteDatabase db = dh.getWritableDatabase();
        long rowId = db.insert(UserTableMetaData.TABLE_NAME, null, values);
        if(rowId > 0){
            Uri insertedUserUri = ContentUris.withAppendedId(UserTableMetaData.CONTENT_URI, rowId);
            //通知监听器，数据已经改变
            getContext().getContentResolver().notifyChange(insertedUserUri, null);
            return insertedUserUri;
        }
        throw new SQLException("Failed to insert row into" + uri);
    }

    //是一个回调方法，所以说在ContentProvider创建的时候执行
    @Override
    public boolean onCreate() {
        //打开数据库
        dh = new DatabaseHelper(getContext(),FirstProviderMetaData.DATABASE_NAME);
        System.out.println("FirstContentProvider.java onCreate");
        return true;
    }
    //查询方法
    @Override
    public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs,
            String sortOrder) {
        System.out.println("Query Debug");
        //SQLiteQueryBuilder类，用于创建一个查询的语句
        SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
        int type = uriMatcher.match(uri);
        switch(type){
        case INCOMING_USER_COLLECTION:
            qb.setTables(UserTableMetaData.TABLE_NAME);
            qb.setProjectionMap(userProjectionMap);
            break;
        case INCOMING_USER_SINGLE:
            qb.setTables(UserTableMetaData.TABLE_NAME);
            qb.setProjectionMap(userProjectionMap);
            qb.appendWhere(UserTableMetaData._ID + "=" + uri.getPathSegments().get(1));
            break;
        }
        String orderBy;
        if(TextUtils.isEmpty(sortOrder)){
            orderBy = UserTableMetaData.DEFAULT_SORT_ORDER;
        }
        else{
            orderBy = sortOrder;
        }
        SQLiteDatabase db = dh.getWritableDatabase();
        Cursor c = qb.query(db, projection, selection, selectionArgs, null, null, orderBy);
        c.setNotificationUri(getContext().getContentResolver(), uri);
        System.out.println("query");
        return c;
    }
    @Override
    public int update(Uri arg0, ContentValues arg1, String arg2, String[] arg3) {
        System.out.println("update");
        return 0;
    }
}

<5>//创建一个测试用的Activity，对DB进行插入和查找

public class CPActivity extends Activity {
    private Button insertButton = null;
    private Button queryButton = null;
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);
        queryButton = (Button) findViewById(R.id.query);
        queryButton.setOnClickListener(new QueryListener());
        insertButton = (Button) findViewById(R.id.insert);
        insertButton.setOnClickListener(new InsertListener());
        System.out.println(getContentResolver().getType(FirstProviderMetaData.UserTableMetaData.CONTENT_URI));
    }
    class InsertListener implements OnClickListener {

        @Override
        public void onClick(View v) {
            ContentValues values = new ContentValues();
            //把数据存如Values中
            values.put(FirstProviderMetaData.UserTableMetaData.USER_NAME,
                    "zhangsan");
            Uri uri = getContentResolver()
                    .insert(
                            FirstProviderMetaData.UserTableMetaData.CONTENT_URI,
                            values);
            System.out.println("uri--->" + uri.toString());
        }

    }
    class QueryListener implements OnClickListener {

        @Override
        public void onClick(View v) {
            //设置查询表中的那些字段，new String[]{"_id","name"}
            Cursor c = getContentResolver().query(
                    FirstProviderMetaData.UserTableMetaData.CONTENT_URI, new String[]{"_id","name"},
                    null, null, null);
            while(c.moveToNext()){
                //System.out.println(c.getString(c.getColumnIndex(UserTableMetaData.USER_NAME)));
            }
        }
    }
}

<6>,其他的一些指令

//删除数据库：

Context.deleteDatabase(String name)删除指定名称的数据库
this.deleteDatabase("myDatabase.db");
//打开数据库：
SQLiteDatabase my_DataBase = this.openOrCreateDatabase("myDatabase.db",MODE_PRIVATE,null);
my_Database.close();
//非查询 SQL 指令
SQLiteDatabase.execSQL(String sql)可以用来执行非查询 SQL 指令,这些指令没有结果
包括:CREATE TABLE / DROP TABLE / INSERT 等等
//创建一个名为"test"并带两个参数的表
my_DataBase.execSQL("CREATE TABLE test (_id INTEGER PRIMARY KEY,
someNumber INTERGER);");
//在数据库中插入一个元组
my_DataBase.execSQL("INSERT INTO test (_id,someNumber) values(1,8);");
//删除表
my_DataBase.execSQL("DROP TABLE test");