让代码尝试不同的事情，直到成功为止

Question

这是我第二次编写此类代码，并决定必须有一种更具可读性的方法来完成此任务：

我的代码试图找出一些东西，但定义不明确，或者有很多方法可以完成它。我希望我的代码能够尝试多种方法来解决这个问题，直到成功，或者耗尽策略。但我还没有找到一种方法来使其整洁且可读。

我的具体情况：我需要从接口中找到特定类型的方法。它可以被注释以明确，但它也可以是唯一合适的方法（根据其参数）。

因此，我的代码目前的读法如下：

Method candidateMethod = getMethodByAnnotation(clazz);
if (candidateMethod == null) {
  candidateMethod = getMethodByBeingOnlyMethod(clazz);
}
if (candidateMethod == null) {
  candidateMethod = getMethodByBeingOnlySuitableMethod(clazz);
}
if (candidateMethod == null) {
  throw new NoSuitableMethodFoundException(clazz);
}

必须有更好的方法...

编辑：如果找到，这些方法将返回一个方法，否则null。我可以将其切换为 try/catch 逻辑，但这很难使其更具可读性。

编辑2：不幸的是，我只能接受一个答案:(

Answer 1

让您烦恼的是用于流程控制的重复模式——它应该让您烦恼——但在 Java 中对此没有太多处理方法。

我对重复的代码感到非常恼火。像这样的模式，所以对我来说，提取重复的副本和内容可能是值得的。粘贴控制代码并将其放入它自己的方法中：

public Method findMethod(Class clazz)
    int i=0;
    Method candidateMethod = null;

    while(candidateMethod == null) {
        switch(i++) {
            case 0:
                candidateMethod = getMethodByAnnotation(clazz);
                break;
            case 1:
                candidateMethod = getMethodByBeingOnlyMethod(clazz);
                break;
            case 2:
                candidateMethod = getMethodByBeingOnlySuitableMethod(clazz);
                break;
            default:
                throw new NoSuitableMethodFoundException(clazz);
    }
    return clazz;
}

这种方法的缺点是非常规并且可能更冗长，但优点是没有太多重复代码（更少的拼写错误）并且更容易阅读，因为代码中的混乱程度较少“肉”。

此外，一旦逻辑被提取到它自己的类中，冗长就根本不重要了，阅读/编辑很清晰，对我来说，这给出了（一旦你理解了 while 循环在做什么）

我确实有这个令人讨厌的愿望这样做：

case 0:    candidateMethod = getMethodByAnnotation(clazz);                break;
case 1:    candidateMethod = getMethodByBeingOnlyMethod(clazz);           break;
case 2:    candidateMethod = getMethodByBeingOnlySuitableMethod(clazz);   break;
default:   throw new NoSuitableMethodFoundException(clazz);

突出显示实际正在执行的操作（按顺序），但在 Java 中这是完全不可接受的——您实际上会发现它在其他一些语言中很常见或更受欢迎。

附言。这在 groovy 中是非常优雅的（该死的，我讨厌这个词）：

actualMethod = getMethodByAnnotation(clazz)                   ?:
               getMethodByBeingOnlyMethod(clazz)              ?:
               getMethodByBeingOnlySuitableMethod(clazz)      ?:
               throw new NoSuitableMethodFoundException(clazz) ;

elvis 操作符规则。请注意，最后一行实际上可能不起作用，但如果不起作用，这将是一个微不足道的补丁。

Answer 2

我认为对于一小部分方法来说，你正在做的事情很好。

对于更大的集合，我可能倾向于构建一个责任链，它捕获了基本概念尝试一系列的事情直到其中一个成功。

Answer 3

我不认为这是一个糟糕的做法。它有点冗长，但它清楚地传达了您正在做的事情，并且很容易更改。

不过，如果您想让它更简洁，您可以将方法 getMethod* 包装到实现接口（“IMethodFinder”）或类似接口的类中：

public interface IMethodFinder{
  public Method findMethod(...);
}

然后您可以创建该类的实例，将将它们放入一个集合并对其进行循环：

...
Method candidateMethod;
findLoop:
for (IMethodFinder mf: myMethodFinders){
  candidateMethod = mf.findMethod(clazz);
  if (candidateMethod!=null){
    break findLoop;
  }
}

if (candidateMethod!=null){
  // method found
} else {
  // not found :-(
}

虽然可以说有些复杂，但如果您需要在调用 findMethods* 方法之间做更多工作（例如更多验证该方法是否合适），或者如果查找方法的方法列表可以在运行时配置...

不过，您的方法可能也可以。

Answer 4

我很遗憾地说，但你使用的方法似乎是被广泛接受的方法。我在 Spring、Maven 等大型库的代码库中看到了很多类似的代码。

但是，另一种选择是引入一个帮助器接口，它可以从给定的输入转换为给定的输出。像这样的东西：

public interface Converter<I, O> {
    boolean canConvert(I input);
    O convert(I input);
}

和一个辅助方法

public static <I, O> O getDataFromConverters(
    final I input,
    final Converter<I, O>... converters
){
    O result = null;
    for(final Converter<I, O> converter : converters){
        if(converter.canConvert(input)){
            result = converter.convert(input);
            break;
        }

    }
    return result;
}

那么你就可以编写可重用的转换器来实现你的逻辑。每个转换器都必须实现 canConvert(input) 方法来决定是否使用其转换例程。

实际上：你的请求让我想起的是 Try.these(a,b,c) 方法。

---

您的案例的使用示例：

假设您有一些具有验证方法的 bean。有多种策略可以找到这些验证方法。首先，我们将检查该类型上是否存在此注释：

// retention, target etc. stripped
public @interface ValidationMethod {
    String value();
}

然后我们将检查是否存在名为“validate”的方法。为了让事情变得更容易，我假设所有方法都定义一个对象类型的参数。您可以选择不同的图案。无论如何，这是示例代码：

// converter using the annotation
public static final class ValidationMethodAnnotationConverter implements
    Converter<Class<?>, Method>{

    @Override
    public boolean canConvert(final Class<?> input){
        return input.isAnnotationPresent(ValidationMethod.class);
    }

    @Override
    public Method convert(final Class<?> input){
        final String methodName =
            input.getAnnotation(ValidationMethod.class).value();
        try{
            return input.getDeclaredMethod(methodName, Object.class);
        } catch(final Exception e){
            throw new IllegalStateException(e);
        }
    }
}

// converter using the method name convention
public static class MethodNameConventionConverter implements
    Converter<Class<?>, Method>{

    private static final String METHOD_NAME = "validate";

    @Override
    public boolean canConvert(final Class<?> input){
        return findMethod(input) != null;
    }

    private Method findMethod(final Class<?> input){
        try{
            return input.getDeclaredMethod(METHOD_NAME, Object.class);
        } catch(final SecurityException e){
            throw new IllegalStateException(e);
        } catch(final NoSuchMethodException e){
            return null;
        }
    }

    @Override
    public Method convert(final Class<?> input){
        return findMethod(input);
    }

}

// find the validation method on a class using the two above converters
public static Method findValidationMethod(final Class<?> beanClass){

    return getDataFromConverters(beanClass,

        new ValidationMethodAnnotationConverter(),
        new MethodNameConventionConverter()

    );

}

// example bean class with validation method found by annotation
@ValidationMethod("doValidate")
public class BeanA{

    public void doValidate(final Object input){
    }

}

// example bean class with validation method found by convention
public class BeanB{

    public void validate(final Object input){
    }

}

Answer 5

您可以使用装饰器设计模式来完成查找某些内容的不同方式。

public interface FindMethod
{
  public Method get(Class clazz);
}

public class FindMethodByAnnotation implements FindMethod
{
  private final FindMethod findMethod;

  public FindMethodByAnnotation(FindMethod findMethod)
  {
    this.findMethod = findMethod;
  }

  private Method findByAnnotation(Class clazz)
  {
    return getMethodByAnnotation(clazz);
  }

  public Method get(Class clazz)
  {
    Method r = null == findMethod ? null : findMethod.get(clazz);
    return r == null ? findByAnnotation(clazz) : r;
  } 
}

public class FindMethodByOnlyMethod implements FindMethod
{
  private final FindMethod findMethod;

  public FindMethodByOnlyMethod(FindMethod findMethod)
  {
    this.findMethod = findMethod;
  }

  private Method findByOnlyMethod(Class clazz)
  {
    return getMethodOnlyMethod(clazz);
  }

  public Method get(Class clazz)
  {
    Method r = null == findMethod ? null : findMethod.get(clazz);
    return r == null ? findByOnlyMethod(clazz) : r;
  } 
}

使用方法非常简单

FindMethod finder = new FindMethodByOnlyMethod(new FindMethodByAnnotation(null));
finder.get(clazz);

Answer 6

...我可以将其切换为 try/catch 逻辑，但这很难使其更具可读性。

更改 get... 方法的签名以便可以使用 try / catch 将是一个非常糟糕的主意。异常的代价是昂贵的，并且只能用于“异常”的情况。正如你所说，代码的可读性会较差。

Answer 7

对我来说，它是可读且可以理解的。我只是将代码中丑陋的部分提取到一个单独的方法中（遵循“Robert C.Martin：清洁代码”中的一些基本原则）并添加一些 javadoc（如有必要，请道歉），如下所示：

//...
try {
   Method method = MethodFinder.findMethodIn(clazz);
catch (NoSuitableMethodException oops) {
   // handle exception
}

稍后在 <代码>MethodFinder.java

/**
 * Will find the most suitable method in the given class or throw an exception if 
 * no such method exists (...)
 */
public static Method findMethodIn(Class<?> clazz) throws NoSuitableMethodException {
  // all your effort to get a method is hidden here,
  // protected with unit tests and no need for anyone to read it 
  // in order to understand the 'main' part of the algorithm.
}