JAVA网络编程

最新推荐文章于 2024-10-01 18:51:18 发布
最新推荐文章于 2024-10-01 18:51:18 发布
阅读量147 收藏
点赞数
文章标签： java 网络 udp
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45715182/article/details/121062040
版权

网络编程之BIO、NIO、AIO

文章目录


一、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();
            }
        }
    }
}

三、NIO

1. Buffer

使用一个 Buffer 完成文件读取、写入

        FileInputStream fileInputStream = new FileInputStream(new File("C:\\Users\\jie2602\\Desktop\\img\\123.txt"));
        FileOutputStream fileOutputStream = new FileOutputStream("C:\\Users\\jie2602\\Desktop\\img\\888.txt");
        FileChannel channelInput = fileInputStream.getChannel();
        FileChannel channelOutput = fileOutputStream.getChannel();
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        //循环读取
        while (true){
            byteBuffer.clear(); //清空 buffer
            int read = channelInput.read(byteBuffer);
            if (read == -1) { //表示读完
                break;
            }
            byteBuffer.put("，我要把这些加在后面.....".getBytes(StandardCharsets.UTF_8));
            byteBuffer.flip();
            channelOutput.write(byteBuffer);
        }
        fileOutputStream.close();
        fileInputStream.close();

直接抛异常，没有try

MappedByteBuffer 可让文件直接在内存（堆外内存）修改,操作系统不需要拷贝一次

内存映射文件方式（nio包），利用底层操作系统，即把文件映射到内存后再操作，省去了频繁磁盘io，更快更高级

        RandomAccessFile randomAccessFile = new RandomAccessFile("C:\\Users\\jie2602\\Desktop\\img\\999.txt", "rw");
        FileChannel channel = randomAccessFile.getChannel();
        //表示只处理文件的前6个字节
        MappedByteBuffer mappedByteBuffer = channel.map(FileChannel.MapMode.READ_WRITE, 0, 6);
        //一个汉字三个字节
        mappedByteBuffer.put("这".getBytes(StandardCharsets.UTF_8));
        mappedByteBuffer.put("是".getBytes(StandardCharsets.UTF_8));
        randomAccessFile.close();

修改前

在这里插入图片描述
修改后
在这里插入图片描述

2. Channel

使用FileChannel输出数据到文件

        FileChannel channel = null;
        FileOutputStream fileOutputStream = null;
        String str = "这是一个利用NIO 的netty study";
        try {
            //输出
            fileOutputStream = new FileOutputStream("C:\\Users\\jie2602\\Desktop\\img\\123.txt");
            channel = fileOutputStream.getChannel();
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            //将数据放入byteBuffer
            byteBuffer.put(str.getBytes(StandardCharsets.UTF_8));
            byteBuffer.flip();//反转后可以写出，反转前只能写入
            channel.write(byteBuffer);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(null != channel) channel.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                if(null != fileOutputStream) fileOutputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

使用FileChanne读取数据到控制台

        FileInputStream fileInputStream = null;
        FileChannel channel = null;
        try {
            File file = new File("C:\\Users\\jie2602\\Desktop\\img\\123.txt");
            fileInputStream = new FileInputStream(file);
            channel = fileInputStream.getChannel();
            ByteBuffer byteBuffer = ByteBuffer.allocate((int) file.length());
            //将通道的数据读入到 Buffer
            channel.read(byteBuffer);
            //将 byteBuffer 的字节数据转成 String
            System.out.println(new String(byteBuffer.array()));
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            try {
                if(null != channel) channel.close();
                if(null != fileInputStream) fileInputStream.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

3. Selector

使用NIO做聊天室
使用NIO做 服务端

public class GroupChatServer {

    private Selector selector;
    private ServerSocketChannel serverSocketChannel;

    //GroupChatServer构造器
    public GroupChatServer() {
        try {
            Selector selector = Selector.open();
            //监听Channel
            ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
            // ip+端口
            InetSocketAddress inetSocketAddress = new InetSocketAddress(6666);
            //将创建的服务端绑定（ip+端口）
            serverSocketChannel.socket().bind(inetSocketAddress);
            //设置非阻塞模式
            serverSocketChannel.configureBlocking(false);
            //将该 serverSocketChannel 注册到 selector，selector监听socketChannel只对接收事件感兴趣
            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
            this.selector =selector;
            this.serverSocketChannel = serverSocketChannel;
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void listen() {
        try {
            //循环处理
            while (true) {
                int sum = selector.select(1000);//阻塞等待1秒
                if(sum > 0){
                    //有事件处理
                    // 遍历得到 selectionKey 集合
                    Set<SelectionKey> selectionKeys = selector.selectedKeys();
                    if(null != selectionKeys && selectionKeys.size() > 0){
                        Iterator<SelectionKey> keyIterator = selectionKeys.iterator();
                        while (keyIterator.hasNext()){
                            //取出 selectionkey
                            SelectionKey selectionKey = keyIterator.next();
                            //监听到 accept
                            if(selectionKey.isAcceptable()){
                                //类似于得到客户端
                                SocketChannel socketChannel = serverSocketChannel.accept();
                                socketChannel.configureBlocking(false);//设置非阻塞
                                //将该 socketChannel 注册到 seletor，selector监听socketChannel只对读事件感兴趣
                                socketChannel.register(selector,SelectionKey.OP_READ);
                                //提示
                                System.out.println(socketChannel.getRemoteAddress() + " 上线 ");
                            }
                            //通道发送read事件，即通道是可读的状态
                            if (selectionKey.isReadable()) {
                                // 处理读(专门写方法..)
                                readData(selectionKey);
                            }
                            //当前的 keyIterator 删除，多线程下防止重复处理。
                            keyIterator.remove();
                        }
                    }
                } else {
                    //无事件处理...
                    //continue;
                    //或者做其他事情...
                    //System.out.println("GroupChatServer 无事件处理...");
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //发生异常处理....
        }
    }

    //读取客户端消息
    public void readData(SelectionKey selectionKey) {
        SocketChannel socketChannel = null;
        try {
            socketChannel = (SocketChannel)selectionKey.channel();
            //创建 buffer
            ByteBuffer buffer = ByteBuffer.allocate(1024);
            int count = socketChannel.read(buffer);
            //根据 count 的值做处理
            if(count > 0){
                //把缓存区的数据转成字符串
                String msg = new String(buffer.array()).trim();
                //输出该消息
                System.out.println("form客户端:" + msg);
                //向其它的客户端转发消息(去掉自己),专门写一个方法来处理
                sendInfoToOtherClients(msg, socketChannel);
            }
        } catch (IOException e) {
            try {
                System.out.println(socketChannel.getRemoteAddress() + "离线了..");
                //取消注册
                selectionKey.cancel();
                //关闭通道
                socketChannel.close();
            } catch (IOException e2) {
                e2.printStackTrace();
            }
        }
    }

    public void sendInfoToOtherClients(String msg, SocketChannel self) throws IOException {
        System.out.println("服务器转发消息中...");
        //遍历所有注册到 selector 上的 SocketChannel,并排除 self
        for (SelectionKey selectionKey : selector.keys()) {
            //通过 key 取出对应的 SocketChannel
            Channel targetChannel = selectionKey.channel();
            //排除自己
            if (targetChannel instanceof SocketChannel && targetChannel != self) {
                //转型
                SocketChannel dest = (SocketChannel) targetChannel;
                //将 msg 存储到 buffer
                ByteBuffer buffer = ByteBuffer.wrap(msg.getBytes());
                //将 buffer 的数据写入通道
                dest.write(buffer);
            }
        }
    }

    public static void main(String[] args) {
        GroupChatServer groupChatServer = new GroupChatServer();
        groupChatServer.listen();
    }
}
使用NIO做 客户端 ,创建多个客户端形成聊天室 
public class GroupChatClient {

    //定义相关的属性
    private final String HOST = "127.0.0.1";//服务器的ip
    private final int PORT = 6666;//服务器端口
    private Selector selector;
    private SocketChannel socketChannel;
    private String username;

    public GroupChatClient() {
        try {
            Selector selector = Selector.open();
            //连接服务器
            SocketAddress socketAddress = new InetSocketAddress(HOST, PORT);
            SocketChannel socketChannel = SocketChannel.open(socketAddress);
            //设置非阻塞
            socketChannel.configureBlocking(false);
            //将 channel 注册到selector,selector只对读取事件感兴趣
            socketChannel.register(selector, SelectionKey.OP_READ);
            //得到 username
            username = socketChannel.getLocalAddress().toString().substring(1);
            System.out.println(username + " is ok...");
            this.selector = selector;
            this.socketChannel = socketChannel;
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //向服务器发送消息
    public void sendInfo(String info) {
        info = username + " 说：" + info;
        try {
            socketChannel.write(ByteBuffer.wrap(info.getBytes()));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //读取从服务器端回复的消息
    private void readInfo() {
        try {
            int sum = selector.select(1000);
            //因为 selector监听socketChannel的读事件，sum > 0 就存在可读消息
            if (sum > 0) {
                Set<SelectionKey> selectionKeys = selector.selectedKeys();
                if (null != selectionKeys && selectionKeys.size() > 0) {
                    Iterator<SelectionKey> keyIterator = selectionKeys.iterator();
                    while (keyIterator.hasNext()) {
                        SelectionKey selectionKey = keyIterator.next();
                        if(selectionKey.isReadable()){
                            //得到有数据读取的通道
                            SocketChannel socketChannel = (SocketChannel)selectionKey.channel();
                            //得到一个 Buffer
                            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
                            socketChannel.read(byteBuffer);
                            //把读到的缓冲区的数据转成字符串
                            String msg = new String(byteBuffer.array());
                            System.out.println(msg.trim());
                        }
                    }
                    keyIterator.remove(); //删除当前的 selectionKey,防止重复操作
                }
            } else {
                //System.out.println("没有可以用的通道...");
            }

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

    public static void main(String[] args) throws InterruptedException {
        //启动我们客户端
        GroupChatClient chatClient = new GroupChatClient();
        Thread.currentThread().sleep(6000);
        //启动一个线程,每个 3 秒，读取从服务器发送数据
        new Thread() {
            public void run() {
                while (true) {
                    chatClient.readInfo();
                    try {
                        Thread.currentThread().sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }.start();

        //发送数据给服务器端
        Scanner scanner = new Scanner(System.in);
        while (scanner.hasNextLine()) {
            String s = scanner.nextLine();
            chatClient.sendInfo(s);
        }
    }
}

四、Netty

使用了NIO原理

总结

总结的话

其他

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

为梦想吃藤藤菜
关注
java中网络编程之socket编程（四）--udp同步非阻塞式
panda-star的博客
01-09 2530
一、简介 同tcp通信一样，udp通信也有同步非阻塞式，可同时发送和读取数据，与多个客户端通信。二、关键类1、java.net.DatagramSocket 报文socket，同udp阻塞通信一样。2、java.nio.channels.DatagramChannel 报文通道，可同时与多个客户端通信，常用方法有： DatagramChannel.open()：静态方法，生成DatagramCha...
java网络编程
03-03
在本资料中，《Java网络编程》第三版提供了深入浅出的讲解，旨在帮助开发者提升对这一领域的理解。 1. **基础概念**： - **网络模型**：Java网络编程基于OSI七层模型和TCP/IP四层模型。理解这些模型有助于理解网络...
Java NIO 选择器 Selector
weixin_45032957的博客
03-29 135
选择器使用步骤 4.1 获取选择器 与通道和缓冲区的获取类似，选择器的获取也是通过静态工厂方法 open() 来得到的。 Selector selector = Selector.open(); // 获取一个选择器实例 4.2 获取可选择通道 能够被选择器监控的通道必须实现了 SelectableChannel 接口，并且需要将通道配置成非阻塞模式，否则后续的注册步骤会抛出 IllegalBlockingModeException。 SocketChannel socketChannel = Soc
Java NIO之Selector的使用
零度的博客专栏
07-08 5179
看了下关于Selector的使用方法，官方的说法是一个“多路复用器”，从我自己的角度来讲就感觉像一个服务总线，负责统一各个处理程序的消息注册，统一接收客户端或服务器消息信息，再分发给不同的事件处理程序进行处理。整个流程就一个注册->接收->处理的过程，从使用者的角度来讲，直接使用这些api还不太成熟，毕竟这些api都太底层了，需要了解太多的技术细节，也不太适合像我这种不了解C语言网络编程的人。这周
java使用selector NIO socket
SUN_FEI的博客
10-23 782
使用NIO的socket时 一直测试状态是 服务端返回的信息所有客户端都能收到  一直很郁闷  后来发现 是服务端代码的问题 在接受到一个channel时 我的代码里是拿select又做了一次遍历 对所有的客户端进行返回  下面给一个代码示例  服务端 public class HansServer { // 用于检测所有Channel状态的Selector priv
Java网络编程
u011005040的博客
11-01 2017
Java网络编程
Java 网络编程
编程开发相关技术学习
12-06 2934
在计算机网络要做到井井有条的交换数据，就必须遵守一些事先约定好的规则，比如交换数据的格式、是否需要发送一个应答信息。这些规则被称为网络协议。TCP/IP：传输控制/网络协议，是面向连接的协议，发送数据前要先建立连接(发送方和接收方的成对的两个之间必须建 立连接)，TCP提供可靠的服务，也就是说，通过TCP连接传输的数据不会丢失，没有重复，并且按顺序到达。UDP：UDP它是属于TCP/IP协议族中的一种。是无连接的协议，发送数据前不需要建立连接，是没有可靠性的协议。因为不需要建立连接所以可以在在网络上以任何可
java——网络编程
Why_does_it_work的博客
06-24 4528
它的核心组件包括IoFilter、IoSession、IoHandler等，可以帮助开发人员构建可靠的、高效的网络应用程序。Spring Web是Spring框架中的一个模块，提供了一系列用于构建Web应用程序的工具和框架，包括MVC、REST等。它提供了丰富的API和插件，可以帮助开发人员实现高性能、可靠的Web应用程序。通过这些规则和标准，不同的计算机和设备可以相互通信，并保证数据的正确传输和接收。Java中的NIO编程是一种基于事件驱动的编程模式，相对于传统的IO编程，它具有更高的性能和扩展性。
Java网络编程案例教程习题参考答案 .pdf
12-28
Java网络编程案例教程习题参考答案 Java_network_programming是Java编程语言中一个基础组件，用于实现网络通信。以下是Java网络编程案例教程习题参考答案中涉及到的知识点： 1. Socket编程：Socket是Java网络编程...
Java网络编程期末考试复习题库+答案
07-06
Java网络编程是计算机科学中的一个重要领域，特别是在软件开发中，它涉及到如何通过网络进行数据传输和通信。在Java中，网络编程主要依赖于Java的Socket编程、ServerSocket、URL类以及NIO（非阻塞I/O）等核心API。这...
Java网络编程/Java网络编程实例
11-29
Java网络编程是Java开发中的重要领域，它涵盖了网络应用程序的设计、实现和调试。在这个主题下，我们可以探讨多个关键知识点： 1. **Java Socket编程**：Java的Socket类提供了基于TCP/IP协议的网络通信能力。通过...
Java NIO实例-DatagramChannel实现UDP协议传输
热门推荐
foart的专栏
08-13 3万+
自己的学习笔记（日后发现问题会修正） 在网上找到一些关于udp协议，学习后写了一个实例用于学习之用。 根据别人的经验，总结了以下几点内容： TCP与UDP效率比较：     TCP协议适用于对效率要求相对低，但对准确性要求相对高的场景下，或者是有一种连接概念的场景下；而UDP协议适用于对效率要求相对高，对准确性要求相对低的场景。 TCP与UDP应用场景：     TCP
JavaScript ArrayBuffer的读写与类型转换
最新发布
白瑕 的博客
10-01 427
所有视图的基本单位是ArrayBuffer, ArrayBuffer中只存储二进制格式的数据.ArrayBuffer不可直接读写, 必须通过视图(比如DataView)暴露的API.
spring-boot 整合 mybatis
m0_72168501的博客
09-29 531
spring boot 整合 mybatis
Java内存布局
阿呆的专栏
10-01 793
64位 JVM 不启用指针压缩时：Object Header 大小是16字节。64位 JVM 启用指针压缩时（默认）：Object Header 大小是12字节。32位 JVM：Object Header 大小是8字节。JVM在默认情况下启用指针压缩，但如果堆内存超过32GB，就会禁用指针压缩。32GB是压缩指针的最大寻址范围。超过32GB的堆内存中，压缩指针带来的性能提升并不显著，而且需要解压指针反而可能增加开销。
【开源免费】基于SpringBoot+Vue.JS校园资料分享平台（JAVA毕业设计）
customer08的博客
09-30 1253
校园资料分享平台是一个B/S模式系统，采用Spring Boot框架作为开发技术，MYSQL数据库设计开发，充分保证系统的稳定性。系统具有界面清晰、操作简单，功能齐全的特点，使得校园资料分享平台管理工作系统化、规范化。
C#基础：掌握控制流语句，构建灵活的程序逻辑
学习和分享
09-28 329
在C#中，控制流语句是用来控制程序执行流程的重要部分。它们允许你根据条件执行不同的代码块，或者重复执行某些代码块直到满足特定条件。
Java网络编程深入解析
"Java网络编程电子书涵盖了从基础的Internet地址概念到高级的非阻塞I/O技术，全面解析了Java进行网络通信的各种方法和策略。本书深入浅出地介绍了如何利用Java API处理网络地址、建立连接、发送与接收数据，以及实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值