TCP/UDP

TCP实现 实现思路

• client 客户端

1. 创建 socket 指定 发送目标
2. 获取 ouputStream()流 通过write写入数据

        Socket socket = new Socket("127.0.0.1",9999);
        socket.getOutputStream().write("满天星成".getBytes());

• Server 服务端

1. 通过 ServerSocket 的 accept 来监听端口
2. 阻塞 等待 inputStream 接收数据

        ServerSocket serverSocket = new ServerSocket(9999);
        Socket socket = serverSocket.accept();
        InputStream inputStream = socket.getInputStream();
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
        System.out.println( bufferedReader.readLine() );

UDP 实现 思路

• client 客户端

1. 通过 DatagramSocket 来建立数据报 通道
2. 准被数据 --》 DatagramPacket 来创建数据 报
3. DatagramSocket 的 send方法。发送数据报

        DatagramSocket datagramSocket = new DatagramSocket();
        byte[] bytes = "悲天悯人".getBytes();
        DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length, InetAddress.getByName("127.0.0.1"), 9999);
        datagramSocket.send(datagramPacket);
        datagramSocket.close();

• server 服务端

1. 通过 DatagreamSocket 来监听端口
2. 创建数据报 容器，DatagramPacket
3. 通过 DataGramSocket 的 receive 方法来接收 报

      DatagramSocket datagramSocket = new DatagramSocket(9999);
        byte[] bytes = new byte[1024];
        DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length);
        datagramSocket.receive(datagramPacket);
        byte[] data = datagramPacket.getData();
        System.out.println( new String(data,0,datagramPacket.getLength()));//TODO 需要获取流中的长度

案例 一 聊天室

server 实现

package com.lfweixiao01.server;


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

/**
 * @author LFweixiao
 * @create 2022-02-21 下午6:04
 */
public class Server {
    //启动主方法
    public static void main(String[] args) {
        try {
            new Server().startServer();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void startServer() throws IOException {
        // 1.创建Selector
        Selector selector = Selector.open();
        // 2. 创建 serverSocketChannel
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        // 3.为 channel 绑定监听
        serverSocketChannel.bind(new InetSocketAddress(9999));
        // 设置非阻塞
        serverSocketChannel.configureBlocking(false);
        // 4.把channel 注册到 selector
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        System.out.println("服务器已经启动");
        // 5.循环，等待有新连接接入
        while (true) {
            // 获取 channel
            int readChannels = selector.select();
            if( readChannels == 0 )continue;
            // 获取可用的channel
            Set<SelectionKey> selectionKeySet = selector.selectedKeys();
            //遍历集合
            Iterator<SelectionKey> iterator = selectionKeySet.iterator();
            while (iterator.hasNext()) {
                SelectionKey selectionKey = iterator.next();
                //移除set集合当前 selectionKey
                iterator.remove();
                //6.根据就绪状态，调用对应方法实现具体业务操作
                //accept状态
                if( selectionKey.isAcceptable() ) acceptOperator(serverSocketChannel,selector);
                else if ( selectionKey.isReadable() ) readOperator(selector,selectionKey );
            }
        }
    }

    /**
     * 可读消息
     * @param selector  选择器
     * @param selectionKey  当前监听到的通道
     */
    private void readOperator(Selector selector, SelectionKey selectionKey) throws IOException {
        // 1.从selectionKey 获取已经 就绪的通道
        SocketChannel  socketChannel = (SocketChannel)selectionKey.channel();
        // 2. 创建byteBuffer
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        // 3. 虚幻读取客户端消息
        int readLength = socketChannel.read(byteBuffer);
        String message = "";
        if (readLength > 0) {
            //切换模式
            byteBuffer.flip();
            //读取内容
            message +=Charset.forName("UTF-8").decode(byteBuffer);
        }
        // 4.将 channel 再次注册到选择器上，监听可读状态
        socketChannel.register(selector, SelectionKey.OP_READ);
        // 5.把客户端发送消息，广播到其他客户端
        if (message.length() > 0) {
            // 广播给其他客户端
            System.out.println(message);
            castOtherClient(message, selector,socketChannel);
        }
    }

    /**TODO
     * 把 收到的消息 广播到其他客户端
     * @param message  接收到的消息
     * @param selector 选择器
     * @param socketChannel 发送消息的通道
     */
    private void castOtherClient(String message, Selector selector, SocketChannel socketChannel) throws IOException {
            // 1。获取所有已经接入的channel
        Set<SelectionKey> selectorKeySet = selector.keys();
        //2.循环 向所有channel 广播
        for (SelectionKey selectionKey : selectorKeySet) {
            //获取每个 channel
            Channel tarChannel = selectionKey.channel();
            //不需要给自己发送
            if (tarChannel instanceof SocketChannel && tarChannel != socketChannel) {
                ((SocketChannel)tarChannel).write(Charset.forName("UTF-8").encode(message));
            }

        }
    }

    /** TODO
     *  新进如的连接 注册到 selector
     * @param serverSocketChannel   服务器TCP通道
     * @param selector   选择器
     */
    private void acceptOperator(ServerSocketChannel serverSocketChannel, Selector selector) throws IOException {
        // 1.接入状态创建socketChannel    监听
        SocketChannel socketChannel = serverSocketChannel.accept();
        // 2. 设置非阻塞
        socketChannel.configureBlocking(false);
        // 3.把channel注册到 selector
        socketChannel.register(selector, SelectionKey.OP_READ);//当前连接 设置为 读取操作
        // 4.客户端回复消息
        socketChannel.write(Charset.forName("UTF-8").encode("何为人，顶天立地，藏气与身"));
    }
}

客户端 实现

package com.lfweixiao01.server.client;

import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.Iterator;
import java.util.Set;

/**
 * @author LFweixiao
 * @create 2022-02-21 下午7:04
 */
public class ClientThread01 implements Runnable {

    private Selector selector;
    public ClientThread01(Selector selector) { this.selector = selector; }

    @Override
    public void run() {

        try {
            while (true) {
                // 获取 channel 数量
                int readChannel = selector.select();
                if( readChannel == 0  ) continue;

                //获取可用的channel
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                //遍历
                Iterator<SelectionKey> iterator = selectionKeys.iterator();
                while (iterator.hasNext()) {
                    SelectionKey selectionKey = iterator.next();
                    //移除当前的 key
                    iterator.remove();
                    //可读状态
                    if (selectionKey.isReadable()) {
                        readOperator(selector,selectionKey);
                    }
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * 处理可读状态操作
     * @param selector  选择器
     * @param selectionKey
     */
    private void readOperator(Selector selector, SelectionKey selectionKey) throws IOException {
        // 1. 从selectionKey 获取已经就绪的通道
        SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
        // 2.创建 buffer
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        // 3.读取客户端消息
        int readLength = socketChannel.read(byteBuffer);
        String message = "";
        if (readLength > 0) {
            byteBuffer.flip();
            //读取内容
            message += Charset.forName("UTF-8").decode(byteBuffer);
        }
        // 4. 将channel 再次注册到选择器上，监听可读
        socketChannel.register(selector, SelectionKey.OP_READ);
        // 5.把客户端消息发送到广播
        if (message.length() > 0) {
            System.out.println(message);
        }
    }
}

package com.lfweixiao01.server.client;

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.SocketChannel;
import java.nio.charset.Charset;
import java.util.Scanner;

/**
 * @author LFweixiao
 * @create 2022-02-21 下午6:56
 */
public class Client01 {

    /**
     * 启动 客户端
     * @param name  当前用户名
     */
    public void startClient(String name) throws IOException {
        //连接服务器
        SocketChannel socketChannel = SocketChannel.open(new InetSocketAddress("127.0.0.1", 9999));
        //接收服务端消息
        Selector selector = Selector.open();
        socketChannel.configureBlocking(false);
        socketChannel.register(selector, SelectionKey.OP_READ);
        //创建线程 TODO
        new Thread( new ClientThread01(selector) ).start();

        //向服务器发送数据   此处起到阻塞
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()) {
            String message = scanner.nextLine();
            if (message.length() > 0) {
                socketChannel.write(Charset.forName("UTF-8").encode(name + ": "+message) );
            }
        }

    }

    public static void main(String[] args) {

    }
}

运行效果

public class A {
    public static void main(String[] args) {
        try {
            new Client01().startClient("联盟");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

服务器

服务器已经启动
部落: 兽人永不为奴
联盟: 你说的对

客户端A

何为人，顶天立地，藏气与身
部落: 兽人永不为奴
你说的对

客户端B

何为人，顶天立地，藏气与身
兽人永不为奴
联盟: 你说的对