com.ctrip.framework.apollo.enums.PropertyChangeType Java Examples

@Override
public synchronized void onRepositoryChange(String namespace, Properties newProperties) {
  if (newProperties.equals(m_configProperties.get())) {
    return;
  }
  Properties newConfigProperties = propertiesFactory.getPropertiesInstance();
  newConfigProperties.putAll(newProperties);

  String oldValue = getContent();

  update(newProperties);
  m_sourceType = m_configRepository.getSourceType();

  String newValue = getContent();

  PropertyChangeType changeType = PropertyChangeType.MODIFIED;

  if (oldValue == null) {
    changeType = PropertyChangeType.ADDED;
  } else if (newValue == null) {
    changeType = PropertyChangeType.DELETED;
  }

  this.fireConfigChange(new ConfigFileChangeEvent(m_namespace, oldValue, newValue, changeType));

  Tracer.logEvent("Apollo.Client.ConfigChanges", m_namespace);
}
 

/**
 * Constructor.
 * @param namespace the namespace of the key
 * @param propertyName the key whose value is changed
 * @param oldValue the value before change
 * @param newValue the value after change
 * @param changeType the change type
 */
public ConfigChange(String namespace, String propertyName, String oldValue, String newValue,
                    PropertyChangeType changeType) {
  this.namespace = namespace;
  this.propertyName = propertyName;
  this.oldValue = oldValue;
  this.newValue = newValue;
  this.changeType = changeType;
}
 

@Test
@DirtiesContext
public void testListenerTriggeredByDel()
    throws InterruptedException, ExecutionException, TimeoutException {
  embeddedApollo.deleteProperty(otherNamespace, "key1");
  ConfigChangeEvent changeEvent = testBean.futureData.get(5000, TimeUnit.MILLISECONDS);
  assertEquals(otherNamespace, changeEvent.getNamespace());
  assertEquals(PropertyChangeType.DELETED, changeEvent.getChange("key1").getChangeType());
}
 

private DataChangedEvent.ChangedType getChangedType(final PropertyChangeType changeType) {
    switch (changeType) {
        case ADDED:
        case MODIFIED:
            return DataChangedEvent.ChangedType.UPDATED;
        case DELETED:
            return DataChangedEvent.ChangedType.DELETED;
        default:
            return DataChangedEvent.ChangedType.IGNORED;
    }
}
 

@Test
public void assertAddChangeListener() throws Exception {
    final SettableFuture<ConfigChangeEvent> future = SettableFuture.create();
    ConfigChangeListener listener = future::set;
    configWrapper.addChangeListener(listener, Collections.singleton("test.children.2"));
    embeddedApollo.addOrModifyProperty("orchestration", "test.children.2", "value3");
    ConfigChangeEvent changeEvent = future.get(5, TimeUnit.SECONDS);
    assertTrue(changeEvent.isChanged("test.children.2"));
    assertThat(changeEvent.getChange("test.children.2").getOldValue(), is("value2"));
    assertThat(changeEvent.getChange("test.children.2").getNewValue(), is("value3"));
    assertThat(changeEvent.getChange("test.children.2").getChangeType(), is(PropertyChangeType.MODIFIED));
}
 

@Test
public void assertAddChangeListenerWithInterestedKeyPrefixes() throws Exception {
    final SettableFuture<ConfigChangeEvent> future = SettableFuture.create();
    ConfigChangeListener listener = future::set;
    configWrapper.addChangeListener(listener, Collections.singleton("test.children.1"), Collections.singleton("test.children.2"));
    embeddedApollo.addOrModifyProperty("orchestration", "test.children.2.1", "value4");
    ConfigChangeEvent changeEvent = future.get(5, TimeUnit.SECONDS);
    assertTrue(changeEvent.isChanged("test.children.2.1"));
    assertThat(changeEvent.getChange("test.children.2.1").getNewValue(), is("value4"));
    assertThat(changeEvent.getChange("test.children.2.1").getChangeType(), is(PropertyChangeType.ADDED));
}
 

List<ConfigChange> calcPropertyChanges(String namespace, Properties previous,
                                       Properties current) {
  if (previous == null) {
    previous = propertiesFactory.getPropertiesInstance();
  }

  if (current == null) {
    current =  propertiesFactory.getPropertiesInstance();
  }

  Set<String> previousKeys = previous.stringPropertyNames();
  Set<String> currentKeys = current.stringPropertyNames();

  Set<String> commonKeys = Sets.intersection(previousKeys, currentKeys);
  Set<String> newKeys = Sets.difference(currentKeys, commonKeys);
  Set<String> removedKeys = Sets.difference(previousKeys, commonKeys);

  List<ConfigChange> changes = Lists.newArrayList();

  for (String newKey : newKeys) {
    changes.add(new ConfigChange(namespace, newKey, null, current.getProperty(newKey),
        PropertyChangeType.ADDED));
  }

  for (String removedKey : removedKeys) {
    changes.add(new ConfigChange(namespace, removedKey, previous.getProperty(removedKey), null,
        PropertyChangeType.DELETED));
  }

  for (String commonKey : commonKeys) {
    String previousValue = previous.getProperty(commonKey);
    String currentValue = current.getProperty(commonKey);
    if (Objects.equal(previousValue, currentValue)) {
      continue;
    }
    changes.add(new ConfigChange(namespace, commonKey, previousValue, currentValue,
        PropertyChangeType.MODIFIED));
  }

  return changes;
}
 

public PropertyChangeType getChangeType() {
  return changeType;
}
 

public PropertyChangeType getChangeType() {
  return changeType;
}
 

public void setChangeType(PropertyChangeType changeType) {
  this.changeType = changeType;
}
 

/***
 * 根据changeEvent和定义的pattern匹配key，如果所有对应PropertyChangeType为DELETED则需要清空GatewayProperties里相关集合
 *
 * @param changeEvent
 * @param pattern
 * @param existSize
 * @return boolean
 * @author ksewen
 * @date 2019/5/23 2:18 PM
 */
private boolean checkNeedClear(ConfigChangeEvent changeEvent, String pattern, int existSize) {

    return changeEvent.changedKeys().stream().filter(key -> key.matches(pattern))
            .filter(key -> {
                ConfigChange change = changeEvent.getChange(key);
                return PropertyChangeType.DELETED.equals(change.getChangeType());
            }).count() == existSize;
}
 

/**
 * Constructor.
 *
 * @param namespace the namespace of the config file change event
 * @param oldValue the value before change
 * @param newValue the value after change
 * @param changeType the change type
 */
public ConfigFileChangeEvent(String namespace, String oldValue, String newValue,
    PropertyChangeType changeType) {
  this.namespace = namespace;
  this.oldValue = oldValue;
  this.newValue = newValue;
  this.changeType = changeType;
}