docs: public void propertiesReloaded(PropertiesReloadedEvent event) {
  
          Properties oldProperties = lastMergedProperties;
  
          try {
              //
              Properties newProperties = mergeProperties();
  
              //
              // 获取哪些 dynamic property 被影响
              //
              Set<String> placeholders = placeholderToDynamics.keySet();
              Set<DynamicProperty> allDynamics = new HashSet<DynamicProperty>();
              for (String placeholder : placeholders) {
                  String newValue = newProperties.getProperty(placeholder);
                  String oldValue = oldProperties.getProperty(placeholder);
                  if (newValue != null && !newValue.equals(oldValue) || newValue == null && oldValue != null) {
                      if (logger.isInfoEnabled()) {
                          logger.info("Property changed detected: " + placeholder +
                                  (newValue != null ? "=" + newValue : " removed"));
                      }
                      List<DynamicProperty> affectedDynamics = placeholderToDynamics.get(placeholder);
                      allDynamics.addAll(affectedDynamics);
                  }
              }
  
              //
              // 获取受影响的beans
              //
              Map<String, List<DynamicProperty>> dynamicsByBeanName = new HashMap<String, List<DynamicProperty>>();
              Map<String, Object> beanByBeanName = new HashMap<String, Object>();
              for (DynamicProperty dynamic : allDynamics) {
                  String beanName = dynamic.getBeanName();
                  List<DynamicProperty> l = dynamicsByBeanName.get(beanName);
  
                  if (l == null) {
                      dynamicsByBeanName.put(beanName, (l = new ArrayList<DynamicProperty>()));
                      Object bean = null;
                      try {
                          bean = applicationContext.getBean(beanName);
                          beanByBeanName.put(beanName, bean);
                      } catch (BeansException e) {
                          // keep dynamicsByBeanName list, warn only once.
                          logger.error("Error obtaining bean " + beanName, e);
                      }
  
                      //
                      // say hello
                      //
                      try {
                          if (bean instanceof IReconfigurationAware) {
                              ((IReconfigurationAware) bean).beforeReconfiguration();  // hello!
                          }
                      } catch (Exception e) {
                          logger.error("Error calling beforeReconfiguration on " + beanName, e);
                      }
                  }
                  l.add(dynamic);
              }
  
              //
              // 处理受影响的bean
              //
              Collection<String> beanNames = dynamicsByBeanName.keySet();
              for (String beanName : beanNames) {
                  Object bean = beanByBeanName.get(beanName);
                  if (bean == null) // problems obtaining bean, earlier
                  {
                      continue;
                  }
                  BeanWrapper beanWrapper = new BeanWrapperImpl(bean);
  
                  // for all affected ...
                  List<DynamicProperty> dynamics = dynamicsByBeanName.get(beanName);
                  for (DynamicProperty dynamic : dynamics) {
                      String propertyName = dynamic.getPropertyName();
                      String unparsedValue = dynamic.getUnparsedValue();
  
                      // obtain an updated value, including dependencies
                      String newValue;
                      removeDynamic(dynamic);
                      currentBeanName = beanName;
                      currentPropertyName = propertyName;
                      try {
                          newValue = parseStringValue(unparsedValue, newProperties, new HashSet());
                      } finally {
                          currentBeanName = null;
                          currentPropertyName = null;
                      }
                      if (logger.isInfoEnabled()) {
                          logger.info("Updating property " + beanName + "." + propertyName + " to " + newValue);
                      }
  
                      // assign it to the bean
                      try {
                          beanWrapper.setPropertyValue(propertyName, newValue);
                      } catch (BeansException e) {
                          logger.error("Error setting property " + beanName + "." + propertyName + " to " + newValue, e);
                      }
                  }
              }
  
              //
              // say goodbye.
              //
              for (String beanName : beanNames) {
                  Object bean = beanByBeanName.get(beanName);
                  try {
  
                      if (bean instanceof IReconfigurationAware) {
                          ((IReconfigurationAware) bean).afterReconfiguration();
                      }
                  } catch (Exception e) {
                      logger.error("Error calling afterReconfiguration on " + beanName, e);
                  }
              }
  
          } catch (IOException e) {
              logger.error("Error trying to reload net.unicon.iamlabs.spring.properties.example.net.unicon.iamlabs" +
                      ".spring" + ".properties: " + e.getMessage(), e);
          }
      }