由於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)
{
}
}
}
}
運行這段程序將得到下面的輸出：
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程序。
