वास्तव में जावा में classpath से पाठ फ़ाइल कैसे पढ़ें


366

मैं एक पाठ फ़ाइल पढ़ने की कोशिश कर रहा हूं जो CLASSPATH सिस्टम चर में सेट है। उपयोगकर्ता चर नहीं है।

मैं नीचे फ़ाइल के लिए इनपुट स्ट्रीम प्राप्त करने की कोशिश कर रहा हूं:

D:\myDirCLASSPATH में फ़ाइल की निर्देशिका रखें ( और नीचे देखें:

InputStream in = this.getClass().getClassLoader().getResourceAsStream("SomeTextFile.txt");
InputStream in = this.getClass().getClassLoader().getResourceAsStream("/SomeTextFile.txt");
InputStream in = this.getClass().getClassLoader().getResourceAsStream("//SomeTextFile.txt");

D:\myDir\SomeTextFile.txtCLASSPATH में फ़ाइल का पूरा पथ रखें ( और कोड की 3 पंक्तियों से ऊपर की कोशिश करें।

लेकिन दुर्भाग्य से उनमें से कोई भी काम नहीं कर रहा है और मैं हमेशा nullअपने इनपुटस्ट्रीम में आ रहा हूं in

जवाबों:


605

क्लासपैथ पर निर्देशिका के साथ, एक ही क्लास लोडर द्वारा लोड की गई कक्षा से, आपको निम्नलिखित में से किसी एक का उपयोग करने में सक्षम होना चाहिए:

// From ClassLoader, all paths are "absolute" already - there's no context
// from which they could be relative. Therefore you don't need a leading slash.
InputStream in = this.getClass().getClassLoader()
                                .getResourceAsStream("SomeTextFile.txt");
// From Class, the path is relative to the package of the class unless
// you include a leading slash, so if you don't want to use the current
// package, include a slash like this:
InputStream in = this.getClass().getResourceAsStream("/SomeTextFile.txt");

यदि वे काम नहीं कर रहे हैं, तो पता चलता है कि कुछ और गलत है।

उदाहरण के लिए, यह कोड लें:

package dummy;

import java.io.*;

public class Test
{
    public static void main(String[] args)
    {
        InputStream stream = Test.class.getResourceAsStream("/SomeTextFile.txt");
        System.out.println(stream != null);
        stream = Test.class.getClassLoader().getResourceAsStream("SomeTextFile.txt");
        System.out.println(stream != null);
    }
}

और यह निर्देशिका संरचना:

code
    dummy
          Test.class
txt
    SomeTextFile.txt

और फिर (यूनिक्स पथ विभाजक का उपयोग कर के रूप में मैं एक लिनक्स बॉक्स पर हूँ):

java -classpath code:txt dummy.Test

परिणाम:

true
true

2
आपने सापेक्ष और निरपेक्ष रास्तों को मिला दिया। एक पथ जो "/" से शुरू होता है वह निरपेक्ष होता है (यानी जो भी CLASSPATH में सूचीबद्ध होता है) से शुरू होता है। अन्य सभी पथ उस वर्ग के पैकेज के सापेक्ष हैं जिस पर आप कॉल करते हैंgetResourceAsStream()
हारून डिगुल्ला

13
नहीं, आपने मेरा उदाहरण तोड़ा । मैं उन्हें स्पष्ट करने के लिए टिप्पणियों को संपादित करूँगा, लेकिन मुद्दा यह है कि क्लासलोडर का उपयोग करते हुए सभी रास्तों को पहले से ही निरपेक्ष मान लिया गया है। उनके सापेक्ष होने के लिए कुछ भी नहीं है।
जॉन स्कीट

6
इसके अलावा Java.IO.File.Separator का उपयोग न करें। यह खिड़कियों पर काम नहीं करेगा। यदि आप इस कोड को विंडोज़ पर चला रहे हैं, तो यह अभी भी '/' है और '\' नहीं है
प्रधान

28
@ प्रधान: नहीं, आप का उपयोग नहीं किया जाना चाहिए File.Separator- क्योंकि आप एक फ़ाइल के लिए नहीं पूछ रहे हैं, आप एक संसाधन के लिए पूछ रहे हैं । यह समझना महत्वपूर्ण है कि इसमें शामिल अमूर्त फाइल सिस्टम नहीं है।
जॉन स्कीट

1
@ जगदपन्जर: यह केवल उन कक्षाओं के लिए है जो मूल रूप से एक ही क्लास लोडर द्वारा लोड किए गए हैं, और यह इसलिए Class.getResourceAsStreamहै क्योंकि यह वास्तव में कॉलिंग के लिए एक सुविधा विधि है ClassLoader.getResourceAsStream, लेकिन "रिश्तेदार" संसाधनों की अतिरिक्त विशेषता के साथ। यदि आप एक निरपेक्ष संसाधन को निर्दिष्ट कर रहे हैं, तो एक ही क्लास लोडर का उपयोग करके कोई भी कॉल एक ही काम करेगा।
जॉन स्कीट

115

स्प्रिंग फ्रेमवर्क का उपयोग करते समय (या तो उपयोगिताओं या कंटेनर के संग्रह के रूप में - आपको बाद की कार्यक्षमता का उपयोग करने की आवश्यकता नहीं है) आप आसानी से संसाधन अमूर्त का उपयोग कर सकते हैं ।

Resource resource = new ClassPathResource("com/example/Foo.class");

संसाधन इंटरफ़ेस के माध्यम से आप इनपुटस्ट्रीम , URL , URI या फ़ाइल के रूप में संसाधन तक पहुँच सकते हैं । फ़ाइल प्रकार संसाधन के लिए संसाधन प्रकार को बदलना उदाहरण बदलने का एक साधारण मामला है।


6
क्या आप इस पर एक नमूना कोड प्रदान कर सकते हैं कि इसका उपयोग I / O फ़ाइल में कैसे किया जा सकता है? मैं एक नहीं मिल सकता है सभ्य , स्पष्ट और सीधा ((((: कैसे इंटरनेट में इसका इस्तेमाल करने पर जिस तरह से

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

मुझे यह समझने में थोड़ी परेशानी हुई कि संसाधन चर के साथ भी क्या किया जाए। मैंने उत्तर को थोड़ा और विस्तार के साथ संपादित किया है
DavidZemon

मैं पहले से ही वसंत का उपयोग कर रहा था और "शुद्ध जावा" की कोशिश कर रहा था। यह मुझे मार रहा था, getResource, getResourceAsStream, आदि के बीच अंतर, कोई अच्छा काम करने के उदाहरण के साथ। यह एनकैप्सुलेशन का एक आदर्श उदाहरण है, इसलिए मुझे परवाह नहीं है।
TinkerTenorSoftwareGuy

1
सावधान रहें, यदि आप अपनी परियोजना को एक जार में पैकेज करते हैं तो आपको एक इनपुटस्ट्रीम का उपयोग करना चाहिए। यदि आप किसी फ़ाइल का उपयोग अपने IDE में करते हैं, लेकिन यदि आप इसे जार से जांचते हैं तो यह विफल हो जाएगा। अगर आपको वास्तव में stackoverflow.com/questions/4317035/… के
Rafael Membrives

58

जावा 7 एनआईओ का उपयोग करके मैंने अपने क्लासपाथ पर एक टेक्स्ट फ़ाइल की सभी पंक्तियों को पढ़ा:

...
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;

...

Files.readAllLines(
    Paths.get(this.getClass().getResource("res.txt").toURI()), Charset.defaultCharset());

NB यह एक उदाहरण है कि यह कैसे किया जा सकता है। आपको आवश्यकतानुसार सुधार करना होगा। यह उदाहरण केवल तभी काम करेगा जब फ़ाइल वास्तव में आपके classpath पर मौजूद है, अन्यथा getResource () रिटर्न null और .toURI () उस पर लागू होने पर NullPointerException को फेंक दिया जाएगा।

इसके अलावा, जावा 7 के बाद से, कैरेक्टर सेट को निर्दिष्ट करने का एक सुविधाजनक तरीका यह है कि इसमें परिभाषित स्थिरांक का उपयोग किया जाए java.nio.charset.StandardCharsets (ये हैं, उनके javadocs के अनुसार , "जावा प्लेटफ़ॉर्म के हर कार्यान्वयन पर उपलब्ध होने की गारंटी है")।

इसलिए, यदि आपको पता है कि फ़ाइल का एन्कोडिंग UTF-8 है, तो स्पष्ट रूप से चारसेट निर्दिष्ट करें StandardCharsets.UTF_8


1
NIO समाधान के लिए धन्यवाद - बहुत कम लोग इस महान एपीआई का उपयोग करते हैं यह शर्म की बात है।
mvreijn

7
एक स्ट्रिंग प्रयास में पढ़ने के लिए। नया स्ट्रिंग (Files.readAllBytes (Paths.get (MyClass.class.getResource) (संसाधन) .toURI ()));
थियो ब्रिस्क

2
मेरे लिए सबसे अच्छा समाधान, क्योंकि इसे किसी भी निर्भरता की आवश्यकता नहीं है, जैसे स्प्रिंग या कॉमन्स आईओ।
बर्नी

1
यह विफल हो जाएगा यदि आपकी संसाधन फ़ाइल जार के अंदर है, उदाहरण के लिए मावेन मॉड्यूल। उस मामले में आप उपयोग करने के लिए की तरह कुछ की आवश्यकता होगी Springकी StreamUtils.copyToString
सोमू

26

प्रयास करें

InputStream in = this.getClass().getResourceAsStream("/SomeTextFile.txt");

आपकी कोशिश काम नहीं आई क्योंकि आपकी कक्षाओं के लिए केवल क्लास लोडर ही क्लासपैथ से लोड करने में सक्षम है। आपने जावा सिस्टम के लिए क्लास लोडर का उपयोग किया।


हालांकि "/" के बारे में निश्चित नहीं है। एक रिश्तेदार मार्ग इस मामले में बेहतर काम कर सकता है।
वॉनसी

3
यदि आप इसे "/" के बिना उपयोग करते हैं, तो आप "यह" के पैकेज के अंदर अपनी फ़ाइल की तलाश कर रहे हैं।
tangens

1
InputStream फ़ाइल = this.getClass ()। GetResourceAsStream ("SomeTextFile.txt"); InputStream फ़ाइल = this.getClass ()। GetResourceAsStream ("/ SomeTextFile.txt"); InputStream फ़ाइल = this.getClass ()। GetResourceAsStream ("// SomeTextFile.txt"); उपरोक्त में से कोई भी काम नहीं किया गया :(
चैतन्य MSV

@चैतन्य: क्या आप जॉन स्कीट के जवाब से उदाहरण चला सकते हैं?
एरोन दिगुल्ला


20

वास्तव में फ़ाइल की सामग्री को पढ़ने के लिए, मुझे कॉमन्स आईओ + स्प्रिंग कोर का उपयोग करना पसंद है। जावा 8 मानकर:

try (InputStream stream = new ClassPathResource("package/resource").getInputStream()) {
    IOUtils.toString(stream);
}

वैकल्पिक रूप से:

InputStream stream = null;
try {
    stream = new ClassPathResource("/log4j.xml").getInputStream();
    IOUtils.toString(stream);
} finally {
    IOUtils.closeQuietly(stream);
}

इनपुटस्ट्रीम को बंद करने के बारे में क्या?
Stephan

धारा अपने आप बंद हो जाएगी। यह जावा 7 की एक विशेषता है "संसाधनों के साथ प्रयास करें" docs.oracle.com/javase/tutorial/essential/exception/…
मीकल मेकीज गालूसस्का

केवल अगर यह कोशिश बयान के अंदर है, जो यहाँ मामला नहीं है। यह कोशिश की जानी चाहिए थी (अंतिम InputStream स्ट्रीम = new ClassPathResource ("/ log4j.xml")। GetInputStream ()) {...
andresp

15

वर्ग निरपेक्ष पथ प्राप्त करने के लिए यह प्रयास करें:

String url = this.getClass().getResource("").getPath();

और फिर क्या? वह जानकारी अपने आप में कोई उपयोग नहीं है।
लोरेन की मार्कीस

यह जानकारी एकदम सही थी। मुझे केवल गेटपाथ () याद आ रहा था!
पैट्रिक

@Patrick यह उत्तर 'वर्ग निरपेक्ष पथ' प्रदान नहीं करता है। यह एक URL प्रदान करता है। बिलकुल भी नहीं।
लोर्न

12

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

ClassLoader loader = Thread.currentThread().getContextClassLoader();
InputStream is = loader.getResourceAsStream("SomeTextFile.txt");

मुझे उम्मीद है कि इससे उन लोगों को मदद मिलेगी जो एक ही मुद्दे का सामना करते हैं।


इससे मुझे एंड्रॉइड पर भी मदद मिली, जहां एप्लिकेशन लोडर द्वारा एक वर्ग लोड किया गया था, लेकिन एक कुंजी जिसे इसकी आवश्यकता थी वह UI थ्रेड में लोड किया गया था।
असोकन

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

6

यदि आप अमरूद का उपयोग करते हैं:

import com.google.common.io.Resources;

हम CLASSPATH से URL प्राप्त कर सकते हैं:

URL resource = Resources.getResource("test.txt");
String file = resource.getFile();   // get file path 

या InputStream:

InputStream is = Resources.getResource("test.txt").openStream();

यदि JAR या WAR फ़ाइल में संसाधन है तो फ़ाइल पथ का कोई उपयोग नहीं है।
लोर्ने

URL का getFile तरीका फ़ाइल नाम वापस नहीं करता है। यह केवल URL का पथ भाग देता है, जो मान्य फ़ाइल नाम होने की गारंटी नहीं है। (URL वर्ग जावा 1.0 का हिस्सा था; फिर, अधिकांश URL ने वास्तव में एक ही कंप्यूटर पर एक अलग कंप्यूटर पर भौतिक फ़ाइलों का उल्लेख किया।)
VGR

3

किसी फ़ाइल की सामग्री को स्ट्रिंग से पढ़ने के लिए classpath, आप इसका उपयोग कर सकते हैं:

private String resourceToString(String filePath) throws IOException, URISyntaxException
{
    try (InputStream inputStream = this.getClass().getClassLoader().getResourceAsStream(filePath))
    {
        return IOUtils.toString(inputStream);
    }
}

नोट:
IOUtilsका हिस्सा है Commons IO

इसे इस तरह से कॉल करें:

String fileContents = resourceToString("ImOnTheClasspath.txt");

1

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

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

ये उपाय हैं:

  1. हर बदलाव के बाद एक नया कंसोल शुरू करें

  2. set CLASSPATH=...कंसोल में चर की प्रतिलिपि सेट करने के लिए कंसोल में उपयोग करें और जब आपका कोड काम करता है, तो अंतिम मान को चर संवाद में पेस्ट करें।

  3. कॉल को जावा को .BATफ़ाइल में रखें और डबल क्लिक करें। यह हर बार एक नया कंसोल बनाएगा (इस प्रकार सिस्टम वैरिएबल के वर्तमान मान की नकल करता है)।

BEWARE: अगर आपके पास भी एक यूजर वेरिएबल है CLASSPATHतो यह आपके सिस्टम वेरिएबल को छाया देगा। यही कारण है कि आमतौर पर कॉल को अपने जावा प्रोग्राम में .BATफ़ाइल में रखना बेहतर होता है और set CLASSPATH=ग्लोबल सिस्टम या यूजर वेरिएबल पर निर्भर होने के बजाए वहां क्लासपाथ को सेट करना (उपयोग करना )।

इससे यह भी सुनिश्चित होता है कि आपके कंप्यूटर पर एक से अधिक जावा प्रोग्राम काम कर सकते हैं क्योंकि वे अलग-अलग क्लासपैथ के लिए बाध्य हैं।


0

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

उदाहरण के लिए मान लीजिए कि एक config फाइल नाम example.xml नीचे दिए गए पथ में स्थित है: -

com.myproject.config.dev

और हमारी जावा निष्पादन योग्य क्लास फ़ाइल नीचे के पथ में है: -

com.myproject.server.main

अब बस ऊपर दिए गए दोनों रास्तों में जाँच करें जो निकटतम सामान्य निर्देशिका / फ़ोल्डर है जहाँ से आप देव और मुख्य निर्देशिका / फ़ोल्डर (com.myproject.server.main - जहाँ हमारे आवेदन का जावा निष्पादन योग्य वर्ग मौजूद है) तक पहुँच सकते हैं - हम देख सकते हैं यह myproject फोल्डर / डायरेक्टरी है जो कि निकटतम कॉमन डाइरेक्टरी / फोल्डर है जहाँ से हम अपने example.xml फ़ाइल को एक्सेस कर सकते हैं। इसलिए एक जावा निष्पादन योग्य वर्ग फ़ोल्डर / निर्देशिका में रहता है मुख्य हमें myproject तक पहुंचने के लिए दो चरणों जैसे ../../ पर वापस जाना होगा । अब इसके बाद, देखें कि हम फाइल को कैसे पढ़ सकते हैं: -

package com.myproject.server.main;

class Example {

  File xmlFile;

  public Example(){
       String filePath = this.getClass().getResource("../../config/dev/example.xml").getPath();
       this.xmlFile = new File(filePath);
    }

  public File getXMLFile() {
      return this.xmlFile;
  }
   public static void main(String args[]){
      Example ex = new Example();
      File xmlFile = ex.getXMLFile();
   }
}

0

यदि आप अपने प्रोजेक्ट को जार फाइल में संकलित करते हैं: आप अपनी फाइल को संसाधनों / फाइलों / your_file.text या pdf में डाल सकते हैं;

और इस कोड का उपयोग करें:

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.*;

public class readFileService(){
    private static final Logger LOGGER = LoggerFactory.getLogger(readFileService.class);


    public byte[] getFile(){
        String filePath="/files/your_file";
        InputStream inputStreamFile;
        byte[] bytes;
        try{
            inputStreamFile = this.getClass().getResourceAsStream(filePath);
            bytes = new byte[inputStreamFile.available()];
            inputStreamFile.read(bytes);    
        } catch(NullPointerException | IOException e) {
            LOGGER.error("Erreur read file "+filePath+" error message :" +e.getMessage());
            return null;
        }
        return bytes;
    } 
}

-1

मैं वेबस्पेयर एप्लिकेशन सर्वर का उपयोग कर रहा हूं और मेरा वेब मॉड्यूल स्प्रिंग एमवीसी पर बना है। Test.propertiesसंसाधन फ़ोल्डर में स्थित थे, मैं निम्नलिखित का उपयोग कर इस फाइल को लोड करने का प्रयास:

  1. this.getClass().getClassLoader().getResourceAsStream("Test.properties");
  2. this.getClass().getResourceAsStream("/Test.properties");

उपरोक्त कोड में से कोई भी फ़ाइल लोड नहीं हुई।

लेकिन नीचे दिए गए कोड की मदद से संपत्ति फ़ाइल को सफलतापूर्वक लोड किया गया था:

Thread.currentThread().getContextClassLoader().getResourceAsStream("Test.properties");

उपयोगकर्ता "user1695166" के लिए धन्यवाद ।


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

-1

उपयोग org.apache.commons.io.FileUtils.readFileToString(new File("src/test/resources/sample-data/fileName.txt"));


src के संदर्भ का उपयोग नहीं किया जाना चाहिए ... अंतिम विरूपण साक्ष्य में काम नहीं करता है।
एल। होलांडा

-1

परिदृश्य:

1) client-service-1.0-SNAPSHOT.jarनिर्भरता हैread-classpath-resource-1.0-SNAPSHOT.jar

2) हम कक्षा पथ संसाधनों ( sample.txt) के read-classpath-resource-1.0-SNAPSHOT.jarमाध्यम से सामग्री पढ़ना चाहते हैं client-service-1.0-SNAPSHOT.jar

3) read-classpath-resource-1.0-SNAPSHOT.jarहैsrc/main/resources/sample.txt

यहाँ मैं तैयार किया गया नमूना कोड काम कर रहा हूं, 2-3 दिनों के बाद अपना विकास समय बर्बाद कर रहा हूं, मुझे पूर्ण अंत-टू-एंड समाधान मिला, आशा है कि यह आपके समय को बचाने में मदद करता है

1. pom.xmlकाread-classpath-resource-1.0-SNAPSHOT.jar

<?xml version="1.0" encoding="UTF-8"?>
        <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
            <modelVersion>4.0.0</modelVersion>
            <groupId>jar-classpath-resource</groupId>
            <artifactId>read-classpath-resource</artifactId>
            <version>1.0-SNAPSHOT</version>
            <name>classpath-test</name>
            <properties>
                <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
                <org.springframework.version>4.3.3.RELEASE</org.springframework.version>
                <mvn.release.plugin>2.5.1</mvn.release.plugin>
                <output.path>${project.artifactId}</output.path>
                <io.dropwizard.version>1.0.3</io.dropwizard.version>
                <commons-io.verion>2.4</commons-io.verion>
            </properties>
            <dependencies>
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-core</artifactId>
                    <version>${org.springframework.version}</version>
                </dependency>
                <dependency>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring-context</artifactId>
                    <version>${org.springframework.version}</version>
                </dependency>
                <dependency>
                    <groupId>commons-io</groupId>
                    <artifactId>commons-io</artifactId>
                    <version>${commons-io.verion}</version>
                </dependency>
            </dependencies>
            <build>
                <resources>
                    <resource>
                        <directory>src/main/resources</directory>
                    </resource>
                </resources>
                <plugins>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-release-plugin</artifactId>
                        <version>${mvn.release.plugin}</version>
                    </plugin>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-compiler-plugin</artifactId>
                        <version>3.1</version>
                        <configuration>
                            <source>1.8</source>
                            <target>1.8</target>
                            <encoding>UTF-8</encoding>
                        </configuration>
                    </plugin>
                    <plugin>
                        <artifactId>maven-jar-plugin</artifactId>
                        <version>2.5</version>
                        <configuration>
                            <outputDirectory>${project.build.directory}/lib</outputDirectory>
                            <archive>
                                <manifest>
                                    <addClasspath>true</addClasspath>
                                    <useUniqueVersions>false</useUniqueVersions>
                                    <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                                    <mainClass>demo.read.classpath.resources.ClassPathResourceReadTest</mainClass>
                                </manifest>
                                <manifestEntries>
                                    <Implementation-Artifact-Id>${project.artifactId}</Implementation-Artifact-Id>
                                    <Class-Path>sample.txt</Class-Path>
                                </manifestEntries>
                            </archive>
                        </configuration>
                    </plugin>
                    <plugin>
                        <groupId>org.apache.maven.plugins</groupId>
                        <artifactId>maven-shade-plugin</artifactId>
                        <version>2.2</version>
                        <configuration>
                            <createDependencyReducedPom>false</createDependencyReducedPom>
                            <filters>
                                <filter>
                                    <artifact>*:*</artifact>
                                    <excludes>
                                        <exclude>META-INF/*.SF</exclude>
                                        <exclude>META-INF/*.DSA</exclude>
                                        <exclude>META-INF/*.RSA</exclude>
                                    </excludes>
                                </filter>
                            </filters>
                        </configuration>
                        <executions>
                            <execution>
                                <phase>package</phase>
                                <goals>
                                    <goal>shade</goal>
                                </goals>
                                <configuration>
                                    <transformers>
                                        <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer" />
                                        <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                            <mainClass>demo.read.classpath.resources.ClassPathResourceReadTest</mainClass>
                                        </transformer>
                                    </transformers>
                                </configuration>
                            </execution>
                        </executions>
                    </plugin>
                </plugins>
            </build>
        </project>

2. उस ClassPathResourceReadTest.javaवर्ग में वर्ग read-classpath-resource-1.0-SNAPSHOT.jarलोड पथ संसाधन फ़ाइल सामग्री लोड करता है।

package demo.read.classpath.resources;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.List;

public final class ClassPathResourceReadTest {
    public ClassPathResourceReadTest() throws IOException {
        InputStream inputStream = getClass().getResourceAsStream("/sample.txt");
        BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
        List<Object> list = new ArrayList<>();
        String line;
        while ((line = reader.readLine()) != null) {
            list.add(line);
        }
        for (Object s1: list) {
            System.out.println("@@@ " +s1);
        }
        System.out.println("getClass().getResourceAsStream('/sample.txt') lines: "+list.size());
    }
}

3. pom.xmlकाclient-service-1.0-SNAPSHOT.jar

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>client-service</groupId>
    <artifactId>client-service</artifactId>
    <version>1.0-SNAPSHOT</version>

    <dependencies>
        <dependency>
            <groupId>jar-classpath-resource</groupId>
            <artifactId>read-classpath-resource</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <artifactId>maven-jar-plugin</artifactId>
                <version>2.5</version>
                <configuration>
                    <outputDirectory>${project.build.directory}/lib</outputDirectory>
                    <archive>
                        <manifest>
                            <addClasspath>true</addClasspath>
                            <useUniqueVersions>false</useUniqueVersions>
                            <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                            <mainClass>com.crazy.issue.client.AccessClassPathResource</mainClass>
                        </manifest>
                        <manifestEntries>
                            <Implementation-Artifact-Id>${project.artifactId}</Implementation-Artifact-Id>
                            <Implementation-Source-SHA>${buildNumber}</Implementation-Source-SHA>
                            <Class-Path>sample.txt</Class-Path>
                        </manifestEntries>
                    </archive>
                </configuration>
            </plugin>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-shade-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <createDependencyReducedPom>false</createDependencyReducedPom>
                    <filters>
                        <filter>
                            <artifact>*:*</artifact>
                            <excludes>
                                <exclude>META-INF/*.SF</exclude>
                                <exclude>META-INF/*.DSA</exclude>
                                <exclude>META-INF/*.RSA</exclude>
                            </excludes>
                        </filter>
                    </filters>
                </configuration>
                <executions>
                    <execution>
                        <phase>package</phase>
                        <goals>
                            <goal>shade</goal>
                        </goals>
                        <configuration>
                            <transformers>
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ServicesResourceTransformer" />
                                <transformer implementation="org.apache.maven.plugins.shade.resource.ManifestResourceTransformer">
                                    <mainClass>com.crazy.issue.client.AccessClassPathResource</mainClass>
                                </transformer>
                            </transformers>
                        </configuration>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

4. AccessClassPathResource.javaतत्काल ClassPathResourceReadTest.javaवर्ग जहां, यह sample.txtअपनी सामग्री को भी लोड और प्रिंट करने जा रहा है ।

package com.crazy.issue.client;

import demo.read.classpath.resources.ClassPathResourceReadTest;
import java.io.IOException;

public class AccessClassPathResource {
    public static void main(String[] args) throws IOException {
        ClassPathResourceReadTest test = new ClassPathResourceReadTest();
    }
}

5. निष्पादन योग्य जार इस प्रकार है:

[ravibeli@localhost lib]$ java -jar client-service-1.0-SNAPSHOT.jar
****************************************
I am in resources directory of read-classpath-resource-1.0-SNAPSHOT.jar
****************************************
3) getClass().getResourceAsStream('/sample.txt'): 3

-2

GetClassLoader () पद्धति का उपयोग न करें और फ़ाइल नाम से पहले "/" का उपयोग करें। "/" बहूत ज़रूरी है

this.getClass().getResourceAsStream("/SomeTextFile.txt");

अग्रणी /का उपयोग करने का getClassLoader()विधि के उपयोग के समान ही प्रभाव है ।
लोरेन

-4
import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;

public class ReadFile

{
    /**
     * * feel free to make any modification I have have been here so I feel you
     * * * @param args * @throws InterruptedException
     */

    public static void main(String[] args) throws InterruptedException {
        // thread pool of 10
        File dir = new File(".");
        // read file from same directory as source //
        if (dir.isDirectory()) {
            File[] files = dir.listFiles();
            for (File file : files) {
                // if you wanna read file name with txt files
                if (file.getName().contains("txt")) {
                    System.out.println(file.getName());
                }

                // if you want to open text file and read each line then
                if (file.getName().contains("txt")) {
                    try {
                        // FileReader reads text files in the default encoding.
                        FileReader fileReader = new FileReader(
                                file.getAbsolutePath());
                        // Always wrap FileReader in BufferedReader.
                        BufferedReader bufferedReader = new BufferedReader(
                                fileReader);
                        String line;
                        // get file details and get info you need.
                        while ((line = bufferedReader.readLine()) != null) {
                            System.out.println(line);
                            // here you can say...
                            // System.out.println(line.substring(0, 10)); this
                            // prints from 0 to 10 indext
                        }
                    } catch (FileNotFoundException ex) {
                        System.out.println("Unable to open file '"
                                + file.getName() + "'");
                    } catch (IOException ex) {
                        System.out.println("Error reading file '"
                                + file.getName() + "'");
                        // Or we could just do this:
                        ex.printStackTrace();
                    }
                }
            }
        }

    }

}

किसी भी तरह से सवाल का जवाब नहीं देता।
लोरेन

-5

आपको अपना 'सिस्टम वेरिएबल' जावा क्लासपाथ पर रखना होगा।


मैंने खुद सिस्टम वेरिएबल डाला।
चैतन्य MSV

'प्रणाली चर' है जावा CLASSPATH। उत्तर का कोई मतलब नहीं है।
लोरेन के मार्किस

पूरी तरह से सच ... यह जवाब लिखना भी याद नहीं है :)
सलंदुर
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.