Java重构代码重复

Question

我有很多重复的代码，但我不知道如何正确重构它。

我有一个类Foo，它解析从套接字接收的网络消息/数据并调用相应的onEvent() 方法。 Foo 纯粹是一个网络消息的解析器，它没有关于它接收到的事件采取什么行动的逻辑。谁想要添加这样的逻辑必须继承Foo 并覆盖onEvent() 方法。

abstract class Foo {
    void processNetwotkMessage(String message) {
        ...
        onEvent1(arg1, arg2, arg3)
        reutn;
        ...
        onEvent2(arg4);
        return;
        ...
        onEvent3()
        return;
        ...
        onEvent999(arg1337);
    }

    abstract protected void onEvent1(Arg1 arg1, Arg2 arg2, Arg3 arg3);
    abstract protected void onEvent2(Arg4 arg4);
    abstract protected void onEvent3();
    ...
    abstract protected void onEvent999(Arg1337 arg1337);
}

现在，我的程序应该是模块化的，我有许多单独的模块类想要接收这些事件并处理它们。模块实现Plugin 接口。该接口匹配来自Foo 的onEvent() 方法，但添加了PluginContext ctx 作为第一个参数。

interface Plugin {
    void onEvent1(PluginContext ctx, Arg1 arg1, Arg2 arg2, Arg3 arg3);
    void onEvent2(PluginContext ctx, Arg4 arg4);
    void onEvent3(PluginContext ctx);
    ...
    void onEvent999(PluginContext ctx, Arg1337 arg1337);
}

现在，为了将事件分派给模块，我创建了 Foo 的模块感知子类，名为 PluginSupporingFoo。

class PluginSupporingFoo extends Foo implements PluginContext {
    List<Plugin> plugins;

    @Override
    protected void onEvent1(Arg1 arg1, Arg2 arg2, Arg3 arg3) {
        synchronized (plugins) {
            for (Plugin p : plugins) {
                p.onEvent1(this, arg1, arg2, arg3);
            }
        }
    }

    @Override
    protected void onEvent2(Arg4 arg4) {
        synchronized (plugins) {
            for (Plugin p : plugins) {
                if (PluginIsAllowedToBeAwareOfThisEvent(p, arg4)) {
                    p.onEvent2(this, arg4);
                }
            }
        }
    }

    @Override
    protected void onEvent3() {
        synchronized (plugins) {
            for (Plugin p : plugins) {
                p.onEvent3(this);
            }
        }
    }

    ...

    @Override
    protected void onEvent999(Arg1337 arg1337) {
        synchronized (plugins) {
            for (Plugin p : plugins) {
                p.onEvent999(this, arg1337);
            }
        }
    }
}

如您所见，每当Foo 调用onEvent() 方法之一时，来自PluginSupporingFoo 的被覆盖方法被调用，然后它通过调用@987654339 的相应onEvent() 方法将此事件分派给所有模块@interface，增加了一个额外的参数——PluginContext ctx。有时还有一个条件是否告诉模块一个事件，就像你在PluginSupporingFoo.onEvent2()中看到的那样。

现在，我想删除很多重复的代码。

1. 首先，Plugin 接口和Foo 类具有几乎相同的方法。实际上，Plugin 接口需要具有 Foo 具有的所有 onEvent 方法，但 PluginContext ctx 作为额外的第一个参数。

2. 另一个代码重复在PluginSupporingFoo。所有onEvent() 方法几乎都是彼此的副本：

.

protected void on${EventName} ( ${ArgList} ) {
    synchronized (plugins) {
        for (Plugin p : plugins) {
            ${ OPTIONAL: if (filter(p, ${ArgList}.arg1)) { }
                p.on{EventName}(this, ${ArgList}.allArgs);
            ${ OPTIONAL: } }
        }
    }
}

鉴于onEvent 方法有很多，拥有如此多的复制粘贴代码令人沮丧，而且如果需要，很难全部修改它们。

Answer 1

哇...这是一个糟糕的设计，有 eventXX( foo, bar, baz) 等，因为每次添加新事件时，都必须添加相应的侦听器方法。

也许更好的设计是重构它，以便您的 Foo 类只有少数或理想情况下有一个采用新 Event 接口的 onEvent() 方法

public class Foo{

  void onEvent(Event e){ ... }

} 

public interface Event{
     Object[] getArgs();

     //other Event specific methods
     ...
}

那么每个eventXX 方法将是Event 接口的新实现。

public class Event2 implements Event{

   public Object[] getArgs(){
       //Arg4 like in your code
       return new Object[]{ new Arg4() };
   }
}

插件也可以同样只有一种方法

interface Plugin{

   onEvent(PluginContext ctx, Event e);

}

现在，当您需要添加一个新事件时，它只是一个新的事件实现，这些接口不需要任何额外的方法。

处理程序可以检查事件的类型，或者您可以根据需要制作EventType 或其他类型的鉴别器。

 class MyPlugin implements Plugin{
     public void onEvent(PluginContext ctx, Event e){
         //this is only useful if we only care about a few types
         if( e instanceOf Event2){
            //we know this is Arg4
            Arg4 arg4 = (Arg4) e.getArgs()[0];
            ...
         }

     }
 }

现在有了 Java Lambda，我们甚至可以拥有一个处理程序 Map<Class<? extends Event>, Function>，如果你想花哨的话。