packagecom.tz.simple.udp;
importjava.io.IOException;
importjava.net.DatagramPacket;
importjava.net.DatagramSocket;
importjava.net.InetAddress;
importjava.util.Date;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;
importcom.tz.uitl.Common;
/**
* UDP程序测试<BR>
* 时间服务器,采用线程池处理<BR>
*
* @author LJZ
*
*/
public class UDPTimeServer extends Thread {
final private static int DAYTIME_PORT = 7897;
private DatagramSocket serverSocket = null;
private final int THREAD_POOL = 10;
private ExecutorService threadPool = null;
public UDPTimeServer() throws IOException {
serverSocket = newDatagramSocket(DAYTIME_PORT);
threadPool =Executors.newFixedThreadPool(THREAD_POOL);
System.out.println("时间服务器启动成功,监听端口 [" + DAYTIME_PORT + "]线程池 ["
+ THREAD_POOL +"].");
}
public void run() {
while (true) {
try {
byte buffer[] = new byte[256];
DatagramPacket packet = newDatagramPacket(buffer,
buffer.length);
serverSocket.receive(packet);
System.out.println("收到客户端 [" +packet.getSocketAddress()
+ " ]请求.");
threadPool.execute(newHandlerThread(packet));
} catch (Exception e){
}
}
}
/**
* 客户端数据处理线程
*
* @author LJZ
*
*/
private class HandlerThread extends Thread {
private DatagramPacket packet = null;
public HandlerThread(DatagramPacket p) {
packet = p;
}
public void run() {
try {
String date = newDate().toString();
byte[] buffer =date.getBytes();
InetAddress address =packet.getAddress();
int port =packet.getPort();
packet = new DatagramPacket(buffer,buffer.length, address,
port);
serverSocket.send(packet);
System.out.println("线程 [" + getName() + "] 向客户端["
+packet.getSocketAddress() + " ]发送数据 ["
+Common.byte2string(buffer, false) + "].");
} catch (Exception e){
} finally {
packet = null;
}
}
}
public static void main(String args[]) throws IOException {
new UDPTimeServer().start();
}
}
packagecom.tz.simple.tcp;
importjava.net.InetSocketAddress;
importjava.nio.ByteBuffer;
importjava.nio.channels.SelectionKey;
importjava.nio.channels.Selector;
importjava.nio.channels.ServerSocketChannel;
importjava.nio.channels.SocketChannel;
importjava.util.Iterator;
importjava.util.Set;
importcom.tz.uitl.Common;
/**
* 非阻塞式TCP时间服务器
*
* @author LJZ
*
*/
public class NIOTCPTimeServer extends Thread{
private int listenPort = 8485;
private ServerSocketChannel serverSocket = null;
private Selector acceptSelector = null;
private Selector readSelector = null;
public NIOTCPTimeServer(int p) {
listenPort = p;
try {
acceptSelector =Selector.open();
readSelector =Selector.open();
serverSocket =ServerSocketChannel.open();
serverSocket.configureBlocking(false);
serverSocket.socket().bind(newInetSocketAddress(listenPort));
serverSocket.register(acceptSelector,SelectionKey.OP_ACCEPT);
System.out.println("服务器启动成功, 监听端口 [" + listenPort +"]");
newReadThread().start();
} catch (Exception e) {
System.out.println("服务器启动失败!");
e.printStackTrace();
}
}
/**
* 主线程方法只处理客户端连接<BR>
*同时将连接客户端事件响应注册为读响应<BR>
*/
public void run() {
while (true) {
try {
if(acceptSelector.select(100) > 0) {
Set keys =acceptSelector.selectedKeys();
for (Iterator i =keys.iterator(); i.hasNext();) {
SelectionKey key= (SelectionKey) i.next();
i.remove();
ServerSocketChannel readyChannel = (ServerSocketChannel) key
.channel();
SocketChannelincomingChannel = readyChannel.accept();
System.out.println("客户端 ["
+incomingChannel.socket()
.getRemoteSocketAddress()
+ "]与服务器建立连接.");
incomingChannel.configureBlocking(false);
incomingChannel.register(readSelector,
SelectionKey.OP_READ, new StringBuffer());
}
}
} catch (Exception e){
e.printStackTrace();
}
}
}
/**
* 客户端数据读线程
*
* @author LJZ
*
*/
private class ReadThread extends Thread {
public void run() {
int keysReady =-1;
while (true) {
try {
/**
*检查客户数据事件,超时1秒
*/
keysReady =readSelector.select(100);
if (keysReady > 0){
Set readyKeys =readSelector.selectedKeys();
for (Iterator i =readyKeys.iterator(); i.hasNext();) {
SelectionKeykey = (SelectionKey) i.next();
SocketChannelincomingChannel = (SocketChannel) key
.channel();
readData(incomingChannel);
i.remove();
}
}
} catch (Exception e){
e.printStackTrace();
}
}
}
private void readData(SocketChannel channel) {
try {
ByteBuffer readBuf =ByteBuffer.allocate(1024);
if (channel.read(readBuf)> 0) {
readBuf.flip();
System.out.println("收到客户端 ["
+channel.socket().getRemoteSocketAddress()
+ "] 数据[" + Common.decode(readBuf) + "].");
}
} catch (Exception e){
try {
channel.close();
System.out.println("关闭一个终端.");
} catch (Exception ex){
}
}
}
}
/**
* @param args
*/
public static void main(String[] args) {
try {
newNIOTCPTimeServer(8485).start();
} catch (Exception e) {
}
}
}
packagecom.tz.simple.tcp;
importjava.io.IOException;
importjava.net.InetSocketAddress;
importjava.nio.ByteBuffer;
importjava.nio.channels.SelectionKey;
importjava.nio.channels.Selector;
importjava.nio.channels.SocketChannel;
importjava.util.Iterator;
importjava.util.Set;
importcom.tz.uitl.Common;
/**
* 非阻塞式TCP时间服务器<BR>
* 同并发接收服务器数据<BR>
*
* @author LJZ
*
*/
public class TCPTimeClient extends Thread{
private int serverPort = 8485;
private SocketChannel client = null;
private Selector readSelector = null;
public TCPTimeClient(int p) throws IOException {
serverPort = p;
readSelector =Selector.open();
client =SocketChannel.open();
client.connect(newInetSocketAddress("192.168.100.38", serverPort));
client.configureBlocking(false);
client.register(readSelector,SelectionKey.OP_READ);
System.out.println("客户端[" + client.socket().getLocalSocketAddress() + "] 启动, 连接服务器["
+client.socket().getRemoteSocketAddress() + "]");
}
public void run() {
while (true) {
try {
int keysReady =readSelector.select(100);
if (keysReady > 0){
Set readyKeys =readSelector.selectedKeys();
for (Iterator i =readyKeys.iterator(); i.hasNext();) {
i.next();
i.remove();
int nbytes = -1;
ByteBufferbyteBuffer = ByteBuffer.allocate(1024);
nbytes =client.read(byteBuffer);
if (nbytes > 0){
byteBuffer.flip();
System.out.println("收到服务器传来数据 "
+Common.decode(byteBuffer));
}
}
}
client.write(ByteBuffer.wrap("abcd".getBytes()));
} catch (Exception e){
e.printStackTrace();
} finally {
}
}
}
/**
* @param args
*/
public static void main(String[] args) {
try {
newTCPTimeClient(8485).start();
} catch (Exception e) {
e.printStackTrace();
}
}
}