程序博客网 > ax是什么软件

java 路径(相对路径和绝对路径)问题汇总

来源：互联网 发布：ax是什么软件 编辑：程序博客网 时间：2024/04/30 07:19

原文转载自点击打开链接


1.基本概念的理解


绝对路径：绝对路径就是你的主页上的文件或目录在硬盘上真正的路径，(URL和物理路径)例如：
C:xyz est.txt 代表了test.txt文件的绝对路径。http://www.sun.com/index.htm也代表了一个URL绝对路径。


相对路径：相对与某个基准目录的路径。包含Web的相对路径（HTML中的相对目录），例如：在
Servlet中，"/"代表Web应用的跟目录。和物理路径的相对表示。例如："./" 代表当前目录,"../"代表上级目录。这种类似的表示，也是属于相对路径。
另外关于URI，URL,URN等内容，请参考RFC相关文档标准。


RFC 2396: Uniform Resource Identifiers (URI): Generic Syntax,
(http://www.ietf.org/rfc/rfc2396.txt)




2.关于JSP/Servlet中的相对路径和绝对路径。


2.1服务器端的地址


服务器端的相对地址指的是相对于你的web应用的地址，这个地址是在服务器端解析的（不同于html和javascript中的相对地址，他们是由客户端浏览器解析的）也就是说这时候在jsp和servlet中的相对地址应该是相对于你的web应用，即相对于http: //192.168.0.1/webapp/的。


其用到的地方有：
forward：servlet中的request.getRequestDispatcher(address);

这个address是在服务器端解析的，所以，你要forward到a.jsp应该这么写：request.getRequestDispatcher(“/user/a.jsp”)这个/ 相对于当前的web应用webapp，

其绝对地址就是：http://192.168.0.1/webapp/user/a.jsp。

sendRedirect：在jsp中<%response.sendRedirect("/rtccp/user/a.jsp");%>


2.22、客户端的地址


所有的html页面中的相对地址都是相对于服务器根目录(http://192.168.0.1/)的，而不是(跟目录下的该Web应用的目录) http://192.168.0.1/webapp/的。

Html中的form表单的action属性的地址应该是相对于服务器根目录(http://192.168.0.1/)的，所以，如果提交到a.jsp 为：action＝"/webapp/user/a.jsp"或action="<%=request.getContextPath()% >"/user/a.jsp；
提交到servlet为actiom＝"/webapp/handleservlet" Javascript也是在客户端解析的，所以其相对路径和form表单一样。




因此，一般情况下，在JSP/HTML页面等引用的CSS,Javascript.Action等属性前面最好都加上
<%=request.getContextPath()%>,以确保所引用的文件都属于Web应用中的目录。另外，应该尽量避免使用类似".","./","../../"等类似的相对该文件位置的相对路径，这样当文件移动时，很容易出问题。




3. JSP/Servlet中获得当前应用的相对路径和绝对路径


3.1 JSP中获得当前应用的相对路径和绝对路径
根目录所对应的绝对路径: request.getRequestURI()
文件的绝对路径 　: application.getRealPath(request.getRequestURI());
当前web应用的绝对路径 : application.getRealPath("/");
取得请求文件的上层目录 : new File(application.getRealPath(request.getRequestURI())).getParent()


3.2 Servlet中获得当前应用的相对路径和绝对路径
根目录所对应的绝对路径 : request.getServletPath();
文件的绝对路径 : request.getSession().getServletContext().getRealPath
(request.getRequestURI())
当前web应用的绝对路径 :servletConfig.getServletContext().getRealPath("/");
(ServletContext对象获得几种方式：
javax.servlet.http.HttpSession.getServletContext()
javax.servlet.jsp.PageContext.getServletContext()
javax.servlet.ServletConfig.getServletContext()
)


4.java 的Class中获得相对路径，绝对路径的方法


4.1单独的Java类中获得绝对路径
根据java.io.File的Doc文挡，可知:
默认情况下new File("/")代表的目录为：System.getProperty("user.dir")。
一下程序获得执行类的当前路径


[java] view plaincopyprint?
  1. package com.itm.path;  
  2. public class TestSystemproperty{  
  3.     public static void main(String[] args){  
  4.           
  5.           
  6.    System.out.println("Java运行时环境版本:\n"+System.getProperty("java.version"));  
  7.    System.out.println("Java 运行时环境供应商:\n"+System.getProperty("java.vendor"));  
  8.    System.out.println("Java 供应商的URL:\n"+System.getProperty("java.vendor.url"));  
  9.    System.out.println("Java安装目录:\n"+System.getProperty("java.home"));  
  10.    System.out.println("Java 虚拟机规范版本:\n"+System.getProperty("java.vm.specification.version"));  
  11.    System.out.println("Java 类格式版本号:\n"+System.getProperty("java.class.version"));  
  12.    System.out.println("Java类路径：\n"+System.getProperty("java.class.path"));  
  13.    System.out.println("加载库时搜索的路径列表:\n"+System.getProperty("java.library.path"));  
  14.    System.out.println("默认的临时文件路径:\n"+System.getProperty("java.io.tmpdir"));  
  15.    System.out.println("要使用的 JIT 编译器的名称:\n"+System.getProperty("java.compiler"));  
  16.    System.out.println("一个或多个扩展目录的路径:\n"+System.getProperty("java.ext.dirs"));  
  17.    System.out.println("操作系统的名称:\n"+System.getProperty("os.name"));  
  18.    System.out.println("操作系统的架构:\n"+System.getProperty("os.arch"));  
  19.    System.out.println("操作系统的版本:\n"+System.getProperty("os.version"));  
  20.    System.out.println("文件分隔符（在 UNIX 系统中是“/”）:\n"+System.getProperty("file.separator"));  
  21.    System.out.println("路径分隔符（在 UNIX 系统中是“:”）:\n"+System.getProperty("path.separator"));  
  22.    System.out.println("行分隔符（在 UNIX 系统中是“/n”）:\n"+System.getProperty("line.separator"));  
  23.    System.out.println("用户的账户名称:\n"+System.getProperty("user.name"));  
  24.    System.out.println("用户的主目录:\n"+System.getProperty("user.home"));  
  25.    System.out.println("用户的当前工作目录:\n"+System.getProperty("user.dir"));  
  26.      
  27.    System.out.println("当前的classpath的绝对路径的URI表示法：---->> :\n" + Thread.currentThread().getContextClassLoader().getResource(""));  
  28.      
  29.    System.out.println("得到的是当前类FileTest.class文件的URI目录。不包括自己！:\n"+TestSystemproperty.class.getResource(""));  
  30.    System.out.println("得到的是当前的classpath的绝对URI路径。:\n"+ TestSystemproperty.class.getResource("/"));  
  31. }  
  32. }  

4.2服务器中的Java类获得当前路径（来自网络）


(1).Weblogic


WebApplication的系统文件根目录是你的weblogic安装所在根目录。
例如：如果你的weblogic安装在c:eaweblogic700.....
那么，你的文件根路径就是c:.
所以，有两种方式能够让你访问你的服务器端的文件：
a.使用绝对路径：
比如将你的参数文件放在c:yourconfigyourconf.properties，
直接使用 new FileInputStream("yourconfig/yourconf.properties");
b.使用相对路径：
相对路径的根目录就是你的webapplication的根路径，即WEB-INF的上一级目录，将你的参数文件放


在yourwebappyourconfigyourconf.properties，
这样使用：
new FileInputStream("./yourconfig/yourconf.properties");
这两种方式均可，自己选择。


(2).Tomcat


在类中输出System.getProperty("user.dir"); 显示的是%Tomcat_Home%/bin


(3).Resin


不是你的JSP放的相对路径,是JSP引擎执行这个JSP编译成SERVLET
的路径为根.比如用新建文件法测试File f = new File("a.htm");
这个a.htm在resin的安装目录下


(4).如何读相对路径哪？


在Java文件中getResource或getResourceAsStream均可


例：getClass().getResourceAsStream(filePath);//filePath可以是"/filename",这里的/代表web


发布根路径下WEB-INF/classes


默认使用该方法的路径是：WEB-INF/classes。已经在Tomcat中测试。


5.读取文件时的相对路径，避免硬编码和绝对路径的使用。（来自网络）
5.1 采用Spring的DI机制获得文件，避免硬编码。
参考下面的连接内容：
http://www.javajia.net/viewtopic.php?p=90213&
5.2 配置文件的读取
参考下面的连接内容：
http://dev.csdn.net/develop/article/39/39681.shtm


5.3 通过虚拟路径或相对路径读取一个xml文件，避免硬编码


参考下面的连接内容：
http://club.gamvan.com/club/clubPage.jsp?iPage=1&tID=10708&ccID=8


6.Java中文件的常用操作（复制，移动，删除，创建等）（来自网络）
常用 java File 操作类
http://www.easydone.cn/014/200604022353065155.htm


Java文件操作大全（JSP中）
http://www.pconline.com.cn/pcedu/empolder/gj/java/0502/559401.html


java文件操作详解（Java中文网）
http://www.51cto.com/html/2005/1108/10947.htm


JAVA 如何创建删除修改复制目录及文件
http://www.gamvan.com/developer/java/2005/2/264.html


总结：
通过上面内容的使用，可以解决在Web应用服务器端，移动文件，查找文件，复制
删除文件等操作，同时对服务器的相对地址，绝对地址概念更加清晰。
建议参考URI,的RFC标准文挡。同时对Java.io.File. Java.net.URI.等内容了解透彻
对其他方面的理解可以更加深入和透彻。

 


以下内容转自：http://blog.csdn.net/shendl/article/details/1427475


Java路径问题最终解决方案

—可定位所有资源的相对路径寻址



前言
Java的路径问题，非常难搞。最近的工作涉及到创建和读取文件的工作，这里我就给大家彻底得解决Java路径问题。
我编写了一个方法，比ClassLoader.getResource(String 相对路径)方法的能力更强。它可以接受“../”这样的参数，允许我们用相对路径来定位classpath外面的资源。这样，我们就可以使用相对于classpath的路径，定位所有位置的资源！

Java路径
Java中使用的路径，分为两种：绝对路径和相对路径。具体而言，又分为四种：
一、URI形式的绝对资源路径
如：file:/D:/java/eclipse32/workspace/jbpmtest3/bin/aaa.b
URL是URI的特例。URL的前缀/协议，必须是Java认识的。URL可以打开资源，而URI则不行。
URL和URI对象可以互相转换，使用各自的toURI(),toURL()方法即可！

二、本地系统的绝对路径
D:/java/eclipse32/workspace/jbpmtest3/bin/aaa.b
Java.io包中的类，需要使用这种形式的参数。
但是，它们一般也提供了URI类型的参数，而URI类型的参数，接受的是URI样式的String。因此，通过URI转换，还是可以把URI样式的绝对路径用在java.io包中的类中。

三、相对于classpath的相对路径
如：相对于
file:/D:/java/eclipse32/workspace/jbpmtest3/bin/这个路径的相对路径。其中，bin是本项目的classpath。所有的Java源文件编译后的.class文件复制到这个目录中。

四、相对于当前用户目录的相对路径


就是相对于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路径实现自由寻找资源的助手类的源代码：


[java] view plaincopyprint?
  1. package com.itm.path;  
  2. import java.io.IOException;  
  3. import java.io.InputStream;  
  4. import java.net.MalformedURLException;  
  5. import java.net.URL;  
  6. import java.util.Properties;  
  7. import org.apache.commons.logging.Log;  
  8. import org.apache.commons.logging.LogFactory;  
  9. /** 
  10.  *@author沈东良shendl_s@hotmail.com Nov29,2006 10:34:34AM 
  11.  *                                用来加载类，ｃｌａｓｓｐａｔｈ下的资源文件，属性文件等。 
  12.  *                                getExtendResource( 
  13.  *                                StringrelativePath)方法，可以使用../ 
  14.  *                                符号来加载classpath外部的资源。 
  15.  */  
  16. public class ClassLoaderUtil {  
  17.     private static Log log = LogFactory.getLog(ClassLoaderUtil.class);  
  18.     /** 
  19.      *Thread.currentThread().getContextClassLoader().getResource("") 
  20.      */  
  21.     /** 
  22.      *加载Java类。 使用全限定类名 
  23.      *  
  24.      * @paramclassName 
  25.      *@return 
  26.      */  
  27.     public static Class loadClass(String className) {  
  28.         try {  
  29.             return getClassLoader().loadClass(className);  
  30.         } catch (ClassNotFoundException e) {  
  31.             throw new RuntimeException("class not found '" + className + "'", e);  
  32.         }  
  33.     }  
  34.     /** 
  35.      *   得到类加载器 
  36.      *  
  37.      * @return 
  38.      */  
  39.     public static ClassLoader getClassLoader() {  
  40.         return ClassLoaderUtil.class.getClassLoader();  
  41.     }  
  42.     /** 
  43.      *   提供相对于classpath的资源路径，返回文件的输入流 
  44.      *  
  45.      * @paramrelativePath必须传递资源的相对路径。 
  46.      *              是相对于classpath的路径。如果需要查找classpath外部的资源，需要使用../来查找 
  47.      * @return 文件输入流 
  48.      * @throwsIOException 
  49.      * @throwsMalformedURLException 
  50.      */  
  51.     public static InputStream getStream(String relativePath)  
  52.             throws MalformedURLException, IOException {  
  53.         if (!relativePath.contains("../")) {  
  54.             return getClassLoader().getResourceAsStream(relativePath);  
  55.         } else {  
  56.             return ClassLoaderUtil.getStreamByExtendResource(relativePath);  
  57.         }  
  58.     }  
  59.     /** 
  60.      *  
  61.      *@paramurl 
  62.      *@return 
  63.      *@throwsIOException 
  64.      */  
  65.     public static InputStream getStream(URL url) throws IOException {  
  66.         if (url != null) {  
  67.             return url.openStream();  
  68.         } else {  
  69.             return null;  
  70.         }  
  71.     }  
  72.     /** 
  73.      *  
  74.      *@paramrelativePath必须传递资源的相对路径。是相对于classpath的路径。如果需要查找classpath外部的资源，需要使用../来查找 
  75.      *@return 
  76.      *@throwsMalformedURLException 
  77.      *@throwsIOException 
  78.      */  
  79.     public static InputStream getStreamByExtendResource(String relativePath)  
  80.             throws MalformedURLException, IOException {  
  81.         return ClassLoaderUtil.getStream(ClassLoaderUtil  
  82.                 .getExtendResource(relativePath));  
  83.     }  
  84.     /** 
  85.      *提供相对于classpath的资源路径，返回属性对象，它是一个散列表 
  86.      *  
  87.      * @paramresource 
  88.      *@return 
  89.      */  
  90.     public static Properties getProperties(String resource) {  
  91.         Properties properties = new Properties();  
  92.         try {  
  93.             properties.load(getStream(resource));  
  94.         } catch (IOException e) {  
  95.             throw new RuntimeException("couldn't load properties file '"  
  96.                     + resource + "'", e);  
  97.         }  
  98.         return properties;  
  99.     }  
  100.     /** 
  101.      *得到本Class所在的ClassLoader的Classpath的绝对路径。 URL形式的 
  102.      *  
  103.      * @return 
  104.      */  
  105.     public static String getAbsolutePathOfClassLoaderClassPath() {  
  106.         ClassLoaderUtil.log.info(ClassLoaderUtil.getClassLoader().getResource(  
  107.                 "").toString());  
  108.         return ClassLoaderUtil.getClassLoader().getResource("").toString();  
  109.     }  
  110.     /** 
  111.      *  
  112.      *@paramrelativePath  
  113.      *                    必须传递资源的相对路径。是相对于classpath的路径。 
  114.      *                    如果需要查找classpath外部的资源，需要使用../来查找。 
  115.      *@return资源的绝对URL 
  116.      *@throwsMalformedURLException 
  117.      */  
  118.     public static URL getExtendResource(String relativePath)  
  119.             throws MalformedURLException {  
  120.         ClassLoaderUtil.log.info("传入的相对路径：" + relativePath);  
  121.         // ClassLoaderUtil.log.info(Integer.valueOf(relativePath.indexOf("../")))  
  122.         // ;   
  123.         if (!relativePath.contains("../")) {  
  124.             return ClassLoaderUtil.getResource(relativePath);  
  125.         }  
  126.         String classPathAbsolutePath = ClassLoaderUtil  
  127.                 .getAbsolutePathOfClassLoaderClassPath();  
  128.         if (relativePath.substring(0, 1).equals("/")) {  
  129.             relativePath = relativePath.substring(1);  
  130.         }  
  131.         ClassLoaderUtil.log.info(Integer.valueOf(relativePath  
  132.                 .lastIndexOf("../")));  
  133.         String wildcardString = relativePath.substring(0, relativePath  
  134.                 .lastIndexOf("../") + 3);  
  135.         relativePath = relativePath  
  136.                 .substring(relativePath.lastIndexOf("../") + 3);  
  137.         int containSum = ClassLoaderUtil.containSum(wildcardString, "../");  
  138.         classPathAbsolutePath = ClassLoaderUtil.cutLastString(  
  139.                 classPathAbsolutePath, "/", containSum);  
  140.         String resourceAbsolutePath = classPathAbsolutePath + relativePath;  
  141.         ClassLoaderUtil.log.info("绝对路径：" + resourceAbsolutePath);  
  142.         URL resourceAbsoluteURL = new URL(resourceAbsolutePath);  
  143.         return resourceAbsoluteURL;  
  144.     }  
  145.     /** 
  146.      *  
  147.      *@paramsource 
  148.      *@paramdest 
  149.      *@return 
  150.      */  
  151.     private static int containSum(String source, String dest) {  
  152.         int containSum = 0;  
  153.         int destLength = dest.length();  
  154.         while (source.contains(dest)) {  
  155.             containSum = containSum + 1;  
  156.             source = source.substring(destLength);  
  157.         }  
  158.         return containSum;  
  159.     }  
  160.     /** 
  161.      *  
  162.      *@paramsource 
  163.      *@paramdest 
  164.      *@paramnum 
  165.      *@return 
  166.      */  
  167.     private static String cutLastString(String source, String dest, int num) {  
  168.         // String cutSource=null;   
  169.         for (int i = 0; i < num; i++) {  
  170.             source = source.substring(0, source.lastIndexOf(dest, source  
  171.                     .length() - 2) + 1);  
  172.         }  
  173.         return source;  
  174.     }  
  175.     /** 
  176.      *  
  177.      *@paramresource 
  178.      *@return 
  179.      */  
  180.     public static URL getResource(String resource) {  
  181.         ClassLoaderUtil.log.info("传入的相对于classpath的路径：" + resource);  
  182.         return ClassLoaderUtil.getClassLoader().getResource(resource);  
  183.     }  
  184.     /** 
  185.      *@paramargs 
  186.      *@throwsMalformedURLException 
  187.      */  
  188.     public static void main(String[] args) throws MalformedURLException {  
  189.         // ClassLoaderUtil.getExtendResource("../spring/dao.xml");  
  190.         // ClassLoaderUtil.getExtendResource("../../../src/log4j.properties");  
  191.         ClassLoaderUtil.getExtendResource("log4j.properties");  
  192.         System.out.println(ClassLoaderUtil.getClassLoader().getResource(  
  193.                 "log4j.properties").toString());  
  194.     }  
  195. }  

打印结果：

 

2012-05-04 21:37:44,609 INFO [com.itm.path.ClassLoaderUtil] - 传入的相对路径：log4j.properties
2012-05-04 21:37:44,609 INFO [com.itm.path.ClassLoaderUtil] - 传入的相对于classpath的路径：log4j.properties
file:/D:/project/testJava/bin/log4j.properties


后记
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的绝对路径来拼资源的绝对路径！



ax是什么软件 ax是什么软件
原创粉丝点击
热门IT博客
ubuntu selinux关闭ubuntu selinux关闭
python items函数python items函数
php 调用nonwsdl 接口
mac mpv 播放器下载
mac中解压软件
eia原油数据库存怎么看
昆明高级seo工程师
mysql删除触发器语句
win10桌面便签软件
个人大数据怎样查询
哈尔滨一手房看房软件
win10网络变慢
协同过滤推荐算法发展
计算机与网络基础知识
怎么删除windows.old
java生成svg
js删除数组最后一个
java 默认字符集
电视网络接口怎么安装
好用的面部精华知乎
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 公路水运检测工程师 天津水运工程科学研究院 公路水运工程监理工程师 广西西江水运物流网 船闸调度西江水运网 船闸调度西江水运物流网 船闸动态西江水运网 长州船闸西江水运物流网 为什么胎儿有u型压迹 逆峰水千丞 佰草集新逆时抗皱活颜水 逆锋水千丞在线阅读 水豆传染吗怎么预防 你在逗我吗的英文 水痘的主要传播途径 怎么预防水痘传染 如何预防水痘传染 水痘的传染途径 水痘传播途径有哪些 水痘传染期是多久 水痘怎么传染途径 水痘的传染 水遁歌曲 水遁大瀑布之术 水都论坛 水都网 嗯好软都成一滩水快穿 龙门水都 水都论坛丹江囗 丹江口市水都网 全校都以为我很丑右三水 水都论坛丹江口 南宁龙门水都 龙门水都风景区门票要多少钱 龙门水都一日游攻略 丹江口水都网 丹江口水都论坛 水都 魏都水世界 南宁龙门水都门票多少钱 龙门水都门票多少钱

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里