【JavaEE初阶】网络编程

【JavaEE初阶】网络编程_第1张图片

【JavaEE初阶】网络编程_第2张图片

文章目录

  • 网络编程基础
    • 网络资源
    • 网络编程
    • 网络编程中的基本概念
      • 发送端和接收端
      • 请求和响应
      • 客户端和服务端
        • 常见的客户端服务端模型
  • Socket套接字
    • 了解UDP和TCP
    • UDP数据报套接字编程
      • DatagramSocket API
      • DatagramPacket API
      • InetSocketAddress API
      • UDP版本的客户端服务器程序
    • TCP流套接字编程
      • ServerSocket API
      • Socket API
      • TCP版本的客户端服务器程序
      • TCP中的长短连接

网络编程基础

网络资源

网络资源,其实就是在网络中可以获取的各种数据资源。
而所有的网络资源,都是通过网络编程来进行数据传输的。
【JavaEE初阶】网络编程_第3张图片

网络编程

网络编程,指网络上的主机,通过不同的进程,以编程的方式实现网络通信(或称为网络数据传输)。
我们只要满足进程不同就行;所以即便是同一个主机,只要是不同进程,基于网络来传输数据,也属于网络编程。
特殊的,对于开发来说,在条件有限的情况下,一般也都是在一个主机中运行多个进程来完成网络编程。
但是,我们一定要明确,我们的目的是提供网络上不同主机,基于网络来传输数据资源:

  • 进程A:编程来获取网络资源
  • 进程B:编程来提供网络资源

网络编程中的基本概念

发送端和接收端

在一次网络数据传输时:
发送端:数据的发送方进程,称为发送端。发送端主机即网络通信中的源主机
接收端:数据的接收方进程,称为接收端。接收端主机即网络通信中的目的主机
收发端:发送端和接收端两端,也简称为收发端。
注意:发送端和接收端只是相对的,只是一次网络数据传输产生数据流向后的概念。

请求和响应

一般来说,获取一个网络资源,涉及到两次网络数据传输:

  • 第一次:请求数据的发送
  • 第二次:响应数据的发送。

客户端和服务端

服务端:在常见的网络数据传输场景下,把提供服务的一方进程,称为服务端,可以提供对外服务。
客户端:获取服务的一方进程,称为客户端。

对于服务来说,一般是提供:

  • 客户端获取服务资源
  • 客户端保存资源在服务端
常见的客户端服务端模型

最常见的场景,客户端是指给用户使用的程序,服务端是提供用户服务的程序:

  1. 客户端先发送请求到服务端
  2. 服务端根据请求数据,执行相应的业务处理
  3. 服务端返回响应:发送业务处理结果
  4. 客户端根据响应数据,展示处理结果(展示获取的资源,或提示保存资源的处理结果)

Socket套接字

网络编程中的核心就是Socket(套接字) API,这是操作系统给应用程序提供的网络编程API。
socket api是和传输层密切相关的。
传输层里提供了两个最核心的协议。UDP和TCP。
【JavaEE初阶】网络编程_第4张图片
因此,socket api也提供了两种风格UDP TCP

了解UDP和TCP

UDP:无连接,不可靠传输,面向数据报,全双工。
TCP:有连接, 可靠传输,面向字节流,全双工。

有无连接:

打电话就是有连接的没需要连接建立了才能通信,连接建立需要对方来“接受”。如果连接没建立好,就无法通信。
发短信/发微信就是无连接的,直接发送即可。

可靠不可靠传输:

网络环境是复杂的,不可能保证传输的数据百分百就能到达。
可靠传输:发送发能知道自己的消息是不是发过去了,还是丢了。比如抖音的已读功能。打电话功能。
不可靠传输:发短信/发微信。(QQ或者微信等没有已读功能的)

面向数据报/字节流:

面向字节流:数据传输就和文件读写类似“流式”的。
面向数据报:数据则以一个个的“数据报”为基本单位(一个数据报可能是若干字节)

全/半双工:

全双工:一个通信通道,可以双向传输。(既可以发送也可以接收)
半双工:比如一跟水管,是单向传输的,是半双工。

UDP数据报套接字编程

DatagramSocket API

DatagramSocket使用这个类,表示一个Socket对象,把这个socket对象也是当成一个文件来处理的。相当于是文件描述表上的一项。

普通的文件对应的硬件设备是硬盘。
socket文件,对应的硬件设备是网卡。

DatagramSocket 是UDP Socket,用于发送和接收UDP数据报。
DatagramSocket 构造方法:

方法签名 方法说明
DatagramSocket() 创建一个UDP数据报套接字的Socket,绑定到本机任意一个随机端口(一般用于客户端)
DatagramSocket(intport) 创建一个UDP数据报套接字的Socket,绑定到本机指定的端口(一般用于服务端)

注意:DatagramSocket()中没有指定端口时,系统则会自动分配一个空闲的端口。
DatagramSocket(intport)这个版本是要传入一个端口号,此时就是让当前的socket对象和这个指定的端口之间关联起来.

DatagramSocket 方法:

方法签名 方法说明
void receive(DatagramPacket p) 从此套接字接收数据报(如果没有接收到数据报,该方法会阻塞等待)
void send(DatagramPacketp) 从此套接字发送数据报包(不会阻塞等待,直接发送)
void close() 关闭此数据报套接字

注意:receive(DatagramPacket p)此处传入的相当于是一个空的对象。recive方法内部,会对参数的这个空对象进行内容填充。从而构造出数据结果。参数也是一个“输出型参数”。
close()使用完后释放资源。

DatagramPacket API

DatagramPacket 表示UDP中传输的一个报文,构造这个对象,可以指定一些具体的数据进去。

DatagramPacket 构造方法:

方法签名 方法说明
DatagramPacket(byte[] buf, int length) 构造一个DatagramPacket以用来接收数据报,接收的数据保存在字节数组(第一个参数buf)中,接收指定长度(第二个参数length)
DatagramPacket(byte[] buf, int offset, int length, SocketAddress address) 构造一个DatagramPacket以用来发送数据报,发送的数据为字节数组(第一个参数buf)中,从0到指定长度(第二个参数length)。address指定目的主机的IP和端口

注意:DatagramPacket(byte[] buf, int length)是把buf缓冲区设置进去了
DatagramPacket(byte[] buf, int offset, int length(构造缓冲区+地址), SocketAddress address(使用此类表示IP+port))

DatagramPacket 方法:

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

InetSocketAddress API

InetSocketAddressSocketAddress 的子类 )构造方法:

方法签名 方法说明
InetSocketAddress(InetAddress addr, int port) 创建一个Socket地址,包含IP地址和端口号

UDP版本的客户端服务器程序

此处的服务器是 回显服务器
一个普通的服务器:收到请求,根据请求计算响应,返回响应
回显服务器echo server:省略了其中还的“根据请求计算响应”,请求是什么,就返回什么。
作为一个真正的服务器,最重要的环节就是“根据请求计算响应”。

接下来我们实现一个UDP 版本的回显服务器

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

//UDP版本的回显服务器
public class UdpEchoServe {
    //网络编程,本质上是操作网卡
    //但是网卡不方便直接操作,在操作系统内核中,使用了一种特殊的叫做“socket”这样的文件来抽象表示网卡。
    //因此进行网络传输中,必须首先要有一个socket对象
    private DatagramSocket socket = null;

    //对于服务器来说,创建socket对象的同时,要让他绑定上一个端口号
    //服务器一定要关联上一个具体的端口号!
    //服务器是网络传输中,被动的一方,如果是操作系统随机分配端口,此时客户端就不知道这个端口时什么了,也就无法进行通信了
    public UdpEchoServe(int port) throws SocketException {
        socket = new DatagramSocket(port);
    }

    public void start() throws IOException {
        System.out.println("服务器启动!");
        //服务器不是只给一个客户端提供服务,而是需要给多个客户端提供服务,所以需要写一个循环
        while(true){
            //只要有客户端过来,就可以提供服务
            //1.读取客户发过来的请求是什么
            // receive 方法的参数是一个输出型参数,需要先构造好一个空白的DatagramPacket对象,交给receive来进行填充
            DatagramPacket requestPacket = new DatagramPacket(new byte[4096],4096);
            //(receive内部会针对参数对象填充数据,填充的数据来自于网卡)
            socket.receive(requestPacket);

            //此时这个DatagramPacket是一个特殊的对象,并不方便直接进行处理,可以把这里包含的数据拿出来,构造成一个字符串。
            String request = new String(requestPacket.getData(),0, requestPacket.getLength());

            //2.根据请求计算响应
            String response = process(request);

            //3.把响应写回到客户端,send的参数也是DatagramPacket,需要把这个Packet对象构造好
            //此处构造的响应对象,不能是用空的字节数组构造了,而是要使用响应数据来构造
            DatagramPacket responsePacket = new DatagramPacket(response.getBytes(),response.getBytes().length,
                    requestPacket.getSocketAddress());
            socket.send(responsePacket);

            //4.打印当前请求响应的处理中间结果
            System.out.printf("[%s:%d] req: %s;resp %s\n",requestPacket.getAddress().toString(),
                    requestPacket.getPort(),request,response);
        }
    }

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

    public static void main(String[] args) throws IOException {
        //端口号的指定,从1024-》65535之间选择一个数字
        UdpEchoServe serve = new UdpEchoServe(1988);
        serve.start();
    }
}

【JavaEE初阶】网络编程_第5张图片
因此,构造字符串,那些用了就构造那些部分。就通过getLength获取到实际的数据报的长度,只是把这个实际的有效部分给构造成字符串即可。
【JavaEE初阶】网络编程_第6张图片
【JavaEE初阶】网络编程_第7张图片

数据到达网卡,经过内核层层分用,最终到达UDP传输层协议。
调用receive相当于是执行到了内核中的相关的udp的代码,就会把这个udp数据报里面的载荷部分取出来,拷贝到用户提供的byte[]数组中。
【JavaEE初阶】网络编程_第8张图片
接下来,编写客户端代码:

import java.io.IOException;
import java.net.*;
import java.util.Scanner;

public class UdpEchoClient {
    private DatagramSocket socket = null;
    private String severIp = null;
    private int serverPort = 0;

    //一次通信,需要有两个ip,两个端口
    //客户端的ip是127.0.0.1已知的
    //客户端的port是系统自动分配的
    //服务器的ip和端口也需要告诉客户端,才能顺利把消息发给服务器
    public UdpEchoClient(String severIp, int serverPort) throws SocketException {
        socket = new DatagramSocket();
        this.severIp = severIp;
        this.serverPort = serverPort;
    }
    public void start() throws IOException {
        System.out.println("客户端启动!");
        Scanner scanner = new Scanner(System.in);
        while(true){
            //1.从服务台读取要发送的数据
            System.out.println(">");
            String request = scanner.next();
            if(request.equals("exit")){
                System.out.println("Goodbye~");
                break;
            }
            //2.构造成UDP这个请求并发送
            //构造这个Packet的时候,需要把serveIp和port都传过来,但是此处IP地址需要的是一个32位的整数形式
            //上述的IP地址是一个字符串,需要使用InetAddress.getByName()来进行一个转换
            DatagramPacket requestPacket = new DatagramPacket(request.getBytes(),request.getBytes().length,
                    InetAddress.getByName(severIp),serverPort);
            socket.send(requestPacket);
            //3.读取服务器的UDP响应,并解析
            DatagramPacket responsePacket = new DatagramPacket(new byte[4096],4096);
            socket.receive(responsePacket);
            String response = new String(responsePacket.getData(),0,responsePacket.getLength());
           //4.把解析好的结果显示出来
            System.out.println(response);
        }
    }

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

【JavaEE初阶】网络编程_第9张图片
在一次通信中,涉及到的ip和端口有两组:

  • 源ip
  • 源端口
  • 目的ip
  • 目的端口

假设是让客户端给服务器发个数据:
此时源ip就是客户端的ip地址
目的ip就是服务器的ip地址(上述代码中,由于客户端和服务器都在同一主机上,所以ip都是“127.0.0.1”(环回ip))
源端口就是客户端端口(即系统随机分配的空闲的端口)
目的端口就是服务器的端口(在上述程序中指定的是1988)

端口号用来表示/区分一个进程
因此不允许一个端口同时被多个进程使用(前提是在同一主机上。)一个端口通常情况下不能被多个进程使用,但是一个进程可以绑定多个端口。(准确来说,socket和端口号是一对一的,进程和socket是一对多的)

对于服务器来说,端口号必须是确定好的,对于客户端来说,端口可以使系统随机分配的。

客户端是否可以自己手动指定端口?
一般来说是不可以的,客户端如果显示指定端口,可能就和客户端电脑上的其他程序的端口冲突了,这一冲突就可能导致程序无法正确通信了。(比如客户端想要8888这个端口,结果,客户端另外一个程序已经使用8888,此时程序就无法正常正确运行:运行就会抛异常提示绑定端口失败。)
但是对于服务器这里的端口是程序员可控的,我们可以自己安排使用哪个端口。

【JavaEE初阶】网络编程_第10张图片
DatagramSocket这个类的receive能阻塞,是因为操作系统原生提供的。
API(receive)就是阻塞的函数。

【JavaEE初阶】网络编程_第11张图片
【JavaEE初阶】网络编程_第12张图片
稍微调整后可以开启多个客户端。

【JavaEE初阶】网络编程_第13张图片

TCP流套接字编程

TCP提供的API主要是两个类:
ServerSocket:专门给服务器使用的Socket对象
Socket:既是会给客户端使用,也会给服务器使用
注意:TCP不需要一个类来表示“TCP数据报”
TCP不是以数据报为单位进行传输的,是以字节的方式,流式传输。

ServerSocket API

ServerSocket 是创建TCP服务端Socket的API。
ServerSocket 构造方法:

方法签名 方法说明
ServerSocket(int port) 创建一个服务端流套接字Socket,并绑定到指定端口

ServerSocket方法:

方法签名 方法说明
Socket accept() 开始监听指定端口(创建时绑定的端口),有客户端连接后,返回一个服务端Socket对象,并基于该Socket建立与客户端的连接,否则阻塞等待
void close() 关闭此套接字

Socket API

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

方法签名 方法说明
Socket(String host, int port) 创建一个客户端流套接字Socket,并与对应IP的主机上,对应端口的进程建立连接

Socket 方法:

方法签名 方法说明
InetAddress getInetAddress() 返回套接字所连接的地址
InputStream getInputStream() 返回此套接字的输入流
OutputStream getOutputStream() 返回此套接字的输出流

TCP版本的客户端服务器程序

服务器端代码:

package nettwork;

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;

public class TcpEchoSever {
    private ServerSocket serverSocket = null;

    public TcpEchoSever(int port) throws IOException {
        serverSocket = new ServerSocket(port);
    }
    public void start() throws IOException {
        System.out.println("启动服务器!");
        // 此处使用 CachedThreadPool, 使用 FixedThreadPool 不太合适 (线程数不太应该是有固定的....)
        ExecutorService threadPool = Executors.newCachedThreadPool();
        while (true) {
            // 使用这个 clientSocket 和具体的客户端进行交流.
            Socket clientSocket = serverSocket.accept();
            // 此处使用多线程来处理.
            // 这里的多线程版本的程序, 最大的问题就是可能会涉及到频繁申请释放线程.
//            Thread t = new Thread(() -> {
//                processConnection(clientSocket);
//            });
//            t.start();

            // 使用线程池.
            threadPool.submit(() -> {
                processConnection(clientSocket);
            });
        }
    }

    //使用这个方法来处理一个连接
    //一个连接对应到一个客户端,但是这里可能会涉及到多次交互
    private void processConnection(Socket clientSocket) {
        System.out.printf("[%s:%d]客户端上线!\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
        //基于上述socket对象和客户端进行通信
        try(InputStream inputStream = clientSocket.getInputStream();
            OutputStream outputStream = clientSocket.getOutputStream()) {
            //处理多个请求和响应,可以使用循环来进行
            while(true){
                //1.读取请求
                Scanner scanner = new Scanner(inputStream);
                if(!scanner.hasNext()){
                    //没有下一个数据了,说明读完了(客户端关闭了连接)
                    System.out.printf("[%s:%d]客户端下线!\n",clientSocket.getInetAddress().toString(),clientSocket.getPort());
                    break;
                }
                //注意:此处使用next是一直读取到换行符/空格/其他空白符结束,但是最终返回结果中不包含上述空白符
                String request = scanner.next();
                //2.根据请求构造响应
                String response = process(request);
                //3.返回响应结果
                //    OutputSrteam 没有  writr String 这样的功能,可以把String 里字节数组拿出来进行写入,
                //    也可以用字符流来转化一下
                PrintWriter printWriter = new PrintWriter(outputStream);
                //此处使用println 来写入,让结果中带有一个\n换行,方便对端来接受解析
                printWriter.println(response);
                //flush刷新缓冲区,保证当前写入的数据被发送出去了。
                printWriter.flush();

                System.out.printf("[%s:%d] req: %s resp: %s \n",clientSocket.getInetAddress().toString(),clientSocket.getPort(),
                        request,response);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            try {
                clientSocket.close();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
    }

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

    public static void main(String[] args) throws IOException {
        TcpEchoSever server = new TcpEchoSever(1988);
        server.start();
    }
}

【JavaEE初阶】网络编程_第14张图片
此代码中,用到了一个clientSocket,此时任意一个客户端连上来吗,都会返回/创建一个Socket对象(Socket就是文件),每次创建一个clientSocket对象,就会占用一个文件描述符表的位置
因此在使用完毕之后,就需要进行“释放”。
前面的socket都没有释放,是因为前面的socket生命周期长。但是此处的clientSocket数量多,每个客户端都有一个,生命周期也更短。

【JavaEE初阶】网络编程_第15张图片
注意:此处使用println来进行发送数据,是因为println会在发送的数据后面自动带上\n换行。如果不使用println,就无法正常运行。因为TCP协议,是面向字节流的协议。(字节流的特性是:一次读多少字节都行。而结束是\n)此处的代码中,隐式约定了使用\n来作为当前代码的请求/响应分割约定。
【JavaEE初阶】网络编程_第16张图片

客户端代码:

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 TcpEchoClient {
    private Socket socket = null;

    public TcpEchoClient(String severIp,int serverPort) throws IOException {
        //Socket构造方法,能够识别点分十进制格式的IP地址,比DatagramPacket更加方便
        //new 这个对象的同时,就会进行TCP连接操作
        socket = new Socket(severIp,serverPort);
    }

    public void start(){
        System.out.println("客户端启动!");
        Scanner scanner = new Scanner(System.in);
        try(InputStream inputStream = socket.getInputStream();
            OutputStream outputStream = socket.getOutputStream()) {
            while(true){
                //1.先从键盘上获取用户输入的内容
                System.out.println(">");
                String request = scanner.next();
                if(request.equals("exit")){
                    System.out.println("Goodbye~");
                    break;
                }
                //2.把读到的内容构造成请求,发送给服务器
                PrintWriter printWriter = new PrintWriter(outputStream);
                printWriter.println(request);
                //此处加上flush确保数据被发送出去
                printWriter.flush();
                //3.读取服务器的响应
                Scanner respScanner = new Scanner(inputStream);
                String response = respScanner.next();
                //4.把响应内容显示到界面上
                System.out.println(response);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

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

运行结果:【JavaEE初阶】网络编程_第17张图片
多线程模式下的运行结果:
【JavaEE初阶】网络编程_第18张图片

TCP中的长短连接

TCP发送数据时,需要先建立连接,什么时候关闭连接就决定是短连接还是长连接:
短连接:每次接收到数据并返回响应后,都关闭连接,即是短连接。也就是说,短连接只能一次收发数据。
长连接:不关闭连接,一直保持连接状态,双方不停的收发数据,即是长连接。也就是说,长连接可以多次收发数据。

  1. 对比以上长短连接,两者区别如下: 建立连接、关闭连接的耗时:短连接每次请求、响应都需要建立连接,关闭连接;而长连接只需要第一次建立连接,之后的请求、响应都可以直接传输。相对来说建立连接,关闭连接也是要耗时 的,长连接效率更高。
  2. 主动发送请求不同:短连接一般是客户端主动向服务端发送请求;而长连接可以是客户端主动发送 请求,也可以是服务端主动发。
  3. 两者的使用场景有不同:短连接适用于客户端请求频率不高的场景,如浏览网页等。长连接适用于 客户端与服务端通信频繁的场景,如聊天室,实时游戏等。

你可能感兴趣的:(JavaEE初阶,网络,java-ee,java)