Java 类org.apache.commons.configuration.event.ConfigurationListener 实例源码

@Override
protected PropertyUtil initialValue() {
    PropertyUtil p = new PropertyUtil(
            System.getProperty("application.properties.file",
                    "resources/application.properties"));
    p.setProperty("isfw.build.info", getBuildInfo());
    p.setEncoding(p.getString(ApplicationProperties.LOCALE_CHAR_ENCODING.key, "UTF-8"));

    File prjDir = new File(".").getAbsoluteFile().getParentFile();
    p.setProperty("project.path", prjDir.getAbsolutePath());
    if(!p.containsKey("project.name"))
    p.setProperty("project.name", prjDir.getName());

    log.info("ISFW build info: " + p.getProperty("isfw.build.info"));
    String[] resources = p.getStringArray("env.resources", "resources");
    for (String resource : resources) {
        addBundle(p, resource);
    }
    ConfigurationListener cl = new PropertyConfigurationListener();
    p.addConfigurationListener(cl);
    return p;
}

public DynamicRequestLimiter(DynamicDistributedLogConfiguration dynConf,
                             StatsLogger statsLogger, Feature rateLimitDisabledFeature) {
    final StatsLogger limiterStatsLogger = statsLogger.scope("dynamic");
    this.dynConf = dynConf;
    this.rateLimitDisabledFeature = rateLimitDisabledFeature;
    this.listener = new ConfigurationListener() {
        @Override
        public void configurationChanged(ConfigurationEvent event) {
            // Note that this method may be called several times if several config options
            // are changed. The effect is harmless except that we create and discard more
            // objects than we need to.
            LOG.debug("Config changed callback invoked with event {} {} {} {}", new Object[] {
                    event.getPropertyName(), event.getPropertyValue(), event.getType(),
                    event.isBeforeUpdate()});
            if (!event.isBeforeUpdate()) {
                limiterStatsLogger.getCounter("config_changed").inc();
                LOG.debug("Rebuilding limiter");
                limiter = build();
            }
        }
    };
    LOG.debug("Registering config changed callback");
    dynConf.addConfigurationListener(listener);
}

@Override
public void onApplicationEvent(EnvironmentChangeEvent event) {
    AbstractConfiguration manager = ConfigurationManager.getConfigInstance();
    for (String key : event.getKeys()) {
        for (ConfigurationListener listener : manager
                .getConfigurationListeners()) {
            Object source = event.getSource();
            // TODO: Handle add vs set vs delete?
            int type = AbstractConfiguration.EVENT_SET_PROPERTY;
            String value = this.env.getProperty(key);
            boolean beforeUpdate = false;
            listener.configurationChanged(new ConfigurationEvent(source, type,
                    key, value, beforeUpdate));
        }
    }
}

@Test
public void environmentChangeEventPropagated() {
    this.context = new AnnotationConfigApplicationContext(
            ArchaiusAutoConfiguration.class);
    ConfigurationManager.getConfigInstance().addConfigurationListener(
            new ConfigurationListener() {
                @Override
                public void configurationChanged(ConfigurationEvent event) {
                    if (event.getPropertyName().equals("my.prop")) {
                        ArchaiusAutoConfigurationTests.this.propertyValue = event
                                .getPropertyValue();
                    }
                }
            });
    EnvironmentTestUtils.addEnvironment(this.context, "my.prop=my.newval");
    this.context.publishEvent(new EnvironmentChangeEvent(Collections
            .singleton("my.prop")));
    assertEquals("my.newval", this.propertyValue);
}

private void invokeListeners()
{
    if (m_configurationListeners != null)
    {
        try
        {
            ConfigurationEvent event = new ConfigurationEvent(this,AbstractConfiguration.EVENT_SET_PROPERTY,null,this, false);
            for (ConfigurationListener listener:m_configurationListeners)
            {
                listener.configurationChanged(event);
            }
        }
        catch (Exception e)
        {
            throw new RuntimeException(e);
        }
    }
}

@Override
protected PropertyUtil childValue(PropertyUtil parentValue) {
    PropertyUtil cp = new PropertyUtil(parentValue);
    ConfigurationListener cl = new PropertyConfigurationListener();
    cp.addConfigurationListener(cl);
    return cp;
}

private void addConfigurationListener() {
    final MetricsCloudWatchConfiguration springConfig = this;
    ConfigurationManager.getConfigInstance().addConfigurationListener(new ConfigurationListener() {

        @Override
        public synchronized void configurationChanged(ConfigurationEvent event) {
            if (!(event.getType() == AbstractConfiguration.EVENT_SET_PROPERTY ||
                    event.getType() == AbstractConfiguration.EVENT_ADD_PROPERTY)) {
                return;
            }
            if (event.isBeforeUpdate()) {
                return;
            }
            String name = event.getPropertyName();

            if (!(name.equals(METRICS_AWS_ENABLED) ||
                    name.equals(METRICS_AWS_FILTER) ||
                    name.equals(METRICS_AWS_PUBLISH_INTERVAL) ||
                    name.equals(METRICS_AWS_PUBLISH_INTERVAL_UNIT))) {
                return;
            }

            springConfig.enabled = name.equals(METRICS_AWS_ENABLED) ? Boolean.parseBoolean(event.getPropertyValue() + "") : springConfig.enabled;
            destroyReporter();
            if (springConfig.enabled) {
                createReporter();
            }

        }
    });
}

private void addConfigurationListener() {
    final MetricsGraphiteConfiguration springConfig = this;
    ConfigurationManager.getConfigInstance().addConfigurationListener(new ConfigurationListener() {

        @Override
        public synchronized void configurationChanged(ConfigurationEvent event) {
            if (!(event.getType() == AbstractConfiguration.EVENT_SET_PROPERTY ||
                    event.getType() == AbstractConfiguration.EVENT_ADD_PROPERTY)) {
                return;
            }
            if (event.isBeforeUpdate()) {
                return;
            }
            String name = event.getPropertyName();
            if (!(name.equals(METRICS_GRAPHITE_ENABLED) ||
                    name.equals(METRICS_GRAPHITE_SERVER) ||
                    name.equals(METRICS_GRAPHITE_PORT) ||
                    name.equals(METRICS_GRAPHITE_FILTER) ||
                    name.equals(METRICS_GRAPHITE_PUBLISH_INTERVAL) ||
                    name.equals(METRICS_GRAPHITE_PUBLISH_INTERVAL_UNIT))) {
                return;
            }

            springConfig.enabled = name.equals(METRICS_GRAPHITE_ENABLED) ? Boolean.parseBoolean(event.getPropertyValue() + "") : springConfig.enabled;

            destroyReporterLoader();
            if (springConfig.enabled) {
                createReporterLoader();
            }

        }
    });
}

private ConfigurationHelper(String applicationContextName)
{   

 DataSource ds = getDataSourceForContext(applicationContextName);                   
 DatabaseConfiguration config = new DatabaseConfiguration(ds,
                 TABLE_NAME, KEY_COLUMN, VALUE_COLUMN);

 ConfigurationListener listener = new LockoutConfigurationListener();
 config.addConfigurationListener(listener);
 config.addErrorListener((ConfigurationErrorListener) listener);            
 config.setDelimiterParsingDisabled(true);
 dataConfig = new DataConfiguration(config);
}

public void addConfigurationListener(ConfigurationListener l) {
    ((PropertiesConfiguration)configuration).addConfigurationListener(l);
}

public void removeConfigurationListener(ConfigurationListener l) {
    ((PropertiesConfiguration)configuration).removeConfigurationListener(l);
}

@Test(timeout = 60000)
public void testExceptionInConfigLoad() throws Exception {
    PropertiesWriter writer = new PropertiesWriter();
    writer.setProperty("prop1", "1");
    writer.save();

    DeterministicScheduler mockScheduler = new DeterministicScheduler();
    FileConfigurationBuilder builder = new PropertiesConfigurationBuilder(writer.getFile().toURI().toURL());
    ConcurrentConstConfiguration conf = new ConcurrentConstConfiguration(new DistributedLogConfiguration());
    List<FileConfigurationBuilder> fileConfigBuilders = Lists.newArrayList(builder);
    ConfigurationSubscription confSub =
            new ConfigurationSubscription(conf, fileConfigBuilders, mockScheduler, 100, TimeUnit.MILLISECONDS);

    final AtomicInteger count = new AtomicInteger(1);
    conf.addConfigurationListener(new ConfigurationListener() {
        @Override
        public void configurationChanged(ConfigurationEvent event) {
            LOG.info("config changed {}", event);
            // Throw after so we actually see the update anyway.
            if (!event.isBeforeUpdate()) {
                count.getAndIncrement();
                throw new RuntimeException("config listener threw and exception");
            }
        }
    });

    int i = 0;
    int initial = 0;
    while (count.get() == initial) {
        writer.setProperty("prop1", Integer.toString(i++));
        writer.save();
        mockScheduler.tick(100, TimeUnit.MILLISECONDS);
    }

    initial = count.get();
    while (count.get() == initial) {
        writer.setProperty("prop1", Integer.toString(i++));
        writer.save();
        mockScheduler.tick(100, TimeUnit.MILLISECONDS);
    }
}

@Override
public void addConfigurationListener(ConfigurationListener l) {
  eventSource.addConfigurationListener(l);
}

@Override
public boolean removeConfigurationListener(ConfigurationListener l) {
  return eventSource.removeConfigurationListener(l);
}

@Override
public Collection<ConfigurationListener> getConfigurationListeners() {
  return eventSource.getConfigurationListeners();
}

public void setConfigurationListener( ConfigurationListener listener ){
    this.listener = listener;
}

public List<ConfigurationListener> getConfigurationListeners()
{
    return m_configurationListeners;
}

public void setConfigurationListeners(
        List<ConfigurationListener> configurationListeners)
{
    m_configurationListeners = configurationListeners;
}