Spring 注入的事件监听模式

public interface EventType {
}

public interface Event {
EventType getEventType();
}

public class JointSurveySubmitEvent implements Event {


  private JointSurvey jointSurvey;


  public JointSurveySubmitEvent(JointSurvey jointSurvey) {
    this.jointSurvey = jointSurvey;
  }


  @Override
  public EventType getEventType() {
    return ScheduleEventType.SUBMIT; // 这是一个实现了EventType的枚举
  }


  public JointSurvey getJointSurvey() {
    return jointSurvey;
  }


}

public interface Listener<TEvent extends Event> {
/**
* 
* @return the EventType(s) you are intersted in,mustn't be empty
*/
EventType[] getEventTypes();


/**
* whenever the event that you are interested in published,the method will
* be called
* 
* @param event
*/
void handle(TEvent event);


/**
* you can override this method return true to begin a new Transaction
* 
* or you can add "@Transactional(propagation = Propagation.REQUIRES_NEW)"
* on Listener's handle method
* 
* @return
*/
boolean isInNewTransaction();
}

import com.jsw.common.eventbus.Event;
import com.jsw.common.eventbus.EventPublisher;
import com.jsw.common.eventbus.EventType;
import com.jsw.common.eventbus.Listener;


import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;


import java.text.MessageFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


@Service(value = "eventPublisher")
public class DefaultEventPublisher implements EventPublisher, InitializingBean {
  private final static Log log = LogFactory.getLog(DefaultEventPublisher.class);


  private final static String EVENT_LISTENER_REGISTER_MSG = "Event:{0} register,Listener:{1}";


  private final static String EVENT_PUBLISH_MSG = "Event:{0} fire";


  private final static String EVENT_LISTENER_HANDLE_MSG = "Listener:{0} handle the event:{1}";


  private Map<EventType, List<Listener<Event>>> listeners = new HashMap<EventType, List<Listener<Event>>>();


  @Autowired(required = false)
  private List<Listener<Event>> autowiredListeners = new ArrayList<Listener<Event>>();


  @Autowired
  private TransactionSupport transactionSupport;


  @Override
  public void afterPropertiesSet() throws Exception {
    for (Listener<Event> listener : autowiredListeners) {
      this.register(listener);
    }
  }


  public void publish(Event event) {
    if (log.isTraceEnabled()) {
      log.trace(MessageFormat.format(EVENT_PUBLISH_MSG, getEventTypeMsg(event.getEventType())));
    }


    List<Listener<Event>> myListeners = this.listeners.get(event.getEventType());
    if (myListeners != null) {
      for (Listener<Event> listener : myListeners) {
        if (log.isTraceEnabled()) {
          log.trace(MessageFormat.format(EVENT_LISTENER_HANDLE_MSG, listener.getClass().getCanonicalName(),
              getEventTypeMsg(event.getEventType())));
        }
        if (!listener.isInNewTransaction()) {
          listener.handle(event);
        } else {
          invokeTransactionHandlers(event, listener);
        }


      }
    }
  }


  @SuppressWarnings("rawtypes")
  public void register(Listener listener) {
    assert listener.getEventTypes() != null : "Listener's eventType(s) can't be empty";


    for (EventType eventType : listener.getEventTypes()) {
      this.register(eventType, listener);
    }
  }


  protected void invokeTransactionHandlers(final Event event, final Listener<Event> listener) {
    new Thread() {
      public void run() {
        transactionSupport.handle(listener, event);
      };
    }.start();
  }


  private String getEventTypeMsg(EventType eventType) {
    return eventType.getClass().isEnum() ? eventType + "[" + eventType.getClass().getCanonicalName() + "]" : eventType
        .getClass().getCanonicalName();
  }


  @SuppressWarnings({ "rawtypes", "unchecked" })
  private void register(EventType eventType, Listener listener) {
    if (log.isTraceEnabled()) {
      log.trace(MessageFormat.format(EVENT_LISTENER_REGISTER_MSG, getEventTypeMsg(eventType), listener.getClass()
          .getCanonicalName()));
    }


    List<Listener<Event>> myListeners = this.listeners.get(eventType);
    if (myListeners == null) {
      myListeners = new ArrayList<Listener<Event>>();
      this.listeners.put(eventType, myListeners);
    }


    myListeners.add(listener);
  }

}

//发布事件

eventPublisher.publish(new JointSurveySubmitEvent(jointSurvey));