1.dependencies中添加依赖

compile group: 'com.j256.ormlite', name: 'ormlite-core', version: '5.1'
compile group: 'com.j256.ormlite', name: 'ormlite-android', version: '5.1'

2.创建ORMLiteHelper类，继承OrmLiteSqliteOpenHelper

public class ORMLiteHelper extends OrmLiteSqliteOpenHelper {
/**
 * 数据库名称
 */
private static final String DBNAME = "ormLiteDBName";
/**
 * 版本号
 */
private static final int DBVERSION = 1;
private static ORMLiteHelper mInstance;
private static Context mContext;

private ORMLiteHelper(Context context) {
    super(context, DBNAME, null, DBVERSION);
}

/**
 * 初始化
 *
 * @param context
 */
public static void initOrmLite(Context context) {
    mContext = context;
    getIntence();
}

/**
 * 获取实例
 *
 * @return
 */
public static ORMLiteHelper getIntence() {
    if (null == mInstance) {
        synchronized (ORMLiteHelper.class) {
            if (null == mInstance) {
                mInstance = new ORMLiteHelper(mContext);
            }
        }
    }
    return mInstance;
}


@Override
public void onCreate(SQLiteDatabase sqLiteDatabase, ConnectionSource connectionSource) {
    try {
        /**
         * 创建表
         */
        int tableIfNotExists = TableUtils.createTableIfNotExists(connectionSource, OrmTable.class);
        Log.e("nan", "测试创建====" + tableIfNotExists);
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

@Override
public void onUpgrade(SQLiteDatabase sqLiteDatabase, ConnectionSource connectionSource, int i, int i1) {

    /**
     * 方式一
     * 删除表，重新创建
     * 弊端：表中原有数据丢失
     */
    try {
        TableUtils.dropTable(connectionSource, OrmTable.class, false);
        onCreate(sqLiteDatabase, connectionSource);
    } catch (SQLException e) {
        e.printStackTrace();
    }
    /**
     * 方式二
     * 动态增删表字段
     * 优点：保留原有数据
     */
    //TableUpdataOperate.getInstance().updateColumn(sqLiteDatabase, "已有表名"
    //                , "新增的表字段", "varchar", "默认值");
    TableUpdataOperate.getInstance().updateColumn(sqLiteDatabase, "tTable"
            , "newColumnName", "varchar", "newColumnvalue");
}

/**
 * 获取数据对象
 *
 * @param classz 对应的表实体的字节码对象
 * @return Dao<T, ID> :T：表实体对象类型.ID：对应的表实体中被指定为id字段的属性类型
 * @throws SQLException
 */
public Dao getDao(Class classz) throws SQLException {
    return super.getDao(classz);
}}

3.创建与数据表具有映射关系的数据实体类OrmTable

@DatabaseTable(tableName = "tTable")
public class OrmTable {
/**
 * columnName：列名
 * id：指定该列为id列
 * <p>
 * 该属性被指定为id列后,其数据类型将与Dao<T,ID>中的泛型ID的类型一致
 */
@DatabaseField(columnName = "_id", id = true)
public String _id;

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

@DatabaseField(columnName = "sex")
public int sex;}

4.创建针对tTable表进行操作的类

public class OrmTableDao {
/**
 * 根据数据表实体查询到的Dao
 * 第一个泛型为数据表实体
 * 第二个泛型为数据表实体中被指定为id的属性的数据类型
 */
private Dao<OrmTable, String> mDao;
private static OrmTableDao mInstance;

private OrmTableDao() {
    try {
        mDao = ORMLiteHelper.getIntence().getDao(OrmTable.class);
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

/**
 * 单例模式获取实例
 */
public static OrmTableDao getInstance() {
    if (null == mInstance) {
        synchronized (OrmTableDao.class) {
            if (null == mInstance) {
                mInstance = new OrmTableDao();
            }
        }
    }
    return mInstance;
}

/**
 * 插入单条数据
 *
 * @param table
 */
public void insert(OrmTable table) {
    try {
        int i = mDao.create(table);
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

/**
 * 插入多条数据
 *
 * @param tables
 */
public void insert(List<OrmTable> tables) {
    try {
        int i = mDao.create(tables);
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

/**
 * 查询表中所有数据
 *
 * @return
 */
public List<OrmTable> query() {
    List<OrmTable> ormTables = null;
    try {
        ormTables = mDao.queryForAll();
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return ormTables;
}

/**
 * 通过id(@DatabaseField(columnName = "_id", id = true))查询指定数据
 *
 * @param id
 * @return
 */
public OrmTable queryById(String id) {
    OrmTable ormTable = null;
    try {
        /**
         * queryForId(id)的参数(id)类型与Dao<T,ID>中的泛型ID的类型一致
         */
        ormTable = mDao.queryForId(id);
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return ormTable;
}

/**
 * 自定义查询表中数据
 */
public List<OrmTable> queryByCustom() {
    List<OrmTable> ormTables = null;
    QueryBuilder<OrmTable, String> builder = mDao.queryBuilder();
    Where<OrmTable, String> where = builder.where();
    try {
        where.eq("_id", "111")
                .and()
                .eq("name", "aaa");
        ormTables = builder.query();
    } catch (SQLException e) {
        e.printStackTrace();
    }
    return ormTables;
}


/**
 * 通过id进行数据删除
 *
 * @param id
 */
public void deleteById(String id) {
    try {
        int i = mDao.deleteById(id);
    } catch (SQLException e) {
        e.printStackTrace();
    }
}

/**
 * 删除表中所有数据
 */
public void deleteAll() {
    try {
        int delete = mDao.deleteBuilder().delete();
    } catch (SQLException e) {
        e.printStackTrace();
    }
}}