JAVA网络编程

网络编程之BIO、NIO、AIO

文章目录

网络编程之BIO、NIO、AIO
一、UDP
- 1.UDP接收数据
- 2.UDP发送数据
- 3.使用UDP作为聊天接收方
- 4.使用UDP作为聊天发送方
二、TCP
- 1.TCP接收数据
- 1.TCP发送数据
- 3.使用TCP做聊天 Server
- 4.使用TCP做聊天 Client
三、Netty
总结
其他

一、UDP

UDP类似于写信，没有连接。只有对方的地址
UDP协议在java中对应的封装接口是 DatagramSocket

1.UDP接收数据

UDPServer：

        DatagramSocket socket = null;
        try {
            socket = new DatagramSocket(8888);//开放端口8888
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container, 0, container.length);
            socket.receive(packet);//接收数据报,这里会阻塞接收
            System.out.println(new String(packet.getData()).trim());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            socket.close();
        }

socket.receive(packet);
接收数据报,这里会阻塞接收。

2.UDP发送数据

UDPClient：

        DatagramSocket socket = null;
        try {
            socket = new DatagramSocket();
            InetAddress address = InetAddress.getByName("127.0.0.1");
            int port = 8888;
            String datas = "这是一个利用UDP发送数据的dome";
            //数据报 DatagramPacket(byte buf[], int offset, int length,InetAddress address, int port)
            DatagramPacket packet = new DatagramPacket(datas.getBytes(),0,datas.getBytes().length,address,port);
            socket.send(packet);//发送数据报
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            socket.close();
        }

3.使用UDP作为聊天接收方

UDPChatReceive

public class UDPChatReceive {
    public static void main(String[] args) {
        DatagramSocket socket = null;
        try {
            InetAddress address = InetAddress.getByName("127.0.0.1");
            socket = new DatagramSocket(9999, address);
            while (true){
                byte[] datas = new byte[1024];//开发中使用JSON传递数据
                DatagramPacket packet = new DatagramPacket(datas, 0, datas.length);
                socket.receive(packet);//阻塞式接收数据报
                String data = new String(packet.getData()).trim();
                System.out.println(data);
                if("886".equals(data)){
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            socket.close();
        }
    }
}

4.使用UDP作为聊天发送方

UDPChatSent

public class UDPChatSent {
    public static void main(String[] args) {
        DatagramSocket socket = null;
        try {
            socket = new DatagramSocket();
            InetAddress address = InetAddress.getByName("127.0.0.1");
            while (true) {
                BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
                String datas = reader.readLine();
                byte[] bytes = datas.getBytes();
                DatagramPacket packet = new DatagramPacket(bytes, 0, bytes.length, address, 9999);
                socket.send(packet);
                if ("886".equals(new String(packet.getData()))) {
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            socket.close();
        }
    }
}

二、TCP

TCP类似于打电话，经过三次握手、四次挥手，建立连接。
TCP协议在java中对应的是封装接口Socket嵌套字
Socket类代表一个TCP客户端套接字
ServerSocket类代表一个TCP服务端套接字

1.TCP接收数据

TCPChatServer：

public class TCPChatServer {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream inputStream = null;
        ByteArrayOutputStream baos = null;
        try {
            InetAddress address = InetAddress.getByName("127.0.0.1");
            int port = 7777;
            //创建TCP服务端  backlog：请求的传入连接队列的最大长度。
            serverSocket = new ServerSocket(port, 10, address);
            while (true) {
                socket = serverSocket.accept();//阻塞式等待TCP客户端连接
                inputStream = socket.getInputStream();//输入流读取客户端数据
                baos = new ByteArrayOutputStream();//管道流
                byte[] bytes = new byte[1024];
                int len;
                while ((len = inputStream.read(bytes)) != -1) {
                    baos.write(bytes, 0, bytes.length);
                }
                System.out.println(new String(bytes).trim());
                if ("886".equals(new String(bytes).trim())) {
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                baos.close();
                inputStream.close();
                socket.close();
                serverSocket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

1.TCP发送数据

TCPChatClient：

public class TCPChatClient {
    public static void main(String[] args) {
        Socket socket = null;
        OutputStream outputStream = null;
        try {
            InetAddress address = InetAddress.getByName("127.0.0.1");
            int port = 7777;
            //创建一个TCP客户端连接
            socket = new Socket(address, port);
            InetAddress localAddress = socket.getLocalAddress();//获取TCP客户端IP
            int localPort = socket.getLocalPort();//获取TCP客户端 端口
            InetAddress inetAddress = socket.getInetAddress();//获取TCP服务端IP
            int inetPort = socket.getPort();//获取TCP服务端 端口
            //发送消息，使用输入流
            outputStream = socket.getOutputStream();
            BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
            String data = reader.readLine();
            outputStream.write(data.getBytes());
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                outputStream.close();
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

3.使用TCP做聊天 Server

使用多线程处理多个客户端连接

public class TCPChatServerVersion2 {
    public static void main(String[] args) {
        try {
            System.out.println("开始启动Server...");
            InetAddress address = InetAddress.getByName("127.0.0.1");
            ServerSocket serverSocket = new ServerSocket(9999, 10, address);
            //考虑存在多个client，所以做多线程
            while (true) {
                Socket accept = serverSocket.accept();
                new Thread(new ServerListener(accept)).start();
                new Thread(new ServerSender(accept)).start();
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {

        }
    }
}

//服务端获取数据监听
class ServerListener implements Runnable {

    private Socket socket;

    public ServerListener(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        ObjectInputStream objectInputStream = null;
        try {
            //得到传来的数据，使用输入流
            objectInputStream = new ObjectInputStream(socket.getInputStream());
            while (true) {
                //打印发送到服务器的消息
                System.out.println(objectInputStream.readObject());
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                objectInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

//服务端发送数据
class ServerSender implements Runnable {
    private Socket socket;

    public ServerSender(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        ObjectOutputStream objectOutputStream = null;
        try {
            objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            Scanner scanner = new Scanner(System.in);
            while (true) {
                System.out.print("请输入发送的内容：");
                String sendData = scanner.nextLine();
                if (StringUtils.isNotBlank(sendData) && sendData.trim().length() > 0) {
                    JSONObject jsonObject = new JSONObject();
                    jsonObject.put("type", "chat");
                    jsonObject.put("message", sendData);
                    objectOutputStream.writeObject(jsonObject);
                    objectOutputStream.flush();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                objectOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

4.使用TCP做聊天 Client

…

public class TCPChatClientVersion2 {
    private static Socket socket;
    public static Boolean client_state = false;

    public static void main(String[] args) {
        connect();
        if (client_state) {
            System.out.println("请开始发送消息.....");
        }
    }

    //连接服务端方法
    private static void connect() {
        try {
            socket = new Socket("127.0.0.1", 9999);
            client_state = true;
            new Thread(new ClientListener(socket)).start();
            new Thread(new ClientSender(socket)).start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //重新连接
    public static void reconnect() {
        while (!client_state) {
            System.out.println("连接已断开...正在尝试重连......");
            connect();
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

class ClientListener implements Runnable {
    private Socket socket;

    public ClientListener(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        ObjectInputStream objectInputStream = null;
        try {
            //得到传来的数据，使用输入流
            objectInputStream = new ObjectInputStream(socket.getInputStream());
            while (true) {
                //打印发送到服务器的消息
                System.out.println(objectInputStream.readObject());
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            try {
                objectInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

//客户端发送数据
class ClientSender implements Runnable {
    private Socket socket;

    public ClientSender(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        ObjectOutputStream objectOutputStream = null;
        try {
            //发送到服务端的数据，使用输出流
            objectOutputStream = new ObjectOutputStream(socket.getOutputStream());
            Scanner scanner = new Scanner(System.in);
            while (true) {
                System.out.print("请输入发送的内容：");
                String sendData = scanner.nextLine();
                if (StringUtils.isNotBlank(sendData) && sendData.trim().length() > 0) {
                    JSONObject jsonObject = new JSONObject();
                    jsonObject.put("type", "chat");
                    jsonObject.put("message", sendData);
                    objectOutputStream.writeObject(jsonObject);
                    objectOutputStream.flush();
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            try {
                socket.close();
                TCPChatClientVersion2.client_state = false;
                reconnect();
            } catch (IOException ex) {
                ex.printStackTrace();
            }
        } finally {
            try {
                objectOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

三、Netty

使用了NIO原理

总结

总结的话

其他

把数据从A手机传输到B手机，底层来讲就是把数据变成电信号或者光信号
各大操作系统都用Socket来对这些操作做了屏蔽和封装
Socket在网络传输中用于唯一标识两个端点之间的链接
Socket类似于 ClienIP + ClientPort + ServerIP + ServerPort = 链接

JAVA网络编程

Java相关栏目本月热门文章