Introduction à la méthode de lecture de .properties et de remplacement du code source par l'espace réservé ${...}-javaDidacticiel-php.cn

Cet article présente principalement les connaissances liées à la lecture du fichier .properties et à l'analyse du code source de remplacement de l'espace réservé ${...}, qui a une très bonne valeur de référence. Jetons-y un coup d'œil avec l'éditeur ci-dessous

Avant-propos

Nous rencontrons souvent un scénario en développement. Certains paramètres dans Bean sont relativement fixes. généralement utilisé pour configurer ces paramètres dans le fichier .properties, puis lorsque le bean est instancié, les paramètres configurés dans le fichier .properties sont lus en remplaçant l'espace réservé "${}" par Spring et en le définissant sur les paramètres correspondants. du Haricot.

L'exemple le plus typique de cette approche est la configuration JDBC. Cet article étudiera le code source pour lire les fichiers .properties et remplacer les espaces réservés "${}". Tout d'abord, commencez par le code, définissez une DataSource et simuler Regardons les quatre paramètres JDBC :

public class DataSource {

  /**
   * 驱动类
   */
  private String driveClass;

  /**
   * jdbc地址
   */
  private String url;

  /**
   * 用户名
   */
  private String userName;

  /**
   * 密码
   */
  private String password;

  public String getDriveClass() {
    return driveClass;
  }

  public void setDriveClass(String driveClass) {
    this.driveClass = driveClass;
  }

  public String getUrl() {
    return url;
  }

  public void setUrl(String url) {
    this.url = url;
  }

  public String getUserName() {
    return userName;
  }

  public void setUserName(String userName) {
    this.userName = userName;
  }

  public String getPassword() {
    return password;
  }

  public void setPassword(String password) {
    this.password = password;
  }

  @Override
  public String toString() {
    return "DataSource [driveClass=" + driveClass + ", url=" + url + ", userName=" + userName + ", password=" + password + "]";
  }
}

Copier après la connexion

Définir un fichier db.properties :

 driveClass=0
 url=1
 userName=2
 password=3

Copier après la connexion

Définir un fichier Properties.xml :

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xmlns:aop="http://www.springframework.org/schema/aop"
  xmlns:tx="http://www.springframework.org/schema/tx"
  xsi:schemaLocation="http://www.springframework.org/schema/beans
    http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
    http://www.springframework.org/schema/aop
    http://www.springframework.org/schema/aop/spring-aop-3.0.xsd">

  <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
    <property name="location" value="properties/db.properties"></property>
  </bean> 

  <bean id="dataSource" class="org.xrq.spring.action.properties.DataSource">
    <property name="driveClass" value="${driveClass}" />
    <property name="url" value="${url}" />
    <property name="userName" value="${userName}" />
    <property name="password" value="${password}" />
  </bean>
</beans>

Copier après la connexion

Écrivez un code de test :

public class TestProperties {

  @Test
  public void testProperties() {
    ApplicationContext ac = new ClassPathXmlApplicationContext("spring/properties.xml");

    DataSource dataSource = (DataSource)ac.getBean("dataSource");
    System.out.println(dataSource);
  }
}

Copier après la connexion

Les résultats en cours d'exécution ne seront pas publiés. Évidemment, analysons comment Spring lit l'attribut dans le fichier de propriétés et remplace l'espace réservé "${}".

Analyse de la classe PropertyPlaceholderConfigurer

Dans le fichier Properties.xml, nous voyons une classe PropertyPlaceholderConfigurer, comme son nom l'indique, il s'agit d'un configurateur d'espace réservé de propriété, jetez un œil à cette classe Diagramme de relation d'héritage :

À partir de ce diagramme, la chose la plus importante que nous pouvons analyser est que PropertyPlaceholderConfigurer est la classe d'implémentation de l'interface BeanFactoryPostProcessor de , imaginez que Le contexte Spring doit remplacer l'espace réservé "${}"< d'un seul coup via la méthode postProcessBeanFactory après le chargement de toutes les définitions du bean et avant que le bean ne soit instancié 🎜>.

Analyse du code source de lecture du fichier .properties

Jetons un coup d'œil à l'implémentation de la méthode postProcessBeanFactory :

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
  try {
    Properties mergedProps = mergeProperties();

    // Convert the merged properties, if necessary.
    convertProperties(mergedProps);
    // Let the subclass process the properties.
    processProperties(beanFactory, mergedProps);
  }
  catch (IOException ex) {
    throw new BeanInitializationException("Could not load properties", ex);
  }
}

Copier après la connexion

Suivez la méthode mergeProperties en ligne 3 :

protected Properties mergeProperties() throws IOException {
  Properties result = new Properties();

  if (this.localOverride) {
    // Load properties from file upfront, to let local properties override.
    loadProperties(result);
  }

  if (this.localProperties != null) {
    for (Properties localProp : this.localProperties) {
      CollectionUtils.mergePropertiesIntoMap(localProp, result);
    }
  }

  if (!this.localOverride) {
    // Load properties from file afterwards, to let those properties override.
    loadProperties(result);
  }
  return result;
}

Copier après la connexion

La méthode de la ligne 2 new crée une propriété nommée result. Ce résultat sera transmis avec le code suivant et les données du fichier .properties seront écrites dans le résultat.

OK, voyons comment le code entre dans la ligne 17, en chargeant le fichier .properties via le fichier :

protected void loadProperties(Properties props) throws IOException {
  if (this.locations != null) {
    for (Resource location : this.locations) {
      if (logger.isInfoEnabled()) {
        logger.info("Loading properties file from " + location);
      }
      InputStream is = null;
      try {
        is = location.getInputStream();

        String filename = null;
        try {
          filename = location.getFilename();
        } catch (IllegalStateException ex) {
          // resource is not file-based. See SPR-7552.
        }

        if (filename != null && filename.endsWith(XML_FILE_EXTENSION)) {
          this.propertiesPersister.loadFromXml(props, is);
        }
        else {
          if (this.fileEncoding != null) {
            this.propertiesPersister.load(props, new InputStreamReader(is, this.fileEncoding));
          }
          else {
            this.propertiesPersister.load(props, is);
          }
        }
      }
      catch (IOException ex) {
        if (this.ignoreResourceNotFound) {
          if (logger.isWarnEnabled()) {
            logger.warn("Could not load properties from " + location + ": " + ex.getMessage());
          }
        }
        else {
          throw ex;
        }
      }
      finally {
        if (is != null) {
          is.close();
        }
      }
    }
  }
}

Copier après la connexion

Ligne 9, la configuration de PropertyPlaceholderConfigurer peut être passée dans la liste des chemins ( bien sûr, ici un seul db.properties est passé), la ligne 3 parcourt la liste, la ligne 9 obtient les données binaires correspondant à .properties via un flux d'octets d'entrée InputStream, puis le code de la ligne 23 analyse le binaire dans InputStream et écrit dans le premier Parmi les paramètres Propriétés, Propriétés est l'outil natif du JDK pour lire les fichiers .properties.

Dans un processus aussi simple, les données de .properties sont analysées et écrites dans le résultat (le résultat est une nouvelle propriété générée dans la méthode mergeProperties).

L'espace réservé "${...}" remplace l'analyse du code source

Le processus de lecture du fichier .properties a été vu ci-dessus, puis "${}" devrait être remplacé "espace réservé, revenons à la méthode postProcessBeanFactory :

public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
  try {
    Properties mergedProps = mergeProperties();

    // Convert the merged properties, if necessary.
    convertProperties(mergedProps);
    // Let the subclass process the properties.
    processProperties(beanFactory, mergedProps);
  }
  catch (IOException ex) {
    throw new BeanInitializationException("Could not load properties", ex);
  }
}

Copier après la connexion

La ligne 3 fusionne les fichiers .properties (c'est ce qu'on appelle la fusion car plusieurs fichiers .properties peuvent avoir la même clé).

La ligne 6 convertit les propriétés fusionnées si nécessaire, mais je n'en vois aucune utilité.

La ligne 9 commence par remplacer l'espace réservé "${...}". Une chose à déclarer à l'avance :

La méthode postProcessBeanFactory de la classe BeanFactoryPostProcessor est appelée après l'analyse de la définition du Bean. , donc les paramètres actuels de beanFactory ont déjà toutes les définitions de Bean Les amis qui connaissent le processus d'analyse de Bean devraient très bien le savoir. Suivez la méthode processProperties à la ligne 9 :

protected void processProperties(ConfigurableListableBeanFactory beanFactoryToProcess, Properties props)
    throws BeansException {

  StringValueResolver valueResolver = new PlaceholderResolvingStringValueResolver(props);
  BeanDefinitionVisitor visitor = new BeanDefinitionVisitor(valueResolver);

  String[] beanNames = beanFactoryToProcess.getBeanDefinitionNames();
  for (String curName : beanNames) {
    // Check that we&#39;re not parsing our own bean definition,
    // to avoid failing on unresolvable placeholders in properties file locations.
    if (!(curName.equals(this.beanName) && beanFactoryToProcess.equals(this.beanFactory))) {
      BeanDefinition bd = beanFactoryToProcess.getBeanDefinition(curName);
      try {
        visitor.visitBeanDefinition(bd);
      }
      catch (Exception ex) {
        throw new BeanDefinitionStoreException(bd.getResourceDescription(), curName, ex.getMessage());
      }
    }
  }

  // New in Spring 2.5: resolve placeholders in alias target names and aliases as well.
  beanFactoryToProcess.resolveAliases(valueResolver);
  // New in Spring 3.0: resolve placeholders in embedded values such as annotation attributes.
  beanFactoryToProcess.addEmbeddedValueResolver(valueResolver);
}

Copier après la connexion

La ligne 4 crée un nouveau PlaceholderResolvingStringValueResolver et transmet Properties Comme son nom l'indique, il s'agit d'une

chaîne qui contient le fichier .properties. configuration.

Ligne 5 BeanDefinitionVistor, passez le StringValueResolver ci-dessus, comme son nom l'indique, il s'agit d'un outil d'accès à la définition du Bean, contenant un analyseur de valeur de chaîne, imaginez

Vous pouvez accéder à la définition du Bean via BeanDefinitionVistor , lors de la rencontre Lorsque la chaîne qui doit être analysée est utilisée, le StringValueResolver transmis par le constructeur est utilisé pour analyser la chaîne .

La ligne 7 obtient les noms de toutes les définitions de Bean via BeanFactory.

La ligne 8 commence à parcourir les noms de toutes les définitions de Bean. Faites attention au premier jugement de la ligne 11

"!(curName.equals(this.beanName)" <🎜. > , this.beanName fait référence à PropertyPlaceholderConfigurer, ce qui signifie que PropertyPlaceholderConfigurer lui-même n'analysera pas l'espace réservé "${...}".

着重跟14行的代码，BeanDefinitionVistor的visitBeanDefinition方法，传入BeanDefinition：

public void visitBeanDefinition(BeanDefinition beanDefinition) {
  visitParentName(beanDefinition);
  visitBeanClassName(beanDefinition);
  visitFactoryBeanName(beanDefinition);
  visitFactoryMethodName(beanDefinition);
  visitScope(beanDefinition);
  visitPropertyValues(beanDefinition.getPropertyValues());
  ConstructorArgumentValues cas = beanDefinition.getConstructorArgumentValues();
  visitIndexedArgumentValues(cas.getIndexedArgumentValues());
  visitGenericArgumentValues(cas.getGenericArgumentValues());
}

Copier après la connexion

看到这个方法轮番访问定义中的parent、class、factory-bean、factory-method、scope、property、constructor-arg属性，但凡遇到需要"${...}"就进行解析。我们这里解析的是property标签中的"${...}"，因此跟一下第7行的代码：

protected void visitPropertyValues(MutablePropertyValues pvs) {
  PropertyValue[] pvArray = pvs.getPropertyValues();
  for (PropertyValue pv : pvArray) {
    Object newVal = resolveValue(pv.getValue());
    if (!ObjectUtils.nullSafeEquals(newVal, pv.getValue())) {
      pvs.add(pv.getName(), newVal);
    }
  }
}

Copier après la connexion

获取属性数组进行遍历，第4行的代码对属性值进行解析获取新属性值，第5行判断新属性值与原属性值不等，第6行的代码用新属性值替换原属性值。因此跟一下第4行的resolveValue方法：

protected Object resolveValue(Object value) {
  if (value instanceof BeanDefinition) {
    visitBeanDefinition((BeanDefinition) value);
  }
  else if (value instanceof BeanDefinitionHolder) {
    visitBeanDefinition(((BeanDefinitionHolder) value).getBeanDefinition());
  }
  else if (value instanceof RuntimeBeanReference) {
    RuntimeBeanReference ref = (RuntimeBeanReference) value;
    String newBeanName = resolveStringValue(ref.getBeanName());
    if (!newBeanName.equals(ref.getBeanName())) {
      return new RuntimeBeanReference(newBeanName);
    }
  }
  else if (value instanceof RuntimeBeanNameReference) {
    RuntimeBeanNameReference ref = (RuntimeBeanNameReference) value;
    String newBeanName = resolveStringValue(ref.getBeanName());
    if (!newBeanName.equals(ref.getBeanName())) {
      return new RuntimeBeanNameReference(newBeanName);
    }
  }
  else if (value instanceof Object[]) {
    visitArray((Object[]) value);
  }
  else if (value instanceof List) {
    visitList((List) value);
  }
  else if (value instanceof Set) {
    visitSet((Set) value);
  }
  else if (value instanceof Map) {
    visitMap((Map) value);
  }
  else if (value instanceof TypedStringValue) {
    TypedStringValue typedStringValue = (TypedStringValue) value;
    String stringValue = typedStringValue.getValue();
    if (stringValue != null) {
      String visitedString = resolveStringValue(stringValue);
      typedStringValue.setValue(visitedString);
    }
  }
  else if (value instanceof String) {
    return resolveStringValue((String) value);
  }
  return value;
}

Copier après la connexion

这里主要对value类型做一个判断，我们配置文件里面配置的是字符串，因此就看字符串相关代码，即34行的判断进去，其余的差不多，可以自己看一下源码是怎么做的。第35~第36行的代码就是获取属性值，第38行的代码resolveStringValue方法解析字符串：

protected String resolveStringValue(String strVal) {
  if (this.valueResolver == null) {
    throw new IllegalStateException("No StringValueResolver specified - pass a resolver " +
        "object into the constructor or override the &#39;resolveStringValue&#39; method");
  }
  String resolvedValue = this.valueResolver.resolveStringValue(strVal);
  // Return original String if not modified.
  return (strVal.equals(resolvedValue) ? strVal : resolvedValue);
}

Copier après la connexion

继续跟第6行的方法，valueResolver前面说过了，是传入的一个PlaceholderResolvingStringValueResolver，看一下resolveStringValue方法实现：

 public String resolveStringValue(String strVal) throws BeansException {
   String value = this.helper.replacePlaceholders(strVal, this.resolver);
   return (value.equals(nullValue) ? null : value);
 }

Copier après la connexion

第2行的replacePlaceholders方法顾名思义，替换占位符，它位于PropertyPlaceholderHelper类中，跟一下这个方法：

 public String replacePlaceholders(String value, PlaceholderResolver placeholderResolver) {
   Assert.notNull(value, "Argument &#39;value&#39; must not be null.");
   return parseStringValue(value, placeholderResolver, new HashSet<String>());
}

Copier après la connexion

继续跟第3行的parseStringValue方法，即追踪到了替换占位符的核心代码中：

protected String parseStringValue(
    String strVal, PlaceholderResolver placeholderResolver, Set<String> visitedPlaceholders) {

  StringBuilder buf = new StringBuilder(strVal);

  int startIndex = strVal.indexOf(this.placeholderPrefix);
  while (startIndex != -1) {
    int endIndex = findPlaceholderEndIndex(buf, startIndex);
    if (endIndex != -1) {
      String placeholder = buf.substring(startIndex + this.placeholderPrefix.length(), endIndex);
      if (!visitedPlaceholders.add(placeholder)) {
        throw new IllegalArgumentException(
            "Circular placeholder reference &#39;" + placeholder + "&#39; in property definitions");
      }
      // Recursive invocation, parsing placeholders contained in the placeholder key.
      placeholder = parseStringValue(placeholder, placeholderResolver, visitedPlaceholders);

      // Now obtain the value for the fully resolved key...
      String propVal = placeholderResolver.resolvePlaceholder(placeholder);
      if (propVal == null && this.valueSeparator != null) {
        int separatorIndex = placeholder.indexOf(this.valueSeparator);
        if (separatorIndex != -1) {
          String actualPlaceholder = placeholder.substring(0, separatorIndex);
          String defaultValue = placeholder.substring(separatorIndex + this.valueSeparator.length());
          propVal = placeholderResolver.resolvePlaceholder(actualPlaceholder);
          if (propVal == null) {
            propVal = defaultValue;
          }
        }
      }
      if (propVal != null) {
        // Recursive invocation, parsing placeholders contained in the
        // previously resolved placeholder value.
        propVal = parseStringValue(propVal, placeholderResolver, visitedPlaceholders);
        buf.replace(startIndex, endIndex + this.placeholderSuffix.length(), propVal);
        if (logger.isTraceEnabled()) {
          logger.trace("Resolved placeholder &#39;" + placeholder + "&#39;");
        }
        startIndex = buf.indexOf(this.placeholderPrefix, startIndex + propVal.length());
      }
      else if (this.ignoreUnresolvablePlaceholders) {
        // Proceed with unprocessed value.
        startIndex = buf.indexOf(this.placeholderPrefix, endIndex + this.placeholderSuffix.length());
      }
      else {
        throw new IllegalArgumentException("Could not resolve placeholder &#39;" + placeholder + "&#39;");
      }

      visitedPlaceholders.remove(placeholder);
    }
    else {
      startIndex = -1;
    }
  }

  return buf.toString();
}

Copier après la connexion

过一下此流程：

获取占位符前缀"${"的位置索引startIndex

占位符前缀"${"存在，从"${"后面开始获取占位符后缀"}"的位置索引endIndex

如果占位符前缀位置索引startIndex与占位符后缀的位置索引endIndex都存在，截取中间的部分placeHolder

从Properties中获取placeHolder对应的值propVal

如果propVal不存在，尝试对placeHolder使用":"进行一次分割，如果分割出来有结果，那么前面一部分命名为actualPlaceholder，后面一部分命名为defaultValue，尝试从Properties中获取actualPlaceholder对应的value，如果存在则取此value，如果不存在则取defaultValue，最终赋值给propVal

返回propVal，就是替换之后的值

流程很长，通过这样一整个的流程，将占位符"${...}"中的内容替换为了我们需要的值。

【相关推荐】

1. Java免费视频教程

2. JAVA教程手册

3. 全面解析Java注解
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!