java समय जावा एप्लिकेशन में एक्सएमएल फाइल में पढ़ने का सबसे अच्छा/सरल तरीका क्या है?




पढ़ाई से संबंधित (10)

वर्तमान में हमारे जावा एप्लिकेशन एक टैब सीमित * .cfg फ़ाइल में रखे गए मानों का उपयोग करता है। हमें इस एप्लिकेशन को बदलने की जरूरत है ताकि अब यह एक एक्सएमएल फाइल का उपयोग करे।

इस फ़ाइल के मूल्यों को पढ़ने के लिए उपयोग करने के लिए सबसे अच्छी / सरल लाइब्रेरी क्या है?


क्या आपके पास XML कॉन्फ़िगरेशन फ़ाइलों को चुना गया कोई विशेष कारण है? मैंने अतीत में एक्सएमएल कॉन्फ़िगर किया है, और वे अक्सर किसी और चीज की तुलना में सिरदर्द के रूप में बाहर निकले हैं।

मुझे लगता है कि असली सवाल यह है कि क्या प्राथमिकता एपीआई जैसे कुछ का उपयोग करना आपकी स्थिति में बेहतर काम कर सकता है।

रोल-अप-एक्सएमएल समाधान पर प्राथमिकता API का उपयोग करने के कारण:

  • एक्सएमएल बैकएंड प्रदान करने के लिए तीसरे पक्ष के पुस्तकालयों से बचने के साथ-साथ ठेठ एक्सएमएल कुरूपता (दस्तावेज़ फैक्ट्री, आदि) से बचें

  • डिफ़ॉल्ट मानों के लिए समर्थन में निर्मित (गायब / भ्रष्ट / अमान्य प्रविष्टियों के लिए आवश्यक कोई विशेष हैंडलिंग नहीं)

  • एक्सएमएल स्टोरेज (सीडीएटीए रैपिंग इत्यादि) के लिए मूल्यों को स्वच्छ करने की आवश्यकता नहीं है

  • बैकिंग स्टोर की गारंटीकृत स्थिति (डिस्क पर एक्सएमएल को लगातार लिखने की आवश्यकता नहीं है)

  • बैकिंग स्टोर कॉन्फ़िगर करने योग्य है (डिस्क पर फ़ाइल, एलडीएपी, आदि)

  • सभी प्राथमिकताओं के लिए बहु-थ्रेडेड पहुंच मुफ्त में


यहां एक बहुत ही सरल एपीआई है जिसे मैंने जावा में सरल एक्सएमएल फाइल पढ़ने के लिए बनाया है। यह अविश्वसनीय रूप से सरल और उपयोग करने में आसान है। उम्मीद है कि यह आपके लिए उपयोगी है।

http://argonrain.wordpress.com/2009/10/27/000/


1.4 से कोर जावा एसई का हिस्सा java.beans.XMLDecoder उपयोग करें।

XMLDecoder input = new XMLDecoder(new FileInputStream("some/path.xml"));
MyConfig config = (MyConfig) input.readObject();
input.close();

कॉन्फ़िगरेशन फ़ाइलों को हाथ से लिखना आसान है, या रन-टाइम पर नई ऑब्जेक्ट्स लिखने के लिए कुछ सेटअप के साथ संबंधित XMLEncoder उपयोग करना आसान है।


यही है वह जो मेरे द्वारा उपयोग किया जाता है। http://marketmovers.blogspot.com/2014/02/the-easy-way-to-read-xml-in-java.html यह मानक जेडीके उपकरण के शीर्ष पर बैठता है, इसलिए यदि इसमें कुछ फीचर गुम है तो आप हमेशा जेडीके संस्करण का प्रयोग करें।

यह वास्तव में मेरे लिए चीजों को आसान बनाता है। यह विशेष रूप से अच्छा है जब मैं एक कॉन्फ़िगरेशन फ़ाइल पढ़ रहा हूं जिसे सॉफ़्टवेयर के पुराने संस्करण द्वारा सहेजा गया था, या उपयोगकर्ता द्वारा मैन्युअल रूप से संपादित किया गया था। यह बहुत मजबूत है और अगर कोई डेटा आपके द्वारा अपेक्षित प्रारूप में बिल्कुल नहीं है तो अपवाद नहीं फेंक देगा।


एक्सएमएल कोड:

<?xml version="1.0"?>
<company>
    <staff id="1001">
        <firstname>yong</firstname>
        <lastname>mook kim</lastname>
        <nickname>mkyong</nickname>
        <salary>100000</salary>
    </staff>
    <staff id="2001">
        <firstname>low</firstname>
        <lastname>yin fong</lastname>
        <nickname>fong fong</nickname>
        <salary>200000</salary>
    </staff>
</company>

जावा कोड:

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import org.w3c.dom.Element;
import java.io.File;

public class ReadXMLFile {

  public static void main(String argv[]) {
    try {
    File fXmlFile = new File("/Users/mkyong/staff.xml");
    DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
    DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
    Document doc = dBuilder.parse(fXmlFile);
    doc.getDocumentElement().normalize();

    System.out.println("Root element :" + doc.getDocumentElement().getNodeName());
    NodeList nList = doc.getElementsByTagName("staff");
    System.out.println("----------------------------");

    for (int temp = 0; temp < nList.getLength(); temp++) {
        Node nNode = nList.item(temp);
        System.out.println("\nCurrent Element :" + nNode.getNodeName());
        if (nNode.getNodeType() == Node.ELEMENT_NODE) {
            Element eElement = (Element) nNode;
            System.out.println("Staff id : "
                               + eElement.getAttribute("id"));
            System.out.println("First Name : "
                               + eElement.getElementsByTagName("firstname")
                                 .item(0).getTextContent());
            System.out.println("Last Name : "
                               + eElement.getElementsByTagName("lastname")
                                 .item(0).getTextContent());
            System.out.println("Nick Name : "
                               + eElement.getElementsByTagName("nickname")
                                 .item(0).getTextContent());
            System.out.println("Salary : "
                               + eElement.getElementsByTagName("salary")
                                 .item(0).getTextContent());
        }
    }
    } catch (Exception e) {
    e.printStackTrace();
    }
  }
}

आउटपुट:

----------------

Root element :company
----------------------------

Current Element :staff
Staff id : 1001
First Name : yong
Last Name : mook kim
Nick Name : mkyong
Salary : 100000

Current Element :staff
Staff id : 2001
First Name : low
Last Name : yin fong
Nick Name : fong fong
Salary : 200000

मैंने आपको यह पढ़ने की सलाह दी: जावा के साथ डीओएम पार्सिंग में सामान्यीकरण - यह कैसे काम करता है?

उदाहरण स्रोत


मैंने केवल जेडोम का इस्तेमाल किया है। यह बहुत आसान है।

दस्तावेज़ीकरण के लिए यहां जाएं और इसे डाउनलोड करें: http://www.jdom.org/

यदि आपके पास बहुत बहुत बड़ा दस्तावेज़ है तो यह बेहतर है कि इसे सभी को स्मृति में न पढ़ें, लेकिन एक SAX पार्सर का उपयोग करें जो आपके तरीकों को कॉल करता है क्योंकि यह कुछ टैग और विशेषताओं को हिट करता है। आने वाली कॉल से निपटने के लिए आपको एक राज्य मशीन बनाना होगा।


आपके आवेदन और सीएफजी फ़ाइल के दायरे के आधार पर, एक गुण फ़ाइल सबसे आसान हो सकती है। निश्चित रूप से यह एक्सएमएल के रूप में सुरुचिपूर्ण नहीं है लेकिन यह निश्चित रूप से आसान है।


JAXB का उपयोग करना आसान है और जावा 6 एसई में शामिल है। जेएक्सबी, या अन्य एक्सएमएल डेटा बाध्यकारी जैसे सरल के साथ, आपको स्वयं को एक्सएमएल को संभालना नहीं है, अधिकांश काम लाइब्रेरी द्वारा किया जाता है। मूल उपयोग आपके मौजूदा पीओजेओ में एनोटेशन जोड़ना है। इन एनोटेशन का उपयोग तब आपके डेटा के लिए एक्सएमएल स्कीमा उत्पन्न करने के लिए किया जाता है और जब भी आपके डेटा को फ़ाइल से / लिखना होता है।


इस फ़ाइल के मूल्यों को पढ़ने के लिए उपयोग करने के लिए सबसे अच्छी / सरल लाइब्रेरी क्या है?

जैसा कि आप सबसे सरल लाइब्रेरी के लिए पूछ रहे हैं, मुझे लगता है कि गिलाउम के शीर्ष-वोट वाले उत्तर में एक दृष्टिकोण को काफी अलग करना है। (दूसरे उत्तरों में, एसजेबोथा का जेडीओएम उल्लेख जो मैंने सुझाया है उसके करीब है)।

मुझे लगता है कि जावा में एक्सएमएल हैंडलिंग के लिए, मानक जेडीके उपकरण का उपयोग करना निश्चित रूप से सबसे आसान तरीका नहीं है, और केवल कुछ परिस्थितियों में (जैसे किसी तीसरे पक्ष के पुस्तकालयों का उपयोग करने में सक्षम नहीं है) यह है सबसे अच्छा तरीका।

इसके बजाय, XOM जैसे एक अच्छी एक्सएमएल लाइब्रेरी का उपयोग करने पर विचार करें। यहां एक XML फ़ाइल को nu.xom.Document ऑब्जेक्ट में पढ़ने का तरीका nu.xom.Document है:

import nu.xom.Builder;
import nu.xom.Document;
import java.io.File;

[...]

File file = new File("some/path");
Document document = new Builder().build(file);

इसलिए, यह थोड़ी सी सरल थी, फ़ाइल को org.w3c.dom.Document में पढ़ने के रूप में। दस्तावेज़ "शुद्ध जेडीके" दृष्टिकोण में बहुत जटिल नहीं था। लेकिन एक अच्छी लाइब्रेरी का उपयोग करने के फायदे केवल यहां शुरू करें! जो भी आप अपने एक्सएमएल के साथ कर रहे हैं, आप अक्सर एक्सओएम जैसी लाइब्रेरी का उपयोग करते समय बनाए रखने के लिए बहुत ही सरल समाधान, और बनाए रखने के लिए अपने स्वयं के कोड से कम हो जाएंगे। उदाहरण के रूप में, this बनाम this पर विचार this , या this बनाम this , या इस पोस्ट में XOM और W3C DOM दोनों उदाहरण शामिल हैं

अन्य जावा-मानक एक्सएमएल एपीआई के लिए चिपकने के लिए काउंटर-तर्क ( इनके जैसे ) प्रदान करेंगे, कम से कम कुछ मामलों में, शायद व्यक्तिगत रूप से मैं उन सभी की सदस्यता नहीं लेता हूं। किसी भी मामले में, एक तरफ या दूसरे को चुनते समय, कहानी के दोनों तरफ से अवगत होना अच्छा होता है।

(यह उत्तर एक्सओएम के मेरे मूल्यांकन का हिस्सा है, जो dom4j को बदलने के लिए सर्वश्रेष्ठ जावा एक्सएमएल लाइब्रेरी खोजने के लिए मेरी खोज में एक मजबूत दावेदार है।)


अब तक का सबसे आसान सरल http://simple.sourceforge.net होगा , आपको केवल एक ही ऑब्जेक्ट को एनोटेट करने की आवश्यकता है

@Root
public class Entry {

   @Attribute
   private String a
   @Attribute
   private int b;
   @Element
   private Date c;

   public String getSomething() {
      return a;
   }
} 

@Root
public class Configuration {

   @ElementList(inline=true)
   private List<Entry> entries;

   public List<Entry> getEntries() { 
      return entries;
   }
}

तो आपको पूरी फाइल को पढ़ने के लिए बस इतना करना है कि वह स्थान निर्दिष्ट करे और यह एनोटेटेड पीओजेओ के विश्लेषण और पॉप्युलेट करेगा। यह सभी प्रकार के रूपांतरण और सत्यापन करेगा। यदि आवश्यक हो तो आप निरंतर कॉलबैक के लिए भी टिप्पणी कर सकते हैं। इसे पढ़ना ऐसा ही किया जा सकता है।

Serializer serializer = new Persister();
Configuration configuraiton = serializer.read(Configuration.class, fileLocation);






file