【转】java路径详解

2010-08-03 16:48 136人阅读 评论(1) 收藏 举报

view plaincopy to clipboardprint?
  1. 1.如何获得当前文件路径  
  2. 常用：  
  3. (1).Test.class.getResource("")  
  4. 得到的是当前类FileTest.class文件的URI目录。不包括自己！  
  5. (2).Test.class.getResource("/")  
  6. 得到的是当前的classpath的绝对URI路径。  
  7. (3).Thread.currentThread().getContextClassLoader().getResource("")  
  8. 得到的也是当前ClassPath的绝对URI路径。  
  9. (4).Test.class.getClassLoader().getResource("")  
  10. 得到的也是当前ClassPath的绝对URI路径。  
  11. (5).ClassLoader.getSystemResource("")  
  12. 得到的也是当前ClassPath的绝对URI路径。  
  13. 尽量不要使用相对于System.getProperty("user.dir")当前用户目录的相对路径，后面可以看出得出结  
  14.   
  15. 果五花八门。  
  16. (6) new File("").getAbsolutePath()也可用。  
  17.          
  18. 2.Web服务器  
  19. (1).Tomcat  
  20. 在类中输出System.getProperty("user.dir");显示的是%Tomcat_Home%/bin  
  21. (2).Resin  
  22. 不是你的JSP放的相对路径,是JSP引擎执行这个JSP编译成SERVLET  
  23. 的路径为根.比如用新建文件法测试File f = new File("a.htm");  
  24. 这个a.htm在resin的安装目录下   
  25. (3).如何读文件  
  26. 使用ServletContext.getResourceAsStream()就可以  
  27. (4).获得文件真实路径  
  28. String file_real_path=ServletContext.getRealPath("mypath/filename");   
  29. 不建议使用request.getRealPath("/");   
  30. 3.文件操作的类，不建议使用，可以使用commons io类   
  31. import java.io.*;  
  32. import java.net.*;  
  33. import java.util.*;  
  34.   
  35.   
  36. /** 
  37. * 此类中封装一些常用的文件操作。 
  38. * 所有方法都是静态方法，不需要生成此类的实例， 
  39. * 为避免生成此类的实例，构造方法被申明为private类型的。 
  40. * @since 0.1 
  41. */  
  42.   
  43. public class FileUtil {  
  44. /** 
  45.    * 私有构造方法，防止类的实例化，因为工具类不需要实例化。 
  46.    */  
  47. private FileUtil() {  
  48.   
  49. }  
  50.   
  51. /** 
  52.    * 修改文件的最后访问时间。 
  53.    * 如果文件不存在则创建该文件。 
  54.    * <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考 
  55.  
  56. 虑中。</b> 
  57.    * @param file 需要修改最后访问时间的文件。 
  58.    * @since 0.1 
  59.    */  
  60. public static void touch(File file) {  
  61.     long currentTime = System.currentTimeMillis();  
  62.     if (!file.exists()) {  
  63.       System.err.println("file not found:" + file.getName());  
  64.       System.err.println("Create a new file:" + file.getName());  
  65.       try {  
  66.         if (file.createNewFile()) {  
  67.         // System.out.println("Succeeded!");   
  68.         }  
  69.         else {  
  70.         // System.err.println("Create file failed!");   
  71.         }  
  72.       }  
  73.       catch (IOException e) {  
  74.       // System.err.println("Create file failed!");   
  75.         e.printStackTrace();  
  76.       }  
  77.     }  
  78.     boolean result = file.setLastModified(currentTime);  
  79.     if (!result) {  
  80.     // System.err.println("touch failed: " + file.getName());   
  81.     }  
  82. }  
  83.   
  84. /** 
  85.    * 修改文件的最后访问时间。 
  86.    * 如果文件不存在则创建该文件。 
  87.    * <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考 
  88.  
  89. 虑中。</b> 
  90.    * @param fileName 需要修改最后访问时间的文件的文件名。 
  91.    * @since 0.1 
  92.    */  
  93. public static void touch(String fileName) {  
  94.     File file = new File(fileName);  
  95.     touch(file);  
  96. }  
  97.   
  98. /** 
  99.    * 修改文件的最后访问时间。 
  100.    * 如果文件不存在则创建该文件。 
  101.    * <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考 
  102.  
  103. 虑中。</b> 
  104.    * @param files 需要修改最后访问时间的文件数组。 
  105.    * @since 0.1 
  106.    */  
  107. public static void touch(File[] files) {  
  108.     for (int i = 0; i < files.length; i++) {  
  109.       touch(files);  
  110.     }  
  111. }  
  112.   
  113. /** 
  114.    * 修改文件的最后访问时间。 
  115.    * 如果文件不存在则创建该文件。 
  116.    * <b>目前这个方法的行为方式还不稳定，主要是方法有些信息输出，这些信息输出是否保留还在考 
  117.  
  118. 虑中。</b> 
  119.    * @param fileNames 需要修改最后访问时间的文件名数组。 
  120.    * @since 0.1 
  121.    */  
  122. public static void touch(String[] fileNames) {  
  123.     File[] files = new File[fileNames.length];  
  124.     for (int i = 0; i < fileNames.length; i++) {  
  125.       files = new File(fileNames);  
  126.     }  
  127.     touch(files);  
  128. }  
  129.   
  130. /** 
  131.    * 判断指定的文件是否存在。 
  132.    * @param fileName 要判断的文件的文件名 
  133.    * @return 存在时返回true，否则返回false。 
  134.    * @since 0.1 
  135.    */  
  136. public static boolean isFileExist(String fileName) {  
  137.     return new File(fileName).isFile();  
  138. }  
  139.   
  140. /** 
  141.    * 创建指定的目录。 
  142.    * 如果指定的目录的父目录不存在则创建其目录书上所有需要的父目录。 
  143.    * <b>注意：可能会在返回false的时候创建部分父目录。</b> 
  144.    * @param file 要创建的目录 
  145.    * @return 完全创建成功时返回true，否则返回false。 
  146.    * @since 0.1 
  147.    */  
  148. public static boolean makeDirectory(File file) {  
  149.     File parent = file.getParentFile();  
  150.     if (parent != null) {  
  151.       return parent.mkdirs();  
  152.     }  
  153.     return false;  
  154. }  
  155.   
  156. /** 
  157.    * 创建指定的目录。 
  158.    * 如果指定的目录的父目录不存在则创建其目录书上所有需要的父目录。 
  159.    * <b>注意：可能会在返回false的时候创建部分父目录。</b> 
  160.    * @param fileName 要创建的目录的目录名 
  161.    * @return 完全创建成功时返回true，否则返回false。 
  162.    * @since 0.1 
  163.    */  
  164. public static boolean makeDirectory(String fileName) {  
  165.     File file = new File(fileName);  
  166.     return makeDirectory(file);  
  167. }  
  168.   
  169. /** 
  170.    * 清空指定目录中的文件。 
  171.    * 这个方法将尽可能删除所有的文件，但是只要有一个文件没有被删除都会返回false。 
  172.    * 另外这个方法不会迭代删除，即不会删除子目录及其内容。 
  173.    * @param directory 要清空的目录 
  174.    * @return 目录下的所有文件都被成功删除时返回true，否则返回false. 
  175.    * @since 0.1 
  176.    */  
  177. public static boolean emptyDirectory(File directory) {  
  178.     boolean result = false;  
  179.     File[] entries = directory.listFiles();  
  180.     for (int i = 0; i < entries.length; i++) {  
  181.       if (!entries.delete()) {  
  182.         result = false;  
  183.       }  
  184.     }  
  185.     return true;  
  186. }  
  187.   
  188. /** 
  189.    * 清空指定目录中的文件。 
  190.    * 这个方法将尽可能删除所有的文件，但是只要有一个文件没有被删除都会返回false。 
  191.    * 另外这个方法不会迭代删除，即不会删除子目录及其内容。 
  192.    * @param directoryName 要清空的目录的目录名 
  193.    * @return 目录下的所有文件都被成功删除时返回true，否则返回false。 
  194.    * @since 0.1 
  195.    */  
  196. public static boolean emptyDirectory(String directoryName) {  
  197.     File dir = new File(directoryName);  
  198.     return emptyDirectory(dir);  
  199. }  
  200.   
  201. /** 
  202.    * 删除指定目录及其中的所有内容。 
  203.    * @param dirName 要删除的目录的目录名 
  204.    * @return 删除成功时返回true，否则返回false。 
  205.    * @since 0.1 
  206.    */  
  207. public static boolean deleteDirectory(String dirName) {  
  208.     return deleteDirectory(new File(dirName));  
  209. }  
  210.   
  211. /** 
  212.    * 删除指定目录及其中的所有内容。 
  213.    * @param dir 要删除的目录 
  214.    * @return 删除成功时返回true，否则返回false。 
  215.    * @since 0.1 
  216.    */  
  217. public static boolean deleteDirectory(File dir) {  
  218.     if ( (dir == null) || !dir.isDirectory()) {  
  219.       throw new IllegalArgumentException("Argument " + dir +  
  220.                                          " is not a directory. ");  
  221.     }  
  222.   
  223.     File[] entries = dir.listFiles();  
  224.     int sz = entries.length;  
  225.   
  226.     for (int i = 0; i < sz; i++) {  
  227.       if (entries.isDirectory()) {  
  228.         if (!deleteDirectory(entries)) {  
  229.           return false;  
  230.         }  
  231.       }  
  232.       else {  
  233.         if (!entries.delete()) {  
  234.           return false;  
  235.         }  
  236.       }  
  237.     }  
  238.   
  239.     if (!dir.delete()) {  
  240.       return false;  
  241.     }  
  242.     return true;  
  243. }  
  244.   
  245.   
  246. /** 
  247.    * 返回文件的URL地址。 
  248.    * @param file 文件 
  249.    * @return 文件对应的的URL地址 
  250.    * @throws MalformedURLException 
  251.    * @since 0.4 
  252.    * @deprecated 在实现的时候没有注意到File类本身带一个toURL方法将文件路径转换为URL。 
  253.    *             请使用File.toURL方法。 
  254.    */  
  255. public static URL getURL(File file) throws MalformedURLException {  
  256.     String fileURL = "file:/" + file.getAbsolutePath();  
  257.     URL url = new URL(fileURL);  
  258.     return url;  
  259. }  
  260.   
  261. /** 
  262.    * 从文件路径得到文件名。 
  263.    * @param filePath 文件的路径，可以是相对路径也可以是绝对路径 
  264.    * @return 对应的文件名 
  265.    * @since 0.4 
  266.    */  
  267. public static String getFileName(String filePath) {  
  268.     File file = new File(filePath);  
  269.     return file.getName();  
  270. }  
  271.   
  272. /** 
  273.    * 从文件名得到文件绝对路径。 
  274.    * @param fileName 文件名 
  275.    * @return 对应的文件路径 
  276.    * @since 0.4 
  277.    */  
  278. public static String getFilePath(String fileName) {  
  279.     File file = new File(fileName);  
  280.     return file.getAbsolutePath();  
  281. }  
  282.   
  283. /** 
  284.    * 将DOS/Windows格式的路径转换为UNIX/Linux格式的路径。 
  285.    * 其实就是将路径中的"/"全部换为"/"，因为在某些情况下我们转换为这种方式比较方便， 
  286.    * 某中程度上说"/"比"/"更适合作为路径分隔符，而且DOS/Windows也将它当作路径分隔符。 
  287.    * @param filePath 转换前的路径 
  288.    * @return 转换后的路径 
  289.    * @since 0.4 
  290.    */  
  291. public static String toUNIXpath(String filePath) {  
  292.     return filePath.replace('//', '/');  
  293. }  
  294.   
  295. /** 
  296.    * 从文件名得到UNIX风格的文件绝对路径。 
  297.    * @param fileName 文件名 
  298.    * @return 对应的UNIX风格的文件路径 
  299.    * @since 0.4 
  300.    * @see #toUNIXpath(String filePath) toUNIXpath 
  301.    */  
  302. public static String getUNIXfilePath(String fileName) {  
  303.     File file = new File(fileName);  
  304.     return toUNIXpath(file.getAbsolutePath());  
  305. }  
  306.   
  307. /** 
  308.    * 得到文件的类型。 
  309.    * 实际上就是得到文件名中最后一个“.”后面的部分。 
  310.    * @param fileName 文件名 
  311.    * @return 文件名中的类型部分 
  312.    * @since 0.5 
  313.    */  
  314. public static String getTypePart(String fileName) {  
  315.     int point = fileName.lastIndexOf('.');  
  316.     int length = fileName.length();  
  317.     if (point == -1 || point == length - 1) {  
  318.       return "";  
  319.     }  
  320.     else {  
  321.       return fileName.substring(point + 1, length);  
  322.     }  
  323. }  
  324.   
  325. /** 
  326.    * 得到文件的类型。 
  327.    * 实际上就是得到文件名中最后一个“.”后面的部分。 
  328.    * @param file 文件 
  329.    * @return 文件名中的类型部分 
  330.    * @since 0.5 
  331.    */  
  332. public static String getFileType(File file) {  
  333.     return getTypePart(file.getName());  
  334. }  
  335.   
  336. /** 
  337.    * 得到文件的名字部分。 
  338.    * 实际上就是路径中的最后一个路径分隔符后的部分。 
  339.    * @param fileName 文件名 
  340.    * @return 文件名中的名字部分 
  341.    * @since 0.5 
  342.    */  
  343. public static String getNamePart(String fileName) {  
  344.     int point = getPathLsatIndex(fileName);  
  345.     int length = fileName.length();  
  346.     if (point == -1) {  
  347.       return fileName;  
  348.     }  
  349.     else if (point == length - 1) {  
  350.       int secondPoint = getPathLsatIndex(fileName, point - 1);  
  351.       if (secondPoint == -1) {  
  352.         if (length == 1) {  
  353.           return fileName;  
  354.         }  
  355.         else {  
  356.           return fileName.substring(0, point);  
  357.         }  
  358.       }  
  359.       else {  
  360.         return fileName.substring(secondPoint + 1, point);  
  361.       }  
  362.     }  
  363.     else {  
  364.       return fileName.substring(point + 1);  
  365.     }  
  366. }  
  367.   
  368. /** 
  369.    * 得到文件名中的父路径部分。 
  370.    * 对两种路径分隔符都有效。 
  371.    * 不存在时返回""。 
  372.    * 如果文件名是以路径分隔符结尾的则不考虑该分隔符，例如"/path/"返回""。 
  373.    * @param fileName 文件名 
  374.    * @return 父路径，不存在或者已经是父目录时返回"" 
  375.    * @since 0.5 
  376.    */  
  377. public static String getPathPart(String fileName) {  
  378.     int point = getPathLsatIndex(fileName);  
  379.     int length = fileName.length();  
  380.     if (point == -1) {  
  381.       return "";  
  382.     }  
  383.     else if (point == length - 1) {  
  384.       int secondPoint = getPathLsatIndex(fileName, point - 1);  
  385.       if (secondPoint == -1) {  
  386.         return "";  
  387.       }  
  388.       else {  
  389.         return fileName.substring(0, secondPoint);  
  390.       }  
  391.     }  
  392.     else {  
  393.       return fileName.substring(0, point);  
  394.     }  
  395. }  
  396.   
  397. /** 
  398.    * 得到路径分隔符在文件路径中首次出现的位置。 
  399.    * 对于DOS或者UNIX风格的分隔符都可以。 
  400.    * @param fileName 文件路径 
  401.    * @return 路径分隔符在路径中首次出现的位置，没有出现时返回-1。 
  402.    * @since 0.5 
  403.    */  
  404. public static int getPathIndex(String fileName) {  
  405.     int point = fileName.indexOf('/');  
  406.     if (point == -1) {  
  407.       point = fileName.indexOf('//');  
  408.     }  
  409.     return point;  
  410. }  
  411.   
  412. /** 
  413.    * 得到路径分隔符在文件路径中指定位置后首次出现的位置。 
  414.    * 对于DOS或者UNIX风格的分隔符都可以。 
  415.    * @param fileName 文件路径 
  416.    * @param fromIndex 开始查找的位置 
  417.    * @return 路径分隔符在路径中指定位置后首次出现的位置，没有出现时返回-1。 
  418.    * @since 0.5 
  419.    */  
  420. public static int getPathIndex(String fileName, int fromIndex) {  
  421.     int point = fileName.indexOf('/', fromIndex);  
  422.     if (point == -1) {  
  423.       point = fileName.indexOf('//', fromIndex);  
  424.     }  
  425.     return point;  
  426. }  
  427.   
  428. /** 
  429.    * 得到路径分隔符在文件路径中最后出现的位置。 
  430.    * 对于DOS或者UNIX风格的分隔符都可以。 
  431.    * @param fileName 文件路径 
  432.    * @return 路径分隔符在路径中最后出现的位置，没有出现时返回-1。 
  433.    * @since 0.5 
  434.    */  
  435. public static int getPathLsatIndex(String fileName) {  
  436.     int point = fileName.lastIndexOf('/');  
  437.     if (point == -1) {  
  438.       point = fileName.lastIndexOf('//');  
  439.     }  
  440.     return point;  
  441. }  
  442.   
  443. /** 
  444.    * 得到路径分隔符在文件路径中指定位置前最后出现的位置。 
  445.    * 对于DOS或者UNIX风格的分隔符都可以。 
  446.    * @param fileName 文件路径 
  447.    * @param fromIndex 开始查找的位置 
  448.    * @return 路径分隔符在路径中指定位置前最后出现的位置，没有出现时返回-1。 
  449.    * @since 0.5 
  450.    */  
  451. public static int getPathLsatIndex(String fileName, int fromIndex) {  
  452.     int point = fileName.lastIndexOf('/', fromIndex);  
  453.     if (point == -1) {  
  454.       point = fileName.lastIndexOf('//', fromIndex);  
  455.     }  
  456.     return point;  
  457. }  
  458.   
  459. /** 
  460.    * 将文件名中的类型部分去掉。 
  461.    * @param filename 文件名 
  462.    * @return 去掉类型部分的结果 
  463.    * @since 0.5 
  464.    */  
  465. public static String trimType(String filename) {  
  466.     int index = filename.lastIndexOf(".");  
  467.     if (index != -1) {  
  468.       return filename.substring(0, index);  
  469.     }  
  470.     else {  
  471.       return filename;  
  472.     }  
  473. }  
  474. /** 
  475.    * 得到相对路径。 
  476.    * 文件名不是目录名的子节点时返回文件名。 
  477.    * @param pathName 目录名 
  478.    * @param fileName 文件名 
  479.    * @return 得到文件名相对于目录名的相对路径，目录下不存在该文件时返回文件名 
  480.    * @since 0.5 
  481.    */  
  482. public static String getSubpath(String pathName,String fileName) {  
  483.     int index = fileName.indexOf(pathName);  
  484.     if (index != -1) {  
  485.       return fileName.substring(index + pathName.length() + 1);  
  486.     }  
  487.     else {  
  488.       return fileName;  
  489.     }  
  490. }  
  491.   
  492. }  
  493. 4.遗留问题  
  494.   
  495. 目前new FileInputStream()只会使用绝对路径，相对没用过，因为要相对于web服务器地址，比较麻烦  
  496.   
  497. 还不如写个配置文件来的快哪  
  498.   
  499. 5.按Java文件类型分类读取配置文件  
  500.   
  501. 配 置文件是应用系统中不可缺少的，可以增加程序的灵活性。java.util.Properties是从jdk1.2就有  
  502.   
  503. 的类，一直到现在都支持load ()方法，jdk1.4以后save(output,string) ->store(output,string)。  
  504.   
  505. 如果只是单纯的读，根本不存在烦恼的问题。web层可以通过 Thread.currentThread  
  506.   
  507. ().getContextClassLoader().  
  508. getResourceAsStream("xx.properties") 获取；Application可以通过new FileInputStream  
  509.   
  510. ("xx.properties");直接在classes一级获取。关键是有时我们需要通过web修改配置文件，我们不 能  
  511.   
  512. 将路径写死了。经过测试觉得有以下心得：  
  513.   
  514. 1.servlet中读写。如果运用Struts 或者Servlet可以直接在初始化参数中配置，调用时根据  
  515.   
  516. servletcontext的getRealPath("/")获取真实路径，再根据String file =  
  517.   
  518. this.servlet.getInitParameter("abc");获取相对的WEB-INF的相对路径。  
  519. 例：  
  520. InputStream input = Thread.currentThread().getContextClassLoader().  
  521. getResourceAsStream("abc.properties");  
  522. Properties prop = new Properties();  
  523. prop.load(input);  
  524. input.close();  
  525. OutputStream out = new FileOutputStream(path);  
  526. prop.setProperty("abc", “test");  
  527. prop.store(out, “–test–");  
  528. out.close();  
  529.   
  530. 2.直接在jsp中操作，通过jsp内置对象获取可操作的绝对地址。  
  531. 例：  
  532. // jsp页面   
  533. String path = pageContext.getServletContext().getRealPath("/");  
  534. String realPath = path+"/WEB-INF/classes/abc.properties";  
  535.   
  536. //java 程序   
  537. InputStream in = getClass().getClassLoader().getResourceAsStream("abc.properties"); //   
  538.   
  539. abc.properties放在webroot/WEB-INF/classes/目录下  
  540. prop.load(in);  
  541. in.close();  
  542.   
  543. OutputStream out = new FileOutputStream(path); // path为通过页面传入的路径   
  544. prop.setProperty("abc", “abcccccc");  
  545. prop.store(out, “–test–");  
  546. out.close();  
  547.   
  548. 3.只通过Java程序操作资源文件  
  549. InputStream in = new FileInputStream("abc.properties"); // 放在classes同级   
  550.   
  551. OutputStream out = new FileOutputStream("abc.properties");  

java中获取文件路径的几种方式
2010-07-30 14:23

关于绝对路径和相对路径：
绝对路径就是你的主页上的文件或目录在硬盘上真正的路径，(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中的相对地址，他们是由客户端浏览器解析的）

第一种：
File f = new File(this.getClass().getResource("/").getPath());
System.out.println(f);
结果:
C:/Documents%20and%20Settings/Administrator/workspace/projectName/bin
获取当前类的所在工程路径;
如果不加“/”
File f = new File(this.getClass().getResource("").getPath());
System.out.println(f);
结果：
C:/Documents%20and%20Settings/Administrator/workspace/projectName/bin/com/test
获取当前类的绝对路径；

第二种：
File directory = new File("");//参数为空
String courseFile = directory.getCanonicalPath() ;
System.out.println(courseFile);
结果：
C:/Documents and Settings/Administrator/workspace/projectName
获取当前类的所在工程路径;

第三种：
URL xmlpath = this.getClass().getClassLoader().getResource("selected.txt");
System.out.println(xmlpath);
结果：
file:/C:/Documents%20and%20Settings/Administrator/workspace/projectName/bin/selected.txt
获取当前工程src目录下selected.txt文件的路径

第四种：
System.out.println(System.getProperty("user.dir"));
结果：
C:/Documents and Settings/Administrator/workspace/projectName
获取当前工程路径

第五种：
System.out.println( System.getProperty("java.class.path"));
结果：
C:/Documents and Settings/Administrator/workspace/projectName/bin
获取当前工程路径

 

java路径问题

  1. 在很多地方都碰到了JAVA中的路径问题，总结起来有以下几点：  
  2. 1、使用绝对路径的时候，应该使用“D://temp//”或者"D:/temp/"等形式.   
  3. 2、如果我们是在eclipse下面运行一个Java类，那么它的当前路径应该是工程目录下，和bin文件夹同级别。  
  4. 3、如果我们是在tomcat下面运行，那么它的当前路径应该就是bin目录。因为这里是整个程序运行的入口。比如File a=new File("frid.jpg");那么这个文件应该就在bin目录下的frid.jpg.  
  5. 4、很多时候在tomcat的项目工程中获得一个相对路径，比如在创建Javabean和java类或者servlet的时候需要在当前index.jsp所在的目录下建立一个文件夹temp，该怎么做呢？我们可以使用如下方法：  
  6.             //假设当前类为PicStatic,包为com.dc.most.那么以下语句则是返回该类所在的目录,注意:返回的变量a 中的空格会自动用%20替换,因此需要对它进行处理,否则java无法辨认该路径.   
  7.             String a=com.dc.most.PicStatic.class.getResource("").toString();  
  8.             a=a.replaceAll("%20", " ");  
  9.             //通过以下两句取得JSP文件所在目录   
  10.             String b=new String("WEB-INF/classes/com/dc/most/");  
  11.             a=a.substring(0,a.lastIndexOf("/", a.length()-(b.length())));  
  12.            //去掉file:/,否则无法辨认   
  13.             a=a.substring(a.indexOf("/")+1);  
  14.             //如果该目录不存在,则创建   
  15.             File myFilePath   = new File(a+"/temp/");  
  16.             if   (!myFilePath.exists())   {     
  17.                myFilePath.mkdir();     
  18.             }  
  19.             //创建文件流   
  20.             fos_jpg = new FileOutputStream(myFilePath +"/"+ filename);  
  21.             if (extname.equalsIgnoreCase("jpg"))  
  22.                 ChartUtilities.writeChartAsJPEG(fos_jpg, 100, chart, width, height, null);  
  23.             else if (extname.equalsIgnoreCase("png"))  
  24.                 ChartUtilities.writeChartAsPNG(fos_jpg, chart, width, height, null);  
  25.             else System.out.print("文件名格式出错，只能以JPG或PNG结尾.");  
  26. 5、如果是在tomcat工程中，可以在JSP页面中加入request.getContextPath()来获得当前工程的网址。  
  30. .基本概念的理解
  31. 绝对路径：绝对路径就是你的主页上的文件或目录在硬盘上真正的路径，(URL和物理路径)例如：
    C:/xyz/test.txt 代表了test.txt文件的绝对路径。http://www.sun.com/index.htm也代表了一个
    URL绝对路径。
  32. 相对路径：相对与某个基准目录的路径。包含Web的相对路径（HTML中的相对目录），例如：在
    Servlet中，"/"代表Web应用的跟目录。和物理路径的相对表示。例如："./" 代表当前目录,
    "../"代表上级目录。这种类似的表示，也是属于相对路径。
  33. 另外关于URI，URL,URN等内容，请参考RFC相关文档标准。
  34. RFC 2396: Uniform Resource Identifiers (URI): Generic Syntax,
    (http://www.ietf.org/rfc/rfc2396.txt)

  35. 2.关于JSP/Servlet中的相对路径和绝对路径。
  36. 2.1服务器端的地址
  37. 服务器端的相对地址指的是相对于你的web应用的地址，这个地址是在服务器端解析的
    （不同于html和javascript中的相对地址，他们是由客户端浏览器解析的）也就是说这时候
    在jsp和servlet中的相对地址应该是相对于你的web应用，即相对于http://192.168.0.1/webapp/的。
  38. 其用到的地方有：
    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");%>
  39. 2.22、客户端的地址
  40.         所有的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表单一样。

  41. 因此，一般情况下，在JSP/HTML页面等引用的CSS,Javascript.Action等属性前面最好都加上
    <%=request.getContextPath()%>,以确保所引用的文件都属于Web应用中的目录。
    另外，应该尽量避免使用类似".","./","http://www.cnblogs.com/"等类似的相对该文件位置的相对路径，这样
    当文件移动时，很容易出问题。

  42. 3. JSP/Servlet中获得当前应用的相对路径和绝对路径
    3.1 JSP中获得当前应用的相对路径和绝对路径
    根目录所对应的绝对路径:request.getRequestURI()
    文件的绝对路径     　:application.getRealPath(request.getRequestURI());
    当前web应用的绝对路径 :application.getRealPath("/");
    取得请求文件的上层目录:new File(application.getRealPath(request.getRequestURI())).getParent()
  43. 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()
          )
  44. 4.java 的Class中获得相对路径，绝对路径的方法
    4.1单独的Java类中获得绝对路径
    根据java.io.File的Doc文挡，可知:
    默认情况下new File("/")代表的目录为：System.getProperty("user.dir")。
    一下程序获得执行类的当前路径
    package org.cheng.file;
    import java.io.File;
  45. public class FileTest {
         public static void main(String[] args) throws Exception {     
  46.    System.out.println(Thread.currentThread().getContextClassLoader().getResource(""));    
  47.    System.out.println(FileTest.class.getClassLoader().getResource(""));       
  48. System.out.println(ClassLoader.getSystemResource(""));       
       System.out.println(FileTest.class.getResource(""));       
       System.out.println(FileTest.class.getResource("/")); //Class文件所在路径 
       System.out.println(new File("/").getAbsolutePath());       
       System.out.println(System.getProperty("user.dir"));   
    }
    }
  49. 4.2服务器中的Java类获得当前路径（来自网络）
    (1).Weblogic
  50. WebApplication的系统文件根目录是你的weblogic安装所在根目录。
    例如：如果你的weblogic安装在c:/bea/weblogic700.....
    那么，你的文件根路径就是c:/.
    所以，有两种方式能够让你访问你的服务器端的文件：
    a.使用绝对路径：
    比如将你的参数文件放在c:/yourconfig/yourconf.properties，
    直接使用 new FileInputStream("yourconfig/yourconf.properties");
    b.使用相对路径：
    相对路径的根目录就是你的webapplication的根路径，即WEB-INF的上一级目录，将你的参数文件放
  51. 在yourwebapp/yourconfig/yourconf.properties，
    这样使用：
    new FileInputStream("./yourconfig/yourconf.properties");
    这两种方式均可，自己选择。
  52. (2).Tomcat
  53. 在类中输出System.getProperty("user.dir");显示的是%Tomcat_Home%/bin
  54. (3).Resin
  55. 不是你的JSP放的相对路径,是JSP引擎执行这个JSP编译成SERVLET
    的路径为根.比如用新建文件法测试File f = new File("a.htm");
    这个a.htm在resin的安装目录下
  56. (4).如何读相对路径哪？
  57. 在Java文件中getResource或getResourceAsStream均可
  58. 例：getClass().getResourceAsStream(filePath);//filePath可以是"/filename",这里的/代表web
  59. 发布根路径下WEB-INF/classes
  60. 默认使用该方法的路径是：WEB-INF/classes。已经在Tomcat中测试。
  61. 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
  62. 6.Java中文件的常用操作（复制，移动，删除，创建等）（来自网络）
    常用 java File 操作类
    http://www.easydone.cn/014/200604022353065155.htm
  63. Java文件操作大全（JSP中）
    http://www.pconline.com.cn/pcedu/empolder/gj/java/0502/559401.html
  64. java文件操作详解（Java中文网）
    http://www.51cto.com/html/2005/1108/10947.htm
  65. JAVA 如何创建/删除/修改/复制目录及文件
    http://www.gamvan.com/developer/java/2005/2/264.html

posted on 2011-09-28 13:53  Chrisnda  阅读(958)  评论(0)  编辑  收藏  举报

导航