java 路径(相对路径和绝对路径)问题汇总【摘抄】

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

package com.itm.path;
public class TestSystemproperty{

    public static void main(String[] args){
    	
    	

   System.out.println("Java运行时环境版本:\n"+System.getProperty("java.version"));

   System.out.println("Java 运行时环境供应商:\n"+System.getProperty("java.vendor"));

   System.out.println("Java 供应商的URL:\n"+System.getProperty("java.vendor.url"));

   System.out.println("Java安装目录:\n"+System.getProperty("java.home"));

   System.out.println("Java 虚拟机规范版本:\n"+System.getProperty("java.vm.specification.version"));

   System.out.println("Java 类格式版本号:\n"+System.getProperty("java.class.version"));

   System.out.println("Java类路径：\n"+System.getProperty("java.class.path"));

   System.out.println("加载库时搜索的路径列表:\n"+System.getProperty("java.library.path"));

   System.out.println("默认的临时文件路径:\n"+System.getProperty("java.io.tmpdir"));

   System.out.println("要使用的 JIT 编译器的名称:\n"+System.getProperty("java.compiler"));

   System.out.println("一个或多个扩展目录的路径:\n"+System.getProperty("java.ext.dirs"));

   System.out.println("操作系统的名称:\n"+System.getProperty("os.name"));

   System.out.println("操作系统的架构:\n"+System.getProperty("os.arch"));

   System.out.println("操作系统的版本:\n"+System.getProperty("os.version"));

   System.out.println("文件分隔符（在 UNIX 系统中是“/”）:\n"+System.getProperty("file.separator"));

   System.out.println("路径分隔符（在 UNIX 系统中是“:”）:\n"+System.getProperty("path.separator"));

   System.out.println("行分隔符（在 UNIX 系统中是“/n”）:\n"+System.getProperty("line.separator"));

   System.out.println("用户的账户名称:\n"+System.getProperty("user.name"));

   System.out.println("用户的主目录:\n"+System.getProperty("user.home"));

   System.out.println("用户的当前工作目录:\n"+System.getProperty("user.dir"));
   
   System.out.println("当前的classpath的绝对路径的URI表示法：---->> :\n" + Thread.currentThread().getContextClassLoader().getResource(""));
   
   System.out.println("得到的是当前类FileTest.class文件的URI目录。不包括自己！:\n"+TestSystemproperty.class.getResource(""));
   System.out.println("得到的是当前的classpath的绝对URI路径。:\n"+ TestSystemproperty.class.getResource("/"));

}

}

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

package com.itm.path;

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沈东良[e-mail] 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的Classpath的绝对路径。 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();
		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;
	}

	/**
	 * 
	 *@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());

	}

}

打印结果：

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