当前页面: 开发资料首页 → Java 专题 → Java网络编程4
Java网络编程4
摘要: Java网络编程4
ServerSocket类
由于SSClient使用了流套接字，所以服务程序也要使用流套接字。这就要创建
一个ServerSocket对象，ServerSocket有几个构造函数，最简单的是ServerSocket
(int port)，当使用ServerSocket(int port)创建一个ServerSocket对象，port参
数传递端口号，这个端口就是服务器监听连接请求的端口，如果在这时出现错误将
抛出IOException异常对象，否则将创建ServerSocket对象并开始准备接收连接请求。
接下来服务程序进入无限循环之中，无限循环从调用ServerSocket的accept()
方法开始，在调用开始后accept()方法将导致调用线程阻塞直到连接建立。在建立
连接后accept()返回一个最近创建的Socket对象，该Socket对象绑定了客户程序的
IP地址或端口号。
由于存在单个服务程序与多个客户程序通讯的可能，所以服务程序响应客户程
序不应该花很多时间，否则客户程序在得到服务前有可能花很多时间来等待通讯的
建立，然而服务程序和客户程序的会话有可能是很长的（这与电话类似），因此为
加快对客户程序连接请求的响应，典型的方法是服务器主机运行一个后台线程，这
个后台线程处理服务程序和客户程序的通讯。
为了示范我们在上面谈到的慨念并完成SSClient程序，下面我们创建一个
SSServer程序，程序将创建一个ServerSocket对象来监听端口10000的连接请求，如
果成功服务程序将等待连接输入，开始一个线程处理连接，并响应来自客户程序的
命令。下面就是这段程序的代码：
Listing 3: SSServer.java
// SSServer.java
import java.io.*;
import java.net.*;
import java.util.*;
class SSServer {
public static void main (String [] args) throws IOException {
System.out.println ("Server starting...\n");
// Create a server socket that listens for incoming connection
// requests on port 10000.
ServerSocket server = new ServerSocket (10000);
while (true) {
// Listen for incoming connection requests from client
// programs, establish a connection, and return a Socket
// object that represents this connection.
Socket s = server.accept ();
System.out.println ("Accepting Connection...\n");
// Start a thread to handle the connection.
new ServerThread (s).start (); } } }
class ServerThread extends Thread {
private Socket s;
ServerThread (Socket s) {
this.s = s; }
public void run () {
BufferedReader br = null;
PrintWriter pw = null; try {
// Create an input stream reader that chains to the socket's
// byte-oriented input stream. The input stream reader
// converts bytes read from the socket to characters. The
// conversion is based on the platform's default character
// set.
InputStreamReader isr;
isr = new InputStreamReader (s.getInputStream ());
// Create a buffered reader that chains to the input stream
// reader. The buffered reader supplies a convenient method
// for reading entire lines of text.
br = new BufferedReader (isr);
// Create a print writer that chains to the socket's byte-
// oriented output stream. The print writer creates an
// intermediate output stream writer that converts
// characters sent to the socket to bytes. The conversion
// is based on the platform's default character set.
pw = new PrintWriter (s.getOutputStream (), true);
// Create a calendar that makes it possible to obtain date
// and time information.
Calendar c = Calendar.getInstance ();
// Because the client program may send multiple commands, a
// loop is required. Keep looping until the client either
// explicitly requests termination by sending a command
// beginning with letters BYE or implicitly requests
// termination by closing its output stream. do {
// Obtain the client program's next command.
String cmd = br.readLine ();
// Exit if client program has closed its output stream.
if (cmd == null)
break;
// Convert command to uppercase, for ease of comparison.
cmd = cmd.toUpperCase ();
// If client program sends BYE command, terminate.
if (cmd.startsWith ("BYE"))
break;
// If client program sends DATE or TIME command, return
// current date/time to the client program.
if (cmd.startsWith ("DATE") || cmd.startsWith ("TIME"))
pw.println (c.getTime ().toString ());
// If client program sends DOM (Day Of Month) command,
// return current day of month to the client program.
if (cmd.startsWith ("DOM"))
pw.println ("" + c.get (Calendar.DAY_OF_MONTH));
// If client program sends DOW (Day Of Week) command,
// return current weekday (as a string) to the client
// program.
if (cmd.startsWith ("DOW"))
switch (c.get (Calendar.DAY_OF_WEEK)) {
case Calendar.SUNDAY : pw.println ("SUNDAY");
break;
case Calendar.MONDAY : pw.println ("MONDAY"); break;
case Calendar.TUESDAY : pw.println ("TUESDAY"); break;
case Calendar.WEDNESDAY: pw.println ("WEDNESDAY");
break;
case Calendar.THURSDAY : pw.println ("THURSDAY"); break;
case Calendar.FRIDAY : pw.println ("FRIDAY"); break;
case Calendar.SATURDAY : pw.println ("SATURDAY"); }
// If client program sends DOY (Day of Year) command,
// return current day of year to the client program.
if (cmd.startsWith ("DOY"))
pw.println ("" + c.get (Calendar.DAY_OF_YEAR));
// If client program sends PAUSE command, sleep for three
// seconds.
if (cmd.startsWith ("PAUSE")) try {
Thread.sleep (3000); }
catch (InterruptedException e) { } }
while (true); {
catch (IOException e) {
System.out.println (e.toString ()); }
finally {
System.out.println ("Closing Connection...\n"); try {
if (br != null)
br.close ();
if (pw != null)
pw.close ();
if (s != null)
s.close (); }
catch (IOException e) { } } } }
运行这段程序将得到下面的输出：
Server starting...
Accepting Connection...
Closing Connection...
SSServer的源代码声明了一对类：SSServer 和ServerThread；SSServer的
main()方法创建了一个ServerSocket对象来监听端口10000上的连接请求，如果成功
, SSServer进入一个无限循环中，交替调用ServerSocket的 accept() 方法来等待
连接请求，同时启动后台线程处理连接（accept()返回的请求）。线程由
ServerThread继承的start()方法开始，并执行ServerThread的run()方法中的代码。
一旦run()方法运行，线程将创建BufferedReader, PrintWriter和 Calendar对
象并进入一个循环，这个循环由读（通过BufferedReader的 readLine()）来自客户
程序的一行文本开始，文本（命令）存储在cmd引用的string对象中，如果客户程序
过早的关闭输出流，会发生什么呢？答案是：cmd将得不到赋值。
注意必须考虑到这种情况：在服务程序正在读输入流时，客户程序关闭了输出
流，如果没有对这种情况进行处理，那么程序将产生异常。
一旦编译了SSServer的源代码，通过输入Java SSServer来运行程序，在开始运
行SSServer后，就可以运行一个或多个SSClient程序。
↑返回目录
前一篇: JAVA学习笔记之Collection
后一篇: Java网络编程3