4

我是这个网站的新手，这是我的第一个问题。

我必须做一个网站，我正在使用 java 和 Struts2，但我是 Struts2 的新手。

在我的站点中，我必须向 Facebook 发出请求并通过 OAuth 进行身份验证。

我正在操作页面的执行方法中执行所有过程（验证和请求受保护的资源），这个过程非常复杂，并且在 Facebook 和我的网站之间有很多重定向。

前几天我读到这个“不要用多种方法创建动作：“执行”和你想要执行的操作（例如“createUser”）应该足够了”（来自http://freeopenidea.blogspot.com.es/ 2010/04/struts2-best-practices.html）。

大多数代码可以在另一个时刻从我网站的另一部分调用，因为我在第一次连接时执行此过程，但我可以执行此操作（或类似操作）以刷新联系人列表。

1 - 我应该为我需要的方法创建一个单独的类（而不是一个动作）并从“执行”方法中调用它们吗？

2 - 我应该将代码保留在操作页面中，但保留在“执行”之外的方法中吗？每次我需要做一些任务时都调用这个页面。

我不知道将代码放在哪里（而且我知道，我必须存储 de accessToken。我只是粘贴代码以显示复杂性但不查看更正）。

public String execute() throws Exception{
   if (code!=null){
      Verifier verifier = new Verifier(code);
      //get the accessToken to do requests
      Token accessToken = service.getAccessToken(EMPTY_TOKEN, verifier);
      OAuthRequest requestList = new OAuthRequest(Verb.GET, PROTECTED_RESOURCE_URL);
      service.signRequest(accessToken, requestList);
      Response responseList = requestList.send();
      if (responseList.getCode() == 200){
        //I get the Friends List
        JsonParse parser = new JsonParse();
        JSONObject json = (JSONObject) JSONSerializer.toJSON(responseList.getBody());
        JSONArray datos = json.getJSONArray("data");
        for (Object o : datos) 
        {//for every friend of the list I do this
            JSONObject elem = (JSONObject) o;
            String id = elem.getString("id");                
            OAuthRequest requestFriend = new OAuthRequest(Verb.GET,"https://graph.facebook.com/"+id);
            service.signRequest(accessToken, requestFriend);
            Response responseFriend = requestFriend.send();
            if (responseFriend.getCode() == 200){
                JsonParse parserAux = new JsonParse();
                PerfilContacto pcBean = parserAux.parseFacebookElement(responseFriend.getBody());
                pcDAO.insertarContacto(pcBean); 
            }
        }
      }
      return SUCCESS; 
   }      
   else return ERROR;    
 }
4

1 回答 1

3

IMO 在动作方法中的代码太多了。操作应该处理 Web 和业务层之间的层，仅此而已。这种级别的耦合，尤其是硬编码的类实例化，使得单独测试动作的逻辑变得非常困难。

基本上将所有代码移动到服务中。该操作仅与服务交互有关。该框架验证code. 该服务在 Struts 2 之外进行测试。该操作使用模拟服务进行测试。

完全未经测试，但我怀疑我的代码看起来更接近下面的内容。它将一种复杂性换成另一种，但带来了多重好处。每种方法都集中注意力且易于阅读。服务调用是隔离的，这允许我们测试不同模式的服务故障。它是系统行为和功能的精细表示。

行动

public String execute() throws Exception {
    fbService.updateFriends(code);
    return SUCCESS;
}

脸书服务

public void updateFriends(String code) {
    Token accessToken = getAccessToken(code);
    Response response = getFriends(accessToken);
    if (response.getCode() == 200) {
        processFriends(accessToken, response);
    }
}

private void processFriends(Token accessToken, Response response) {
    JSONObject json = (JSONObject) JSONSerializer.toJSON(response.getBody());
    JSONArray datos = json.getJSONArray("data");
    for (Object o : datos)  {
        JSONObject friend = (JSONObject) o;
        processFriend(friend);
    }
}

private void processFriend(Token accessToken, JSONObject friend) {
    Response response = getFriendGraph(accessToken, friend.getString("id"));
    if (response.getCode() == 200){
        PerfilContacto pcBean = new JsonParse().parseFacebookElement(response.getBody());
        pcDAO.insertarContacto(pcBean); 
    }
}

//~ Service interaction

private Response getFriends(Token accessToken) {
    return sendSignedGetRequest(PROTECTED_RESOURCE_URL, accessToken);
}

private Response getFriendGraph(Token accessToken, String id) {
    return sendSignedGetRequest("https://graph.facebook.com/" + id, accessToken);
}

private Token getAccessToken(String code) {
    return service.getAccessToken(EMPTY_TOKEN, new Verifier(code));
}

private Response sendSignedGetRequest(String url, Token accessToken) {
    OAuthRequest request = new OAuthRequest(Verb.GET, url);
    service.signRequest(accessToken, request);
    return request.send();
}

如果我们考虑指标，我们最终会得到以下结果。

原来的：

Average Function NCSS:      24.00
Average Function CCN:        6.00
Program NCSS:               25.00

重做：

Average Function NCSS:       3.63
Average Function CCN:        1.38
Program NCSS:               31.00

最终，这意味着：

  • 显着 LOC 的数量没有增加太多。
  • 每个函数的长度小于 4 行（易于阅读）。
  • 每个函数的圈复杂度小于 2（易于测试和推理）。
  • 程序读起来更像它正在做的事情，从而可以更快地理解。

权衡是我们有更多的方法（考虑到任何合理的 IDE 或文本编辑器，这不应该是一个大问题），这是一种复杂性。然而：

  • 我们可以在我们选择的深度停止阅读。
  • 我们可以用更大的粒度进行测试。
  • 我们可以识别我们可能错过的成功/失败模式。
  • 我们可以更轻松地交换和/或扩展功能。
于 2012-09-19T21:20:59.907 回答