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

转载 2013年12月02日 22:28:03

原文转载自点击打开链接


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")。
一下程序获得执行类的当前路径


  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路径实现自由寻找资源的助手类的源代码:


  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.  *                                用来加载类,classpath下的资源文件,属性文件等。 
  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(01).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的绝对路径来拼资源的绝对路径!



相关文章推荐

Java路径问题最终解决方案—可定位所有资源的相对路径寻址

Java路径问题最终解决方案                      ...
  • shendl
  • shendl
  • 2006-12-03 01:34
  • 39366

Java中相对路径与绝对路径的总结

操作系统约定,文件或目录的路径名由斜线(/)或反斜线(\)分割,此外,相对路径中可以采用'.'表示当前路径,'..'表示当前路径的父路径,即上一级目录。 Java编程时,需要注意,'\'后面表示的是...

java中如何获取绝对路径和相对路径

3. JSP/Servlet中获得当前应用的相对路径和绝对路径 3.1 JSP中获得当前应用的相对路径和绝对路径  根目录所对应的绝对路径:request.getRequestURI()  文件...

JAVA File的创建及相对路径绝对路径

File f = newFile("D:/test/mytest.txt");//当执行这句话后在内存的栈空间存在一个f的应用,在堆空间里存在一个mytest.txt对象。注意 这个对象只含有文件的...

java相对路径设置

在java中相对路径的设置是一个比较头痛的问题:配置文件应该写在哪里,"/","./"等各自代表着什么含义,普通的java工程和jsp(servlet)的路径有什么不同,这都是我们特别需要留意的。不然...

java相对路径与绝对路径

1.基本概念的理解 绝对路径:绝对路径就是你的主页上的文件或目录在硬盘上真正的路径,(URL和物理路径)例如: C:xyz est.txt 代表了test.txt文件的绝对路径。http://...

java(Web)中相对路径,绝对路径问题总结

java中相对路径,绝对路径问题总结               ————bohemia(城)前言: 前一段时间,由于在处理Web应用下的文件创建与移动等,因此涉及到很多关于java中相对路径,绝对路...

Java中文件的相对路径与绝对路径

通过这篇博客可以深入理解Java中相对路径与绝对路径的概念,同时对Eclipse和tomcat中的相对路径也做介绍,有助于开发。另外,getPath()、getAbsolutePath()、getCa...

Java中的相对路径与绝对路径

Java相对路径/绝对路径总结 2008-07-01 11:43:18| 分类: java技术 |举报|字号 订阅 路径分隔符是双反斜杠“\”createNewFile()方法抛出异常,调用时必...

Java:System.loadLibrary()的使用方法汇总

转自http://blog.csdn.net/forandever/article/details/5983846 当使用System.loadLibrary()调用 Dll,两种方法:...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)