org.springframework.context.event.ApplicationContextEvent#org.springframework.context.event.ContextRefreshedEvent源码实例Demo

@Test
public void testOnApplicationEvent() {
	//Set up dependencies
	JMXControl jmxControl = new JMXControl(null);
	when(appContext.getBean(JMXControl.BEAN_JMX_CONTROL)).thenReturn(jmxControl);
	setupExportables();
	setupGateListeners();

	//raise the event
	ev.onApplicationEvent(new ContextRefreshedEvent(appContext));

	//Verify that all exportables were exported
	verify(exportable1).export(jmxControl);
	verify(exportable2).export(jmxControl);

	//Verify that all registered gate listeners have been notified
	verify(gateListener1).onCougarStart();
	verify(gateListener2).onCougarStart();
}
 

@EventListener(ContextRefreshedEvent.class)
public void onContextRefreshedEventEvent() {
    if (apimlEnabled) {
        if (apiMediationClient.getEurekaClient() != null) {
            if (config != null) {
                logger.log( "org.zowe.apiml.enabler.registration.renew"
                    , config.getBaseUrl(), config.getServiceIpAddress(), config.getDiscoveryServiceUrls()
                    , newConfig.getBaseUrl(), newConfig.getServiceIpAddress(), newConfig.getDiscoveryServiceUrls()
                );
            }

            unregister();
        } else {
            logger.log("org.zowe.apiml.enabler.registration.initial"
                , newConfig.getBaseUrl(), newConfig.getServiceIpAddress(), newConfig.getDiscoveryServiceUrls()
            );
        }

        register(newConfig);
    }
}
 

@Test
public void itDoesNotOverwriteExistingPermissions() {
  final PermissionEntry permissionEntry = new PermissionEntry();
  permissionEntry.setActor(actors.get(0));
  permissionEntry.setAllowedOperations(Arrays.asList(PermissionOperation.READ, PermissionOperation.WRITE, PermissionOperation.READ_ACL, PermissionOperation.WRITE_ACL));
  permissionEntry.setPath("/test/path");
  permissionService.savePermissions(Arrays.asList(permissionEntry));

  applicationEventPublisher.publishEvent(new ContextRefreshedEvent(applicationContext));

  final List<PermissionData> savedPermissions = permissionRepository.findAllByPath(credentialPath);
  assertThat(savedPermissions, hasSize(2));
  assertThat(savedPermissions.stream().map(p -> p.getActor()).collect(Collectors.toList()), containsInAnyOrder(actors.get(0), actors.get(1)));
  assertThat(savedPermissions.stream().allMatch(p -> p.hasReadPermission() && p.hasWritePermission()), is(true));
  assertThat(savedPermissions.get(0).hasWriteAclPermission() && savedPermissions.get(1).hasWriteAclPermission(), is(false));
  assertThat(savedPermissions.get(0).hasReadAclPermission() && savedPermissions.get(1).hasReadAclPermission(), is(false));
  assertThat(savedPermissions.stream().allMatch(p -> p.hasDeletePermission()), is(false));
}
 

@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
    //root application context 没有parent
    ApplicationContext context = event.getApplicationContext().getParent();
    if(context == null){
        if(StringUtils.isNotBlank(licensePath)){
            logger.info("++++++++ 开始安装证书 ++++++++");

            LicenseVerifyParam param = new LicenseVerifyParam();
            param.setSubject(subject);
            param.setPublicAlias(publicAlias);
            param.setStorePass(storePass);
            param.setLicensePath(licensePath);
            param.setPublicKeysStorePath(publicKeysStorePath);

            LicenseVerify licenseVerify = new LicenseVerify();
            //安装证书
            licenseVerify.install(param);

            logger.info("++++++++ 证书安装结束 ++++++++");
        }
    }
}
 

@Override
public void onApplicationEvent(final ContextRefreshedEvent event) {
    synchronized (ADDRESS) {
        if (serviceOps.list(NetworkService.Type.CORE).isEmpty()) {
            // 1. start (mocked) Core as embedded CXF
            JAXRSServerFactoryBean sf = new JAXRSServerFactoryBean();
            sf.setAddress(ADDRESS);
            sf.setResourceClasses(WAClientAppService.class, GoogleMfaAuthTokenService.class);
            sf.setResourceProvider(
                    WAClientAppService.class,
                    new SingletonResourceProvider(new StubWAClientAppService(), true));
            sf.setResourceProvider(
                    GoogleMfaAuthTokenService.class,
                    new SingletonResourceProvider(new StubGoogleMfaAuthTokenService(), true));
            sf.setProviders(List.of(new JacksonJsonProvider()));
            sf.create();

            // 2. register Core in Keymaster
            NetworkService core = new NetworkService();
            core.setType(NetworkService.Type.CORE);
            core.setAddress(ADDRESS);
            serviceOps.register(core);
        }
    }
}
 

@Override
public void onApplicationEvent(ApplicationEvent event) {
	ApplicationContext context = ((ContextRefreshedEvent) event).getApplicationContext();
	if (context != this.context) {
		return;
	}
	if (!ClassUtils.isPresent("org.springframework.http.server.reactive.HttpHandler", null)) {
		logger.info("No web server classes found so no server to start");
		return;
	}
	Integer port = Integer.valueOf(context.getEnvironment().resolvePlaceholders("${server.port:${PORT:8080}}"));
	String address = context.getEnvironment().resolvePlaceholders("${server.address:0.0.0.0}");
	if (port >= 0) {
		HttpHandler handler = context.getBean(HttpHandler.class);
		ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(handler);
		HttpServer httpServer = HttpServer.create().host(address).port(port).handle(adapter);
		Thread thread = new Thread(
				() -> httpServer.bindUntilJavaShutdown(Duration.ofSeconds(60), this::callback),
				"server-startup");
		thread.setDaemon(false);
		thread.start();
	}
}
 

@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
    try (TempAuth auth = TempAuth.asSystem()) {
        Map<String, ClusterConfigImpl.Builder> configs = swarmsConfig.getConfigs();
        DiscoveryStorageImpl storage = storageFactory.getObject();
        if(CollectionUtils.isEmpty(configs)) {
            LoggerFactory.getLogger(getClass()).info("No configs in " + swarmsConfig);
        } else {
            for(Map.Entry<String, ClusterConfigImpl.Builder> e: configs.entrySet()) {
                String cluster = e.getKey();
                ClusterConfigImpl.Builder config = ClusterConfigImpl.builder().from(e.getValue());
                config.cluster(cluster);
                SwarmNodesGroupConfig ngc = new SwarmNodesGroupConfig();
                ngc.setConfig(config.build());
                ngc.setName(cluster);
                storage.getOrCreateGroup(ngc);
            }
        }
        storage.load();
    }
}
 

@EventListener(value = ContextRefreshedEvent.class)
public void init() {
    log.info("start data initialization  ...");
    this.databaseClient.insert()
        .into("posts")
        //.nullValue("id", Integer.class)
        .value("title", "First post title")
        .value("content", "Content of my first post")
        .map((r, m) -> r.get("id", Integer.class))
        .all()
        .log()
        .thenMany(
            this.databaseClient.select()
                .from("posts")
                .orderBy(Sort.by(desc("id")))
                .as(Post.class)
                .fetch()
                .all()
                .log()
        )
        .subscribe(null, null, () -> log.info("initialization is done..."));
}
 

@SuppressWarnings("rawtypes")
	@EventListener
	public void handleContextRefresh(ContextRefreshedEvent event) {
		final Environment environment = event.getApplicationContext().getEnvironment();
		LOGGER.info("====== Environment and configuration ======");
		LOGGER.info("Active profiles: {}", Arrays.toString(environment.getActiveProfiles()));
		final MutablePropertySources sources = ((AbstractEnvironment) environment).getPropertySources();
		StreamSupport.stream(sources.spliterator(), false).filter(ps -> ps instanceof EnumerablePropertySource)
				.map(ps -> ((EnumerablePropertySource) ps).getPropertyNames()).flatMap(Arrays::stream).distinct()
				.forEach(prop -> {
					LOGGER.info("{}", prop);
//					Object resolved = environment.getProperty(prop, Object.class);
//					if (resolved instanceof String) {
//						LOGGER.info("{}", environment.getProperty(prop));
//					}
				});
		LOGGER.info("===========================================");
	}
 

@Override
public void onApplicationEvent(ApplicationContextEvent event) {
  try {
    // we only want to listen for context events of the main application
    // context, not its children
    if (event.getSource().equals(applicationContext)) {
      if (event instanceof ContextRefreshedEvent && !isDeployed) {
        // deploy the process application
        afterPropertiesSet();
      } else if (event instanceof ContextClosedEvent) {
        // undeploy the process application
        destroy();
      } else {
        // ignore
      }
    }
  } catch (Exception e) {
    throw new RuntimeException(e);
  }
}
 

@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
    logger.debug("Received ContextRefreshedEvent {}", event);

    if (event.getSource().equals(getBootstrapApplicationContext())) {
        //the root context is fully started
        appMetadata = bootstrapApplicationContext.getBean(AppMetadata.class);
        configuration = bootstrapApplicationContext.getBean(AbstractConfiguration.class);
        configurationProvider = bootstrapApplicationContext.getBean(ConfigurationProvider.class);

        logger.debug("Root context started");

        initClientApplication();

        return;
    }

    if (event.getSource() instanceof ApplicationContext && ((ApplicationContext) event.getSource()).getId().equals(appMetadata.getName())) {
        //the child context is fully started
        this.applicationContext = (AbstractApplicationContext) event.getSource();

        logger.debug("Child context started");
    }

    state.compareAndSet(State.STARTING, State.RUNNING);
}
 

@SuppressWarnings("rawtypes")
@EventListener
public void handleContextRefresh(ContextRefreshedEvent event) {
	final Environment environment = event.getApplicationContext().getEnvironment();
	LOGGER.info("====== Environment and configuration ======");
	LOGGER.info("Active profiles: {}", Arrays.toString(environment.getActiveProfiles()));
	final MutablePropertySources sources = ((AbstractEnvironment) environment).getPropertySources();
	StreamSupport.stream(sources.spliterator(), false).filter(ps -> ps instanceof EnumerablePropertySource)
			.map(ps -> ((EnumerablePropertySource) ps).getPropertyNames()).flatMap(Arrays::stream).distinct()
			.forEach(prop -> {
				Object resolved = environment.getProperty(prop, Object.class);
				if (resolved instanceof String) {
					LOGGER.info("{} - {}", prop, environment.getProperty(prop));
				} else {
					LOGGER.info("{} - {}", prop, "NON-STRING-VALUE");
				}
				
			});
	LOGGER.debug("===========================================");
}
 

@SuppressWarnings("rawtypes")
@EventListener
public void handleContextRefresh(ContextRefreshedEvent event) {
	final Environment environment = event.getApplicationContext().getEnvironment();
	LOGGER.info("====== Environment and configuration ======");
	LOGGER.info("Active profiles: {}", Arrays.toString(environment.getActiveProfiles()));
	final MutablePropertySources sources = ((AbstractEnvironment) environment).getPropertySources();
	StreamSupport.stream(sources.spliterator(), false).filter(ps -> ps instanceof EnumerablePropertySource)
			.map(ps -> ((EnumerablePropertySource) ps).getPropertyNames()).flatMap(Arrays::stream).distinct()
			.forEach(prop -> {
				Object resolved = environment.getProperty(prop, Object.class);
				if (resolved instanceof String) {
					LOGGER.info("{} - {}", prop, environment.getProperty(prop));
				} else {
					LOGGER.info("{} - {}", prop, "NON-STRING-VALUE");
				}
				
			});
	LOGGER.debug("===========================================");
}
 

@Override
public void onApplicationEvent( ContextRefreshedEvent event ) {
    String start = properties.getProperty( START_SCHEDULER_PROP, "true" );
    if ( Boolean.parseBoolean( start ) ) {
        logger.info( "Starting Scheduler Service..." );
        jobScheduler.startAsync();
        jobScheduler.awaitRunning();

    } else {
        logger.info( "Scheduler Service disabled" );
    }

    boolean shouldRun = new Boolean(properties.getProperty("usergrid.notifications.listener.run","true"));
    if(shouldRun){
        notificationsQueueListener.start();
    }else{
        logger.info("QueueListener: never started due to config value usergrid.notifications.listener.run.");
    }

}
 

@Override
public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
    log.info("======程序启动成功======");
    coinTraderFactory.getTraderMap();
    HashMap<String,CoinTrader> traders = coinTraderFactory.getTraderMap();
    traders.forEach((symbol,trader) ->{
        List<ExchangeOrder> orders = exchangeOrderService.findAllTradingOrderBySymbol(symbol);
        List<ExchangeOrder> tradingOrders = new ArrayList<>();
        orders.forEach(order -> {
            BigDecimal tradedAmount = BigDecimal.ZERO;
            BigDecimal turnover = BigDecimal.ZERO;
            List<ExchangeOrderDetail> details = exchangeOrderDetailService.findAllByOrderId(order.getOrderId());
            order.setDetail(details);
            for(ExchangeOrderDetail trade:details){
                tradedAmount = tradedAmount.add(trade.getAmount());
                turnover = turnover.add(trade.getAmount().multiply(trade.getPrice()));
            }
            order.setTradedAmount(tradedAmount);
            order.setTurnover(turnover);
            if(!order.isCompleted()){
                tradingOrders.add(order);
            }
        });
        trader.trade(tradingOrders);
    });
}
 

@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
    if (event.getApplicationContext().getParent() == null) {
        LOGGER.info("Start to add the validator into current handler,base packages contains:{}",this.getBasePackages());
        this.addValidators();
    }
}
 

@Override
    public void onApplicationEvent(ContextRefreshedEvent event) {
        if (isDelay() && !isExported() && !isUnexported()) {
            if (logger.isInfoEnabled()) {
                logger.info("The service ready on spring started. service: " + getInterface());
            }
//            接收到上下文刷新事件注册服务=》
            export();
        }
    }
 

@Override
public void onApplicationEvent(ContextRefreshedEvent contextRefreshedEvent) {
    ApplicationContext applicationContext = contextRefreshedEvent.getApplicationContext();

    if (applicationContext.getParent() == null) {
        FactoryBuilder.registerBeanFactory(applicationContext.getBean(BeanFactory.class));
    }
}
 

@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
	if (isAutodetect()) {
		this.handlerMap.clear();
		detectResourceHandlers(event.getApplicationContext());
		if (!this.handlerMap.isEmpty()) {
			this.autodetect = false;
		}
	}
}
 

public void onApplicationEvent(ContextRefreshedEvent event) {
    destroy();
    setBus(null);
    try {
        init(getServletConfig());
    } catch (ServletException e) {
        throw new RuntimeException("Unable to reinitialize the CXFServlet", e);
    }
}
 

@Override
public void onApplicationEvent(ContextRefreshedEvent event) {

    if ("Root WebApplicationContext".equals(event.getApplicationContext().getDisplayName())) {
        log.info("Initializing and populating DB if necessary");

        Map<String, DBInit> map = event.getApplicationContext().getBeansOfType(DBInit.class);

        if (map != null && !map.isEmpty()) {
            List<DBInit> list = new ArrayList<>(map.values());

            // order based on the @Order annotation
            list.sort(new AnnotationAwareOrderComparator());

            log.info(String.format("Found %d beans to init", list.size()));
            for (int i = 0; i < list.size(); i++) {
                DBInit dbInit = list.get(i);
                log.info(String.format("Init-ing (order: %d): %s", i, dbInit.getClass().getSimpleName()));
                // our current strategy is ONLY to persist these objects if the data does NOT already exist
                boolean didExecute = dbInit.initIfNotExist();

                if (didExecute) {
                    // wait a bit in case the next db init is dependent on the former
                    try {
                        log.info("Sleeping 2 seconds before starting the next DB init bean");
                        Thread.sleep(2000);
                    } catch (InterruptedException e) {
                        log.error(e.getMessage(), e);
                    }
                }
            }
        }
    }
}
 

/**
 * Initialize internationalization attributes
 *
 * @param event application event
 */
public void initialize(ContextRefreshedEvent event) {
  ApplicationContext ctx = event.getApplicationContext();
  Stream<String> languageCodes = LanguageService.getLanguageCodes();

  EntityTypeMetadata entityTypeMeta = ctx.getBean(EntityTypeMetadata.class);
  AttributeMetadata attrMetaMeta = ctx.getBean(AttributeMetadata.class);
  L10nStringMetadata l10nStringMeta = ctx.getBean(L10nStringMetadata.class);

  languageCodes.forEach(
      languageCode -> {
        entityTypeMeta
            .addAttribute(getI18nAttributeName(EntityTypeMetadata.LABEL, languageCode))
            .setNillable(true)
            .setLabel("Label (" + languageCode + ')');
        entityTypeMeta
            .addAttribute(getI18nAttributeName(EntityTypeMetadata.DESCRIPTION, languageCode))
            .setNillable(true)
            .setLabel("Description (" + languageCode + ')')
            .setDataType(TEXT);
        attrMetaMeta
            .addAttribute(getI18nAttributeName(AttributeMetadata.LABEL, languageCode))
            .setNillable(true)
            .setLabel("Label (" + languageCode + ')');
        attrMetaMeta
            .addAttribute(getI18nAttributeName(AttributeMetadata.DESCRIPTION, languageCode))
            .setNillable(true)
            .setLabel("Description (" + languageCode + ')')
            .setDataType(TEXT);
        l10nStringMeta.addAttribute(languageCode).setNillable(true).setDataType(TEXT);
      });
}
 

@Override
public void onApplicationEvent(ApplicationEvent event) {
    if (server.isHasRegistryServer() && event instanceof ContextRefreshedEvent) {
        // 发布服务
        if (providerInitializer == null) {
            server.getServer().publish(serviceWrapper);
        } else {
            server.getServer().publishWithInitializer(
                    serviceWrapper, providerInitializer, providerInitializerExecutor);
        }

        logger.info("#publish service: {}.", serviceWrapper);
    }
}
 

/** Starts the scheduleCheckTask tasks upon application start */
@EventListener({ContextRefreshedEvent.class})
public void onApplicationEvent() {
  for (Project project : listProjectsPort.getProjects()) {
    projectStatusPort.setBeingProcessed(project.getId(), false);
  }
  taskScheduler.scheduleAtFixedRate(
      this::scheduleCheckTask,
      coderadarConfigurationProperties.getScanIntervalInSeconds() * 1000);
}
 

@EventListener
public void handleContextRefresh( ContextRefreshedEvent contextRefreshedEvent )
{
    for ( SchemaDescriptor descriptor : descriptors )
    {
        Schema schema = descriptor.getSchema();

        MetamodelImplementor metamodelImplementor = (MetamodelImplementor) sessionFactory.getMetamodel();

        try
        {
            metamodelImplementor.entityPersister( schema.getKlass() );
            schema.setPersisted( true );
        }
        catch ( MappingException e )
        {
            // class is not persisted with Hibernate
            schema.setPersisted( false );
        }

        schema.setDisplayName( TextUtils.getPrettyClassName( schema.getKlass() ) );

        if ( schema.getProperties().isEmpty() )
        {
            schema.setPropertyMap( Maps.newHashMap( propertyIntrospectorService.getPropertiesMap( schema.getKlass() ) ) );
        }

        classSchemaMap.put( schema.getKlass(), schema );
        singularSchemaMap.put( schema.getSingular(), schema );
        pluralSchemaMap.put( schema.getPlural(), schema );

        updateSelf( schema );

        schema.getPersistedProperties();
        schema.getNonPersistedProperties();
        schema.getReadableProperties();
        schema.getEmbeddedObjectProperties();
    }
}
 

@Override
@Transactional
public void onApplicationEvent(ContextRefreshedEvent event) {
    if (alreadySetup) {
        return;
    }

    // == create initial privileges
    Privilege readPrivilege = createPrivilegeIfNotFound("READ_PRIVILEGE");
    Privilege writePrivilege = createPrivilegeIfNotFound("WRITE_PRIVILEGE"); 

    // == create initial roles
    List<Privilege> adminPrivileges = Arrays.asList(readPrivilege, writePrivilege);
    createRoleIfNotFound("ROLE_ADMIN", adminPrivileges);
    List<Privilege> rolePrivileges = new ArrayList<>();
    createRoleIfNotFound("ROLE_USER", rolePrivileges);

    Role adminRole = roleRepository.findByName("ROLE_ADMIN");
    User user = new User();
    user.setFirstName("Admin");
    user.setLastName("Admin");
    user.setEmail("[email protected]");
    user.setPassword(passwordEncoder.encode("admin"));
    user.setRoles(Arrays.asList(adminRole));
    user.setEnabled(true);
    userRepository.save(user);

    Role basicRole = roleRepository.findByName("ROLE_USER");
    User basicUser = new User();
    basicUser.setFirstName("User");
    basicUser.setLastName("User");
    basicUser.setEmail("[email protected]");
    basicUser.setPassword(passwordEncoder.encode("user"));
    basicUser.setRoles(Arrays.asList(basicRole));
    basicUser.setEnabled(true);
    userRepository.save(basicUser);

    alreadySetup = true;
}
 

@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
    log.info("Start onApplicationEvent");
    Page<EnvironmentEntity> environmentEntities = environmentsRepository
            .getEnvironmentsList(1, 1);
    if (environmentEntities.getResult().size() <= 0) {
        Optional<EnvironmentEntity> environmentEntityOptional = environmentsRepository
                .findByName(defaultEnvironmentName);
        if (defaultEnvironmentName != null
                && defaultEnvironmentServiceUrl != null
                && defaultEnvironmentName.length() > 0
                && defaultEnvironmentServiceUrl.length() > 0
                && !environmentEntityOptional.isPresent()) {
            try {
                pulsarAdminService.clusters(defaultEnvironmentServiceUrl).getClusters();
            } catch (PulsarAdminException e) {
                log.error("Failed to get clusters list.", e);
                log.error("Unable to connect default environment {} via {}, " +
                                "please check if `environment.default.name` " +
                                "and `environment.default.broker` are set correctly, " +
                                "environmentDefaultName, environmentDefaultBroker",
                        defaultEnvironmentName, defaultEnvironmentServiceUrl);
                System.exit(-1);
            }

            EnvironmentEntity environmentEntity = new EnvironmentEntity();
            environmentEntity.setBroker(defaultEnvironmentServiceUrl);
            environmentEntity.setName(defaultEnvironmentName);
            environmentsRepository.save(environmentEntity);
            log.info("Successfully added a default environment: name = {}, service_url = {}.",
                    defaultEnvironmentName, defaultEnvironmentServiceUrl);
        } else {
            log.warn("The default environment already exists.");
        }
    }
    log.debug("Environments already exist.");
}
 

@EventListener(ContextRefreshedEvent.class)
public void initializeServices() {
    contextRunner.runOnServiceContext(promise -> {
        initializables.forEach(Initializable::initialize);
        promise.complete();
    });
}
 

@Override
public void onApplicationEvent(ContextRefreshedEvent event) {
    if (!initialized) {

        if (bootstrapConfig.isEnabled()) {
            createData();
        }

        initialized = true;
    }
}
 

@BeforeEach
public void beforeEach() {
  ContextRefreshedEvent contextRefreshedEvent = Mockito.mock(ContextRefreshedEvent.class);
  Mockito.when(contextRefreshedEvent.getApplicationContext()).thenReturn(applicationContext);
  importServiceRegistrar.register(contextRefreshedEvent);
  RunAsSystemAspect.runAsSystem(() -> dataService.add(USER, getTestUser()));
}