我可以创建一个抽象来隐藏我的“检查缓存”吗？逻辑？

Question

我有 getResponse() 方法，可以根据从数据库获取的数据（或预先保存在 SavedData 对象中）构建响应。我想找到一种方法从我的 getResponse() 方法中抽象出“检查保存的数据”逻辑。理想情况下，我想找出一种方法，让我的 getResponse() 方法甚至不知道 SavedData 存在，它只是隐藏在某个界面后面。这里有一个好的抽象可以用来清理这段代码吗？

以下只是伪代码。对于 getResponse() JSON 对象中返回的每个字段，他们首先检查该字段是否已保存在某个 SavedData 中，如果有则使用它，否则，他们需要查询数据库中的字段。

interface ResponseGetter {
  public Response getResponse(String userID, SavedData savedData);
}

class A implements ResponseGetter {
  public Response getResponse(String userID, SavedData savedData) {           
      List<String> foo;
      int bar;
      String bizz;

      foo = savedData.get(userID, "foo");
      if (foo == null) {
        foo = loadFooFromDB(userID);
      }
      bar = savedData.get(userID, "bar");
      if (bar == null) {
        bar = loadBarFromDB(userID);
      }
      bizz = savedData.get(userID, "bizz");
      if (bizz == null) {
        bizz = loadBizzFromDB(userID);
      }

      JSONObject json = new JSONObject();
      json.put("foo", foo);
      json.put("bar", bar);
      json.put("bizz", biz);
      return new Response(json);
  }

  private List<String> loadFooFromDB(String userID) {
     List<String> returnList = new ArrayList<String>();
     DB db = this.getDB();
     String query = "SELECT foo FROM SomeTable WHERE user_id=" + userID;
     Results results = db.executeQuery(query);
     for (Result result : results) {
         returnList.add(result.toString());
     }

     return returnList;
  }
}

class B implements ResponseGetter {
  public Response getResponse(String userID, SavedData savedData) {           
      List<String> baz;
      int qux;
      String corge;

      baz = savedData.get(userID, "baz");
      if (baz == null) {
        baz = loadBazFromDB(userID);
      }
      qux = savedData.get(userID, "qux");
      if (qux == null) {
        qux = loadQuxFromDB(userID);
      }
      corge = savedData.get(userID, "corge");
      if (corge == null) {
        corge = loadCorgeFromDB(userID);
      }
      
    
      JSONObject json = new JSONObject();
      json.put("baz", baz);
      json.put("qux", qux);
      json.put("corge", corge);
        
      return new Response(json);
  }
}

Answer 1

我会使用泛型和策略设计模式。

我真的不知道你可以放弃哪些类型和类，因为你提供了伪代码。

如果我忘了写重要的东西，请评论。

---

但我会采用这样的方法：

interface ResponseGetter<R> {
R getResponse(String userId, String dataToCheck, SavedData<R> savedData, Function<String, R> lambda);
}

class DB<R> {
public R executeQuery(String query) {
    return null;
}
}

interface SavedData<R> {
    public R get(String userId, String name);
}

class SomeClass<R> implements ResponseGetter<R> {

    @Override
    public R getResponse(String userId, String dataToCheck, SavedData<R> savedData, Function<String, R> lambda) {
        R checkedData = savedData.get(userId, dataToCheck);
        return checkedData == null ? loadDataFromDB(userId, lambda) : checkedData;
    }

    public R loadDataFromDB(String userId, Function<String, R> lambda) {
        return lambda.apply(userId);
    }
}

class SavedDataImpl<R> implements SavedData<R> {

    @Override
    public R get(String userId, String name) {
        return null;
    }
}

class Main  {

    public static void main(String[] args) {

        // foo
        SomeClass<List<String>> someClass = new SomeClass<>();
        SavedDataImpl<List<String> savedDataImpl = new SavedDataImpl<>();
        DB<List<String>> db = new DB<>();

        List<String> foo = someClass.getResponse("1", "foo", savedDataImpl, (String userId) -> {
        List<String> result = db.executeQuery("SELECT foo FROM SomeTable WHERE user_id=" + userId);
        return result;
    });

    // bar
    SomeClass<Integer> someClassTwo = new SomeClass<>();
    SavedDataImpl<Integer savedDataImplTwo = new SavedDataImpl<>();
    DB<Integer> dbTwo = new DB<>();

    Integer bar = someClassTwo.getResponse("1", "bar", savedDataImplTwo, (String userId) -> {
        Integer result = dbTwo.executeQuery("SELECT bar FROM SomeTable WHERE user_id=" + userId);
        return result;
    });

    // bizz
    SomeClass<String> someClassThree = new SomeClass<>();
    SavedDataImpl<String savedDataImplThree = new SavedDataImpl<>();
    DB<String> dbThree = new DB<>();

    String bizz = someClassThree.getResponse("1", "bizz", savedDataImplThree, (String userId) -> {
        String result = dbThree.executeQuery("SELECT bizz FROM SomeTable WHERE user_id=" + userId);
        return result;
    });

    Map json = new HashMap();
    json.put("foo", foo);
    json.put("bar", bar);
    json.put("bizz", bizz);

}
}

这样你就可以抽象出如何获取数据和获取哪些数据的行为。

为了简单起见，我只是在地图中格式化了响应。