Java路徑問題最終解決方案

                                             Java 路徑問題最終解決方案

                                                                                                            — 可定位全部資源的相對路徑尋址

 

 

 

前言

Java的路徑問題，很是難搞。最近的工做涉及到建立和讀取文件的工做，這裏我就給你們完全得解決Java路徑問題。

我編寫了一個方法，比ClassLoader.getResource(String 相對路徑)方法的能力更強。它能夠接受「../」這樣的參數，容許咱們用相對路徑來定位classpath外面的資源。這樣，咱們就可使用相對於classpath的路徑，定位全部位置的資源！

 

Java路徑

Java中使用的路徑，分爲兩種：絕對路徑和相對路徑。具體而言，又分爲四種：

1、URI形式的絕對資源路徑

如：file:/D:/java/eclipse32/workspace/jbpmtest3/bin/aaa.b

URL是URI的特例。URL的前綴/協議，必須是Java認識的。URL能夠打開資源，而URI則不行。

URL和URI對象能夠互相轉換，使用各自的toURI(),toURL()方法便可！

 

2、本地系統的絕對路徑

D:/java/eclipse32/workspace/jbpmtest3/bin/aaa.b

Java.io包中的類，須要使用這種形式的參數。

可是，它們通常也提供了URI類型的參數，而URI類型的參數，接受的是URI樣式的String。所以，經過URI轉換，仍是能夠把URI樣式的絕對路徑用在java.io包中的類中。

 

3、相對於classpath的相對路徑

如：相對於

file:/D:/java/eclipse32/workspace/jbpmtest3/bin/這個路徑的相對路徑。其中，bin是本項目的classpath。全部的Java源文件編譯後的.class文件複製到這個目錄中。

 

 

4、相對於當前用戶目錄的相對路徑

就是相對於System.getProperty("user.dir")返回的路徑。

對於通常項目，這是項目的根路徑。對於JavaEE服務器，這多是服務器的某個路徑。這個並無統一的規範！

因此，絕對不要使用「相對於當前用戶目錄的相對路徑」。然而：

默認狀況下，java.io 包中的類老是根據當前用戶目錄來分析相對路徑名。此目錄由系統屬性 user.dir 指定，一般是 Java 虛擬機的調用目錄。

這就是說，在使用java.io包中的類時，最好不要使用相對路徑。不然，雖然在J2SE應用程序中可能還算正常，可是到了J2EE程序中，必定會出問題！並且這個路徑，在不一樣的服務器中都是不一樣的！

 

相對路徑最佳實踐

推薦使用相對於當前classpath的相對路徑

所以，咱們在使用相對路徑時，應當使用相對於當前classpath的相對路徑。

ClassLoader類的getResource(String name), getResourceAsStream(String name)等方法，使用相對於當前項目的classpath的相對路徑來查找資源。

讀取屬性文件經常使用到的ResourceBundle類的getBundle(String path)也是如此。

經過查看ClassLoader類及其相關類的源代碼，我發現，它實際上仍是使用了URI形式的絕對路徑。經過獲得當前classpath的URI形式的絕對路徑，構建了相對路徑的URI形式的絕對路徑。（這個其實是猜測，由於JDK內部調用了SUN的源代碼，而這些代碼不屬於JDK，不是開源的。）

 

相對路徑本質上仍是絕對路徑

所以，歸根結底， Java 本質上只能使用絕對路徑來尋找資源。全部的相對路徑尋找資源的方法，都不過是一些便利方法。不過是 API 在底層幫助咱們構建了絕對路徑，從而找到資源的！

 

獲得classpath和當前類的絕對路徑的一些方法

    下面是一些獲得classpath和當前類的絕對路徑的一些方法。你可能須要使用其中的一些方法來獲得你須要的資源的絕對路徑。

1 ，FileTest.class.getResource("")

獲得的是當前類FileTest.class文件的URI目錄。不包括本身！

如： file:/D:/java/eclipse32/workspace/jbpmtest3/bin/com/test/

2 ，FileTest.class.getResource("/")

獲得的是當前的classpath的絕對URI路徑。

如： file:/D:/java/eclipse32/workspace/jbpmtest3/bin/

3 ，Thread.currentThread().getContextClassLoader().getResource("")

獲得的也是當前ClassPath的絕對URI路徑。

如： file:/D:/java/eclipse32/workspace/jbpmtest3/bin/

4 ，FileTest.class.getClassLoader().getResource("")

獲得的也是當前ClassPath的絕對URI路徑。

如： file:/D:/java/eclipse32/workspace/jbpmtest3/bin/

5 ，ClassLoader.getSystemResource("")

獲得的也是當前ClassPath的絕對URI路徑。

如： file:/D:/java/eclipse32/workspace/jbpmtest3/bin/

   

我推薦使用 Thread.currentThread().getContextClassLoader().getResource("") 來獲得當前的classpath的絕對路徑的URI表示法。

 

Web應用程序中資源的尋址

    上文中說過，當前用戶目錄，即相對於System.getProperty("user.dir")返回的路徑。

對於JavaEE服務器，這多是服務器的某個路徑，這個並無統一的規範！

而不是咱們發佈的Web應用程序的根目錄！

這樣，在Web應用程序中，咱們絕對不能使用相對於當前用戶目錄的相對路徑。

在Web應用程序中，咱們通常經過ServletContext.getRealPath("/")方法獲得Web應用程序的根目錄的絕對路徑。

這樣，咱們只須要提供相對於Web應用程序根目錄的路徑，就能夠構建出定位資源的絕對路徑。

這是咱們開發Web應用程序時通常所採起的策略。

 

通用的相對路徑解決辦法

Java中各類相對路徑很是多，不容易使用，很是容易出錯。所以，我編寫了一個便利方法，幫助更容易的解決相對路徑問題。

 

Web應用程序中使用JavaSE運行的資源尋址問題

在JavaSE程序中，咱們通常使用classpath來做爲存放資源的目的地。可是，在Web應用程序中，咱們通常使用classpath外面的WEB-INF及其子目錄做爲資源文件的存放地。

在Web應用程序中，咱們通常經過ServletContext.getRealPath("/")方法獲得Web應用程序的根目錄的絕對路徑。這樣，咱們只須要提供相對於Web應用程序根目錄的路徑，就能夠構建出定位資源的絕對路徑。

Web應用程序，能夠做爲Web應用程序進行發佈和運行。可是，咱們也經常會以JavaSE的方式來運行Web應用程序的某個類的main方法。或者，使用JUnit測試。這都須要使用JavaSE的方式來運行。

這樣，咱們就沒法使用ServletContext.getRealPath("/")方法獲得Web應用程序的根目錄的絕對路徑。

而JDK提供的ClassLoader類，

它的getResource(String name), getResourceAsStream(String name)等方法，使用相對於當前項目的classpath的相對路徑來查找資源。

讀取屬性文件經常使用到的ResourceBundle類的getBundle(String path)也是如此。

它們都只能使用相對路徑來讀取classpath下的資源，沒法定位到classpath外面的資源。

Classpath外配置文件讀取問題

如，咱們使用測試驅動開發的方法，開發Spring、Hibernate、iBatis等使用配置文件的Web應用程序，就會遇到問題。

儘管Spring本身提供了FileSystem（也就是相對於user,dir目錄）來讀取Web配置文件的方法，可是終究不是很方便。並且與Web程序中的代碼使用方式不一致！

至於Hibernate，iBatis就更麻煩了！只有把配置文件移到classpath下，不然根本不可能使用測試驅動開發！

 

    這怎麼辦？

 

通用的相對路徑解決辦法

面對這個問題，我決定編寫一個助手類 ClassLoaderUtil，提供一個便利方法[ public  static URL getExtendResource(String relativePath)]。在Web應用程序等一切Java程序中，須要定位classpath外的資源時，都使用這個助手類的便利方法，而不使用Web應用程序特有的ServletContext.getRealPath("/")方法來定位資源。

 

利用classpath的絕對路徑，定位全部資源

這個便利方法的實現原理，就是「利用classpath的絕對路徑，定位全部資源」。

ClassLoader類的getResource("")方法可以獲得當前classpath的絕對路徑，這是全部Java程序都擁有的能力，具備最大的適應性！

而目前的JDK提供的ClassLoader類的getResource(String 相對路徑)方法，只能接受通常的相對路徑。這樣，使用ClassLoader類的getResource(String 相對路徑)方法就只能定位到classpath下的資源。

若是，它可以接受「../ 」這樣的參數，容許咱們用相對路徑來定位classpath 外面的資源，那麼咱們就能夠定位位置的資源！

固然，我沒法修改ClassLoader類的這個方法，因而，我編寫了一個助手類ClassLoaderUtil類，提供了[ public  static URL getExtendResource(String relativePath)]這個方法。它可以接受帶有「../」符號的相對路徑，實現了自由尋找資源的功能。

 

經過相對classpath路徑實現自由尋找資源的助手類的源代碼：

import  java.io.IOException;

import  java.io.InputStream;

import  java.net.MalformedURLException;

import  java.net.URL;

import  java.util.Properties;

 

import  org.apache.commons.logging.Log;

import  org.apache.commons.logging.LogFactory;

 

/**

  * @author 沈東良 shendl_s@hotmail.com

  * Nov 29, 2006   10:34:34 AM

  * 用來加載類，ｃｌａｓｓｐａｔｈ下的資源文件，屬性文件等。

  * getExtendResource(String relativePath) 方法，可使用../符號來加載classpath外部的資源。

  */

public class  ClassLoaderUtil {

     private static  Log  log =LogFactory.getLog(ClassLoaderUtil. class );

     /**

      * Thread.currentThread().getContextClassLoader().getResource("")

      */

   

     /**

      * 加載Java類。   使用全限定類名

      * @param className

      * @return

      */

     public static  Class loadClass(String className) {

         try  {

           return  getClassLoader().loadClass(className);

        }  catch  (ClassNotFoundException e) {

           throw new  RuntimeException( "class not found '" +className+ "'" , e);

        }

     }

      /**

        * 獲得類加載器

        * @return

        */

      public static  ClassLoader getClassLoader() {

     

         return  ClassLoaderUtil. class .getClassLoader();

     }

      /**

        * 提供相對於classpath的資源路徑，返回文件的輸入流

        * @param relativePath 必須傳遞資源的相對路徑。是相對於classpath的路徑。若是須要查找classpath外部的資源，須要使用../來查找

        * @return   文件輸入流

      * @throws IOException

      * @throws MalformedURLException

        */

      public static  InputStream getStream(String relativePath)  throws  MalformedURLException, IOException {

          if (!relativePath.contains( "../" )){

              return  getClassLoader().getResourceAsStream(relativePath);

             

         } else {

              return  ClassLoaderUtil.getStreamByExtendResource(relativePath);

         }

       

     }

      /**

        *

        * @param url

        * @return

        * @throws IOException

        */

      public static  InputStream getStream(URL url)  throws  IOException{

          if (url!= null ){

             

                 return  url.openStream();

           

             

         } else {

              return null ;

         }

     }

      /**

        *

        * @param relativePath 必須傳遞資源的相對路徑。是相對於classpath的路徑。若是須要查找classpath外部的資源，須要使用../來查找

        * @return

        * @throws MalformedURLException

        * @throws IOException

        */

      public static  InputStream getStreamByExtendResource(String relativePath)  throws  MalformedURLException, IOException{

         return  ClassLoaderUtil.getStream(ClassLoaderUtil.getExtendResource(relativePath));

         

         

     }

     

       /**

        * 提供相對於classpath的資源路徑，返回屬性對象，它是一個散列表

        * @param resource

        * @return

        */

      public static  Properties getProperties(String resource) {

        Properties properties =  new  Properties();

         try  {

          properties.load(getStream(resource));

        }  catch  (IOException e) {

           throw new  RuntimeException( "couldn't load properties file '" +resource+ "'" , e);

        }

         return  properties;

     }

      /**

        * 獲得本Class所在的ClassLoader的Classpat的絕對路徑。

        * URL 形式的

        * @return

        */

      public static  String getAbsolutePathOfClassLoaderClassPath(){

         

         

         ClassLoaderUtil. log .info(ClassLoaderUtil.getClassLoader().getResource( "" ).toString());

          return  ClassLoaderUtil.getClassLoader().getResource( "" ).toString();

         

     }

      /**

        *

        * @param relativePath   必須傳遞資源的相對路徑。是相對於classpath的路徑。若是須要查找classpath外部的資源，須要使用../來查找

        * @return 資源的絕對URL

      * @throws MalformedURLException

        */

      public static  URL getExtendResource(String relativePath)  throws  MalformedURLException{

     

         ClassLoaderUtil. log .info( " 傳入的相對路徑：" +relativePath) ;

          //ClassLoaderUtil.log.info(Integer.valueOf(relativePath.indexOf("../"))) ;

          if (!relativePath.contains( "../" )){

              return  ClassLoaderUtil.getResource(relativePath);

             

         }

         String classPathAbsolutePath=ClassLoaderUtil.getAbsolutePathOfClassLoaderClassPath();

          if (relativePath.substring(0, 1).equals( "/" )){

             relativePath=relativePath.substring(1);

         }

         ClassLoaderUtil. log .info(Integer.valueOf(relativePath.lastIndexOf( "../" ))) ;

       

         String wildcardString=relativePath.substring(0,relativePath.lastIndexOf( "../" )+3);

        relativePath=relativePath.substring(relativePath.lastIndexOf( "../" )+3);

          int  containSum=ClassLoaderUtil.containSum(wildcardString,  "../" );

         classPathAbsolutePath= ClassLoaderUtil.cutLastString(classPathAbsolutePath,  "/" , containSum);

         String resourceAbsolutePath=classPathAbsolutePath+relativePath;

         ClassLoaderUtil. log .info( " 絕對路徑：" +resourceAbsolutePath) ;

         URL resourceAbsoluteURL= new  URL(resourceAbsolutePath);

          return  resourceAbsoluteURL;

     }

      /**

       *

        * @param source

        * @param dest

        * @return

        */

      private static int  containSum(String source,String dest){

          int  containSum=0;

          int  destLength=dest.length();

          while (source.contains(dest)){

             containSum=containSum+1;

             source=source.substring(destLength);

             

         }

         

         

          return  containSum;

     }

      /**

        *

        * @param source

        * @param dest

        * @param num

        * @return

        */

      private static  String cutLastString(String source,String dest, int  num){

          // String cutSource=null;

          for ( int  i=0;i<num;i++){

             source=source.substring(0, source.lastIndexOf(dest, source.length()-2)+1);

             

             

         }

         

         

         

          return  source;

     }

      /**

        *

        * @param resource

        * @return

        */

       public static  URL getResource(String resource){

      ClassLoaderUtil. log .info( " 傳入的相對於classpath的路徑：" +resource) ;

          return  ClassLoaderUtil.getClassLoader().getResource(resource);

     }

    

 

     

 

     /**

      * @param args

      * @throws MalformedURLException

      */

     public static void  main(String[] args)  throws  MalformedURLException {

       

             //ClassLoaderUtil.getExtendResource("../spring/dao.xml");

         //ClassLoaderUtil.getExtendResource("../../../src/log4j.properties");

        ClassLoaderUtil.getExtendResource( "log4j.properties" );

       

        System. out .println(ClassLoaderUtil.getClassLoader().getResource( "log4j.properties" ).toString());

 

    }

 

}

 

後記

ClassLoaderUtil類的public static URL getExtendResource(String relativePath)，雖然很簡單，可是確實能夠解決大問題。

不過這個方法仍是比較簡陋的。我還想在將來有空時，進一步加強它的能力。好比，增長Ant風格的匹配符。用**表明多個目錄，*表明多個字符，？表明一個字符。達到Spring那樣的能力，一次返回多個資源的URL，進一步方便你們開發。

 

總結：

1，儘可能不要使用相對於System.getProperty("user.dir")當前用戶目錄的相對路徑。這是一顆定時炸彈，隨時可能要你的命。

2，儘可能使用URI形式的絕對路徑資源。它能夠很容易的轉變爲URI,URL，File對象。

3，儘可能使用相對classpath的相對路徑。不要使用絕對路徑。使用上面ClassLoaderUtil類的public static URL getExtendResource(String relativePath)方法已經可以使用相對於classpath的相對路徑定位全部位置的資源。

4，絕對不要使用硬編碼的絕對路徑。由於，咱們徹底可使用ClassLoader類的getResource("")方法獲得當前classpath的絕對路徑。

使用硬編碼的絕對路徑是徹底沒有必要的！它必定會讓你死的很難看！程序將沒法移植！

若是你必定要指定一個絕對路徑，那麼使用配置文件，也比硬編碼要好得多！

固然，我仍是推薦你使用程序獲得classpath的絕對路徑來拼資源的絕對路徑！