java路径解析

java路径最终解决方案http://blog.csdn.net/shendl/article/details/1427475

贴出作者写的一个工具类

这个工具的思路大概就是：

如果路径中没有带有../ 即路径在classes中，那么可以直接调用下面的这行代码获取输入流

如果路径中带有../那么作者就会将这个相对路径进行解析，解析出其绝对路径URL，然后通过URL.openStream()得到这个流

package com.Utils;

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
 *Nov29,2006 10:34:34AM
 *用来加载类，ｃｌａｓｓｐａｔｈ下的资源文件，属性文件等。
 *getExtendResource(StringrelativePath)方法，可以使用../符号来加载classpath外部的资源。
 */
public class ClassLoaderUtil {
    private static Log log=LogFactory.getLog(ClassLoaderUtil.class);
    /**
     *Thread.currentThread().getContextClassLoader().getResource("")
     */
   
    /**
     *加载Java类。 使用全限定类名
     *@paramclassName
     *@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的资源路径，返回文件的输入流
       *@paramrelativePath必须传递资源的相对路径。是相对于classpath的路径。如果需要查找classpath外部的资源，需要使用../来查找
       *@return 文件输入流
     *@throwsIOException
     *@throwsMalformedURLException
       */
     public static InputStream getStream(String relativePath) throws MalformedURLException, IOException {
         if(!relativePath.contains("../")){
             return getClassLoader().getResourceAsStream(relativePath);
             
         }else{
             return ClassLoaderUtil.getStreamByExtendResource(relativePath);
         }
       
     }
     /**
       *
       *@paramurl
       *@return
       *@throwsIOException
       */
     public static InputStream getStream(URL url) throws IOException{
         if(url!=null){
             
                return url.openStream();
           
             
         }else{
             return null;
         }
     }
     /**
       *
       *@paramrelativePath必须传递资源的相对路径。是相对于classpath的路径。如果需要查找classpath外部的资源，需要使用../来查找
       *@return
       *@throwsMalformedURLException
       *@throwsIOException
       */
     public static InputStream getStreamByExtendResource(String relativePath) throws MalformedURLException, IOException{
        return ClassLoaderUtil.getStream(ClassLoaderUtil.getExtendResource(relativePath));
         
         
     }
     
      /**
       *提供相对于classpath的资源路径，返回属性对象，它是一个散列表
       *@paramresource
       *@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();
         
     }
     /**
       *
       *@paramrelativePath 必须传递资源的相对路径。是相对于classpath的路径。如果需要查找classpath外部的资源，需要使用../来查找
       *@return资源的绝对URL
     *@throwsMalformedURLException
       */
     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();
         ClassLoaderUtil.log.info("classPathAbsolutePath:"+classPathAbsolutePath);
         //如果是当前目录的路径 ./
         if(relativePath.substring(0, 1).equals("/")){
             relativePath=relativePath.substring(1);
             System.out.println(relativePath);
         }
         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);
         System.out.println(classPathAbsolutePath);
         String resourceAbsolutePath=classPathAbsolutePath+relativePath;
         ClassLoaderUtil.log.info("绝对路径："+resourceAbsolutePath) ;
         URL resourceAbsoluteURL=new URL(resourceAbsolutePath);
         return resourceAbsoluteURL;
     }
     /**
      *看source里面包含多少个dest
       *@paramsource
       *@paramdest
       *@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;
     }
     /**
       *
       *@paramsource
       *@paramdest
       *@paramnum
       *@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;
     }
     /**
       *
       *@paramresource
       *@return
       */
      public static URL getResource(String resource){
      ClassLoaderUtil.log.info("传入的相对于classpath的路径："+resource) ;
         return ClassLoaderUtil.getClassLoader().getResource(resource);
     }
    
 
     
 
    /**
     *@paramargs
     *@throwsMalformedURLException
     */
    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());
        String a="abcd/efg/hijk/lmn";
        System.out.println(a.lastIndexOf("/", 3));
    }
 
}

InputStream input = this.getClass().getClassLoader().getResourceAsStream("Book.xml");//得到类加载器，这个是在当前的classpath下面查找Book.xml

如果直接getResourceAsStream(filePath);这个filePath只能在classPath下面(如图的classes下面)，可以用 ./com/Book.xml(等价于 com/Book.xml).

源代码对不在这个classPath下面的路径可能没有相应的解析功能，如../Book.xml就会报错

而作者写的这个工具类可以使用classPath的上层路径如../Book.xml获取build目录下面的xml

我看了下源代码，最终还是使用了URL.openStream()；将这个Book.xml构造成URL的绝对路径形式来获得这个流

引用作者这句话

因此，归根结底，Java本质上只能使用绝对路径来寻找资源。所有的相对路径寻找资源的方法，都不过是一些便利方法。不过是API在底层帮助我们构建了绝对路径，从而找到资源的！

URL URI String

只能通过URL来打开资源

本地系统路径 D:/java/eclipse32/workspace/jbpmtest3/bin/aaa.b

URL file:/F:/workspace/Test/Book.xml