java基础-网络编程

最新推荐文章于 2023-03-31 16:19:06 发布

山有木兮丶丶

最新推荐文章于 2023-03-31 16:19:06 发布

阅读量135

点赞数

分类专栏： java基础文章标签： java

本文链接：https://blog.csdn.net/weixin_50117915/article/details/128217817

版权

java基础专栏收录该内容

7 篇文章 0 订阅

订阅专栏

网络编程

一、概述

计算机网络：

计算机网络系统就是利用通信设备和线路将地理位置不同、功能独立的多个计算机系统互联起来，以功能完善的网络软件实现网络中资源共享和信息传递的系统。

联网目的：相互通信，资源共享。

网络分类：局域网，城域网，互联网。

IP地址：网络中主机的地址。

域名： IP地址的别名，因为IP不好记，也难理解，实际访问主机采用域名地址。

协议：计算机之间的通信规则称为协议

七层协议：物理层 — 数据链路层 — 网络层(IP) — 传输层(TCP) — 会话层 — 表示层 — 应用层

MAC地址：硬件地址

DNS：提供域名和IP地址之间的转换

子网掩码：用来指明一个IP地址的哪些位标识的是网络号（含子网号）以及哪些位标识的是主机号的位掩码。子网掩码不能单独存在，必须结合IP地址一起使用。子网掩码只有一个作用，就是将某个IP地址划分为网络地址和主机地址两部分

二、网络通信的要素

通信双方地址：

ip
port

规则：网络通信协议

TCP/IP模型：

网络编程主要是针对传输层：TCP，UDP

网络编程中的要素：

ip和端口号
网络通信协议

三、IP地址

ip地址：InetAddress

唯一定位一台网络上的计算机
127.0.0.1：本机localhost
ip地址的分类
- ipv4 / ipv6
  - ipv4：4个字节组成，每个字节0-255，共42多亿个
  - ipv6：16个字节组成，用16进制表示，其中0可以省略
- 公网（互联网) - 私网(局域网)
  - ABCD类地址
  - 192.168.xx.xx
域名：ip地址别名

public class Demo1 {
    public static void main(String[] args) {
        try {
            InetAddress addresses1 = InetAddress.getByName("www.baidu.com");
            InetAddress addresses2 = InetAddress.getByName("localhost");
            InetAddress addresses3 = InetAddress.getLocalHost();
            System.out.println(addresses1);
            System.out.println(addresses2);
            System.out.println(addresses3);
            System.out.println(addresses1.getHostAddress());//获取域名下的ip地址
            System.out.println(addresses1.getHostName());//获取域名
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

四、Port端口

端口可以表示为计算机上的一个进程

不同的进程有不同的端口号，用来区分软件
范围是：0-65535
不同协议间的端口独立，例如TCP端口和UDP端口。由于TCP和UDP两个协议是独立的，因此各自的端口号也相互独立，比如TCP有235端口，UDP也可以有235端口，两者并不冲突。
端口分类
- 周知端口：0-1023
  - http: 80
  - https: 443
  - ftp: 21
  - ssh: 22
  - Telent: 23
- 程序注册端口：1024-49151
  - Tomcat：8080
  - MySQL：3306
  - Oracle：1521
- 动态端口：49152-65535
  - 动态分配是指当一个系统进程或应用程序进程需要网络通信时，它向主机申请一个端口，主机从可用的端口号中分配一个供它使用。当这个进程关闭时，同时也就释放了所占用的端口号。

查看端口命令：

#查看所有端口信息
netstat -ano
#查看指定端口信息
netstat -ano|findstr "5900"
#查看指定进程的端口：pid
tasklist|findstr "9648"

public class Demo2 {
    public static void main(String[] args) {
        InetSocketAddress i = new InetSocketAddress("gggd.club", 443);
        System.out.println(i);
        System.out.println(i.getAddress());//地址
        System.out.println(i.getHostName());//域名
        System.out.println(i.getPort());//端口
    }
}

五、通信协议

网络通信协议：速率、传输码率、代码结构、传输控制。。。。

TCP/IP协议簇：

TCP/IP（Transmission Control Protocol/Internet Protocol，传输控制协议/网际协议）是指能够在多个不同网络间实现信息传输的协议簇。TCP/IP协议不仅仅指的是TCP 和 IP 两个协议，而是指一个由 FTP 、SMTP、TCP、UDP、IP等协议构成的协议簇，只是因为在TCP/IP协议中TCP协议和IP协议最具代表性，所以被称为TCP/IP协议。

TCP与UDP对比

TCP：例如打电话

双方需要进行连接，过程稳定
需要三次握手、四次挥手
拥有客户端和服务端
传输完成，释放连接

UDP：例如发短信

双方不需要连接，过程不稳定
不需要对方确认，己方只需发送信息，不用关注对方是否接收到
拥有客户端和服务端，但界限不明确

三次握手、四次挥手

三次握手：

客户端：请求传输数据。#SYN=1，seq=x
服务端：确认请求。#SYN=1，ack=x+1，seq=y
客户端：即将开始传输。#SYN=1，ack=y+1，seq=x+1

三次握手原因：

为了防止服务器端开启一些无用的连接增加服务器开销以及防止已失效的连接请求报文段突然又传送到了服务端，因而产生错误。

四次挥手：

客户端：请求断开连接。#FIN=1，seq=x
服务端：收到请求，正在整理数据。#FIN=1，ack=x+1，seq=y
服务端：数据整理完毕，即将断开连接。#FIN=1，ack=x+1，seq=z
客户端：确认断开连接。#FIN=1，ack=z+1，seq=h

为什么“握手”是三次，“挥手”却要四次？

TCP建立连接时之所以只需要"三次握手"，是因为在第二次"握手"过程中，服务器端发送给客户端的TCP报文是以SYN与ACK作为标志位的。SYN是请求连接标志，表示服务器端同意建立连接；ACK是确认报文，表示告诉客户端，服务器端收到了它的请求报文。即SYN建立连接报文与ACK确认接收报文是在同一次"握手"当中传输的，所以"三次握手"不多也不少，正好让双方明确彼此信息互通。

TCP释放连接时之所以需要“四次挥手”,是因为FIN释放连接报文与ACK确认接收报文是分别由第二次和第三次"握手"传输的。为何建立连接时一起传输，释放连接时却要分开传输？

建立连接时，被动方服务器端结束CLOSED阶段进入“握手”阶段并不需要任何准备，可以直接返回SYN和ACK报文，开始建立连接。
释放连接时，被动方服务器，突然收到主动方客户端释放连接的请求时并不能立即释放连接，因为还有必要的数据需要处理，所以服务器先返回ACK确认收到报文，经过CLOSE-WAIT阶段准备好释放连接之后，才能返回FIN释放连接报文。

六、TCP

概念

传输控制协议（TCP，Transmission Control Protocol）是一种面向连接的、可靠的、基于字节流的传输层通信协议，由IETF的RFC 793 定义。

1、聊天实现

1、客户端

1.建立连接

2.发送消息

3.接收消息

4.关闭流

public class Client01 {
    public static void main(String[] args) {
        Socket socket = null;
        OutputStream os = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        try {
            //1.需要一个服务端的地址,端口号
            InetAddress ip = InetAddress.getByName("127.0.0.1");
            int port = 9999;
            //2.创建一个socket
            socket = new Socket(ip, port);
            //3.发送消息通过IO流
            os = socket.getOutputStream();
            os.write("你好:java".getBytes());
            //关闭流，目的是告诉服务端这边已经发送完毕
            socket.shutdownOutput();
            //4.接收服务端的消息
            is = socket.getInputStream();
            //管道流
            baos = new ByteArrayOutputStream();
            byte[] buffer = new byte[1024];
            int len;
            while ((len = is.read(buffer)) != -1){
                baos.write(buffer,0 ,len);
            }
            //关闭流，目的是告诉服务端这边已经接收完毕
            socket.shutdownInput();
            System.out.println("来自服务端的消息：" + baos);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            if(baos != null){
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(os != null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

2、服务端

1.建立服务

2.等待连接

3.接收消息

4.发送消息

5.关闭流

public class Server01 {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket accept = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;
        OutputStream out = null;
        try {
            //1.需要创建一个地址
            serverSocket = new ServerSocket(9999);
            while (true){
                //2.等待客户端连接
                accept = serverSocket.accept();
                //3.读取客户端的消息
                is = accept.getInputStream();
                //管道流
                baos = new ByteArrayOutputStream();
                byte[] buffer = new byte[1024];
                int len;
                while ((len = is.read(buffer)) != -1){
                    baos.write(buffer,0 ,len);
                }
                //关闭流，目的是告诉客户端这边已经给接收完毕
                accept.shutdownInput();
                System.out.println("来自客户端的消息：" + baos);
                //4.向客户端发送消息
                out = accept.getOutputStream();
                out.write(("已收到来自客户端的消息：" + baos).getBytes());
                //关闭流，目的是告诉客户端这边已经发送完毕
                accept.shutdownOutput();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        finally {
            if(out != null){
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (baos != null) {
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (accept != null) {
                try {
                    accept.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

2、多线程聊天

1、服务端

public class Server implements Runnable{
    Socket accept = null;
    InputStream is = null;
    BufferedReader br = null;
    OutputStream out = null;

    public Server(Socket accept) {
        this.accept = accept;
    }

    @Override
    public void run() {
        try {
            is = accept.getInputStream();
            br = new BufferedReader(new InputStreamReader(is));
            while (true) {
                String msg = br.readLine();
                System.out.println("来自客户端的消息：" + msg);
                //4.向客户端发送消息
                out = accept.getOutputStream();
                out.write(("来自client01：" + msg + "\n").getBytes());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class ServerMain {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(9999);
            if(serverSocket.isBound()){
                System.out.println("服务器已启动");
            }
            while(true) {
                Socket socket = serverSocket.accept();
                new Thread(new Server(socket)).start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

    }
}

2、客户端

public class Client {
    public static void main(String[] args) {
        Socket socket = null;
        OutputStream os = null;
        InputStream is = null;
        BufferedReader br = null;
        try {
            InetAddress ip = InetAddress.getByName("127.0.0.1");
            int port = 9999;
            //2.创建一个socket
            socket = new Socket(ip, port);
            if(socket.isConnected()){
                System.out.println("登录成功！");
            }
            os = socket.getOutputStream();
            is = socket.getInputStream();
            Scanner input = new Scanner(System.in);
            while (true) {
                os.flush();
                String msg = input.next();
                msg = msg + "\n";
                os.write(msg.getBytes());
                //4.接收服务端的消息
                br = new BufferedReader(new InputStreamReader(is));
                String receive = br.readLine();
                System.out.println(receive);
            }
        } catch (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

3、文件上传

1、客户端

1.连接

2.将文件写入输出流

3.确认服务端是否接收

4.关闭流

public class Client {
    public static void main(String[] args) throws Exception{
        //1.连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9999);
        //2.创建输出流
        OutputStream os = socket.getOutputStream();
        //3.将文件写入到输出流
        FileInputStream fis = new FileInputStream(new File("D:\\BaiduNetdiskDownload\\新建文件夹\\不动鸣神，泡影断灭-1920x1080.jpg"));
        byte[] buffer = new byte[1024];
        int len;
        while ((len = fis.read(buffer)) != -1){
            os.write(buffer, 0, len);
        }
        //告诉服务端这边已经发送完毕
        socket.shutdownOutput();
        //4.确认服务端是否接收完毕才可以关闭流
        InputStream is = socket.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer2 = new byte[1024];
        int len2;
        while ((len2 = is.read(buffer2)) != -1){
            baos.write(buffer2, 0, len2);
        }
        //告诉服务端这边已经接收完毕
        socket.shutdownInput();
        System.out.println(baos);
        //5.关闭流
        baos.close();
        is.close();
        fis.close();
        os.close();
        socket.close();
    }
}

2、服务端

1.启动服务

2.等待连接

3.将文件写入本地

4.确认接收完毕

5.关闭流

public class Server {
    public static void main(String[] args) throws Exception{
        //1.启动服务
        ServerSocket serverSocket = new ServerSocket(9999);
        //2.等待连接
        Socket accept = serverSocket.accept();
        //3.将文件写入到输出流
        InputStream is = accept.getInputStream();
        FileOutputStream fos = new FileOutputStream(new File("D:\\BaiduNetdiskDownload\\pic.jpg"));
        byte[] buffer = new byte[1024];
        int len;
        while ((len = is.read(buffer)) != -1){
            fos.write(buffer, 0, len);
        }
        //告诉客户端这边已经接收完毕
        accept.shutdownInput();
        //4.给客户端发送接收成功消息
        OutputStream os = accept.getOutputStream();
        os.write("接收成功".getBytes("UTF-8"));
        //告诉客户端这边已经发送完毕
        accept.shutdownOutput();
        //5.关闭流
        os.close();
        fos.close();
        is.close();
        accept.close();
        serverSocket.close();
    }
}

七、UDP

概念

Internet 协议集支持一个无连接的传输协议，该协议称为用户数据包协议（UDP，User Datagram Protocol）。UDP 为应用程序提供了一种无需建立连接就可以发送封装的 IP 数据包的方法。提供面向事务的简单不可靠信息传送服务。

UDP的不可靠指的是：使用UDP发送数据包时会把数据包划分为一个个小包再进行传输，在传输过程中可能就会丢包，当数据包比较大时，丢包的可能性就会更高，从而导致数据传输不完整。

1、发送消息

1.发送端

1.建立一个socket

2.创建包

3.发送包

4.关闭流

public class Client01 {
    public static void main(String[] args) throws Exception{
        //1.建立一个socket
        DatagramSocket socket = new DatagramSocket();
        //2.创建包
        String msg = "你好呀，java";
        InetAddress address = InetAddress.getByName("127.0.0.1");
        int port = 9999;
        //该构造方法参数分别为：发送的字节数组、起始位置、结束位置、ip地址、端口号
        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, address, port);
        //3.发送包
        socket.send(packet);
        //4.关闭流
        socket.close();
    }
}

2.接收端

1.开放端口

2.接收数据

3.关闭流

public class Server01 {
    public static void main(String[] args) throws Exception{
        //1.开放端口
        int port = 9999;
        DatagramSocket socket = new DatagramSocket(port);
        //2.接收数据
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);
        //阻塞接收
        socket.receive(packet);
        System.out.println(packet.getAddress().getHostName());
        System.out.println(new String(packet.getData(), 0, packet.getLength()));
        //3.关闭流
        socket.close();
    }
}

2、聊天实现

1.发送端

public class Sender {
    public static void main(String[] args) throws Exception{
        DatagramSocket socket = new DatagramSocket();
        //读取需要发送的消息
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        //循环发送
        while (true){
            String msg = reader.readLine();
            byte[] data = msg.getBytes();
            InetAddress address = InetAddress.getByName("127.0.0.1");
            int port = 6666;
            //发送
            DatagramPacket packet = new DatagramPacket(data, 0, data.length, address, port);
            socket.send(packet);
            //断开连接
            if("bye".equals(msg)){
                break;
            }
        }
        socket.close();
    }
}

2.接收端

public class Receive {
    public static void main(String[] args) throws Exception{
        DatagramSocket socket = new DatagramSocket(6666);
        //循环接收
        while (true){
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container, 0, container.length);
            socket.receive(packet);
            byte[] data = packet.getData();
            String msg = new String(data, 0, packet.getLength());
            System.out.println(msg);
            //断开连接
            if("bye".equals(msg)){
                break;
            }
        }
        socket.close();
    }
}

3、多线程聊天

可实现双方互相通信

1.发送端

public class Sender implements Runnable {
    DatagramSocket socket =null;
    BufferedReader reader = null;

    private String toIp;
    private int toPort;
    private int fromPort;

    public Sender(String toIp, int toPort, int fromPort) {
        this.toIp = toIp;
        this.toPort = toPort;
        this.fromPort = fromPort;
        try {
            socket = new DatagramSocket(fromPort);
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        //循环发送
        while (true){
            String msg = null;
            try {
                msg = reader.readLine();
                byte[] data = msg.getBytes();
                //发送
                DatagramPacket packet = new DatagramPacket(data, 0, data.length, new InetSocketAddress(toIp, toPort));
                socket.send(packet);
                //断开连接
                if("bye".equals(msg)){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

2.接收端

public class Receive implements Runnable{
    DatagramSocket socket = null;
    private int port;
    private String name;

    public Receive(int port, String name) {
        this.port = port;
        this.name = name;
        try {
            socket = new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        //循环接收
        while (true){
            try {
                byte[] container = new byte[1024];
                DatagramPacket packet = new DatagramPacket(container, 0, container.length);
                socket.receive(packet);
                byte[] data = packet.getData();
                String msg = new String(data, 0, packet.getLength());
                System.out.println(name + "：" + msg);
                //断开连接
                if("bye".equals(msg)){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

3.学生

public class Student {
    public static void main(String[] args) {
        //开启两个线程
        new Thread(new Sender("127.0.0.1", 8888, 6666)).start();
        new Thread(new Receive(7777, "老师")).start();
    }
}

4.老师

public class Teacher {
    public static void main(String[] args) {
        //开启两个线程
        new Thread(new Sender("127.0.0.1", 7777, 9999)).start();
        new Thread(new Receive(8888, "学生")).start();
    }
}

八、URL

URL：统一资源定位符，定位互联网上的某一个资源

https://www.baidu.com:80
协议://ip:端口/项目名/资源

通过url爬取网页资源

public class Demo {
    public static void main(String[] args) throws Exception{
        String spec = "http://www.haoword.com/xindetihui/duhougan/688782.htm";
        URL url = new URL(spec);
        InputStream in = url.openStream();
        OutputStream out = new FileOutputStream("D:\\BaiduNetdiskDownload\\688782.html");
        byte[] b = new byte[1024*4];
        int len = -1;
        while((len = in.read(b))!=-1) {
            out.write(b, 0, len);
        }
        out.close();
        in.close();
    }
}

九、WebSocket

概念：WebSocket是一种在单个TCP连接上进行全双工通信的协议。

WebSocket使得客户端和服务器之间的数据交换变得更加简单，允许服务端主动向客户端推送数据。在WebSocket API中，浏览器和服务器只需要完成一次握手，两者之间就直接可以创建持久性的连接，并进行双向数据传输。

背景：很多网站为了实现推送技术，所用的技术都是轮询。轮询是在特定的的时间间隔（如每1秒），由浏览器对服务器发出HTTP请求，然后由服务器返回最新的数据给客户端的浏览器。这种传统的模式带来很明显的缺点，即浏览器需要不断的向服务器发出请求，然而HTTP请求可能包含较长的头部，其中真正有效的数据可能只是很小的一部分，显然这样会浪费很多的带宽等资源。

在这种情况下，HTML5定义了WebSocket协议，能更好的节省服务器资源和带宽，并且能够更实时地进行通讯。

原理：

WebSocket并不是全新的协议，而是利用了HTTP协议来建立连接。我们来看看WebSocket连接是如何创建的。

首先，WebSocket连接必须由浏览器发起，因为请求协议是一个标准的HTTP请求，格式如下：

GET ws://localhost:3000/ws/chat HTTP/1.1
Host: localhost
Upgrade: websocket
Connection: Upgrade
Origin: http://localhost:3000
Sec-WebSocket-Key: client-random-string
Sec-WebSocket-Version: 13

该请求和普通的HTTP请求有几点不同：

GET请求的地址不是类似/path/，而是以ws://开头的地址；
请求头Upgrade: websocket和Connection: Upgrade表示这个连接将要被转换为WebSocket连接；
Sec-WebSocket-Key是用于标识这个连接，并非用于加密数据；
Sec-WebSocket-Version指定了WebSocket的协议版本。

随后，服务器如果接受该请求，就会返回如下响应：

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: server-random-string

该响应代码101表示本次连接的HTTP协议即将被更改，更改后的协议就是Upgrade: websocket指定的WebSocket协议。

为了创建Websocket连接，需要通过浏览器发出请求，之后服务器进行回应，这个过程通常称为“握手)”（handshaking）

版本号和子协议规定了双方能理解的数据格式，以及是否支持压缩等等。如果仅使用WebSocket的API，就不需要关心这些。

现在，一个WebSocket连接就建立成功，浏览器和服务器就可以随时主动发送消息给对方。消息有两种，一种是文本，一种是二进制数据。通常，我们可以发送JSON格式的文本，这样，在浏览器处理起来就十分容易。

为什么WebSocket连接可以实现全双工通信而HTTP连接不行呢？实际上HTTP协议是建立在TCP协议之上的，TCP协议本身就实现了全双工通信，但是HTTP协议的请求－应答机制限制了全双工通信。WebSocket连接建立以后，其实只是简单规定了一下：通信不使用HTTP协议，直接互相发数据。

WebSocket目前支持两种统一资源标志符ws和wss，类似于HTTP和HTTPS。

浏览器支持：

很显然，要支持WebSocket通信，浏览器得支持这个协议，这样才能发出ws://xxx的请求。目前，支持WebSocket的主流浏览器如下：

Chrome
Firefox
IE >= 10
Sarafi >= 6
Android >= 4.4
iOS >= 8

java服务端实现

1、maven依赖

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.78</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-websocket</artifactId>
</dependency>

2、config配置类

@Configuration
public class WebsocketConfiguration {
    /**
     * 注入一个ServerEndpointExporter,该Bean会自动注册使用@ServerEndpoint注解申明的websocket endpoint
     */
    @Bean
    public ServerEndpointExporter serverEndpointExporter() {
        return new ServerEndpointExporter();
    }
}

3、websocket服务端

下面是websocket的重点

@ServerEndpoint(“/api/pushMessage/{userId}”) 前端通过此 URI 和后端交互，建立连接
@Component 将此类交给 spring 管理
@OnOpen websocket 建立连接的注解，前端触发上面 URI 时会进入此注解标注的方法
@OnMessage 收到前端传来的消息后执行的方法
@OnClose 顾名思义关闭连接，销毁 session
因为WebSocket是类似客户端服务端的形式(采用ws协议)，那么这里的WebSocketServer其实就相当于一个http协议的Controller
新建一个ConcurrentHashMap webSocketMap 用于接收当前userId的WebSocket，方便IM之间对userId进行推送消息

/**
 * @Description websocket的处理类。
 *  * 作用相当于HTTP请求
 *  * 中的controller
 * @Author srx
 * @date 2022/5/12 17:45
 */
@Component
@Slf4j
@ServerEndpoint("/api/pushMessage/{userId}")
public class WebSocketServer {

    /**静态变量，用来记录当前在线连接数。应该把它设计成线程安全的。*/
    private static int onlineCount = 0;

    /**concurrent包的线程安全Set，用来存放每个客户端对应的WebSocket对象。*/
    private static ConcurrentHashMap<String,WebSocketServer> webSocketMap = new ConcurrentHashMap<>();

    /**与某个客户端的连接会话，需要通过它来给客户端发送数据*/
    private Session session;

    /**接收userId*/
    private String userId = "";

    /**
     * 连接成功
     * 调用的方法
     */
    @OnOpen
    public void onOpen(Session session, @PathParam("userId") String userId) {
        this.session = session;
        this.userId = userId;
        if(webSocketMap.containsKey(userId)){
            webSocketMap.remove(userId);
            //加入set中
            webSocketMap.put(userId, this);
        }else{
            //加入set中
            webSocketMap.put(userId, this);
            //在线数加1
            addOnlineCount();
        }
        log.info("用户连接:" + userId + ",当前在线人数为:" + getOnlineCount());
        sendMessage("用户：" + userId + "连接成功");
    }

    /**
     * 连接关闭
     * 调用的方法
     */
    @OnClose
    public void onClose() {
        if(webSocketMap.containsKey(userId)){
            //从set中删除
            webSocketMap.remove(userId);
            //在线数减1
            subOnlineCount();
        }
        log.info("用户退出:" + userId+",当前在线人数为:" + getOnlineCount());
    }

    /**
     * 收到客户端消
     * 息后调用的方法
     * @param message 客户端发送过来的消息
     *
     **/
    @OnMessage
    public void onMessage(String message, Session session) {
        log.info("用户消息:" + userId + ",报文:" + message);
        //可以群发消息
        //todo 消息保存到数据库、redis
        if(StringUtils.isNotBlank(message)){
            try {
                //解析发送的报文
                JSONObject jsonObject = JSON.parseObject(message);
                //追加发送人(防止串改)
                jsonObject.put("fromUserId", this.userId);
                String toUserId = jsonObject.getString("toUserId");
                //传送给对应toUserId用户的websocket
                if(StringUtils.isNotBlank(toUserId) && webSocketMap.containsKey(toUserId)){
                    webSocketMap.get(toUserId).sendMessage(jsonObject.toJSONString());
                }else{
                    //否则不在线，发送到mysql或者redis
                    log.error("请求的userId:" + toUserId + "不在线");
                }
            }catch (Exception e){
                e.printStackTrace();
            }
        }
    }

    /**
     * 实现服务
     * 器主动推送
     */
    public void sendMessage(String message) {
        try {
            this.session.getBasicRemote().sendText(message);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    /**
     * @param session
     * @param error
     */
    @OnError
    public void onError(Session session, Throwable error) {
        log.error("用户错误:" + this.userId + ",原因:" + error.getMessage());
        error.printStackTrace();
    }

    /**
     * 发送自定义消息
     **/
    public static void sendInfo(String message, String userId) {
        log.info("发送消息到:" + userId + "，报文:" + message);
        if(StringUtils.isNotBlank(userId) && webSocketMap.containsKey(userId)){
            webSocketMap.get(userId).sendMessage(message);
        }else{
            log.error("用户" + userId + ",不在线！");
        }
    }

    /**
     * 发送自定义消息至全体用户
     **/
    public static void sendInfo(String message) {
        log.info("发送消息到全体用户，报文:" + message);
        webSocketMap.forEach((k, v) -> v.sendMessage(message));
    }

    /**
     * 获得此时的
     * 在线人数
     * @return
     */
    public static synchronized int getOnlineCount() {
        return onlineCount;
    }

    /**
     * 在线人
     * 数加1
     */
    public static synchronized void addOnlineCount() {
        WebSocketServer.onlineCount++;
    }

    /**
     * 在线人
     * 数减1
     */
    public static synchronized void subOnlineCount() {
        WebSocketServer.onlineCount--;
    }
}

4、消息推送

可以在自己的Controller写个方法调用WebSocketServer.sendInfo()即可。

@Controller
@RequestMapping("/api/msg")
public class MsgController {

    /**
     * 向某个用户发送消息
     * @param msg
     * @return
     */
    @PostMapping("/push")
    public String push(@RequestBody Msg msg){
        WebSocketServer.sendInfo(msg.getMsg(), msg.getUid().toString());
        return "ok";
    }

    /**
     * 向全体用户发送消息
     * @param msg
     * @return
     */
    @PostMapping("/push/all")
    public String pushAll(@RequestBody Msg msg){
        WebSocketServer.sendInfo(msg.getMsg());
        return "ok";
    }
}

html客户端实现

前端页面直接使用ws协议建立连接，ws://localhost:8080/api/pushMessage/{userId}

<template>
  <div>
    <el-row type="flex" class="row-bg" justify="center">
      <el-col :span="12">
          <el-card class="box-card">
              <el-breadcrumb separator-class="el-icon-arrow-right" style="float:left">
                  <el-breadcrumb-item><b>websocket</b></el-breadcrumb-item>
              </el-breadcrumb>
              <el-divider></el-divider>
              <el-input
                type="textarea"
                :rows="8"
                placeholder="暂无消息"
                v-model="content">
              </el-input>
              <el-divider></el-divider>
              <p>我的信息：</p>
              <el-input v-model="fromUid" placeholder="请输入您的id"></el-input>
              <p>发送消息：</p>
              <el-input v-model="toUid" placeholder="请输入对方的id"></el-input>
              <el-input
                style="margin-top: 5px"
                type="textarea"
                :rows="4"
                placeholder="请输入消息内容"
                v-model="msg">
              </el-input>
              <p><el-button plain @click="send">发送</el-button></p>
              <p><el-button plain @click="connect">建立连接</el-button></p>
          </el-card>
      </el-col>
    </el-row>
  </div>
</template>
<script>
import { Message } from 'element-ui';
export default {
    data() {
        return {
          socket: null,
          content: '',
          toUid: '',
          fromUid: '',
          msg: '',
          acceptMsg: ''
        };
    },
    methods:{
      send(){
        console.log('发送消息：' + this.msg);
        this.socket.send('{"toUserId":"' + this.toUid + '","contentText":"' + this.msg + '"}');
        Message.success('消息发送成功')
        this.content += '\n\t\t\t' + this.fromUid + ':' + this.msg;
      },
      connect(){
        let _this = this;
        const socketUrl = "ws://localhost:8080/api/pushMessage/" + this.fromUid;
        console.log('当前连接地址：' + socketUrl);
        if(this.socket != null){
          this.socket.close();
          this.socket = null;
        }
        this.socket = new WebSocket(socketUrl);
        //打开事件
        this.socket.onopen = function() {
          console.log("websocket已打开");
          Message.success('已建立连接')
        };
        //获得消息事件
        this.socket.onmessage = function(msg) {
          console.log('获取到消息：' + msg.data);
          //发现消息进入,开始处理前端触发逻辑
          let s = msg.data.split('{')
          if(s.length <= 1){
            _this.content += '\n' + msg.data;
          }else{
            _this.acceptMsg = JSON.parse(msg.data);
            _this.content += '\n' + _this.acceptMsg.fromUserId + ':' + _this.acceptMsg.contentText;
          }
        };
        //关闭事件
        this.socket.onclose = function() {
          console.log("websocket已关闭");
          _this.content += '\nwebsocket已关闭';
        };
        //发生了错误事件
        this.socket.onerror = function() {
          console.log("websocket发生了错误");
        }
      },
    }
};
</script>
<style scoped>
</style>

群聊

1、后端

只需修改接收消息判断为群聊，发送给所有人即可

@OnMessage
public void onMessage(String message, Session session) {
    log.info("用户消息:" + userId + ",报文:" + message);
    //可以群发消息
    //todo 消息保存到数据库、redis
    if(StringUtils.isNotBlank(message)){
        try {
            //解析发送的报文
            JSONObject jsonObject = JSON.parseObject(message);
            //追加发送人(防止串改)
            jsonObject.put("fromUserId", this.userId);
            String toUserId = jsonObject.getString("toUserId");
            System.out.println(toUserId);
            //传送给对应toUserId用户的websocket
            if(StringUtils.isNotBlank(toUserId) && webSocketMap.containsKey(toUserId)){
                webSocketMap.get(toUserId).sendMessage(jsonObject.toJSONString());
            }else{
                //toUserID为null，判定为群聊
                if("null".equals(toUserId)){
                    //向全部人发送消息
                    webSocketMap.forEach((k, v) -> v.sendMessage(jsonObject.toJSONString()));
                }else{
                    //否则不在线，发送到mysql或者redis
                    log.error("请求的userId:" + toUserId + "不在线");
                }
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }
}

2、前端

<template>
  <div>
    <el-row type="flex" class="row-bg" justify="center">
      <el-col :span="12">
          <el-card class="box-card">
              <el-breadcrumb separator-class="el-icon-arrow-right" style="float:left">
                  <el-breadcrumb-item><b>websocket-every</b></el-breadcrumb-item>
              </el-breadcrumb>
              <el-divider></el-divider>
              <el-input
                type="textarea"
                :rows="8"
                placeholder="暂无消息"
                v-model="content">
              </el-input>
              <el-divider></el-divider>
              <p>我的信息：</p>
              <el-input v-model="fromUid" placeholder="请输入您的id"></el-input>
              <el-input
                style="margin-top: 5px"
                type="textarea"
                :rows="4"
                placeholder="请输入消息内容"
                v-model="msg">
              </el-input>
              <p><el-button plain @click="send">发送</el-button></p>
              <p><el-button plain @click="connect">建立连接</el-button></p>
          </el-card>
      </el-col>
    </el-row>
  </div>
</template>
<script>
import { Message } from 'element-ui';
export default {
    data() {
        return {
          socket: null,
          content: '',
          //为群聊，则接受者为null
          toUid: null,
          fromUid: '',
          msg: '',
          acceptMsg: ''
        };
    },
    methods:{
      send(){
        console.log('发送消息：' + this.msg);
        this.socket.send('{"toUserId":"' + this.toUid + '","contentText":"' + this.msg + '"}');
        Message.success('消息发送成功')
        this.content += '\n\t\t\t' + this.fromUid + ':' + this.msg;
      },
      connect(){
        let _this = this;
        const socketUrl = "ws://localhost:8080/api/pushMessage/" + this.fromUid;
        console.log('当前连接地址：' + socketUrl);
        if(this.socket != null){
          this.socket.close();
          this.socket = null;
        }
        this.socket = new WebSocket(socketUrl);
        //打开事件
        this.socket.onopen = function() {
          console.log("websocket已打开");
          Message.success('已建立连接')
        };
        //获得消息事件
        this.socket.onmessage = function(msg) {
          console.log('获取到消息：' + msg.data);
          //发现消息进入,开始处理前端触发逻辑
          let s = msg.data.split('{')
          if(s.length <= 1){
            _this.content += '\n' + msg.data;
          }else{
            _this.acceptMsg = JSON.parse(msg.data);
            if(_this.acceptMsg.toUserId === 'null' && _this.acceptMsg.fromUserId === _this.fromUid){
              //toUserId为null，且为自己发送的消息，则不显示自己的信息在聊天框左侧
            }else{
              _this.content += '\n' + _this.acceptMsg.fromUserId + ':' + _this.acceptMsg.contentText;
            }
          }
        };
        //关闭事件
        this.socket.onclose = function() {
          console.log("websocket已关闭");
          _this.content += '\nwebsocket已关闭';
        };
        //发生了错误事件
        this.socket.onerror = function() {
          console.log("websocket发生了错误");
        }
      },
    }
};
</script>
<style scoped>
</style>