Android数据库两种操作方式介绍: SQLite与ORMLite

1、关系型数据库SQlite

（1）简介：

SQlite是android内置的轻量级的数据库，它的运算速度非常快，占用资源少，通常只需要几百K的内存就足够。SQLite不仅支持标准的SQL语法，还遵循了数据库的ACID事务（ACID，是指在可靠数据库管理系统（DBMS）中，事务（Transaction）所应该具有的四个特性：原子性（Atomicity）、一致性（Consistency）、隔离性（Isolation）、持久性（Durability））。

（2）使用：

1. 创建SQliteHelper类并extends（继承）SQliteOpenHelper（SQLiteOpenHelper是一个抽象类，意味着我们要使用它的话就需要创建一个类去继承它并实现其中的方法，分别是onCreate( )和onUpgrade( )）
   
   [java]  view plain  copy

   1. <pre name="code" class="java">public class MyDatabaseHelper extends SQLiteOpenHelper {  
   2.     //用于创建Book表  
   3.     public static final String CREATE_BOOK = "create table Book ("  
   4.             + "id integer primary key autoincrement, "  
   5.             + "author text, "  
   6.             + "price real, "  
   7.             + "pages integer, "  
   8.             + "name text, "  
   9.             + "catagory_id integer)";  
   10.     //用于创建Category表  
   11.     public static final String CREATE_CATEGORY = "create table Category ("  
   12.             + "id integer primary key autoincrement, "  
   13.             + "category_name text, "  
   14.             + "category_code integer)";  
   15.     private Context mContext;  
   16.   
   17.     public MyDatabaseHelper(Context context, String name,  
   18.                             SQLiteDatabase.CursorFactory factory, int version) {  
   19.         super(context, name, factory, version);  
   20.         mContext = context;  
   21.     }  
   22.     //第一次创建数据库时会调用此方法  
   23.     @Override  
   24.     public void onCreate(SQLiteDatabase db) {  
   25.         db.execSQL(CREATE_BOOK);  
   26.         db.execSQL(CREATE_CATEGORY);  
   27.     }  
   28.     //数据库版本升级时会调用此方法  
   29.     @Override  
   30.     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {  
   31.         /*第一版的数据库只有Book表，第二版的数据库增加了Category表， 
   32.         * 为了保证用户体验，在不干扰前一版的数据的情况下，实现对数据 
   33.         * 库的平滑升级，简单的可以用此方法进行判断在升级*/  
   34.         switch (oldVersion){  
   35.             case 1:  
   36.                 db.execSQL(CREATE_CATEGORY);  
   37.             case 2:  
   38.                 db.execSQL("alter table Book add column category_id integer");  
   39.             default:  
   40.         }  
   41.     }  
   42. }</pre>  
   43. <pre></pre>  
   44. 在MainActivity中创建MyDatabaseHelper对象并调用<strong>getReadableDatabase( )</strong>或者<strong>getWritableDatabase( )进行数据库的创建</strong> ,(两者不同点在于，当数据库不可写入时（如磁盘空间已满）getReadableDatabase( )方法返回的对象将以只读的方式去打开数据库，而getWritableDatabase( )方法则将出现异常)<br>  
   45. <pre name="code" class="java"></pre><pre name="code" class="java">//数据库文件名称  
   46. private static final String DATABASE_NAME = "BookStore.db";  
   47. //数据库版本号  
   48. private static final int DATABASE_VERSION = 3;  
   49. private MyDatabaseHelper mMyDatabaseHelper;  
   50. mMyDatabaseHelper = new MyDatabaseHelper(this, DATABASE_NAME, null, DATABASE_VERSION);  
   51. mMyDatabaseHelper.getReadableDatabase();</pre>  
2. 对数据库的增删改查
   （1）增：
   
   [java]  view plain  copy

   1. SQLiteDatabase db = mMyDatabaseHelper.getReadableDatabase();  
   2. ContentValues values = new ContentValues();  
   3.   
   4. values.put("name", "The Da Vinci Code");  
   5. values.put("author", "Dan Brown");  
   6. values.put("pages", 454);  
   7. values.put("price", 16.96);  
   8. //向数据库插入数据  
   9. db.insert("Book", null, values);  
   （2）删：
   
   [java]  view plain  copy

   1. //删除数据库的数据  
   2. db.delete("Book", "pages > ?", new String[]{"500"});  
   （3）改
   
   [java]  view plain  copy

   1. <pre name="code" class="java">ContentValues value = new ContentValues();  
   2.   
   3. value.put("price", 10.56);  
   4.   
   5. //更新数据库的数据  
   6. db.update("Book", value, "name=?", new String[]{"The Da Vinci Code"});</pre>  
   7. <pre></pre>  
   8. （4）查（以下是较常见的一种）<br>  
   9. <pre name="code" class="java">//对数据库表进行查询，会返回游标  
   10. Cursor cursor = db.query("Book", null, null, null, null, null, null);  
   11.   
   12. while (cursor.moveToNext()){  
   13.         String name = cursor.getString(cursor.getColumnIndex("name"));  
   14.         String author = cursor.getString(cursor.getColumnIndex("author"));  
   15.         int pages = cursor.getInt(cursor.getColumnIndex("pages"));  
   16.         double price = cursor.getDouble(cursor.getColumnIndex("price"));  
   17. }  
   18. cursor.close();</pre>（5）数据库的事务操作<br>  
   19. <pre name="code" class="java">//开启事务  
   20. db.beginTransaction();  
   21.   
   22. try {  
   23.         db.delete("Book", null, null);  
   24.   
   25.         Toast.makeText(MainActivity.this, 删除数据成功",Toast.LENGTH_SHORT).show();  
   26.   
   27.         /*if (true){ 
   28.             throw new NullPointerException(); 
   29.         }*/  
   30.   
   31.         ContentValues values = new ContentValues();  
   32.   
   33.         values.put("name", "Game of Thrones");  
   34.         values.put("author", "George Martin");  
   35.         values.put("pages", 720);  
   36.         values.put("price", 20.15);  
   37.   
   38.         db.insert("Book", null, values);  
   39.   
   40.         //事务已经执行成功  
   41.         db.setTransactionSuccessful();  
   42.   
   43.         Toast.makeText(MainActivity.this, "插入数据成功", Toast.LENGTH_SHORT).show();  
   44.   
   45. } catch (NullPointerException e) {  
   46.     e.printStackTrace();  
   47. } finally {  
   48.     //结束事务  
   49.     db.endTransaction();  
   50. }</pre>  

2、对象型数据库ORMlite

（1）简介：

ORMLite是一种对象关系映射（Object-Relational Mapping， 简称ORM）工具，可用于读写数据。ORMLite是一个框架，对多数据进行操作更加方便，特别是对于那些对SQL语句不熟悉的人。

（2）使用：

1. [java]  view plain  copy

   1. //数据库框架  
   2. compile "com.j256.ormlite:ormlite-android:4.48"  
   3. compile "com.j256.ormlite:ormlite-core:4.48"  
   或下载ORMlite jar：ormlite-android-4.48.jar 和 ormlite-core-4.48.jar
2. 创建Bean
   User.java
   
   [java]  view plain  copy

   1. /* 
   2. * 当定义表时，第一个建议便是使用final变量定义数据库表名和列名， 
   3. * 该方法可以简化代码的维护工作，不过本例并没使用*/  
   4. @DatabaseTable(tableName = "tb_user") //@DatabaseTable：标明这是数据库的一张表  
   5. public class User {  
   6.     /*@DatabaseField：标明这是表中的字段 
   7.       columnName: 为该字段在数据中的列名 
   8.       generatedId：表示id为自增长*/  
   9.     @DatabaseField(generatedId = true)  
   10.     private int id;  
   11.     @DatabaseField(columnName = "name")  
   12.     private String name;  
   13.     @DatabaseField(columnName = "desc")  
   14.     private String desc;  
   15.   
   16.     /*ORMLite需要用到无参构造方法 
   17.     * 当ORMLite需要创建User类时会使用到无参数的构造方法， 
   18.     * 并通过反射机制设置成员变量，也可以使用setter方法设置成员变量*/  
   19.     public User() {  
   20.     }  
   21.   
   22.     public User(String name, String desc) {  
   23.         this.name = name;  
   24.         this.desc = desc;  
   25.     }  
   26.   
   27.     public int getId() {  
   28.         return id;  
   29.     }  
   30.   
   31.     public void setId(int id) {  
   32.         this.id = id;  
   33.     }  
   34.   
   35.     public String getName() {  
   36.         return name;  
   37.     }  
   38.   
   39.     public void setName(String name) {  
   40.         this.name = name;  
   41.     }  
   42.   
   43.     public String getDesc() {  
   44.         return desc;  
   45.     }  
   46.   
   47.     public void setDesc(String desc) {  
   48.         this.desc = desc;  
   49.     }  
   50. }  
3. 创建数据库
   SQliteHelper需要继承OrmLiteSqliteOpenHelper
   DatabaseHelper.java
4. [java]  view plain  copy

   1. public class DatabaseHelper extends OrmLiteSqliteOpenHelper {  
   2.     //数据库文件的名称  
   3.     private static final String TABLE_NAME = "sqlit-test.db";  
   4.   
   5.     /*userDao , 每张表对应一个*/  
   6.     private Dao<User, Integer> userDao;  
   7.   
   8.     private DatabaseHelper(Context context) {  
   9.         super(context, TABLE_NAME, null, 2);  
   10.     }  
   11.   
   12.     @Override  
   13.     public void onCreate(SQLiteDatabase sqLiteDatabase,ConnectionSource connectionSource) {  
   14.         try{  
   15.             //创建表  
   16.             TableUtils.createTable(connectionSource, User.class);  
   17.         }catch (SQLException e){  
   18.             e.printStackTrace();  
   19.         }  
   20.     }  
   21.   
   22.     @Override  
   23.     public void onUpgrade(SQLiteDatabase sqLiteDatabase,ConnectionSource connectionSource, int i, int i1) {  
   24.         try{  
   25.             TableUtils.dropTable(connectionSource, User.class, true);  
   26.             onCreate(sqLiteDatabase, connectionSource);  
   27.         }catch (SQLException e){  
   28.             e.printStackTrace();  
   29.         }  
   30.     }  
   31.   
   32.     private static DatabaseHelper instance;  
   33.   
   34.     /* 
   35.     * 单例获取该Helper*/  
   36.     public static synchronized DatabaseHelper getHelper(Context context) {  
   37.         if (instance == null){  
   38.             synchronized (DatabaseHelper.class){  
   39.                 if (instance == null){  
   40.                     instance = new DatabaseHelper(context);  
   41.                 }  
   42.             }  
   43.         }  
   44.         return instance;  
   45.     }  
   46.   
   47.     /* 
   48.     * 获得userDao*/  
   49.     public Dao<User, Integer> getUserDao() throws SQLException {  
   50.         if (userDao == null){  
   51.             userDao = getDao(User.class);  
   52.         }  
   53.         return userDao;  
   54.     }  
   55.   
   56.     /* 
   57.     * 释放资源*/  
   58.     public void close(){  
   59.         super.close();  
   60.         userDao=null;  
   61.     }  
   62. }  
   这里我们需要继承OrmLiteSqliteOpenHelper，其实就是间接继承了SQLiteOpenHelper
   然后需要实现两个方法：
   【创建表，我们直接使用ORMLite提供的TableUtils.createTable(connectionSource, User.class);进行创建】
   
   onCreate(SQLiteDatabase database,ConnectionSource connectionSource)
5. 宁波整形医院http://www.lyxcl.org/
   宁波整形美容医院http://www.zuanno.com/
   onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion)
   
   
6. 数据库的增删改查
   
   [java]  view plain  copy

   1. //增加数据  
   2. public void testAddUser(){  
   3.     User u1 = new User("zhy", "2B青年");  
   4.     DatabaseHelper helper = DatabaseHelper.getHelper(getContext());  
   5.     try{  
   6.         helper.getUserDao().create(u1);  
   7.         u1 = new User("zhy2", "2B青年");  
   8.         helper.getUserDao().create(u1);  
   9.         u1 = new User("zhy3", "2B青年");  
   10.         helper.getUserDao().create(u1);  
   11.         u1 = new User("zhy4", "2B青年");  
   12.         helper.getUserDao().create(u1);  
   13.         u1 = new User("zhy5", "2B青年");  
   14.         helper.getUserDao().create(u1);  
   15.         u1 = new User("zhy6", "2B青年");  
   16.         helper.getUserDao().create(u1);  
   17.   
   18.         testList();  
   19.   
   20.     }catch (SQLException e){  
   21.         e.printStackTrace();  
   22.     }  
   23. }  
   24.   
   25. //删除数据  
   26. public void testDeleteUser(){  
   27.     DatabaseHelper helper = DatabaseHelper.getHelper(getContext());  
   28.     try{  
   29.         helper.getUserDao().deleteById(2);  
   30.     }catch (SQLException e){  
   31.         e.printStackTrace();  
   32.     }  
   33. }  
   34.   
   35. //更新数据  
   36. public void testUpdateUser(){  
   37.     DatabaseHelper helper = DatabaseHelper.getHelper(getContext());  
   38.     try{  
   39.         User u1 = new User("zhy-android", "2B青年");  
   40.         u1.setId(3);  
   41.         helper.getUserDao().update(u1);  
   42.     }catch (SQLException e){  
   43.         e.printStackTrace();  
   44.     }  
   45. }  
   46.   
   47. //查询数据  
   48. public void testList(){  
   49.     DatabaseHelper helper = DatabaseHelper.getHelper(getContext());  
   50.     try {  
   51.         User u1 = new User("zhy-android", "2B青年");  
   52.         u1.setId(2);  
   53.         List<User> users = helper.getUserDao().queryForAll();  
   54.         Log.e("TAG", users.toString());  
   55.     }catch (SQLException e){  
   56.         e.printStackTrace();  
   57.     }  
   58. }