BIO/NIO java实现

BIO

import java.io.*;
import java.net.Socket;
//BIO
public class TCPcliet {
    private int port=10000;
    private String IP="192.168.1.7";
    private Socket csocket;
    private int count;
    public TCPcliet() {
        try {
            csocket =new Socket(IP,port);
            start(csocket);
        }catch (IOException e){
            e.printStackTrace();
        }
    }

    public void start(Socket socket){

            try {
                while (true){
                    //发送文件
                    BufferedReader getbr=
                            new BufferedReader(new InputStreamReader(socket.getInputStream()));
                    BufferedReader cbr=
                            new BufferedReader(new FileReader("D://filetest//readw.txt"));
                    BufferedWriter cbw=
                            new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
                    String str;
                    while ((str=cbr.readLine())!=null){
                        cbw.write(str);
                        cbw.newLine();
                        cbw.flush();
                    }
//                    socket.shutdownOutput();
//                    shutdownbuff();
                    cbw.write("老子输入完了，你别阻塞等我了");//这句话为啥没发过去
                    cbw.newLine();//!!!!这里必须要换行不然对面不知道你这一行没完一直在等你这一行！！！！！
                    cbw.flush();
                    System.out.println("222");//
                    //得到反馈
                    String getstr=getbr.readLine();
                    System.out.println("收到回复为"+getstr);
                    System.out.println("收到回复之后");
                }

            }catch (IOException e){
                e.printStackTrace();
            }finally {
                try {
                    socket.close();
                }catch (IOException a){
                    a.printStackTrace();
                }
            }


    }
    public void shutdownbuff(){
        try {
            BufferedWriter stopbuff=
                    new BufferedWriter(new OutputStreamWriter(csocket.getOutputStream()));
            stopbuff.write("老子输入完了，你别阻塞等我了");
            stopbuff.flush();
        }catch (IOException e){
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        new TCPcliet();
    }
}

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class TCPserver {
    private int port=10000;
    private ServerSocket serverSocket;

    //BIO
    public TCPserver() {
        try {
            serverSocket =new ServerSocket(port);

        }catch (IOException e){
            e.printStackTrace();
        }
    }

    public void startserver(){

            try {
                while (true){
                    System.out.println("服务器请求连接");
                    Socket socket = serverSocket.accept();//这里如果一直未接受会发生阻塞
                    //创建线程
                    Thread thread = new Thread(new ThreadServer(socket));
                    thread.start();
                    thread.run();
                }



            } catch (IOException e) {
                e.printStackTrace();
            }/*finally {
                try {
                    serverSocket.close();
                }catch (IOException a){
                    a.printStackTrace();
                }

            }
*/

    }

    public static void main(String[] args) throws IOException{
        new TCPserver().startserver();
    }
}

NIO

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.util.Iterator;
import java.util.Set;

public class NIOClientTh {
    private int port=10085;
    private String IP="192.168.1.7";
    private Selector selector;
    private SocketChannel socketChannel;
    private ByteBuffer sendbuffer;
    private ByteBuffer recbuffer;
    public NIOClientTh() {
        try {
            sendbuffer=ByteBuffer.allocate(4096);
            recbuffer=ByteBuffer.allocate(4096);
            selector= Selector.open();
            socketChannel=SocketChannel.open();
            socketChannel.configureBlocking(false);
            socketChannel.connect(new InetSocketAddress(IP,port));
            socketChannel.register(selector,SelectionKey.OP_CONNECT);

            listen();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void listen() throws IOException {
        while (true){
            int selects=selector.select();
            if (selects>0){
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                if (selectionKeys.isEmpty()){
                    continue;
                }
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                if (iterator.hasNext()){
                    SelectionKey nextkey = iterator.next();
                    handle(nextkey);
                    iterator.remove();
                }
            }
        }
        
    }

    private void handle(SelectionKey selectionKey)  {

        try {
            if (selectionKey.isConnectable() && selectionKey.isValid()){
                //判断是连接事件，并注册读事件
                SocketChannel channel = (SocketChannel)selectionKey.channel();
                if (channel.isConnectionPending()){
                    channel.finishConnect();
                    sendbuffer.clear();
                    sendbuffer.put("你好".getBytes());
                    sendbuffer.flip();
                    channel.write(sendbuffer);
                    channel.register(selector,SelectionKey.OP_READ);
                }
            }else if (selectionKey.isReadable() && selectionKey.isValid()){
                //是读事件，接受服务器反馈的信息
                SocketChannel channel=(SocketChannel)selectionKey.channel();
                recbuffer.clear();
                int read=channel.read(recbuffer);
                if (read>0){
                    String str=new String(recbuffer.array(),0,read);
                    System.out.println(str);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }

    public static void main(String[] args) {
        new NIOClientTh();
    }
}

import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.util.Iterator;
import java.util.Set;

public class NIOServerTh {
    private int port=10085;
    private Selector selector;
    private ByteBuffer sendbuffer;
    private ByteBuffer recbuffer;
    private ServerSocketChannel serverSocketChannel;
    public NIOServerTh() {
        try {
            recbuffer=ByteBuffer.allocate(4096);
            sendbuffer=ByteBuffer.allocate(4096);
            serverSocketChannel = ServerSocketChannel.open();
            selector=Selector.open();
            serverSocketChannel.bind(new InetSocketAddress(port));
            serverSocketChannel.configureBlocking(false);
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            listen();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    private void listen() throws IOException {
        while (true){
            int selects = selector.select();
            if (selects>0){
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                if (selectionKeys.isEmpty()){
                    continue;
                }
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()){
                    SelectionKey keynext = iterator.next();
                    handle(keynext);
                    iterator.remove();
                }
            }
        }
    }

    private void handle(SelectionKey selectionKey) throws IOException {
        SocketChannel socketChannel=null;
        try {
            if (selectionKey.isAcceptable() && selectionKey.isValid()) {
                System.out.println("连接");
                socketChannel = serverSocketChannel.accept();
                //这里得到的是客户端服务器连接的Channel，用处是用来连接客户端和服务器用来读写，
                socketChannel.configureBlocking(false);
                socketChannel.register(selector, SelectionKey.OP_READ);
            }else if (selectionKey.isReadable() && selectionKey.isValid()){
                System.out.println("读事件");
                recbuffer.clear();
                socketChannel = (SocketChannel) selectionKey.channel();
                socketChannel.read(recbuffer);
                String str=new String(recbuffer.array());
                System.out.println(str);
                sendbuffer.clear();
                sendbuffer.put("收到了".getBytes());
                sendbuffer.flip();
                socketChannel.write(sendbuffer);
            }
        }catch (IOException e){
            if (e.getMessage().equals("远程主机强迫关闭了一个现有的连接。")){
                socketChannel.close();
            }
        }

    }

    public static void main(String[] args) {
        new NIOServerTh();
    }
}