public void notifyObservers(Object arg) {
    for (int i = arrLocal.length-1; i>=0; i--){
    	//使用了for循環(huán)同步通知觀察者
    	((Observer)arrLocal[i]).update(this, arg);
    } 
}

public void notifyObservers(Object arg) {
    for (int i = arrLocal.length-1; i>=0; i--){
    	//使用了開啟新線程方式異步通知觀察者
    	new Thread(()->{
    		((Observer)arrLocal[i]).update(this, arg);
		}).start();
    } 
}

//自定義被觀察者
public class MyObservable extends Observable {
    private int data;
    public void setData(int data) {
        this.data = data;
    }
    public void notifyObserver(){
    	//當(dāng)data等于1時通知觀察者
        if (data==1){
            this.setChanged();
            super.notifyObservers();
        }
    }
}
//自定義觀察者
public class MyObserver implements Observer {
    @Override
    public void update(Observable o, Object arg) {
        System.out.println("自定義觀察者執(zhí)行了.....");
    }
}
//測試類
public class PubSubTest {
    public static void main(String[] args) {
        MyObservable observable = new MyObservable();
        observable.addObserver(new MyObserver());
        observable.setData(1);
        observable.notifyObserver();
    }
}

public class EventObject implements java.io.Serializable {
    protected transient Object  source;
    public EventObject(Object source) {
        if (source == null)
            throw new IllegalArgumentException("null source");
        this.source = source;
    }
    public Object getSource() {
        return source;
    }
}

public abstract class ApplicationEvent extends EventObject {
	/**
	 * Create a new {@code ApplicationEvent}.
	 * @param source the object on which the event initially occurred or with
	 * which the event is associated (never {@code null})
	 */
	public ApplicationEvent(Object source) {
		super(source);
		this.timestamp = System.currentTimeMillis();
	}
}

@FunctionalInterface
public interface ApplicationListener<E extends ApplicationEvent> extends EventListener {
	/**
	 * Handle an application event.
	 * @param event the event to respond to
	 */
	void onApplicationEvent(E event);
}

public class SpringEventTest {
    public static void main(String[] args) {
        ApplicationContext context=new AnnotationConfigApplicationContext("com.thinkcoder.parttern.behavioral.pubsub.spring");
        Request request = (Request) context.getBean("request");
        //調(diào)用方法，發(fā)布事件
        request.doRequest();
    }
}
//定義事件
class RequestEvent extends ApplicationEvent {
    public RequestEvent(Request source) {
        super(source);
    }
}
//發(fā)布事件
@Component
class Request{
    @Autowired
    private ApplicationContext applicationContext;
    public void doRequest(){
        System.out.println("調(diào)用Request類的doRequest方法發(fā)送一個請求");
        applicationContext.publishEvent(new RequestEvent(this));
    }
}
//監(jiān)聽事件
@Component
class RequestListener implements ApplicationListener<RequestEvent> {
    @Override
    public void onApplicationEvent(RequestEvent event) {
        System.out.println("監(jiān)聽到RequestEvent事件,執(zhí)行方法");
    }
}
//打印的日志
調(diào)用Request類的doRequest方法發(fā)送一個請求
監(jiān)聽到RequestEvent事件,執(zhí)行方法

for (ApplicationListener<?> listener : getApplicationListeners()) {
	getApplicationEventMulticaster().addApplicationListener(listener);
}
// Do not initialize FactoryBeans here: We need to leave all regular beans
// uninitialized to let post-processors apply to them!
String[] listenerBeanNames = getBeanNamesForType(ApplicationListener.class, true, false);
for (String listenerBeanName : listenerBeanNames) {
	getApplicationEventMulticaster().addApplicationListenerBean(listenerBeanName);
}

private class ListenerRetriever {
	public final Set<ApplicationListener<?>> applicationListeners = new LinkedHashSet<>();
	public final Set<String> applicationListenerBeans = new LinkedHashSet<>();

public void multicastEvent(final ApplicationEvent event, @Nullable ResolvableType eventType) {
	ResolvableType type = (eventType != null ? eventType : resolveDefaultEventType(event));
	Executor executor = getTaskExecutor();
	for (ApplicationListener<?> listener : getApplicationListeners(event, type)) {
		if (executor != null) {
			executor.execute(() -> invokeListener(listener, event));
		}
		else {
			invokeListener(listener, event);
		}
	}
}

private void doInvokeListener(ApplicationListener listener, ApplicationEvent event) {
	try {
		//直接調(diào)用了listener接口的onApplicationEvent方法
		listener.onApplicationEvent(event);
	}
}