当前页面: 开发资料首页 → Java 专题 → Java在Client/Server网络中的应用
Java在Client/Server网络中的应用
摘要: Java在Client/Server网络中的应用
---- 随 着Java 语 言 的 日 益 流 行， 特 别 是Java 与Internet Web 的 密 切 结 合， 使 它 在 全 球 取 得 了 巨 大 的 成 功。Java 语 言 以 其 独 立 于 平 台、 面 向 对 象、 分 布 式、 多 线 索 及 完 善 的 安 全 机 制 等 特 色， 成 为 现 代 信 息 系 统 建 设 中 的 良 好 的 开 发 平 台 和 运 行 环 境。
一、Java 网 络 应 用 模 型
---- 和Internet 上 的 许 多 环 境 一 样， 完 整 的Java 应 用 环 境 实 际 上 也 是 一 个 客 户 机/ 服 务 器 环 境， 更 确 切 地 说 是 浏 览 器/ 服 务 器 模 型（ 即Browser/Server 模 型， 简 称Web 模 型）。 但 与 传 统 的 客 户 机/ 服 务 器(C/S) 的 二 层 结 构 不 同， 应 用Java 的Web 模 型 是 由 三 层 结 构 组 成 的。 传 统 的C/S 结 构 通 过 消 息 传 递 机 制， 由 客 户 端 发 出 请 求 给 服 务 器， 服 务 器 进 行 相 应 处 理 后 经 传 递 机 制 送 回 客 户 端。 而 在Web 模 型 中， 服 务 器 一 端 被 分 解 成 两 部 分： 一 部 分 是 应 用 服 务 器(Web 服 务 器)， 另 一 部 分 是 数 据 库 服 务 器。
Java 网 络 应 用 模 型
---- 针 对 分 布 式 计 算 环 境，Java 通 过 其 网 络 类 库 提 供 了 良 好 的 支 持。 对 数 据 分 布，Java 提 供 了 一 个URL(Uniform Resource Locator) 对 象， 利 用 此 对 象 可 打 开 并 访 问 网 络 上 的 对 象， 其 访 问 方 式 与 访 问 本 地 文 件 系 统 几 乎 完 全 相 同。 对 操 作 分 布，Java 的 客 户 机/ 服 务 器 模 式 可 以 把 运 算 从 服 务 器 分 散 到 客 户 一 端（ 服 务 器 负 责 提 供 查 询 结 果， 客 户 机 负 责 组 织 结 果 的 显 示）， 从 而 提 高 整 个 系 统 的 执 行 效 率， 增 加 动 态 可 扩 充 性。Java 网 络 类 库 是Java 语 言 为 适 应Internet 环 境 而 进 行 的 扩 展。 另 外， 为 适 应Internet 的 不 断 发 展，Java 还 提 供 了 动 态 扩 充 协 议， 以 不 断 扩 充Java 网 络 类 库。
---- Java 的 网 络 类 库 支 持 多 种Internet 协 议， 包 括Telnet, FTP 和HTTP(WWW)， 与 此 相 对 应 的Java 网 络 类 库 的 子 类 库 为：
Java.net
Java.net.ftp
Java.net.www.content
Java.net.www.html
Java.net.www.http
---- 这 些 子 类 库 各 自 容 纳 了 可 用 于 处 理Internet 协 议 的 类 和 方 法。 其 中，java.net 用 于 处 理 一 些 基 本 的 网 络 功 能， 包 括 远 程 登 录(Telnet)；java.net.ftp 用 于 处 理ftp 协 议；java.net.www.content 用 于 处 理WWW 页 面 内 容；java.net.www.html 和java.net.www.http 则 分 别 提 供 了 对HTML 语 言 和HTTP 协 议 的 支 持。
二、 客 户 机/ 服 务 器 环 境 下 的Java 应 用 程 序
---- 客 户 机/ 服 务 器 在 分 布 处 理 过 程 中， 使 用 基 于 连 接 的 网 络 通 信 模 式。 该 通 信 模 式 首 先 在 客 户 机 和 服 务 器 之 间 定 义 一 套 通 信 协 议， 并 创 建 一Socket 类， 利 用 这 个 类 建 立 一 条 可 靠 的 链 接； 然 后， 客 户 机/ 服 务 器 再 在 这 条 链 接 上 可 靠 地 传 输 数 据。 客 户 机 发 出 请 求， 服 务 器 监 听 来 自 客 户 机 的 请 求， 并 为 客 户 机 提 供 响 应 服 务。 这 就 是 典 型 的" 请?-- 应 答" 模 式。 下 面 是 客 户?/ 服 务 器 的 一 个 典 型 运 作 过 程：
---- 2 ． 服 务 器 监 听 相 应 端 口 的 输 入；
---- 3* 客 户 机 发 出 一 个 请 求；
---- 5 ． 服 务 器 接 收 到 此 请 求；
---- 6 ． 服 务 器 处 理 这 个 请 求， 并 把 结 果 返 回 给 客 户 机；
---- 7 ． 重 复 上 述 过 程， 直 至 完 成 一 次 会 话 过 程。
---- 按 照 以 上 过 程， 我 们 使 用Java 语 言 编 写 一 个 分 别 针 对 服 务 器 和 客 户 机 的 应 用 程 序（Application）。 该 程 序 在 服 务 器 上 时， 程 序 负 责 监 听 客 户 机 请 求， 为 每 个 客 户 机 请 求 建 立Socket 连 接， 从 而 为 客 户 机 提 供 服 务。 本 程 序 提 供 的 服 务 为： 读 取 来 自 客 户 机 的 一 行 文 本， 反 转 该 文 本， 并 把 它 发 回 给 客 户 机。
---- 通 过 该 程 序 实 例 我 们 看 到， 使 用Java 语 言 设 计C/S 程 序 时 需 要 注 意 以 下 几 点：
---- （1）、 服 务 器 应 使 用ServerSocket 类 来 处 理 客 户 机 的 连 接 请 求。 当 客 户 机 连 接 到 服 务 器 所 监 听 的 端 口 时，ServerSocket 将 分 配 一 新 的Socket 对 象。 这 个 新 的Socket 对 象 将 连 接 到 一 些 新 端 口， 负 责 处 理 与 之 相 对 应 客 户 机 的 通 信。 然 后， 服 务 器 继 续 监 听ServerSocket， 处 理 新 的 客 户 机 连 接。
---- Socket 和ServerSocket 是Java 网 络 类 库 提 供 的 两 个 类。
---- （2）、 服 务 器 使 用 了 多 线 程 机 制。Server 对 象 本 身 就 是 一 个 线 程， 它 的run() 方 法 是 一 个 无 限 循 环， 用 以 监 听 来 自 客 户 机 的 连 接。 每 当 有 一 个 新 的 客 户 机 连 接 时，ServerSocket 就 会 创 建 一 个 新 的Socket 类 实 例， 同 时 服 务 器 也 将 创 建 一 新 线 程， 即 一 个Connection 对 象， 以 处 理 基 于Socket 的 通 信。 与 客 户 机 的 所 有 通 信 均 由 这 个Connection 对 象 处 理。Connection 的 构 造 函 数 将 初 始 化 基 于Socket 对 象 的 通 信 流， 并 启 动 线 程 的 运 行。 与 客 户 机 的 通 信 以 及 服 务 的 提 供， 均 由Connection 对 象 处 理。
---- （3）、 客 户 机 首 先 创 建 一Socket 对 象， 用 以 与 服 务 器 通 信。 之 后 需 创 建 两 个 对 象：DataInputStream 和PrintStream， 前 者 用 以 从Socket 的InputStream 输 入 流 中 读 取 数 据， 后 者 则 用 于 往Socket 的OutputStream 中 写 数 据。 最 后， 客 户 机 程 序 从 标 准 输 入（ 如： 控 制 台） 中 读 取 数 据， 并 把 这 些 数 据 写 到 服 务 器， 在 从 服 务 器 读 取 应 答 消 息， 然 后 大 这 些 应 答 消 息 写 到 到 准 输 出。
---- 以 下 本 别 为 服 务 器 和 客 户 机 端 的 源 程 序 清 单。 本 程 序 在NT 4.0 网 络 环 境（TCP/IP） 下 使 用JDK1.1 调 试 通 过。
---- 2 ． 编 写 服 务 器 类Java 程 序
// Server.java
import java.io.*;
import java.net.*;
public class Server extends Thread
{
public final static int Default_Port=6543;
protectd int port;
protectd ServerSockrt listen_socket;
// 定 义 出 错 例 程： 如 果 出 现 异 常 错 误， 退 出 程 序。
Public static void fail(Exception e, String msg)
{
System.err.println(msg + ": " + e);
System.exit(1);
}
// 定 义 并 启 动 服 务 器 的Socket 例 程，
监 听 客 户 机 的 连 接 请 求。
public Server(int port)
{
if(port == 0) port = Default_Port;
this.port = port;
try
{
listen_socket = new ServerSocket(port);
}
catch(IOException e) fail(e, "Exception creating server socket");
System.out.println("Server: listening on port" + port);
This.start();
}
---- /* 下 面 为 服 务 器 监 听 线 程 的 主 程 序。 该 线 程 一 直 循 环 执 行， 监 听 并 接 受 客 户 机 发 出 的 连 接 请 求。 对 每 一 个 连 接， 均 产 生 一 个 连 接 对 象 与 之 对 应， 通 过Socket 通 道 进 行 通 信。
*/
public void run()
{
try
{
while(true)
{
Socket client_socket = listen_socket.accept();
Connection c = new Connection(client_socket);
}
}
catch(IOException e) fail(e,"Exception while listening for connections")
}
// 启 动 服 务 器 主 程 序
public static void main(String args[])
{
int port = 0;
if (args.length == 1)
{
try port = Integer.parseInt(args[0]);
catch(NumberFormatException e) port = 0;
}
new Server(port);
}// End of the main
}// End of Server class
// 以 下 定 义 了Connection 类， 它 是 用 来 处 理
与 客 户 机 的 所 有 通 信 的 线 程。
class Connection extends Thread
{
protected Socket client;
protected DataInputStream in;
protected PrintStream out;
// 初 始 化 通 信 流 并 启 动 线 程
public Connection(Socket client_socket)
{
client = client_socket;
try
{
in = new DataInputStream(client.getinputStream());
out = new PrintStream(client.getOutputStream());
}
catch(IOException e)
{
try client.close();
catch(IOException e2);
System.err.println("Exception while getting socket streram: " + e);
Return;
}
this.start;
}// End of Connection method
// 服 务 例 程： 读 出 一 行 文 本； 反 转 文 本； 返 回 文 本。
public void run()
{
String line;
StringBuffer revline;
int len;
try
{
for(;;)
{
// Read a line
line = in.readline();
if(line == null) break;
// Reverse the line
len = line.length();
revline = new StringBuffer(len);
for(int i = len-1; i >=0; i--)
revline.insert(len-1-I;line.charAt(i));
// Write out the reverse line
out.println(revline);
}
catch(IOException e);
finally try client.close();
catch(IOException e2);
}// End of run method
}// End of Connection class
3* 编 写 客 户 机 类Java 程 序
// Client.java
importjava.io.*;
importjava.net.*;
public class Client extends
{
public static final int Default_Port = 6543;
// 定 义 出 错 例 程
public static final void usage()
{
System.out.println("Usage: Java Client <> [<>]");
System.exit(0);
}
public static void main(String args[])
{
int port = Default_Port;
Socket s = null;
// 解 析 端 口 参 数
if ((args.length != 1)&&(args.length != 2 )) usage();
if (args.length == 1)
port = Default_Port;
else
{
try port = Integer.parseInt(args[1]);
catch(NumberFormaatException e) usage();
}
try{
// 产 生 一 个Socket ，
通 过 指 定 的 端 口 与 主 机 通 信。
s = new Socket(args[0], port);
// 产 生 用 于 发 出 和 接 收 的 文 本 字 符 流
DataInputStream sin = new DataInputStream(s.getInputStream());
PrintStream sout = new DataInputStream(s.getInputStream());
// 从 控 制 台 读 入 字 符 流
DataInputStream in = new DataInputStream(System.in);
// 返 回 连 接 的 地 址 和 端 口
System.out.println("Connected to"+s.getInetAddress()+":"+ s.getPort());
String line;
For(;;)
{
// 显 示 提 示 符
System.out.print(" >");
System.out.flush();
// 读 入 控 制 台 输 入 的 一 行 字 符
line = in.readline();
if (line == null) break;
// 将 接 收 的 文 本 行 送 至 服 务 器
sout.println(line);
// 从 服 务 器 接 收 一 行 字 符
line = sin.readline();
// Check if connection is closed(i.e. for EOF)
if(line == null)
{
System.out.println("Connection closed by server.");
Break;
}
// 在 控 制 台 上 显 示 接 收 的 字 符
System.out.println(line);
}// End of for loop
}// End of try
catch(IOException e ) System.err.println(e);
// Always be sure to close the socket
finally
{
try if(s != null) s.close();
catch(IOException e2);
}
}// End of main
}// End of Client
---- 运 行 该 客 户 机 程 序 时， 必 须 以 服 务 器 主 机 名 作 为 第 一 个 参 数， 服 务 器 端 口 号 为 第 二 个 参 数， 其 中 服 务 器 端 口 号 可 缺 省。
↑返回目录
前一篇: JAVA开发工具之英雄篇
后一篇: 如何用JAVA来实现“生产者―消费者”问题