Java网络编程

最新推荐文章于 2025-06-12 16:18:56 发布

喜欢吃animal milk

最新推荐文章于 2025-06-12 16:18:56 发布

阅读量900

点赞数 25

分类专栏：网络文章标签：网络服务器智能路由器

本文链接：https://blog.youkuaiyun.com/weixin_73869209/article/details/136975679

版权

网络专栏收录该内容

4 篇文章

订阅专栏

文章目录

前言

大家好,今天给大家介绍一下网络编程

1 . TCP/IP分层体系结构

应用层：负责应用程序间沟通，如简单电子邮件传输（SMTP）、文件传输协议（FTP）、网络远程访问协议（Telnet）等。我们的网络编程主要就是针对应用层。
传输层：负责两台主机之间的数据传输。如传输控制协议 (TCP)，能够确保数据可靠的从源主机发送到目标主机。
网络层：负责地址管理和路由选择。例如在IP协议中，通过IP地址来标识一台主机，并通过路由表的方式规划出两台主机之间的数据传输的线路（路由）。路由器（Router）工作在网路层。
数据链路层：负责设备之间的数据帧的传送和识别。例如网卡设备的驱动、帧同步(就是说从网线上检测到什么信号算作新帧的开始)、冲突检测(如果检测到冲突就自动重发)、数据差错校验等工作。有以太网、令牌环网，无线LAN等标准。交换机（Switch）工作在数据链路层。
物理层：解决比特0和1的传输问题。比如现在以太网通用的网线(双绞线)、早期以太网采用的的同轴电缆(现在主要用于有线电视)、光纤，现在的wifi无线网使用电磁波等都属于物理层的概念。物理层的能力决定了最大传输速率、传输距离、抗干扰性等。集线器（Hub）工作在物理层。

2 . 网络编程

上述QQ发送消息的过程就是网络传输, 网络编程就是通过编程实现数据在网络之间的传输

网络编程，指网络上的主机，通过不同的进程，以编程的方式实现网络通信（或称为网络数据传输）

应用程序之间想要基于网络进行通信,就需要调用传输层提供的API

传输层提供的协议主要有两个, 分别是TCP和UDP

Socket套接字

概念

Socket套接字，是由系统提供用于网络通信的技术，是基于TCP/IP协议的网络通信的基本操作单元。基于Socket套接字的网络程序开发就是网络编程

分类

流套接字：使用传输层TCP协议

TCP特点

有连接

可靠传输

面向字节流

有接收缓冲区，也有发送缓冲区

大小不限

对于字节流来说，可以简单的理解为，传输数据是基于IO流，流式数据的特征就是在IO流没有关闭的情况下，是无边界的数据，可以多次发送，也可以分开多次接收。

数据报套接字：使用传输层UDP协议

UDP特点

无连接

不可靠传输

面向数据报

有接收缓冲区，无发送缓冲区

大小受限：一次最多传输64k

对于数据报来说，可以简单的理解为，传输数据是一块一块的，发送一块数据假如100个字节，必须一次发送，接收也必须一次接收100个字节，而不能分100次，每次接收1个字节。

Java数据报套接字通信模型

Java流套接字通信模型

3 . UDP数据报套接字编程

DatagramSocket 是UDP Socket，用于发送和接收UDP数据报。

DataGramPacket 该类表示数据报包

方法签名	方法说明
InetAddress getAddress()	从接收的数据报中，获取发送端主机IP地址；或从发送的数据报中，获取接收端主机IP地址
int getPort()	从接收的数据报中，获取发送端主机的端口号；或从发送的数据报中，获取接收端主机端口号
byte[] getData()	获取数据报中的数据

参考代码

客户端

kage Udp;


import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.util.Scanner;

public class udpClient {
    private DatagramSocket socket = null;
    private String serverIp;
    private int serverPort;

    public udpClient(String ip, int port) throws SocketException {
        serverIp = ip;
        serverPort = port;
        // 系统自动分配端口号
        socket = new DatagramSocket();
    }

    // 客户端读取用户输入的内容发送给服务器,服务器解析响应给客户端,客户端打印在控制台
    public void start() throws IOException {
        System.out.println("客户端启动!");
        Scanner scanner = new Scanner(System.in);
        while(true){
            System.out.println("请输入你要发送给客户端的内容: ");
            String request = scanner.next();
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),request.getBytes().length,
            InetAddress.getByName(serverIp),serverPort);
            socket.send(requestPacket);

            DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
            socket.receive(responsePacket);
            String response = new String(responsePacket.getData(),0, responsePacket.getLength());
            System.out.println(response);
        }
    }

    public static void main(String[] args) throws IOException {
        udpClient udpClient = new udpClient("127.0.0.1",8888);
        udpClient.start();
    }
}

服务器

package Udp;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

/**
 * 回显服务器
 * 客户端发什么服务器响应什么
 */
public class udpServer {
    DatagramSocket socket = null;

    public udpServer(int port) throws SocketException {
        socket = new DatagramSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动!");
        /*
        * 一个服务器要给很多客户端提供服务,同时服务器也不知道客户端什么时候来,
        * 因此我们的逻辑要写在循环中
        * */
        while(true){
            // 1.读取请求并解析
            /*
            * 参数 datagramPacket 是输出型参数
            * 传入receive时为空 receive会把datagramPacket填满 拿出时datagramPacket已经是满的了
            * */
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
            /*
            * 服务一启动就会执行到receive 如果此时没有请求 receive就会进入阻塞等待 一直等待到真正有客户端过来
            * */
            socket.receive(requestPacket);
            // 前提是客户端发送的内容是文本数据
            String request = new String(requestPacket.getData(),0, requestPacket.getLength());
            // 2.根据请求计算出响应
            String response = process(request);
            // 3.把响应写回给客户端
            /*
            * 告诉网卡要发的内容是什么,要发给谁
            * 内容: buff, 0, buff.length
            * 发给谁(ip,端口)  requestPacket.getSocketAddress()
            * */
            byte[] buff = response.getBytes();
            DatagramPacket responseSocket = new DatagramPacket(buff, 0, buff.length, requestPacket.getSocketAddress());
            socket.send(responseSocket);
        }
    }

    // 根据请求计算出响应
    private String process(String request) {
        return request;
    }


    public static void main(String[] args) throws IOException {
        udpServer udpServer = new udpServer(8888);
        udpServer.start();
    }
}

4 . TCP流套接字编程

ServerSocket API

Socket API

Socket 是客户端Socket，或服务端中接收到客户端建立连接（accept方法）的请求后，返回的服务端 Socket。不管是客户端还是服务端Socket，都是双方建立连接以后，保存的对端信息，及用来与对方收发数据的。

构造方法

TCP长短连接

TCP发送数据时，需要先建立连接，什么时候关闭连接就决定是短连接还是长连接：

短连接：每次接收到数据并返回响应后，都关闭连接，即是短连接。也就是说，短连接只能一次收发数据。

长连接：不关闭连接，一直保持连接状态，双方不停的收发数据，即是长连接。也就是说，长连接可以多次收发数据。

区别

建立连接、关闭连接的耗时：短连接每次请求、响应都需要建立连接，关闭连接；而长连接只需要第一次建立连接，之后的请求、响应都可以直接传输。相对来说建立连接，关闭连接也是要耗时的，长连接效率更高。

主动发送请求不同：短连接一般是客户端主动向服务端发送请求；而长连接可以是客户端主动发送请求，也可以是服务端主动发。

两者的使用场景有不同：短连接适用于客户端请求频率不高的场景，如浏览网页等。长连接适用于客户端与服务端通信频繁的场景，如聊天室，实时游戏等。

参考代码

服务器

package Tcp;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Scanner;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/*
* tcp 版本的回显服务器
* */
public class TcpServer {
    private ServerSocket serverSocket = null;
    // 创建非固定长度的线程池对象
    private ExecutorService service = Executors.newCachedThreadPool();

    public TcpServer(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }


    public void start() throws IOException {
        System.out.println("服务器启动!");
        while(true){
            /*
            * tcp 是有连接的传输层协议 需要先建立连接 连接之前的握手是由系统内核负责完成的
            * 服务器内核中有很多客户端的连接,在应用程序中需要一个一个去处理
            * accept: 将服务器内核中的连接获取到应用程序中(内核态 -> 用户态)
            * serverSocket实际上就是一个文件在系统内核中,涉及阻塞队列
            * */
            Socket clientSocket = serverSocket.accept();
            // 处理客户端并发访问的情况
            service.submit(new Runnable() {
                @Override
                public void run() {
                    processConnection(clientSocket);
                }
            });
            clientSocket.close();
        }
    }

    // 处理一个连接的逻辑
    private void processConnection(Socket clientSocket) {
        System.out.printf("[%s:%d] 客户端上线!",clientSocket.getInetAddress().toString(),clientSocket.getPort());
        // 接下来,进行三步走
        try(InputStream inputStream = clientSocket.getInputStream();
            OutputStream outputStream = clientSocket.getOutputStream()) {
            // 一次连接中可能会涉及到多次请求/响应
            while(true){
                // 1.读取请求并解析
                Scanner scanner = new Scanner(inputStream);
                if(!scanner.hasNext()){
                    System.out.println();
                    System.out.printf("[%s:%d] 客户端下线!",clientSocket.getInetAddress().toString(),clientSocket.getPort());
                    break;
                }
                // 客户端发送的是文本数据
                /*
                * next读取数据读到空白符结束  回车 换行 空格 制表符 翻页符 垂直制表符
                * */
                String request = scanner.next();
                // 2.解析请求
                String response = process(request);

                // 3.写会客户端
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(response);
                // 保证发出去了 防止在缓冲区中没有发送出去
                printWriter.flush();
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    private String process(String request) {
        return request;
    }


    public static void main(String[] args) throws IOException {
        TcpServer tcpServer = new TcpServer(8888);
        tcpServer.start();
    }
}

客户端

package Tcp;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Scanner;

public class TcpClient {
    Socket socket = null;

    public TcpClient(String ip, int port) throws IOException {
        socket = new Socket(ip,port);
    }

    public void start(){
        System.out.println("客户端启动!");
        Scanner scannerConsole = new Scanner(System.in);
        try(InputStream inputStream = socket.getInputStream();
            OutputStream outputStream = socket.getOutputStream()) {
            while(true){
                System.out.println("请输入: ");
                String request = scannerConsole.next();
                // 写到服务器
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(request);
                printWriter.flush();

                Scanner scanner = new Scanner(inputStream);
                String response = scanner.next();
                if(response == null){
                    break;
                }
                System.out.println(response);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args) throws IOException {
        TcpClient tcpClient = new TcpClient("127.0.0.1",8888);
        tcpClient.start();
    }
}