Android数据持久化篇

一.文件操作篇

主要通过流来完成

　　得到输出流对象FileOutputStream：通过Context的openFileOuput("文件名"，模式)方法获取

　　　　文件路径：/data/data/<包名>/files/  存放在这个目录下
　　　　模式有二：Activity.MODE_PRIVATE覆盖；Activity.MODE_APPEND——追加

　　得到输入流对象FileInputStream:通过Context的openFileInput("文件名"）返回一个输入流对象

　　　　会自动在路径：/data/data/<包名>/files/  下找到要读取的文件名

　　接下来的操作即为java的IO操作技术！

贴入一段小代码

package com.example.filepersistencetest;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;

import android.app.Activity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;

public class MainActivity extends Activity implements OnClickListener {
    private EditText editText;
    private Button sava_button;
    private Button read_button;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        editText = (EditText) findViewById(R.id.edit);
        sava_button = (Button) findViewById(R.id.save);
        read_button = (Button) findViewById(R.id.read);

        // 绑定单击事件
        sava_button.setOnClickListener(this);
        read_button.setOnClickListener(this);

    }

    @Override
    public void onClick(View v) {
        // 监听
        switch (v.getId()) {
        case R.id.save:
            save();
            break;
        case R.id.read:
            read();
            break;

        default:
            break;
        }

    }

    public void save() {
        String inputText = editText.getText().toString();
        BufferedWriter bufw = null;
        FileOutputStream out = null;
        // 得到输出流 Context->openFileOutput("文件名",写出模式——覆盖Private或者追加append)
        // 返回FileOutputStream对象
        try {

            out = openFileOutput("my_data.txt", Activity.MODE_PRIVATE);
            bufw = new BufferedWriter(new OutputStreamWriter(out));
            bufw.write(inputText);
            Log.d("test", inputText);
            bufw.flush();
            editText.setText("");
        } catch (Exception e) {
            throw new RuntimeException("打开文件异常!!");
        } finally {
            try {
                if (null != bufw)
                    bufw.close();
            } catch (Exception e2) {
                throw new RuntimeException("关闭流失败");
            }
        }
    }

    public void read() {
        editText.setText("");
        FileInputStream in = null;
        BufferedReader bur = null;
        try {
            in = openFileInput("my_data.txt");
            bur = new BufferedReader(new InputStreamReader(in));
            String line = null;
            boolean flag = false;
            while ((line = bur.readLine()) != null) {
                if (flag)
                    editText.append("
" + line);//
                else {
                    editText.append(line);
                    flag=true;
                }
            }
        } catch (Exception e) {
            // TODO: handle exception
        } finally {
            try {
                bur.close();
            } catch (Exception e2) {
                // TODO: handle exception
            }
        }

    }

}

 另外补充两点

　　a.TextUtils.isEmpty(inputText)——文本工具类，双重判空
　　b.edit.setSelection(inputText.length())——设置光标到末尾

二.xml存储篇——SharedPreferences

　　文件操作方式有点类似于无脑读，无脑写

　　而SharedPreferences则将数据分类的比较好，可以做到存什么类型就读什么类型，以键值对的方式存储

　　通常映射关系简单的时候，用SharedPreferences是比较合适的

　　存储路径：/data/data/<packagename>/shared_prefs/目录下
　　A.获取SharedPreferences，三种方法
　　a.Context 的 getSharedPreferences("文件名",模式)——如果指定的文件不存在，则会自动创建
　　　　MODE_PRIVATE(=0,默认，只有当前应用程序可以访问)
　　　　MODE_MULTI_PROCESS,用于多个进程多同一个SharedPreferences进行访问
　　b.Activity 的 getPreferences(模式) 会自动将当前活动的类名作为SharedPreferences文件名
　　c.PreferenceManager 的 静态getDefaultSharedPreferences(Context)——自动使用当前应用程序名称作为文件名的前缀
　　B.写
　　a.获得编辑器 通过SharedPreferences对象的edit()方法获取一个SharedPreferences.Editor对象
　　b.通过编辑器写数据 putBoolean putString ==
　　c.提交 commit()

代码示例：

        saveButton.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                // Context获取SharedPreferences对象，创建编辑器
                SharedPreferences.Editor editor = getSharedPreferences("data", MODE_PRIVATE).edit();
                // put内容
                editor.putString("name", "二哥");
                editor.putInt("age", 22);
                editor.putBoolean("married", false);
                // 提交
                editor.commit();
            }
        });

        getButton.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                SharedPreferences pref = getSharedPreferences("data", MODE_PRIVATE);
                String name = pref.getString("name", "null");
                int age = pref.getInt("age", 0);
                boolean married = pref.getBoolean("married", false);
                
                Toast.makeText(MainActivity.this, name+"::"+age+"::"+married, Toast.LENGTH_LONG).show();
            }
        });

记住密码功能实现——参看BroadcastBestPractice

a.定义一个控制器ActivityController管理所有的活动:包括增加，移除活动和销毁所有活动，通过一个List承载

package com.example.broadcastbestpractic;

import java.util.ArrayList;
import java.util.List;

import android.app.Activity;

/**
 * 活动控制器
 * 1.添加活动
 * 2.删除活动
 * 3.销毁所有活动
 */
public class ActivityController {
    public static List<Activity> activities = new ArrayList<Activity>();
    public static void addActivity(Activity activity ){
        activities.add(activity);
    }
    public static void removeActivity(Activity activity ){
        
        activities.remove(activity);
    }
    public static void finishAll(){
        for(Activity activity:activities){
            activity.finish();
        }
    }
}

b.定义一个基类继承Activity，改类的onCreate和onDestory方法分别实现增加和移除活动

package com.example.broadcastbestpractic;

import android.app.Activity;
import android.os.Bundle;

public class BaseActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        // TODO Auto-generated method stub
        super.onCreate(savedInstanceState);
        ActivityController.addActivity(this);
    }

    @Override
    protected void onDestroy() {
        // TODO Auto-generated method stub
        super.onDestroy();
        ActivityController.removeActivity(this);
    }
    
}

c.主界面MainActivity，具有Button，用于发送强制下线广播

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingBottom="@dimen/activity_vertical_margin"
    android:paddingLeft="@dimen/activity_horizontal_margin"
    android:paddingRight="@dimen/activity_horizontal_margin"
    android:paddingTop="@dimen/activity_vertical_margin"
    tools:context="com.example.broadcastbestpractic.MainActivity" >

    <Button 
        android:id="@+id/force_offline"
        android:layout_width="match_parent"
        android:layout_height="wrap_content"
        android:text="Send a force offline broadcast"
        android:gravity="center"
        />

</RelativeLayout>

package com.example.broadcastbestpractic;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;


public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        Button offLine_btn = (Button) findViewById(R.id.force_offline);
        offLine_btn.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                // 发送轻质下线广播                
                Intent intent = new Intent("com.example.broadcastbestpractic.FORCE_OFFLINE");
                
                sendBroadcast(intent);
                
            }
        });
    }

}

d.登录界面LoginActivity，登录成功则跳转至主界面

<?xml version="1.0" encoding="utf-8"?>
<TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:stretchColumns="1"
     >
    
    <TableRow >
        <TextView
            android:layout_height="wrap_content"
            android:text="Account:"
             />
        <EditText
            android:id="@+id/account"
            android:layout_height="wrap_content"
            android:hint="admin 123456"
             />
    </TableRow>
    
    <TableRow >
        <TextView
            android:layout_height="wrap_content"
            android:text="Password:"
             />
        <EditText
            android:id="@+id/password"
            android:layout_height="wrap_content"
            android:inputType="textPassword"
             />
    </TableRow>
    <TableRow >
        <CheckBox 
            android:id="@+id/remember_pass"
            android:layout_height="wrap_content"
            android:layout_gravity="right"
            android:layout_marginRight="10dp"
            />
        <TextView
            android:layout_height="wrap_content"
            android:layout_gravity="center_vertical"
            android:text="Remenbered password"
             />
    </TableRow>
    <TableRow >
        <Button 
            android:id="@+id/login"
            android:text="login"
            android:layout_span="2"
            />
        
    </TableRow>

</TableLayout>

package com.example.broadcastbestpractic;

import android.content.Intent;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.CheckBox;
import android.widget.EditText;
import android.widget.Toast;

public class LoginActivity extends BaseActivity {
    private EditText accoutnEdit;
    private EditText passwordEdit;
    private Button loginButton;
    private CheckBox rememberBox;


    private SharedPreferences pref;
    private SharedPreferences.Editor editor;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        
        setContentView(R.layout.login);
        
        loginButton = (Button) findViewById(R.id.login);
        accoutnEdit = (EditText) findViewById(R.id.account);
        passwordEdit = (EditText) findViewById(R.id.password);
        rememberBox = (CheckBox) findViewById(R.id.remember_pass);
        
        /* 在登录界面创建的时候，先读取xml文件，看复选框的值是否为true
         * 如果为true，复选框状态改为true，账号密码的内容设置为xml文件的账号密码
         * 不为true，则不管
         */
        // 获取checkbox的值
        pref = getSharedPreferences("data", MODE_PRIVATE);
        Boolean isRemember = pref.getBoolean("isRemember", false);
        
        if(isRemember){
            accoutnEdit.setText(pref.getString("account", ""));
            passwordEdit.setText(pref.getString("password", ""));
            
            // 注意设置选中的语句为 setChecked(true)
            rememberBox.setChecked(true);
        }
        
        loginButton.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                // 验证成功则跳转至主界面，失败者提示账号密码不正确
                if("admin".equals(accoutnEdit.getText().toString())&&"123456".equals(passwordEdit.getText().toString())){
                    // 记录账号
                    editor = getSharedPreferences("data", MODE_PRIVATE).edit();
                    // 如果选中，则上传
                    if(rememberBox.isChecked()){ 
                        editor.putBoolean("isRemember", true);
                        editor.putString("account", "admin");
                        editor.putString("password", "123456");
                        
                    }else {
                        // 如果未选中，则清除，如果不清除，依然会记住密码
                        // 可用的方案二是，如果不清除，可以吧isRemember这个值设置为false，就不用大范围清空数据
                        editor.clear();
                    }
                    editor.commit();
                    
                    Intent intent = new Intent(LoginActivity.this,MainActivity.class);
                    
                    startActivity(intent);
                }else {
                    Toast.makeText(LoginActivity.this, "account or password is not corret", Toast.LENGTH_SHORT).show();
                }
                
            }
        });
    }
}

e.静态广播接收器，用于接收强制下线广播，收到后销毁所有活动，弹出AlertDialog，提示重新登录

package com.example.broadcastbestpractic;

import android.app.AlertDialog;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.DialogInterface.OnClickListener;
import android.content.Intent;
import android.view.WindowManager;
/**
 * 
 * 静态注册一个广播接收器，用于销毁活动和开启活动
 */
public class OfflineReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(final Context context, Intent intent) {
        // 销毁活动
        ActivityController.finishAll();
        // 弹出对话框
        AlertDialog.Builder alerBuilder = new AlertDialog.Builder(context);
        alerBuilder.setTitle("Warnning!");
        alerBuilder.setMessage("You are forced line , plese try to login agin.");
        alerBuilder.setCancelable(false);
        alerBuilder.setPositiveButton("OK", new OnClickListener() {
            
            @Override
            public void onClick(DialogInterface dialog, int which) {
                // 销毁所有活动
                ActivityController.finishAll();
                // 重启登录
                Intent intent = new Intent(context, LoginActivity.class);
                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                context.startActivity(intent);
            }
        });
        
        AlertDialog dialog = alerBuilder.create();
        
        // dialog 创建好了，必须要让其显示,并且屏蔽home键
        dialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);
        dialog.show();
        

    }

}

f.Manifest注册，LoginActivity(入口),MainActivity(主界面),静态广播

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.broadcastbestpractic"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="14"
        android:targetSdkVersion="19" />

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

    <application
        android:allowBackup="true"
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name=".LoginActivity"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity android:name=".MainActivity" >
        </activity>
        <receiver android:name="com.example.broadcastbestpractic.OfflineReceiver">
            <intent-filter >
                <action android:name="com.example.broadcastbestpractic.FORCE_OFFLINE"/>
            </intent-filter>
        </receiver>
    </application>

</manifest>

注意：

　　a.Receiver中弹出对话框的步骤以及需要的权限
　　b.Manifest中要声明权限 android.permission.SYSTEM_ALERT_WINDOW，因为需要对话框一直存活直到点击重新ok重新登录

三.sqlite数据库篇

首先得知道的事情：

1.当数据映射复杂的时候，必然会用到数据库

2.Android内置轻量级数据库sqlite，路径在/system/xbin/sqlite3

3.程序中创建的数据库地址：/data/data/<包名>/databases/目录下

4.用实现抽象类SQLiteOpenHelper的子类对象XXX来创建和升级数据库

5.用XXX.getReadableDatabase()或XXX.getWritableDatabase()获取SQLiteDatabase对象YYY

6.通过YYY进行数据的增删改查

补充下cmd下sqlite测试操作

C:Usersjoho>adb shell

 $ su

 # cd /data/data/com.example.databasetest/databases

 # sqlite3 BookStore.db

 sqlite>.table

 sqlite>.schema

 sqlite>select * from Book;

 sqlite>.quit

 ... 

1.创建数据库

23.sqLiteOpenHelper = new MyDatabaseHelper(this, "BookStore.db", null, 1);
38.sqLiteOpenHelper.getWritableDatabase();

2.增

        addDataButton.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                // SQLiteOpenHelper的getWritableDatabase和getReadableDatab会返回一个SQLiteDatabase对象
                SQLiteDatabase db = sqLiteOpenHelper.getWritableDatabase();
//                public long insert(String table, String nullColumnHack, ContentValues values)
                ContentValues values = new ContentValues();
                values.put("author", "erge");
                values.put("price", "88.8");
                values.put("pages", "1");
                values.put("name", "程序员的自我修养");
                db.insert("Book", null, values);// 插入一条数据
                
                values.clear();  // 准备插入第二条
                values.put("author", "erge");
                values.put("price", "888.8");
                values.put("pages", "2");
                values.put("name", "程序员的未来");
                db.insert("Book", null, values); //插入第二条
                
            }
        });

3.改

        updateButton.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                SQLiteDatabase db = sqLiteOpenHelper.getWritableDatabase();
//                 public int update(String table, ContentValues values, String whereClause, String[] whereArgs)
//                (表名，值，where，where的值)
                ContentValues values = new ContentValues();
                values.put("name", "the self_improvement of developer");
                db.update("Book", values, "name = ?", new String[]{"程序员的自我修养"});
                
                values.clear();
                values.put("name", "the future of developer");
                db.update("Book", values, "name = ?", new String[]{"程序员的未来"});
                Toast.makeText(MainActivity.this, "update sucess", Toast.LENGTH_SHORT).show();
            }
        });

4.删

        deleteButton.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                // 
                SQLiteDatabase db = sqLiteOpenHelper.getWritableDatabase();
//                public int delete(String table, String whereClause, String[] whereArgs)
                db.delete("Book", "pages > ?", new String[]{"1"});
            }
        });

5.查

        // 查询最为复杂，参数较多，得到的结果保存在游标——Cursor对象中
        queryButton.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                SQLiteDatabase db = sqLiteOpenHelper.getWritableDatabase();
//                public Cursor query(String table, String[] columns, String selection,String[] selectionArgs, String groupBy, String having,String orderBy) 
                //columns用于约束查询哪几列，不指定则查全部
                //selection，selectionArgs用来约束查询哪些行，不指定则全部；
                //groupBy指定需要group by的列，不指定则对结果进行group by处理;
                //having用于对之前group by的数据进一步过滤，不指定则不过滤；orderBy对结果进行排序，不指定则默认排序
                
                // 遍历得结果会存储到一个Course对象中，通过遍历这个对象，来输出数据
                Cursor cursor = db.query("Book",null,null,null,null,null,null);
                if(cursor.moveToFirst()){
                    do {
                        String author = cursor.getString(cursor.getColumnIndex("author"));
                        Double price = cursor.getDouble(cursor.getColumnIndex("price"));
                        int pages = cursor.getInt(cursor.getColumnIndex("pages"));
                        String name = cursor.getString(cursor.getColumnIndex("name"));
                        Log.d("test", "name::"+name);
                        Log.d("test", "pages::"+pages);
                        Log.d("test", "price::"+price);
                        Log.d("test", "author::"+author);
                    } while (cursor.moveToNext());
                }
                cursor.close();
            }
        });

DatabaseTest代码

主布局

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical" >

    <Button 
        android:id="@+id/create"
        android:layout_height="wrap_content"
        android:layout_width="match_parent"
        android:text="create database BookStore.db"
        />

    <Button 
        android:id="@+id/add_data"
        android:layout_height="wrap_content"
        android:layout_width="match_parent"
        android:text="Add data"
        />
    <Button 
        android:id="@+id/update_data"
        android:layout_height="wrap_content"
        android:layout_width="match_parent"
        android:text="Update data"
        />
    <Button 
        android:id="@+id/delete_data"
        android:layout_height="wrap_content"
        android:layout_width="match_parent"
        android:text="Delete data"
        />
    <Button 
        android:id="@+id/query_data"
        android:layout_height="wrap_content"
        android:layout_width="match_parent"
        android:text="Query data"
        />
    <Button 
        android:id="@+id/replace_data"
        android:layout_height="wrap_content"
        android:layout_width="match_parent"
        android:text="use transaction to replace Book"
        />
    
    <Button 
        android:id="@+id/upgrade_one"
        android:layout_height="wrap_content"
        android:layout_width="match_parent"
        android:text="upgrade database one"
        />
    <Button 
        android:id="@+id/upgrade_two"
        android:layout_height="wrap_content"
        android:layout_width="match_parent"
        android:text="upgrade database two"
        />
</LinearLayout>

定义MyDatabaseHelper继承SQLiteOpenHelper

特别注意升级数据库的写法！！

package com.example.databasetest;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteDatabase.CursorFactory;
import android.database.sqlite.SQLiteOpenHelper;
import android.widget.Toast;
/**
 * 
 * 注意 id 设为主键时 primary key 两个词，分开的
 */
public class MyDatabaseHelper extends SQLiteOpenHelper {
    public static final String CREATE_BOOK =
            "create table Book(" +
            "id integer primary key autoincrement," +
            "author text, " +
            "price real," +
            "pages integer," +
            "name text)";
    public static final String CREATE_CATEGORY="create table Category(" +
            "id integer primary key autoincrement," +
            "category_name text," +
            "category_code integer)";
    private Context mContext;//为什么需要？获取SQLiteOpenHelper实例的时候，会传入context，为了在这个context中进行操作
//  构造方法(contex , 数据库名 , 光标？ ， 版本号)
    public MyDatabaseHelper(Context context, String name,
            CursorFactory factory, int version) {
        super(context, name, factory, version);
        mContext = context;
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        // 创建数据库的时候创建一张表
        db.execSQL(CREATE_BOOK);
        //db.execSQL(CREATE_CATEGORY);
        Toast.makeText(mContext, "create table sussessed", Toast.LENGTH_SHORT).show();
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        // 更新数据库——感觉这种方法很糟糕，如果存在则删除，数据不要了？？
        /*
        db.execSQL("drop table if exists Category");
        db.execSQL("drop table if exists Book");
        onCreate(db);
        */
        
        // 最佳写法——当然第二版创建时就会创建category表，第三版创建时就会增加id
        // 只有低版本升级是才会执行到下面的语句，另外特别注意：
        // 这里并没有写break语句，是为了保证夸版本升级可以执行到所有语句——感觉还能改造，事务之类的
        switch (oldVersion) {
        //升级至第二版时，会多创建一个category表
        case 1:
            db.execSQL(CREATE_CATEGORY);
        //升级至第三版时，Book表会新建一列 category_id
        case 2:
            db.execSQL("alter table Book add column category_id integer");
        default:
        }
        
    }

}

主入口

package com.example.databasetest;

import android.app.Activity;
import android.content.ContentValues;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.Toast;


public class MainActivity extends Activity {
    private SQLiteOpenHelper sqLiteOpenHelper;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        // 得到SQLiteOpentHelper的实例
        sqLiteOpenHelper = new MyDatabaseHelper(this, "BookStore.db", null, 1);
        Button createDatabaseButton = (Button) findViewById(R.id.create);
        Button addDataButton = (Button) findViewById(R.id.add_data);
        Button updateButton = (Button) findViewById(R.id.update_data);
        Button deleteButton = (Button) findViewById(R.id.delete_data);
        Button queryButton = (Button) findViewById(R.id.query_data);
        Button replaceButton = (Button) findViewById(R.id.replace_data);
        Button upgrade_One_Button = (Button) findViewById(R.id.upgrade_one);
        Button upgrade_Two_Button = (Button) findViewById(R.id.upgrade_two);
        
        createDatabaseButton.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                // 没有则会创建数据库，有则不创建
                sqLiteOpenHelper.getWritableDatabase();
            }
        });
        

        addDataButton.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                // SQLiteOpenHelper的getWritableDatabase和getReadableDatab会返回一个SQLiteDatabase对象
                SQLiteDatabase db = sqLiteOpenHelper.getWritableDatabase();
//                public long insert(String table, String nullColumnHack, ContentValues values)
                ContentValues values = new ContentValues();
                values.put("author", "erge");
                values.put("price", "88.8");
                values.put("pages", "1");
                values.put("name", "程序员的自我修养");
                db.insert("Book", null, values);// 插入一条数据
                
                values.clear();  // 准备插入第二条
                values.put("author", "erge");
                values.put("price", "888.8");
                values.put("pages", "2");
                values.put("name", "程序员的未来");
                db.insert("Book", null, values); //插入第二条
                
            }
        });
        
        updateButton.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                SQLiteDatabase db = sqLiteOpenHelper.getWritableDatabase();
//                 public int update(String table, ContentValues values, String whereClause, String[] whereArgs)
//                (表名，值，where，where的值)
                ContentValues values = new ContentValues();
                values.put("name", "the self_improvement of developer");
                db.update("Book", values, "name = ?", new String[]{"程序员的自我修养"});
                
                values.clear();
                values.put("name", "the future of developer");
                db.update("Book", values, "name = ?", new String[]{"程序员的未来"});
                Toast.makeText(MainActivity.this, "update sucess", Toast.LENGTH_SHORT).show();
            }
        });
        
        deleteButton.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                // 
                SQLiteDatabase db = sqLiteOpenHelper.getWritableDatabase();
//                public int delete(String table, String whereClause, String[] whereArgs)
                db.delete("Book", "pages > ?", new String[]{"1"});
            }
        });
        
        // 查询最为复杂，参数较多
        queryButton.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                SQLiteDatabase db = sqLiteOpenHelper.getWritableDatabase();
//                public Cursor query(String table, String[] columns, String selection,String[] selectionArgs, String groupBy, String having,String orderBy) 
                //columns用于约束查询哪几列，不指定则查全部
                //selection，selectionArgs用来约束查询哪些行，不指定则全部；
                //groupBy指定需要group by的列，不指定则对结果进行group by处理;
                //having用于对之前group by的数据进一步过滤，不指定则不过滤；orderBy对结果进行排序，不指定则默认排序
                
                // 遍历得结果会存储到一个Course对象中，通过遍历这个对象，来输出数据
                Cursor cursor = db.query("Book",null,null,null,null,null,null);
                if(cursor.moveToFirst()){
                    do {
                        String author = cursor.getString(cursor.getColumnIndex("author"));
                        Double price = cursor.getDouble(cursor.getColumnIndex("price"));
                        int pages = cursor.getInt(cursor.getColumnIndex("pages"));
                        String name = cursor.getString(cursor.getColumnIndex("name"));
                        Log.d("test", "name::"+name);
                        Log.d("test", "pages::"+pages);
                        Log.d("test", "price::"+price);
                        Log.d("test", "author::"+author);
                    } while (cursor.moveToNext());
                }
                cursor.close();
            }
        });
        
        replaceButton.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                SQLiteDatabase db = sqLiteOpenHelper.getWritableDatabase();
                db.beginTransaction();
                try {
                    // 删除原来的表
                    db.delete("Book", null, null);
                    
                    // 中断测试
                    if(true){
                        throw new RuntimeException("...");
                    }
                    // 重新添加数据
                    ContentValues values = new ContentValues();
                    values.put("author", "nima");
                    values.put("price", 25.5);
                    values.put("pages", 88);
                    values.put("name", "zhiqinchun");
                    
                    db.insert("Book", null, values);
                    db.setTransactionSuccessful();
                } catch (Exception e) {
                    // TODO: handle exception
                }finally{
                    db.endTransaction();
                }
            }
        });
        
        upgrade_One_Button.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                // 这里数据库版本应该搞个变量控制一下，不然升级就只能升级一次  ，后面指定的版本号比之前的大的话，就会调用onUpgrade方法
                sqLiteOpenHelper = new MyDatabaseHelper(MainActivity.this, "BookStore.db", null, 2);
                sqLiteOpenHelper.getWritableDatabase();
                
            }
        });
        upgrade_Two_Button.setOnClickListener(new OnClickListener() {
            
            @Override
            public void onClick(View v) {
                // 这里数据库版本应该搞个变量控制一下，不然升级就只能升级一次  ，后面指定的版本号比之前的大的话，就会调用onUpgrade方法
                sqLiteOpenHelper = new MyDatabaseHelper(MainActivity.this, "BookStore.db", null, 3);
                sqLiteOpenHelper.getWritableDatabase();
                
            }
        });
        
    }

}