import org.vaadin.spring.events.EventBus; //导入依赖的package包/类
UploadHandler(final String fileName, final long fileSize, final UploadLayout view, final long maxSize,
        final Upload upload, final String mimeType, final SoftwareModule selectedSw,
        final SoftwareModuleManagement softwareManagement) {
    super();
    this.aborted = false;
    this.fileName = fileName;
    this.fileSize = fileSize;
    this.view = view;
    this.maxSize = maxSize;
    this.upload = upload;
    this.mimeType = mimeType;
    this.selectedSw = selectedSw;
    this.i18n = SpringContextHelper.getBean(VaadinMessageSource.class);
    this.eventBus = SpringContextHelper.getBean(EventBus.UIEventBus.class);
    this.artifactUploadState = SpringContextHelper.getBean(ArtifactUploadState.class);
    this.softwareModuleManagement = softwareManagement;
    eventBus.subscribe(this);
}
 

import org.vaadin.spring.events.EventBus; //导入依赖的package包/类
private void invokeAwareInterfaces(Object bean) {
    if (bean instanceof EventBusAware) {

        if (bean instanceof EventBusAware.ApplicationEventBusAware) {
            ((EventBusAware.ApplicationEventBusAware) bean).setApplicationEventBus(this.applicationContext.getBean(EventBus.ApplicationEventBus.class));
        }
        if (bean instanceof EventBusAware.SessionEventBusAware) {
            ((EventBusAware.SessionEventBusAware) bean).setSessionEventBus(this.applicationContext.getBean(EventBus.SessionEventBus.class));
        }
        if (bean instanceof EventBusAware.UIEventBusAware) {
            ((EventBusAware.UIEventBusAware) bean).setUIEventBus(this.applicationContext.getBean(EventBus.UIEventBus.class));
        }
        if (bean instanceof EventBusAware.ViewEventBusAware) {
            ((EventBusAware.ViewEventBusAware) bean).setViewEventBus(this.applicationContext.getBean(EventBus.ViewEventBus.class));
        }

    }
}
 

import org.vaadin.spring.events.EventBus; //导入依赖的package包/类
/**
 * @param scope          the scope of the events that this event bus handles.
 * @param parentEventBus the parent event bus to use, may be {@code null};
 */
public ScopedEventBus(EventScope scope, EventBus parentEventBus) {
    eventScope = scope;
    this.parentEventBus = parentEventBus;
    if (parentEventBus != null) {
        if (AopUtils.isJdkDynamicProxy(parentEventBus)) {
            logger.debug("Parent event bus [{}] is proxied, trying to get the real EventBus instance",
                    parentEventBus);
            try {
                this.parentEventBus = (EventBus) ((Advised) parentEventBus).getTargetSource().getTarget();
            } catch (Exception e) {
                logger.error("Could not get target EventBus from proxy", e);
                throw new RuntimeException("Could not get parent event bus", e);
            }
        }
        logger.debug("Using parent event bus [{}]", this.parentEventBus);
        this.parentEventBus.subscribe(parentListener);
    }
}
 

import org.vaadin.spring.events.EventBus; //导入依赖的package包/类
/**
 * Constructor.
 * 
 * @param eventBus
 *            the ui event bus
 * @param notificationUnreadButton
 *            the notificationUnreadButton
 */
public AbstractNotificationView(final EventBus.UIEventBus eventBus,
        final NotificationUnreadButton notificationUnreadButton) {
    this.eventBus = eventBus;
    this.notificationUnreadButton = notificationUnreadButton;
    this.viewUnreadNotifcations = new AtomicInteger(0);
    skipUiEventsCache = CacheBuilder.newBuilder().expireAfterAccess(10, SECONDS).build();
    eventBus.subscribe(this);
}
 

import org.vaadin.spring.events.EventBus; //导入依赖的package包/类
/**
 * The constructor automatically subscribes to event bus events.
 *
 * @param view <em>View</em>
 * @param eventBus Vaadin even bus
 */
public Presenter(T view, EventBus eventBus) {
    Assert.notNull(view);
    Assert.notNull(eventBus);
    this.view = view;
    this.eventBus = eventBus;
    eventBus.subscribe(this);
}
 

import org.vaadin.spring.events.EventBus; //导入依赖的package包/类
@Test
public void testOnApplicationEvent() {
    ApplicationEvent event = new ApplicationEvent(this) {

        private static final long serialVersionUID = 7475015652750718692L;

        @Override
        public Object getSource() {
            return "mySource";
        }
    };
    EventBus eventBus = mock(EventBus.class);
    new ApplicationContextEventBroker(eventBus).onApplicationEvent(event);
    verify(eventBus).publish("mySource", event);
}
 

import org.vaadin.spring.events.EventBus; //导入依赖的package包/类
public static void doDefault(ErrorEvent event) {
    Throwable t = event.getThrowable();
    if (t instanceof SocketException) {
        // Most likely client browser closed socket
        getLogger().info(
                "SocketException in CommunicationManager."
                        + " Most likely client (browser) closed socket.");
        return;
    }

    t = findRelevantThrowable(t);
    
    /*
     * Handle SpringSecurity 
     */
    if (t instanceof AccessDeniedException) {
    	
    	EventBus eventBus = SpringApplicationContext.getEventBus();
    	eventBus.publish(EventScope.UI, eventBus, new AccessDeniedEvent(t));
    	
    	getLogger().log(Level.FINE, "Access is denied", t);
    	return;
    }

    // Finds the original source of the error/exception
    AbstractComponent component = findAbstractComponent(event);
    if (component != null) {
        // Shows the error in AbstractComponent
        ErrorMessage errorMessage = AbstractErrorMessage
                .getErrorMessageForException(t);
        component.setComponentError(errorMessage);
    }

    // also print the error on console
    getLogger().log(Level.SEVERE, "", t);
}
 

import org.vaadin.spring.events.EventBus; //导入依赖的package包/类
public SecuredNavigator(UI ui, ViewDisplay display, SpringViewProvider viewProvider, Security security, EventBus eventBus) {
	super(ui, display);		
	this.security = security;
	this.viewProvider = viewProvider;
	this.eventBus = eventBus;
	addProvider(this.viewProvider);
}
 

import org.vaadin.spring.events.EventBus; //导入依赖的package包/类
/**
 * @return the eventBus
 */
public EventBus.UIEventBus getEventBus() {
    return eventBus;
}
 

import org.vaadin.spring.events.EventBus; //导入依赖的package包/类
public EventBus.UIEventBus getEventBus() {
    return eventBus;
}
 

import org.vaadin.spring.events.EventBus; //导入依赖的package包/类
public EventBus getEventBus() {
    return eventBus;
}
 

import org.vaadin.spring.events.EventBus; //导入依赖的package包/类
@Before
public void setUp() {
    fooView = new FooView();
    eventBus = mock(EventBus.class);
    presenter = new ExplicitPresenter(fooView, eventBus);
}
 

import org.vaadin.spring.events.EventBus; //导入依赖的package包/类
@Autowired
public AutowiredPresenter(FooView view, EventBus.UIEventBus eventBus) {
    super(view, eventBus);
}
 

import org.vaadin.spring.events.EventBus; //导入依赖的package包/类
public ExplicitPresenter(FooView view, EventBus eventBus) {
    super(view, eventBus);
}
 

import org.vaadin.spring.events.EventBus; //导入依赖的package包/类
public EventBus getEventBus() {
    return this.eventBus;
}
 

import org.vaadin.spring.events.EventBus; //导入依赖的package包/类
public ApplicationContextEventBroker(EventBus eventBus) {
    this.eventBus = eventBus;
}
 

import org.vaadin.spring.events.EventBus; //导入依赖的package包/类
public EventBusListenerWrapper(EventBus owningEventBus, EventBusListener<?> listenerTarget, String topic, boolean includingPropagatingEvents) {
    super(owningEventBus, listenerTarget, topic, includingPropagatingEvents);
    payloadType = GenericTypeResolver.resolveTypeArgument(listenerTarget.getClass(), EventBusListener.class);
    Assert.notNull(payloadType, "Could not resolve payload type");
}
 

import org.vaadin.spring.events.EventBus; //导入依赖的package包/类
public AbstractListenerWrapper(EventBus owningEventBus, Object listenerTarget, String topic, boolean includingPropagatingEvents) {
    this.owningEventBus = owningEventBus;
    this.topic = topic;
    this.listenerTarget = listenerTarget;
    this.includingPropagatingEvents = includingPropagatingEvents;
}
 

import org.vaadin.spring.events.EventBus; //导入依赖的package包/类
@Bean
EventBus.ApplicationEventBus applicationEventBus() {
    return new ScopedEventBus.DefaultApplicationEventBus();
}
 

import org.vaadin.spring.events.EventBus; //导入依赖的package包/类
@Bean
@Scope(value = VaadinSessionScope.VAADIN_SESSION_SCOPE_NAME, proxyMode = ScopedProxyMode.INTERFACES)
@EventBusProxy
EventBus.SessionEventBus proxiedSessionEventBus() {
    return sessionEventBus();
}