站内搜索: 请输入搜索关键词

当前页面: 开发资料首页J2SE 专题实现JAVA的动态类载入机制

实现JAVA的动态类载入机制

摘要: 实现JAVA的动态类载入机制
<table cellSpacing=0 cellPadding=0 border=0 class="zh114" align="right"> <tr> <td > </td> </tr> </table>
  ---- 作 为 充 分 利 用Java 的 动 态 类 载 入 机 制 的 最 好 例 子, 带 有Java 扩 展 的Web 浏 览 器 根 据 请 求 从 网 络 或 本 地 文 件 系 统 中 动 态 加 载Java applet( 遵 循 一 定 规 则 的Java 小 应 用 程 序 类), 然 后 在 本 地 系 统 中 执 行 它, 大 大 增 强 了 主 页 的 功 能。
  
  ---- 其 实,Java 本 身 就 是 一 种 极 具 动 态 性 的 语 言。 类 似Windows 的 动 态 链 接 库(DLL),Java 应 用 程 序 总 是 被 编 译 成 若 干 个 单 独 的class 文 件, 程 序 执 行 时 根 据 需 要 由Java 虚 拟 机 动 态 载 入 相 应 的 类。 这 种 机 制 使 编 写 动 态 的 分 布 式 应 用 程 序 成 为 可 能: 我 们 可 以 在 客 户 端 编 写 自 己 的 类 载 入 器, 而 真 正 执 行 的 程 序 却 存 放 在 本 地、 局 域 网 或 世 界 另 一 端 的 主 机 上。 下 面 将 介 绍 如 何 在 自 己 的 应 用 程 序 中 实 现Java 的 动 态 类 载 入 机 制。
  
  与 动 态 类 载 入 有 关 的 系 统 类
  ---- 为 支 持 动 态 类 载 入 机 制, 在 系 统 类 组java.lang 中 提 供 了 两 个 类:Class 类 和ClassLoader 类。
  
  ---- 1、 类java.lang.Class。 在Java 虚 拟 机 中, 每 一 个 类 或 接 口 都 是 由Class 类 来 操 纵 的, 它 不 能 被 显 式 的 实 例 化, 必 须 用 其 他 方 法 来 获 取Class 类 的 对 象。 动 态 类 载 入 机 制 的 关 键 一 步 在 于 如 何 获 得 指 定 类 的Class 类 型 的 对 象。 相 关 方 法 主 要 有:
  
  ---- public static Class forName(String className)
  
  ---- 这 是 一 个 静 态 方 法, 它 获 取 指 定 名 字 的 类 的Class 类 型 对 象, 类 名 可 以 是 象“sun.applet.Applet” 这 样 的 字 符 串, 但 不 能 带 有 路 径 或 网 络 地 址 等 信 息。 这 是 从 本 地 系 统 中 动 态 载 入 类 的 最 方 便 的 办 法。
  
  ---- public Object newInstance()
  
  ---- 这 是 最 重 要 的 一 个 方 法, 它 建 立 由Class 类 型 对 象 描 述 的 指 定 类 的 实 例。
  
  ---- 下 面 是 一 个 用forName() 和newInstance() 方 法 实 现 动 态 类 载 入 的 代 码,share 类 包 含 一 个 接 口, 详 细 内 容 将 在 第 三 部 分 中 解 释。
  
  try{
  //根据类名建立Class类型的对象。
  Class cc =Class.forName("类名"));
  //建立被载入类类的实例并强制类型转换,
  值赋给share类型的变量。
  share oo=((share)cc).newInstance();
  //调用该类的方法进行工作。
  }
  catch (Exception ex){
  //如果发生例外,则进行相应处理。
  };
  
  ---- 2、 类java.lang.ClassLoader。 这 是 一 个 抽 象 类, 如 果 打 算 运 用 它, 必 须 继 承 它 并 重 写 它 的loadClass() 方 法。 其 主 要 方 法 有:
  
  ---- protected ClassLoader();
  
  ---- 这 是 一 个 建 构 元, 可 以 用 它 建 立 一 个ClassLoader 类 的 实 例。 注 意 继 承 这 个 类 的 类 必 须 重 写 这 个 方 法, 而 不 能 使 用 缺 省 的 建 构 元。
  
  ---- protected abstract Class loadClass(String name, boolean resolve)
  
  ---- 载 入 指 定 的 类 数 据, 建 立Class 类 型 的 对 象 并 根 据 需 要 解 析 它。 这 是 一 个 抽 象 方 法, 大 家 必 须 在 自 己 的 子 类 中 重 写 这 个 方 法, 重 写 的 规 则 可 以 参 考 第 三 部 分 的 例 子。
  
  ---- protected final Class defineClass(byte data[], int offset, int length)
  
  ---- 将 字 节 数 组 中 的 数 据 定 义 为Class 类 型 的 对 象, 字 节 数 组 的 格 式 由 虚 拟 机 规 定。
  
  ---- protected final Class findSystemClass(String name)
  
  ---- 根 据 指 定 的 类 名 载 入 类, 它 会 自 动 在 当 前 目 录 和 环 境 变 量“CLASSPATH” 指 定 的 路 径 中 寻 找, 如 果 找 不 到, 则 会 抛 出ClassNotFoundException 例 外。
  
  ---- protected final void resolveClass(Class c)
  
  ---- 通 过 载 入 与 指 定 的 类 相 关 的 所 有 类 来 解 析 这 个 类, 这 必 须 在 类 被 使 用 之 前 完 成。
  
  扩 充ClasslLader 类 以 实 现 动 态 类 载 入
  ---- 理 解 动 态 类 载 入 机 制 的 最 好 办 法 是 通 过 例 子, 下 面 这 个 完 整 的 例 子 由 四 个 类 组 成, 分 别 解 释 如 下:
  
  ---- 1、MyClassLoader 类 是ClassLoader 类 的 子 类, 它 重 写 了loadClass 方 法, 实 现 了 将 网 络 上 用URL 地 址 指 定 的 类 动 态 载 入, 取 得 它 的Class 类 型 对 象 的 功 能。 读 者 可 根 据 自 己 载 入 类 的 具 体 方 式 改 写 下 面 的 代 码。
  
  import java.io.*;
  import java.util.*;
  import java.net.*;
  
  public class MyClassLoader extends ClassLoader {
  //定义哈希表(Hashtable)类型的变量,
  用于保存被载入的类数据。
  Hashtable loadedClasses;
  
  public MyClassLoader() {
  loadedClasses = new Hashtable();
  }
  
  public synchronized Class loadClass(String className,
  boolean resolve) throws ClassNotFoundException {
  Class newClass;
  byte[] classData;
  
  //检查要载入的类数据是否已经被保存在哈希表中。
  newClass = (Class) loadedClasses.get(className);
  //如果类数据已经存在且resolve值为true,则解析它。
  if (newClass != null){
  if (resolve)
  resolveClass(newClass);
  return newClass;
  }
  
  ---- /* 首 先 试 图 从 本 地 系 统 类 组 中 载 入 指 定 类。 这 是 必 须 的, 因 为 虚 拟 机 将 这 个 类 载 入 后, 在 解 析 和 执 行 它 时 所 用 到 的 任 何 其 他 类, 如java.lang.System 类 等, 均 不 再 使 用 虚 拟 机 的 类 载 入 器, 而 是 调 用 我 们 自 制 的 类 载 入 器 来 加 载。*/
  
  try {
  newClass = findSystemClass(className);
  return newClass;
  } catch (ClassNotFoundException e) {
  System.out.println(className+" is not a system class!");
  }
  
  //如果不是系统类,
  则试图从网络中指定的URL地址载入类。
  try {
  //用自定义方法载入类数据,
  存放于字节数组classData中。
  classData = getClassData(className);
  //由字节数组所包含的数据建立一个class类型的对象。
  newClass = defineClass(classData, 0, classData.length);
  if (newClass == null)
  throw new ClassNotFoundException(className);
  } catch (Exception e) {
  throw new ClassNotFoundException(className);
  }
  
  //如果类被正确载入,
  则将类数据保存在哈希表中,以备再次使用。
  loadedClasses.put(className, newClass);
  //如果resolve值为true,则解析类数据。
  if (resolve){
  resolveClass(newClass);
  }
  return newClass;
  }
  //这个方法从网络中载入类数据。
  protected byte[] getClassData(String className)
  throws IOException {
  byte[] data;
  int length;
  try {
  //从网络中采用URL类的方法
  载入指定URL地址的类的数据。
  URL url = new URL(className.endsWith(".class") ?
  className : className + ".class");
  URLConnection connection = url.openConnection();
  InputStream inputStream = connection.getInputStream();
  length = connection.getContentLength();
  
  data = new byte[length];
  inputStream.read(data);
  inputStream.close();
  return data;
  } catch(Exception e) {
  throw new IOException(className);
  }
  }
  }
  
  ---- 2、 由 于Java 是 强 类 型 检 查 语 言, 通 过 网 络 载 入 后 的 类 被 实 例 化 后 只 是 一 个Object 类 型 的 对 象, 虚 拟 机 并 不 知 道 它 包 含 那 些 方 法, 应 从 哪 个 方 法 开 始 执 行。 因 此, 可 以 被 动 态 载 入 的 类 必 须 继 承 某 一 个 抽 象 类 或 实 现 某 一 个 接 口, 因 为 父 类 只 能 有 一 个, 所 以 通 常 用 实 现 特 定 接 口 的 办 法。 下 面 的 代 码 定 义 了 一 个 接 口 类share 和 它 的 方 法start()。
  
  public interface share {
  public void start(String[] option);
  }
  
  ---- 3、TestClassLoader 类 通 过 使 用MyClassLoader 类 的loadClass() 方 法, 将 指 定URL 地 址 的 类 载 入 并 在 本 地 系 统 执 行 它, 实 现 了 类 的 动 态 载 入。 注 意 在 执 行 被 载 入 类 的 方 法 前 一 定 要 将 它 进 行 强 制 数 据 类 型 转 换。
  
  public class TestClassLoader {
  public static void main(String[] args){
  MyClassLoader ll = new MyClassLoader(); <

<table width="96%"> <tr> <td background="http:///images/dian.gif" height="3"></td> </tr> </table>

↑返回目录
前一篇: JBuilder6:Borland方式的Java集成开发环境
后一篇: .NET 数据访问架构指南