Question

我有一个带有methodA的类，它具有以下结构

function methodA() {
  $providers = $this->getFirstSetOfProviders();
  foreach ($providers as $provider) {
    try {
      $this->method1($provider);
    } catch ( Exception $e ) {
      // exception handling
    }
  }

  $providers = $this->getSecondSetOfProviders();
  foreach ($providers as $provider) {
    try {
      $this->method2($provider);
    } catch ( Exception $e ) {
      // exception handling
    }
  }
}

catch子句的内容是相同的。有没有办法组织代码以避免重复嵌套在foreach循环中的try / catch结构？从概念上讲，我正在尝试

function methodA() {
  foreach ($providers as $provider) {
    $method1 = function($provider) {
      $this->method1($provider);
    }
    $this->withTryCatch($method1);
  }
  ...
}

function withTryCatch($method) {
  try {
    $method;  // invoke this method somehow
  } catch (Exception $e) {
    // exception handling
  }
}

这与Code sandwich类似，但我不知道如何继续使用php。

更新： try / catch嵌套在foreach循环中，这样当抛出异常时，它会被处理，执行继续循环中的下一次迭代，而不是终止循环。

Answer 1

Exceptions的好处在于它们是可以像其他任何一样传递的对象。因此，您可以删除重复的代码（基本样板除外）而不会改变太多：

foreach ($providers as $provider) {
    try {
      $this->method1($provider);
    } catch ( Exception $e ) {
      $this->handleException($e);
    }
}

注意：如果您还需要在异常处理中使用某些上下文（例如$provider），则只需提供handleException()个参数。

第2部分：重构整个方法

您想知道如何进一步删除重复。我不知道这在你的实际代码中是否有意义，它也可能过度工程化。你必须自己决定。以下是模板方法模式的实现。原谅粗略的命名，但我试着效仿你的榜样，我不知道你在做什么。

abstract class ClassThatDoesThingsWithProviders
{
    public function methodA($providers)
    {
        foreach($provicers as $provider) {
            try {
                $this->methodThatActuallyDoesSomethingWithProvider($provider);
            } catch(Exception $e) {
                $this->handleException($e);
            }
        }
    }
    protected function handleException(Exception $e)
    {
        // handle exception
    }
    abstract protected function methodThatActuallyDoesSomethingWithProvider($provider);
}
class ClassThatDoesThing1WithProviders extends ClassThatDoesThingsWithProviders
{
    protected function methodThatActuallyDoesSomethingWithProvider($provider)
    {
        // this is your method1()
    }
}
class ClassThatDoesThing2WithProviders extends ClassThatDoesThingsWithProviders
{
    protected function methodThatActuallyDoesSomethingWithProvider($provider)
    {
        // this is your method2()
    }
}

class YourOriginalClass
{
    protected $thingsdoer1;
    protected $thingsdoer2;

    public function __construct()
    {
        $this->thingsdoer1 = new ClassThatDoesThing1WithProviders;
        $this->thingsdoer2 = new ClassThatDoesThing2WithProviders;
    }
    public function methodA()
    {
        $this->thingsdoer1->methodA($this->getFirstSetOfProviders());
        $this->thingsdoer2->methodA($this->getSecondSetOfProviders());
    }
}

您可以轻松地从thingsdoer1和thingsdoer2以及抽象getFirstSetOfProviders和getSecondSetOfProviders旁边制作一个数组。另外我不知道实际的method1和method2实现依赖于什么，也许你不能在没有破坏凝聚力的情况下提取它们。

但由于我不知道你的真实代码以及你在做什么我不能推荐一个具体的策略，以上面的例子为出发点。

Answer 2

function methodA() {
  try {
      $providers = $this->getFirstSetOfProviders();
      foreach ($providers as $provider) {
          $this->method1($provider);
      }

      $providers = $this->getSecondSetOfProviders();
      foreach ($providers as $provider) {
          $this->method2($provider);
      }
  } catch ( Exception $e ) {
    // exception handling
  }

}

php 5.3避免在foreach循环中嵌套try / catch重复（代码三明治）

2 个答案: