java 路径转url_Java路径的最终解决方案(转)

利用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

*Nov29,2006 10:34:34AM

*用来加载类，classpath下的资源文件，属性文件等。

*getExtendResource(StringrelativePath)方法，

*可以使用../符号来加载classpath外部的资源。

*/

publicclass ClassLoaderUtil {

privatestatic Log log=LogFactory.getLog(ClassLoaderUtil.class);

/**

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

*/

/**

*加载Java类。 使用全限定类名

*@paramclassName

*@return

*/

publicstatic Class loadClass(String className) {

try {

return getClassLoader().loadClass(className);

} catch (ClassNotFoundException e) {

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

}

}

/**

*得到类加载器

*@return

*/

publicstatic ClassLoader getClassLoader() {

return ClassLoaderUtil.class.getClassLoader();

}

/**

*提供相对于classpath的资源路径，返回文件的输入流

*@paramrelativePath必须传递资源的相对路径。

*@是相对于classpath的路径。

*@如果需要查找classpath外部的资源，需要使用../来查找

*@return 文件输入流

*@throwsIOException

*@throwsMalformedURLException

*/

publicstatic InputStream getStream(String relativePath)

throws MalformedURLException, IOException {

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

return getClassLoader().getResourceAsStream(relativePath);

}else{

return ClassLoaderUtil.getStreamByExtendResource(relativePath);

}

}

/**

*

*@paramurl

*@return

*@throwsIOException

*/

publicstatic InputStream getStream(URL url) throws IOException{

if(url!=null){

return url.openStream();

}else{

returnnull;

}

}

/**

*

*@paramrelativePath必须传递资源的相对路径。是相对于classpath的路径。

*@如果需要查找classpath外部的资源，需要使用../来查找

*@return

*@throwsMalformedURLException

*@throwsIOException

*/

publicstatic InputStream getStreamByExtendResource(String relativePath)

throws MalformedURLException, IOException{

return ClassLoaderUtil.getStream(

ClassLoaderUtil.getExtendResource(relativePath));

}

/**

*提供相对于classpath的资源路径，返回属性对象，它是一个散列表

*@paramresource

*@return

*/

publicstatic Properties getProperties(String resource) {

Properties properties = new Properties();

try {

properties.load(getStream(resource));

} catch (IOException e) {

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

}

return properties;

}

/**

*得到本Class所在的ClassLoader的Classpat的绝对路径。

*URL形式的

*@return

*/

publicstatic String getAbsolutePathOfClassLoaderClassPath(){

ClassLoaderUtil.log.info(

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

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

}

/**

*

*@paramrelativePath 必须传递资源的相对路径。是相对于classpath的路径。

*@如果需要查找classpath外部的资源，需要使用../来查找

*@return资源的绝对URL

*@throwsMalformedURLException

*/

publicstatic 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

*/

privatestaticint 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

*/

privatestatic String cutLastString(String source,String dest,int num){

// String cutSource=null;

for(int i=0;i

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

}

return source;

}

/**

*

*@paramresource

*@return

*/

publicstatic URL getResource(String resource){

ClassLoaderUtil.log.info("传入的相对于classpath的路径："+resource) ;

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

}

/**

*@paramargs

*@throwsMalformedURLException

*/

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