Java文件路径

最新推荐文章于 2024-11-01 14:48:20 发布
最新推荐文章于 2024-11-01 14:48:20 发布
阅读量827 收藏
点赞数
分类专栏： java 文章标签： classloader java properties string null class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hezhong002/article/details/7010175
版权

在做项目经常需要用到配置文件，读取文件的路径问题也是我们经常遇到的。一般路径问题分为2种：classpath路径和web路径。

一.Class路径

概念：ClassLoader类加载器，负责加载类的对象。查找classpath离不开ClassLoader的帮助。

           ClassLoader提供getResource(String name)方法,查找具有给定名称的资源。

getResource
public URL getResource(String name)查找具有给定名称的资源。资源是可以通过类代码以与代码基无关的方式访问的一些数据（图像、声音、文本等）。 
资源名称是以 '/' 分隔的标识资源的路径名称。 

此方法首先搜索资源的父类加载器；如果父类加载器为 null，则搜索的路径就是虚拟机的内置类加载器的路径。如果搜索失败，则此方法将调用 findResource(String) 来查找资源。

参数：
	name - 资源名称 
返回：
	读取资源的 URL 对象；如果找不到该资源，或者调用者没有足够的权限获取该资源，则返回 null。
从以下版本开始： 
	1.1
查找类路径的配置文件总共有多种方法实现，都是在获得 ClassLoader实例的情况下实现的 ，以为PathExample对象为例：

(1) PathExample.class.getResource("")

(2) PathExample.class.getResource("/")

(1)和(2)是调用同一个方法,都是从当前类的Class对象中获取资源地址

getResource
public URL getResource(String name)查找带有给定名称的资源。查找与给定类相关的资源的规则是通过定义类的 classloader 实现的。此方法委托给此对象的类加载器。如果此对象通过引导类加载器加载，则此方法将委托给 ClassLoader.getSystemResource(java.lang.String)。 
在委托前，使用下面的算法从给定的资源名构造一个绝对资源名： 

如果 name 以 '/' ('\u002f') 开始，则绝对资源名是 '/' 后面的 name 的一部分。 
否则，绝对名具有以下形式： 
   modified_package_name/name
其中 modified_package_name 是此对象的包名，该名用 '/' 取代了 '.' ('\u002e')。 


参数：
	name - 所需资源的名称 
返回：
	一个 URL 对象；如果找不到带有该名称的资源，则返回 null
从以下版本开始： 
	JDK1.1

也就是这个方法是先查找是否有类的过定义类的classloader实现，如果有就从自定义的classloader中查找资源，如果没有就从
ClassLoader.getSystemResource(java.lang.String)也就是从默认的系统类加载器中查找.

 

(1)表示的当前的包路径,如果配置文件在当前包内，可以直接传入配置文件名字,如:text.xml

(2)表示前的classpath的根路径, 如果配置文件在根目录，则传入参数 /text.xml

如果资源文件在包里面可以通过传入包路径来获得资源地址，如在包a/b/c/test.xml文件,

应传入参数 /a/b/c/test.xml

(3) PathExample.class.getClassLoader().getResource("")

此方法获取claspaths根路径

getClassLoader
public ClassLoader getClassLoader()返回该类的类加载器。有些实现可能使用 null 来表示引导类加载器。如果该类由引导类加载器加载，则此方法在这类实现中将返回 null。 
如果存在安全管理器，并且调用者的类加载器不是 null，也不同于或是请求其类加载器的类的类加载器的祖先，则此方法通过 RuntimePermission("getClassLoader") 权限调用此安全管理器的 checkPermission 方法，以确保可以访问该类的类加载器。 

如果此对象表示一个基本类型或 void，则返回 null。 


返回：
	加载此对象所表示的类或接口的类加载器。 
抛出： 
	SecurityException - 如果存在安全管理器，并且 checkPermission 方法拒绝对该类类加载器的访问。
另请参见：
	ClassLoader, SecurityManager.checkPermission(java.security.Permission), RuntimePermission

从文档中可看出，可能会有NULL的情况，不推荐此方法。


(4)ClassLoader.getSystemClassLoader().getResource("")
(5)ClassLoader.getSystemResource("")

(5)的实现其实还是通过(4)来现实的，都是从系统默认的ClassLoader获取当前的classpath根目录


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

从当前线程中获取classloader对象

getContextClassLoader
public ClassLoader getContextClassLoader()返回该线程的上下文 ClassLoader。上下文 ClassLoader 由线程创建者提供，供运行于该线程中的代码在加载类和资源时使用。如果未设定，则默认为父线程的 ClassLoader 上下文。原始线程的上下文 ClassLoader 通常设定为用于加载应用程序的类加载器。 
首先，如果有安全管理器，并且调用者的类加载器不是 null，也不同于其上下文类加载器正在被请求的线程上下文类加载器的祖先，则通过 RuntimePermission("getClassLoader") 权限调用该安全管理器的 checkPermission 方法，查看是否可以获取上下文 ClassLoader。 


返回：
	该线程的上下文 ClassLoader
从以下版本开始： 
	1.2 
另请参见：
	setContextClassLoader(java.lang.ClassLoader), SecurityManager.checkPermission(java.security.Permission), RuntimePermission

以上六种方法，其实都可以解决问题，并在某些方面不是最好的方式，如果不考虑特殊情况的话，推荐使用的（1）、（2）或（6）。

以下是mybatis源码中用来读配置文件的工具类，很不错，各种classloader都考虑了，很好用，贴出来参考下:

package com.talkweb.spe.config;

import java.io.InputStream;
import java.net.URL;

/**
 * A class to wrap access to multiple class loaders making them work as one
 */
public class ClassLoaderWrapper {

  ClassLoader defaultClassLoader;
  ClassLoader systemClassLoader;

  ClassLoaderWrapper() {
    try {
      systemClassLoader = ClassLoader.getSystemClassLoader();
    } catch (SecurityException ignored) {
      // AccessControlException on Google App Engine   
    }
  }
  
  /**
   * Get a resource as a URL using the current class path
   *
   * @param resource - the resource to locate
   * @return the resource or null
   */
  public URL getResourceAsURL(String resource) {
    return getResourceAsURL(resource, getClassLoaders(null));
  }

  /**
   * Get a resource from the classpath, starting with a specific class loader
   *
   * @param resource    - the resource to find
   * @param classLoader - the first classloader to try
   * @return the stream or null
   */
  public URL getResourceAsURL(String resource, ClassLoader classLoader) {
    return getResourceAsURL(resource, getClassLoaders(classLoader));
  }

  /**
   * Get a resource from the classpath
   *
   * @param resource - the resource to find
   * @return the stream or null
   */
  public InputStream getResourceAsStream(String resource) {
    return getResourceAsStream(resource, getClassLoaders(null));
  }

  /**
   * Get a resource from the classpath, starting with a specific class loader
   *
   * @param resource    - the resource to find
   * @param classLoader - the first class loader to try
   * @return the stream or null
   */
  public InputStream getResourceAsStream(String resource, ClassLoader classLoader) {
    return getResourceAsStream(resource, getClassLoaders(classLoader));
  }

  /**
   * Find a class on the classpath (or die trying)
   *
   * @param name - the class to look for
   * @return - the class
   * @throws ClassNotFoundException Duh.
   */
  public Class<?> classForName(String name) throws ClassNotFoundException {
    return classForName(name, getClassLoaders(null));
  }

  /**
   * Find a class on the classpath, starting with a specific classloader (or die trying)
   *
   * @param name        - the class to look for
   * @param classLoader - the first classloader to try
   * @return - the class
   * @throws ClassNotFoundException Duh.
   */
  public Class<?> classForName(String name, ClassLoader classLoader) throws ClassNotFoundException {
    return classForName(name, getClassLoaders(classLoader));
  }

  /**
   * Try to get a resource from a group of classloaders
   *
   * @param resource    - the resource to get
   * @param classLoader - the classloaders to examine
   * @return the resource or null
   */
  InputStream getResourceAsStream(String resource, ClassLoader[] classLoader) {
    for (ClassLoader cl : classLoader) {
      if (null != cl) {

        // try to find the resource as passed
        InputStream returnValue = cl.getResourceAsStream(resource);

        // now, some class loaders want this leading "/", so we'll add it and try again if we didn't find the resource
        if (null == returnValue) returnValue = cl.getResourceAsStream("/" + resource);

        if (null != returnValue) return returnValue;
      }
    }
    return null;
  }

  /**
   * Get a resource as a URL using the current class path
   *
   * @param resource    - the resource to locate
   * @param classLoader - the class loaders to examine
   * @return the resource or null
   */
  URL getResourceAsURL(String resource, ClassLoader[] classLoader) {

    URL url;

    for (ClassLoader cl : classLoader) {

      if (null != cl) {

        // look for the resource as passed in...
        url = cl.getResource(resource);

        // ...but some class loaders want this leading "/", so we'll add it
        // and try again if we didn't find the resource
        if (null == url) url = cl.getResource("/" + resource);

        // "It's always in the last place I look for it!"
        // ... because only an idiot would keep looking for it after finding it, so stop looking already.
        if (null != url) return url;

      }

    }

    // didn't find it anywhere.
    return null;

  }

  /**
   * Attempt to load a class from a group of classloaders
   *
   * @param name        - the class to load
   * @param classLoader - the group of classloaders to examine
   * @return the class
   * @throws ClassNotFoundException - Remember the wisdom of Judge Smails: Well, the world needs ditch diggers, too.
   */
  Class<?> classForName(String name, ClassLoader[] classLoader) throws ClassNotFoundException {

    for (ClassLoader cl : classLoader) {

      if (null != cl) {

        try {

          Class<?> c = Class.forName(name, true, cl);

          if (null != c) return c;

        } catch (ClassNotFoundException e) {
          // we'll ignore this until all classloaders fail to locate the class
        }

      }

    }

    throw new ClassNotFoundException("Cannot find class: " + name);

  }

  ClassLoader[] getClassLoaders(ClassLoader classLoader) {
    return new ClassLoader[]{
        classLoader, 
        defaultClassLoader, 
        Thread.currentThread().getContextClassLoader(), 
        getClass().getClassLoader(), 
        systemClassLoader}; 
  }

}


package com.talkweb.spe.config;

import java.io.*;
import java.net.URL;
import java.net.URLConnection;
import java.nio.charset.Charset;
import java.util.Properties;

/**
 * A class to simplify access to resources through the classloader.
 */
public class Resources {

  private static ClassLoaderWrapper classLoaderWrapper = new ClassLoaderWrapper();

  /**
   * Charset to use when calling getResourceAsReader.
   * null means use the system default.
   */
  private static Charset charset;

  Resources() {
  }

  /**
   * Returns the default classloader (may be null).
   *
   * @return The default classloader
   */
  public static ClassLoader getDefaultClassLoader() {
    return classLoaderWrapper.defaultClassLoader;
  }

  /**
   * Sets the default classloader
   *
   * @param defaultClassLoader - the new default ClassLoader
   */
  public static void setDefaultClassLoader(ClassLoader defaultClassLoader) {
    classLoaderWrapper.defaultClassLoader = defaultClassLoader;
  }

  /**
   * Returns the URL of the resource on the classpath
   *
   * @param resource The resource to find
   * @return The resource
   * @throws java.io.IOException If the resource cannot be found or read
   */
  public static URL getResourceURL(String resource) throws IOException {
    return classLoaderWrapper.getResourceAsURL(resource);
  }

  /**
   * Returns the URL of the resource on the classpath
   *
   * @param loader   The classloader used to fetch the resource
   * @param resource The resource to find
   * @return The resource
   * @throws java.io.IOException If the resource cannot be found or read
   */
  public static URL getResourceURL(ClassLoader loader, String resource) throws IOException {
    URL url = classLoaderWrapper.getResourceAsURL(resource, loader);
    if (url == null) throw new IOException("Could not find resource " + resource);
    return url;
  }

  /**
   * Returns a resource on the classpath as a Stream object
   *
   * @param resource The resource to find
   * @return The resource
   * @throws java.io.IOException If the resource cannot be found or read
   */
  public static InputStream getResourceAsStream(String resource) throws IOException {
    return getResourceAsStream(null, resource);
  }

  /**
   * Returns a resource on the classpath as a Stream object
   *
   * @param loader   The classloader used to fetch the resource
   * @param resource The resource to find
   * @return The resource
   * @throws java.io.IOException If the resource cannot be found or read
   */
  public static InputStream getResourceAsStream(ClassLoader loader, String resource) throws IOException {
    InputStream in = classLoaderWrapper.getResourceAsStream(resource, loader);
    if (in == null) throw new IOException("Could not find resource " + resource);
    return in;
  }

  /**
   * Returns a resource on the classpath as a Properties object
   *
   * @param resource The resource to find
   * @return The resource
   * @throws java.io.IOException If the resource cannot be found or read
   */
  public static Properties getResourceAsProperties(String resource) throws IOException {
    Properties props = new Properties();
    InputStream in = getResourceAsStream(resource);
    props.load(in);
    in.close();
    return props;
  }

  /**
   * Returns a resource on the classpath as a Properties object
   *
   * @param loader   The classloader used to fetch the resource
   * @param resource The resource to find
   * @return The resource
   * @throws java.io.IOException If the resource cannot be found or read
   */
  public static Properties getResourceAsProperties(ClassLoader loader, String resource) throws IOException {
    Properties props = new Properties();
    InputStream in = getResourceAsStream(loader, resource);
    props.load(in);
    in.close();
    return props;
  }

  /**
   * Returns a resource on the classpath as a Reader object
   *
   * @param resource The resource to find
   * @return The resource
   * @throws java.io.IOException If the resource cannot be found or read
   */
  public static Reader getResourceAsReader(String resource) throws IOException {
    Reader reader;
    if (charset == null) {
      reader = new InputStreamReader(getResourceAsStream(resource));
    } else {
      reader = new InputStreamReader(getResourceAsStream(resource), charset);
    }
    return reader;
  }

  /**
   * Returns a resource on the classpath as a Reader object
   *
   * @param loader   The classloader used to fetch the resource
   * @param resource The resource to find
   * @return The resource
   * @throws java.io.IOException If the resource cannot be found or read
   */
  public static Reader getResourceAsReader(ClassLoader loader, String resource) throws IOException {
    Reader reader;
    if (charset == null) {
      reader = new InputStreamReader(getResourceAsStream(loader, resource));
    } else {
      reader = new InputStreamReader(getResourceAsStream(loader, resource), charset);
    }
    return reader;
  }

  /**
   * Returns a resource on the classpath as a File object
   *
   * @param resource The resource to find
   * @return The resource
   * @throws java.io.IOException If the resource cannot be found or read
   */
  public static File getResourceAsFile(String resource) throws IOException {
    return new File(getResourceURL(resource).getFile());
  }

  /**
   * Returns a resource on the classpath as a File object
   *
   * @param loader   - the classloader used to fetch the resource
   * @param resource - the resource to find
   * @return The resource
   * @throws java.io.IOException If the resource cannot be found or read
   */
  public static File getResourceAsFile(ClassLoader loader, String resource) throws IOException {
    return new File(getResourceURL(loader, resource).getFile());
  }

  /**
   * Gets a URL as an input stream
   *
   * @param urlString - the URL to get
   * @return An input stream with the data from the URL
   * @throws java.io.IOException If the resource cannot be found or read
   */
  public static InputStream getUrlAsStream(String urlString) throws IOException {
    URL url = new URL(urlString);
    URLConnection conn = url.openConnection();
    return conn.getInputStream();
  }

  /**
   * Gets a URL as a Reader
   *
   * @param urlString - the URL to get
   * @return A Reader with the data from the URL
   * @throws java.io.IOException If the resource cannot be found or read
   */
  public static Reader getUrlAsReader(String urlString) throws IOException {
    Reader reader;
    if (charset == null) {
      reader = new InputStreamReader(getUrlAsStream(urlString));
    } else {
      reader = new InputStreamReader(getUrlAsStream(urlString), charset);
    }
    return reader;
  }

  /**
   * Gets a URL as a Properties object
   *
   * @param urlString - the URL to get
   * @return A Properties object with the data from the URL
   * @throws java.io.IOException If the resource cannot be found or read
   */
  public static Properties getUrlAsProperties(String urlString) throws IOException {
    Properties props = new Properties();
    InputStream in = getUrlAsStream(urlString);
    props.load(in);
    in.close();
    return props;
  }

  /**
   * Loads a class
   *
   * @param className - the class to fetch
   * @return The loaded class
   * @throws ClassNotFoundException If the class cannot be found (duh!)
   */
  public static Class<?> classForName(String className) throws ClassNotFoundException {
    return classLoaderWrapper.classForName(className);
  }

  public static Charset getCharset() {
    return charset;
  }

  public static void setCharset(Charset charset) {
    Resources.charset = charset;
  }

}

读取资源文件，直接使用Resources即可，简单好用！


二.web路径

getServletContext().getRealPath("/") 
获取web项目的根路径 就能大解决问题了


以后如有发现问题再补充，关于classloader的地方还有些不理解，以后再补充。


hezhong002
关注
专栏目录
Java文件路径（getResource）
03-27 4万+
getResourceAsStream ()返回的是inputstream getResource()返回:URL Class.getResource("")    返回的是当前Class这个类所在包开始的为置 Class.getResource("/") 返回的是classpath的位置 getClassLoader().getResource("")  返回的是classpath的位置
各种获取Resource资源的方法
xiao_jun_0820的专栏
12-17 7473
import java.io.File; import java.io.IOException; import java.io.InputStream; import java.io.InputStreamReader; import java.io.Reader; import java.net.URL; import java.net.URLConnection; import java.ni
Java 安全模型介绍
shan_yuge的专栏
01-09 640
作为一种诞生于互联网兴起时代的语言，Java 从一开始就带有安全上的考虑，如何保证通过互联网下载到本地的 Java 程序是安全的，如何对 Java 程序访问本地资源权限进行有限授权，这些安全角度的考虑一开始就影响到 Java 语言的设计与实现。可以说 Java 在这些方面的探索与经验，对后来的一些语言与产品都带来了积极影响。 本篇文章中将介绍 Java 中安全模型，以及如何利用安全访问控制机
Tomcat启动非常慢，报打开$JAVA_PATH/jre/lib/security/java.security这个文件，找到下面的内容： securerandom.source=file:/dev
ltyzsd的博客
01-22 5053
突然发现tomcat启动非常非常慢，看了一下日志，报WARNING: Creation of SecureRandom instance for session ID generation using [SHA1PRNG] took [168,417] milliseconds. 网上搜索了一下，发现以下这样操作就好了 打开$JAVA_PATH/jre/lib/security/java.
Java安全管理器SecurityManager
热门推荐
到黄昏，点点滴滴
11-20 3万+
原文出处：http://sweepingmonkgo.iteye.com/blog/2115800 安全管理器是一个允许应用程序实现安全策略的类。它允许应用程序在执行一个可能不安全或敏感的操作前确定该操作是什么，以及是否是在允许执行该操作的安全上下文中执行它。应用程序可以允许或不允许该操作。 SecurityManager 类包含了很多名称以单词 check 开头的方法。Java 
java文件路径的写法相关
SE_LIN的博客
12-18 2575
java文件路径的写法 笔记
java文件路径转义_Windows文件路径转换为java中可识别的文件路径的转义方法，（另附转义多种格式）...
weixin_42139429的博客
02-16 1436
ps:欢迎加qq好友：2318645572,交流学习一：路径转化Windows中的文件路径格式为D:\eclipse\apache-tomcat-7.0.67\wtpwebapps\...Java中的文件路径格式为D:/eclipse/apache-tomcat-7.0.67/wtpwebapps/...如果直接用windows的路径，用流写入的时候会抛出异常在java中使用前者则会报错，所以...
关于Java文件路径问题
03-17
这篇博客文章“关于Java文件路径问题”可能探讨了Java中处理文件路径的常见挑战和解决方案。 在Java中，文件路径可以是绝对路径或相对路径。绝对路径是从根目录开始的完整路径，它指明了文件的确切位置。相对路径则...
java 文件路径小工具
09-06
java 文件路径小工具 谁用谁知道 管理windows下的目录文件
Java文件路径获取方式：使用Java编程获取文件路径
PixelLogic的博客
10-04 781
在Java编程中，我们经常需要获取文件的路径，以便对文件进行读取、写入或其他操作。下面将介绍几种常用的Java文件路径获取方式，并附上相应的源代码示例。以上是几种常用的Java文件路径获取方式。根据具体的需求和场景，选择适合的方式来获取文件路径。希望这些示例代码能帮助到你！
Java文件路径获取完全解析
"Java文件路径获取方法的总结，包括使用`getResourceAsStream()`和`getClassLoader().getResourceAsStream()`的差异以及如何正确处理路径" 在Java编程中，获取文件路径是一项常见的任务，特别是在处理资源文件或者...
eclipse 引入java文件路径问题_java - Eclipse构建路径嵌套错误
weixin_27310417的博客
02-24 1523
java - Eclipse构建路径嵌套错误我正在为我的班级开发一个简单的JSP / Servlet / Tomcat webapp。 教授要求我们使用与默认动态Web项目结构略有不同的文件夹结构。 他没有使用webcontent文件夹，而是希望我们在src / main / java和src / main / webapp下的所有源代码。当我运行应用程序时，我的欢迎文件显示正常，但当我尝试访...
Java加解密security目录-策略文件 local_policy.jar
u014137486的专栏
01-21 5503
Java AES、DES加解密时可能会因为密钥长度限制，不能使用大于128位的密钥，此问题与local_policy.jar有关。
[自用，更新自day5]瑞吉外卖代码及笔记
最新发布
lapiii的博客
11-01 455
当使用ThreadLocal维护变量时，ThreadLocal为每个使用该变量的线程提供独立的变量副本，所以每一个线程都可以独立地改变自己的副本，而不会影响其它线程所对应的副本。Mybatis Plus公共字段自动填充，也就是在插入或者更新的时候为指定字段赋予指定的值，使用它的好处就是可以统一对这些字段进行处理，避免了重复代码。因为在分页查询的Dish的records(菜品记录中)，只有这个菜品所属的categoryId，但是我们需要分页的时候展示的是菜品名字。
基于vue框架的的汇生活家居商城的设计与实现bdjlq（程序+源码+数据库+调试部署+开发环境）系统界面在最后面。
h2345678的博客
10-29 1309
项目功能：商品分类,商品信息,用户。
JAVA 插入 JSON 对象到 PostgreSQL
qq_52143611的博客
10-30 790
在现代软件开发中，由于 JSON 数据的轻量和通用性，处理 JSON 数据已经变得无处不在。PostgreSQL凭借其对 JSON 的强大支持，为存储和查询 JSON 数据提供了出色的平台。为了将JSON数据保存到PostgreSQL数据库中，我们可以将JSON数据转换为PostgreSQL的JSONB类型数据，然后将其存储在数据库中。在Java中，我们可以使用JDBC或者基于ORM框架的方式来实现这一功能。
（1）Java 编程基础概览：数据类型、常量、变量、标识符与运算符
码界领航的Cherry Yang的博客
10-28 1059
8 位，占1个字节，有符号的，范围 -128（-2^7）至 127（2^7-1）。32 位，占4个字节，范围 -2,147,483,648（-2^31）至 2,147,483,647（2^31 - 1）。Java 提供了六种数字类型，其中四个为整数类型，两个为浮点类型，还有字符类型，以及布尔型。16 位，占2个字节，范围 -32768（-2^15）至 32767（2^15 - 1）64 位，占8个字节，范围 -2^63 至 2^63 - 1。16 位 Unicode 字符，占 2 个字节。
SpringSession源码分析
lkr_lkr的博客
11-01 159
默认对常规Session的理解和使用，如何使用Set-Cookie。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值