`
liuxing87327
  • 浏览: 82799 次
  • 性别: Icon_minigender_1
  • 来自: 上海
社区版块
存档分类
最新评论

java获取当前类的绝对路径

    博客分类:
  • java
阅读更多

1.获得当前文件路径


常用:
(1).Test.class.getResource("")
得到的是当前类FileTest.class文件的URI目录。不包括自己!
(2).Test.class.getResource("/")
得到的是当前的classpath的绝对URI路径。
(3).Thread.currentThread().getContextClassLoader().getResource("")
得到的也是当前ClassPath的绝对URI路径。
(4).Test.class.getClassLoader().getResource("")
得到的也是当前ClassPath的绝对URI路径。
(5).ClassLoader.getSystemResource("")
得到的也是当前ClassPath的绝对URI路径。
尽量不要使用相对于System.getProperty("user.dir")当前用户目录的相对路径,后面可以看出得出结果五花八门。
(6) new File("").getAbsolutePath()也可用。
       
2.Web服务器


(1).Tomcat
在类中输出System.getProperty("user.dir");显示的是%Tomcat_Home%/bin
(2).Resin
不是你的JSP放的相对路径,是JSP引擎执行这个JSP编译成SERVLET
的路径为根.比如用新建文件法测试File f = new File("a.htm");
这个a.htm在resin的安装目录下
(3).如何读文件
使用ServletContext.getResourceAsStream()就可以
(4).获得文件真实路径
String   file_real_path=ServletContext.getRealPath("mypath/filename");  
不建议使用request.getRealPath("/");

3.文件操作的类,不建议使用,可以使用commons io类

 

import java.io.*;
import java.net.*;
import java.util.*;


/**
* 此类中封装一些常用的文件操作。
* 所有方法都是静态方法,不需要生成此类的实例,
* 为避免生成此类的实例,构造方法被申明为private类型的。
* @since   0.1
*/

public class FileUtil {
   /**
    * 私有构造方法,防止类的实例化,因为工具类不需要实例化。
    */
   private FileUtil() {

   }

   /**
    * 修改文件的最后访问时间。
    * 如果文件不存在则创建该文件。
    * <b>目前这个方法的行为方式还不稳定,主要是方法有些信息输出,这些信息输出是否保留还在考

虑中。</b>
    * @param file 需要修改最后访问时间的文件。
    * @since   0.1
    */
   public static void touch(File file) {
     long currentTime = System.currentTimeMillis();
     if (!file.exists()) {
       System.err.println("file not found:" + file.getName());
       System.err.println("Create a new file:" + file.getName());
       try {
         if (file.createNewFile()) {
         //   System.out.println("Succeeded!");
         }
         else {
         //   System.err.println("Create file failed!");
         }
       }
       catch (IOException e) {
       //   System.err.println("Create file failed!");
         e.printStackTrace();
       }
     }
     boolean result = file.setLastModified(currentTime);
     if (!result) {
     //   System.err.println("touch failed: " + file.getName());
     }
   }

   /**
    * 修改文件的最后访问时间。
    * 如果文件不存在则创建该文件。
    * <b>目前这个方法的行为方式还不稳定,主要是方法有些信息输出,这些信息输出是否保留还在考

虑中。</b>
    * @param fileName 需要修改最后访问时间的文件的文件名。
    * @since   0.1
    */
   public static void touch(String fileName) {
     File file = new File(fileName);
     touch(file);
   }

   /**
    * 修改文件的最后访问时间。
    * 如果文件不存在则创建该文件。
    * <b>目前这个方法的行为方式还不稳定,主要是方法有些信息输出,这些信息输出是否保留还在考

虑中。</b>
    * @param files 需要修改最后访问时间的文件数组。
    * @since   0.1
    */
   public static void touch(File[] files) {
     for (int i = 0; i < files.length; i++) {
       touch(files);
     }
   }

   /**
    * 修改文件的最后访问时间。
    * 如果文件不存在则创建该文件。
    * <b>目前这个方法的行为方式还不稳定,主要是方法有些信息输出,这些信息输出是否保留还在考

虑中。</b>
    * @param fileNames 需要修改最后访问时间的文件名数组。
    * @since   0.1
    */
   public static void touch(String[] fileNames) {
     File[] files = new File[fileNames.length];
     for (int i = 0; i < fileNames.length; i++) {
       files = new File(fileNames);
     }
     touch(files);
   }

   /**
    * 判断指定的文件是否存在。
    * @param fileName 要判断的文件的文件名
    * @return 存在时返回true,否则返回false。
    * @since   0.1
    */
   public static boolean isFileExist(String fileName) {
     return new File(fileName).isFile();
   }

   /**
    * 创建指定的目录。
    * 如果指定的目录的父目录不存在则创建其目录书上所有需要的父目录。
    * <b>注意:可能会在返回false的时候创建部分父目录。</b>
    * @param file 要创建的目录
    * @return 完全创建成功时返回true,否则返回false。
    * @since   0.1
    */
   public static boolean makeDirectory(File file) {
     File parent = file.getParentFile();
     if (parent != null) {
       return parent.mkdirs();
     }
     return false;
   }

   /**
    * 创建指定的目录。
    * 如果指定的目录的父目录不存在则创建其目录书上所有需要的父目录。
    * <b>注意:可能会在返回false的时候创建部分父目录。</b>
    * @param fileName 要创建的目录的目录名
    * @return 完全创建成功时返回true,否则返回false。
    * @since   0.1
    */
   public static boolean makeDirectory(String fileName) {
     File file = new File(fileName);
     return makeDirectory(file);
   }

   /**
    * 清空指定目录中的文件。
    * 这个方法将尽可能删除所有的文件,但是只要有一个文件没有被删除都会返回false。
    * 另外这个方法不会迭代删除,即不会删除子目录及其内容。
    * @param directory 要清空的目录
    * @return 目录下的所有文件都被成功删除时返回true,否则返回false.
    * @since   0.1
    */
   public static boolean emptyDirectory(File directory) {
     boolean result = false;
     File[] entries = directory.listFiles();
     for (int i = 0; i < entries.length; i++) {
       if (!entries.delete()) {
         result = false;
       }
     }
     return true;
   }

   /**
    * 清空指定目录中的文件。
    * 这个方法将尽可能删除所有的文件,但是只要有一个文件没有被删除都会返回false。
    * 另外这个方法不会迭代删除,即不会删除子目录及其内容。
    * @param directoryName 要清空的目录的目录名
    * @return 目录下的所有文件都被成功删除时返回true,否则返回false。
    * @since   0.1
    */
   public static boolean emptyDirectory(String directoryName) {
     File dir = new File(directoryName);
     return emptyDirectory(dir);
   }

   /**
    * 删除指定目录及其中的所有内容。
    * @param dirName 要删除的目录的目录名
    * @return 删除成功时返回true,否则返回false。
    * @since   0.1
    */
   public static boolean deleteDirectory(String dirName) {
     return deleteDirectory(new File(dirName));
   }

   /**
    * 删除指定目录及其中的所有内容。
    * @param dir 要删除的目录
    * @return 删除成功时返回true,否则返回false。
    * @since   0.1
    */
   public static boolean deleteDirectory(File dir) {
     if ( (dir == null) || !dir.isDirectory()) {
       throw new IllegalArgumentException("Argument " + dir +
                                          " is not a directory. ");
     }

     File[] entries = dir.listFiles();
     int sz = entries.length;

     for (int i = 0; i < sz; i++) {
       if (entries.isDirectory()) {
         if (!deleteDirectory(entries)) {
           return false;
         }
       }
       else {
         if (!entries.delete()) {
           return false;
         }
       }
     }

     if (!dir.delete()) {
       return false;
     }
     return true;
   }


   /**
    * 返回文件的URL地址。
    * @param file 文件
    * @return 文件对应的的URL地址
    * @throws MalformedURLException
    * @since   0.4
    * @deprecated 在实现的时候没有注意到File类本身带一个toURL方法将文件路径转换为URL。
    *              请使用File.toURL方法。
    */
   public static URL getURL(File file) throws MalformedURLException {
     String fileURL = "file:/" + file.getAbsolutePath();
     URL url = new URL(fileURL);
     return url;
   }

   /**
    * 从文件路径得到文件名。
    * @param filePath 文件的路径,可以是相对路径也可以是绝对路径
    * @return 对应的文件名
    * @since   0.4
    */
   public static String getFileName(String filePath) {
     File file = new File(filePath);
     return file.getName();
   }

   /**
    * 从文件名得到文件绝对路径。
    * @param fileName 文件名
    * @return 对应的文件路径
    * @since   0.4
    */
   public static String getFilePath(String fileName) {
     File file = new File(fileName);
     return file.getAbsolutePath();
   }

   /**
    * 将DOS/Windows格式的路径转换为UNIX/Linux格式的路径。
    * 其实就是将路径中的"\"全部换为"/",因为在某些情况下我们转换为这种方式比较方便,
    * 某中程度上说"/"比"\"更适合作为路径分隔符,而且DOS/Windows也将它当作路径分隔符。
    * @param filePath 转换前的路径
    * @return 转换后的路径
    * @since   0.4
    */
   public static String toUNIXpath(String filePath) {
     return filePath.replace('\\', '/');
   }

   /**
    * 从文件名得到UNIX风格的文件绝对路径。
    * @param fileName 文件名
    * @return 对应的UNIX风格的文件路径
    * @since   0.4
    * @see #toUNIXpath(String filePath) toUNIXpath
    */
   public static String getUNIXfilePath(String fileName) {
     File file = new File(fileName);
     return toUNIXpath(file.getAbsolutePath());
   }

   /**
    * 得到文件的类型。
    * 实际上就是得到文件名中最后一个“.”后面的部分。
    * @param fileName 文件名
    * @return 文件名中的类型部分
    * @since   0.5
    */
   public static String getTypePart(String fileName) {
     int point = fileName.lastIndexOf('.');
     int length = fileName.length();
     if (point == -1 || point == length - 1) {
       return "";
     }
     else {
       return fileName.substring(point + 1, length);
     }
   }

   /**
    * 得到文件的类型。
    * 实际上就是得到文件名中最后一个“.”后面的部分。
    * @param file 文件
    * @return 文件名中的类型部分
    * @since   0.5
    */
   public static String getFileType(File file) {
     return getTypePart(file.getName());
   }

   /**
    * 得到文件的名字部分。
    * 实际上就是路径中的最后一个路径分隔符后的部分。
    * @param fileName 文件名
    * @return 文件名中的名字部分
    * @since   0.5
    */
   public static String getNamePart(String fileName) {
     int point = getPathLsatIndex(fileName);
     int length = fileName.length();
     if (point == -1) {
       return fileName;
     }
     else if (point == length - 1) {
       int secondPoint = getPathLsatIndex(fileName, point - 1);
       if (secondPoint == -1) {
         if (length == 1) {
           return fileName;
         }
         else {
           return fileName.substring(0, point);
         }
       }
       else {
         return fileName.substring(secondPoint + 1, point);
       }
     }
     else {
       return fileName.substring(point + 1);
     }
   }

   /**
    * 得到文件名中的父路径部分。
    * 对两种路径分隔符都有效。
    * 不存在时返回""。
    * 如果文件名是以路径分隔符结尾的则不考虑该分隔符,例如"/path/"返回""。
    * @param fileName 文件名
    * @return 父路径,不存在或者已经是父目录时返回""
    * @since   0.5
    */
   public static String getPathPart(String fileName) {
     int point = getPathLsatIndex(fileName);
     int length = fileName.length();
     if (point == -1) {
       return "";
     }
     else if (point == length - 1) {
       int secondPoint = getPathLsatIndex(fileName, point - 1);
       if (secondPoint == -1) {
         return "";
       }
       else {
         return fileName.substring(0, secondPoint);
       }
     }
     else {
       return fileName.substring(0, point);
     }
   }

   /**
    * 得到路径分隔符在文件路径中首次出现的位置。
    * 对于DOS或者UNIX风格的分隔符都可以。
    * @param fileName 文件路径
    * @return 路径分隔符在路径中首次出现的位置,没有出现时返回-1。
    * @since   0.5
    */
   public static int getPathIndex(String fileName) {
     int point = fileName.indexOf('/');
     if (point == -1) {
       point = fileName.indexOf('\\');
     }
     return point;
   }

   /**
    * 得到路径分隔符在文件路径中指定位置后首次出现的位置。
    * 对于DOS或者UNIX风格的分隔符都可以。
    * @param fileName 文件路径
    * @param fromIndex 开始查找的位置
    * @return 路径分隔符在路径中指定位置后首次出现的位置,没有出现时返回-1。
    * @since   0.5
    */
   public static int getPathIndex(String fileName, int fromIndex) {
     int point = fileName.indexOf('/', fromIndex);
     if (point == -1) {
       point = fileName.indexOf('\\', fromIndex);
     }
     return point;
   }

   /**
    * 得到路径分隔符在文件路径中最后出现的位置。
    * 对于DOS或者UNIX风格的分隔符都可以。
    * @param fileName 文件路径
    * @return 路径分隔符在路径中最后出现的位置,没有出现时返回-1。
    * @since   0.5
    */
   public static int getPathLsatIndex(String fileName) {
     int point = fileName.lastIndexOf('/');
     if (point == -1) {
       point = fileName.lastIndexOf('\\');
     }
     return point;
   }

   /**
    * 得到路径分隔符在文件路径中指定位置前最后出现的位置。
    * 对于DOS或者UNIX风格的分隔符都可以。
    * @param fileName 文件路径
    * @param fromIndex 开始查找的位置
    * @return 路径分隔符在路径中指定位置前最后出现的位置,没有出现时返回-1。
    * @since   0.5
    */
   public static int getPathLsatIndex(String fileName, int fromIndex) {
     int point = fileName.lastIndexOf('/', fromIndex);
     if (point == -1) {
       point = fileName.lastIndexOf('\\', fromIndex);
     }
     return point;
   }

   /**
    * 将文件名中的类型部分去掉。
    * @param filename 文件名
    * @return 去掉类型部分的结果
    * @since   0.5
    */
   public static String trimType(String filename) {
     int index = filename.lastIndexOf(".");
     if (index != -1) {
       return filename.substring(0, index);
     }
     else {
       return filename;
     }
   }
   /**
    * 得到相对路径。
    * 文件名不是目录名的子节点时返回文件名。
    * @param pathName 目录名
    * @param fileName 文件名
    * @return 得到文件名相对于目录名的相对路径,目录下不存在该文件时返回文件名
    * @since   0.5
    */
   public static String getSubpath(String pathName,String fileName) {
     int index = fileName.indexOf(pathName);
     if (index != -1) {
       return fileName.substring(index + pathName.length() + 1);
     }
     else {
       return fileName;
     }
   }

}

 

 

 

4.遗留问题

目前new FileInputStream()只会使用绝对路径,相对没用过,因为要相对于web服务器地址,比较麻烦

还不如写个配置文件来的快哪

 

5.按Java文件类型分类读取配置文件

 

配 置文件是应用系统中不可缺少的,可以增加程序的灵活性。java.util.Properties是从jdk1.2就有的类,一直到现在都支持load ()方法,jdk1.4以后save(output,string) ->store(output,string)。如果只是单纯的读,根本不存在烦恼的问题。web层可以通过 Thread.currentThread().getContextClassLoader().
getResourceAsStream("xx.properties") 获取;Application可以通过new FileInputStream("xx.properties");直接在classes一级获取。关键是有时我们需要通过web修改配置文件,我们不 能将路径写死了。经过测试觉得有以下心得:

 

1.servlet中读写。如果运用Struts 或者Servlet可以直接在初始化参数中配置,调用时根据servletcontext的getRealPath("/")获取真实路径,再根据 String file = this.servlet.getInitParameter("abc");获取相对的WEB-INF的相对路径。
例:

InputStream input = Thread.currentThread().getContextClassLoader().
getResourceAsStream("abc.properties");
Properties prop = new Properties();
prop.load(input);
input.close();
OutputStream out = new FileOutputStream(path);
prop.setProperty("abc", “test");
prop.store(out, “–test–");
out.close();

 

 

2.直接在jsp中操作,通过jsp内置对象获取可操作的绝对地址。
例:

// jsp页面
String path = pageContext.getServletContext().getRealPath("/");
String realPath = path+"/WEB-INF/classes/abc.properties";

//java 程序
InputStream in = getClass().getClassLoader().getResourceAsStream("abc.properties"); // abc.properties放在webroot/WEB-INF/classes/目录下
prop.load(in);
in.close();

OutputStream out = new FileOutputStream(path); // path为通过页面传入的路径
prop.setProperty("abc", “abcccccc");
prop.store(out, “–test–");
out.close();

 

 

3.只通过Java程序操作资源文件


 

InputStream in = new FileInputStream("abc.properties"); // 放在classes同级

OutputStream out = new FileOutputStream("abc.properties");

 

 

转载自:http://blog.csdn.net/dagouaofei/archive/2010/05/13/5588008.aspx

分享到:
评论

相关推荐

    java 获取当前路径

    Java 获取当前路径 Java 获取当前路径是 Java 编程中一个常见的需求,下面我们将讨论如何在 Java 中获取当前路径。 方法一:使用 System.getProperty() 函数 使用 System.getProperty() 函数可以获取当前路径,该...

    普通java类获取绝对路径

    6. **阅读相关文档**:压缩包中的`Java类中获得相对路径和绝对路径.txt`和`Java普通类中如何获取工程真实路径?.txt`文档可能包含了更具体的实现细节,建议仔细阅读以获取更多信息。 理解这些知识点后,开发者就能...

    JAVA获取各种路径总结

    1. **获取当前应用的相对路径与绝对路径** - **根目录所对应的绝对路径** - 方法:`request.getRequestURI()` - `request.getRequestURI()` 返回客户端请求的资源的相对路径(相对于当前上下文)。 - **文件的...

    java项目中获取路径详解

    在 Java 项目中,获取绝对路径可以使用 `HttpServletRequest` 对象的 `getRealPath()` 方法。在 Web 项目中,可以使用 `request.getRealPath("")` 获取绝对路径。 ClassPath 路径 ClassPath 路径是 Java 项目中的...

    windows linux 下,获取java项目绝对路径的方法

    windows linux 下,获取java项目绝对路径的方法,struts2设置了struts.multipart.saveDir后会在根目录建立文件夹,这样会涉及linux下的权限问题

    java绝对路径和相对路径

    ### Java中的绝对路径与相对路径 在Java编程中,路径管理是进行文件操作的重要组成部分,尤其是在Web应用开发中。本文将详细介绍如何在Java中获取不同类型的路径,包括Web服务器下的文件路径、本地路径以及相对路径...

    java中相对路径与绝对路径的问题

    例如,我们可以使用 `FileTest.class.getResource("")` 来获取当前类的相对路径,使用 `FileTest.class.getResource("/")` 来获取当前类的绝对路径。 获得执行类的当前路径 在 Java 编程中,我们可以使用 `System....

    JAVA中获取各种路径

    #### (5) 获取页面的父目录绝对路径: 通过组合使用`application.getRealPath()`和`new File().getParent()`可以得到文件的父目录绝对路径,例如`D:\resin\webapps\TEST`。 ### 2. 类路径的获取 #### (1) 获取类...

    Java相对路径绝对路径总结

    #### 三、JSP/Servlet中获得当前应用的相对路径和绝对路径 ##### 3.1 JSP中获得当前应用的相对路径和绝对路径 - **根目录所对应的绝对路径**: 可以通过`request.getRequestURI()`获取。 - **文件的绝对路径**: ...

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

    在Java Web开发中,理解和掌握相对路径与绝对路径的运用是至关重要的,因为这直接影响到资源定位、页面跳转以及文件读写等操作的正确性。以下是对Java Web中相对路径与绝对路径问题的深入总结: ### 一、路径概念与...

    java项目相对路径与绝对路径问题分析

    而像`D:/java/eclipse32/workspace/jbpmtest3/bin/aaa.b`则是本地系统的绝对路径,同样是表示文件`aaa.b`的完整路径,但格式不同。 相对路径则相对抽象,它是相对于某个已知起点(基路径)的路径。在Java项目中,有...

    在Java程序中获取当前运行程序的路径

    这将返回类文件在类路径中的绝对路径。 其次,`java.lang.Runtime`类提供了执行操作系统命令的方法,例如`exec`,通过执行特定的系统命令,可以获取到程序的当前工作目录。例如: ```java Runtime.getRuntime()....

    JAVA获取项目路径.doc

    ### JAVA获取项目路径 在Java开发中,获取项目的路径是一个非常常见的需求,尤其是在处理文件读写、资源定位等场景时尤为重要。本文将详细介绍如何通过不同的方法来获取项目的各种路径,并结合示例代码进行说明。 ...

    java类动态获取相对路径

    // 获取绝对路径 String relativePath = file.getPath(); // 获取相对路径,这里可能需要根据实际基础路径做处理 ``` `getPath()`方法返回的是相对于JAR文件或类路径的路径,可能并不是我们想要的类的相对路径。...

    Java开发绝对和相对路径问题

    3. JSP/Servlet 中获得当前应用的相对路径和绝对路径 3.1 JSP 中获得当前应用的相对路径和绝对路径 可以使用 request.getRequestURI() 获取当前应用的相对路径,使用 application.getRealPath(request....

    java中File的相对路径与绝对路径总结

    ### Java中File的相对路径与绝对路径总结 在Java Web开发过程中,经常需要处理文件的读写操作,尤其是在运行时获取配置文件、动态加载对象等情况。对于这些需求,理解和掌握文件的相对路径与绝对路径至关重要。 ##...

    绝对路径和相对路径

    这种方法适用于在独立的Java类中获取文件的绝对路径。 总之,无论是开发Web应用还是编写独立的Java程序,理解并合理使用绝对路径和相对路径都是非常重要的。这不仅有助于代码的可维护性和可移植性,还能有效避免因...

    Java获取Tomcat下war包部署的Web工程根目录路径的方法

    开发web工程时经常要获取工程的根目录,自己用Java实现的获取Tomcat下war包部署的Web工程根目录路径的方法,主要利用web工程默认的目录结构,此外也可以指定工程名称获取工程目录的绝对路径

    java获取路径的各种方法

    本文将详细介绍Java中获取路径的几种方法,以及相对路径和绝对路径的基本概念。 首先,理解绝对路径和相对路径的概念至关重要。绝对路径是文件或目录在硬盘上的完整路径,无论起点在哪里都能准确地指向目标。例如,...

Global site tag (gtag.js) - Google Analytics