6 façons de lire les fichiers de propriétés, recommandées pour la collecte !

Le centre de configuration distribué manuscrit progresse étape par étape.

De nos jours, nous utilisons essentiellement Spring Boot pour le développement, et tout le monde sait qu'il y aura un application.properties fichier de configuration (certains sont également des application.yaml, de toute façon, il est utilisé pour enregistrer certaines de nos informations de configuration), généralement nous écrirons certaines informations de configuration dans le fichier de propriétés, telles que : base de données informations de connexion, informations d'interface tierce (clé, nom d'utilisateur, mot de passe, adresse, etc.), pool de connexions, informations de configuration Redis, diverses informations de configuration de composants tiers, etc. application.properties配置文件（也有的是application.yaml，反正就是用来保存我们的一些配置信息），通常我们会把一些配置信息写到properties文件中，比如：数据库连接信息、第三方接口信息（密钥、用户名、密码、地址等），连接池、Redis配置信息、各种第三方组件配置信息等。

单体服务，甚至一些小型的分布式架构中，项目的配置都是依赖一个application.properties配置文件来解决（可能有的项目会搞一个环境区分，比如：application-dev.properties、application-pro.properties

Dans les services uniques, et même dans certaines petites architectures distribuées, la configuration du projet repose sur un application.properties pour résoudre le problème (certains projets peuvent faire une distinction d'environnement, comme : application-dev.properties, application-pro.properties, etc.). Cependant, à mesure que l'activité se développe et que l'architecture continue de se mettre à niveau, de plus en plus de données de service et d'informations de configuration seront impliquées dans chaque service, et les exigences en matière de gestion de la configuration deviendront également de plus en plus élevées, comme une configuration en temps réel et indépendante. informations. Sexe, etc.

Dans le même temps, dans le cadre de l'architecture des microservices, nous pouvons également impliquer la gestion de la configuration, la publication en niveaux de gris, la limitation dynamique du courant, la rétrogradation dynamique et d'autres exigences dans différents environnements, y compris la sécurité et les autorisations du contenu de configuration, donc la maintenance de configuration traditionnelle. est difficile de répondre à la demande.

Ainsi, le centre de configuration distribué est né dans un tel environnement.

Dans cet article, nous découvrons d'abord quelles sont les méthodes disponibles pour lire le fichier de configuration des propriétés en Java. 🎜6 façons pour Java de lire les fichiers de configuration des propriétés -rayon : 4 px ; marge droite : 2 px ; marge gauche : 2 px ; couleur d'arrière-plan : rgba (27, 31, 35, 0,05) ; famille de polices : « Operator Mono », Consolas, Monaco, Menlo, mot monospace ; -break: break-all;color: rgb(239, 112, 96);">jdbc.properties fichier de configuration, comme suit :

jdbc.driver=com.mysql.cj.jdbc.Driver
jdbc.url=mysql://localhost:3306/database?useUnicode=true&characterEncoding=utf-8&serverTimezone=Asia/Shanghai
jdbc.username=root
jdbc.password=123456

Maintenant, je veux obtenir le fichier de configuration ci-dessus dans le contenu du code Java . La première façon

La première façon que nous utilisons : this.getClass().getResourceAsStream()+PropriétésImplémentation du code :

/**
* @author tianwc  公众号：java后端技术全栈、面试专栏
* @version 1.0.0
* @date 2023年05月27日 09:13
* 在线刷题1200+，100+篇干货文章：<a href="http://woaijava.cc/">博客地址</a>
*/
public void readProperties1() throws IOException {
    //不加/会从当前包进行寻找，加上/会从src开始找
    InputStream inputStream = this.getClass().getResourceAsStream("/jdbc.properties");
    Properties properties=new Properties();
    properties.load(inputStream);
    System.out.println("jdbc.driver="+properties.getProperty("jdbc.driver"));
    System.out.println("jdbc.url="+properties.getProperty("jdbc.url"));
    System.out.println("jdbc.username="+properties.getProperty("jdbc.username"));
    System.out.println("jdbc.password="+properties.getProperty("jdbc.password"));
}

Parlons du code ci-dessus :

jdbc.properties 配置文件，内如如下：

public synchronized void load(InputStream inStream) throws IOException {
        load0(new LineReader(inStream));
    }

    private void load0 (LineReader lr) throws IOException {
        char[] convtBuf = new char[1024];
        int limit;
        int keyLen;
        int valueStart;
        char c;
        boolean hasSep;
        boolean precedingBackslash;
        //逐行读取
        while ((limit = lr.readLine()) >= 0) {
            c = 0;
            keyLen = 0;
            valueStart = limit;
            hasSep = false;

            //System.out.println("line=<" + new String(lineBuf, 0, limit) + ">");
            precedingBackslash = false;
            while (keyLen < limit) {
                c = lr.lineBuf[keyLen];
                //need check if escaped.
                if ((c == &#39;=&#39; ||  c == &#39;:&#39;) && !precedingBackslash) {
                    valueStart = keyLen + 1;
                    hasSep = true;
                    break;
                } else if ((c == &#39; &#39; || c == &#39;\t&#39; ||  c == &#39;\f&#39;) && !precedingBackslash) {
                    valueStart = keyLen + 1;
                    break;
                }
                if (c == &#39;\&#39;) {
                    precedingBackslash = !precedingBackslash;
                } else {
                    precedingBackslash = false;
                }
                keyLen++;
            }
            while (valueStart < limit) {
                c = lr.lineBuf[valueStart];
                if (c != &#39; &#39; && c != &#39;\t&#39; &&  c != &#39;\f&#39;) {
                    if (!hasSep && (c == &#39;=&#39; ||  c == &#39;:&#39;)) {
                        hasSep = true;
                    } else {
                        break;
                    }
                }
                valueStart++;
            }
            //前面一堆代码就是做校验和解析
            //下面两个是做转换
            String key = loadConvert(lr.lineBuf, 0, keyLen, convtBuf);
            String value = loadConvert(lr.lineBuf, valueStart, limit - valueStart, convtBuf);
            
            put(key, value);
        }
    }

现在是想要在java代码中获取上面配置文件内容。

第一种方式

第一种方式我们采用：this.getClass().getResourceAsStream()+Properties

代码实现：

public String getProperty(String key) {
    Object oval = super.get(key);
    String sval = (oval instanceof String) ? (String)oval : null;
    return ((sval == null) && (defaults != null)) ? defaults.getProperty(key) : sval;
}

下面来聊聊上面的这段代码：

this.getClass().getResourceAsStream()

具体文件和代码的位置是，代码在src/main/java目录下，资源文件在src/main/resources/

this.getClass().getResourceAsStream()

Fichiers spécifiques et l'emplacement du code est, le code est en src/main/java répertoire, les fichiers de ressources sont au format <code style="font-size: 14px;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color: rgba(27 , 31, 35, 0.05);famille de polices : " operator mono consolas monaco menlo monospace de mot break-all rgb>src/main/ resources/ répertoire.

🎜 sera trouvé dans le répertoire de la classe courante Si ce fichier n'est pas dans le même répertoire que la classe, il ne sera pas trouvé. 🎜🎜Il sera trouvé dans l'intégralité du répertoire des classes compilées. Maven regroupera également les fichiers de ressources dans le dossier classes, afin qu'ils puissent être trouvés. 🎜

ClassLoader就是从整个classes文件夹找的，所以前面无需再加/

Properties

Properties：java.util.Properties，该类主要用于读取Java的配置文件，不同的编程语言有自己所支持的配置文件，配置文件中很多变量是经常改变的，为了方便用户的配置，能让用户够脱离程序本身去修改相关的变量设置。就像在Java中，其配置文件常为.properties文件，是以键值对的形式进行参数配置的。

类关系图：

从上面的类图可以看到Properties类继承至Hashtable，相信大家都知道Hashtable是存储key-value数据结构类，也刚好对应我们properties文件内容也是key-value形式。

Properties 常见方法

getProperty(String key)   ：在此属性列表中搜索具有指定键的属性。如果在此属性列表中找不到该键，则会检查默认属性列表及其默认值（递归）。如果未找到该属性，则该方法返回默认值参数。

list(PrintStream out) Imprimez cette liste de propriétés dans le flux de sortie spécifié. Cette méthode est utile pour le débogage.

load(InputStream inStream) : depuis l'entrée Lit une liste d'attributs (paires de clés et d'éléments) à partir d'un flux d'octets. Le flux d'entrée est dans le format orienté ligne simple spécifié dans le chargeur (lecteur) et suppose l'utilisation de ISO 8859-1Codage de caractères ; c'est-à-dire que chaque octet est un caractère Latin1. Les caractères qui ne sont pas en Latin1 et certains caractères spéciaux sont représentés dans les clés et les éléments à l'aide d'échappements Unicode. Après le retour de cette méthode, le flux spécifié reste ouvert. load(InputStream inStream)  ：从输入字节流中读取属性列表（键和元素对）。输入流采用加载（Reader）中指定的简单的面向行的格式，并假定使用ISO 8859-1字符编码;即每个字节是一个Latin1字符。不在Latin1中的字符和某些特殊字符在使用Unicode转义符的键和元素中表示。 此方法返回后，指定的流仍保持打开状态。

setProperty(String key, String  value) ：调用 Hashtable 的方法 put 。他通过调用基类的put方法来设置 键值对。

store(OutputStream out, String comments) ：将此Properties表中的此属性列表（键和元素对）以适合使用load（InputStream）方法加载到Properties表的格式写入输出流。 此Properties方法不会写出此Properties表的defaults表中的属性（如果有）。

storeToXML(OutputStream os, String comment, String encoding) ：使用指定的编码发出表示此表中包含的所有属性的XML文档。

clear()  ：清除此哈希表，使其不包含任何键。

stringPropertyNames()

setProperty(String key, String value) : Appelez la méthode put de Hashtable. Il définit les paires clé-valeur en appelant la méthode put de la classe de base. 🎜🎜store(OutputStream out, String comments) : Écrit cette liste de propriétés (paires clé et élément) de cette table Propriétés dans le flux de sortie dans un format adapté au chargement dans la table Propriétés à l'aide de la méthode load(InputStream). Cette méthode Propriétés n'écrit pas les propriétés (le cas échéant) dans la table des valeurs par défaut de cette table Propriétés. 🎜🎜storeToXML(OutputStream os, String commentaire, String encoding) : Émet un document XML représentant tous les attributs contenus dans cette table en utilisant l'encodage spécifié. 🎜🎜clear() ：Effacer ce hachage table afin qu’elle ne contienne aucune clé. 🎜🎜stringPropertyNames() : Renvoie cette propriété Un ensemble de clés dans une liste où les clés et leurs valeurs correspondantes sont des chaînes, y compris différentes clés de la liste de propriétés par défaut si une clé du même nom n'a pas été trouvée dans la liste de propriétés principale. Les clés ou propriétés dont les clés ne sont pas de type String seront omises. 🎜

properties.load(inputStream)

public synchronized void load(InputStream inStream) throws IOException {
        load0(new LineReader(inStream));
    }

    private void load0 (LineReader lr) throws IOException {
        char[] convtBuf = new char[1024];
        int limit;
        int keyLen;
        int valueStart;
        char c;
        boolean hasSep;
        boolean precedingBackslash;
        //逐行读取
        while ((limit = lr.readLine()) >= 0) {
            c = 0;
            keyLen = 0;
            valueStart = limit;
            hasSep = false;

            //System.out.println("line=<" + new String(lineBuf, 0, limit) + ">");
            precedingBackslash = false;
            while (keyLen < limit) {
                c = lr.lineBuf[keyLen];
                //need check if escaped.
                if ((c == &#39;=&#39; ||  c == &#39;:&#39;) && !precedingBackslash) {
                    valueStart = keyLen + 1;
                    hasSep = true;
                    break;
                } else if ((c == &#39; &#39; || c == &#39;\t&#39; ||  c == &#39;\f&#39;) && !precedingBackslash) {
                    valueStart = keyLen + 1;
                    break;
                }
                if (c == &#39;\\&#39;) {
                    precedingBackslash = !precedingBackslash;
                } else {
                    precedingBackslash = false;
                }
                keyLen++;
            }
            while (valueStart < limit) {
                c = lr.lineBuf[valueStart];
                if (c != &#39; &#39; && c != &#39;\t&#39; &&  c != &#39;\f&#39;) {
                    if (!hasSep && (c == &#39;=&#39; ||  c == &#39;:&#39;)) {
                        hasSep = true;
                    } else {
                        break;
                    }
                }
                valueStart++;
            }
            //前面一堆代码就是做校验和解析
            //下面两个是做转换
            String key = loadConvert(lr.lineBuf, 0, keyLen, convtBuf);
            String value = loadConvert(lr.lineBuf, valueStart, limit - valueStart, convtBuf);
            
            put(key, value);
        }
    }

最后调用put(key, value);这个put方法就是Hashtable中的put方法。这里可以这么理解：将我们的配置项保存到Hashtable中。

getProperty(String key)

public String getProperty(String key) {
    Object oval = super.get(key);
    String sval = (oval instanceof String) ? (String)oval : null;
    return ((sval == null) && (defaults != null)) ? defaults.getProperty(key) : sval;
}

super.get(key);就是调用Hashtable中的get()方法，也就是此时返回value，同时这就对应返回了properties文件中key对应的value。

第二种方式

第二种方式，我们通过当前类的加载器进行读取this.getClass().getClassLoader().getResourceAsStream()获取InputStream。

代码实现：

/**
* @author tianwc  公众号：java后端技术全栈、面试专栏
* @version 1.0.0
* @date 2023年05月27日 09:13
* 博客地址：<a href="http://woaijava.cc/">在线刷题1200+，100+篇干货文章</a>
*/
public void readProperties2() throws IOException {
    //不加/，若加了会为null
    InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("jdbc.properties");
    //如果放在config目录下
    //InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream("config/jdbc.properties");
    Properties properties=new Properties();
    properties.load(inputStream);
    System.out.println("jdbc.driver="+properties.getProperty("jdbc.driver"));
    System.out.println("jdbc.url="+properties.getProperty("jdbc.url"));
    System.out.println("jdbc.username="+properties.getProperty("jdbc.username"));
    System.out.println("jdbc.password="+properties.getProperty("jdbc.password"));
}

第一看怎么觉得和第一种方式很像，下面来说说两个的区别。

• this.getClass.getResourceAsStream() jdbc.properties必须加/从<code style="font-size: 14px;padding: 2px 4px;border-radius: 4px;margin-right: 2px;margin-left: 2px;background-color: rgba(27, 31, 35, < /section></li><code style=" font-size: rgba mono consolas monaco menlo monospace break-all rgb>this.getClass.getResourceAsStream() 从当前类所在的位置开始查找配置文件位置。要找到jdbc.properties必须加/从classpath下开始查找
• this.getClass().getClassLoader().getResourceAsStream() 默认就从classpath路径下开始查找，加上/会报空指针异常。

剩下的部分代码和第一种方式一样，这里就不在赘述了。

第三种方式

接下来我们采用ClassLoader类的static方法 getSystemResourceAsStream()

this.getClass( ).getClassLoader().getResourceAsStream() 默认就从classpath路径下开始查找，加上/会报空指针异常。

h2 data-tool="mdnice编辑器" style="margin-top: 30px;margin-bottom: 15px;font-weight: bold;border-bottom: 2px solid rgb(239, 112, 96);font-size: 1.3em;">第三种方式

接下来我们采用ClassLoader类的static方法 getSystemResourceAsStream()。🎜

/**
* @author tianwc  公众号：java后端技术全栈、面试专栏
* @version 1.0.0
* @date 2023年05月27日 09:13
* 博客地址：<a href="http://woaijava.cc/">在线刷题1200+，100+篇干货文章</a>
*/
public void readProperties3() throws IOException {
    //如果存放到config目录下
    //InputStream inputStream = ClassLoader.getSystemResourceAsStream("config/jdbc.properties");
    InputStream inputStream = ClassLoader.getSystemResourceAsStream("jdbc.properties");
    Properties properties=new Properties();
    properties.load(inputStream);
    System.out.println("jdbc.driver="+properties.getProperty("jdbc.driver"));
    System.out.println("jdbc.url="+properties.getProperty("jdbc.url"));
    System.out.println("jdbc.username="+properties.getProperty("jdbc.username"));
    System.out.println("jdbc.password="+properties.getProperty("jdbc.password"));
}

ClassLoader中的getSystemResourceAsStream()方法，它用于获取资源作为参数并将资源转换为InputStream。例如，我们可以使用该方法获取网站的静态资源并将其转换为InputStream。

说白了就是获取InputStream的方式不同罢了，最终还是交给Properties去解析jdbc.properties文件内容。

第四种方式

我们在实际开发中，基本上都是离不开Spring了，所以，接下来我们使用Spring中的 ClassPathResource读取配置文件。

代码实现：

/**
* @author tianwc  公众号：java后端技术全栈、面试专栏
* @version 1.0.0
* @date 2023年05月27日 09:13
* 博客地址：<a href="http://woaijava.cc/">博客地址</a>
*/
public void readProperties4() throws IOException {
    ClassPathResource resource = new ClassPathResource("jdbc.properties");
    //ClassPathResource resource = new ClassPathResource("config/jdbc.properties");
    Properties properties= PropertiesLoaderUtils.loadProperties(resource);
    System.out.println("jdbc.driver="+properties.getProperty("jdbc.driver"));
    System.out.println("jdbc.url="+properties.getProperty("jdbc.url"));
    System.out.println("jdbc.username="+properties.getProperty("jdbc.username"));
    System.out.println("jdbc.password="+properties.getProperty("jdbc.password"));
}

这里PropertiesLoaderUtils是spring-core.jar下面的，全路径名称：

org.springframework.core.io.support.PropertiesLoaderUtils。

PropertiesLoaderUtils.loadProperties(resource)源码部分：

public static Properties loadProperties(EncodedResource resource) throws IOException {
    //创建一个Properties对象
    Properties props = new Properties();
    //处理文件内容并赋值给props
    fillProperties(props, resource);
    return props;
}

fillProperties(props, resource);方法：

public static void fillProperties(Properties props, EncodedResource resource) throws IOException {
    fillProperties(props, resource, ResourcePropertiesPersister.INSTANCE);
}

static void fillProperties(Properties props, EncodedResource resource, PropertiesPersister persister) throws IOException {
    InputStream stream = null;
    Reader reader = null;

    try {
        //省略不相关代码
        stream = resource.getInputStream();
        //获取InputStream
        persister.load(props, stream); 
    } finally {
        //关闭
    }
}

最后到PropertiesPersister的persister.load(props, stream);

public void load(Properties props, InputStream is) throws IOException {
    props.load(is);
}

这里又回到Properties类中的load()方法里了。

绕了半天也只是获取InputStream的方式不同而已

第五种方式

接下来我们来使用PropertyResourceBundle读取InputStream流，实现配置文件读取。

代码实现：

public void readProperties5() throws IOException {
    InputStream inputStream = ClassLoader.getSystemResourceAsStream("jdbc.properties");
    //InputStream inputStream = ClassLoader.getSystemResourceAsStream("config/jdbc.properties");
    PropertyResourceBundle bundle = new PropertyResourceBundle(inputStream);
    System.out.println(bundle.getString("jdbc.driver"));
    System.out.println(bundle.getString("jdbc.url"));
    System.out.println(bundle.getString("jdbc.username"));
    System.out.println(bundle.getString("jdbc.password"));
}

好像也没什么，

PropertyResourceBundle源码

我们来看看 new PropertyResourceBundle(inputStream);源码部分：

public PropertyResourceBundle (InputStream stream) throws IOException {
    Properties properties = new Properties();
    properties.load(stream);
    lookup = new HashMap(properties);
}

这个构造方法里直接new了一个Properties对象。然后调用load方法解析。

所以，这种方式无非就是在Properties基础之上再封装了，也就是让我们使用起来更加方便。

PropertyResourceBundle类关系图

所以，上面代码中的bundle.getString("jdbc.url")其实调用的是父类中方法；

public final String getString(String key) {
    return (String) getObject(key);
}

最终调用到PropertyResourceBundle的handleGetObject()方法：

public Object handleGetObject(String key) {
    if (key == null) {
        throw new NullPointerException();
    }
    return lookup.get(key);
}

lookup就是一个HashMap：lookup = new HashMap(properties);

第六种方式

第五种方式中我们看到了ResourceBundle，接下来我们就是用ResourceBundle.getBundle()实现。

//不用输入后缀
public void readProperties6()  {
    ResourceBundle bundle=ResourceBundle.getBundle("jdbc"); 
    System.out.println(bundle.getString("jdbc.driver"));
    System.out.println(bundle.getString("jdbc.url"));
    System.out.println(bundle.getString("jdbc.username"));
    System.out.println(bundle.getString("jdbc.password"));
}

直接使用文件名称就可以了，不需要写文件后缀名。

java.util.ResourceBundle.getBundle(String baseName) 方法获取使用指定的基本名称，不需要文件后缀名，默认的语言环境和调用者的类加载器获取资源包。

• Si baseName est null , alors Signaler une exceptionNullPointerException baseName 为 null ，则报异常NullPointerException
• 如果可以找到指定的基没有相应的资源包 ，则报异常MissingResourceException

si vous can Si aucun package de ressources correspondant n'est trouvé pour la base spécifiée, une exception sera signalée MissingResourceException

Résumé

Ci-dessus sont les 6 façons dont nous lisons habituellement les fichiers de propriétés en 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!