【51CTO精選譯文】Listener，直譯為偵聽器或監聽器，在面向對象的開發中經常需要用到。如果你需要啟動或者停止基于Java的Web系統中不同部分的代碼，那么你可以使用一個簡單的ServletContentListener來監聽容器（container）里面的啟動事件和停止事件。這個監聽器可以使用java.util.ServiceLoader去尋找這些被偵聽事件所對應的已注冊類。

這個方法不錯，但是如果添加一個編譯時間注釋處理器會不會更好呢？如果你用@Lifecycle(LifecycleEvent.STARTUP)注釋一個靜態方法，它將會在開機的時候被調用（在關機的時候被關掉）。處理器會產生類，并為了ServiceLoader而注冊它們。你也可以把同樣的機制用在任何事件總線（event-bus）模型上：在編譯的時候注冊listener，并且帶有注釋，當事件被觸發的時候總線會自動調用他們。從本質上講，你可以通過注釋實現用ServiceLoader在運行時間自動發現代碼。

實際過程中，其概念如下：

1. 你用@EventListener對方法進行注釋（可能包含一些元信息（meta-info））。

2. 注釋處理器為每個@EventListener方法生成一個EventDispatcher，包括注釋中元信息需要的過濾器。

3.  事件總線利用java.util.ServiceLoader找到EventDispatcher的實現。

當EventBus.dispatch被調用時，任何有興趣的、已經用@EventListener注釋的方法都會被調用。

本文將對事件總線創建的幾個必要步驟進行分析，從而闡明這一概念。事件總線不需要任何手動注冊就可以調用已注釋了的listener方法。我們將從Eventbus開始討論，然后是注釋處理器，***是一個用法實例。

組織你的代碼

這個例子的代碼包含兩個單獨的IDE工程

◆EventBus ——包含了事件總線以及注釋處理器

◆EventBusExample ——包含了一個使用事件總線的例子

當操作注釋處理器的時候，你應該在IDE選項中關閉"Compile on Save"（或者其他等同的選項）。這些選項可能會刪除注釋處理器所生成的類，讓你摸不著頭腦。

以下內容將會解釋這些工程中的代碼是如何工作的，而且為了便于說明還提供了一些程序片段。

注釋和事件

你需要的***個東西是一個@EventListener注釋，用來標識那些偵聽事件的方法。下面是一個EventListener注釋的例子，它只能用來注釋方法。在代碼編譯后它將被拋棄，因為所有的處理都是對源代碼進行的。

@Target(ElementType.METHOD)  
@Retention(RetentionPolicy.SOURCE)  
public @interface EventListener {  
    String name() default ".*";  
    Class<?> source() default Object.class;  
}  
 

由于這個例子是一個事件總線模型，那么listener方法***只接受它們唯一感興趣的事件。為了便于執行這個規則，在BusEventObject類中包含了你想過濾的名字（以@EventListener注釋里面的名字為基礎）。為了讓過濾事件更加簡單，這個普通的EventObject類中還有一個附加的名字域。BusEventObject也作為一個標識，可以標識出通過EventBus分派的事件。

public abstract class BusEventObject extends EventObject {  
    private final String name;  
    public BusEventObject(  
            final Object source,  
            final String name) {  
        super(source);  
        if(name == null || name.isEmpty()) {  
            throw new IllegalArgumentException("empty or null name");  
        }  
        this.name = name;  
    }  
    public String getName() {  
        return name;  
    }  
}  
 

注釋處理器

為了開始寫注釋處理器，你首先應該熟悉javax.annotation.processing 和 javax.lang.model的包組。一般來說，你可以直接掠過執行處理器接口，進入抽象類javax.annotation.processing.AbstractProcessor。AbstractProcessor需要一些關于實現的信息，這些信息用來提供注釋。例子中的EventListenerAnnotationProcessor代碼聲明如下所示：

@SupportedSourceVersion(SourceVersion.RELEASE_5)  
@SupportedAnnotationTypes(EventListenerAnnotationProcessor.ANNOTATION_TYPE)  
public class EventListenerAnnotationProcessor extends AbstractProcessor {  
 

@SupportedSourceVersion告訴AbstractProcessor你只想要用java5或者更高版本寫的源文件；而@SupportedAnnotationTypes告訴AbstractProcessor哪個注釋是你感興趣的（EventListener.class.getName()不會作為一個注釋值起作用，因為編譯器不能計算這種表達式的值）。

public static final String ANNOTATION_TYPE = "eventbus.EventListener";  
 

為了簡單起見，注釋處理器被分成兩個主要的類（EventListenerAnnotationProcessor 和EventDispatcherGenerator）以及一個通用工具類(ServiceRegistration)。為了便于編譯器注釋工具執行EventListenerAnnotationProcessor，你需要用一個服務文件來注冊它（編譯器也使用ServiceLoader）。

eventbus.processor.EventListenerAnnotationProcessor

服務注冊文件(META-INF/services/javax.annotation.processing.Processor)是根據ServiceLoader一定能找到的接口來命名的。

EventListenerAnnotationProcessor.process()方法的***個行動就是找到這輪編譯中所有的@EventListener方法。

final Elements elements = processingEnv.getElementUtils();  
final TypeElement annotation = elements.getTypeElement(ANNOTATION_TYPE);  
final Set<? extends Element> methods =  
        roundEnv.getElementsAnnotatedWith(annotation);  
 

Element對象很像編譯器以及注釋處理器的反射對象（reflection objects）。TypeElement就像是類，而ExecutableElement跟構造器或者方法類似。RoundEnvironment（代表本輪注釋處理）將會返回到被@EventListener 注釋的Element。

EventDispatcherGenerator

EventDispatcherGenerator是一個非常簡單的代碼生成器。你可能更喜歡用模板（比如FreeMarker 或者Velocity）來生成你的源代碼，但是這個例子中的代碼是用PrintWriter寫的。每個代表@EventListener注釋方法的ExecutableElementEvent被傳遞到DispatcherGenerator.generate，它可以給EventDispatcher寫出源代碼。

for(final Element m : methods) {  
    // ensure that the element is a method  
    if(m.getKind() == ElementKind.METHOD) {  
        final ExecutableElement method = (ExecutableElement)m;  
        results.add(generator.generate(method));  
    }  
}  
 

該EventDispatcherGenerator需要為每個方法產生一個Java源文件。一個注釋處理器用ProcessingEnvironment提供的過濾目標來創建用于編寫代碼的源文件。

final JavaFileObject file = processingEnvironment.getFiler().createSourceFile(  
        className, // ie: com.mydomain.example.OnMessageDispatcher  
        method);     // ie: com.mydomain.example.Listener.onMessage(MessageEvent)  
 

在這個例子中，給定的過濾器ExecutableElement代表了已經注釋的方法（createSourceFile中的第二個觀點）。這會告訴環境你正在生成跟那個方法相關的源代碼，雖然不是必須的，但是比較有用。然后代碼用JavaFileObject來打開一個書寫器，并開始生成源代碼。

final Writer writer = file.openWriter();  
final PrintWriter pw = new PrintWriter(writer);  
pw.append("package ").append(packageName).println(';');  
 

在@EventListener注釋中為方法指定值，從而在調用注釋方法之前產生一個if 語句，這個if語句可以過濾BusEventObjects。EventDispatcherGenerator把if 語句寫進源代碼，從而決定是否把事件對象分派到@EventListener方法中去。

public final class EventBus {  
    private static final EventDispatcher[] DISPATCHERS;  
    static {  
        final ServiceLoader<EventDispatcher> loader =  
                ServiceLoader.load(EventDispatcher.class);  
        final List<EventDispatcher> list = new ArrayList<EventDispatcher>();  
        for(final EventDispatcher dispatcher : loader) {  
            list.add(dispatcher);  
        }  
        DISPATCHERS = list.toArray(new EventDispatcher[list.size()]);  
    }  
    private EventBus() {  
    }  
    public static void dispatch(final BusEventObject object) {  
        if(object == null) {  
            throw new IllegalArgumentException("null event object");  
        }  
        for(final EventDispatcher dispatcher : DISPATCHERS) {  
            dispatcher.dispatch(object);  
        }  
    }   
    public static interface EventDispatcher {  
   
        void dispatch(BusEventObject object);  
    }  
}  
 

#p#

對EventDispatcher進行注冊

對于生成EventDispatcher來說，***的工作就是在一個服務文件中把它們全部列出，這樣在EventBus初始化的時候ServiceLoader能夠找得到它們。這個過程有幾個技巧。注釋處理器會給你一個列表，上面只列出了目前編譯中的方法。如果開發人員不想馬上編譯他們的所有代碼，那么處理器代碼需要跟蹤已經編譯好了的和那些正在編譯的方法。這便是ServiceRegistration類所要做的工作。

首先，你需要告訴ServiceRegistration來讀在源路徑或者類輸出目錄中現存的服務文件。接下來，你添加新編譯的EventDispatcher類，然后把新的服務文件寫到類的輸出目錄中。

final AnnotationHelper annotation = new AnnotationHelper(  
                method,  
                EventListenerAnnotationProcessor.ANNOTATION_TYPE,  
                environment.getElementUtils());  
   
final String nameFilter = (String)annotation.getValue("name");  
final TypeElement sourceFilter = (TypeElement)environment.getTypeUtils().  
        asElement((TypeMirror)annotation.getValue("source"));  
   
pw.println("\tpublic void dispatch(eventbus.BusEventObject event) {");  
   
pw.print("\t\tif(event instanceof ");  
pw.println(eventType.getQualifiedName());  
pw.println("\t\t\t\t&& nameFilter.matcher(event.getName()).matches()");  
pw.append("\t\t\t\t&& event.getSource() instanceof ").  
        append(sourceFilter.getQualifiedName()).println(") {");  
 

把所有的東西放在一起

EventBus工程的結果是一個簡單的JAR文件，既有編譯時間又有運行時間代碼（盡管你可以把它分解成兩個JAR文件）。現在你需要寫一個BusEventObject的子類，它可以通過EventBus被分派到listener。你還需要一個@EventListener方法，來接受你的新事件類的實例。***：你需要一個類來分派事件（從一個源文件）。

為了驗證@EventListener方法生成了一個EventDispatcher，你需要讓編譯器知道運行EventListenerAnnotationProcessor。這個過程根據IDE的不同而不同，但是驗證了JAR文件是在類路徑上或者在你工程庫里已經足夠了。在一些IDE里，你需要對注釋處理器進行手動注冊。而這個例子中，MessageEvent類將通過事件總線來分派：

public class MessageEvent extends BusEventObject {  
    private final String message;  
    // constructor, etc.  
    public String getMessage() {  
        return message;  
    }  
}  
 

你需要一個@EventListener來接受MessageEvent對象，并進行一些處理。請記住，你可以在任何類中進行這樣的操作，只要注釋處理器有機會看代碼。比如本例，代碼打開了一個帶有消息的JoptionPane：

@EventListener 
public static void onMessage(final MessageEvent event) {  
    JOptionPane.showMessageDialog(  
            null,  
            event.getMessage(),  
            "Message Event",  
            JOptionPane.INFORMATION_MESSAGE);  
}  
 

這個listener MessageListener是一個包羅萬象的listener，可以接受所有通過事件總線分派過來的MessageEvent對象。

剩下唯一需要做的事情就是通過EventBus來分派MessageEvent：

EventBus.dispatch(new MessageEvent(  
        this,  
        "message",  
        "Hello World!"));  
 

MessageEvent構造器接管了事件的源，事件名字，以及消息。這個事件將去向任何由@EventListener注釋的方法，并接受MessageEvent作為他們的參數。

輸出文件在哪里？

#t#當你完成編譯代碼以后，看看創建目錄。在每個帶有@EventListener方法的類文件旁邊，那里應該有*EventDispatcher Java源文件以及生成的類文件。如果那些文件不在那里，請確保你已經設置了你的創建目錄環境，以便于EventListenerAnnotationProcessor對于編譯器以及注釋處理工具是可見的（你可以回去參考"組織你的代碼"那一節）。

我希望，你會發現使用ServiceLoader注釋讓你的生活更輕松。

原文：Implement Automatic Discovery in Your Java Code with Annotations  作者：Jason Morris