发信人: tedz()
整理人: eagle(2001-05-19 17:40:40), 站内信件
|
Java，Beans 和 关 系 数 据 库 的 镜 像
----------------------------------------------------------------------
----------
摘 要
JDK1.1 包 括 了 新 的 数 据 库 存 取(JDBC) 及 组 件(JavaBeans
) 的 应 用 程 序 接 口(APIs)。 这 两 个API 结 合 在 一 起， 可 用 来 开
发 通 用 数 据 库 代 码。 通 过 用 唯 一 的 一 个 类 去 存 取 任 何 一
种JDBC 数 据 库( 封 装 于 不 同 组 件 中 的 各 个 应 用 程 序 有 着 其
具 体 的 编 码)， 用 户 就 不 必 因 为 数 据 库 结 构 一 点 点 的 细
小 变 化 去 修 改 数 据 库 编 码。
一 个 关 系 数 据 库 基 本 上 包 括 一 系 列 相 互 关 连 的 表
， 在 每 一 个 表 中 存 有 一 类 与 应 用 系 统 相 关 的 数 据。 例 如
一 个 地 址 簿 数 据 库 中， 可 能 有 关 于 人 员、 住 址、 电 话 号
码 等 方 面 的 表。 在 数 据 库 中， 每 一 个 这 样 的 实 体 将 被 作
为 一 系 列 的 字 符 串， 整 数 及 其 它 原 始 数 据 类 型 存 贮 起 来
。 数 据 库 中， 表 的 定 义 将 描 述 每 一 种 与 实 体 相 关 的 信 息
如 何 在 一 个 表 的 字 段 中 存 储。 例 如， 你 可 以 在 一 个 名 为
“ 人” 的 表 中， 有 两 个 字 段 别 表 示 所 存 字 符 串 为“ 姓” 和
“ 名”。 每 一 张 表 应 当 有 一 个 或 几 个 字 段 值 作 为 标 识， 确
保 每 条 记 录 的 唯 一 性。 这 些 标 识 或“ 键” 可 以 用 来 连 接
存 在 于 不 同 表 中 的 信 息。 例 如 你 可 以 在“ 人 员” 表 中， 为
每 个 人 指 定 唯 一 的“ 人 员 号 码” 的 键 值， 并 在“ 地 址” 表
中 的 相 应 字 段 中 使 用 同 一 个 键 值。 这 样， 你 可 以 通 过 对
两 个 表 中 的“ 人 员 号 码” 字 段 值 的 匹 配， 使 每 一 个 人 和
他 的 地 址 关 联 起 来。
关 系 数 据 库 系 统 出 现 于 七 十 年 代， 时 至 今 日， 它
仍 然 是 存 储 巨 量 数 据 的 主 要 方 式。 因 而，Java 软 件 工 具 有
必 要 具 备 处 理 关 系 数 据 库 的 能 力。
关 系 数 据 库 要 想 被 某 个Java 应 用 程 序 利 用， 首 先 需
要 解 决 两 个 问 题。 第 一： 需 要 某 些 基 础 的 中 间 件 来 建 立
与 数 据 库 的 连 接， 向 数 据 库 发 出SQL 查 询 等 等； 第 二： 操
纵 数 据 库 的 处 理 结 果 要 与 操 纵 任 何 一 种Java 信 息 一 样 方
便 — — 作 为 一 个 对 象。 前 一 个 问 题 已 被SUN 及 几 个 数 据 库
产 商 解 决； 后 一 个 问 题 则 有 待 我 们 进 一 步 去 探 究。
在 为 普 通 的 程 序 开 发 业 务 定 义 大 量 的APIs 这 项 工
作 上，SUN 一 直 保 持 着 与 许 多 软 件 公 司 的 合 作 关 系。 在JDK1
.1 APIs 中， JDBC 的API 是 最 早 建 立 起 来 的。 而 且， 它 已 得 到
了 为 数 众 多 的 应 用。 这 些 应 用 中， 有 的 是100% 的 纯Java， 有
的 则 是Java 和 其 它 程 序 的 混 合 体， 如： 用 现 有 的ODBC 数 据
源 进 行 连 接( 参 看 图1)。JavaSoft 已 将 一 个 关 于 现 有 的JDBC 驱
动 程 序 的 介 绍 放 在 它 的Web 站 点 上(http://splash.javasoft.com/
jdbc/jdbc.drivers.html)。
图1 一 个 典 型 的JDBC 或JDBC/ODBC 配 置
注 意： 此 图 已 被 简 化。 另 外 的 组 件 已 包 括 其 中( 如
ODBD 驱 动 程 序)
非 常 明 显， 这 些 应 用 的 优 缺 点 取 决 于 你 的 环 境 和
设 置， 在 此 我 不 准 备 对 它 们 的 各 种 情 况 进 行 逐 一 论 述。
在 下 面 的 内 容 中， 我 们 假 定， 在 你 的 机 器 中 已 拥 有 某 种
Java 开 发 环 境， 并 且 你 已 正 确 地 安 装 并 测 试 过 某 个JDBC 驱
动 程 序， 或 者 运 用 过 某 种JDBC 驱 动 程 序 及SUN 的JDBC/ODBC 桥。
JDBC API
JDBC API 作 为 一 个 单 独 的Java 包( 或 类 库， 即java.sql)
出 现， 包 括 有 一 系 列 的 类。 这 些 类 提 供 了 处 理 某 个 关 系
数 据 库 的 中 间 件。 本 质 上 讲， 它 们 使 得 你 可 以 关 联 某 个
数 据 库， 并 向 其 发 出 查 询。 你 可 以 对 这 些 查 询 结 果 进 行
处 理， 检 索 你 数 据 库 的meta- 信 息(meta-information)， 并 且 处 理
在 此 间 可 能 发 生 的 各 种 异 常 情 况。
让 我 们 来 看 一 个 简 单 的JDBC 例 子， 看 一 看 应 用 了Ja
va JDBC 之 后， 查 询 会 得 到 怎 样 的 简 化。 表1 是 一 个 极 其 简
单 的 数 据 库。 在 清 单1 中 的 编 码 是 一 段 最 简 单 的 对 关 系 数
据 库 进 行SQL 查 询 所 需 的Java 语 句。
人 员 ＃ 名 姓
43674 Sandor Spruit
90329 John Doe
65435 Donald Duck
String ur1="jdbc:odbc:sample";
String query="SELECT * FROM PERSON";
boolean more;
try
{
Class.forName("sun.jdbc.odbc.jdbcOdbcDriver");
Connection con = DriverManager.getConnection(ur1,"sandor","guest"
);
Statement stmt = con.createStatement();
ResultSet rs = stmt.executeQuery(query);
While (more = rs,next())
{
int number = rs.getInt("PERSON#");
String firstName = rs.getString("FIRST_NAME");
String lastName = rs.getString("LAST_NAME");
System.out.printIn(number + " " + firstName + " " + lastName)
;
}
rs.close();
stmt.close();
con.close();
}
catch(SQLException ex)
{
ex.printStackTrace();
}
清 单1: 一 个 应 用 了JDBC 的SQL 查 询
这 段 编 码 的 含 义 是： 先 装 入SUN 的JDBC/ODBC 驱 动 程 序
， 然 后 与 被jdbc:odbc:sample 指 定 的 数 据 库 建 立 起 一 个 关 联，
最 后 对 该 数 据 库 进 行 一 个 简 单 的SELECT 查 询。 如 果 没 有 遇
到 查 询 异 常(SQLException)， 程 序 将 循 环 地 从 结 果 集(ResultSe
t) 中 每 次 抽 出 一 条 数 据 库 记 录， 并 将 其 显 示 在 屏 幕 上。
好 了， 现 在 我 们 来 看 一 看 这 段 程 序 还 有 哪 些 不 足
? 在 清 单1 的 这 类 程 序 中， 存 在 着 两 个 根 本 性 的 错 误：
1 ． 这 种 编 码 用 到 了 数 量 众 多 的 数 据 库meta- 信 息，
而 这 些 信 息 都 只 能 手 工 编 码 到 程 序 中。 当 你 想 要 取 一 个
数 值 时， 你 必 须 提 前 知 道 你 将 取 到 的 数 值 是 一 个 整 数、
浮 点 数、 还 是 一 个 双 精 度 数。 这 将 会 使 得 编 写 一 个 可 以
处 理 任 何 一 个 数 据 库 的 类 变 得 十 分 困 难； 并 且 每 一 个 数
据 库 的 细 小 调 整 都 会 逼 你 去 仔 细 地 检 查 和 修 改 程 序。
2 ． 数 据 库 中 的 信 息 总 是 作 为 一 个 单 个 的RecordSet
( 记 录 集) 实 例 来 传 递， 而 这 种 实 例 并 不 是 一 个 真 正 的 对
象。RecordSet 类 ( 与 其 它 的 数 据 库 类 封 装 没 什 么 差 别) 更 象
一 个 指 针 或 游 标， 借 助 方 法， 它 能 够 提 供 存 取 数 据 信 息
的 途 径。RecordSet 中 的 实 例 实 际 上 并 不 包 括 信 息， 它 们 仅
仅 表 示 获 得 信 息 的 方 式。 这 正 说 明 了 当 你 要 调 用 另 外 的
RecordSet 方 法 去 获 取 某 些 真 实 的 数 据 信 息 的 时 候， 你 必 须
通 过RecordSet 去 做 更 多 的 工 作( 利 用RecordSet.NEXT() 去 移 动 指
针)。 实 际 上，JDBC 类 的 确 仅 仅 传 递 这 类 联 系 松 散 的 字 段。
即 使 你 完 全 了 解 数 据 库 的 所 有 内 部 细 节， 这 也 没 有 任 何
价 值， 因 为 在Java 提 供 了 存 储 和 处 理 信 息 的 方 法。
所 以， 理 想 的 状 态 是， 有 一 种 好 的 方 法， 能 够 逐 一
地 从 数 据 库 中 抽 取 记 录 或 字 段( 通 过RecordSet)， 并 且 将 取
到 的 信 息“ 填” 入 到 新 生 成 的 对 象 之 中。
这 一 解 决 方 式 的 关 键 在 于 关 系 数 据 库（RDB） 和 面
向 对 象 的 数 据 模 型（ODB） 之 间 的 相 似 性。RDB 中 的 表 和ODB 中
的 类 的 作 用 很 相 似， 而 记 录 和 对 象 也 有 着 某 些 相 同 的 属
性。 你 可 以 将 记 录 看 作 是 用 来 初 始 化 某 个 对 象 的 数 据 元
素 的 数 据 组。 如 果 你 已 将 记 录 从 数 据 库 中 抽 取 出 来， 就
必 须 调 用 类 构 造 函 数 来 生 成 上 面 所 说 的 对 象。 若 能 够 将
每 一 条 记 录 自 动 地 传 到 适 当 的 构 造 函 数 中， 就 可 以 轻 而
易 举 地 由 记 录 来 构 造 对 象。
在 开 发 一 个 小 的 应 用 程 序 时， 有 可 能 将 每 一 个 记
录 传 递 给 某 个 构 造 函 数， 以 此 来 生 成 新 的 对 象。 你 可 以
经 常 利 用 对 象 参 照 来 操 纵 从 数 据 库 中 抽 取 的 任 何 数 据。
因 为 你 通 过RecordSet 所 得 到 的 每 一 个 对 象 最 终 都 是java.la
ng.Object 的 扩 充。 你 可 以 定 义 一 个BibClass, 使 其 具 有 各 类 的
共 同 属 性，BigClass 类 操 作 将 利 用Java instanceof 算 子 来 实 时
决 定 运 行 中 所 遇 到 的 数 据 库 信 息， 并 且 通 过 一 个 大 的sw
itch 选 择， 跳 到 相 应 的 程 序 段 中。
你 也 可 以 定 义 一 个 相 似 的 带 有 多 个 构 造 函 数 的Bi
gClass， 每 个 构 造 函 数 有 差 别 不 太 大 的 调 用 参 数。 你 可 以
用BigClass(int，int)，BigClass(int，float) 等 等， 取 决 于 你 从Reco
rdSet 中 循 环 取 出 的 数 据 的 类 型( 这 一 方 法 当 然 将 会 包 括
许 多 冗 余 代 码)。
然 而， 以 上 两 种 方 法 都 不 能 真 正 解 决 问 题。 因 为
记 录 和 构 造 函 数 在 程 序 中 的 关 系 仍 将 是 僵 硬 的。 若 想 得
到 通 用 的 数 据 库 编 码， 必 须 自 动 地 建 立 数 据 库 和 构 造 函
数 二 者 的 关 联。
Java 的 性 能 对 于 此 时 的 我 们 就 如 雪 中 送 碳。 清 单2
中 的 程 序 片 段 只 需 一 个 类 名 就 可 以 建 造 一 个Java 类。 这
样， 我 们 就 可 以 凭 借 类 和 表 的 名 称 来 识 别 那 些 可 以 处 理
从 表 中 抽 取 出 的 记 录 的 构 造 函 数。 利 用 标 准 的JDBC 类， 可
以 容 易 地 获 得 所 有 表 的 表 名， 在 此， 我 们 将 要 充 分 利 用
这 个Java 小 技 巧。 只 要 简 单 地 为 每 个 数 据 库 表 开 辟 一 个J
ava 类， 使 类 名 和 表 名 相 互 匹 配， 无 论 何 时， 每 当 从 表 中
抽 取 出 一 条 记 录 的 时 候， 通 过 将 表 名 传 递 给Class.forName()
， 程 序 将 自 动 生 成 一 个 对 象。
Class c = class.forName("Person");
Person p = (Person)c.newInstance();
System。out.println("... just created a " + c.getName();
清 单2: 一 个 简 单 的Class.forName() 例 子
然 而， 此 处 还 有 一 些 问 题。 由 于 对 某 些 特 定 的 类
来 说，forName() 函 数 需 要 调 用 参 数 为void 的 构 造 函 数， 所 以
不 能 将RecordSet 变 量 直 接 传 递 给 构 造 函 数。 在 这 里， 我 们
需 要 一 个 初 始 化 函 数， 把 从 数 据 库 中 抽 取 出 的 记 录 作 为
RESULTSET 参 数， 将 其 值 赋 予 对 象 的 数 据 元 素。 一 个 好 的 方
法 是 引 入 超 级 类， 并 将 其 作 为 所 有 数 据 库 表 相 关 类 的 通
用 父 类。 实 际 上， 这 个 超 级 类 在 数 据 库 查 询 中 充 当 着 重
要 的 角 色， 我 们 将 在 下 面 展 示 这 一 点。
查 询 数 据 库
利 用 上 面 的 方 法 可 以 由 记 录 生 成 对 象， 但 是 你 仍
然 得 用SQL 语 句 来 查 询 数 据 库， 这 需 要 对 数 据 库 结 构 有 深
入 的 了 解。 这 还 是 没 有 解 决 问 题， 虽 然 我 们 能 够 自 动 地
匹 配 数 据 库 表 和 类 的 名 字， 但 是 还 是 必 须 手 工 编 写SQL 语
句。 这 就 是 说 每 次 修 改 数 据 库 结 构 后， 将 不 得 不 手 工 编
辑 这 些 查 询 语 句。 不 过， 我 们 仍 然 可 以 利 用 前 文 所 述 的
方 法 来 越 过 这 个 障 碍。 通 常 而 言， 查 询 关 系 数 据 库 时，
你 将 会 用 到 属 于 主 键 或 索 引 的 字 段 名 和 值。 一 言 弊 之，
如 果 某 人 向 你 提 供 了 适 当 的 字 段 名 和 字 段 值， 你 就 可 以
从 相 应 的 数 据 库 中 抽 取 符 合 要 求 的 记 录( 或 字 段)。 而Dat
abaseMetaData 对 象 不 但 可 以 被 用 于 检 索 一 系 列 的 表 名( 见 上
所 述)， 而 且 可 以 获 得 一 系 列 的 主 键 及 索 引 字 段。 上 面 的
问 题 由 此 可 以 迎 刃 而 解。
通 过 填 入 一 系 列 适 当 的（ 字 段 名， 字 段 值） 对， 可
以 利 用 相 对 而 言 少 得 多 的 代 码 实 现 对 关 系 数 据 库 的 查
询。 你 可 以 将 对 子 中 的 所 有 字 段 名 和 数 据 库 中 的 主 健 及
索 引 字 段 相 匹 配。 每 当 你 找 到 了 名 字 列 表 中 相 应 的 主 健
或 索 引 字 段， 可 以 根 据 相 应 的 数 值 来 生 成 一 个SQL 语 句，
执 行 它 来 获 取RecordSet， 并 通 过Class.forName() 构 造 机 制 将 结
果 转 化 为 对 象。
实 现 这 一 想 法 要 求 可 以 以（ 名， 值） 对 的 方 式 对 与
数 据 库 表 相 关 的 每 个 类 的 数 据 元 素 进 行 存 取。 但 是 这 种
方 法 只 有 通 过 上 节 所 述 的 通 用 父 类 才 能 趋 于 完 美。 清 单
3 和4 利 用 伪 码 表 示 了 这 一 方 法。
Open the database connection
Retrieve a list of user defined tables
for each table
{
Check where there is a corresponding class file
if(it is availabe)
{
load the class file
Retrieve lists of key fields and indeces for this table
Store these lists in hashtables for easy access
}
else throw an exception
}
清 单3: 初 始 化 数 据 库 连 接 的 伪 码
Take an object A containing a series of (name，value) pairs
for each table T
{
for each (name，value) pair
{
if(name matches primary_key_field or index_field)
store a refrence to both name and value
}
if all key_fields were found
create a query string using key names and values
else if all index_fields were found
create a query string using index names and values
execute the query to obtain a ResultSet
For each record in the ResultSet
{
Create an object of the class associated with table T
initialize the object using the record's contents
Add the object to the results， e。g。， attach it to A
}
}
清 单4: 描 述 数 据 库 查 询 的 伪 码
Java 镜 像 和Javabeans
Java1.1 开 发 套 件(JDK) 的 引 入， 为 我 们 带 来 了 许 多 强
大 的 新 性 能， 例 如 全 新 的 用 户 界 面 接 口 类。 有 两 个 新 的
JDK API 尤 其 值 得 注 意： 镜 像 机 制(java.lang.reflect 包) 和JavaBe
ans 组 件 的 应 用 程 序 接 口(java.beans 包)。 这 两 个API 将 会 帮 助
我 们 创 建 高 明 的 数 据 库 类， 使 我 们 可 以 利 用 有 关 类 的me
ta- 信 息， 以 此 来 解 决 开 发 通 用 数 据 库 类 中 的 问 题。
拥 有forName() 和newInstance() 方 法 的Class 类， 仅 仅 是 镜
象(reflection) 功 能 的 一 个 简 单 例 子。 真 正 重 要 的 是，forNam
e() 字 符 串 参 数 不 必 须 是 源 程 序 中 出 现 的 字 符 串。 只 要 给
出 一 个 名 字 ( 这 个 名 字 可 从 任 何 地 方 取 来 )， 你 就 可 以
载 入 并 实 例 化 任 何 一 个 类。 对 于 我 们 的 数 据 库 类， 我 们
可 以 直 接 从 数 据 库 自 身 的 表 名 中 得 到 类 名。 这 就 是 说，
与 数 据 库 表 相 关 的Java 类 名 并 不 需 要 出 现 在 源 程 序 中。 相
应 地， 当 表 名 改 变 或 某 个 表 被 加 入 到 数 据 库 中 时， 不 需
要 修 改 源 码， 只 要 确 信 带 有 新 名 字 的 类 已 存 在 你 的 系 统
中。
镜 像 类 意 味 着 可 以 在 实 时 运 行 中 获 取、 存 储 和 处
理Java 程 序 中 的 类 信 息。 它 们 的 实 例 能 够 象 任 何Java 对 象
一 样 被 运 用， 你 可 以 象 修 改 字 符 串 和 整 数 一 样， 去 修 改
类、 数 据 类 型、 返 回 类 型、 方 法 参 照 和 参 数。 在 源 程 序 级
， 这 个 镜 像 的 概 念 看 起 来 并 没 有 什 么 价 值 — — 因 为 可 以
应 用 你 自 己 的 编 码 直 接 存 取 你 所 需 要 的 有 关 类、 方 法 及
参 数 的 所 有 信 息。 但 是， 镜 像(reflection) 将 会 在java 的 编 译
文 件 中 发 挥 作 用。JavaBeans API 的 作 用 是： 通 过 应 用 程 序 的
构 造 机 制 利 用 来 自 于 全 然 不 同 的 开 发 者 或 产 商 所 编 写
的 类。
JavaBeans 规 范 为 类 成 员 的 名 字 制 定 一 系 列 的 条 例。
以 确 保 方 法 函 数 的 名 字 能 系 统 地 描 述 它 们 的 功 能。 任 何
一 个 符 合 规 则 的Java 类 都 可 以 被 一 个Bean 的 内 化 实 例( 通
过 镜 像) 检 查， 以 揭 示 其 行 为 的 重 要 特 征 — — 诸 如 对 于 什
么 样 的 事 件 类 将 有 所 响 应， 以 及 该 类 将 会 产 生 什 么 样 的
事 件 等 等。 任 何 符 合 这 些 规 范 的 类 都 是 高 效 的Bean， 因 而
是 一 个 组 件。 在 理 论 上， 这 意 味 着 你 可 以 从 各 种 来 源 收
集 一 系 列beans， 当 需 要 它 们 时 可 以 将 其 其 实 时 地 绑 在 一
起。
一 个Bean 的 例 子
在 下 面 一 个 名 为Translation 的Bean 中， 有 一 个 构 造 函
数 和 两 个 方 法 来 操 作 一 个 名 为“language” 的 属 性。 这 里 我
想 强 调 的 是， 既 然 你 可 以 通 过 检 查 一 个 类 的 代 码 来 了 解
它 的 构 造 函 数、 方 法 及 属 性， 那 么Bean 的 内 化 器(Introspect
or) 也 能 做 到。
public class Translation extends Object
{
int language;
public translation()
{
}
public int getlanguage()
{
return(language);
}
public void setLanguage( int language)
{
this。language=language;
}
}
清 单5: 一 个 非 常 简 单 的Bean
一 个Bean Introspector 能 够 提 供 许 多 数 组 的PropertyDesc
riptor 实 例， 这 些 实 例 包 含 所 有Bean 的 属 性 的 类 型 信 息， 即
例 子 中 由get/set 方 法 所 定 义 的 类 型。 你 可 以 调 用 这 些 方
法( 利 用reflection) 来 读 或 写 这 些 属 性。
镜 像 机 制(reflection facilities) 为 我 们 检 查 原 本 松 散
的 类 和 数 据 库 表 的 完 整 性 提 供 了 的 更 好 方 法。 实 际 上，
仅 仅 通 过 类 名 和 一 个 表 匹 配 并 不 一 定 能 够 保 证 一 些 类
内 部 的 一 致 性。 一 个 与 表 相 关 的 类 显 然 应 当 具 备 存 储 数
据 库 表 中 所 有 字 段 的 数 据 元 素。 一 个 类 可 能 有 适 当 的 名
字， 但 其 初 始 化 代 码 可 能 会 省 略。 它 可 能 只 有 一 个 正 确
的 名 字， 而 其 数 据 成 员 可 能 有 不 同 的 名 字 或 者 是 不 同 的
类 型。 使 用JDBC 的DatabaseMetaData 及 镜 像 机 制 可 以 检 查 它 们
是 否 完 全 匹 配 ！
引 用 一 些JDBC 调 用 去 获 得 现 实 中 必 须 的 数 据 库 信
息， 通 过 正 确 的 名 字 去 检 查 你 系 统 中 的 类， 并 且 通 过 镜
像 去 比 较 表 和 类 的 属 性， 这 实 实 在 在 是 一 块 香 饼 ！
结 论 和 启 示
JDBC， 镜 像 和JavaBeans 三 者 的 结 合， 能 够 方 便 地 从 关
系 数 据 库 中 存 取 记 录 并 利 用 记 录 来 初 始 化 组 件( 不 仅 仅
是 对 象)。 为 了 实 现 上 述 操 作， 无 需 修 改 你 的 数 据 库， 只
需 确 认 你 的 类 符 合Bean 规 范， 并 使 类 属 性 和 表 字 段 相 互
匹 配。Beans 还 有 其 它 一 些 简 单 的 技 巧， 可 使 编 程 更 加 有 趣
。Beans 能 够 提 供 自 己 的 用 户 界 面 组 件， 并 且Beans 规 范 还 包
括 一 个 名 为Customizers 的 东 西。 你 可 以 引 入 另 外 的 类 专 门
地 去 察 看、 编 辑 和 自 行 定 制 一 个Bean 类 的 实 例。( 关 于 定
制Beans， 请 参 看 下 一 期《 定 制 你 的Java》
总 之， 我 们 可 以 为 数 据 库 类 编 写 自 行 定 义 的 类，
应 用 程 序 能 够 从 关 系 数 据 库 中 抽 取 数 据， 通 过 实 例 化 某
个 类 得 到 新 的 实 例， 并 引 入 相 关 的 图 形 用 户 界 面(GUI) 组
件 来 查 看 和 编 辑 数 据。 所 有 这 些 都 由 通 用 代 码 完 成， 因
而 能 够 处 理 任 何 数 据 库。 利 用Java 编 写 的、 功 能 齐 全 的 数
据 库 查 看/ 编 辑 器 正 迎 我 们 而 来。
张 智 雄 编 译
稿 件 来 源：http://www.javaworld.com/javaworld/jw-09-1997/jw
-09-reflections.html
--
朋友可以让时间变得短暂,
让快乐加倍的膨胀,
让悲伤悄悄的引退,
让回忆不再平淡.
我想--------我会喜欢这里.
※ 来源:．月光软件站 http://www.moon-soft.com．[FROM: 61.130.132.158]
|
|