Java ApplicationEventMulticaster类代码示例

import org.springframework.context.event.ApplicationEventMulticaster; //导入依赖的package包/类
/**
 * Initialize the ApplicationEventMulticaster.
 * Uses SimpleApplicationEventMulticaster if none defined in the context.
 * @see org.springframework.context.event.SimpleApplicationEventMulticaster
 */
protected void initApplicationEventMulticaster() {
	ConfigurableListableBeanFactory beanFactory = getBeanFactory();
	if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
		this.applicationEventMulticaster =
				beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
		if (logger.isDebugEnabled()) {
			logger.debug("Using ApplicationEventMulticaster [" + this.applicationEventMulticaster + "]");
		}
	}
	else {
		this.applicationEventMulticaster = new SimpleApplicationEventMulticaster(beanFactory);
		beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, this.applicationEventMulticaster);
		if (logger.isDebugEnabled()) {
			logger.debug("Unable to locate ApplicationEventMulticaster with name '" +
					APPLICATION_EVENT_MULTICASTER_BEAN_NAME +
					"': using default [" + this.applicationEventMulticaster + "]");
		}
	}
}
 

import org.springframework.context.event.ApplicationEventMulticaster; //导入依赖的package包/类
private synchronized ApplicationEventMulticaster getApplicationEventMulticaster()
{
  try
  {
    Field field = DataStore.class.getDeclaredField("mainContext");
    field.setAccessible(true);
    AbstractApplicationContext ctx = (AbstractApplicationContext) field.get(DataStore.getInstance());
    if (ctx == null)
      return null;
    Method m = AbstractApplicationContext.class.getDeclaredMethod("getApplicationEventMulticaster");
    m.setAccessible(true);
    ApplicationEventMulticaster eventCaster = (ApplicationEventMulticaster) m.invoke(ctx);
    field.setAccessible(false);
    m.setAccessible(false);
    return eventCaster;
  }
  catch (Exception e)
  {
    e.printStackTrace();
  }
  return null;
}
 

import org.springframework.context.event.ApplicationEventMulticaster; //导入依赖的package包/类
private Editor createEditor(){
	Object o = BeanUtils.instantiateClass(editorClass);
	Assert.isTrue((o instanceof Editor), "Editor class '"+
		editorClass + "' was instantiated but is not an Editor");
	Editor editor = (Editor)o;
	editor.setDescriptor(this);
	ApplicationEventMulticaster multicaster = getApplicationEventMulticaster();
	if(editor instanceof ApplicationListener &&  multicaster != null){
		multicaster.addApplicationListener((ApplicationListener)editor);
	}
	if(editorProperties != null){
		BeanWrapper wrapper = new BeanWrapperImpl(editor);
		wrapper.setPropertyValues(editorProperties);
	}
	if(editor instanceof InitializingBean){
		 try {
			 ((InitializingBean)editor).afterPropertiesSet();
         }
         catch (Exception e) {
             throw new BeanInitializationException("Problem running on " + editor, e);
         }
	}
	return editor;
}
 

import org.springframework.context.event.ApplicationEventMulticaster; //导入依赖的package包/类
@Bean(name = "applicationEventMulticaster")
public ApplicationEventMulticaster simpleApplicationEventMulticaster() {
    SimpleApplicationEventMulticaster eventMulticaster = new SimpleApplicationEventMulticaster();

    taskExecutor = new ThreadPoolTaskExecutor();
    taskExecutor.setThreadNamePrefix("asyncEventExecutor-");
    taskExecutor.setCorePoolSize(4);
    taskExecutor.initialize();

    eventMulticaster.setTaskExecutor(taskExecutor);
    return eventMulticaster;
}
 

import org.springframework.context.event.ApplicationEventMulticaster; //导入依赖的package包/类
@Override
public void publishEvent(ApplicationEvent event)
{
    Assert.notNull(event, "Event must not be null");
    if (logger.isTraceEnabled())
    {
        logger.trace("Publishing event in " + getDisplayName() + ": " + event);
    }
    ((ApplicationEventMulticaster) getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)).multicastEvent(event);

    if (!(getParent() == null || event instanceof ContextRefreshedEvent || event instanceof ContextClosedEvent))
    {
        getParent().publishEvent(event);
    }
}
 

import org.springframework.context.event.ApplicationEventMulticaster; //导入依赖的package包/类
/**
 * Return the internal ApplicationEventMulticaster used by the context.
 * @return the internal ApplicationEventMulticaster (never {@code null})
 * @throws IllegalStateException if the context has not been initialized yet
 */
ApplicationEventMulticaster getApplicationEventMulticaster() throws IllegalStateException {
	if (this.applicationEventMulticaster == null) {
		throw new IllegalStateException("ApplicationEventMulticaster not initialized - " +
				"call 'refresh' before multicasting events via the context: " + this);
	}
	return this.applicationEventMulticaster;
}
 

import org.springframework.context.event.ApplicationEventMulticaster; //导入依赖的package包/类
@Override
public void postProcessBeforeDestruction(Object bean, String beanName) {
	if (bean instanceof ApplicationListener) {
		ApplicationEventMulticaster multicaster = this.applicationContext.getApplicationEventMulticaster();
		multicaster.removeApplicationListener((ApplicationListener<?>) bean);
		multicaster.removeApplicationListenerBean(beanName);
	}
}
 

import org.springframework.context.event.ApplicationEventMulticaster; //导入依赖的package包/类
@Bean(name = "applicationEventMulticaster")
public ApplicationEventMulticaster simpleApplicationEventMulticaster() {
    multicasterExecutor.initialize();
    SimpleApplicationEventMulticaster eventMulticaster = new SimpleApplicationEventMulticaster();
    eventMulticaster.setTaskExecutor(multicasterExecutor);
    return eventMulticaster;
}
 

import org.springframework.context.event.ApplicationEventMulticaster; //导入依赖的package包/类
@Before
public void init() throws Throwable {
    stubDemo();

    pluginDao.refresh();

    initGit();

    if (Files.exists(Paths.get(gitWorkspace.toString(), "plugin_cache.json"))) {
        Files.delete(Paths.get(gitWorkspace.toString(), "plugin_cache.json"));
    }

    applicationEventMulticaster = (ApplicationEventMulticaster) applicationContext
        .getBean(AbstractApplicationContext.APPLICATION_EVENT_MULTICASTER_BEAN_NAME);
}
 

import org.springframework.context.event.ApplicationEventMulticaster; //导入依赖的package包/类
/**
 * Constructor.
 *
 * @param asyncEventMulticaster The asynchronous event multicaster to use
 */
public MetacatApplicationEventMulticaster(
    @Nonnull @NonNull final ApplicationEventMulticaster asyncEventMulticaster
) {
    super();
    this.asyncEventMulticaster = asyncEventMulticaster;
}
 

import org.springframework.context.event.ApplicationEventMulticaster; //导入依赖的package包/类
/**
 * The application event multicaster to use.
 *
 * @param asyncEventMulticaster The asynchronous event publisher
 * @return The application event multicaster to use.
 */
@Bean
public MetacatApplicationEventMulticaster applicationEventMulticaster(
    final ApplicationEventMulticaster asyncEventMulticaster
) {
    return new MetacatApplicationEventMulticaster(asyncEventMulticaster);
}
 

import org.springframework.context.event.ApplicationEventMulticaster; //导入依赖的package包/类
/**
 * A multicast (async) event publisher to replace the synchronous one used by Spring via the ApplicationContext.
 *
 * @param taskExecutor The task executor to use
 * @return The application event multicaster to use
 */
@Bean
public ApplicationEventMulticaster asyncEventMulticaster(final TaskExecutor taskExecutor) {
    final SimpleApplicationEventMulticaster applicationEventMulticaster = new SimpleApplicationEventMulticaster();
    applicationEventMulticaster.setTaskExecutor(taskExecutor);
    return applicationEventMulticaster;
}
 

import org.springframework.context.event.ApplicationEventMulticaster; //导入依赖的package包/类
/**
 * Server internal event publisher that allows parallel event processing if
 * the event listener is marked as so.
 *
 * @return publisher bean
 */
@Bean(name = AbstractApplicationContext.APPLICATION_EVENT_MULTICASTER_BEAN_NAME)
public ApplicationEventMulticaster applicationEventMulticaster() {
    final SimpleApplicationEventMulticaster simpleApplicationEventMulticaster = new TenantAwareApplicationEventPublisher(
            tenantAware, applicationEventFilter());
    simpleApplicationEventMulticaster.setTaskExecutor(executor);
    return simpleApplicationEventMulticaster;
}
 

import org.springframework.context.event.ApplicationEventMulticaster; //导入依赖的package包/类
/**
 * 修改特定上下文的Event Multicaster的默认实现
 *
 * @param context 被修改的上下文
 */
public static void initApplicationEventMulticaster(GenericApplicationContext context) {
    ApplicationEventMulticaster multicaster;
    ConfigurableListableBeanFactory beanFactory = context.getBeanFactory();
    if (beanFactory.containsLocalBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME)) {
        multicaster =
                beanFactory.getBean(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, ApplicationEventMulticaster.class);
    } else {
        multicaster = new SmartApplicationEventMulticaster(beanFactory);
        beanFactory.registerSingleton(APPLICATION_EVENT_MULTICASTER_BEAN_NAME, multicaster);
    }
    setApplicationEventMulticaster(context, multicaster);

}
 

import org.springframework.context.event.ApplicationEventMulticaster; //导入依赖的package包/类
private static void setApplicationEventMulticaster(GenericApplicationContext context,
                                                     ApplicationEventMulticaster applicationEventMulticaster) {
    try {
        FieldUtils.writeField(context, "applicationEventMulticaster", applicationEventMulticaster, true);
    } catch (IllegalAccessException e) {
        throw new ApplicationContextException("Can't hacking the spring context for applicationEventMulticaster", e);
    }
}