Question

我正在尝试重构一段代码，如下所述：

原始代码：

Method(URL link)
{
    if(ConditionA(link))
    {
      MehodA(link);
    }else if(ConditionB(link))
    {
      MehodB(link);
    }else if(ConditionC(link))
    {
      MehodC(link);
    }else if(ConditionD(link))
    {
      MehodD(link);
    }
}

上述代码可能会随着未来可能出现的新情况而增长。在重构之后，我能够将代码分成多个类，每个类都以单一责任为重点，因此降低了初始复杂性，如下所示：

重整后：

METHOD(URL link)
{
  ConditionalHandlerClass obj = new ConditionalHandlerClass(link);
  ConditionalHandlerClass.HandleLinkProcessing();
}

Class ConditionalHandlerClass
{
  URL link;
  IConditionalProcess process;

  public ConditionalHandlerClass(URL _link)
  {
    link = _link;
  }

  public void HandleLinkProcessing()
  {
     if(ConditionA(link))
        {
          process = new ProcessA(link);
        }else if(ConditionB(link))
        {
          process = new ProcessB(link);
        }else if(ConditionC(link))
        {
         process = new ProcessC(link);
        }else if(ConditionD(link))
        {
         process = new ProcessD(link);
        }
    process.Handle();
  }
}

interface IConditionalProcess
{
  void handle();
}


class ProcessA() : IConditionalProcess
{
   void handle()
  {
   // Business Logic here
  }
}

class ProcessB() : IConditionalProcess
{
   void handle()
  {
   // Business Logic here
  }
}

class ProcessC() : IConditionalProcess
{
   void handle()
  {
   // Business Logic here
  }
}

class ProcessD() : IConditionalProcess
{
   void handle()
  {
   // Business Logic here
  }
}

但是我发现ConditionalHandlerClass类中的HandleLinkProcessing（）方法仍然会随着新条件的不断增加而继续增加。

您能否建议如何更好地实现此实现，以便在添加新的ConditionE（）和MethodE（）调用流时不应更改类似ConditionalHandlerClass的类。因此，即使新条件被添加，也会降低一次类的复杂性。

我在目标c中编写此代码。

Answer 1

我认为你走在正确的轨道上。当然，处理可以通过无数种方式完成（并且通过DI构建器注入，如果它不需要处理大多数），但这里有一种方法，它使用条件和执行逻辑组成Handler类的可重用实例。

public interface IConditional
{
    bool Evaluate(Url link);
}

public class ConditionA : IConditional
{
    public bool Evaluate(Url link)
    {
        return true; // your conditional logic here
    }
}

public class ConditionB : IConditional
{
    public bool Evaluate(Url link)
    {
        return true; // your conditional logic here
    }
}

public class ConditionC : IConditional
{
    public bool Evaluate(Url link)
    {
        return true; // your conditional logic here
    }
}

public class ConditionD : IConditional
{
    public bool Evaluate(Url link)
    {
        return true; // your conditional logic here
    }
}

public interface IProcessor
{
    void Process(Url link);
}

public class MethodA : IProcessor
{
    public void Process(Url link)
    {
        // whatever A does?
    }
}

public class MethodB : IProcessor
{
    public void Process(Url link)
    {
        // whatever B does?
    }
}

public class MethodC : IProcessor
{
    public void Process(Url link)
    {
        // whatever C does?
    }
}

public class MethodD : IProcessor
{
    public void Process(Url link)
    {
        // whatever D does?
    }
}

public class Handler
{
    private IConditional conditional;
    private IProcessor processor;

    public Handler(
        IConditional conditionalReference,
        IProcessor processorReference)
    {
        this.conditional = conditionalReference;
        this.processor = processorReference;
    }

    public bool Handle(Url link)
    {
        bool handled = false;
        if (this.conditional.Evaluate(link)
        {
            this.processor.Process(link);
            handled = true;
        }

        return handled;
    }
}

public class Program
{
    public static void Main()
    {
        Handler[] orderedHandlers = new []
        {
            new Handler(new ConditionA(), new MethodA()),
            new Handler(new ConditionB(), new MethodB()),
            new Handler(new ConditionC(), new MethodC()),
            new Handler(new ConditionD(), new MethodD()),
        };

        Url link = new Url("xxx");

        foreach(Handler handler in orderedHandlers)
        {
            if(handler.Handle(link))
            {
                break;
            }
        }
    }
}

Answer 2

一种可能的方法是保留Predicate<URL>和Consumer<URL>对的集合。这样的结构可能是LinkedHashMap，它保持了插入顺序。

LinkedHashMap<Predicate<URL>, Consumer<URL>> ops = new LinkedHashMap<> {{ 
    put(::ConditionA, ::MethodA); 
    put(::ConditionB, ::MethodB); .... 
}}

void processURL(URL link) {
     for(Map.Entry<...,...> entry : ops.entrySet()) {
          if (entry.getKey().test(link)) {
               entry.getValue().accept(link);
               break;
          }
     }
}

编辑：当我写答案时，标签Java消失了。然而，我不是目标C流利的，主要语言不可知。

Answer 3

可能会为处理程序引入策略并只是迭代它们。处理程序列表可以在运行时或某些静态上下文中初始化，但至少可以避免创建mega-if-construct

编辑抱歉我的Java伪代码...

interface LinkHandler() {

  boolean accepts(URL link);

  void handle(URL link);
}

public static void main( ...) {
  List<LinkHandler> handlers = ...

  URL urlToCheck = new URL( ... );

  for( LinkHandler handler : handlers ) {
     if( handler.accepts(urlToCheck) ) {
       handler.handle(urlToCheck);
       break;
     }
   }
}

更好地重构代码的条件部分的方法

3 个答案: