1. /**

  2.  * Copyright: Copyright (c) 2002-2004

  3.  * Company: JavaResearch(http://www.javaresearch.org)

  4.  */

  5. 

  6. package org.jr.java2html;

  7. 

  8. 

  9. 

  10. import java.io.BufferedReader;

  11. import java.io.File;

  12. import java.io.FileReader;

  13. import java.net.URL;

  14. import java.util.HashMap;

  15. import java.util.Iterator;

  16. import java.util.ArrayList;

  17. 

  18. import org.jr.util.StringUtil;

  19. 

  20. /**

  21.  * 根据类名得到相应的链接的工具类。 根据以下的规则得到类名是否有对应的源代码:

  22.  * <ol>

  23.  * <li>如果类名前有包名，则根据这个全限定名进行匹配

  24.  * <li>如果导入语句中有以该类名结尾的导入语句，则以该导入声明的全限定名进行匹配

  25.  * <li>如果导入语句中有带*号的通用导入，则以该包加类名逐个进行匹配

  26.  * <li>根据类文件所在的路径加类名进行匹配

  27.  * <li>以java.lang作为包名进行匹配

  28.  * </ol>

  29.  * 最后更新日期:2004年11月30日

  30.  * @author cherami@javaresearch.org

  31.  * @version 0.9

  32.  */

  33. public class ClassLink {

  34.   HashMap linkMap;

  35. 

  36.   /**

  37.    * 构造一个空的ClassLink对象。

  38.    */

  39.   public ClassLink() {

  40.   }

  41. 

  42.   /**

  43.    * 以指定参数构造一个ClassLink对象。

  44.    * @param linkMap 类名HashMap和URL映射的集合

  45.    */

  46.   public ClassLink(HashMap linkMap) {

  47.     this.linkMap = linkMap;

  48.   }

  49. 

  50.   /**

  51.    * 将指定的类名HashMap和链接添加到映射中。

  52.    * @param classMap 类名HashMap

  53.    * @param link 类的URL

  54.    */

  55.   public void put(HashMap classMap, String link) {

  56.     if (linkMap == null) {

  57.       linkMap = new HashMap();

  58.     }

  59.     linkMap.put(classMap, link);

  60.   }

  61. 

  62.   /**

  63.    * 将指定的ClassLink对象中的所有映射添加到当前的映射中。

  64.    * @param classLink ClassLink对象

  65.    */

  66.   public void putAll(ClassLink classLink) {

  67.     if (linkMap == null) {

  68.       linkMap = new HashMap();

  69.     }

  70.     linkMap.putAll(classLink.linkMap);

  71.   }

  72. 

  73.   /**

  74.    * 根据指定的类名从当前映射中取得类名对应的URL。

  75.    * @param className 当前解析的类名

  76.    * @param packagePath 当前解析的文件的包名

  77.    * @param classPackage 当前解析的类的限定包名

  78.    * @param importedClasses 当前解析的文件的导入声明

  79.    * @return 类名对应的URL，如果不存在返回null。

  80.    */

  81.   public String getLink(String className, String packagePath,

  82.       String classPackage, ArrayList importedClasses) {

  83.     if (linkMap == null || linkMap.size() == 0) {

  84.       return null;

  85.     }

  86.     Iterator classMaps = linkMap.keySet().iterator();

  87.     while (classMaps.hasNext()) {

  88.       HashMap classMap = (HashMap) classMaps.next();

  89.       Object path = classMap.get(className);

  90.       if (path != null) {

  91.         String root = (String) linkMap.get(classMap);

  92.         String classPath = getPath(path, className, packagePath, classPackage,

  93.             importedClasses);

  94.         if (classPath == null) {

  95.           return null;

  96.         } else {

  97.           return getRoot(root, packagePath) + classPath;

  98.         }

  99.       }

  100.     }

  101.     return null;

  102.   }

  103. 

  104.   /**

  105.    * 根据指定的根路径和包路径得到实际的根路径。 

  106.    * 如果指定的根路径是空字符串说明是当前转换的项目的类，实际的路径将是根据指定的包路径得到的相对路径；

  107.    * 如果指定的根路径不是以http://或者file:///开头的绝对URL路径说明是本地相对路径，实际的路径将是根据指定的包路径得到的相对路径加指定的根路径;

  108.    * 如果是其它则说明是绝对的URL路径，直接返回指定的根路径。

  109.    * @param root 根路径

  110.    * @param packagePath 当前解析的文件的包路径

  111.    * @return 实际的根路径。

  112.    */

  113.   private String getRoot(String root, String packagePath) {

  114.     if (root.equals("")) {

  115.       if (packagePath != null) {

  116.         int count = StringUtil.getSubtringCount(packagePath, "/");

  117.         if (packagePath.length() > 0) {

  118.           count++;

  119.         }

  120.         if (count > 0) {

  121.           return Utility.fill("../", count);

  122.         }

  123.         return "";

  124.       } else {

  125.         return root;

  126.       }

  127.     } else if (!root.startsWith("http://") && !root.startsWith("file:///")) {

  128.       if (packagePath != null) {

  129.         int count = StringUtil.getSubtringCount(packagePath, "/");

  130.         if (packagePath.length() > 0) {

  131.           count++;

  132.         }

  133.         if (count > 0) {

  134.           return Utility.fill("../", count) + root;

  135.         }

  136.         return root;

  137.       } else {

  138.         return root;

  139.       }

  140.     } else {

  141.       return root;

  142.     }

  143.   }

  144. 

  145.   /**

  146.    * 根据直接取得的可能路径对象得到完全匹配的类路径。

  147.    * @param path 可能路径，String类型或者ArrayList类型

  148.    * @param className 当前解析的类名

  149.    * @param packagePath 当前解析的文件的包名

  150.    * @param classPackage 当前解析的类的限定包名

  151.    * @param importedClasses 当前解析的文件的导入声明

  152.    * @return 完全匹配的类路径。

  153.    */

  154.   private String getPath(Object path, String className, String packagePath,

  155.       String classPackage, ArrayList importedClasses) {

  156.     //如果只有一个匹配的路径

  157.     if (path instanceof String) {

  158.       //如果类名前有限定包名则比较得到的路径是否是以该限定包名开头的，是则返回该路径，否则返回null

  159.       if (classPackage != null) {

  160.         if (((String) path).startsWith(classPackage)) {

  161.           return ((String) path);

  162.         }

  163.         return null;

  164.       }

  165.       //如果文件中有包导入声明

  166.       if (importedClasses.size() > 0) {

  167.         //取完全匹配类名的导入声明和路径中完全匹配的

  168.         for (int i = 0; i < importedClasses.size(); i++) {

  169.           String currentPackage = (String) importedClasses.get(i);

  170.           if (currentPackage.endsWith("/" + className)) {

  171.             if (((String) path).startsWith(currentPackage)) {

  172.               return ((String) path);

  173.             }

  174.             break;

  175.           }

  176.         }

  177.         //取通配形式的导入声明和路径中完全匹配的

  178.         for (int i = 0; i < importedClasses.size(); i++) {

  179.           String currentPackage = (String) importedClasses.get(i);

  180.           if (currentPackage.endsWith("/")) {

  181.             String fullName = currentPackage + className;

  182.             if (((String) path).startsWith(fullName)) {

  183.               return ((String) path);

  184.             }

  185.           }

  186.         }

  187.       }

  188.       //当前文件的包名加类名是否匹配

  189.       if (packagePath != null) {

  190.         if (((String) path).startsWith(packagePath)) {

  191.           return ((String) path);

  192.         }

  193.       }

  194.       //java中默认导入的包java/lang/是否匹配

  195.       if (((String) path).startsWith("java/lang/")) {

  196.         return ((String) path);

  197.       }

  198.       //没有匹配

  199.       return null;

  200.     } else {//有多个可能的匹配路径

  201.       ArrayList pathList = (ArrayList) path;

  202.       //如果类名前有限定包名则查找是否有完全匹配的

  203.       if (classPackage != null) {

  204.         String fullName = classPackage + className;

  205.         for (int j = 0; j < pathList.size(); j++) {

  206.           String currentPath = (String) pathList.get(j);

  207.           if (currentPath.startsWith(fullName)) {

  208.             return currentPath;

  209.           }

  210.         }

  211.         return null;

  212.       }

  213.       //如果有导入声明

  214.       if (importedClasses.size() > 0) {

  215.         //查找导入声明中可以完全匹配的

  216.         for (int i = 0; i < importedClasses.size(); i++) {

  217.           String currentPackage = (String) importedClasses.get(i);

  218.           if (currentPackage.endsWith("/" + className)) {

  219.             for (int j = 0; j < pathList.size(); j++) {

  220.               String currentPath = (String) pathList.get(j);

  221.               if (currentPath.startsWith(currentPackage)) {

  222.                 return currentPath;

  223.               }

  224.             }

  225.             break;

  226.           }

  227.         }

  228.         //查找导入声明中通配中可以完全匹配的

  229.         for (int i = 0; i < importedClasses.size(); i++) {

  230.           String currentPackage = (String) importedClasses.get(i);

  231.           if (currentPackage.endsWith("/")) {

  232.             String fullName = currentPackage + className;

  233.             for (int j = 0; j < pathList.size(); j++) {

  234.               String currentPath = (String) pathList.get(j);

  235.               if (currentPath.startsWith(fullName)) {

  236.                 return currentPath;

  237.               }

  238.             }

  239.           }

  240.         }

  241.       }

  242.       //用文件包名加类名进行完全匹配

  243.       String fullName = packagePath + "/" + className;

  244.       for (int j = 0; j < pathList.size(); j++) {

  245.         String currentPath = (String) pathList.get(j);

  246.         if (currentPath.startsWith(fullName)) {

  247.           return currentPath;

  248.         }

  249.       }

  250.       //用java缺省导入的java/lang包进行完全匹配

  251.       fullName = "java/lang/" + className;

  252.       for (int j = 0; j < pathList.size(); j++) {

  253.         String currentPath = (String) pathList.get(j);

  254.         if (currentPath.startsWith(fullName)) {

  255.           return currentPath;

  256.         }

  257.       }

  258.       return null;

  259.     }

  260.   }

  261. 

  262.   /**

  263.    * 从指定文件中取得类名URL映射关系。

  264.    * @param mapFilename 类名URL映射关系文件

  265.    * @return 类名URL映射关系对象

  266.    */

  267.   public static ClassLink getClassLink(String mapFilename) {

  268.     try {

  269.       BufferedReader buffer = new BufferedReader(new FileReader(mapFilename));

  270.       String line = buffer.readLine();

  271.       ClassLink classLink = new ClassLink();

  272.       while (line != null) {

  273.         if (line.startsWith("#") || line.length() == 0) {

  274.           line = buffer.readLine();

  275.           continue;

  276.         }

  277.         String[] array = line.split("=");

  278.         String path;

  279.         String link;

  280.         URL url;

  281.         if (array.length == 1) {

  282.           path = line;

  283.           int index = line.lastIndexOf("/");

  284.           if (index >= 0) {

  285.             link = line.substring(0, index + 1);

  286.           } else {

  287.             link = "";

  288.           }

  289.         } else {

  290.           path = array[0];

  291.           link = array[1];

  292.         }

  293.         url = getURL(path);

  294.         HashMap map = (HashMap) org.jr.io.FileReader.readObject(url);

  295.         if (map != null) {

  296.           classLink.put(map, link);

  297.         }

  298.         line = buffer.readLine();

  299.       }

  300.       return classLink;

  301.     }

  302.     catch (Exception e) {

  303.       e.printStackTrace();

  304.     }

  305.     return null;

  306.   }

  307. 

  308.   /**

  309.    * 根据指定的路径得到路径的URL。 

  310.    * 如果路径是以http://或者file:///开头的则直接生成URL， 否则将路径转换为文件对象后再转换为URL。

  311.    * @param path 路径

  312.    * @return 路径对应的URL

  313.    */

  314.   private static URL getURL(String path) {

  315.     try {

  316.       if (path.startsWith("http://") || path.startsWith("file:///")) {

  317.         return new URL(path);

  318.       } else {

  319.         return new File(path).toURL();

  320.       }

  321.     }

  322.     catch (Exception e) {

  323.       e.printStackTrace();

  324.       return null;

  325.     }

  326.   }

  327. 

  328. }