简介：本PPT介绍了一个基于Java和Socket通信技术的简单聊天室应用程序的开发。首先讲解Java的基础知识，接着深入探讨Socket通信原理及其在Java中的实现。介绍了聊天室的系统架构，包括服务器端和客户端的设计，数据传输方法，以及实时消息传递的事件处理机制。PPT内容包括Java和Socket基础、聊天室设计架构、服务器和客户端的代码实现，以及整个系统的运行流程和问题解决方案，旨在帮助学习者掌握如何利用Java和Socket编程技术创建聊天应用，加深对网络通信的理解。 
1. Java基础知识回顾
在深入探索Java高级特性之前，有必要对Java基础知识进行一次系统的回顾。Java以其跨平台特性、面向对象和丰富的API库为世人所熟知。首先，我们需要理解Java程序的生命周期，包括源代码如何编译成字节码，以及Java虚拟机（JVM）如何运行这些字节码。其次，数据类型与变量的概念是构建Java程序的基础。包括基本数据类型（如int、char、double等）和引用数据类型（如类、接口和数组）的区别以及使用场景。接着，掌握控制流程的语句如if-else、for循环和switch-case，是编写逻辑决策和循环结构的关键。最后，对于Java的核心概念，如类与对象、继承、封装、多态，以及异常处理机制的理解，为后续章节中涉及的网络编程和多线程处理提供了理论基础。
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello, Java World!");
}
}
上面的示例代码展示了Java程序的标准入口方法 main 。一个完整的Java项目通常包含一个或多个类文件，每个文件中定义了一个或多个类。理解类和对象的基本使用，是任何Java开发者都需要掌握的基础技能。
2. 深入理解Socket通信技术
2.1 Socket通信原理
2.1.1 网络通信协议概述
网络通信协议是网络中不同主机间进行数据交换时所遵守的标准。最著名的协议是OSI七层模型和TCP/IP协议族。OSI模型将通信过程分为物理层、数据链路层、网络层、传输层、会话层、表示层和应用层。而TCP/IP协议族简化了模型，主要包含网络接口层、网络层、传输层和应用层。
在Socket通信中，最常涉及的两个层是传输层和应用层。传输层提供了端到端的通信服务，TCP协议保证了数据的可靠传输，而UDP协议则提供了不可靠的面向无连接的服务。应用层协议如HTTP、FTP、SMTP等，定义了应用程序之间的通信规范。
2.1.2 Socket通信模型详解
Socket模型是一种网络通信编程模型，允许程序通过端口进行数据交换。Socket通信模型分为服务器端和客户端两部分。
-
服务器端：首先创建一个Socket，绑定到特定的IP地址和端口上，然后监听这个地址端口，等待客户端的连接请求。一旦建立连接，服务器就可以接收和发送数据。
-
客户端：客户端创建一个Socket，指定服务器的IP地址和端口号进行连接。连接成功后，客户端也可以发送和接收数据。
Socket通信模型是一个双向的通道，数据传输可以双向进行，这在很多应用场景中是非常有用的，比如即时通讯软件。
2.1.3 Socket通信的工作流程
- 服务器端监听端口；
- 客户端向服务器端发起连接请求；
- 服务器端接受连接请求，建立连接；
- 数据传输阶段，双方通过读取和写入Socket进行通信；
- 连接关闭，一方或双方结束连接。
2.2 Java中的Socket编程
2.2.1 Java中的Socket类和ServerSocket类
Java通过 ***.Socket 类和 ***.ServerSocket 类来实现Socket通信。
-
Socket类代表客户端和服务端之间的一个连接。客户端通过Socket类的实例来建立和服务器的连接，然后通过这个连接来发送和接收数据。 -
ServerSocket类用于实现服务端监听特定端口，等待客户端的连接请求。当一个请求到来时，它会创建一个新的Socket与客户端进行通信。
2.2.2 使用Java实现Socket通信的基本步骤
以下是一个简单的TCP客户端实现步骤：
- 创建
Socket对象，并指定服务器的IP地址和端口。 - 通过
Socket对象的getInputStream()和getOutputStream()方法获取输入和输出流。 - 通过输入流读取数据，通过输出流发送数据。
- 通信完成后关闭
Socket。
服务端实现步骤：
- 创建
ServerSocket对象，并指定监听的端口。 - 调用
ServerSocket的accept()方法等待客户端连接。 - 接受连接后，返回一个新的
Socket对象。 - 通过
Socket对象的输入输出流与客户端进行通信。 - 通信完成后关闭
Socket和ServerSocket。
2.2.3 代码示例
这是一个简单的TCP服务器端的Java代码实现：
import java.io.*;
***.*;
public class SimpleTCPServer {
public static void main(String[] args) {
int port = 12345;
try (ServerSocket serverSocket = new ServerSocket(port)) {
System.out.println("Server is listening on port " + port);
Socket clientSocket = serverSocket.accept();
System.out.println("New client connected");
InputStream input = clientSocket.getInputStream();
BufferedReader reader = new BufferedReader(new InputStreamReader(input));
String message;
while ((message = reader.readLine()) != null) {
System.out.println("Received: " + message);
}
clientSocket.close();
} catch (IOException ex) {
ex.printStackTrace();
}
}
}
这段代码首先创建了一个 ServerSocket 对象用于监听端口，然后使用 accept() 方法等待连接。一旦客户端连接，它将读取客户端发送的消息直到消息结束（在这个例子中，消息结束是通过输入流结束表示的）。最后关闭 clientSocket 来释放资源。
对应的TCP客户端代码实现如下：
import java.io.*;
***.*;
public class SimpleTCPClient {
public static void main(String[] args) {
String hostname = "localhost";
int port = 12345;
try (Socket socket = new Socket(hostname, port);
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
BufferedReader in = new BufferedReader(new InputStreamReader(socket.getInputStream()))) {
out.println("Hello, world!");
String serverResponse = in.readLine();
System.out.println("Server: " + serverResponse);
} catch (UnknownHostException ex) {
System.err.println("Server not found: " + ex.getMessage());
} catch (IOException ex) {
System.err.println("I/O error: " + ex.getMessage());
}
}
}
在这个客户端实现中， Socket 对象首先连接到指定的服务器和端口。一旦连接成功，通过输出流 PrintWriter 发送消息到服务器，然后使用 BufferedReader 读取服务器的响应。
2.2.4 代码逻辑分析
在服务端代码中， ServerSocket 的构造函数接受端口号作为参数，这表示服务端将会监听指定端口。 accept() 方法使得服务端阻塞等待客户端的连接请求。一旦客户端连接， accept() 返回一个新的 Socket 对象，这个对象代表与客户端的连接。
客户端代码中，首先创建了一个 Socket 实例。构造函数接受服务器的主机名和端口。连接建立后，客户端通过 PrintWriter 发送一条消息。接着，它通过 BufferedReader 等待并读取服务器端的响应。
以上是使用Java实现Socket通信的基础。在实际应用中，往往需要考虑更复杂的网络协议和数据处理方式，以及如何处理网络异常和多线程情况。
2.2.5 总结
本节内容首先介绍了网络通信协议的基础知识，然后深入解析了Socket通信原理，并通过Java中的Socket类和ServerSocket类的实例代码演示了如何使用Java实现基本的Socket通信。通过这些示例，我们能够理解Java中Socket通信的工作流程和基本方法，为后续章节中针对实际应用场景的深入讲解打下了基础。
下一章我们将探讨聊天室系统的架构设计，包括功能需求分析、架构模式选择等，这些都是在构建实用的聊天应用时必须考虑的要素。
3. 聊天室系统架构设计
3.1 聊天室的功能需求分析
3.1.1 用户模块设计
在设计聊天室的用户模块时，关键要素包括用户注册、登录、注销以及用户信息管理等功能。用户模块的构建应考虑以下几个核心点：
- 用户唯一性 ：需要有唯一标识用户的方式，如用户名或邮箱，确保每个用户都有自己的独立身份。
- 安全机制 ：用户密码应当加密存储，常用的方法有哈希加盐技术，以保证用户信息的安全性。
- 信息存储 ：用户的个人信息、登录记录和操作日志需要合理存储，便于后续的查询和管理。
- 权限管理 ：区分普通用户和管理员角色，赋予不同权限，如用户管理、聊天室管理等。
// 用户类设计示例
public class User {
private String username;
private String passwordHash; // 密码的哈希值
private String salt; // 加盐值
// 构造器、getter和setter省略
public boolean checkPassword(String inputPassword) {
// 实现密码校验逻辑
}
}
// 用户注册逻辑
public void register(String username, String password) {
// 检查用户名是否已存在
// 生成盐值
// 对密码进行哈希处理并存储
// 存储用户信息到数据库
}
3.1.2 聊天模块设计
聊天模块是聊天室的核心部分，主要包括消息的发送与接收、聊天室的创建和加入、以及消息的存储与检索等功能。聊天模块的设计重点包括：
- 消息传输 ：确保消息能够实时且准确地在用户间传递。
- 消息持久化 ：对于历史消息的存储和查询，以便用户查看之前的聊天记录。
- 并发处理 ：支持大量用户同时在线聊天，保证系统的高并发处理能力。
// 消息类设计示例
public class Message {
private User sender;
private User receiver;
private String content;
private LocalDateTime sendTime;
// 构造器、getter和setter省略
}
// 消息发送逻辑
public void sendMessage(Message message) {
// 将消息发送到接收者
// 消息存储到数据库
}
3.2 聊天室架构模式选择
3.2.1 C/S架构与B/S架构的对比
C/S（Client/Server）架构和B/S（Browser/Server）架构是两种常见的网络应用架构模式。它们在聊天室的应用中各有利弊：
- C/S架构 ：客户端需要安装特定的软件来使用服务。它提供了较强的交互性和响应速度，但更新和维护较为麻烦，安装和部署成本较高。
- B/S架构 ：用户只需通过Web浏览器即可访问服务，易于部署和维护，用户使用门槛低。但对网络的依赖较大，且交互性能不如C/S架构。
3.2.2 聊天室适用的架构模式
针对聊天室的实时性、交互性、以及用户基数的特点，两种架构模式各有优劣。但鉴于当前互联网环境下的普遍需求，B/S架构更符合现代网络应用的发展趋势。通过Web Socket等技术，B/S架构的聊天室可以实现类似C/S架构的即时通讯体验，同时保留了Web应用的优势。
graph LR
A[聊天室用户] -->|通过浏览器访问| B[Web服务器]
B -->|处理请求| C[后端服务]
C -->|推送消息| B
B -->|回显消息| A
本章节通过对聊天室的功能需求和架构模式选择进行了详尽分析，为后续的技术实现打下了坚实的基础。在下一章节中，我们将深入探讨服务器端的核心代码实现以及多线程处理的详细内容。
4. 服务器端代码实现与多线程处理
4.1 服务器端核心代码解析
4.1.1 服务器监听与连接处理
在构建一个聊天服务器时，监听特定端口并处理客户端的连接请求是核心功能之一。这通常通过实现一个服务器套接字来完成，该套接字在指定端口上监听来自客户端的连接请求。当客户端发起连接请求时，服务器端需要接收连接并创建一个独立的线程来处理该连接，从而实现并发通信。
以下是一个简单的服务器端代码实现示例：
import java.io.*;
***.*;
public class ChatServer {
private ServerSocket serverSocket;
public ChatServer(int port) throws IOException {
serverSocket = new ServerSocket(port);
}
public void start() {
while (true) {
try {
Socket clientSocket = serverSocket.accept();
System.out.println("客户端已连接: " + clientSocket.getInetAddress().getHostAddress());
new ClientHandler(clientSocket).start();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private static class ClientHandler extends Thread {
private Socket clientSocket;
public ClientHandler(Socket socket) {
this.clientSocket = socket;
}
public void run() {
// 处理客户端连接
}
}
public static void main(String[] args) throws IOException {
ChatServer server = new ChatServer(8080);
server.start();
}
}
在这段代码中， ChatServer 类构造函数中创建了一个 ServerSocket 实例，绑定到指定端口上。 start 方法中使用一个无限循环来监听端口，每当有新的客户端连接时，就会调用 serverSocket.accept() 方法。此方法会阻塞，直到有客户端请求连接，然后创建一个新的 Socket 实例，并将这个套接字交给 ClientHandler 线程处理。
4.1.2 多线程机制的应用
为了同时处理多个客户端，服务器端通常会为每个接受的连接创建一个新的线程。Java中实现多线程处理的一种简单方式是通过继承 Thread 类或者实现 Runnable 接口。在前面的代码示例中，每个新连接都通过创建一个新的 ClientHandler 线程来处理。
这使得服务器可以并发地处理多个客户端请求，而不会互相阻塞。不过，需要注意的是，创建过多的线程可能会导致上下文切换的开销增大，影响性能。为了解决这个问题，可以使用线程池来复用线程资源。
4.2 多线程同步与异常处理
4.2.1 线程同步机制的实现
在多线程环境中，数据共享和更新必须是线程安全的。如果多个线程试图同时访问同一个共享资源，就可能产生竞态条件，导致数据不一致或者其他不可预知的行为。Java提供了多种机制来保证线程安全，例如同步代码块、锁、以及 synchronized 关键字。
例如，在处理聊天信息时，确保消息队列的线程安全是至关重要的。下面是一个使用 synchronized 关键字的简单示例：
public class MessageQueue {
private Queue<String> queue = new LinkedList<>();
public synchronized void enqueue(String message) {
queue.offer(message);
}
public synchronized String dequeue() {
return queue.poll();
}
}
在这个示例中， MessageQueue 类中的 enqueue 和 dequeue 方法都是同步的，保证了同一时刻只有一个线程能操作队列。
4.2.2 异常处理策略及安全性保障
异常处理是编写健壮多线程应用的重要组成部分。在多线程环境中，除了要处理常规的运行时异常之外，还需要处理中断异常，以及由于资源受限而导致的异常情况。
例如，当线程因为等待某个资源而阻塞时，可能需要响应外部的中断请求。Java 提供了 InterruptedException 来处理这种中断情况。此外，还需要注意处理资源耗尽导致的异常，如 OutOfMemoryError 。
在服务器端，还需要注意网络连接的异常处理，如 IOException 。以下是一些异常处理的基本策略：
- 捕获并处理异常，确保程序能够继续运行。
- 记录异常信息，便于问题追踪和调试。
- 在合适的情况下，通知用户相关的异常情况。
- 考虑异常恢复机制，例如在异常发生后尝试重新连接资源或者进行回滚操作。
异常处理策略的合理设计，不仅能够确保系统在遇到意外情况时的稳定性，还能够提升用户体验，确保应用的连续性和安全性。
在后续章节中，我们将深入到客户端连接与数据交互的细节，以及如何优化数据传输和处理事件驱动模型。
5. 客户端连接与数据交互
5.1 客户端连接机制
5.1.1 客户端Socket的创建和连接
在Java中，客户端通过Socket与服务器进行通信。首先，需要创建一个Socket实例，并指定服务器的IP地址和端口号。这个过程涉及到的Java代码示例如下：
import java.io.IOException;
import java.io.PrintWriter;
***.Socket;
public class Client {
public static void main(String[] args) {
String serverIP = "***.*.*.*"; // 服务器IP地址
int port = 12345; // 服务器端口号
try (Socket socket = new Socket(serverIP, port)) {
// 连接成功后的操作
System.out.println("Connected to server...");
// 示例：发送消息到服务器
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);
out.println("Hello, Server!");
// 示例：接收服务器的响应
java.util.Scanner in = new java.util.Scanner(socket.getInputStream());
System.out.println("Server says: " + in.nextLine());
} catch (IOException e) {
e.printStackTrace();
}
}
}
参数说明和代码逻辑分析
-
Socket socket = new Socket(serverIP, port);：创建一个新的socket连接到服务器。如果连接失败，会抛出一个IOException异常。 -
PrintWriter out = new PrintWriter(socket.getOutputStream(), true);：创建一个用于发送消息到服务器的PrintWriter实例。 -
out.println("Hello, Server!");：通过socket发送消息。 -
java.util.Scanner in = new java.util.Scanner(socket.getInputStream());：创建一个Scanner对象来读取来自服务器的数据。 -
System.out.println("Server says: " + in.nextLine());：读取服务器的响应并打印出来。
5.1.2 连接异常处理和断线重连策略
在实际应用中，网络连接可能会因为多种原因中断，如网络不稳定、服务器宕机等。因此，客户端需要具备异常处理和断线重连的能力。以下是异常处理和断线重连的代码示例：
// ...之前的代码
try (Socket socket = new Socket(serverIP, port)) {
// 处理连接逻辑...
} catch (IOException e) {
// 尝试断线重连
try {
int reconnectAttempts = 3; // 尝试重连次数
for (int i = 0; i < reconnectAttempts; i++) {
try {
System.out.println("Attempting to reconnect...");
socket = new Socket(serverIP, port);
System.out.println("Reconnected to server.");
// 重连成功后，可以继续之前的逻辑
break;
} catch (IOException ex) {
if (i == reconnectAttempts - 1) {
System.err.println("Reconnection failed after " + reconnectAttempts + " attempts.");
}
}
}
} catch (Exception ex) {
ex.printStackTrace();
}
}
在上述代码中，客户端尝试连接到服务器，并捕获可能发生的异常。如果发生异常，它会进入一个循环，尝试重新连接服务器，直到达到指定的重连次数。重连成功后，可以恢复之前的连接逻辑。若重连失败，将输出错误信息。
5.2 客户端数据交互实现
5.2.1 发送和接收消息
在客户端与服务器的通信过程中，发送和接收消息是最基本的操作。在客户端，需要有代码来不断监听服务器发送过来的数据，并处理。同时，用户界面会提供输入框，让用户输入消息并发送给服务器。下面是一个简化的消息发送和接收的实现：
// ...之前的代码
Socket socket = null;
try {
socket = new Socket(serverIP, port);
// ...其他代码，比如创建输入输出流
} catch (IOException e) {
e.printStackTrace();
}
// 接收消息的线程
new Thread(() -> {
try (Scanner in = new Scanner(socket.getInputStream())) {
while (!Thread.interrupted()) {
String response = in.nextLine();
System.out.println("Server: " + response);
}
} catch (IOException e) {
e.printStackTrace();
}
}).start();
// 发送消息的线程
new Thread(() -> {
try (PrintWriter out = new PrintWriter(socket.getOutputStream(), true)) {
while (!Thread.interrupted()) {
String message = getMessageFromUserInterface();
if (message != null) {
out.println(message);
}
}
} catch (IOException e) {
e.printStackTrace();
}
}).start();
参数说明和代码逻辑分析
- 线程用于不断地监听来自服务器的消息，并且发送用户通过用户界面输入的消息。
-
Scanner in = new Scanner(socket.getInputStream())创建一个Scanner对象用于读取服务器消息。 -
PrintWriter out = new PrintWriter(socket.getOutputStream(), true)创建一个PrintWriter对象用于发送消息给服务器。
5.2.2 消息的格式和处理流程
在客户端与服务器进行通信时，消息的格式和处理流程需要明确。通常，消息会有一个固定的格式，比如JSON或者XML，客户端和服务器都需要遵循这种格式。消息处理流程通常包括解析消息、处理消息以及响应。下面是一个简单的消息格式化与处理流程的示例：
// ...之前的代码
// 消息格式化工具类
class MessageFormatter {
public static String createMessage(String type, String content) {
return "{\"type\":\"" + type + "\", \"content\":\"" + content + "\"}";
}
public static String getType(String message) {
// 实现JSON解析，获取消息类型
return ...;
}
public static String getContent(String message) {
// 实现JSON解析，获取消息内容
return ...;
}
}
// 消息处理流程
String messageFromServer = ...; // 从服务器接收到的消息
String type = MessageFormatter.getType(messageFromServer);
String content = MessageFormatter.getContent(messageFromServer);
switch (type) {
case "LOGIN":
// 处理登录消息
break;
case "MESSAGE":
// 处理聊天消息
break;
// ...其他消息类型处理
default:
// 未知消息类型处理
break;
}
参数说明和代码逻辑分析
-
MessageFormatter.createMessage(String type, String content)：这是一个静态方法，用于创建一个格式化的消息字符串。 -
MessageFormatter.getType(String message)和MessageFormatter.getContent(String message)：这些方法用于解析消息，提取出消息类型和内容。 - 在消息处理流程中，通过解析出的消息类型来决定如何处理消息。根据不同的消息类型，可以有登录、聊天、退出等多种不同的处理方式。
通过本章的介绍，我们了解了客户端连接和数据交互的基本原理与实现方式。在此基础上，下一章节将进一步探讨服务器端的代码实现，以及如何高效地处理多线程环境下的数据传输问题。
6. 数据传输与事件处理
6.1 数据传输的优化策略
在聊天室系统中，数据传输的效率和准确性直接影响用户体验。要优化数据传输，我们不仅需要考虑网络带宽和延迟，还要考虑数据的格式和处理方式。
6.1.1 数据压缩与传输效率
在网络通信中，数据压缩是一种常见的优化策略，特别是在聊天室系统中，用户发送的消息可能包含大量重复的格式化数据或表情符号，这为数据压缩提供了良好的适用场景。
import java.util.zip.Deflater;
import java.util.zip.DeflaterOutputStream;
import java.util.zip.GZIPInputStream;
import java.util.zip.GZIPOutputStream;
// 数据压缩示例代码
public byte[] compressData(byte[] data) throws IOException {
Deflater compressor = new Deflater();
compressor.setInput(data);
compressor.finish();
ByteArrayOutputStream bos = new ByteArrayOutputStream(data.length);
DeflaterOutputStream dos = new DeflaterOutputStream(bos, compressor);
dos.write(data);
dos.close();
return bos.toByteArray();
}
// 数据解压缩示例代码
public byte[] decompressData(byte[] data) throws IOException {
GZIPInputStream gis = new GZIPInputStream(new ByteArrayInputStream(data));
ByteArrayOutputStream bos = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int len;
while ((len = gis.read(buffer)) != -1) {
bos.write(buffer, 0, len);
}
return bos.toByteArray();
}
在上述示例中，我们展示了如何使用Java内置的 Deflater 类来压缩数据，以及使用 GZIPInputStream 来解压缩数据。压缩和解压缩过程都应放在合适的时机，比如在消息发送之前进行压缩，在服务器或客户端接收消息之后进行解压缩。
6.1.2 断点续传和文件传输
在聊天室系统中，文件传输是一个常见的需求。由于文件通常较大，直接传输可能会受到网络状况的影响，导致传输失败。实现断点续传功能可以解决这一问题。
public void sendFile(Socket client, File file) throws IOException {
// 使用输入流打开文件
FileInputStream fis = new FileInputStream(file);
// 发送文件名和文件大小作为文件信息
String fileName = file.getName();
long fileSize = file.length();
client.getOutputStream().write((fileName + ":" + fileSize).getBytes());
// 实现断点续传机制，这里只是一个简单的实现框架
// 实际应用中需要保存已传输的文件位置，并在重连时从该位置继续传输
long transferred = 0;
byte[] buffer = new byte[4096];
while (transferred < fileSize) {
int read = fis.read(buffer);
if (read < 0) {
break;
}
client.getOutputStream().write(buffer, 0, read);
transferred += read;
}
// 发送完成消息给客户端
client.getOutputStream().write("transfer completed".getBytes());
fis.close();
}
在文件传输时，需要先发送文件名和文件大小信息。然后开始文件的读取和发送过程，如果发送过程中发生中断，可以在重连时根据已发送的文件大小信息继续发送剩余部分，从而实现断点续传。
6.2 基于事件的通信机制
事件驱动模型是一种重要的编程范式，特别是在UI应用程序中，它允许程序在事件发生时做出响应。在聊天室系统中，我们也可以使用事件驱动模型来处理各种通信事件。
6.2.1 事件驱动模型的原理
事件驱动模型的核心思想是，程序由事件组成，而事件则由事件处理器来处理。当一个事件发生时，系统会自动调用与该事件相关联的事件处理器。
在Java中，我们可以使用事件监听器和回调方法来实现事件驱动模型。例如，我们可以创建一个事件类和一个监听接口，监听器注册到事件类上，并在事件发生时被回调。
6.2.2 实现事件监听和回调处理
在Java中， java.util.Observer 和 java.util.Observable 是两个与事件监听相关的类。我们可以利用这些类来实现聊天室中的消息通知机制。
import java.util.Observable;
import java.util.Observer;
public class MessageObservable extends Observable {
private String message;
// 设置消息，通知观察者
public void setMessage(String message) {
this.message = message;
setChanged(); // 设置状态改变标志
notifyObservers(message); // 通知所有观察者
}
public String getMessage() {
return message;
}
}
// 观察者接口实现
public class MessageObserver implements Observer {
private String name;
public MessageObserver(String name) {
this.name = name;
}
@Override
public void update(Observable o, Object arg) {
if (o instanceof MessageObservable) {
String message = (String) arg;
System.out.println(name + " 收到新消息：" + message);
}
}
}
// 使用
public class EventDemo {
public static void main(String[] args) {
MessageObservable observable = new MessageObservable();
MessageObserver observer1 = new MessageObserver("Alice");
MessageObserver observer2 = new MessageObserver("Bob");
// 注册观察者
observable.addObserver(observer1);
observable.addObserver(observer2);
// 消息更新
observable.setMessage("你好，世界！");
}
}
在上面的代码中， MessageObservable 类继承自 Observable ，用于存储和通知消息。 MessageObserver 实现了 Observer 接口，用于接收消息通知。在 EventDemo 类的 main 方法中，我们创建了可观察对象和观察者对象，并注册了观察者。当调用 setMessage 方法时，所有注册的观察者都会收到通知并打印消息。
通过实现事件监听和回调处理，聊天室系统可以对用户的操作和系统的事件做出响应，提高了系统的灵活性和可维护性。
简介：本PPT介绍了一个基于Java和Socket通信技术的简单聊天室应用程序的开发。首先讲解Java的基础知识，接着深入探讨Socket通信原理及其在Java中的实现。介绍了聊天室的系统架构，包括服务器端和客户端的设计，数据传输方法，以及实时消息传递的事件处理机制。PPT内容包括Java和Socket基础、聊天室设计架构、服务器和客户端的代码实现，以及整个系统的运行流程和问题解决方案，旨在帮助学习者掌握如何利用Java和Socket编程技术创建聊天应用，加深对网络通信的理解。
扫一扫
499
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
