ORMLite和GreenDao是Android上最流行的ORM(物件關係對映)框架

現在來簡單梳理下ORMLite在Android上的簡單使用

1.在官網下載jar包,將這兩個jar包放在libs目錄下,然後同步工程(也就是將這兩個jar包新增進library)

2.建立一個java類(User.java),這個類對映到資料庫當中的一張表

@DatabaseTable(tableName = "user")
public class User {

    public User() {
    }

    public User(int id, String name, String age, String address) {
        this
 
.id = id;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    @DatabaseField(id = true)
    private int id;

    @DatabaseField(columnName = "name")
    private String name;

    @DatabaseField(columnName = "age")
    private String age;

    @DatabaseField(columnName = "address"
 
)
    private String address;


    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAge() {
        return
 
 age;
    }

    public void setAge(String age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

1. @DatabaseTable(tableName = “user”) : 代表此類對應於資料庫當中的名為user的表

2. @DatabaseField() : 代表此欄位是資料庫當中的一個列名
   例如:
   @DatabaseField(id = true)
   private int id; 代表id是此表的主鍵

   @DatabaseField(columnName = “name”)
   private String name; 代表name對應於user表中的name欄位

   更多@DatabaseField()括號中的註解請參考 :　ORMLite註解小計

3.新建一個繼承自OrmLiteSqliteOpenHelper的類DatabaseHelper,主要用於建立、更新資料庫，也可以用來獲取資料庫操作物件dao

public class DatabaseHelper extends OrmLiteSqliteOpenHelper {
    private static final String DB_NAME = "ormtest.db";
    private static final int DB_VERSION = 1;

    private Dao<User, Integer> userDao;

    private DatabaseHelper(Context context) {
        super(context, DB_NAME, null, DB_VERSION);
    }

    private static volatile DatabaseHelper mInstance;

    /**
     * 單例模式,獲取DatabaseHelper的唯一例項
     *
     * @param context
     * @return
     */
    public static DatabaseHelper getInstance(Context context) {
        if (mInstance == null) {
            synchronized (DatabaseHelper.class) {
                if (mInstance == null) {
                    mInstance = new DatabaseHelper(context);
                }
            }
        }

        return mInstance;
    }


    /**
     * 如果還沒有這個資料庫的時候就會建立資料庫,同時建立表格
     *
     * @param sqLiteDatabase
     * @param connectionSource
     */
    @Override
    public void onCreate(SQLiteDatabase sqLiteDatabase, ConnectionSource connectionSource) {

        try {
            //建立表
            TableUtils.createTable(connectionSource, User.class);

        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 升級資料庫
     *
     * @param sqLiteDatabase
     * @param connectionSource
     * @param i
     * @param i1
     */
    @Override
    public void onUpgrade(SQLiteDatabase sqLiteDatabase, ConnectionSource connectionSource, int i, int i1) {
        try {
            TableUtils.dropTable(connectionSource, User.class, true);
            onCreate(sqLiteDatabase, connectionSource);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 釋放資源
     */
    @Override
    public void close() {
        super.close();
        userDao = null;
    }
}

4.從DatabaseHelper獲取dao物件,用來操作資料庫(增刪改查)

DatabaseHelper helper = DatabaseHelper.getInstance(this);
        try {
            Dao<User, Integer> dao = helper.getDao(User.class);
            dao.delete(new User());//刪除資料

        } catch (SQLException e) {
            e.printStackTrace();
        }

上面只羅列了刪除(delete),還有增(create)、改（update）、查（query）的方法

（建議）自己封裝一個dao，比如我這裡自己封裝了一個UserDao,裡面包含了資料的增刪改查的方法

public class UserDao {
    private DatabaseHelper mHelper;
    private Dao<User, Integer> mDao;

    private static volatile UserDao mUserDao;

    private UserDao(Context context) {
        if (mDao == null) {
            if (mHelper == null) {
                mHelper = DatabaseHelper.getInstance(context);
            }

            try {
                mDao = mHelper.getDao(User.class);
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    public static UserDao getInstance(Context context) {
        if (mUserDao == null) {
            synchronized (UserDao.class) {
                if (mUserDao == null) {
                    mUserDao = new UserDao(context);
                }
            }
        }

        return mUserDao;
    }


    /**
     * Create a new row in the database from an object
     * 建立一條新的記錄到資料庫中
     *
     * @param user
     * @return 是否插入成功
     */
    public boolean insert(User user) {
        boolean flag = false;
        try {
            //插入或者更新的行數,單條插入成功就是1
            int i = mDao.create(user);
            flag = i == 1 ? true : false;
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return flag;
    }

    /**
     * 批量插入資料
     *
     * @param user
     * @return 是否插入成功
     */
    public boolean insertAll(List<User> user) {
        boolean flag = false;
        try {
            //插入或者更新的行數,單條插入成功就是1
            int i = mDao.create(user);
            flag = i == 1 ? true : false;
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return flag;
    }

    /**
     * 刪除一條資料
     *
     * @param user
     * @return
     */
    public boolean delete(User user) {
        boolean flag = false;
        try {
            int rowCount = mDao.delete(user);
            flag = rowCount == 1 ? true : false;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 批量刪除
     *
     * @param users
     * @return
     */
    public boolean deleteAll(List<User> users) {
        boolean flag = false;
        try {
            int rowCount = mDao.delete(users);
            flag = rowCount == 1 ? true : false;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 更新資料
     *
     * @param user
     * @return
     */
    public boolean update(User user) {
        boolean flag = false;
        try {
            int rowCount = mDao.update(user);
            flag = rowCount == 1 ? true : false;
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return flag;
    }

    /**
     * 批量更新
     *
     * @param users
     * @return
     */
    public boolean updateAll(List<User> users) {
        boolean flag = true;
        try {
            for (User user : users) {
                int rowCount = mDao.update(user);
                boolean b = rowCount == 1 ? true : false;
                if (!b) {
                    flag = false;
                }
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return flag;
    }


    /**
     * 使用QueryBuilder查詢
     */
    public List<User> query() {
        QueryBuilder<User, Integer> builder = mDao.queryBuilder();
        Where<User, Integer> where = builder.where();
        try {
            //相當於:select * from user where name = '張三' and age > 20
            where.and(where.eq("name", "張三"), where.ge("age", 20));

            //下面這條語句相當於:select * from user where (name = '張三' and age > 20 ) or address = '陝西'
            where.and(where.eq("name", "張三"), where.ge("age", 20)).or().eq("address", "陝西");

            List<User> users = where.query();
            return users;
        } catch (SQLException e) {
            e.printStackTrace();
        }

        return null;
    }

}

基本的使用就介紹到此,如果希望更加深入的瞭解,建議移步 官網