NIO 编程示例代码
server
package nio;
import java.io.*;
import java.net.*;
import java.nio.*;
import java.nio.channels.*;
import java.util.*;
public class Server implements Runnable {
// The port we will listen on
private int port;
// A pre-allocated buffer for encrypting data
private final ByteBuffer buffer = ByteBuffer.allocate(16384);
public Server(int port) {
this.port = port;
new Thread(this).start();
}
public void run() {
try {
// Instead of creating a ServerSocket,
// create a ServerSocketChannel
ServerSocketChannel ssc = ServerSocketChannel.open();
// Set it to non-blocking, so we can use select
ssc.configureBlocking(false);
// Get the Socket connected to this channel, and bind it
// to the listening port
ServerSocket ss = ssc.socket();
InetSocketAddress isa = new InetSocketAddress(port);
ss.bind(isa);
// Create a new Selector for selecting
Selector selector = Selector.open();
// Register the ServerSocketChannel, so we can
// listen for incoming connections
ssc.register(selector, SelectionKey.OP_ACCEPT);
System.out.println("Listening on port " + port);
while (true) {
// See if we've had any activity -- either
// an incoming connection, or incoming data on an
// existing connection
int num = selector.select();
// If we don't have any activity, loop around and wait
// again
if (num == 0) {
continue;
}
// Get the keys corresponding to the activity
// that has been detected, and process them
// one by one
Set keys = selector.selectedKeys();
Iterator it = keys.iterator();
while (it.hasNext()) {
// Get a key representing one of bits of I/O
// activity
SelectionKey key = (SelectionKey) it.next();
// What kind of activity is it?
if ((key.readyOps() & SelectionKey.OP_ACCEPT) == SelectionKey.OP_ACCEPT) {
System.out.println("acc");
// It's an incoming connection.
// Register this socket with the Selector
// so we can listen for input on it
Socket s = ss.accept();
System.out.println("Got connection from " + s);
// Make sure to make it non-blocking, so we can
// use a selector on it.
SocketChannel sc = s.getChannel();
sc.configureBlocking(false);
// Register it with the selector, for reading
sc.register(selector, SelectionKey.OP_READ);
} else if ((key.readyOps() & SelectionKey.OP_READ) == SelectionKey.OP_READ) {
SocketChannel sc = null;
try {
// It's incoming data on a connection, so
// process it
sc = (SocketChannel) key.channel();
boolean ok = processInput(sc);
// If the connection is dead, then remove it
// from the selector and close it
if (!ok) {
key.cancel();
Socket s = null;
try {
s = sc.socket();
s.close();
} catch (IOException ie) {
System.err.println("Error closing socket "
+ s + ": " + ie);
}
}
} catch (IOException ie) {
// On exception, remove this channel from the
// selector
key.cancel();
try {
sc.close();
} catch (IOException ie2) {
System.out.println(ie2);
}
System.out.println("Closed " + sc);
}
}
}
// We remove the selected keys, because we've dealt
// with them.
keys.clear();
}
} catch (IOException ie) {
System.err.println(ie);
}
}
// Do some cheesy encryption on the incoming data,
// and send it back out
private boolean processInput(SocketChannel sc) throws IOException {
buffer.clear();
sc.read(buffer);
buffer.flip();
// If no data, close the connection
if (buffer.limit() == 0) {
return false;
}
// Simple rot-13 encryption
for (int i = 0; i < buffer.limit(); ++i) {
byte b = buffer.get(i);
if ((b >= 'a' && b <= 'm') || (b >= 'A' && b <= 'M')) {
b += 13;
} else if ((b >= 'n' && b <= 'z') || (b >= 'N' && b <= 'Z')) {
b -= 13;
}
buffer.put(i, b);
}
sc.write(buffer);
System.out.println("Processed " + buffer.limit() + " from " + sc);
return true;
}
static public void main(String args[]) throws Exception {
int port = Integer.parseInt(args[0]);
new Server(port);
}
}
client NIO方式实现
/**
*
*/
package com.topsci.xxxxxx.provider.service;
import java.io.IOException;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import java.nio.CharBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.nio.charset.CharsetDecoder;
import java.nio.charset.CharsetEncoder;
import java.util.Random;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
*
*/
class TestClient {
private static Logger logger = LoggerFactory.getLogger(TestClient.class);//slf4j logging
// The host:port combination to connect to
private InetAddress hostAddress;
private int port;
private SocketChannel client;
protected Charset charset = Charset.forName("UTF-8");
protected CharsetEncoder charsetEncoder = charset.newEncoder();
protected CharsetDecoder charsetDecoder = charset.newDecoder();
public TestClient(InetAddress hostAddress, int port) throws IOException{
this.hostAddress = hostAddress;
this.port = port;
// Create a non-blocking socket channel
client = SocketChannel.open();
// client.configureBlocking(false);
// client.register(this.selector, SelectionKey.OP_CONNECT);
// Kick off connection establishment
client.connect(new InetSocketAddress(this.hostAddress, this.port));
}
private void request(String msg){
ByteBuffer buffer = ByteBuffer.allocate(100);
try {
this.client.write(charsetEncoder.encode(CharBuffer.wrap(msg)));
int len = this.client.read(buffer);
if (len > 0){
buffer.flip();
logger.info(charsetDecoder.decode(buffer).toString());
}
} catch (IOException e) {
e.printStackTrace();
}
}
/**
* @param args
* @throws IOException
* @throws UnknownHostException
*/
public static void main(String[] args) throws UnknownHostException, IOException {
// TODO Auto-generated method stub
TestClient client = new TestClient(InetAddress.getByName("localhost"), 9999);
Random random = new Random();
for (int i = 5; i > 0; i--){
String req = "请求编号 " + random.nextInt();
client.request(req);
try {
Thread.sleep(5000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
client 传统方式实现
package nio;
import java.io.*;
import java.net.*;
import java.util.*;
public class Client implements Runnable {
private String host;
private int port;
// Bounds on how much we write per cycle
private static final int minWriteSize = 1024;
private static final int maxWriteSize = 65536;
// Bounds on how long we wait between cycles
private static final int minPause = (int) (0.05 * 1000);
private static final int maxPause = (int) (0.5 * 1000);
// Random number generator
Random rand = new Random();
public Client(String host, int port, int numThreads) {
this.host = host;
this.port = port;
for (int i = 0; i < numThreads; ++i) {
new Thread(this).start();
}
}
public void run() {
byte buffer[] = new byte[maxWriteSize];
try {
Socket s = new Socket(host, port);
InputStream in = s.getInputStream();
OutputStream out = s.getOutputStream();
while (true) {
int numToWrite = minWriteSize
+ (int) (rand.nextDouble() * (maxWriteSize - minWriteSize));
for (int i = 0; i < numToWrite; ++i) {
buffer[i] = (byte) rand.nextInt(256);
}
out.write(buffer, 0, numToWrite);
int sofar = 0;
while (sofar < numToWrite) {
sofar += in.read(buffer, sofar, numToWrite - sofar);
}
System.out.println(Thread.currentThread() + " wrote "
+ numToWrite);
int pause = minPause
+ (int) (rand.nextDouble() * (maxPause - minPause));
try {
Thread.sleep(pause);
} catch (InterruptedException ie) {
}
}
} catch (IOException ie) {
ie.printStackTrace();
}
}
static public void main(String args[]) throws Exception {
String host = args[0];
int port = Integer.parseInt(args[1]);
int numThreads = Integer.parseInt(args[2]);
new Client(host, port, numThreads);
}
}