Android数据存储几种方式用法总结

1、概述

　　Android提供了5种方式来让用户保存持久化应用程序数据。根据自己的需求来做选择，比如数据是否是应用程序私有的，是否能被其他程序访问，需要多少数据存储空间等，分别是：　
　　
①　使用SharedPreferences存储数据　

②　文件存储数据

③　 SQLite数据库存储数据

④　使用ContentProvider存储数据

⑤　网络存储数据　

Android提供了一种方式来暴露你的数据（甚至是私有数据）给其他应用程序 - ContentProvider。它是一个可选组件，可公开读写你应用程序数据。

第一种：使用SharedPreferences存储数据

适用范围：保存少量的数据，且这些数据的格式非常简单：字符串型、基本类型的值。比如应用程序的各种配置信息（如是否打开音效、是否使用震动效果、小游戏的玩家积分等），解锁口令密码等

核心原理：保存基于XML文件存储的key-value键值对数据，通常用来存储一些简单的配置信息。通过DDMS的File Explorer面板，展开文件浏览树,很明显SharedPreferences数据总是存储在/data/data/<package name>/shared_prefs目录下。SharedPreferences对象本身只能获取数据而不支持存储和修改,存储修改是通过SharedPreferences.edit()获取的内部接口Editor对象实现。 SharedPreferences本身是一个接口，程序无法直接创建SharedPreferences实例，只能通过Context提供的getSharedPreferences(String name, int mode)方法来获取SharedPreferences实例，该方法中name表示要操作的xml文件名，第二个参数具体如下：

Context.MODE_PRIVATE: 指定该SharedPreferences数据只能被本应用程序读、写。

Context.MODE_WORLD_READABLE: 指定该SharedPreferences数据能被其他应用程序读，但不能写。

Context.MODE_WORLD_WRITEABLE: 指定该SharedPreferences数据能被其他应用程序读，写

Editor有如下主要重要方法：

SharedPreferences.Editor clear():清空SharedPreferences里所有数据

SharedPreferences.Editor putXxx(String key , xxx value): 向SharedPreferences存入指定key对应的数据，其中xxx 可以是boolean,float,int等各种基本类型据

SharedPreferences.Editor remove(): 删除SharedPreferences中指定key对应的数据项

boolean commit(): 当Editor编辑完成后，使用该方法提交修改

实际案例：运行界面如下

这里只提供了两个按钮和一个输入文本框，布局简单，故在此不给出界面布局文件了,程序核心代码如下：

class ViewOcl implements View.OnClickListener{@Overridepublic void onClick(View v) {switch(v.getId()){case R.id.btnSet://步骤1：获取输入值String code = txtCode.getText().toString().trim();//步骤2-1：创建一个SharedPreferences.Editor接口对象，lock表示要写入的XML文件名，MODE_WORLD_WRITEABLE写操作SharedPreferences.Editor editor = getSharedPreferences("lock", MODE_WORLD_WRITEABLE).edit();//步骤2-2：将获取过来的值放入文件editor.putString("code", code);//步骤3：提交
                editor.commit();Toast.makeText(getApplicationContext(), "口令设置成功", Toast.LENGTH_LONG).show();break;case R.id.btnGet://步骤1：创建一个SharedPreferences接口对象SharedPreferences read = getSharedPreferences("lock", MODE_WORLD_READABLE);//步骤2：获取文件中的值String value = read.getString("code", "");Toast.makeText(getApplicationContext(), "口令为："+value, Toast.LENGTH_LONG).show();break;}}}

读写其他应用的SharedPreferences: 步骤如下

1、在创建SharedPreferences时，指定MODE_WORLD_READABLE模式，表明该SharedPreferences数据可以被其他程序读取

2、创建其他应用程序对应的Context:

Context pvCount = createPackageContext("com.tony.app", Context.CONTEXT_IGNORE_SECURITY);这里的com.tony.app就是其他程序的包名

3、使用其他程序的Context获取对应的SharedPreferences

SharedPreferences read = pvCount.getSharedPreferences("lock", Context.MODE_WORLD_READABLE);

4、如果是写入数据，使用Editor接口即可，所有其他操作均和前面一致。

SharedPreferences对象与SQLite数据库相比，免去了创建数据库，创建表，写SQL语句等诸多操作，相对而言更加方便，简洁。但是SharedPreferences也有其自身缺陷，比如其职能存储boolean，int，float，long和String五种简单的数据类型，比如其无法进行条件查询等。所以不论SharedPreferences的数据存储操作是如何简单，它也只能是存储方式的一种补充，而无法完全替代如SQLite数据库这样的其他数据存储方式。

第二种：文件存储数据

核心原理: Context提供了两个方法来打开数据文件里的文件IO流 FileInputStream openFileInput(String name); FileOutputStream(String name , int mode),这两个方法第一个参数用于指定文件名，第二个参数指定打开文件的模式。具体有以下值可选：

MODE_PRIVATE：为默认操作模式，代表该文件是私有数据，只能被应用本身访问，在该模式下，写入的内容会覆盖原文件的内容，如果想把新写入的内容追加到原文件中。可以使用Context.MODE_APPEND

MODE_APPEND：模式会检查文件是否存在，存在就往文件追加内容，否则就创建新文件。

MODE_WORLD_READABLE：表示当前文件可以被其他应用读取；

MODE_WORLD_WRITEABLE：表示当前文件可以被其他应用写入。

除此之外，Context还提供了如下几个重要的方法：

getDir(String name , int mode):在应用程序的数据文件夹下获取或者创建name对应的子目录

File getFilesDir():获取该应用程序的数据文件夹得绝对路径

String[] fileList():返回该应用数据文件夹的全部文件

实际案例：界面沿用上图

核心代码如下：

public String read() {try {FileInputStream inStream = this.openFileInput("message.txt");byte[] buffer = new byte[1024];int hasRead = 0;StringBuilder sb = new StringBuilder();while ((hasRead = inStream.read(buffer)) != -1) {sb.append(new String(buffer, 0, hasRead));}inStream.close();return sb.toString();} catch (Exception e) {e.printStackTrace();} return null;}public void write(String msg){// 步骤1：获取输入值if(msg == null) return;try {// 步骤2:创建一个FileOutputStream对象,MODE_APPEND追加模式FileOutputStream fos = openFileOutput("message.txt",MODE_APPEND);// 步骤3：将获取过来的值放入文件
            fos.write(msg.getBytes());// 步骤4：关闭数据流
            fos.close();} catch (Exception e) {e.printStackTrace();}}

openFileOutput()方法的第一参数用于指定文件名称，不能包含路径分隔符“/” ，如果文件不存在，Android 会自动创建它。创建的文件保存在/data/data/<package name>/files目录，如： /data/data/cn.tony.app/files/message.txt，

下面讲解某些特殊文件读写需要注意的地方:

读写sdcard上的文件

其中读写步骤按如下进行:

1、调用Environment的getExternalStorageState()方法判断手机上是否插了sd卡,且应用程序具有读写SD卡的权限，如下代码将返回true

Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)

2、调用Environment.getExternalStorageDirectory()方法来获取外部存储器，也就是SD卡的目录,或者使用"/mnt/sdcard/"目录

3、使用IO流操作SD卡上的文件

注意点：手机应该已插入SD卡，对于模拟器而言，可通过mksdcard命令来创建虚拟存储卡

必须在AndroidManifest.xml上配置读写SD卡的权限

<uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

案例代码：

// 文件写操作函数private void write(String content) {if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) { // 如果sdcard存在File file = new File(Environment.getExternalStorageDirectory().toString()+ File.separator+ DIR+ File.separator+ FILENAME); // 定义File类对象if (!file.getParentFile().exists()) { // 父文件夹不存在file.getParentFile().mkdirs(); // 创建文件夹
            }PrintStream out = null; // 打印流对象用于输出try {out = new PrintStream(new FileOutputStream(file, true)); // 追加文件
                out.println(content);} catch (Exception e) {e.printStackTrace();} finally {if (out != null) {out.close(); // 关闭打印流
                }}} else { // SDCard不存在，使用Toast提示用户Toast.makeText(this, "保存失败，SD卡不存在！", Toast.LENGTH_LONG).show();}}// 文件读操作函数private String read() {if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) { // 如果sdcard存在File file = new File(Environment.getExternalStorageDirectory().toString()+ File.separator+ DIR+ File.separator+ FILENAME); // 定义File类对象if (!file.getParentFile().exists()) { // 父文件夹不存在file.getParentFile().mkdirs(); // 创建文件夹
            }Scanner scan = null; // 扫描输入StringBuilder sb = new StringBuilder();try {scan = new Scanner(new FileInputStream(file)); // 实例化Scannerwhile (scan.hasNext()) { // 循环读取sb.append(scan.next() + "\n"); // 设置文本
                }return sb.toString();} catch (Exception e) {e.printStackTrace();} finally {if (scan != null) {scan.close(); // 关闭打印流
                }}} else { // SDCard不存在，使用Toast提示用户Toast.makeText(this, "读取失败，SD卡不存在！", Toast.LENGTH_LONG).show();}return null;}

2.1 使用内部存储

　　当文件被保存在内部存储中时，默认情况下，文件是应用程序私有的，其他应用不能访问。当用户卸载应用程序时这些文件也跟着被删除。

　　文件默认存储位置：/data/data/包名/files/文件名。

2.1.1 创建和写入一个内部存储的私有文件：

①　调用Context的openFileOutput()函数，填入文件名和操作模式，它会返回一个FileOutputStream对象。

②　通过FileOutputStream对象的write()函数写入数据。

③　 FileOutputStream对象的close ()函数关闭流。

例如：

        String FILENAME = "a.txt";String string = "fanrunqi";try {FileOutputStream fos = openFileOutput(FILENAME, Context.MODE_PRIVATE);fos.write(string.getBytes());fos.close();} catch (Exception e) {e.printStackTrace();}

在 openFileOutput(String name, int mode)方法中

name参数:　用于指定文件名称，不能包含路径分隔符“/” ，如果文件不存在，Android 会自动创建它。
mode参数：用于指定操作模式，分为四种：

Context.MODE_PRIVATE = 0

　　为默认操作模式，代表该文件是私有数据，只能被应用本身访问，在该模式下，写入的内容会覆盖原文件的内容。

Context.MODE_APPEND = 32768

　　该模式会检查文件是否存在，存在就往文件追加内容，否则就创建新文件。　

Context.MODE_WORLD_READABLE = 1

　　表示当前文件可以被其他应用读取。

MODE_WORLD_WRITEABLE

　　表示当前文件可以被其他应用写入。

2.1.2 读取一个内部存储的私有文件：

① 调用openFileInput( )，参数中填入文件名，会返回一个FileInputStream对象。

② 使用流对象的 read()方法读取字节

③ 调用流的close()方法关闭流

例如：

    String FILENAME = "a.txt";try {FileInputStream inStream = openFileInput(FILENAME);int len = 0;byte[] buf = new byte[1024];StringBuilder sb = new StringBuilder();while ((len = inStream.read(buf)) != -1) {sb.append(new String(buf, 0, len));}inStream.close();} catch (Exception e) {e.printStackTrace();}

其他一些经常用到的方法：

getFilesDir()：　得到内存储文件的绝对路径
getDir()：　在内存储空间中创建或打开一个已经存在的目录
deleteFile()：　删除保存在内部存储的文件。　　
fileList()：　返回当前由应用程序保存的文件的数组（内存储目录下的全部文件）。

3.1.３　保存编译时的静态文件

　　如果你想在应用编译时保存静态文件，应该把文件保存在项目的　res/raw/　目录下，你可以通过 openRawResource()方法去打开它（传入参数R.raw.filename），这个方法返回一个 InputStream流对象你可以读取文件但是不能修改原始文件。

InputStream is = this.getResources().openRawResource(R.raw.filename);

3.1.４　保存内存缓存文件

　　有时候我们只想缓存一些数据而不是持久化保存，可以使用getCacheDir（）去打开一个文件，文件的存储目录（ /data/data/包名/cache ）是一个应用专门来保存临时缓存文件的内存目录。

　　当设备的内部存储空间比较低的时候，Android可能会删除这些缓存文件来恢复空间，但是你不应该依赖系统来回收，要自己维护这些缓存文件把它们的大小限制在一个合理的范围内，比如1ＭＢ．当你卸载应用的时候这些缓存文件也会被移除。

2.２使用外部存储（sdcard）

　　因为内部存储容量限制，有时候需要存储数据比较大的时候需要用到外部存储，使用外部存储分为以下几个步骤：

2.2.1　添加外部存储访问限权

　
　　首先，要在AndroidManifest.xml中加入访问SDCard的权限，如下:

　<!-- 在SDCard中创建与删除文件权限 --> <uses-permission android:name="android.permission.MOUNT_UNMOUNT_FILESYSTEMS"/> <!-- 往SDCard写入数据权限 --> <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>

2.2.２　检测外部存储的可用性

　　在使用外部存储时我们需要检测其状态，它可能被连接到计算机、丢失或者只读等。下面代码将说明如何检查状态：

//获取外存储的状态
String state = Environment.getExternalStorageState();
if (Environment.MEDIA_MOUNTED.equals(state)) {// 可读可写mExternalStorageAvailable = mExternalStorageWriteable = true;
} else if (Environment.MEDIA_MOUNTED_READ_ONLY.equals(state)) {// 可读
} else {// 可能有很多其他的状态，但是我们只需要知道，不能读也不能写
}

2.2.3　访问外部存储器中的文件

１、如果 API 版本大于或等于８，使用

getExternalFilesDir (String type)

　　该方法打开一个外存储目录，此方法需要一个类型，指定你想要的子目录，如类型参数DIRECTORY_MUSIC和 DIRECTORY_RINGTONES（传null就是你应用程序的文件目录的根目录）。通过指定目录的类型，确保Android的媒体扫描仪将扫描分类系统中的文件（例如，铃声被确定为铃声）。如果用户卸载应用程序，这个目录及其所有内容将被删除。

例如：

File file = new File(getExternalFilesDir(null), "fanrunqi.jpg");

２、如果API 版本小于 8 （7或者更低）

getExternalStorageDirectory ()

通过该方法打开外存储的根目录，你应该在以下目录下写入你的应用数据，这样当卸载应用程序时该目录及其所有内容也将被删除。

/Android/data/<package_name>/files/

读写数据：

if(Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)){  File sdCardDir = Environment.getExternalStorageDirectory();//获取SDCard目录  "/sdcard"        File saveFile = new File(sdCardDir,"a.txt"); //写数据try {FileOutputStream fos= new FileOutputStream(saveFile); fos.write("fanrunqi".getBytes()); fos.close();} catch (Exception e) {e.printStackTrace();} //读数据try {FileInputStream fis= new FileInputStream(saveFile); int len =0;byte[] buf = new byte[1024];StringBuffer sb = new StringBuffer();while((len=fis.read(buf))!=-1){sb.append(new String(buf, 0, len));}fis.close();} catch (Exception e) {e.printStackTrace();}  }

　　我们也可以在　/Android/data/package_name/cache/目录下做外部缓存。

部分翻译于：android-data-storage

第三种：SQLite存储数据

SQLite是轻量级嵌入式数据库引擎，它支持 SQL 语言，并且只利用很少的内存就有很好的性能。现在的主流移动设备像Android、iPhone等都使用SQLite作为复杂数据的存储引擎，在我们为移动设备开发应用程序时，也许就要使用到SQLite来存储我们大量的数据，所以我们就需要掌握移动设备上的SQLite开发技巧

SQLiteDatabase类为我们提供了很多种方法，上面的代码中基本上囊括了大部分的数据库操作；对于添加、更新和删除来说，我们都可以使用

1 db.executeSQL(String sql);
2 db.executeSQL(String sql, Object[] bindArgs);//sql语句中使用占位符，然后第二个参数是实际的参数集

除了统一的形式之外，他们还有各自的操作方法：

1 db.insert(String table, String nullColumnHack, ContentValues values);
2 db.update(String table, Contentvalues values, String whereClause, String whereArgs);
3 db.delete(String table, String whereClause, String whereArgs);

以上三个方法的第一个参数都是表示要操作的表名；insert中的第二个参数表示如果插入的数据每一列都为空的话，需要指定此行中某一列的名称，系统将此列设置为NULL，不至于出现错误；insert中的第三个参数是ContentValues类型的变量，是键值对组成的Map，key代表列名，value代表该列要插入的值；update的第二个参数也很类似，只不过它是更新该字段key为最新的value值，第三个参数whereClause表示WHERE表达式，比如“age > ? and age < ?”等，最后的whereArgs参数是占位符的实际参数值；delete方法的参数也是一样

下面给出demo

数据的添加

1.使用insert方法

1 ContentValues cv = new ContentValues();//实例化一个ContentValues用来装载待插入的数据
2 cv.put("title","you are beautiful");//添加title
3 cv.put("weather","sun"); //添加weather
4 cv.put("context","xxxx"); //添加context
5 String publish = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
6                         .format(new Date());
7 cv.put("publish ",publish); //添加publish
8 db.insert("diary",null,cv);//执行插入操作

2.使用execSQL方式来实现

String sql = "insert into user(username,password) values ('Jack Johnson','iLovePopMuisc');//插入操作的SQL语句
db.execSQL(sql);//执行SQL语句

数据的删除

同样有2种方式可以实现

String whereClause = "username=?";//删除的条件
String[] whereArgs = {"Jack Johnson"};//删除的条件参数
db.delete("user",whereClause,whereArgs);//执行删除

使用execSQL方式的实现

String sql = "delete from user where username='Jack Johnson'";//删除操作的SQL语句
db.execSQL(sql);//执行删除操作

数据修改

同上，仍是2种方式

ContentValues cv = new ContentValues();//实例化ContentValues
cv.put("password","iHatePopMusic");//添加要更改的字段及内容
String whereClause = "username=?";//修改条件
String[] whereArgs = {"Jack Johnson"};//修改条件的参数
db.update("user",cv,whereClause,whereArgs);//执行修改

使用execSQL方式的实现

String sql = "update user set password = 'iHatePopMusic' where username='Jack Johnson'";//修改的SQL语句
db.execSQL(sql);//执行修改

数据查询

下面来说说查询操作。查询操作相对于上面的几种操作要复杂些，因为我们经常要面对着各种各样的查询条件，所以系统也考虑到这种复杂性，为我们提供了较为丰富的查询形式：

1 db.rawQuery(String sql, String[] selectionArgs);
2 db.query(String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy);
3 db.query(String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit);
4 db.query(String distinct, String table, String[] columns, String selection, String[] selectionArgs, String groupBy, String having, String orderBy, String limit);

上面几种都是常用的查询方法，第一种最为简单，将所有的SQL语句都组织到一个字符串中，使用占位符代替实际参数，selectionArgs就是占位符实际参数集；

各参数说明：

table：表名称
colums：表示要查询的列所有名称集
selection：表示WHERE之后的条件语句，可以使用占位符
selectionArgs：条件语句的参数数组
groupBy：指定分组的列名
having：指定分组条件,配合groupBy使用
orderBy：y指定排序的列名
limit：指定分页参数
distinct：指定“true”或“false”表示要不要过滤重复值
Cursor：返回值，相当于结果集ResultSet

最后，他们同时返回一个Cursor对象，代表数据集的游标，有点类似于JavaSE中的ResultSet。下面是Cursor对象的常用方法：

 1 c.move(int offset); //以当前位置为参考,移动到指定行
 2 c.moveToFirst();    //移动到第一行
 3 c.moveToLast();     //移动到最后一行
 4 c.moveToPosition(int position); //移动到指定行
 5 c.moveToPrevious(); //移动到前一行
 6 c.moveToNext();     //移动到下一行
 7 c.isFirst();        //是否指向第一条
 8 c.isLast();     //是否指向最后一条
 9 c.isBeforeFirst();  //是否指向第一条之前
10 c.isAfterLast();    //是否指向最后一条之后
11 c.isNull(int columnIndex);  //指定列是否为空(列基数为0)
12 c.isClosed();       //游标是否已关闭
13 c.getCount();       //总数据项数
14 c.getPosition();    //返回当前游标所指向的行数
15 c.getColumnIndex(String columnName);//返回某列名对应的列索引值
16 c.getString(int columnIndex);   //返回当前行指定列的值

实现代码

String[] params =  {12345,123456};Cursor cursor = db.query("user",columns,"ID=?",params,null,null,null);//查询并获得游标
if(cursor.moveToFirst()){//判断游标是否为空for(int i=0;i<cursor.getCount();i++){cursor.move(i);//移动到指定记录String username = cursor.getString(cursor.getColumnIndex("username");String password = cursor.getString(cursor.getColumnIndex("password"));}
}

通过rawQuery实现的带参数查询

Cursor result=db.rawQuery("SELECT ID, name, inventory FROM mytable");
//Cursor c = db.rawQuery("s name, inventory FROM mytable where ID=?",new Stirng[]{"123456"});
result.moveToFirst();
while (!result.isAfterLast()) { int id=result.getInt(0); String name=result.getString(1); int inventory=result.getInt(2); // do something useful with these
    result.moveToNext(); } result.close();

在上面的代码示例中，已经用到了这几个常用方法中的一些，关于更多的信息，大家可以参考官方文档中的说明。

最后当我们完成了对数据库的操作后，记得调用SQLiteDatabase的close()方法释放数据库连接，否则容易出现SQLiteException。

上面就是SQLite的基本应用，但在实际开发中，为了能够更好的管理和维护数据库，我们会封装一个继承自SQLiteOpenHelper类的数据库操作类，然后以这个类为基础，再封装我们的业务逻辑方法。

这里直接使用案例讲解：下面是案例demo的界面

SQLiteOpenHelper类介绍

SQLiteOpenHelper是SQLiteDatabase的一个帮助类，用来管理数据库的创建和版本的更新。一般是建立一个类继承它，并实现它的onCreate和onUpgrade方法。

方法名	方法描述
SQLiteOpenHelper(Context context,String name,SQLiteDatabase.CursorFactory factory,int version)	构造方法，其中 context 程序上下文环境即：XXXActivity.this; name :数据库名字; factory:游标工厂，默认为null,即为使用默认工厂; version 数据库版本号
onCreate(SQLiteDatabase db)	创建数据库时调用
onUpgrade(SQLiteDatabase db,int oldVersion , int newVersion)	版本更新时调用
getReadableDatabase()	创建或打开一个只读数据库
getWritableDatabase()	创建或打开一个读写数据库

首先创建数据库类

 1 import android.content.Context;
 2 import android.database.sqlite.SQLiteDatabase;
 3 import android.database.sqlite.SQLiteDatabase.CursorFactory;
 4 import android.database.sqlite.SQLiteOpenHelper;
 5
 6 public class SqliteDBHelper extends SQLiteOpenHelper {
 7
 8     // 步骤1：设置常数参量
 9     private static final String DATABASE_NAME = "diary_db";
10     private static final int VERSION = 1;
11     private static final String TABLE_NAME = "diary";
12
13     // 步骤2：重载构造方法
14     public SqliteDBHelper(Context context) {
15         super(context, DATABASE_NAME, null, VERSION);
16     }
17
18     /*
19      * 参数介绍：context 程序上下文环境 即：XXXActivity.this
20      * name 数据库名字
21      * factory 接收数据，一般情况为null
22      * version 数据库版本号
23      */
24     public SqliteDBHelper(Context context, String name, CursorFactory factory,
25             int version) {
26         super(context, name, factory, version);
27     }
28     //数据库第一次被创建时，onCreate()会被调用
29     @Override
30     public void onCreate(SQLiteDatabase db) {
31         // 步骤3：数据库表的创建
32         String strSQL = "create table "
33                 + TABLE_NAME
34                 + "(tid integer primary key autoincrement,title varchar(20),weather varchar(10),context text,publish date)";
35         //步骤4：使用参数db,创建对象
36         db.execSQL(strSQL);
37     }
38     //数据库版本变化时，会调用onUpgrade()
39     @Override
40     public void onUpgrade(SQLiteDatabase arg0, int arg1, int arg2) {
41
42     }
43 }

正如上面所述，数据库第一次创建时onCreate方法会被调用，我们可以执行创建表的语句，当系统发现版本变化之后，会调用onUpgrade方法，我们可以执行修改表结构等语句。

我们需要一个Dao，来封装我们所有的业务方法，代码如下：

 1 import android.content.Context;
 2 import android.database.Cursor;
 3 import android.database.sqlite.SQLiteDatabase;
 4
 5 import com.chinasoft.dbhelper.SqliteDBHelper;
 6
 7 public class DiaryDao {
 8
 9     private SqliteDBHelper sqliteDBHelper;
10     private SQLiteDatabase db;
11
12     // 重写构造方法
13     public DiaryDao(Context context) {
14         this.sqliteDBHelper = new SqliteDBHelper(context);
15         db = sqliteDBHelper.getWritableDatabase();
16     }
17
18     // 读操作
19     public String execQuery(final String strSQL) {
20         try {
21             System.out.println("strSQL>" + strSQL);
22             // Cursor相当于JDBC中的ResultSet
23             Cursor cursor = db.rawQuery(strSQL, null);
24             // 始终让cursor指向数据库表的第1行记录
25             cursor.moveToFirst();
26             // 定义一个StringBuffer的对象，用于动态拼接字符串
27             StringBuffer sb = new StringBuffer();
28             // 循环游标，如果不是最后一项记录
29             while (!cursor.isAfterLast()) {
30                 sb.append(cursor.getInt(0) + "/" + cursor.getString(1) + "/"
31                         + cursor.getString(2) + "/" + cursor.getString(3) + "/"
32                         + cursor.getString(4)+"#");
33                 //cursor游标移动
34                 cursor.moveToNext();
35             }
36             db.close();
37             return sb.deleteCharAt(sb.length()-1).toString();
38         } catch (RuntimeException e) {
39             e.printStackTrace();
40             return null;
41         }
42
43     }
44
45     // 写操作
46     public boolean execOther(final String strSQL) {
47         db.beginTransaction();  //开始事务
48         try {
49             System.out.println("strSQL" + strSQL);
50             db.execSQL(strSQL);
51             db.setTransactionSuccessful();  //设置事务成功完成
52             db.close();
53             return true;
54         } catch (RuntimeException e) {
55             e.printStackTrace();
56             return false;
57         }finally {
58             db.endTransaction();    //结束事务
59         }
60
61     }
62 }

我们在Dao构造方法中实例化sqliteDBHelper并获取一个SQLiteDatabase对象，作为整个应用的数据库实例；在增删改信息时，我们采用了事务处理，确保数据完整性；最后要注意释放数据库资源db.close()，这一个步骤在我们整个应用关闭时执行，这个环节容易被忘记，所以朋友们要注意。

我们获取数据库实例时使用了getWritableDatabase()方法，也许朋友们会有疑问，在getWritableDatabase()和getReadableDatabase()中，你为什么选择前者作为整个应用的数据库实例呢？在这里我想和大家着重分析一下这一点。

我们来看一下SQLiteOpenHelper中的getReadableDatabase()方法：

 1 public synchronized SQLiteDatabase getReadableDatabase() {
 2     if (mDatabase != null && mDatabase.isOpen()) {
 3         // 如果发现mDatabase不为空并且已经打开则直接返回
 4         return mDatabase;
 5     }
 6
 7     if (mIsInitializing) {
 8         // 如果正在初始化则抛出异常
 9         throw new IllegalStateException("getReadableDatabase called recursively");
10     }
11
12     // 开始实例化数据库mDatabase
13
14     try {
15         // 注意这里是调用了getWritableDatabase()方法
16         return getWritableDatabase();
17     } catch (SQLiteException e) {
18         if (mName == null)
19             throw e; // Can't open a temp database read-only!
20         Log.e(TAG, "Couldn't open " + mName + " for writing (will try read-only):", e);
21     }
22
23     // 如果无法以可读写模式打开数据库 则以只读方式打开
24
25     SQLiteDatabase db = null;
26     try {
27         mIsInitializing = true;
28         String path = mContext.getDatabasePath(mName).getPath();// 获取数据库路径
29         // 以只读方式打开数据库
30         db = SQLiteDatabase.openDatabase(path, mFactory, SQLiteDatabase.OPEN_READONLY);
31         if (db.getVersion() != mNewVersion) {
32             throw new SQLiteException("Can't upgrade read-only database from version " + db.getVersion() + " to "
33                     + mNewVersion + ": " + path);
34         }
35
36         onOpen(db);
37         Log.w(TAG, "Opened " + mName + " in read-only mode");
38         mDatabase = db;// 为mDatabase指定新打开的数据库
39         return mDatabase;// 返回打开的数据库
40     } finally {
41         mIsInitializing = false;
42         if (db != null && db != mDatabase)
43             db.close();
44     }
45 }

在getReadableDatabase()方法中，首先判断是否已存在数据库实例并且是打开状态，如果是，则直接返回该实例，否则试图获取一个可读写模式的数据库实例，如果遇到磁盘空间已满等情况获取失败的话，再以只读模式打开数据库，获取数据库实例并返回，然后为mDatabase赋值为最新打开的数据库实例。既然有可能调用到getWritableDatabase()方法，我们就要看一下了：

public synchronized SQLiteDatabase getWritableDatabase() {  if (mDatabase != null && mDatabase.isOpen() && !mDatabase.isReadOnly()) {  // 如果mDatabase不为空已打开并且不是只读模式 则返回该实例  return mDatabase;  }  if (mIsInitializing) {  throw new IllegalStateException("getWritableDatabase called recursively");  }  // If we have a read-only database open, someone could be using it  // (though they shouldn't), which would cause a lock to be held on  // the file, and our attempts to open the database read-write would  // fail waiting for the file lock. To prevent that, we acquire the  // lock on the read-only database, which shuts out other users.  boolean success = false;  SQLiteDatabase db = null;  // 如果mDatabase不为空则加锁 阻止其他的操作  if (mDatabase != null)  mDatabase.lock();  try {  mIsInitializing = true;  if (mName == null) {  db = SQLiteDatabase.create(null);  } else {  // 打开或创建数据库  db = mContext.openOrCreateDatabase(mName, 0, mFactory);  }  // 获取数据库版本(如果刚创建的数据库,版本为0)  int version = db.getVersion();  // 比较版本(我们代码中的版本mNewVersion为1)  if (version != mNewVersion) {  db.beginTransaction();// 开始事务  try {  if (version == 0) {  // 执行我们的onCreate方法
                    onCreate(db);  } else {  // 如果我们应用升级了mNewVersion为2,而原版本为1则执行onUpgrade方法
                    onUpgrade(db, version, mNewVersion);  }  db.setVersion(mNewVersion);// 设置最新版本  db.setTransactionSuccessful();// 设置事务成功  } finally {  db.endTransaction();// 结束事务
            }  }  onOpen(db);  success = true;  return db;// 返回可读写模式的数据库实例  } finally {  mIsInitializing = false;  if (success) {  // 打开成功  if (mDatabase != null) {  // 如果mDatabase有值则先关闭  try {  mDatabase.close();  } catch (Exception e) {  }  mDatabase.unlock();// 解锁
            }  mDatabase = db;// 赋值给mDatabase  } else {  // 打开失败的情况：解锁、关闭  if (mDatabase != null)  mDatabase.unlock();  if (db != null)  db.close();  }  }
}

大家可以看到，几个关键步骤是，首先判断mDatabase如果不为空已打开并不是只读模式则直接返回，否则如果mDatabase不为空则加锁，然后开始打开或创建数据库，比较版本，根据版本号来调用相应的方法，为数据库设置新版本号，最后释放旧的不为空的mDatabase并解锁，把新打开的数据库实例赋予mDatabase，并返回最新实例。

看完上面的过程之后，大家或许就清楚了许多，如果不是在遇到磁盘空间已满等情况，getReadableDatabase()一般都会返回和getWritableDatabase()一样的数据库实例，所以我们在DBManager构造方法中使用getWritableDatabase()获取整个应用所使用的数据库实例是可行的。当然如果你真的担心这种情况会发生，那么你可以先用getWritableDatabase()获取数据实例，如果遇到异常，再试图用getReadableDatabase()获取实例，当然这个时候你获取的实例只能读不能写了

最后，让我们看一下如何使用这些数据操作方法来显示数据,界面核心逻辑代码:

public class SQLiteActivity extends Activity {public DiaryDao diaryDao;//因为getWritableDatabase内部调用了mContext.openOrCreateDatabase(mName, 0, mFactory);  //所以要确保context已初始化,我们可以把实例化Dao的步骤放在Activity的onCreate里
    @Overrideprotected void onCreate(Bundle savedInstanceState) {diaryDao = new DiaryDao(SQLiteActivity.this);initDatabase();}class ViewOcl implements View.OnClickListener {@Overridepublic void onClick(View v) {String strSQL;boolean flag;String message;switch (v.getId()) {case R.id.btnAdd:String title = txtTitle.getText().toString().trim();String weather = txtWeather.getText().toString().trim();;String context = txtContext.getText().toString().trim();;String publish = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());// 动态组件SQL语句strSQL = "insert into diary values(null,'" + title + "','"+ weather + "','" + context + "','" + publish + "')";flag = diaryDao.execOther(strSQL);//返回信息message = flag?"添加成功":"添加失败";Toast.makeText(getApplicationContext(), message, Toast.LENGTH_LONG).show();break;case R.id.btnDelete:strSQL = "delete from diary where tid = 1";flag = diaryDao.execOther(strSQL);//返回信息message = flag?"删除成功":"删除失败";Toast.makeText(getApplicationContext(), message, Toast.LENGTH_LONG).show();break;case R.id.btnQuery:strSQL = "select * from diary order by publish desc";String data = diaryDao.execQuery(strSQL);Toast.makeText(getApplicationContext(), data, Toast.LENGTH_LONG).show();break;case R.id.btnUpdate:strSQL = "update diary set title = '测试标题1-1' where tid = 1";flag = diaryDao.execOther(strSQL);//返回信息message = flag?"更新成功":"更新失败";Toast.makeText(getApplicationContext(), message, Toast.LENGTH_LONG).show();break;}}}private void initDatabase() {// 创建数据库对象SqliteDBHelper sqliteDBHelper = new SqliteDBHelper(SQLiteActivity.this);sqliteDBHelper.getWritableDatabase();System.out.println("数据库创建成功");}
}

Android sqlite3数据库管理工具

Android SDK的tools目录下提供了一个sqlite3.exe工具，这是一个简单的sqlite数据库管理工具。开发者可以方便的使用其对sqlite数据库进行命令行的操作。

程序运行生成的*.db文件一般位于"/data/data/项目名(包括所处包名)/databases/*.db"，因此要对数据库文件进行操作需要先找到数据库文件：

1、进入shell 命令

adb shell

2、找到数据库文件

#cd data/data
#ls                --列出所有项目
#cd project_name   --进入所需项目名
#cd databases
#ls                --列出现寸的数据库文件

3、进入数据库

#sqlite3 test_db   --进入所需数据库

会出现类似如下字样：

SQLite version 3.6.22
Enter ".help" for instructions
Enter SQL statements terminated with a ";"
sqlite>

至此，可对数据库进行sql操作。

4、sqlite常用命令

>.databases        --产看当前数据库
>.tables           --查看当前数据库中的表
>.help             --sqlite3帮助
>.schema            --各个表的生成语句

4、使用ContentProvider存储数据

1.ContentProvider是什么？

　　ContentProvider（内容提供者）是Android的四大组件之一，管理android以结构化方式存放的数据，以相对安全的方式封装数据（表）并且提供简易的处理机制和统一的访问接口供其他程序调用。　
　　
　　Android的数据存储方式总共有五种，分别是：Shared Preferences、网络存储、文件存储、外储存储、SQLite。但一般这些存储都只是在单独的一个应用程序之中达到一个数据的共享，有时候我们需要操作其他应用程序的一些数据，就会用到ContentProvider。而且Android为常见的一些数据提供了默认的ContentProvider（包括音频、视频、图片和通讯录等）。

　　但注意ContentProvider它也只是一个中间人，真正操作的数据源可能是数据库，也可以是文件、xml或网络等其他存储方式。

２.URL

　　URL（统一资源标识符）代表要操作的数据，可以用来标识每个ContentProvider，这样你就可以通过指定的URI找到想要的ContentProvider,从中获取或修改数据。
　　在Android中URI的格式如下图所示：

Ａ
　
　　　schema，已经由Android所规定为：content://．　
　　　
Ｂ

　　　主机名（Authority），是URI的授权部分，是唯一标识符，用来定位ContentProvider。

Ｃ部分和D部分：是每个ContentProvider内部的路径部分

Ｃ

　　　指向一个对象集合，一般用表的名字，如果没有指定D部分，则返回全部记录。
Ｄ

　　　指向特定的记录，这里表示操作user表id为7的记录。如果要操作user表中id为7的记录的name字段， D部分变为 /7/name即可。

URI模式匹配通配符

*：匹配的任意长度的任何有效字符的字符串。

＃：匹配的任意长度的数字字符的字符串。

如：

content://com.example.app.provider/*
匹配provider的任何内容url

content://com.example.app.provider/table3/#
匹配table3的所有行

2.１MIME

　　MIME是指定某个扩展名的文件用一种应用程序来打开，就像你用浏览器查看PDF格式的文件，浏览器会选择合适的应用来打开一样。Android中的工作方式跟HTTP类似，ContentProvider会根据URI来返回MIME类型，ContentProvider会返回一个包含两部分的字符串。MIME类型一般包含两部分，如：

text/html
text/css
text/xml
application/pdf

　　分为类型和子类型，Android遵循类似的约定来定义MIME类型，每个内容类型的Android MIME类型有两种形式：多条记录（集合）和单条记录。

　　集合记录：

vnd.android.cursor.dir/自定义

　　单条记录：

vnd.android.cursor.item/自定义

　　vnd表示这些类型和子类型具有非标准的、供应商特定的形式。Android中类型已经固定好了，不能更改，只能区别是集合还是单条具体记录，子类型可以按照格式自己填写。
　　在使用Intent时，会用到MIME，根据Mimetype打开符合条件的活动。

　　下面分别介绍Android系统提供了两个用于操作Uri的工具类：ContentUris和UriMatcher。

2.２ ContentUris

　　ContetnUris包含一个便利的函数withAppendedId()来向URI追加一个id。

Uri uri = Uri.parse("content://cn.scu.myprovider/user")
Uri resultUri = ContentUris.withAppendedId(uri, 7); //生成后的Uri为：content://cn.scu.myprovider/user/7

　　同时提供parseId(uri)方法用于从URL中获取ID:

Uri uri = Uri.parse("content://cn.scu.myprovider/user/7")
long personid = ContentUris.parseId(uri);
//获取的结果为:7

2.３UriMatcher

　　UriMatcher本质上是一个文本过滤器，用在contentProvider中帮助我们过滤，分辨出查询者想要查询哪个数据表。

　　举例说明：

第一步，初始化：

UriMatcher matcher = new UriMatcher(UriMatcher.NO_MATCH);
//常量UriMatcher.NO_MATCH表示不匹配任何路径的返回码

第二步，注册需要的Uri：

//USER 和 USER_ID是两个int型数据
matcher.addURI("cn.scu.myprovider", "user", USER);
matcher.addURI("cn.scu.myprovider", "user/#",USER_ID);
//如果match()方法匹配content://cn.scu.myprovider/user路径，返回匹配码为USER

第三部，与已经注册的Uri进行匹配:

/* * 如果操作集合，则必须以vnd.android.cursor.dir开头 * 如果操作非集合，则必须以vnd.android.cursor.item开头 * */  @Override  public String getType(Uri uri) {  Uri uri = Uri.parse("content://" + "cn.scu.myprovider" + "/user");  switch(matcher.match(uri)){  case USER:  return "vnd.android.cursor.dir/user";  case USER_ID:  return "vnd.android.cursor.item/user";  }  }

3.ContentProvider的主要方法

public boolean onCreate()

　　ContentProvider创建后　或　打开系统后其它应用第一次访问该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类型。

４.ContentResolver

　　ContentResolver通过URI来查询ContentProvider中提供的数据。除了URI以外，还必须知道需要获取的数据段的名称，以及此数据段的数据类型。如果你需要获取一个特定的记录，你就必须知道当前记录的ID，也就是URI中D部分。

　　ContentResolver 类提供了与ContentProvider类相同签名的四个方法：

public Uri insert(Uri uri, ContentValues values)　//添加

public int delete(Uri uri, String selection, String[] selectionArgs)　//删除

public int update(Uri uri, ContentValues values, String selection, String[] selectionArgs)　//更新

public Cursor query(Uri uri, String[] projection, String selection, String[] selectionArgs, String sortOrder)//获取

实例代码：

ContentResolver resolver =  getContentResolver();
Uri uri = Uri.parse("content://cn.scu.myprovider/user");//添加一条记录
ContentValues values = new ContentValues();
values.put("name", "fanrunqi");
values.put("age", 24);
resolver.insert(uri, values);  //获取user表中所有记录
Cursor cursor = resolver.query(uri, null, null, null, "userid desc");
while(cursor.moveToNext()){//操作
}//把id为1的记录的name字段值更改新为finch
ContentValues updateValues = new ContentValues();
updateValues.put("name", "finch");
Uri updateIdUri = ContentUris.withAppendedId(uri, 1);
resolver.update(updateIdUri, updateValues, null, null);//删除id为2的记录
Uri deleteIdUri = ContentUris.withAppendedId(uri, 2);
resolver.delete(deleteIdUri, null, null);

5.ContentObserver

　　　 ContentObserver(内容观察者)，目的是观察特定Uri引起的数据库的变化，继而做一些相应的处理，它类似于数据库技术中的触发器(Trigger)，当ContentObserver所观察的Uri发生变化时，便会触发它.

下面是使用内容观察者监听短信的例子：

public class MainActivity extends Activity {@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(R.layout.activity_main);//注册观察者Observser
this.getContentResolver().registerContentObserver(Uri.parse("content://sms"),true,new SMSObserver(new Handler()));}private final class SMSObserver extends ContentObserver {public SMSObserver(Handler handler) {super(handler);}@Overridepublic void onChange(boolean selfChange) {Cursor cursor = MainActivity.this.getContentResolver().query(
Uri.parse("content://sms/inbox"), null, null, null, null);while (cursor.moveToNext()) {StringBuilder sb = new StringBuilder();sb.append("address=").append(cursor.getString(cursor.getColumnIndex("address")));sb.append(";subject=").append(cursor.getString(cursor.getColumnIndex("subject")));sb.append(";body=").append(cursor.getString(cursor.getColumnIndex("body")));sb.append(";time=").append(cursor.getLong(cursor.getColumnIndex("date")));System.out.println("--------has Receivered SMS::" + sb.toString());}}}
}

同时可以在ContentProvider发生数据变化时调用
getContentResolver().notifyChange(uri, null)来通知注册在此URI上的访问者。

public class UserContentProvider extends ContentProvider {public Uri insert(Uri uri, ContentValues values) {db.insert("user", "userid", values);getContext().getContentResolver().notifyChange(uri, null);}
}

6.实例说明

　　数据源是SQLite, 用ContentResolver操作ContentProvider。

Constant.java（储存一些常量）

public class Constant {  public static final String TABLE_NAME = "user";  public static final String COLUMN_ID = "_id";  public static final String COLUMN_NAME = "name";  public static final String AUTOHORITY = "cn.scu.myprovider";  public static final int ITEM = 1;  public static final int ITEM_ID = 2;  public static final String CONTENT_TYPE = "vnd.android.cursor.dir/user";  public static final String CONTENT_ITEM_TYPE = "vnd.android.cursor.item/user";  public static final Uri CONTENT_URI = Uri.parse("content://" + AUTOHORITY + "/user");
}

DBHelper.java(操作数据库)

public class DBHelper extends SQLiteOpenHelper {  private static final String DATABASE_NAME = "finch.db";    private static final int DATABASE_VERSION = 1;    public DBHelper(Context context) {  super(context, DATABASE_NAME, null, DATABASE_VERSION);  }  @Override  public void onCreate(SQLiteDatabase db)  throws SQLException {  //创建表格  db.execSQL("CREATE TABLE IF NOT EXISTS "+ Constant.TABLE_NAME + "("+ Constant.COLUMN_ID +" INTEGER PRIMARY KEY AUTOINCREMENT," + Constant.COLUMN_NAME +" VARCHAR NOT NULL);");  }  @Override  public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion)  throws SQLException {  //删除并创建表格  db.execSQL("DROP TABLE IF EXISTS "+ Constant.TABLE_NAME+";");  onCreate(db);  }
}

　MyProvider.java(自定义的ContentProvider)　

public class MyProvider extends ContentProvider {    DBHelper mDbHelper = null;    SQLiteDatabase db = null;    private static final UriMatcher mMatcher;    static{    mMatcher = new UriMatcher(UriMatcher.NO_MATCH);    mMatcher.addURI(Constant.AUTOHORITY,Constant.TABLE_NAME, Constant.ITEM);    mMatcher.addURI(Constant.AUTOHORITY, Constant.TABLE_NAME+"/#", Constant.ITEM_ID);    }    @Override    public String getType(Uri uri) {    switch (mMatcher.match(uri)) {    case Constant.ITEM:    return Constant.CONTENT_TYPE;    case Constant.ITEM_ID:    return Constant.CONTENT_ITEM_TYPE;    default:    throw new IllegalArgumentException("Unknown URI"+uri);    }    }    @Override    public Uri insert(Uri uri, ContentValues values) {    // TODO Auto-generated method stub    long rowId;    if(mMatcher.match(uri)!=Constant.ITEM){    throw new IllegalArgumentException("Unknown URI"+uri);    }    rowId = db.insert(Constant.TABLE_NAME,null,values);    if(rowId>0){    Uri noteUri=ContentUris.withAppendedId(Constant.CONTENT_URI, rowId);    getContext().getContentResolver().notifyChange(noteUri, null);    return noteUri;    }    throw new SQLException("Failed to insert row into " + uri);    }    @Override    public boolean onCreate() {    // TODO Auto-generated method stub    mDbHelper = new DBHelper(getContext());    db = mDbHelper.getReadableDatabase();    return true;    }    @Override    public Cursor query(Uri uri, String[] projection, String selection,    String[] selectionArgs, String sortOrder) {    // TODO Auto-generated method stub    Cursor c = null;    switch (mMatcher.match(uri)) {    case Constant.ITEM:    c =  db.query(Constant.TABLE_NAME, projection, selection, selectionArgs, null, null, sortOrder);    break;    case Constant.ITEM_ID:    c = db.query(Constant.TABLE_NAME, projection,Constant.COLUMN_ID + "="+uri.getLastPathSegment(), selectionArgs, null, null, sortOrder);    break;    default:    throw new IllegalArgumentException("Unknown URI"+uri);    }    c.setNotificationUri(getContext().getContentResolver(), uri);    return c;    }    @Override    public int update(Uri uri, ContentValues values, String selection,    String[] selectionArgs) {    // TODO Auto-generated method stub    return 0;    }@Overridepublic int delete(Uri uri, String selection, String[] selectionArgs) {// TODO Auto-generated method stubreturn 0;}    }

MainActivity.java(ContentResolver操作)

public class MainActivity extends Activity {private ContentResolver mContentResolver = null; private Cursor cursor = null;  @Overrideprotected void onCreate(Bundle savedInstanceState) {// TODO Auto-generated method stubsuper.onCreate(savedInstanceState);setContentView(R.layout.activity_main);TextView tv = (TextView) findViewById(R.id.tv);mContentResolver = getContentResolver();  tv.setText("添加初始数据 ");for (int i = 0; i < 10; i++) {  ContentValues values = new ContentValues();  values.put(Constant.COLUMN_NAME, "fanrunqi"+i);  mContentResolver.insert(Constant.CONTENT_URI, values);  } tv.setText("查询数据 ");cursor = mContentResolver.query(Constant.CONTENT_URI, new String[]{Constant.COLUMN_ID,Constant.COLUMN_NAME}, null, null, null);  if (cursor.moveToFirst()) {String s = cursor.getString(cursor.getColumnIndex(Constant.COLUMN_NAME));tv.setText("第一个数据： "+s);}}}

最后在manifest申明

<provider android:name="MyProvider" android:authorities="cn.scu.myprovider" />

5、网络存储数据

HttpUrlConnection

　　HttpUrlConnection是Java.net包中提供的API，我们知道Android SDK是基于Java的，所以当然优先考虑HttpUrlConnection这种最原始最基本的API，其实大多数开源的联网框架基本上也是基于JDK的HttpUrlConnection进行的封装罢了，掌握HttpUrlConnection需要以下几个步骤：
　　
1、将访问的路径转换成URL。

URL url = new URL(path);

2、通过URL获取连接。

HttpURLConnection conn = (HttpURLConnection) url.openConnection();

3、设置请求方式。

conn.setRequestMethod(GET);

4、设置连接超时时间。

conn.setConnectTimeout(5000);

5、设置请求头的信息。

conn.setRequestProperty(User-Agent, Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0));

7、针对不同的响应码，做不同的操作（请求码200，表明请求成功，获取返回内容的输入流）

工具类：

public class StreamTools {/*** 将输入流转换成字符串* * @param is*            从网络获取的输入流* @return*/public static String streamToString(InputStream is) {try {ByteArrayOutputStream baos = new ByteArrayOutputStream();byte[] buffer = new byte[1024];int len = 0;while ((len = is.read(buffer)) != -1) {baos.write(buffer, 0, len);}baos.close();is.close();byte[] byteArray = baos.toByteArray();return new String(byteArray);} catch (Exception e) {Log.e(tag, e.toString());return null;}}
}

HttpUrlConnection发送GET请求

public static String loginByGet(String username, String password) {String path = http://192.168.0.107:8080/WebTest/LoginServerlet?username= + username + &password= + password;try {URL url = new URL(path);HttpURLConnection conn = (HttpURLConnection) url.openConnection();conn.setConnectTimeout(5000);conn.setRequestMethod(GET);int code = conn.getResponseCode();if (code == 200) {InputStream is = conn.getInputStream(); // 字节流转换成字符串return StreamTools.streamToString(is);} else {return 网络访问失败;}} catch (Exception e) {e.printStackTrace();return 网络访问失败;}}

HttpUrlConnection发送POST请求

public static String loginByPost(String username, String password) {String path = http://192.168.0.107:8080/WebTest/LoginServerlet;try {URL url = new URL(path);HttpURLConnection conn = (HttpURLConnection) url.openConnection();conn.setConnectTimeout(5000);conn.setRequestMethod(POST);conn.setRequestProperty(Content-Type, application/x-www-form-urlencoded);String data = username= + username + &password= + password;conn.setRequestProperty(Content-Length, data.length() + );// POST方式，其实就是浏览器把数据写给服务器conn.setDoOutput(true); // 设置可输出流OutputStream os = conn.getOutputStream(); // 获取输出流os.write(data.getBytes()); // 将数据写给服务器int code = conn.getResponseCode();if (code == 200) {InputStream is = conn.getInputStream();return StreamTools.streamToString(is);} else {return 网络访问失败;}} catch (Exception e) {e.printStackTrace();return 网络访问失败;}}

HttpClient

　　HttpClient是开源组织Apache提供的Java请求网络框架，其最早是为了方便Java服务器开发而诞生的，是对JDK中的HttpUrlConnection各API进行了封装和简化，提高了性能并且降低了调用API的繁琐，Android因此也引进了这个联网框架，我们再不需要导入任何jar或者类库就可以直接使用，值得注意的是Android官方已经宣布不建议使用HttpClient了。

HttpClient发送GET请求

1、创建HttpClient对象

2、创建HttpGet对象，指定请求地址（带参数）

3、使用HttpClient的execute(),方法执行HttpGet请求，得到HttpResponse对象

4、调用HttpResponse的getStatusLine().getStatusCode()方法得到响应码

5、调用的HttpResponse的getEntity().getContent()得到输入流，获取服务端写回的数据

public static String loginByHttpClientGet(String username, String password) {String path = http://192.168.0.107:8080/WebTest/LoginServerlet?username=+ username + &password= + password;HttpClient client = new DefaultHttpClient(); // 开启网络访问客户端HttpGet httpGet = new HttpGet(path); // 包装一个GET请求try {HttpResponse response = client.execute(httpGet); // 客户端执行请求int code = response.getStatusLine().getStatusCode(); // 获取响应码if (code == 200) {InputStream is = response.getEntity().getContent(); // 获取实体内容String result = StreamTools.streamToString(is); // 字节流转字符串return result;} else {return 网络访问失败;}} catch (Exception e) {e.printStackTrace();return 网络访问失败;}}

HttpClient发送POST请求

1，创建HttpClient对象

2，创建HttpPost对象，指定请求地址

3，创建List，用来装载参数

4，调用HttpPost对象的setEntity()方法，装入一个UrlEncodedFormEntity对象，携带之前封装好的参数

5，使用HttpClient的execute()方法执行HttpPost请求，得到HttpResponse对象

6，调用HttpResponse的getStatusLine().getStatusCode()方法得到响应码

7，调用的HttpResponse的getEntity().getContent()得到输入流，获取服务端写回的数据

public static String loginByHttpClientPOST(String username, String password) {String path = http://192.168.0.107:8080/WebTest/LoginServerlet;try {HttpClient client = new DefaultHttpClient(); // 建立一个客户端HttpPost httpPost = new HttpPost(path); // 包装POST请求// 设置发送的实体参数List parameters = new ArrayList();parameters.add(new BasicNameValuePair(username, username));parameters.add(new BasicNameValuePair(password, password));httpPost.setEntity(new UrlEncodedFormEntity(parameters, UTF-8));HttpResponse response = client.execute(httpPost); // 执行POST请求int code = response.getStatusLine().getStatusCode();if (code == 200) {InputStream is = response.getEntity().getContent();String result = StreamTools.streamToString(is);return result;} else {return 网络访问失败;}} catch (Exception e) {e.printStackTrace();return 访问网络失败;}}

参考：

　　Android开发请求网络方式详解

Android提供的其他网络访问框架

　　HttpClient和HttpUrlConnection的两种网络访问方式编写网络代码，需要自己考虑很多，获取数据或许可以，但是如果要将手机本地数据上传至网络，根据不同的web端接口，需要组织不同的数据内容上传，给手机端造成了很大的工作量。
　　
　　目前有几种快捷的网络开发开源框架，给我们提供了非常大的便利。下面是这些项目Github地址，有文档和Api说明。
　　
android-async-http　

http-request

okhttp