try-catch-finally 与抽象方法

Question

在我们的系统中，我们有一个抽象类，我们称之为BasicAction，它包含几个抽象方法。其中最重要的是执行。它处理来自 JSP 页面的请求。主处理程序的工作方式如下：

// Sample 1: 
String actionName;// The name of action to use
Map<String, BasicAction> mapping;//The mapping of names and actual handlers

BasicAction action = mapping.get(actionName);

try {
  action.execute(request);//Handle the http request from the JSP page
} catch (Exception ex) {
  // Handle here any exceptions
}

现在，一切看起来都很好，但基本上所有派生处理程序都实现相同的代码：

// Sample 1: 
public class ConcreteAction extends BasicAction {
  @Override
  public void execute(HttpServletRequest request) {
    // The managers provide the middle layer between 
    // web presentation and database
    TrafficManager trafficManager = null;
    CargoManager cargoManager = null;
    try {
      trafficManager = new TrafficManager(); 
      cargoManager = new CargoManager();
      // Perform here all the logic required using managers
    } catch (Exception ex) {
       // handle the exception or rethrow it
    } finally {
      // Should remove all managers clearly and release the connection
      removeManager(trafficManager);
      removeManager(cargoManager);
    }
  }
}

在我拥有的每个处理程序中编写这样的块似乎有点烦人。看起来我们在这里模仿每个处理程序的进入/退出点，但并不像想象的那样。我认为我们这里需要的是在 BasicAction 中定义两个更抽象的方法，称为 createManagers 和 disposeManagers。然后主处理程序将如下所示：

// Sample 2: 
String actionName;// The name of action to use
Map<String, BasicAction> mapping;//The mapping of names and actual handlers

BasicAction action = mapping.get(actionName);

try {
  action.createManagers(); // The enter point
  action.execute(request);//Handle the http request from the JSP page
} catch (Exception ex) {
  // Handle here any exceptions
} finally {
  action.disposeManagers(); // The exit point
}

之后，每个派生操作处理程序可以这样定义：

// Sample 2: 
public class ConcreteAction extends BasicAction {
  private TrafficManager trafficManager = null;
  private CargoManager cargoManager = null;

  @Override
  public void createManagers() {
    trafficManager = new TrafficManager();
    cargoManager = new CargoManager();
  }

  @Override
  public void disposeManagers() {
    removeManager(trafficManager);
    removeManager(cargoManager);
  }

  @Override
  public void execute(HttpServletRequest request) {
    // Perform here all the logic required using managers    
  }
}

哪种方法更好使用 - 在每个处理程序中使用 try-catch-finally 或使用标准进入/退出点。

Answer 1

就我个人而言，我会选择抽象类方法，因为它听起来像策略模式。而且，代码更干净、更容易遵循；另外 - 你不会一遍又一遍地重复这个结构。但这只是我的意见，有人可能会提出相反的建议。

Answer 2

让 createManagers() 返回经理列表。然后，调用类可以对每个类调用removeManager()，从而不需要disposeManagers()。

此外，您还可以使用继承来耦合 BasicAction 和 ConcreteAction。这是没有必要的。您可以通过组合将它们耦合起来。如果 ConcreteAction 实现 IBasicAction 接口，则单独的类 ActionRunner 可以对操作调用 createManagers() 和execute()。您可以将 ConcreteAction 实例传递给 ActionRunner。

Answer 3

抽象化（选项 2）。

公共代码，特别是公共处理流程应该被抽象。这使得子类可以自由地实现差异，并且意味着可以单独测试抽象代码 - 例如使用模拟/测试实现。

请注意，您可能会走得太远，因此常识适用，但请始终注意抽象点。

Answer 4

我通常使用后一种方法，因为它使重用更加简单。通常，我需要相同的管理器来执行许多操作，因此我可以实现一次创建/处置代码，然后剩下的就是一个小的 execute() 方法。

如果这种方法不起作用，我仍然可以重写原始处理程序方法，这样我就可以两全其美。

Answer 5

抽象类将提供某种保证，确保始终调用清理代码，并且它减少了重复，因此在我看来，它比现有结构更好。当然，您无法知道 disposeManagers 的子类实现将准确地杀死它之前创建的那些管理器 - 但在编写标准 finally 块时您也会遇到同样的问题。

我想我会更进一步。一方面，execute 方法需要这两个管理器来完成工作，因此我将其定义为

public void execute(HttpServletRequest req, TrafficManager t, CargoManager c);

现在让我们假设您的大多数操作都使用相同的管理器实现。我们在超类中将这些方法定义为（尽管不是将它们设为最终方法）：

public TrafficManager createTrafficManager() { return new TrafficManager(); }
public CargoManager createCargoManager() { return new CargoManager(); }

因此，现在超类可以通过调用该方法自行创建这些实例，并将它们传递给执行。如果子类需要与默认不同的实现，它可以根据需要重写该方法。

看看清理 - 我们可以采用与上述类似的方法并定义抽象实现。但是，如果管理器需要被清理，那么他们可能会实现close()方法或类似的方法。在这种情况下，我们可以直接调用它 - 这保证了它们将被正确处理，无论子类的实现如何，并且 try 和 finally 不可能不同步。

或者，如果您的逻辑需要的话，您可以对每个调用 removeManager 。 （这可能会进一步改进，但这取决于该方法的语义以及它“存在”的位置。）

总而言之，BasicAction 的主要代码如下所示

BasicAction action = mapping.get(actionName);

// (It's a shame that these need the initial assignment to null due to being
//  referenced in the finally block - it's pretty ugly)
TrafficManager tMan = null;
CargoManager cMan = null;
try {
  tMan = createTrafficManager();
  cMan = createCargoManager();
  action.execute(request, tMan, cMan);//Handle the http request from the JSP page
} catch (Exception ex) {
  // Handle here any exceptions
} finally {
  if (tMan != null) {
    removeManager(tMan); // Is this necessary, did it get registered somewhere after creation?
    tMan.close(); // If they're closeable
  }
  if (cMan != null) { 
    // Of course this block could be a tiny method to further remove duplication,
    // so long as you have a common superinterface for both *Manager classes
    removeManager(cMan);
    cMan.close();
  }
}