OrmLite的快速使用方案

首先分享给大家一个可以查看sqllite数据库的工具：sqliteexpert，很好很强大的。大家可以下载免费版本的。地址：http://www.sqliteexpert.com/download.html

1.Android Studio用户自己在gradle添加以下配置

dependencies {
    compile 'com.j256.ormlite:ormlite-core:4.48'
    compile 'com.j256.ormlite:ormlite-android:4.48'

2.建立一个User类:通过注解，可以在数据库里建表，以下是建立了一个user_table的表

package com.csdndatasave.bean;

import com.j256.ormlite.field.DatabaseField;
import com.j256.ormlite.table.DatabaseTable;

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

    @DatabaseField(generatedId = true)
    private int _id;
    @DatabaseField(columnName = "name")
    private String name;
    private String age;
    @DatabaseField(columnName = "birthday")
    private String birthday;
    @DatabaseField(columnName = "city")
    private String city;

    public int get_id() {
        return _id;
    }

    public void set_id(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 getBirthday() {
        return birthday;
    }

    public void setBirthday(String birthday) {
        this.birthday = birthday;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }
}

3.如果不用第三方的框架，我们需要自己建立一个helper类继承sqliteOpenHelper，ormLite就需要我们继承OrmLiteSqliteOpenHelper

package com.csdndatasave.db;

import android.content.Context;
import android.database.sqlite.SQLiteDatabase;

import com.csdndatasave.bean.User;
import com.j256.ormlite.android.apptools.OrmLiteSqliteOpenHelper;
import com.j256.ormlite.dao.Dao;
import com.j256.ormlite.support.ConnectionSource;
import com.j256.ormlite.table.TableUtils;

import java.sql.SQLException;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class DataBaseHelper extends OrmLiteSqliteOpenHelper {
    private static final String TABLE_NAME = "CSDN.db";
    private static DataBaseHelper instance;
    private Map<String, Dao> daoMap = new HashMap<>();

    private DataBaseHelper(Context context) {
        super(context, TABLE_NAME, null, 1);
    }

    /**
     * 单例模式
     *
     * @param context
     * @return
     */
    public static DataBaseHelper getInstance(Context context) {
        if (instance == null) {
            synchronized (DataBaseHelper.class) {
                if (instance == null) {
                    instance = new DataBaseHelper(context);
                }
            }
        }
        return instance;
    }

    /**
     * 建表
     *
     * @param database
     * @param connectionSource
     */
    @Override
    public void onCreate(SQLiteDatabase database, ConnectionSource connectionSource) {
        try {
            //建立表user_table
            TableUtils.createTable(connectionSource, User.class);
        } catch (SQLException e) {
            e.printStackTrace();
        }

    }

    /**
     * 更新
     *
     * @param database
     * @param connectionSource
     * @param oldVersion
     * @param newVersion
     */
    @Override
    public void onUpgrade(SQLiteDatabase database, ConnectionSource connectionSource, int oldVersion, int newVersion) {
        try {
            TableUtils.dropTable(connectionSource, User.class, true);
            onCreate(database, connectionSource);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }

    /**
     * 获取Dao类，通过Dao类可以对表里的数据进行增删改查
     *
     * @param clazz
     * @return
     * @throws SQLException
     */
    public synchronized Dao getDao(Class clazz) throws SQLException {
        Dao dao = null;
        String className = clazz.getSimpleName();
        if (daoMap.containsKey(className)) {
            dao = daoMap.get(className);
        }
        if (dao == null) {
            dao = super.getDao(clazz);
            daoMap.put(className, dao);
        }
        return dao;
    }

    /**
     * 清除某个表内的数据
     *
     * @param clazz
     */
    public synchronized void clearData(Class clazz) {
        try {
            TableUtils.clearTable(connectionSource, clazz);
        } catch (SQLException e) {
            e.printStackTrace();
        }
    }
}

3.接下来我们建立个Dao类

package com.csdndatasave.db;

import android.annotation.TargetApi;
import android.content.ContentValues;
import android.content.Context;
import android.os.Build;

import com.csdndatasave.activity.APP;
import com.j256.ormlite.dao.Dao;
import com.j256.ormlite.stmt.QueryBuilder;
import com.j256.ormlite.stmt.UpdateBuilder;

import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class GeneralDao<T> {
    private static final String TAG = "GeneralDao";
    private DataBaseHelper dbHelper;
    private Context context;

    public GeneralDao() {
        context = APP.getInstance().getApplicationContext();
        dbHelper = DataBaseHelper.getInstance(context);
    }

    /**
     * 新增一条记录
     */
    public int create(T po) {

        try {
            Dao dao = dbHelper.getDao(po.getClass());
            return dao.create(po);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return -1;
    }

    public boolean exists(T po, Map<String, Object> where) {
        try {
            Dao dao = dbHelper.getDao(po.getClass());
            if (dao.queryForFieldValues(where).size() > 0) {
                return true;
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return false;
    }

    public int createIfNotExists(T po, Map<String, Object> where) {
        try {
            Dao dao = dbHelper.getDao(po.getClass());
            if (dao.queryForFieldValues(where).size() < 1) {
                return dao.create(po);
            }
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return -1;
    }

    /**
     * 查询一条记录
     */
    public List<T> queryForEq(Class<T> c, String fieldName, Object value) {
        try {
            Dao dao = dbHelper.getDao(c);
            return dao.queryForEq(fieldName, value);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return new ArrayList<T>();
    }

    /**
     * 查询第一条记录
     */
    public T queryForFirst(Class<T> c) {
        try {
            Dao dao = dbHelper.getDao(c);
            QueryBuilder<T, Integer> queryBuilder = dao.queryBuilder();
            return queryBuilder.queryForFirst();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 根据id删除一条记录
     *
     * @param po
     * @param id
     * @return
     */
    public int removeById(T po, int id) {
        try {
            Dao dao = dbHelper.getDao(po.getClass());
            return dao.deleteById(id);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return -1;
    }


    /**
     * 根据特定条件更新特定字段
     *
     * @param c
     * @param values
     * @param columnName where字段
     * @param value      where值
     * @return
     */
    @TargetApi(Build.VERSION_CODES.HONEYCOMB)
    public int update(Class<T> c, ContentValues values, String columnName, Object value) {
        try {
            Dao dao = dbHelper.getDao(c);
            UpdateBuilder<T, Long> updateBuilder = dao.updateBuilder();
            updateBuilder.where().eq(columnName, value);
            for (String key : values.keySet()) {
                updateBuilder.updateColumnValue(key, values.get(key));
            }
            return updateBuilder.update();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return -1;
    }

    /**
     * 更新一条记录
     */
    public int update(T po) {
        try {
            Dao dao = dbHelper.getDao(po.getClass());
            return dao.update(po);
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return -1;
    }

    /**
     * 查询所有记录
     */
    public List<T> queryForAll(Class<T> c) {
        try {
            Dao dao = dbHelper.getDao(c);
            return dao.queryForAll();
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return new ArrayList<T>();
    }
}

上面这是一个抽取出的一个比较通用的Dao类，如果没有特殊的需求，就可以直接用上面的这个Dao类进行操作
下载地址：http://download.csdn.net/detail/qq_29375071/9392863