Comment lire les fichiers de configuration XML et de propriétés dans le développement Java

Lecture connexe :

Utiliser Ajax pour télécharger des fichiers et d'autres paramètres (développement Java)

1. Fichier XML :

Qu'est-ce que XML ? XML fait généralement référence à Extensible Markup Language, un sous-ensemble du Standard Universal Markup Language. Il s'agit d'un langage de balisage utilisé pour marquer les documents électroniques afin de les rendre structurels.

2. Avantages des fichiers XML :

1) Le contenu et la structure du document XML sont complètement séparés.
2) Forte interopérabilité.
3) Standardisation et unification.
4) Prend en charge plusieurs encodages.
5) Forte évolutivité.

3. Comment analyser les documents XML :

XML analyse les documents XML dans différentes langues​​de la même manière, mais la syntaxe implémentée est différente. Il existe deux méthodes d'analyse de base, l'une. la première est la méthode SAX, qui analyse le fichier XML étape par étape dans l'ordre du fichier XML. Une autre méthode d'analyse est la méthode DOM, et la clé de l'analyse DOM est le nœud. Il existe également DOM4J, JDOM et d'autres méthodes. Cet article présente la méthode DOM, DOM4J et la méthode pour l'encapsuler dans une classe d'outils pour lire des documents XML.

Document 4.XML :

scores.xml :

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE students [
 <!ELEMENT students (student+)>
 <!ELEMENT student (name,course,score)>
 <!ATTLIST student id CDATA #REQUIRED>
 <!ELEMENT name (#PCDATA)>
 <!ELEMENT course (#PCDATA)>
 <!ELEMENT score (#PCDATA)>
]>
<students>
 <student id="11">
  <name>张三</name>
  <course>JavaSE</course>
  <score>100</score>
 </student>
 <student id="22"> 
  <name>李四</name>
  <course>Oracle</course>
  <score>98</score>
 </student>
</students>

5.DOM analyse XML

public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException {
  //1.创建DOM解析器工厂
  DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
  //2.由DOM解析器工厂创建DOM解析器
  DocumentBuilder db = dbf.newDocumentBuilder();
  //3.由DOM解析器解析文档，生成DOM树
  Document doc = db.parse("scores.xml");
  //4.解析DOM树，获取文档内容（元素 属性 文本）
  //4.1获取根元素scores
  NodeList scoresList = doc.getChildNodes();
  Node scoresNode = scoresList.item(1);
  System.out.println(scoresList.getLength());
  //4.2获取scores中所有的子元素student
  NodeList studentList = scoresNode.getChildNodes();
  System.out.println(studentList.getLength());
  //4.3对每个student进行处理
  for(int i=0;i<studentList.getLength();i++){
   Node stuNode = studentList.item(i);
   //System.out.println(stuNode.getNodeType());
   //输出元素的属性 id
   if(stuNode.getNodeType()==Node.ELEMENT_NODE){
    Element elem =(Element)stuNode;
    String id= elem.getAttribute("id");
    System.out.println("id------>"+id);
   }
   //输出元素的子元素 name course score
   NodeList ncsList = stuNode.getChildNodes();
   //System.out.println(ncsList.getLength() );
   for(int j=0;j<ncsList.getLength();j++){
    Node ncs = ncsList.item(j);
    if(ncs.getNodeType() == Node.ELEMENT_NODE){
      String name = ncs.getNodeName();
      //String value = ncs.getFirstChild().getNodeValue();//文本是元素的子节点，所以要getFirstChild
      String value = ncs.getTextContent();
      System.out.println(name+"----->"+value);
    }
   }
   System.out.println();
  }
 }

6.DOM4J analyse le document XML :

public static void main(String[] args) throws DocumentException {
 //使用dom4j解析scores2.xml,生成dom树
 SAXReader reader = new SAXReader();
 Document doc = reader.read(new File("scores.xml")); 
 //得到根节点：students
 Element root = doc.getRootElement(); 
 //得到students的所有子节点：student
 Iterator<Element> it = root.elementIterator();
 //处理每个student
 while(it.hasNext()){
  //得到每个学生
  Element stuElem =it.next();
  //System.out.println(stuElem);
  //输出学生的属性：id
  List<Attribute> attrList = stuElem.attributes();
  for(Attribute attr :attrList){
   String name = attr.getName();
   String value = attr.getValue();
   System.out.println(name+"----->"+value);
  }
  //输出学生的子元素：name，course，score
  Iterator <Element>it2 = stuElem.elementIterator();
  while(it2.hasNext()){
   Element elem = it2.next();
   String name = elem.getName();
   String text = elem.getText();
   System.out.println(name+"----->"+text);
  }
  System.out.println();
 }
}

Bien sûr, non Quelle que soit la manière dont nous utilisons pour analyser XML, nous devons importer le package jar (ne l'oubliez pas).

7. À ma façon :

Dans les projets de développement réels, nous devons être bons dans l'utilisation des classes d'outils et encapsuler les fonctions que nous utilisons à plusieurs reprises dans une classe d'outils, donc la méthode suivante est la suivante. méthode que j'utilise pendant le processus de développement.

7.1 Qu'est-ce qu'un fichier de propriétés :

7.1.1 Structurellement :

Le fichier .xml est principalement sous forme de document en forme d'arborescence.
Les fichiers .properties existent principalement sous la forme de paires clé-valeur

7.1.2 D'un point de vue flexible :

Les fichiers .xml sont plus flexibles que les fichiers .properties Lire plus haut.

7.1.3 D'un point de vue pratique :

La configuration du fichier .properties est plus simple que la configuration du fichier .xml.

7.1.4 Du point de vue de l'application :

Les fichiers .properties sont plus adaptés aux petits projets simples car .xml est plus flexible.

7.2 Mon propre document de propriétés :

J'ai créé un fichier path.properties dans mon propre projet, qui sert à stocker le chemin que je m'apprête à utiliser, stocké sous la forme de nom = valeur. Par exemple :

realPath = D:/file/

7.3 Analysez votre propre fichier .properties :

public class PropertiesUtil {
 private static PropertiesUtil manager = null;
 private static Object managerLock = new Object();
 private Object propertiesLock = new Object();
 private static String DATABASE_CONFIG_FILE = "/path.properties";
 private Properties properties = null;
 public static PropertiesUtil getInstance() {
  if (manager == null) {
   synchronized (managerLock) {
    if (manager == null) {
     manager = new PropertiesUtil();
    }
   }
  }
  return manager;
 }
 private PropertiesUtil() {
 }
 public static String getProperty(String name) {
  return getInstance()._getProperty(name);
 }
 private String _getProperty(String name) {
  initProperty();
  String property = properties.getProperty(name);
  if (property == null) {
   return "";
  } else {
   return property.trim();
  }
 }
 public static Enumeration<?> propertyNames() {
  return getInstance()._propertyNames();
 }
 private Enumeration<?> _propertyNames() {
  initProperty();
  return properties.propertyNames();
 }
 private void initProperty() {
  if (properties == null) {
   synchronized (propertiesLock) {
    if (properties == null) {
     loadProperties();
    }
   }
  }
 }
 private void loadProperties() {
  properties = new Properties();
  InputStream in = null;
  try {
   in = getClass().getResourceAsStream(DATABASE_CONFIG_FILE);
   properties.load(in);
  } catch (Exception e) {
   System.err
     .println("Error reading conf properties in PropertiesUtil.loadProps() "
       + e);
   e.printStackTrace();
  } finally {
   try {
    in.close();
   } catch (Exception e) {
   }
  }
 }
 /**
  * 提供配置文件路径
  *
  * @param filePath
  * @return
  */
 public Properties loadProperties(String filePath) {
  Properties properties = new Properties();
  InputStream in = null;
  try {
   in = getClass().getResourceAsStream(filePath);
   properties.load(in);
  } catch (Exception e) {
   System.err
     .println("Error reading conf properties in PropertiesUtil.loadProperties() "
       + e);
   e.printStackTrace();
  } finally {
   try {
    in.close();
   } catch (Exception e) {
   }
  }
  return properties;
 }
}

Avant de l'utiliser, il suffit d'attacher une valeur à l'attribut DATABASE_CONFIG_FILE, qui est le nom de notre fichier .properties. Lorsqu'il est utilisé, nous pouvons directement utiliser le nom de la classe getProperty("realPath"); in La clé du fichier .properties est le contenu de realPath.

Ce qui précède est la méthode de lecture des fichiers de configuration XML et des propriétés dans le développement Java introduite par l'éditeur. J'espère qu'elle vous sera utile. Si vous avez des questions, veuillez me laisser un message et l'éditeur le fera. Répondez rapidement à tout le monde !

Pour plus d'articles liés aux méthodes de lecture XML et aux fichiers de configuration de propriétés dans le développement Java, veuillez faire attention au site Web PHP chinois !