|
|
| 利用JAVA向垃圾电子邮件宣战 |
作者：未知
文章来源：www.jspcn.net
访问次数：563次
加入时间：2005年01月19日
|
|
摘 要 计 算 机 技 术 给 我 们 的 日 常 生 活 带 来 了 很 多 便 利： 来 自 生 产 线 的 产 品、 高 效 的 通 信 以 及 大 量 易 于 访 问 的 信 息， 然 而 它 同 时 也 带 来 了 垃 圾 电 子 邮 件。 幸 运 的 是， 我 们 已 经 有 办 法 对 付 它。 本 文 将 对Java 类 库 的I/O 包 以 及 建 立 在 其 上 的“ 流” 模 型 进 行 深 入 的 讨 论， 包 括： 它 是 如 何 工 作 的，Java 1.0.2 和Java 1.1 在I/O 实 现 方 面 的 差 别， 以 及 如 何 利 用 这 些 知 识 建 立 一 个 垃 圾 电 子 邮 件“ 过 滤 器”。
“ 足 不 出 户， 也 能 至 富”
“ 神 奇 的 饮 食， 一 周 减 肥20 磅”
“ 热 情 的XXX 宝 贝 想 见 你”
有 时， 我 们 会 收 到 很 多 不 受 欢 迎 的 电 子 邮 件， 这 些 邮 件 往 往 令 人 不 快。 那 些 还 没 有 受 垃 圾 电 子 邮 件 之 苦 的 幸 运 者 也 应 该 意 识 到 这 是 一 个 现 实 的 问 题。 这 里 我 们 将 介 绍 一 种 利 用JAVA 控 制 垃 圾 电 子 邮 件 的 方 法。
监 视 敌 人
我 们 无 法 逃 避 垃 圾 电 子 邮 件， 只 能 尽 量 减 少 它 对 我 们 生 活 的 侵 扰。 最 好， 也 是 最 有 效 的 方 法 是 阻 止 人 们 给 我 们 发 不 受 欢 迎 的 电 子 邮 件。 我 们 必 须 在 看 到 垃 圾 电 子 邮 件 之 前 消 除 它， 那 么 如 何 实 现 呢 ？
一 种 行 之 有 效 的 方 法 是 检 查 电 子 邮 件 的 内 容， 然 后 决 定 是 否 保 留 它。 其 实， 我 们 在 阅 读 电 子 邮 件 时 就 是 这 样 做 的： 我 们 一 个 接 一 个 字 符、 一 行 接 一 行 地 读 电 子 邮 件， 搜 索 我 们 认 识 地 单 词， 如 果 其 中 包 括 单 词“Java”， 我 们 便 保 留 它， 如 果 包 括“Make Money Fast”， 我 们 便 将 它 扔 到 垃 圾 桶 里。 能 否 编 制 一 个 计 算 机 程 序 来 帮 助 我 们 更 有 效 地 工 作 呢 ？
战 术 评 估
下 面， 我 们 讨 论Java 类 库I/O 包 中 的 类。Java 类 库 的 输 入 输 出 类 基 于 一 种 简 单 但 强 大 的 模 型：“ 流”(Streams)。
在“ 流” 模 型 中， 信 息 从 一 点“ 流” 到 另 一 点， 就 象 在 河 流 或 者 管 道 中 一 样。 在“ 流” 中 的 任 何 一 点， 观 察 者 看 到 信 息 一 点 一 点 地 顺 序 流 过。 这 种 模 型 适 合 现 实 世 界 中 很 多 类 型 的 信 息， 比 如 来 自 计 算 机 键 盘 的 键 码(Keycodes)、 来 自 声 音 文 件 的 声 音 数 据、 来 自 文 本 文 件 的 一 行 接 一 行 的 文 本 等 都 是 信 息 流。
图1 “流” 中 信 息 从 一 点 传 到 另 一 点
“ 流” 中 的 一 个 重 要 工 具 便 是“ 过 滤 器”(Filters)。“ 过 滤 器” 从“ 流” 的“ 上 游” 获 取 信 息， 用 某 种 方 式 过 滤 或 者 处 理 后， 发 送 到“ 流” 的“ 下 游”。“ 流” 模 型 功 能 强 大 的 关 键 是 可 以 用 一 些 非 常 简 单 的、 独 立 的“ 过 滤 器” 串 成 一 个 功 能 强 大 的 复 合“ 过 滤 器”。
图 2“过 滤 器 ”中 断 处 理 信 息 流
图 3 级 联 “ 过 滤 器 ”
Java 类 库 将“ 流” 分 为 两 类 ─ ─ 输 入 和 输 出， 这 种 区 分 在 理 论 上 是 不 必 要 的， 但 是 在 实 际 应 用 中 却 是 有 用 的。 输 入“ 流” 的 最 初 来 源 是 某 一 设 备 或 者 文 件， 它 将 数 据 从 设 备 或 文 件 输 入 到 程 序 中， 输 入“ 流” 在 处 理 中 一 般 是 要 过 滤 的。 输 出“ 流” 的 最 终 目 标 也 是 某 一 设 备 或 者 文 件， 它 将 数 据 从 程 序 输 出 到 设 备 或 文 件 中， 输 入“ 流” 在 处 理 中 一 般 也 是 要 过 滤 的。
有 两 个 原 因 使 我 们 将Java 类 库 中 的“ 流” 类 应 用 到 垃 圾 电 子 邮 件 问 题 的 解 决 方 案 中：
可 以 很 容 易 地 将 电 子 邮 件 看 做 是 一 个 接 一 个 字 符、 一 行 接 一 行 进 入 到 计 算 机 的。
当 电 子 邮 件 进 入 计 算 机 时， 我 们 要 一 个 接 一 个 字 符、 一 行 接 一 行 地 检 查 是 否 与 我 们 指 定 的 模 板 匹 配。
兵 工 厂 ─ ─“ 流” 类 详 细 介 绍
Java 1.1 说 明 书 中 描 述 了 两 种 基 本 相 同 的 输 入 和 输 出 类 集， 一 种 是 面 向 字 节 的， 另 一 种 是 面 向 字 符 的。 面 向 字 节“ 流” 类 与 在Java 1.0.2 中 实 现 的 只 有 微 小 的 差 别， 而 面 向 字 符“ 流” 类 是 在Java 1.1 版 本 中 最 新 实 现 的。
本 文 中 我 们 讨 论 面 向 字 节 的“ 流” 类， 这 样 做 有 两 个 原 因。 首 先， 对 那 些 没 有 使 用Java 1.1 的 人 也 可 以 利 用 这 份 材 料； 其 次， 我 们 可 以 指 出Java 1.0.2 中 类 库 中 出 现、 在Java 1.1 中 已 经 修 正 的 一 些 错 误。
上 面 已 经 提 过，“ 流” 可 以 分 为 两 类： 输 入“ 流” 和 输 出“ 流”。 在Java 中， 所 有 面 向 字 节 的 输 入“ 流” 类 都 是 抽 象 类InputStream 的 子 类，InputStream 定 义 了 所 有 输 入“ 流” 类 必 须 提 供 的 一 套 基 本 方 法(Mothods)。 同 样， 所 有 面 向 字 节 的 输 出“ 流” 类 都 是 抽 象 类OutputStream 的 子 类，OutputStream 定 义 了 所 有 输 出“ 流” 类 必 须 提 供 的 一 套 基 本 方 法(Mothods)。
通 用 输 入“ 流” 类 方 法
以 下 是 对 所 有 输 入“ 流” 通 用 的 方 法， 每 个 方 法 说 明 之 后 列 出 了 方 法 能 执 行 的 任 务。
public int read() throws IOException
从 输 入“ 流” 读 一 个 字 节 并 且 返 回 此 字 节。
如 果 已 经 到 了 输 入“ 流” 的 结 尾， 则 返 回-1。
如 果 必 要， 阻 塞( 或 等 待) 直 到 数 据 可 用。
当 读 操 作 时 发 生 错 误， 则 抛 出IOException 异 常。
public int read(byte [] rgb) throws IOException
从 输 入“ 流” 读 一 字 节 序 列 并 且 置 于 指 定 的 数 组 中。
返 回 所 读 的 字 节 数。
如 果 已 经 到 了 输 入“ 流” 的 结 尾， 则 返 回-1。
如 果 必 要， 阻 塞( 或 等 待) 直 到 数 据 可 用。
当 读 操 作 时 发 生 错 误， 则 抛 出IOException 异 常。
public int read(byte [] rgb, int nOff, int nLen) throws IOException
从 输 入“ 流” 读 一 指 定 长 度 的 字 节 序 列 并 且 置 于 指 定 的 数 组 中 指 定 偏 移 上。
返 回 所 读 的 字 节 数。
如 果 已 经 到 了 输 入“ 流” 的 结 尾， 则 返 回-1。
如 果 必 要， 阻 塞( 或 等 待) 直 到 数 据 可 用。
当 读 操 作 时 发 生 错 误， 则 抛 出IOException 异 常。
public long skip(long n) throws IOException
跳 过 指 定 的 字 节 数。
返 回 跳 过 的 字 节 数。
如 果 已 经 到 了 输 入“ 流” 的 结 尾， 则 返 回-1。
当 操 作 时 发 生 错 误， 则 抛 出IOException 异 常。
public int available() throws IOException
返 回 可 以 从 输 入“ 流” 中 读 取 的 字 节 数， 而 不 产 生 读 操 作 阻 塞。
当 操 作 时 发 生 错 误， 则 抛 出IOException 异 常。
public void close() throws IOException
关 闭 输 入“ 流”， 释 放 所 有 与 此 输 入“ 流” 有 关 的 资 源( 例 如 操 作 系 统 文 件 句 柄)。
当 操 作 时 发 生 错 误， 则 抛 出IOException 异 常。
public void mark(int nReadLimit)
在 输 入“ 流” 中 标 识 当 前 位 置， 以 后 当 调 用reset() 时， 输 入“ 流” 将 重 新 定 位 在 此 位 置 上。
指 定 在 标 识 无 效 之 前， 标 识 之 后 能 读 取 的 字 节 数。
public void reset() throws IOException
将 输 入“ 流” 重 新 定 位 在 最 近 标 识 的 位 置 上。
如 果“ 流” 没 有 标 识， 或 者 标 识 已 经 无 效， 则 抛 出IOException 异 常。
public boolean markSupported()
显 示 此 输 入“ 流” 是 否 支 持mark 和reset 操 作。
通 用 输 出“ 流” 类 方 法
以 下 是 对 所 有 输 出“ 流” 通 用 的 方 法， 与 前 一 部 分 一 样， 每 个 方 法 说 明 之 后 列 出 了 方 法 能 执 行 的 任 务。
public void write(byte b) throws IOException
将 一 个 字 节 写 入 输 出“ 流”。
阻 塞( 或 等 待) 直 到 数 据 真 正 写 入。
当 写 操 作 时 发 生 错 误， 则 抛 出IOException 异 常。
public void write(byte [] rgb) throws IOException
将 一 个 字 节 序 列 写 入 输 出“ 流”。
阻 塞( 或 等 待) 直 到 数 据 真 正 写 入。
当 写 操 作 时 发 生 错 误， 则 抛 出IOException 异 常。
public void write(byte [] rgb, int nOff, int nLen) throws IOException
将 一 个 指 定 长 度 的 字 节 序 列 从 指 定 的 偏 移 量 开 始 写 入 输 出“ 流”。
阻 塞( 或 等 待) 直 到 数 据 真 正 写 入。
当 写 操 作 时 发 生 错 误， 则 抛 出IOException 异 常。
public void flush() throws IOException
“ 冲 洗” 输 出“ 流”， 立 即 写 所 有 的 缓 冲 数 据。
当 操 作 时 发 生 错 误， 则 抛 出IOException 异 常。
public void close() throws IOException
关 闭 输 出“ 流”， 释 放 所 有 与 此 输 出“ 流” 有 关 的 资 源( 例 如 操 作 系 统 文 件 句 柄)。
当 操 作 时 发 生 错 误， 则 抛 出IOException 异 常。
攻 击 计 划
本 文 的 代 码 有 三 种 形 式， 这 是 因 为： 在Java 1.0.2 中 字 节 到 字 符 的 转 换 有 重 要 的 瑕 疵( 使 语 言 对Unicode 的 支 持 无 实 质 用 处)， 为 了 支 持 国 际 化， 这 个 瑕 疵 在Java 1.1 中 得 到 了 修 正。 结 果 是 产 生 两 套 几 乎 相 同 的API， 仅 仅 在 提 供 给 字 节 到 字 符 的 转 换 的 方 法 有 所 区 别。 为 了 给 所 有 人 提 供 可 工 作 的 代 码， 以 及 显 示API 是 如 何 改 变 的， 我 们 用 三 个 包 提 供 代 码， 必 要 时 可 以 下 载 所 有 三 个 包 做 比 较， 也 可 以 下 载 适 合 你 平 台 的 包。
第 一 个 包 运 行 在Java 1.0.2， 有tar 文 件 和zip 文 件。
第 二 个 包 运 行 在Java 1.1， 也 有tar 文 件 和zip 文 件。
第 三 个 包 同 时 运 行 在Java 1.0.2 和Java 1.1， 这 个 包 没 有 使 用API 中 冲 突 的 部 分， 它 自 己 完 成 工 作， 你 如 果 对 可 移 植 性 更 感 兴 趣， 可 以 以tar 文 件 或 者zip 文 件 下 载 此 包。 本 文 的 代 码 不 是 以 小 程 序(Applets) 的 方 式 运 行， 所 以 你 需 要Java Development Kit 或 者 类 似 的 命 令 行 环 境。
首 先 在 你 的 系 统 中 用 正 确 的 方 法 解 开 下 载 的 文 件， 然 后 在 命 令 行 下 按 照 如 下 命 令 执 行Java Runtime：% java Main [keyword] [keyword] ． ． ． [email file]。 你 可 以 在 命 令 行 中 指 定 任 意 多 的 关 键 字(Keywords)。 程 序 对 每 个 关 键 字 建 立 一 个“ 过 滤 器”， 然 后 将 它 们 一 起 连 接 入 一 个“ 流”。 当 输 入 以 标 准 输 入 进 入 时， 程 序 从 标 准 输 入 中 读 取 数 据， 通 过“ 流” 传 送 这 些 数 据， 写 入 标 准 输 出 中。 如 果 有 一 个“ 过 滤 器” 检 测 到 一 个 关 键 字， 就 会 产 生 一 个 异 常， 以 结 束 程 序。 这 种 解 决 方 案 很 简 单， 但 是 非 常 有 用 而 且 高 效。
|
|
|
