Java网络编程底子(四) ServerSocket类操纵[Java编程]

由于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 redivsents 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)
　　　　 {
　　　　 }
　　　 }
　　 }
}

　　以上是“Java网络编程底子(四) ServerSocket类操纵[Java编程]”的内容，如果你对以上该文章内容感兴趣，你可以看看七道奇为您推荐以下文章：