我怎樣才能讓它更具可讀性和清潔度？

Question

我想知道我能做些什么才能讓它更具可讀性和清潔性。 通過可讀，我的意思是更容易閱讀其他開發人員。

我真的不想兩次使用相同的代碼。 我想我可以制作一些方法或方法來縮短它，但我不確定......

@Override
public void dispatchEvent(Event event) {
    checkNotNull(event);

    CancellableEvent cancellableEvent = null;
    boolean cancellable;
    if (cancellable = event instanceof CancellableEvent) {
        cancellableEvent = (CancellableEvent) event;
        checkArgument(cancellableEvent.isCancelled());
    }

    // Ignore-cancellation event handlers will run
    for (EventPriority priority : EventPriority.values()) {
        Map<Method, EventListener> internalMapping = getRegistry().getMethodMap(event.getClass(), priority, true);
        if (internalMapping != null) {
            for (Entry<Method, EventListener> entry : internalMapping.entrySet()) {
                try {
                    entry.getKey().invoke(entry.getValue(), event);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    /*
                     * Delegate any exceptions that occur from
                     * the method to a runtime exception.
                     */
                    throw new RuntimeException(e);
                }
            }
        }
    }

    // Event handlers that consider cancellation will run
    for (EventPriority priority : EventPriority.values()) {
        Map<Method, EventListener> internalMapping = getRegistry().getMethodMap(event.getClass(), priority, false);
        if (internalMapping != null) {
            for (Entry<Method, EventListener> entry : internalMapping.entrySet()) {
                try {
                    entry.getKey().invoke(entry.getValue(), event);
                } catch (IllegalAccessException e) {
                    e.printStackTrace();
                } catch (IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    /*
                     * Delegate any exceptions that occur from
                     * the method to a runtime exception.
                     */
                    throw new RuntimeException(e);
                }
                // Immediately return in the case of the event being cancelled.
                if (cancellable && cancellableEvent.isCancelled()) {
                    return;
                }
            }
        }
    }
}

Answer 1

如果您正在討論異常，那么在Java 7中您可以使用異常。

這是關於使用Java7異常的文章

} catch (ParseException | IOException exception) {
// handle I/O problems.
}

關於迭代，您可以使用單獨的方法來調用功能。

Answer 2

有什么建議讓一些代碼更具可讀性？ 很長一段時間都知道好的和干凈的代碼之一：類應該盡可能小，方法應該盡可能小。

假設你可以做一些“提取方法”重構和提取，例如：

processIgnoreCancellationEventHandlers（）; processEventHandlersWithPossibleCancellation（）;

如果可能的話，我會更進一步，使用不同的輸入參數制作一個方法，例如：

processEventHandlers（noCancellationEventHandlers）; processEventHandlers（CancellationAwareEventHandlers）;

這樣你就會有兩個成就：

• 更簡單，簡潔，可讀的代碼，
• 沒有重復。

Answer 3

沒有更多的背景很難知道，但這里有一些想法。

• 您的for (Entry<Method, EventListener> entry : internalMapping.entrySet()) { loop似乎對於兩個循環都是相同的。 我會把它放到它自己的方法中。 它將采用Map ，它將完成整個循環。 那么你們兩個for循環會小得多。

   private void runMap(Map<Method, EventListener> methodMap) { for (Entry<Method, EventListener> entry : methodMap.entrySet()) { ... } } 

  然后你可以做一個循環：

   for (EventPriority priority : EventPriority.values()) { runMap(getRegistry().getMethodMap(event.getClass(), priority, true)); runMap(getRegistry().getMethodMap(event.getClass(), priority, false)); } 

• 當你在循環中做一些if (internalMapping != null) {包含整個循環然后我傾向於使用if (internalMapper == null) continue; 。 這減少了縮進級別。

• 已經提到了異常處理。 您還可以先處理InvocationTargetException ，然后在它下面catch (Exception e) ，以便打印出所有其余部分。

Answer 4

我假設你真正想做的就是消除這兩個循環。 我只是強制它並提取一個包含所有必要參數的方法，例如：

  @Override
  public void dispatchEvent(Event event) {
      checkNotNull(event);

      CancellableEvent cancellableEvent = null;
      boolean cancellable;
      if (cancellable = event instanceof CancellableEvent) {
          cancellableEvent = (CancellableEvent) event;
          checkArgument(cancellableEvent.isCancelled());
      }

     fireEvents(false, event, cancellableEvent, cancellable);
     fireEvents(true, event, cancellableEvent, cancellable);

  }

  private void fireEvents(boolean considerCancellation, Event event, CancellableEvent cancellableEvent, boolean cancellable)
  {
     // Event handlers that consider cancellation will run
     for (EventPriority priority : EventPriority.values()) {
         Map<Method, EventListener> internalMapping = getRegistry().getMethodMap(event.getClass(), priority, ! considerCancellation);
         if (internalMapping != null) {
             for (Map.Entry<Method, EventListener> entry : internalMapping.entrySet()) {
                 try {
                     entry.getKey().invoke(entry.getValue(), event);
                 } catch (IllegalAccessException e) {
                     e.printStackTrace();
                 } catch (IllegalArgumentException e) {
                     e.printStackTrace();
                 } catch (InvocationTargetException e) {
                     /*
                      * Delegate any exceptions that occur from
                      * the method to a runtime exception.
                      */
                     throw new RuntimeException(e);
                 }
                 // Immediately return in the case of the event being cancelled.
                 if ( considerCancellation && cancellable && cancellableEvent.isCancelled()) {
                     return;
                 }
             }
         }
     }
  }

然后你可以重構新的fireEvents方法並清理它。

Answer 5

永遠不要在if條件下進行分配。 這很容易出錯：

if (cancellable = event instanceof CancellableEvent) {
    ...
}

這樣做：

boolean cancellable = event instanceof CancellableEvent;
if (cancellable) {
    ...
}

Answer 6

您可以將條目的調用重構為另一種方法。

private final void invokeEntry(Entry<Method, EventListener> entry, Event event) {
    try {
        entry.getKey().invoke(entry.getValue(), event);
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (IllegalArgumentException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        /*
         * Delegate any exceptions that occur from
         * the method to a runtime exception.
         */
        throw new RuntimeException(e);
    }
}

然后你可以用這個替換你的dispatchEvent方法：

@Override
public void dispatchEvent(Event event) {
    checkNotNull(event);

    CancellableEvent cancellableEvent = null;
    boolean cancellable;
    if (cancellable = event instanceof CancellableEvent) {
        cancellableEvent = (CancellableEvent) event;
        checkArgument(cancellableEvent.isCancelled());
    }

    // Ignore-cancellation event handlers will run
    for (EventPriority priority : EventPriority.values()) {
        Map<Method, EventListener> internalMapping = getRegistry().getMethodMap(event.getClass(), priority, true);
        if (internalMapping != null) {
            for (Entry<Method, EventListener> entry : internalMapping.entrySet()) {
                invokeEntry(entry, event);
            }
        }
    }

    // Event handlers that consider cancellation will run
    for (EventPriority priority : EventPriority.values()) {
        Map<Method, EventListener> internalMapping = getRegistry().getMethodMap(event.getClass(), priority, false);
        if (internalMapping != null) {
            for (Entry<Method, EventListener> entry : internalMapping.entrySet()) {
                invokeEntry(entry, event);
                // Immediately return in the case of the event being cancelled.
                if (cancellable && cancellableEvent.isCancelled()) {
                    return;
                }
            }
        }
    }
}

Answer 7

由於除了一個布爾值之外的循環是相同的，我首先將它們分開，然后根據需要進一步分解它們。

@Override
public void dispatchEvent(Event event) {
    checkNotNull(event);
    CancellableEvent cancellableEvent = null;
    boolean cancellable;
    if (cancellable = event instanceof CancellableEvent) {
        cancellableEvent = (CancellableEvent) event;
        checkArgument(cancellableEvent.isCancelled());
    }
    handleEvents(event, true);
    handleEvents(event, false, cancellableEvent);
}

public void handleEvents(Event event, boolean cancellable)
{
    handleEvents(event, cancellable, null);
}

public void handleEvents(Event event, boolean cancellable, CancellableEvent cancellableEvent)
{
    for (EventPriority priority : EventPriority.values()) {
        Map<Method, EventListener> internalMapping = getRegistry().getMethodMap(event.getClass(), priority, cancellable);
        if (internalMapping != null) {
            for (Entry<Method, EventListener> entry : internalMapping.entrySet()) {
                try {
                    entry.getKey().invoke(entry.getValue(), event);
                } catch (IllegalAccessException | IllegalArgumentException e) {
                    e.printStackTrace();
                } catch (InvocationTargetException e) {
                    /*
                    * Delegate any exceptions that occur from
                    * the method to a runtime exception.
                    */
                    throw new RuntimeException(e);
                }
                // Immediately return in the case of the event being cancelled.
                if (cancellableEvent != null && cancellable && cancellableEvent.isCancelled()) {
                    return;
                }
            }
        }
    }
}