Question

我想使用AsyncTask查询数据库。现在，我可以选择为每种查询类型制作不同的AsyncTask。我倾向于的另一种选择是为每种查询类型创建一个AsyncTask。

如果我将参数作为对象传递，然后将其抛弃，这是不好的做法吗？我可以遇到麻烦吗？我应该在构造函数中传递所有内容吗？

public void insert (Item item){
    new queryAsyncTask(mItemDao).execute(INSERT_QUERY, item);
}

public void delete (int uid){
    new queryAsyncTask(mItemDao).execute(DELETE_QUERY, uid);
}

private static class queryAsyncTask extends AsyncTask<Object, Void, Void>{

    private ItemDao mAsyncDao;

    queryAsyncTask(ItemDao dao){
        mAsyncDao = dao;
    }

    @Override
    protected Void doInBackground(Object... objects) {
        switch ((int) objects[0]){
            case DELETE_QUERY:
                mAsyncDao.deleteItem((int)objects[1]);
                break;
            case INSERT_QUERY:
                mAsyncDao.insert((Item)objects[1]);
                break;
        }
        return null;
    }
}

Answer 1

如果我将参数作为对象传递，然后将其抛回，这是不好的做法？我可以遇到麻烦吗？我应该过去吗构造函数中的所有内容？

是的，这是非常糟糕的做法。考虑以下代码：

private static class queryAsyncTask extends AsyncTask<Object, Void, Void>{

    private ItemDao mAsyncDao;

    queryAsyncTask(ItemDao dao){
        mAsyncDao = dao;
    }

    @Override
    protected Void doInBackground(Object... objects) {
        ...
    }
}

然后您可以通过以下方式调用它：

new queryAsyncTask(mItemDao).execute(DELETE_QUERY, uid);

或

new queryAsyncTask(mItemDao).execute(INSERT_QUERY, item);

但是，您也可以同时使用以下两项进行调用：

new queryAsyncTask(mItemDao).execute(new Object(), item);
new queryAsyncTask(mItemDao).execute(new ArrayList<String>(), item);

这完全没有给出任何错误。这是因为您的代码没有严格的限制，也没有给出足够的解释。

最好为CRUD制作每个任务，然后通过构造函数传递值（引用）。例如，您可以为INSERT创建如下内容：

private static class InsertQueryTask extends AsyncTask<Void, Void, Void> {

    private ItemDao mItemDao;
    private Item mItem;

    InsertQueryTask(ItemDao dao, Item item) {
        mItemDao = dao;
        mItem = item;
    }

    @Override
    protected Void doInBackground(Void... voids) {
       mItemDao.insert(mItem);
    }
}

然后您可以调用它：

new InsertQueryTask(mItemDao, item).execute();

上面的代码行更具可读性和可维护性，因为您只需阅读其名称即可知道代码在做什么。

您可以进一步修改代码，使其成为Fluent Interface。像这样：

private static class InsertQueryTask extends AsyncTask<Void, Void, Void> {

    private ItemDao mItemDao;
    private Item mItem;

    InsertQueryTask(ItemDao dao) {
        mItemDao = dao;
    }

    InsertQueryTask with(Item item) {
      mItem = item;
      return this;
    }

    @Override
    protected Void doInBackground(Void... voids) {
       mItemDao.insert(mItem);
    }
}

现在，您可以通过以下方式调用它：

new InsertQueryTask(mItemDao).with(item).execute();

比以前的代码更具可读性。

注意：尚未测试所有代码。

在AsyncTask中将对象作为参数传递

1 个答案: