Question

我有以下Java方法：

public ERROR myMainMethod() {
  ERROR ret = invokeFirstSub();
  if (ret != ERROR.NO_ERROR) {
    return ret;
  }
  ret = invokeSecondSub();
  if (ret != ERROR.NO_ERROR) {
    return ret;
  }
  // you get the rest
}

基本上，在每次子调用之后，我们检查返回值并在发生任何错误时退出。怎么重构？第一个想法是将整个调用序列放在try-catch循环中，使用asserts并捕获第一个AssertionError，但我发现它并不优雅。什么是好的做法？

Answer 1

根据重构良好做法，可能会有两项改进：

避免使用多个return语句（使得具有多个return语句的大型方法的代码可读性变得笨拙）
尽可能封装逻辑，即在ERROR枚举中将错误检查逻辑移动为方法isError()

public ERROR myMainMethod（）{

ERROR ret = invokeFirstSub（）;

ret =（ret.isError（））？ ret：invokeSecondSub（）;

ret =（ret.isError（））？ ret：invokeThirdSub（）;

//等等，最后

ret =（ret.isError（））？ ret：ERROR.NO_ERROR;

//你得到其余的

返回; }

此外，正如所指出的那样，策略模式可能适合您的情况，即管理每个类别的子类或类中的所有子类型。

Answer 2

如果您的设计允许，您可以实施Strategy pattern：

public interface CheckStrategy {
    ERROR invoke();
}

public class FirstCheck implements CheckStrategy {
    ERROR invoke() {
        // do something
    }
}

public class SecondCheck implements CheckStrategy {
    ERROR invoke() {
        // do something
    }
}
[...]

你的主要方法：

public ERROR myMainMethod() {
    List<CheckStrategy> checks = new ArrayList<CheckStrategy>();
    checks.add(new FirstCheck());
    checks.add(new SecondCheck());
    [...]

    ERROR ret = ERROR.NO_ERROR;
    for(CheckStrategy check : checks) {
        ret = check.invoke();
        if(ret != ERROR.NO_ERROR) {
            break;
        }
    }

    return ret;
}

Answer 3

其中一个解决方案是使用AOP。根据您的技术堆栈，您可以使用Spring AOP，Guice AOP甚至原始AspectJ轻松实现目标。

这个想法是定义一个拦截器，它拦截某些方法并在方法之前和/或之后执行自定义逻辑。

每步后检查错误值

3 个答案: