BIO~~

article/2025/3/17 20:22:17

BIO~~

  • 第一章 Java的I/O演进之路
    • 2.1 I/O 模型基本说明
    • 2.2 I/O模型
        • Java BIO
        • Java NIO
        • Java AIO
    • 2.3 BIO、NIO、AIO 适用场景分析
  • 第三章 JAVA BIO深入剖析
    • 3.1 Java BIO 基本介绍
    • 3.2 Java BIO 工作机制
    • 3.3 传统的BIO编程实例回顾
      • 客户端案例如下
      • 服务端案例如下
      • 小结
    • 3.4 BIO模式下多发和多收消息
      • 客户端代码如下
      • 服务端代码如下
      • 小结
    • 3.5 BIO模式下接收多个客户端
      • 概述
      • 客户端案例代码如下
      • 服务端案例代码如下
      • 小结
    • 3.6 伪异步I/O编程
      • 概述
      • 客户端源码分析
      • 线程池处理类
      • 服务端源码分析
      • 小结
    • 3.7 基于BIO形式下的文件上传
      • 目标
      • 客户端开发
      • 服务端开发
      • 小结
    • 3.9 Java BIO模式下的端口转发思想
    • 3.10 基于BIO模式下即时通信
      • 项目功能演示
        • 项目案例说明
        • 功能清单简单说明：
      • 服务端设计
        • 服务端接收多个客户端逻辑
          • 目标
          • 实现步骤
          • 代码实现
          • 小结
        • 服务端接收登陆消息以及监测离线
          • 目标
          • 实现步骤
          • 代码实现
          • 小结
        • 服务端接收群聊消息
          • 目标
          • 实现步骤
          • 代码实现
          • 小结
        • 服务端接收私聊消息
          • 目标
          • 实现步骤
          • 代码实现
          • 小结
      • 客户端设计
        • 启动客户端界面 ,登陆，刷新在线
          • 目标
          • 实现步骤
          • 代码实现
          • 小结
        • 客户端发送消息逻辑
          • 目标
          • 实现步骤
          • 代码实现
          • 小结

第一章 Java的I/O演进之路

2.1 I/O 模型基本说明

I/O 模型：就是用什么样的通道或者说是通信模式和架构进行数据的传输和接收，很大程度上决定了程序通信的性能，Java 共支持 3 种网络编程的/IO 模型：BIO、NIO、AIO

实际通信需求下，要根据不同的业务场景和性能需求决定选择不同的I/O模型请添加图片描述

2.2 I/O模型

Java BIO

同步并阻塞(传统阻塞型)，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销 [简单示意图]

请添加图片描述

Java NIO

Java NIO ： 同步非阻塞，服务器实现模式为一个线程处理多个请求(连接)，即客户端发送的连接请求都会注
册到多路复用器上，多路复用器轮询到连接有 I/O 请求就进行处理 【简单示意图】

请添加图片描述

Java AIO

Java AIO(NIO.2) ： 异步 异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理，一般适用于连接数较多且连接时间较长的应用

2.3 BIO、NIO、AIO 适用场景分析

1、BIO 方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序简单易理解。

2、NIO 方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，弹幕系统，服务器间通讯等。
编程比较复杂，JDK1.4 开始支持。

3、AIO 方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用 OS 参与并发操作，
编程比较复杂，JDK7 开始支持。

第三章 JAVA BIO深入剖析

3.1 Java BIO 基本介绍

  • Java BIO 就是传统的 java io 编程，其相关的类和接口在 java.io包下
  • BIO(blocking I/O) ： 同步阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，可以通过线程池机制改善(实现多个客户连接服务器).

3.2 Java BIO 工作机制

请添加图片描述

对 BIO 编程流程的梳理

  1. 服务器端启动一个 ServerSocket，注册端口，调用accpet方法监听客户端的Socket连接。
  2. 客户端启动 Socket 对服务器进行通信，默认情况下服务器端需要对每个客户 建立一个线程与之通讯

3.3 传统的BIO编程实例回顾

​ 网络编程的基本模型是Client/Server模型，也就是两个进程之间进行相互通信，其中服务端提供位置信息（绑定IP地址和端口），客户端通过连接操作向服务端监听的端口地址发起连接请求，基于TCP协议下进行三次握手连接，连接成功后，双方通过网络套接字（Socket）进行通信。

​ 传统的同步阻塞模型开发中，服务端ServerSocket负责绑定IP地址，启动监听端口；客户端Socket负责发起连接操作。连接成功后，双方通过输入和输出流进行同步阻塞式通信。
​ 基于BIO模式下的通信，客户端 - 服务端是完全同步，完全耦合的。

客户端案例如下

import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
/**目标: Socket网络编程。Java提供了一个包：java.net下的类都是用于网络通信。Java提供了基于套接字（端口）Socket的网络通信模式，我们基于这种模式就可以直接实现TCP通信。只要用Socket通信，那么就是基于TCP可靠传输通信。功能1：客户端发送一个消息，服务端接口一个消息，通信结束！！创建客户端对象：（1）创建一个Socket的通信管道，请求与服务端的端口连接。（2）从Socket管道中得到一个字节输出流。（3）把字节流改装成自己需要的流进行数据的发送创建服务端对象：（1）注册端口（2）开始等待接收客户端的连接,得到一个端到端的Socket管道（3）从Socket管道中得到一个字节输入流。（4）把字节输入流包装成自己需要的流进行数据的读取。Socket的使用：构造器：public Socket(String host, int port)方法：  public OutputStream getOutputStream()：获取字节输出流public InputStream getInputStream() :获取字节输入流ServerSocket的使用：构造器：public ServerSocket(int port)小结：通信是很严格的，对方怎么发你就怎么收，对方发多少你就只能收多少！！*/
public class ClientDemo {public static void main(String[] args) throws Exception {System.out.println("==客户端的启动==");// （1）创建一个Socket的通信管道，请求与服务端的端口连接。Socket socket = new Socket("127.0.0.1",8888);// （2）从Socket通信管道中得到一个字节输出流。OutputStream os = socket.getOutputStream();// （3）把字节流改装成自己需要的流进行数据的发送PrintStream ps = new PrintStream(os);// （4）开始发送消息ps.println("我是客户端，我想约你吃小龙虾！！！");ps.flush();}
}

服务端案例如下

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;/*** 服务端*/
public class ServerDemo {public static void main(String[] args) throws Exception {System.out.println("==服务器的启动==");// （1）注册端口ServerSocket serverSocket = new ServerSocket(8888);//（2）开始在这里暂停等待接收客户端的连接,得到一个端到端的Socket管道Socket socket = serverSocket.accept();//（3）从Socket管道中得到一个字节输入流。InputStream is = socket.getInputStream();//（4）把字节输入流包装成自己需要的流进行数据的读取。BufferedReader br = new BufferedReader(new InputStreamReader(is));//（5）读取数据String line ;while((line = br.readLine())!=null){System.out.println("服务端收到："+line);}}
}

小结

  • 在以上通信中，服务端会一直等待客户端的消息，因为读取完一行数据后，会再次进入readline方法读取，此时如果客户端没有进行消息的发送，服务端将一直进入阻塞状态，因为开启的流并不会被关闭，除非断开连接或者手动关闭。
  • 同时服务端是按照行获取消息的，这意味着客户端也必须按照行进行消息的发送，否则服务端将进入等待消息的阻塞状态！(因为读取不到换行符，认为客户端还有消息没发送过来)

3.4 BIO模式下多发和多收消息

​ 在1.3的案例中，只能实现客户端发送消息，服务端接收消息，并不能实现反复的收消息和反复的发消息，我们只需要在客户端案例中，加上反复按照行发送消息的逻辑即可！案例代码如下：

客户端代码如下

import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;/**目标: Socket网络编程。功能1：客户端可以反复发消息，服务端可以反复收消息小结：通信是很严格的，对方怎么发你就怎么收，对方发多少你就只能收多少！！*/
public class ClientDemo {public static void main(String[] args) throws Exception {System.out.println("==客户端的启动==");// （1）创建一个Socket的通信管道，请求与服务端的端口连接。Socket socket = new Socket("127.0.0.1",8888);// （2）从Socket通信管道中得到一个字节输出流。OutputStream os = socket.getOutputStream();// （3）把字节流改装成自己需要的流进行数据的发送PrintStream ps = new PrintStream(os);// （4）开始发送消息Scanner sc = new Scanner(System.in);while(true){System.out.print("请说:");String msg = sc.nextLine();ps.println(msg);ps.flush();}}
}

服务端代码如下

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;/*** 服务端*/
public class ServerDemo {public static void main(String[] args) throws Exception {String s = "886";System.out.println("886".equals(s));System.out.println("==服务器的启动==");//（1）注册端口ServerSocket serverSocket = new ServerSocket(8888);//（2）开始在这里暂停等待接收客户端的连接,得到一个端到端的Socket管道Socket socket = serverSocket.accept();//（3）从Socket管道中得到一个字节输入流。InputStream is = socket.getInputStream();//（4）把字节输入流包装成  自己需要的流进行数据的读取。BufferedReader br = new BufferedReader(new InputStreamReader(is));//（5）读取数据String line ;while((line = br.readLine())!=null){System.out.println("服务端收到："+line);}}
}

小结

  • 本案例中确实可以实现客户端多发多收
  • 但是服务端只能处理一个客户端的请求，因为服务端是单线程的。一次只能与一个客户端进行消息通信。

3.5 BIO模式下接收多个客户端

概述

​ 在上述的案例中，一个服务端只能接收一个客户端的通信请求，那么如果服务端需要处理很多个客户端的消息通信请求应该如何处理呢，此时我们就需要在服务端引入线程了，也就是说客户端每发起一个请求，服务端就创建一个新的线程来处理这个客户端的请求，这样就实现了一个客户端一个线程的模型，图解模式如下：

请添加图片描述

客户端案例代码如下

/**目标: Socket网络编程。功能1：客户端可以反复发，一个服务端可以接收无数个客户端的消息！！小结：服务器如果想要接收多个客户端，那么必须引入线程，一个客户端一个线程处理！！*/
public class ClientDemo {public static void main(String[] args) throws Exception {System.out.println("==客户端的启动==");// （1）创建一个Socket的通信管道，请求与服务端的端口连接。Socket socket = new Socket("127.0.0.1",7777);// （2）从Socket通信管道中得到一个字节输出流。OutputStream os = socket.getOutputStream();// （3）把字节流改装成自己需要的流进行数据的发送PrintStream ps = new PrintStream(os);// （4）开始发送消息Scanner sc = new Scanner(System.in);while(true){System.out.print("请说:");String msg = sc.nextLine();ps.println(msg);ps.flush();}}
}

服务端案例代码如下

/**服务端*/
public class ServerDemo {public static void main(String[] args) throws Exception {System.out.println("==服务器的启动==");// （1）注册端口ServerSocket serverSocket = new ServerSocket(7777);while(true){//（2）开始在这里暂停等待接收客户端的连接,得到一个端到端的Socket管道Socket socket = serverSocket.accept();new ServerReadThread(socket).start();System.out.println(socket.getRemoteSocketAddress()+"上线了！");}}
}class ServerReadThread extends Thread{private Socket socket;public ServerReadThread(Socket socket){this.socket = socket;}@Overridepublic void run() {try{//（3）从Socket管道中得到一个字节输入流。InputStream is = socket.getInputStream();//（4）把字节输入流包装成自己需要的流进行数据的读取。BufferedReader br = new BufferedReader(new InputStreamReader(is));//（5）读取数据String line ;while((line = br.readLine())!=null){System.out.println("服务端收到："+socket.getRemoteSocketAddress()+":"+line);}}catch (Exception e){System.out.println(socket.getRemoteSocketAddress()+"下线了！");}}
}

小结

  • 1.每个Socket接收到，都会创建一个线程，线程的竞争、切换上下文影响性能；
  • 2.每个线程都会占用栈空间和CPU资源；
  • 3.并不是每个socket都进行IO操作，无意义的线程处理；
  • 4.客户端的并发访问增加时。服务端将呈现1:1的线程开销，访问量越大，系统将发生线程栈溢出，线程创建失败，最终导致进程宕机或者僵死，从而不能对外提供服务。

3.6 伪异步I/O编程

概述

​ 在上述案例中：客户端的并发访问增加时。服务端将呈现1:1的线程开销，访问量越大，系统将发生线程栈溢出，线程创建失败，最终导致进程宕机或者僵死，从而不能对外提供服务。

​ 接下来我们采用一个伪异步I/O的通信框架，采用线程池和任务队列实现，当客户端接入时，将客户端的Socket封装成一个Task(该任务实现java.lang.Runnable线程任务接口)交给后端的线程池中进行处理。JDK的线程池维护一个消息队列和N个活跃的线程，对消息队列中Socket任务进行处理，由于线程池可以设置消息队列的大小和最大线程数，因此，它的资源占用是可控的，无论多少个客户端并发访问，都不会导致资源的耗尽和宕机。

​ 图示如下:

请添加图片描述

客户端源码分析

public class Client {public static void main(String[] args) {try {// 1.简历一个与服务端的Socket对象：套接字Socket socket = new Socket("127.0.0.1", 9999);// 2.从socket管道中获取一个输出流，写数据给服务端 OutputStream os = socket.getOutputStream() ;// 3.把输出流包装成一个打印流 PrintWriter pw = new PrintWriter(os);// 4.反复接收用户的输入 BufferedReader br = new BufferedReader(new InputStreamReader(System.in));String line = null ;while((line = br.readLine()) != null){pw.println(line);pw.flush();}} catch (Exception e) {e.printStackTrace();}}
}

线程池处理类

// 线程池处理类
public class HandlerSocketThreadPool {// 线程池 private ExecutorService executor;public HandlerSocketThreadPool(int maxPoolSize, int queueSize){this.executor = new ThreadPoolExecutor(3, // 8maxPoolSize,  120L, TimeUnit.SECONDS,new ArrayBlockingQueue<Runnable>(queueSize) );}public void execute(Runnable task){this.executor.execute(task);}
}

服务端源码分析

public class Server {public static void main(String[] args) {try {System.out.println("----------服务端启动成功------------");ServerSocket ss = new ServerSocket(9999);// 一个服务端只需要对应一个线程池HandlerSocketThreadPool handlerSocketThreadPool =new HandlerSocketThreadPool(3, 1000);// 客户端可能有很多个while(true){Socket socket = ss.accept() ; // 阻塞式的！System.out.println("有人上线了！！");// 每次收到一个客户端的socket请求，都需要为这个客户端分配一个// 独立的线程 专门负责对这个客户端的通信！！handlerSocketThreadPool.execute(new ReaderClientRunnable(socket));}} catch (Exception e) {e.printStackTrace();}}}
class ReaderClientRunnable implements Runnable{private Socket socket ;public ReaderClientRunnable(Socket socket) {this.socket = socket;}@Overridepublic void run() {try {// 读取一行数据InputStream is = socket.getInputStream() ;// 转成一个缓冲字符流Reader fr = new InputStreamReader(is);BufferedReader br = new BufferedReader(fr);// 一行一行的读取数据String line = null ;while((line = br.readLine())!=null){ // 阻塞式的！！System.out.println("服务端收到了数据："+line);}} catch (Exception e) {System.out.println("有人下线了");}}
}

小结

  • 伪异步io采用了线程池实现，因此避免了为每个请求创建一个独立线程造成线程资源耗尽的问题，但由于底层依然是采用的同步阻塞模型，因此无法从根本上解决问题。
  • 如果单个消息处理的缓慢，或者服务器线程池中的全部线程都被阻塞，那么后续socket的i/o消息都将在队列中排队。新的Socket请求将被拒绝，客户端会发生大量连接超时。

3.7 基于BIO形式下的文件上传

目标

支持任意类型文件形式的上传。

客户端开发

import java.io.DataOutputStream;
import java.io.FileInputStream;
import java.io.InputStream;
import java.net.Socket;/**目标：实现客户端上传任意类型的文件数据给服务端保存起来。*/
public class Client {public static void main(String[] args) {try(InputStream is = new FileInputStream("C:\\Users\\dlei\\Desktop\\BIO,NIO,AIO\\文件\\java.png");){//  1、请求与服务端的Socket链接Socket socket = new Socket("127.0.0.1" , 8888);//  2、把字节输出流包装成一个数据输出流DataOutputStream dos = new DataOutputStream(socket.getOutputStream());//  3、先发送上传文件的后缀给服务端dos.writeUTF(".png");//  4、把文件数据发送给服务端进行接收byte[] buffer = new byte[1024];int len;while((len = is.read(buffer)) > 0 ){dos.write(buffer , 0 , len);}dos.flush();Thread.sleep(10000);}catch (Exception e){e.printStackTrace();}}
}

服务端开发

import java.net.ServerSocket;
import java.net.Socket;/**目标：服务端开发，可以实现接收客户端的任意类型文件，并保存到服务端磁盘。*/
public class Server {public static void main(String[] args) {try{ServerSocket ss = new ServerSocket(8888);while (true){Socket socket = ss.accept();// 交给一个独立的线程来处理与这个客户端的文件通信需求。new ServerReaderThread(socket).start();}}catch (Exception e){e.printStackTrace();}}
}

import java.io.DataInputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.util.UUID;public class ServerReaderThread extends Thread {private Socket socket;public ServerReaderThread(Socket socket){this.socket = socket;}@Overridepublic void run() {try{// 1、得到一个数据输入流读取客户端发送过来的数据DataInputStream dis = new DataInputStream(socket.getInputStream());// 2、读取客户端发送过来的文件类型String suffix = dis.readUTF();System.out.println("服务端已经成功接收到了文件类型：" + suffix);// 3、定义一个字节输出管道负责把客户端发来的文件数据写出去OutputStream os = new FileOutputStream("C:\\Users\\dlei\\Desktop\\BIO,NIO,AIO\\文件\\server\\"+UUID.randomUUID().toString()+suffix);// 4、从数据输入流中读取文件数据，写出到字节输出流中去byte[] buffer = new byte[1024];int len;while((len = dis.read(buffer)) > 0){os.write(buffer,0, len);}os.close();System.out.println("服务端接收文件保存成功！");}catch (Exception e){e.printStackTrace();}}
}

小结

客户端怎么发，服务端就怎么接收

3.9 Java BIO模式下的端口转发思想

需求：需要实现一个客户端的消息可以发送给所有的客户端去接收。（群聊实现）

请添加图片描述

  • 服务端保存所有连接上来的客户端的socket对象
  • 某个客户端发送的消息，服务端会遍历socket对象集合，挨个发送，自己除外

3.10 基于BIO模式下即时通信

基于BIO模式下的即时通信，我们需要解决客户端到客户端的通信，也就是需要实现客户端与客户端的端口消息转发逻辑。

项目功能演示

项目案例说明

本项目案例为即时通信的软件项目，适合基础加强的大案例，具备综合性。学习本项目案例至少需要具备如下Java SE技术点:

    1. Java 面向对象设计，语法设计。
    1. 多线程技术。
    1. IO流技术。
    1. 网络通信相关技术。
    1. 集合框架。
    1. 项目开发思维。
    1. Java 常用 api 使用。

​ …

功能清单简单说明：

1.客户端登陆功能

  • 可以启动客户端进行登录，客户端登陆只需要输入用户名和服务端ip地址即可。

2.在线人数实时更新。

  • 客户端用户户登陆以后，需要同步更新所有客户端的联系人信息栏。

3.离线人数更新

  • 检测到有客户端下线后，需要同步更新所有客户端的联系人信息栏。

4.群聊

  • 任意一个客户端的消息，可以推送给当前所有客户端接收。

5.私聊

  • 可以选择某个员工，点击私聊按钮，然后发出的消息可以被该客户端单独接收。

6.@消息

  • 可以选择某个员工，然后发出的消息可以@该用户，但是其他所有人都能

7.消息用户和消息时间点

  • 服务端可以实时记录该用户的消息时间点，然后进行消息的多路转发或者选择。

服务端设计

服务端接收多个客户端逻辑

目标

服务端需要接收多个客户端的接入。

实现步骤
  • 1.服务端需要接收多个客户端，目前我们采取的策略是一个客户端对应一个服务端线程。
  • 2.服务端除了要注册端口以外，还需要为每个客户端分配一个独立线程处理与之通信。
代码实现
  • 服务端主体代码，主要进行端口注册，和接收客户端，分配线程处理该客户端请求
public class ServerChat {/** 定义一个集合存放所有在线的socket  */public static Map<Socket, String> onLineSockets = new HashMap<>();public static void main(String[] args) {try {/** 1.注册端口   */ServerSocket serverSocket = new ServerSocket(Constants.PORT);/** 2.循环一直等待所有可能的客户端连接 */while(true){Socket socket = serverSocket.accept();/**3. 把客户端的socket管道单独配置一个线程来处理 */new ServerReader(socket).start();}} catch (Exception e) {e.printStackTrace();}}
}
  • 服务端分配的独立线程类负责处理该客户端Socket的管道请求。
class ServerReader extends Thread {private Socket socket;public ServerReader(Socket socket) {this.socket = socket;}@Overridepublic void run() {try {} catch (Exception e) {e.printStackTrace();}}
}
  • 常量包负责做端口配置
public class Constants {/** 常量 */public static final int PORT = 7778 ;}
小结

​ 本节实现了服务端可以接收多个客户端请求。

服务端接收登陆消息以及监测离线

目标

在上节我们实现了服务端可以接收多个客户端，然后服务端可以接收多个客户端连接，接下来我们要接收客户端的登陆消息。

实现步骤
  • 需要在服务端处理客户端的线程的登陆消息。
  • 需要注意的是，服务端需要接收客户端的消息可能有很多种。
    • 分别是登陆消息，群聊消息，私聊消息 和@消息。
    • 这里需要约定如果客户端发送消息之前需要先发送消息的类型，类型我们使用信号值标志（1，2，3）。
      • 1代表接收的是登陆消息
      • 2代表群发| @消息
      • 3代表了私聊消息
  • 服务端的线程中有异常校验机制，一旦发现客户端下线会在异常机制中处理，然后移除当前客户端用户，把最新的用户列表发回给全部客户端进行在线人数更新。
代码实现
public class ServerReader extends Thread {private Socket socket;public ServerReader(Socket socket) {this.socket = socket;}@Overridepublic void run() {DataInputStream dis = null;try {dis = new DataInputStream(socket.getInputStream());/** 1.循环一直等待客户端的消息 */while(true){/** 2.读取当前的消息类型 ：登录,群发,私聊 , @消息 */int flag = dis.readInt();if(flag == 1){/** 先将当前登录的客户端socket存到在线人数的socket集合中   */String name = dis.readUTF() ;System.out.println(name+"---->"+socket.getRemoteSocketAddress());ServerChat.onLineSockets.put(socket, name);}writeMsg(flag,dis);}} catch (Exception e) {System.out.println("--有人下线了--");// 从在线人数中将当前socket移出去  ServerChat.onLineSockets.remove(socket);try {// 从新更新在线人数并发给所有客户端 writeMsg(1,dis);} catch (Exception e1) {e1.printStackTrace();}}}private void writeMsg(int flag, DataInputStream dis) throws Exception {// DataOutputStream dos = new DataOutputStream(socket.getOutputStream()); // 定义一个变量存放最终的消息形式 String msg = null ;if(flag == 1){/** 读取所有在线人数发给所有客户端去更新自己的在线人数列表 *//** onlineNames = [波仔,zhangsan,波妞]*/StringBuilder rs = new StringBuilder();Collection<String> onlineNames = ServerChat.onLineSockets.values();// 判断是否存在在线人数 if(onlineNames != null && onlineNames.size() > 0){for(String name : onlineNames){rs.append(name+ Constants.SPILIT);}// 波仔003197♣♣㏘♣④④♣zhangsan003197♣♣㏘♣④④♣波妞003197♣♣㏘♣④④♣// 去掉最后的一个分隔符 msg = rs.substring(0, rs.lastIndexOf(Constants.SPILIT));/** 将消息发送给所有的客户端 */sendMsgToAll(flag,msg);}}else if(flag == 2 || flag == 3){}}}private void sendMsgToAll(int flag, String msg) throws Exception {// 拿到所有的在线socket管道 给这些管道写出消息Set<Socket> allOnLineSockets = ServerChat.onLineSockets.keySet();for(Socket sk :  allOnLineSockets){DataOutputStream dos = new DataOutputStream(sk.getOutputStream());dos.writeInt(flag); // 消息类型dos.writeUTF(msg);dos.flush();}}
}
小结
  • 此处实现了接收客户端的登陆消息，然后提取当前在线的全部的用户名称和当前登陆的用户名称发送给全部在线用户更新自己的在线人数列表。

服务端接收群聊消息

目标

在上节实现了接收客户端的登陆消息，然后提取当前在线的全部的用户名称和当前登陆的用户名称发送给全部在线用户更新自己的在线人数列表。接下来要接收客户端发来的群聊消息推送给当前在线的所有客户端

实现步骤
  • 接下来要接收客户端发来的群聊消息。
  • 需要注意的是，服务端需要接收客户端的消息可能有很多种。
    • 分别是登陆消息，群聊消息，私聊消息 和@消息。
    • 这里需要约定如果客户端发送消息之前需要先发送消息的类型，类型我们使用信号值标志（1，2，3）。
      • 1代表接收的是登陆消息
      • 2代表群发| @消息
      • 3代表了私聊消息
代码实现
public class ServerReader extends Thread {private Socket socket;public ServerReader(Socket socket) {this.socket = socket;}@Overridepublic void run() {DataInputStream dis = null;try {dis = new DataInputStream(socket.getInputStream());/** 1.循环一直等待客户端的消息 */while(true){/** 2.读取当前的消息类型 ：登录,群发,私聊 , @消息 */int flag = dis.readInt();if(flag == 1){/** 先将当前登录的客户端socket存到在线人数的socket集合中   */String name = dis.readUTF() ;System.out.println(name+"---->"+socket.getRemoteSocketAddress());ServerChat.onLineSockets.put(socket, name);}writeMsg(flag,dis);}} catch (Exception e) {System.out.println("--有人下线了--");// 从在线人数中将当前socket移出去  ServerChat.onLineSockets.remove(socket);try {// 从新更新在线人数并发给所有客户端 writeMsg(1,dis);} catch (Exception e1) {e1.printStackTrace();}}}private void writeMsg(int flag, DataInputStream dis) throws Exception {// DataOutputStream dos = new DataOutputStream(socket.getOutputStream()); // 定义一个变量存放最终的消息形式 String msg = null ;if(flag == 1){/** 读取所有在线人数发给所有客户端去更新自己的在线人数列表 *//** onlineNames = [波仔,zhangsan,波妞]*/StringBuilder rs = new StringBuilder();Collection<String> onlineNames = ServerChat.onLineSockets.values();// 判断是否存在在线人数 if(onlineNames != null && onlineNames.size() > 0){for(String name : onlineNames){rs.append(name+ Constants.SPILIT);}// 波仔003197♣♣㏘♣④④♣zhangsan003197♣♣㏘♣④④♣波妞003197♣♣㏘♣④④♣// 去掉最后的一个分隔符 msg = rs.substring(0, rs.lastIndexOf(Constants.SPILIT));/** 将消息发送给所有的客户端 */sendMsgToAll(flag,msg);}}else if(flag == 2 || flag == 3){// 读到消息  群发的 或者 @消息String newMsg = dis.readUTF() ; // 消息// 得到发件人 String sendName = ServerChat.onLineSockets.get(socket);// 内容StringBuilder msgFinal = new StringBuilder();// 时间  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss EEE");if(flag == 2){msgFinal.append(sendName).append("  ").append(sdf.format(System.currentTimeMillis())).append("\r\n");msgFinal.append("    ").append(newMsg).append("\r\n");sendMsgToAll(flag,msgFinal.toString());}else if(flag == 3){}}}private void sendMsgToAll(int flag, String msg) throws Exception {// 拿到所有的在线socket管道 给这些管道写出消息Set<Socket> allOnLineSockets = ServerChat.onLineSockets.keySet();for(Socket sk :  allOnLineSockets){DataOutputStream dos = new DataOutputStream(sk.getOutputStream());dos.writeInt(flag); // 消息类型dos.writeUTF(msg);dos.flush();}}
}
小结
  • 此处根据消息的类型判断为群聊消息，然后把群聊消息推送给当前在线的所有客户端。

服务端接收私聊消息

目标

在上节我们接收了客户端发来的群聊消息推送给当前在线的所有客户端，接下来要解决私聊消息的推送逻辑

实现步骤
  • 解决私聊消息的推送逻辑，私聊消息需要知道推送给某个具体的客户端
  • 我们可以接收到客户端发来的私聊用户名称，根据用户名称定位该用户的Socket管道，然后单独推送消息给该Socket管道。
  • 需要注意的是，服务端需要接收客户端的消息可能有很多种。
    • 分别是登陆消息，群聊消息，私聊消息 和@消息。
    • 这里需要约定如果客户端发送消息之前需要先发送消息的类型，类型我们使用信号值标志（1，2，3）。
      • 1代表接收的是登陆消息
      • 2代表群发| @消息
      • 3代表了私聊消息
代码实现
public class ServerReader extends Thread {private Socket socket;public ServerReader(Socket socket) {this.socket = socket;}@Overridepublic void run() {DataInputStream dis = null;try {dis = new DataInputStream(socket.getInputStream());/** 1.循环一直等待客户端的消息 */while(true){/** 2.读取当前的消息类型 ：登录,群发,私聊 , @消息 */int flag = dis.readInt();if(flag == 1){/** 先将当前登录的客户端socket存到在线人数的socket集合中   */String name = dis.readUTF() ;System.out.println(name+"---->"+socket.getRemoteSocketAddress());ServerChat.onLineSockets.put(socket, name);}writeMsg(flag,dis);}} catch (Exception e) {System.out.println("--有人下线了--");// 从在线人数中将当前socket移出去  ServerChat.onLineSockets.remove(socket);try {// 从新更新在线人数并发给所有客户端 writeMsg(1,dis);} catch (Exception e1) {e1.printStackTrace();}}}private void writeMsg(int flag, DataInputStream dis) throws Exception {// DataOutputStream dos = new DataOutputStream(socket.getOutputStream()); // 定义一个变量存放最终的消息形式 String msg = null ;if(flag == 1){/** 读取所有在线人数发给所有客户端去更新自己的在线人数列表 *//** onlineNames = [波仔,zhangsan,波妞]*/StringBuilder rs = new StringBuilder();Collection<String> onlineNames = ServerChat.onLineSockets.values();// 判断是否存在在线人数 if(onlineNames != null && onlineNames.size() > 0){for(String name : onlineNames){rs.append(name+ Constants.SPILIT);}// 波仔003197♣♣㏘♣④④♣zhangsan003197♣♣㏘♣④④♣波妞003197♣♣㏘♣④④♣// 去掉最后的一个分隔符 msg = rs.substring(0, rs.lastIndexOf(Constants.SPILIT));/** 将消息发送给所有的客户端 */sendMsgToAll(flag,msg);}}else if(flag == 2 || flag == 3){// 读到消息  群发的 或者 @消息String newMsg = dis.readUTF() ; // 消息// 得到发件人 String sendName = ServerChat.onLineSockets.get(socket);// 内容StringBuilder msgFinal = new StringBuilder();// 时间  SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss EEE");if(flag == 2){msgFinal.append(sendName).append("  ").append(sdf.format(System.currentTimeMillis())).append("\r\n");msgFinal.append("    ").append(newMsg).append("\r\n");sendMsgToAll(flag,msgFinal.toString());}else if(flag == 3){msgFinal.append(sendName).append("  ").append(sdf.format(System.currentTimeMillis())).append("对您私发\r\n");msgFinal.append("    ").append(newMsg).append("\r\n");// 私发 // 得到给谁私发 String destName = dis.readUTF();sendMsgToOne(destName,msgFinal.toString());}}}/*** @param destName 对谁私发 * @param msg 发的消息内容 * @throws Exception*/private void sendMsgToOne(String destName, String msg) throws Exception {// 拿到所有的在线socket管道 给这些管道写出消息Set<Socket> allOnLineSockets = ServerChat.onLineSockets.keySet();for(Socket sk :  allOnLineSockets){// 得到当前需要私发的socket // 只对这个名字对应的socket私发消息if(ServerChat.onLineSockets.get(sk).trim().equals(destName)){DataOutputStream dos = new DataOutputStream(sk.getOutputStream());dos.writeInt(2); // 消息类型dos.writeUTF(msg);dos.flush();}}}private void sendMsgToAll(int flag, String msg) throws Exception {// 拿到所有的在线socket管道 给这些管道写出消息Set<Socket> allOnLineSockets = ServerChat.onLineSockets.keySet();for(Socket sk :  allOnLineSockets){DataOutputStream dos = new DataOutputStream(sk.getOutputStream());dos.writeInt(flag); // 消息类型dos.writeUTF(msg);dos.flush();}}
}
小结
  • 本节我们解决了私聊消息的推送逻辑，私聊消息需要知道推送给某个具体的客户端Socket管道
  • 我们可以接收到客户端发来的私聊用户名称，根据用户名称定位该用户的Socket管道，然后单独推送消息给该Socket管道。

客户端设计

启动客户端界面 ,登陆，刷新在线

目标

启动客户端界面，登陆，刷新在线人数列表

实现步骤
  • 客户端界面主要是GUI设计，主体页面分为登陆界面和聊天窗口，以及在线用户列表。
  • GUI界面读者可以自行复制使用。
  • 登陆输入服务端ip和用户名后，要请求与服务端的登陆，然后立即为当前客户端分配一个读线程处理客户端的读数据消息。因为客户端可能随时会接收到服务端那边转发过来的各种即时消息信息。
  • 客户端登陆完成，服务端收到登陆的用户名后，会立即发来最新的用户列表给客户端更新。
代码实现

客户端主体代码：

public class ClientChat implements ActionListener {/** 1.设计界面  */private JFrame win = new JFrame();/** 2.消息内容框架 */public JTextArea smsContent =new JTextArea(23 , 50);/** 3.发送消息的框  */private JTextArea smsSend = new JTextArea(4,40);/** 4.在线人数的区域  *//** 存放人的数据 *//** 展示在线人数的窗口 */public JList<String> onLineUsers = new JList<>();// 是否私聊按钮private JCheckBox isPrivateBn = new JCheckBox("私聊");// 消息按钮private JButton sendBn  = new JButton("发送");// 登录界面private JFrame loginView;private JTextField ipEt , nameEt , idEt;private Socket socket ;public static void main(String[] args) {new ClientChat().initView();}private void initView() {/** 初始化聊天窗口的界面 */win.setSize(650, 600);/** 展示登录界面  */displayLoginView();/** 展示聊天界面 *///displayChatView();}private void displayChatView() {JPanel bottomPanel = new JPanel(new BorderLayout());//-----------------------------------------------// 将消息框和按钮 添加到窗口的底端win.add(bottomPanel, BorderLayout.SOUTH);bottomPanel.add(smsSend);JPanel btns = new JPanel(new FlowLayout(FlowLayout.LEFT));btns.add(sendBn);btns.add(isPrivateBn);bottomPanel.add(btns, BorderLayout.EAST);//-----------------------------------------------// 给发送消息按钮绑定点击事件监听器// 将展示消息区centerPanel添加到窗口的中间smsContent.setBackground(new Color(0xdd,0xdd,0xdd));// 让展示消息区可以滚动。win.add(new JScrollPane(smsContent), BorderLayout.CENTER);smsContent.setEditable(false);//-----------------------------------------------// 用户列表和是否私聊放到窗口的最右边Box rightBox = new Box(BoxLayout.Y_AXIS);onLineUsers.setFixedCellWidth(120);onLineUsers.setVisibleRowCount(13);rightBox.add(new JScrollPane(onLineUsers));win.add(rightBox, BorderLayout.EAST);//-----------------------------------------------// 关闭窗口退出当前程序win.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);win.pack();  // swing 加上这句 就可以拥有关闭窗口的功能/** 设置窗口居中,显示出来  */setWindowCenter(win,650,600,true);// 发送按钮绑定点击事件sendBn.addActionListener(this);}private void displayLoginView(){/** 先让用户进行登录*  服务端ip*  用户名*  id*  *//** 显示一个qq的登录框     */loginView = new JFrame("登录");loginView.setLayout(new GridLayout(3, 1));loginView.setSize(400, 230);JPanel ip = new JPanel();JLabel label = new JLabel("   IP:");ip.add(label);ipEt = new JTextField(20);ip.add(ipEt);loginView.add(ip);JPanel name = new JPanel();JLabel label1 = new JLabel("姓名:");name.add(label1);nameEt = new JTextField(20);name.add(nameEt);loginView.add(name);JPanel btnView = new JPanel();JButton login = new JButton("登陆");btnView.add(login);JButton cancle = new JButton("取消");btnView.add(cancle);loginView.add(btnView);// 关闭窗口退出当前程序loginView.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);setWindowCenter(loginView,400,260,true);/** 给登录和取消绑定点击事件 */login.addActionListener(this);cancle.addActionListener(this);}private static void setWindowCenter(JFrame frame, int width , int height, boolean flag) {/** 得到所在系统所在屏幕的宽高 */Dimension ds = frame.getToolkit().getScreenSize();/** 拿到电脑的宽 */int width1 = ds.width;/** 高 */int height1 = ds.height ;System.out.println(width1 +"*" + height1);/** 设置窗口的左上角坐标 */frame.setLocation(width1/2 - width/2, height1/2 -height/2);frame.setVisible(flag);}@Overridepublic void actionPerformed(ActionEvent e) {/** 得到点击的事件源 */JButton btn = (JButton) e.getSource();switch(btn.getText()){case "登陆":String ip = ipEt.getText().toString();String name = nameEt.getText().toString();// 校验参数是否为空// 错误提示String msg = "" ;// 12.1.2.0// \d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\if(ip==null || !ip.matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}")){msg = "请输入合法的服务端ip地址";}else if(name==null || !name.matches("\\S{1,}")){msg = "姓名必须1个字符以上";}if(!msg.equals("")){/** msg有内容说明参数有为空 */// 参数一：弹出放到哪个窗口里面JOptionPane.showMessageDialog(loginView, msg);}else{try {// 参数都合法了// 当前登录的用户,去服务端登陆/** 先把当前用户的名称展示到界面 */win.setTitle(name);// 去服务端登陆连接一个socket管道socket = new Socket(ip, Constants.PORT);//为客户端的socket分配一个线程 专门负责收消息new ClientReader(this,socket).start();// 带上用户信息过去DataOutputStream dos = new DataOutputStream(socket.getOutputStream());dos.writeInt(1); // 登录消息dos.writeUTF(name.trim());dos.flush();// 关系当前窗口 弹出聊天界面loginView.dispose(); // 登录窗口销毁displayChatView(); // 展示了聊天窗口了} catch (Exception e1) {e1.printStackTrace();}}break;case "取消":/** 退出系统 */System.exit(0);break;case "发送":break;}}
}

客户端socket处理线程：

public class ClientReader extends Thread {private Socket socket;// 接收客户端界面，方便收到消息后，更新界面数据。private ClientChat clientChat ;public ClientReader(ClientChat clientChat, Socket socket) {this.clientChat = clientChat;this.socket = socket;}@Overridepublic void run() {try {DataInputStream dis = new DataInputStream(socket.getInputStream());/** 循环一直等待客户端的消息 */while(true){/** 读取当前的消息类型 ：登录,群发,私聊 , @消息 */int flag = dis.readInt();if(flag == 1){// 在线人数消息回来了String nameDatas = dis.readUTF();// 展示到在线人数的界面String[] names = nameDatas.split(Constants.SPILIT);clientChat.onLineUsers.setListData(names);}else if(flag == 2){}}} catch (Exception e) {e.printStackTrace();}}
}
小结
  • 此处说明了如果启动客户端界面，以及登陆功能后，服务端收到新的登陆消息后，会响应一个在线列表用户回来给客户端更新在线人数！

客户端发送消息逻辑

目标

客户端发送群聊消息，@消息，以及私聊消息。

实现步骤
  • 客户端启动后，在聊天界面需要通过发送按钮推送群聊消息，@消息，以及私聊消息。

请添加图片描述

代码实现

客户端主体代码：

public class ClientChat implements ActionListener {/** 1.设计界面  */private JFrame win = new JFrame();/** 2.消息内容框架 */public JTextArea smsContent =new JTextArea(23 , 50);/** 3.发送消息的框  */private JTextArea smsSend = new JTextArea(4,40);/** 4.在线人数的区域  *//** 存放人的数据 *//** 展示在线人数的窗口 */public JList<String> onLineUsers = new JList<>();// 是否私聊按钮private JCheckBox isPrivateBn = new JCheckBox("私聊");// 消息按钮private JButton sendBn  = new JButton("发送");// 登录界面private JFrame loginView;private JTextField ipEt , nameEt , idEt;private Socket socket ;public static void main(String[] args) {new ClientChat().initView();}private void initView() {/** 初始化聊天窗口的界面 */win.setSize(650, 600);/** 展示登录界面  */displayLoginView();/** 展示聊天界面 *///displayChatView();}private void displayChatView() {JPanel bottomPanel = new JPanel(new BorderLayout());//-----------------------------------------------// 将消息框和按钮 添加到窗口的底端win.add(bottomPanel, BorderLayout.SOUTH);bottomPanel.add(smsSend);JPanel btns = new JPanel(new FlowLayout(FlowLayout.LEFT));btns.add(sendBn);btns.add(isPrivateBn);bottomPanel.add(btns, BorderLayout.EAST);//-----------------------------------------------// 给发送消息按钮绑定点击事件监听器// 将展示消息区centerPanel添加到窗口的中间smsContent.setBackground(new Color(0xdd,0xdd,0xdd));// 让展示消息区可以滚动。win.add(new JScrollPane(smsContent), BorderLayout.CENTER);smsContent.setEditable(false);//-----------------------------------------------// 用户列表和是否私聊放到窗口的最右边Box rightBox = new Box(BoxLayout.Y_AXIS);onLineUsers.setFixedCellWidth(120);onLineUsers.setVisibleRowCount(13);rightBox.add(new JScrollPane(onLineUsers));win.add(rightBox, BorderLayout.EAST);//-----------------------------------------------// 关闭窗口退出当前程序win.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);win.pack();  // swing 加上这句 就可以拥有关闭窗口的功能/** 设置窗口居中,显示出来  */setWindowCenter(win,650,600,true);// 发送按钮绑定点击事件sendBn.addActionListener(this);}private void displayLoginView(){/** 先让用户进行登录*  服务端ip*  用户名*  id*  *//** 显示一个qq的登录框     */loginView = new JFrame("登录");loginView.setLayout(new GridLayout(3, 1));loginView.setSize(400, 230);JPanel ip = new JPanel();JLabel label = new JLabel("   IP:");ip.add(label);ipEt = new JTextField(20);ip.add(ipEt);loginView.add(ip);JPanel name = new JPanel();JLabel label1 = new JLabel("姓名:");name.add(label1);nameEt = new JTextField(20);name.add(nameEt);loginView.add(name);JPanel btnView = new JPanel();JButton login = new JButton("登陆");btnView.add(login);JButton cancle = new JButton("取消");btnView.add(cancle);loginView.add(btnView);// 关闭窗口退出当前程序loginView.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);setWindowCenter(loginView,400,260,true);/** 给登录和取消绑定点击事件 */login.addActionListener(this);cancle.addActionListener(this);}private static void setWindowCenter(JFrame frame, int width , int height, boolean flag) {/** 得到所在系统所在屏幕的宽高 */Dimension ds = frame.getToolkit().getScreenSize();/** 拿到电脑的宽 */int width1 = ds.width;/** 高 */int height1 = ds.height ;System.out.println(width1 +"*" + height1);/** 设置窗口的左上角坐标 */frame.setLocation(width1/2 - width/2, height1/2 -height/2);frame.setVisible(flag);}@Overridepublic void actionPerformed(ActionEvent e) {/** 得到点击的事件源 */JButton btn = (JButton) e.getSource();switch(btn.getText()){case "登陆":String ip = ipEt.getText().toString();String name = nameEt.getText().toString();// 校验参数是否为空// 错误提示String msg = "" ;// 12.1.2.0// \d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\if(ip==null || !ip.matches("\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}")){msg = "请输入合法的服务端ip地址";}else if(name==null || !name.matches("\\S{1,}")){msg = "姓名必须1个字符以上";}if(!msg.equals("")){/** msg有内容说明参数有为空 */// 参数一：弹出放到哪个窗口里面JOptionPane.showMessageDialog(loginView, msg);}else{try {// 参数都合法了// 当前登录的用户,去服务端登陆/** 先把当前用户的名称展示到界面 */win.setTitle(name);// 去服务端登陆连接一个socket管道socket = new Socket(ip, Constants.PORT);//为客户端的socket分配一个线程 专门负责收消息new ClientReader(this,socket).start();// 带上用户信息过去DataOutputStream dos = new DataOutputStream(socket.getOutputStream());dos.writeInt(1); // 登录消息dos.writeUTF(name.trim());dos.flush();// 关系当前窗口 弹出聊天界面loginView.dispose(); // 登录窗口销毁displayChatView(); // 展示了聊天窗口了} catch (Exception e1) {e1.printStackTrace();}}break;case "取消":/** 退出系统 */System.exit(0);break;case "发送":// 得到发送消息的内容String msgSend = smsSend.getText().toString();if(!msgSend.trim().equals("")){/** 发消息给服务端 */try {// 判断是否对谁发消息String selectName = onLineUsers.getSelectedValue();int flag = 2 ;// 群发 @消息if(selectName!=null&&!selectName.equals("")){msgSend =("@"+selectName+","+msgSend);/** 判断是否选中了私法 */if(isPrivateBn.isSelected()){/** 私法 */flag = 3 ;//私发消息}}DataOutputStream dos = new DataOutputStream(socket.getOutputStream());dos.writeInt(flag); // 群发消息  发送给所有人dos.writeUTF(msgSend);if(flag == 3){// 告诉服务端我对谁私发dos.writeUTF(selectName.trim());}dos.flush();} catch (Exception e1) {e1.printStackTrace();}}smsSend.setText(null);break;}}
}

客户端socket处理线程：

class ClientReader extends Thread {private Socket socket;private ClientChat clientChat ;public ClientReader(ClientChat clientChat, Socket socket) {this.clientChat = clientChat;this.socket = socket;}@Overridepublic void run() {try {DataInputStream dis = new DataInputStream(socket.getInputStream());/** 循环一直等待客户端的消息 */while(true){/** 读取当前的消息类型 ：登录,群发,私聊 , @消息 */int flag = dis.readInt();if(flag == 1){// 在线人数消息回来了String nameDatas = dis.readUTF();// 展示到在线人数的界面String[] names = nameDatas.split(Constants.SPILIT);clientChat.onLineUsers.setListData(names);}else if(flag == 2){//群发,私聊 , @消息 都是直接显示的。String msg = dis.readUTF() ;clientChat.smsContent.append(msg);// 让消息界面滾動到底端clientChat.smsContent.setCaretPosition(clientChat.smsContent.getText().length());}}} catch (Exception e) {e.printStackTrace();}}
}
小结
  • 此处实现了客户端发送群聊消息，@消息，以及私聊消息。
  • 如果直接点击发送，默认发送群聊消息
  • 如果选中右侧在线列表某个用户，默认发送@消息
  • 如果选中右侧在线列表某个用户，然后选择右下侧私聊按钮默，认发送私聊消息。

http://chatgpt.dhexx.cn/article/vgavviOC.shtml

相关文章

python处理数据的一些代码

python处理数据的一些代码

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 一、如何读取txt文件&#xff0c;将其转化为DataFrame格式二、给DataFrame添加列名三、删除指定行四、读取csv文件&#xff0c;不让第一行成为列名五、读取DataFram…
阅读更多...
BioGRID:蛋白质相互作用数据库

BioGRID:蛋白质相互作用数据库

欢迎关注微信公众号《生信修炼手册》! BioGRID数据库是一个老牌经典的蛋白质相互作用数据库&#xff0c;在今年9月份刚刚分布了最新版本3.5.165&#xff0c;该版本从66,164篇文献中整理出了1,607,037个蛋白质相互作用&#xff0c;28,093个嵌合体信息以及726,378个转录后修饰PTM…
阅读更多...
(NCRE网络技术)中小型网络系统总体规划与设计方法-知识点

(NCRE网络技术)中小型网络系统总体规划与设计方法-知识点

欢迎您阅读此系列文章&#xff0c;文章参考自《全国计算机等级考试三级教程.网络技术》。内容为NCRE三级网络技术主要知识点以及常考点&#xff0c;此知识点总结参照《三级网络技术考试大纲(2018年版)》。阅读此系列文章可以帮助您快速、轻松考取相应证书&#xff01;祝您阅读愉…
阅读更多...
Linux系统如何查看服务器带宽及网络使用情况

Linux系统如何查看服务器带宽及网络使用情况

文章目录 前言  linux查看服务器带宽具体方法  一、使用speedtest-cli命令查看下载和上传最大流量值  二、查看网卡、网络的详情   1.查看服务器网络端口   2.ethtool命令查看宽带大小 三、nload命令实时统计网卡带宽使用率  四、dstat -n命令实时监测网络的状态…
阅读更多...
计算机网络的组成及其逻辑结构

计算机网络的组成及其逻辑结构

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 目录 前言 一、计算机网络的组成 计算机系统&#xff1a; 数据通信系统 网络软件及网络协议 二、计算机网络的逻辑结构 资源子网 通信子网 总结 前言 计算机网络是在20世纪6…
阅读更多...
Linux中centos修改系统时间并写到硬件，Linux中centos设置定时自动同步网络时间

Linux中centos修改系统时间并写到硬件，Linux中centos设置定时自动同步网络时间

文章目录 前言一、centos修改系统时间并写到硬件1.1查看当前的系统时间1.2修改系统时间1.3查看硬件时间1.4同步系统时间和硬件时间1.5本地时间写入硬件时间 二、centos设置定时自动同步网络时间2.1安装ntpdate工具2.2CentOS安装/操纵crontab2.3启动crontab并查看状态2.4写一个c…
阅读更多...
计算机网络的发展简史

计算机网络的发展简史

目录 前言一、互联网发展历史1. 第一阶段&#xff1a;ARPANET2. 第二阶段&#xff1a;三级结构互联网3. 第三阶段&#xff1a;多层次ISP互联网 二、中国互联网的发展简史1. 发展阶段2. 公共网络 总结 前言 时间是2022年的6月&#xff0c;当真正的注意到现在的时间时不禁感叹时…
阅读更多...
浅谈网络舆情监测系统中爬虫的设计及系统架构

浅谈网络舆情监测系统中爬虫的设计及系统架构

前言 说到网络舆情监测想必很多人都不陌生。可以跟大家这么说吧。爬虫所能带来的商业价值适用并深存于所有小-中-大企业中，尤其做网络舆情的大数据公司所有的业务基本都必须依托于爬虫来开展它的战略布局，毕竟有了米才能做饭嘛～ 不信的话我简单的来采访一下做舆情项目的相关…
阅读更多...
基于java的网络在线考试管理系统的设计与实现--毕业开题报告

基于java的网络在线考试管理系统的设计与实现--毕业开题报告

基于java的网络在线考试管理系 统的设计与实现开题报告–毕业设计 最近grace刚完成毕业设计 通过了赶紧来给宝贝们分享我的成果哈哈 设计题目&#xff1a;基于java的网络在线考试管理系统的设计与实现 一、选题依据&#xff1a; 1.国内外有关的研究动态 在线考试系统在国内…
阅读更多...
校园网系统集成方案设计

校园网系统集成方案设计

校园网系统集成方案设计 第一篇的文章献给我的网络系统集成大作业&#xff0c;这篇文章是关于校园网系统集成方案的设计&#xff0c;文章有很多不足仅限于我目前的水平。 第一章 前言 随着经济的发展&#xff0c;信息起着越来越重要的作用。计算机、网络和多媒体等信息技术的…
阅读更多...
VM虚拟机上的网络设置

VM虚拟机上的网络设置

1. 前言 一般Linux编程时，经常都会使用虚拟机跑Linux系统，VMware Workstation Pro 虚拟机里的系统不管是Linux、还是windows、还是其他系统想要上网就必须配置好虚拟网络连接方式。VMware Workstation 支持共享、桥接，选择网卡的方法自定义上网方式。 如果虚拟机里的系统想…
阅读更多...
Cisco Packet Tracer 网络系统工程实训大作业【附网络拓扑图】

Cisco Packet Tracer 网络系统工程实训大作业【附网络拓扑图】

文章目录 前言网络拓扑图资源项目基本要求项目一项目二项目三 实验原理静态路由基本原理VLAN基本原理OSPF的基本原理 项目的实现项目一的设计与实现网络拓扑图接口信息配置流程连通性测试 项目二的设计与实现网络拓扑图接口信息配置流程连通性测试 项目三的设计与实现网络拓扑图…
阅读更多...
零信任网络

零信任网络

“前些天发现了一个巨牛的人工智能学习网站&#xff0c;通俗易懂&#xff0c;风趣幽默&#xff0c;忍不住分享一下给大家。点击跳转到网站。” 前言 - 床长人工智能教程 零信任&#xff1a; 零信任概念是由网络去边界化发展改进而来。之前网络的建设理念中&#xff0c;将网络分…
阅读更多...
Linux系统中网络管理命令和查看网络配置的命令

Linux系统中网络管理命令和查看网络配置的命令

前言 这是我听老师讲课做的笔记,考试要看的。 这是视频地址 作者&#xff1a;RodmaChen 关注我的csdn博客&#xff0c;更多Linux笔记知识还在更新 说明&#xff1a;本人只在csdn写博客&#xff0c;如果在其他网站上看到&#xff0c;请不要信 网络管理命令和查看网络配置的命令 …
阅读更多...
基于卷积神经网络的电影推荐系统

基于卷积神经网络的电影推荐系统

基于卷积神经网络的电影推荐系统 前言1.实现效果1.1 算法运行结果1.2 系统主要界面 2.主要代码实现2.1 网络模型代码2.2 django代码 前言 如今协同过滤等传统推荐算法被广泛用于推荐&#xff0c;但也存在冷启动、矩阵稀疏等问题&#xff0c;本项目用深度学习来实现电影推荐&am…
阅读更多...
炸鸡网络验证系统

炸鸡网络验证系统

文章目录 前言一、炸鸡网络验证系统二、程序演示与下载1.程序演示2.程序下载 前言 今天介绍的是一款才了解到的系统&#xff0c;网络验证系统。具体介绍如下 一、炸鸡网络验证系统 炸鸡网络验证系统基于PhpMySql数据库架构的网络验证系统&#xff0c;安全稳定、性能强悍、承…
阅读更多...
Linux系统的网络设置

Linux系统的网络设置

前言 linux上设置网络需要设置 IP、子网掩码、网关、DNS等。设置正确才可访问网络&#xff0c;否则会出现无法联网的问题。下面会写出如何设置IP等信息&#xff0c;如何处理路由表等操作。 一. 查看网络配置 1.1 查看所有活动网接口的信息 执行ifconfig 命令 ens33&#…
阅读更多...
1.网络安全之windows系统知识

1.网络安全之windows系统知识

提示&#xff1a;文章写完后&#xff0c;目录可以自动生成&#xff0c;如何生成可参考右边的帮助文档 文章目录 前言一、Windows 常见分类二、Windows 常用操作1.Windows常用快捷键2.Windows常用控制台 三、Windows 网络配置1.IP地址2.子网掩码3.默认网关4.Windows Cmd 介绍及使…
阅读更多...
python中split()方法的使用

python中split()方法的使用

split()方法是用来拆分字符串的，返回的数据类型是列表，当传入参数时，必须指定分割符。当不传递参数时，此时将整个字符串作为列表的一个元素返回。 使用方法： 1.空格作为分隔符 2.按点号.分割 当字符串中没有指定分割符时，会将整个字符串作为列表的一个元素返回。 3.包含…
阅读更多...
java split 顺序_Java的split方法说明

java split 顺序_Java的split方法说明

相信大家都经常使用String 的split方法，但是大家有没有遇到下面的这种情况： 大家想想下面的代码执行结果是什么 public static voidmain(String[] args) {//TODO Auto-generated method stub String str1= "a,b,c,,,a"; String str2= "a,b,c,,,"; String…
阅读更多...
推荐文章

Copyright @ 2022~2023