RFC868--时间协议客户机与服务器的实现
本例根据RFC 868网络时间协议分别建立了时间协议的客户机和服务器。
1.TimeProtocolConstants类提供提供两个常量静态值：TCP_PORT指定协议的标准TCP端口；EPOCH_OFFSET_MILLIS储存1970年1月1日0时0分0秒(JVM纪年起始时间) 与 1900年1月1日0时0分0秒(协议纪年起始时间) 时间差的毫秒数。
2.TimeProtocolClient类为客户端。getSecondsSinceEpoch方法通过BufferedInputStream的read方法获得协议中的四个时间字节，并当前计算协议时间的毫秒数；getDate方法计算JVM获得时间的毫秒数，并将毫秒数转换为当前的日期和时间；
3.TimeProtocolServer类为服务端。在构造函数中首先建立ServerSocket，启动线程后阻塞；在run里面调用ServerSocket的accept方法生成socket，并调用process方法处理socket；process方法利BufferedOutputStream的write方法将协议中的四个时间字节传给客户机。
测试：
1.客户端单独测试：
I:/jdk/bin>java com.wrox.timeprotocol.TimeProtocolClient time-a.nist.gov
Fri Aug 24 17:06:33 CST 2007
2.服务端与客户端一起测试：
I:/jdk/bin>java com.wrox.timeprotocol.TimeProtocolServer
Fri Aug 24 23:33:20 CST 2007: TimeProtocolServer(37): info: Accepting connection
s on TCP port 37...
Fri Aug 24 23:33:51 CST 2007: TimeProtocolServer(37): info: Connection from loca
lhost:2145
I:/jdk/bin>java com.wrox.timeprotocol.TimeProtocolClient localhost 37
Fri Aug 24 23:33:50 CST 2007
//TimeProtocolConstants
package com.wrox.timeprotocol;
import java.util.Calendar;
// Defines constants used by clients and servers implementing
// the time protocol defined in RFC 868.
public class TimeProtocolConstants
{
// Prevent instantiation
private TimeProtocolConstants() {}
// The time protocol TCP port defined in RFC 868
public static final int TCP_PORT = 37;
// The number of milliseconds between the RFC 868 epoch,
// January 1st 1900, 0:0:0 UTC, and the Java epoch, January
// 1st 1970, 0:0:0 UTC
public static final long EPOCH_OFFSET_MILLIS;
// Computes the epoch offset
static
{
Calendar calendar = Calendar.getInstance(java.util.TimeZone.getTimeZone("UTC"));
calendar.set(1900, Calendar.JANUARY, 1, 0, 0, 0);
EPOCH_OFFSET_MILLIS = Math.abs(calendar.getTime().getTime());
}
}
//TimeProtocolClient
package com.wrox.timeprotocol;
import java.io.*;
import java.net.*;
import java.util.*;
// Static methods for quering time servers using the RFC-868.
public class TimeProtocolClient
{
// Prevent instantiation
private TimeProtocolClient() {}
// Returns the no. of seconds since Jan 1, 1900 00:00:00 UTC
// obtained by the time server on the given address and port.
/**
* @param address - the address of the time server
* @param port - the port of the time server
*
* @exception IOException - if a communications error occured while
* contacting the time server.
* @exception SecurityException - if the client is not permitted to
* connect to the remote server
*/
public static long getSecondsSinceEpoch(InetAddress address, int port) throws SecurityException, IOException
{
Socket socket = new Socket(address, port);
long result;
try
{
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream(),
socket.getReceiveBufferSize());
int b1 = bis.read();
int b2 = bis.read();
int b3 = bis.read();
int b4 = bis.read();
if ((b1 | b2 | b3 | b3) < 0)
{
throw new EOFException("Server didn’t provide a 4-byte value");
}
result = (((long) b1) << 24) + (b2 << 16) + (b3 << 8) + b4;
}
finally
{
socket.close();
}
return (result);
}
/** Returns a Date object encapsulating the current time.
* @param address - the address of the time server
* @param port - the port of the time server
* @exception IOException - error occured while contacting the server
* @exception SecurityException - if the client is not permitted
*/
public static Date getDate(InetAddress address, int port) throws SecurityException, IOException
{
long millis = ((long) getSecondsSinceEpoch(address, port)) * 1000;
return (new Date(millis - TimeProtocolConstants.EPOCH_OFFSET_MILLIS));
}
/** Command-line invocation of the time protocol client. Expects the
* time server host name or address, plus an optional port number used
* to override the default port. The retrieved time is printed to
* standard out adjusted to the local timezone.
*/
public static void main(String[] args)
{
// Parse command-line arguments
InetAddress address = null;
int port = TimeProtocolConstants.TCP_PORT;
try
{
if (args.length == 1)
{
address = InetAddress.getByName(args[0]);
}
else if (args.length == 2)
{
address = InetAddress.getByName(args[0]);
port = Integer.parseInt(args[1]);
}
else
{
System.err.println("Usage: TimeProtocolClient <server> {<port>}");
System.exit(1);
}
}
catch (UnknownHostException e)
{
System.err.println("TimeProtocolClient: unknown host "
+ e.getMessage());
System.exit(1);
}
catch (NumberFormatException e)
{
System.err.println("TimeProtocolClient: Invalid port: "
+ e.getMessage());
System.exit(1);
}
catch (SecurityException e)
{
System.err.println("TimeProtocolClient: permission to resolve host name denied: " + e.getMessage());
System.exit(1);
}
// Retrieve current time from server and print to standard out
try
{
System.out.println(getDate(address, port));
}
catch (java.net.UnknownHostException e)
{
System.err.println("Could not resolve host name: "
+ e.getMessage());
System.exit(1);
}
catch (java.net.ConnectException e)
{
System.err.println("TimeProtocolClient: the time protocol server is not running on "
+ address.getHostName() + ": " + port);
System.exit(1);
}
catch (java.io.IOException e)
{
System.err.println("A communications error occured: "
+ e.getClass().getName() + ": " + e.getMessage());
System.exit(1);
}
catch (SecurityException e)
{
System.err.println("The security manager refused permission to connect to the remote TCP service: "
+ e.getMessage());
System.exit(1);
}
}
}
//TimeProtocolServer
package com.wrox.timeprotocol;
import java.io.*;
import java.net.*;
import java.util.*;
// A network time server supporting RFC-868 over TCP.
public class TimeProtocolServer extends Thread
{
// The TCP server socket used to receive connection requests
protected ServerSocket server = null;
// Used to control termination of the accept thread
protected boolean isActive = true;
// Server socket timeout milliseconds
protected int socketTimeoutMillis = 5000;
/** Construct a new time protocol server
* @see TimeProtocolConstants#TCP_PORT
* @exception IOException - TCP socket could not be created
* @exception SecurityException - permission to create a TCP
* socket is denied.
*/
public TimeProtocolServer() throws SecurityException, IOException
{
this(TimeProtocolConstants.TCP_PORT);
}
/** Constructs a new time server bound to the specified port.
* @param port - the TCP port number used to bind
* @exception IOException - TCP socket could not be created
* @exception SecurityException - permission to create a TCP
* socket is denied.
*/
public TimeProtocolServer(int port) throws SecurityException, IOException
{
server = new ServerSocket(port);
server.setSoTimeout(socketTimeoutMillis);
start();
}
// Logs an error to System.err
public void error(String message, Throwable e)
{
System.err.println(new Date() + ": TimeProtocolServer("
+ server.getLocalPort() + "): error: " + message
+ ": " + e.getClass().getName() + ": " + e.getMessage());
}
// Logs an information message to System.out
public void info(String message)
{
System.out.println(new Date() + ": TimeProtocolServer("
+ server.getLocalPort() + "): info: " + message);
}
// Requests asynchronous termination of the server
public void terminate()
{
isActive = false;
}
/** Processes a new connection. Typically in a separate thread but since we don't read from the client
and comp is trivial, processing can be performed in the same thread.
*/
protected void process(Socket socket)
{
if (socket == null)
{
return;
}
try
{
info("Connection from " + socket.getInetAddress().getHostName()
+ ":" + socket.getPort());
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream(), socket.getSendBufferSize());
// number of seconds since January 1, 1900 0:0:0 UTC
long resultSecs = ((System.currentTimeMillis() +
TimeProtocolConstants.EPOCH_OFFSET_MILLIS) / 1000);
bos.write((int) ((resultSecs >> 24) & 0xFF));
bos.write((int) ((resultSecs >> 16) & 0xFF));
bos.write((int) ((resultSecs >> 8) & 0xFF));
bos.write((int) (resultSecs & 0xFF));
bos.close(); // very important; needed to flush stream contents
}
catch (java.io.IOException e)
{
error("I/O Error", e);
}
finally
{
try
{
socket.close();
}
catch (IOException e)
{
error("Error closing socket", e);
}
}
}
// Server socket accept thread; loops until termination
public void run()
{
info("Accepting connections on TCP port " +
server.getLocalPort() + "...");
while (isActive)
{
Socket socket = null;
try
{
socket = server.accept();
process(socket);
}
catch (java.io.InterruptedIOException e)
{
// Used to periodically check for termination
}
catch (IOException e)
{
error("I/O Error", e);
}
catch (SecurityException e)
{
error("Unauthorized client attemptting to connect", e);
}
catch (Throwable e)
{
error("Unexpected exception", e);
}
}
try
{
server.close();
}
catch (IOException e)
{
error("Error closing server socket", e);
}
info("server thread terminated");
}
/**
* Prints usage to System.err and exits with error code 1
*/
public static void usageExit()
{
System.err.println("Usage: TimeProtocolServer {<port>}");
System.exit(1);
}
// Create a time protocol server. Invocation accepts a single optional port number.
public static void main(String[] args)
{
// Parse command-line arguments
int port = 0;
if (args.length == 0)
{
port = TimeProtocolConstants.TCP_PORT;
}
else if (args.length == 1)
{
try
{
port = Integer.parseInt(args[0]);
}
catch (NumberFormatException e)
{
usageExit();
}
}
else
{
usageExit();
}
// Start time protocol server
TimeProtocolServer server = null;
try
{
server = new TimeProtocolServer(port);
}
catch (java.net.BindException e)
{
System.err.println("The server could not bind to port "
+ port + " (may already be used): " + e.getMessage());
if (port < 1024)
{
System.err.println("Warning: On user-level "
+ "processes cannot bind to ports below 1024");
}
}
catch (java.io.IOException e)
{
System.err.println(e.getMessage());
}
catch (SecurityException e)
{
System.err.println("Permission to bind to port " + port
+ " denied (check security policy): " + e.getMessage());
}
if (server == null) { System.exit(1); }
// Join the server thread, don't have anything else to do
try
{
server.join();
}
catch (InterruptedException e)
{
System.err.println("Error while joined to server thread: "
+ e.getMessage());
System.exit(1);
}
}
}
本文来自CSDN博客，转载请标明出处：http://blog.csdn.net/doncai/archive/2007/08/26/1759503.aspx