GreenDao基类升级版（记录）

基类

public interface TestDao<K> {
    /**
     * 插入数据
     * @param entity 插入的对象
     * @return 插入新纪录的id
     */
    long insert(K entity);

    /**
     * 修改数据
     * @param entity 修改的对象
     */
    void update(K entity);

    /**
     * 删除数据
     * @param entity 删除的对象
     */
    void delete(K entity);

    /**
     * 删除多条数据
     * @param clazz 删除的列表数据对应的类
     * @param list 删除的列表数据
     */
    void deleteForList(Class clazz, List<K> list);

    /**
     * 查询num条数据
     * @param num 查询的数量
     * @return 记录对应的类的列表list
     */
    List<K> queryForList(int num);

    /**
     * 获取数据总数
     * @return
     */
    long getCount();
}

public class BaseTestDao<K> implements TestDao<K> {

    private Class<K> clazz;

    public BaseTestDao() {
        clazz = ReflectionUtil.getClass(getClass());
    }

    @Override
    public long insert(K entity) {
        return DBUtil.getInstance().getWriteDaoSession().insert(entity);
    }

    @Override
    public void update(K entity) {
        DBUtil.getInstance().getWriteDaoSession().update(entity);
    }

    @Override
    public void delete(K entity) {
        DBUtil.getInstance().getWriteDaoSession().delete(entity);
    }

    @Override
    public void deleteForList(Class clazz,List<K> list) {
        try {
            DBUtil.getInstance().getWriteDaoSession().getDao(clazz).deleteInTx(list);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public List<K> queryForList(int num) {
        return DBUtil.getInstance().getReadDaoSession().queryBuilder(clazz).limit(num).list();
    }

    @Override
    public long getCount() {
        return DBUtil.getInstance().getReadDaoSession().queryBuilder(clazz).count();
    }
}

public class ReflectionUtil {
    public static Class getClass(Class clazz){
        Type type = clazz.getGenericSuperclass();
        if (!(type instanceof ParameterizedType)) {
            return Object.class;
        }

        Type[] params = ((ParameterizedType) type).getActualTypeArguments();

        if (params.length <= 0) {
            return Object.class;
        }

        if (!(params[0] instanceof Class)) {
            return Object.class;
        }

        return (Class) params[0];
    }
}

public class DBUtil {
    private DaoMaster.DevOpenHelper mOpenHelper;
    private DaoSession mReadDaoSession, mWriteDaoSession;

    private static volatile DBUtil mInstance;

    public static final String DB_NAME = "gps.db";

    public static DBUtil getInstance() {
        if (mInstance == null) {
            synchronized (DBUtil.class) {
                if (mInstance == null) {
                    mInstance = new DBUtil();
                }
            }
        }
        return mInstance;
    }

    public DBUtil() {
        initDbHelp();
        mWriteDaoSession = new DaoMaster(getWritableDatabase()).newSession();
        mReadDaoSession = new DaoMaster(getReadableDatabase()).newSession();
    }

    private SQLiteDatabase getWritableDatabase() {
        initDbHelp();
        return mOpenHelper.getWritableDatabase();
    }

    private SQLiteDatabase getReadableDatabase() {
        initDbHelp();
        return mOpenHelper.getReadableDatabase();
    }

    private void initDbHelp() {
        if (mOpenHelper == null) {
            mOpenHelper = new DaoMaster.DevOpenHelper(MyApplication.getContext(), DB_NAME, null);
        }
    }

    public DaoSession getReadDaoSession() {
        return mReadDaoSession;
    }

    public DaoSession getWriteDaoSession() {
        return mWriteDaoSession;
    }

}

使用

public interface GpsDeviceDao {
    public abstract void addDevice(GpsDevice gpsDevice);
}

public class GpsDeviceDAOImpl extends BaseTestDao<GpsDevice> implements GpsDeviceDao {

    @Override
    public void addDevice(GpsDevice gpsDevice) {
        insert(gpsDevice);
    }
}

 GpsDeviceDao dao = new GpsDeviceDAOImpl;
 dao.addDevice(new GpsDevice(null, “test"));