网络编程
网络的相关概念
计算机网络：计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在[网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现[资源共享]和信息传递的计算机系统。
网络编程：
就是如何在程序中实现两台计算机的通信。
通过操作相应API调度计算机资源硬件，并且利用管道（网线）进行数据交互的过程
**网络编程的目的：**传播交流信息、数据交换、通信。
网络编程的要素：
通信双方的地址：
- IP
- 端口号
规则：网络通信的协议
小结：
- 网络编程中有两个主要问题：
- 如何准确的定位到网络上的一台或多台主机。（ping命令）
- 找到主机后如何进行通信。
- 网络编程中的要素：
- IP地址和端口号
- 网络通信协议
IP地址
- IP地址：InetAddress
- 127.0.0.1：本机 localhost
- 域名：便于记忆IP地址
唯一定位一台网络上的计算机
域名
- 为了方便记忆，解决即 IP 的困难
- 将IP地址映射成域名
端口
-
概念：用于表示计算机上某个特定的网络程序
-
表示形式：以整数形式，范围0~65535 【2个字节表示端口 0~2^16 -1】
-
0~1024 已经被占用
-
常见的网络程序端口号：
tomcat：8080
mysql ：3306oracle ：1521
sqleerver ：1433
网络通信协议
网络通信协议：负责在网络上建立通信通道和控制通过通道的信息流的规则
为了进行网络通信，通信双方必须遵守通信协议
协议是一种数据的组织形式
网络通信协议的组成：
语法（syntax）：包括数据格式、数据编码以及信号等。
语义（semantics）：包括用于协调和差错处理的控制信息。
定时（Timing）：包括传输速率和数据排序等。
TCP协议
【 Transmission Control Protocol 传输控制协议】
- 使用TCP协议前，必须先建立TCP连接，形成传输数据通道
- 传输前，采用"三次握手"方式，是可靠的
- TCP协议进行通信的两个应用进程：客户端、服务端
- 在连接中可以进行大数据量的传输
- 传输完毕，需释放已建立的连接，效率低
UDP协议
【User Datagram Protocol 用户数据协议】
- 将数据、源、目的封装成数据包，不需要建立连接
- 每个数据报的大小限制在64K内，不适合传输大量数据
- 因无序连接，所以是不可靠的
- 发送数据结束时无需释放资源（因为不是面向连接的）速度快
InetAddress类
package com.yhs.api;
import java.net.InetAddress;
import java.net.UnknownHostException;
public class API_ {
public static void main(String[] args) throws UnknownHostException {
//1. 获取本地的InetAddress 对象
InetAddress localHost = InetAddress.getLocalHost();
System.out.println(localHost); //LAPTOP-8CO1DEFN/192.168.0.105
//2. 根据指定的主机名，获取 InetAddress 对象
InetAddress[] host1 = InetAddress.getByName("LAPTOP-8CO1DEFN");
System.out.println(host1);
//3. 根据域名返回 InetAddress对象，比如 www.baidu.com
InetAddress host2 = InetAddress.getByName("www.baidu.com");
System.out.println(host2); //www.baidu.com/14.215.177.38
//4. 通过 InetAddress 对象，获取相应的地址
String hostAddress = host2.getHostAddress();
System.out.println("host2 对应的ip = " + hostAddress);
//5. 通过 InetAddress 对象，获取对应的主机名/域名
String hostName = host2.getHostName();
System.out.println("host2对应的主机名/域名= " + hostName);
}
}
Socket
在计算机通信领域，socket 被翻译为“套接字”，它是计算机之间进行通信的一种约定或一种方式。通过 socket 这种约定，一台计算机可以接收其他计算机的数据，也可以向其他计算机发送数据
- 套接字（Socket）开发网络应用程序被广泛采用，以至于成为事实上的标准
- 通信的两端都要有Socket，是两台机器间的端点
- 网络通信其实就是Socket间的通信
- Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输
- 一般主动发起通信的应用程序属客户端，等待通信请求的为服务器
TCP网络通信编程
基本介绍：
- 基于客户端—服务端的网络通信
- 底层使用的是 TCP/IP 协议
- 应用场景举例：客户端发送数据，服务端接受并显示
- 基于Socket的TCP编程
【TCP 字节流编程】
package com.yhs.api.socket;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
@SuppressWarnings({"all"})
public class SocketTCP02Server {
public static void main(String[] args) throws IOException {
// 思路
//1. 在本机的 9999端口监听等待连接
// 细节：要求本机没有其他服务器在监听9999
// 细节：这个ServerSocket 可以通过 accept() 返回多个Socket[多个客户端连接服务器的并发]
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务器，在9999端口监听，等待连接。。。");
//2. 当没有客户端连接9999端口时，程序会 阻塞，等待连接
// 如果有客户端连接，则会返回Socket对象，程序继续
Socket socket = serverSocket.accept();
System.out.println("服务器 socket = " + socket.getClass());
//3. 通过socket.getInputStream() 读取客户端写入到数据通道的数据
InputStream inputStream = socket.getInputStream();
//4。 IO读取
byte[] buf = new byte[1024];
int readLen = 0;
while ((readLen = inputStream.read(buf)) != -1) {
System.out.println(new String(buf, 0, readLen));
}
//5. 获取socket相关联的输出流
OutputStream outputStream = socket.getOutputStream();
outputStream.write("hello, 客户端".getBytes());
// 设置写入结束标记
socket.shutdownOutput();
//关闭流 和 socket
outputStream.close();
inputStream.close();
socket.close();
serverSocket.close();//关闭
}
}
package com.yhs.api.socket;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
@SuppressWarnings({"all"})
public class SocketTCP02Client {
public static void main(String[] args) throws IOException {
// 思路
//1. 连接服务器(ip, 端口)
// 连接本机的9999端口，如果连接成功，返回Socket对象
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端 socket =" + socket.getClass());
//2. 连接上后，生成Socket，通过socket.getOutputStream()
// 得到 和 socket对象关联的输出流对象
OutputStream outputStream = socket.getOutputStream();
//3. 通过输出流，写入数据到 数据通道
outputStream.write("hello, 服务器".getBytes());
// 设置结束标记
socket.shutdownOutput();
//4. 获取和socket相关联的输入流，读取数据(字节)，并显示
InputStream inputStream = socket.getInputStream();
byte[] buf = new byte[1024];
int readLen = 0;
while ((readLen = inputStream.read(buf)) != -1) {
System.out.println(new String(buf, 0, readLen));
}
//5. 关闭流对象 和 socket，必须关闭
inputStream.close();
outputStream.close();
socket.close();
System.out.println("客户端已关闭...");
}
}
【TCP 字符流编程】
package com.yhs.api.socket;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
@SuppressWarnings({"all"})
public class SocketTCP04Server {
public static void main(String[] args) throws IOException {
// 思路
//1. 在本机的 9999端口监听等待连接
// 细节：要求本机没有其他服务器在监听9999
// 细节：这个ServerSocket 可以通过 accept() 返回多个Socket[多个客户端连接服务器的并发]
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务器，在9999端口监听，等待连接。。。");
//2. 当没有客户端连接9999端口时，程序会 阻塞，等待连接
// 如果有客户端连接，则会返回Socket对象，程序继续
Socket socket = serverSocket.accept();
System.out.println("服务器 socket = " + socket.getClass());
//3. 通过socket.getInputStream() 读取客户端写入到数据通道的数据
InputStream inputStream = socket.getInputStream();
//4。 IO读取 ，使用字符流
BufferedReader bfr = new BufferedReader(new InputStreamReader(inputStream));
String line = bfr.readLine();
System.out.println(line);//输出
// 使用字符输出流的方式回复信息
OutputStream outputStream = socket.getOutputStream();
BufferedWriter bfw = new BufferedWriter(new OutputStreamWriter(outputStream));
bfw.write("hello, 客户端4");
bfw.newLine();// 插入一个换行符，表示回复内容的结束
bfw.flush();//注意需要手动flush
//关闭流 和 socket
bfw.close();
bfr.close();
socket.close();
serverSocket.close();//关闭
}
}
package com.yhs.api.socket;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
@SuppressWarnings({"all"})
public class SocketTCP04Client {
public static void main(String[] args) throws IOException {
// 思路
//1. 连接服务器(ip, 端口)
// 连接本机的9999端口，如果连接成功，返回Socket对象
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端 socket =" + socket.getClass());
//2. 连接上后，生成Socket，通过socket.getOutputStream()
// 得到 和 socket对象关联的输出流对象
OutputStream outputStream = socket.getOutputStream();
//3. 通过输出流，写入数据到 数据通道
BufferedWriter bfw = new BufferedWriter(new OutputStreamWriter(outputStream));
bfw.write("hello, 服务器4");
bfw.newLine(); //插入一个换行符，表示写入的内容结束,【注意】此时要求对方使用readLine() 读取
bfw.flush(); //如果使用字符流，需要手动刷新，否则数据不会写入数据通道
//4. 获取和socket关联的输入流，读取数据(字符) 并显示
InputStream inputStream = socket.getInputStream();
BufferedReader bfr = new BufferedReader(new InputStreamReader(inputStream));
String line = bfr.readLine();
System.out.println(line);
//5. 关闭流对象 和 socket，必须关闭
bfr.close();//一般后打开的先关闭
bfw.close();
socket.close();
System.out.println("客户端已关闭...");
}
}
【网络上传文件】
package upload;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class TCPFileUploadServer {
public static void main(String[] args) throws Exception {
//1， 服务端在本即监听8888端口
ServerSocket serverSocket = new ServerSocket(8888);
System.out.println("服务断 在8888端口监听....");
//2. 等待连接
Socket socket = serverSocket.accept();
//3. 读取客户端发送的数据
// 通过Socket得到输入流
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
byte[] bytes = StreamUtils.streamToByteArray(bis);
//4. 将得到的 bytes 数组，写入到指定的路径，就得到一个文件
String destFilePath = "src\\monkey2.jpg";
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
bos.write(bytes);
bos.close();
// 向客户端回复"收到图片"
// 通过socket 获取到输出流(字符)
BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
writer.write("收到图片");
writer.flush();
socket.shutdownOutput();
//关闭其他资源
writer.close();
bis.close();
socket.close();
serverSocket.close();
}
}
package upload;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
public class TCPFileUploadClient {
public static void main(String[] args) throws Exception {
//客户端连接服务端，得到Socket对象
Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
//创建读取磁盘文件的输入流
String filePath = "d:\\monkey.jpg";
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
//bytes 就是 filePath 对应的字节数组
byte[] bytes = StreamUtils.streamToByteArray(bis);
//通过socket获取到输出流，将bytes数据发送给服务端
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
bos.write(bytes); //将文件对应的字节数组内容，写入到数据通道
bis.close();
socket.shutdownOutput();//设置写入数据的结束标记
//===接收从服务端回复的消息
InputStream inputStream = socket.getInputStream();
//使用StreamUtils 的方法，直接将 inputStream 读取到的内容转成 字符串
String s = StreamUtils.streamToString(inputStream);
System.out.println(s);
//关闭流
bos.close();
socket.close();
}
}
package upload;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
/**
* 此类用于演示关于流的读写方法
*
*/
public class StreamUtils {
/**
* 功能：将输入流转换成byte[]， 即可以把文件的内容读入到byte[]
* @param is
* @return
* @throws Exception
*/
public static byte[] streamToByteArray(InputStream is) throws Exception{
ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
byte[] b = new byte[1024];//字节数组
int len;
while((len=is.read(b))!=-1){//循环读取
bos.write(b, 0, len);//把读取到的数据，写入bos
}
byte[] array = bos.toByteArray();//然后将bos 转成字节数组
bos.close();
return array;
}
/**
* 功能：将InputStream转换成String
* @param is
* @return
* @throws Exception
*/
public static String streamToString(InputStream is) throws Exception{
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
StringBuilder builder= new StringBuilder();
String line;
while((line=reader.readLine())!=null){
builder.append(line+"\r\n");
}
return builder.toString();
}
}
netstat 指令
-anb | more ：以管理员身份运行，可以看到什么程序在监听
当客户端连接到服务器后，实际上客户端也是通过一个端口和服务器进行通讯的，这个端口是TCP/ IP来分配的，是不确定的，是随机的
UDP网络通信编程
基本介绍：
- 类 DatagramSocket 和 DatagramPacket（数据包 / 数据报） 实现了基于 UDP 协议网络程序
- UDP数据通过数据报套接字 DaragramSocket 发送和接收，系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达
- DatagramPacket 对象封装了 UPD数据报，在数据报包含了发送端的IP地址和端口号以及接收端的IP地址和端口号
- UDP议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接
基本流程
- 核心的两个类 / 对象 DatagramSocket 与 DatagramPacket
- 建立发送端，接收端（没有服务端 和 客户端概念）
- 发送数据前，建立数据包/报 DatagramPacket对象
- 调用DatagramSocket 的发送，接收方法
- 关闭DatagramSocket
【网络编程】
package UDP;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class UDPReceiverA {
public static void main(String[] args) throws IOException {
//1. 构建一个 DatagramSocket 对象，准备在9999端口接收数据
DatagramSocket socket = new DatagramSocket(9999);
//2. 构建一个 DatagramPacket 对象，准备接收数据
// UDP 协议一个数据包最大 64K
byte[] buf = new byte[1024];
DatagramPacket packet = new DatagramPacket(buf, buf.length);
//3. 调用 接收方法，将通过网络传输的 DatagramPacket 对象
// 填充到 packet对象
// 提示：当有数据包发送到 本机9999端口时，就会接收到数据
// 如果没有数据包发送到 本机的9999端口，就会阻塞等待
System.out.println("接收端A 等待接收数据。。。");
socket.receive(packet);
//4. 可以把packet 进行拆包 取出数据，并显示
int length = packet.getLength(); //实际接收到的数据字节长度
byte[] data = packet.getData(); //接收到数据
String s = new String(data, 0, length);
System.out.println(s);
//======================回复信息给B端=======================
byte[] bytes = "好的 明天见咯~~~~".getBytes();
DatagramPacket packet2 =
new DatagramPacket(bytes, 0, bytes.length, InetAddress.getByName("192.168.3.7"), 9998);
socket.send(packet2);
//5. 关闭资源
socket.close();
System.out.println("A端退出...");
}
}
package UDP;
import java.io.IOException;
import java.net.*;
public class UDPSenderB {
public static void main(String[] args) throws IOException {
//1. 创建 DatagramSocket 对象，准备在9998端口接收数据
DatagramSocket socket = new DatagramSocket(9998);
//2. 将需要发送的数据，封装到 DatagramPacket对象
byte[] data = "hello 明天吃火锅~~~".getBytes();
//说明：封装的 DatagramPacket对象： data 内容字节数组，data.length , 主机(IP) , 端口
DatagramPacket packet =
new DatagramPacket(data, data.length, InetAddress.getByName("192.168.3.7"), 9999);
socket.send(packet);
//======================接收A端信息======================
byte[] buf2 = new byte[1024];
DatagramPacket packet2 = new DatagramPacket(buf2, buf2.length);
socket.receive(packet2);
int length2 = packet2.getLength();
data = packet2.getData();
String s2 = new String(data, 0, length2);
System.out.println(s2);
//关闭资源
socket.close();
System.out.println("B端退出。。。");
}
}
网络编程练习
package homework;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class Server01 {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(6666);
System.out.println("服务器 正在6666端口监听，等待连接...");
Socket socket = serverSocket.accept();
InputStream inputStream = socket.getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String line = bufferedReader.readLine();
String answer = "";
if ("name".equals(line)) {
answer = "我是猛虎王";
} else if ("hobby".equals(line)) {
answer = "java 编程";
} else {
answer = "你说的啥子";
}
OutputStream outputStream = socket.getOutputStream();
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
bufferedWriter.write(answer);
bufferedWriter.newLine();
bufferedWriter.flush();
outputStream.close();
bufferedReader.close();
bufferedWriter.close();
serverSocket.close();
socket.close();
System.out.println("服务器退出...");
}
}
package homework;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;
public class Client01 {
public static void main(String[] args) throws IOException {
Socket socket = new Socket(InetAddress.getByName("192.168.0.108"), 6666);
OutputStream outputStream = socket.getOutputStream();
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
//从键盘读取用户问题
Scanner scanner = new Scanner(System.in);
System.out.println("请输入您的问题 ！！！");
String question = scanner.next();
bufferedWriter.write(question);
bufferedWriter.newLine();
bufferedWriter.flush();
InputStream inputStream = socket.getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String line = bufferedReader.readLine();
System.out.println(line);
inputStream.close();
bufferedReader.close();
bufferedWriter.close();
socket.close();
System.out.println("客户端退出...");
}
}
package homework;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class Receiver02 {
public static void main(String[] args) throws IOException {
DatagramSocket socket = new DatagramSocket(7777);
byte[] buf = new byte[1024];
DatagramPacket packet = new DatagramPacket(buf, buf.length);
socket.receive(packet);
int length = packet.getLength();
byte[] data = packet.getData();
String s = new String(data, 0, length);
String answer = "";
if ("四大名著是哪些".equals(s)) {
answer = "四大名著有 《红楼梦》《三国演义》《水浒传》《西游记》";
} else {
answer = "what";
}
data = answer.getBytes();
packet = new DatagramPacket(data, data.length, InetAddress.getByName("192.168.0.108"), 7776);
socket.send(packet);
socket.close();
System.out.println("Receiver退出...");
}
}
package homework;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;
public class Sender02 {
public static void main(String[] args) throws IOException {
DatagramSocket socket = new DatagramSocket(7776);
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的问题");
String question = scanner.next();
byte[] buf = question.getBytes();
DatagramPacket packet = new DatagramPacket(buf, buf.length, InetAddress.getByName("192.168.0.108"), 7777);
socket.send(packet);
byte[] buf2 = new byte[1024];
packet = new DatagramPacket(buf2, buf2.length);
socket.receive(packet);
int length = packet.getLength();
byte[] data = packet.getData();
String s = new String(data, 0, length);
System.out.println(s);
socket.close();
System.out.println("Sender端退出...");
}
}
package homework;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;
public class homework03Sender {
public static void main(String[] args) throws Exception {
Socket socket = new Socket(InetAddress.getByName("192.168.0.108"), 9999);
OutputStream outputStream = socket.getOutputStream();
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
Scanner scanner = new Scanner(System.in);
System.out.print("请输入歌名：");
String songName = scanner.next();
bw.write(songName);
bw.newLine();
bw.flush();
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
byte[] bytes = StreamUtils.streamToByteArray(bis);
String destFilePath = "d:\\歌曲.mp3";
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
bos.write(bytes);
System.out.println("已接收到歌曲...");
bos.close();
bis.close();
socket.close();
bw.close();
}
}
package homework;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
@SuppressWarnings({"all"})
public class homework03Receiver {
public static void main(String[] args) throws Exception {
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务器，在9999端口监听...");
Socket socket = serverSocket.accept();
InputStream inputStream = socket.getInputStream();
/**
* 为了防止传入的内容过多，这里也可写成循环：
* byte[] b = new byte[1024];
* int len = 0;
* String downloadFileName = "";
* while ((len = inputStream.readline(b)) != -1) {
* downloadFileName += new String(b, 0, len)
* }
*/
BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
String s = br.readLine();
if ("高山流水".equals(s)) {
//创建读取磁盘文件的输入流
String filePath = "d:\\高山流水.mp3";
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
byte[] bytes = StreamUtils.streamToByteArray(bis);
//得到socket关联的输出流
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
bos.write(bytes);
socket.shutdownOutput();
bos.close();
socket.close();
serverSocket.close();
br.close();
bis.close();
} else {
//创建读取磁盘文件的输入流
String filePath = "d:\\无名.mp3";
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
byte[] bytes = StreamUtils.streamToByteArray(bis);
//得到socket关联的输出流
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
bos.write(bytes);
socket.shutdownOutput();
bos.close();
socket.close();
serverSocket.close();
br.close();
bis.close();
}
}
}
多用户即时通信系统
需求分析：
- 用户登录
- 拉取在线用户列表
- 无异常退出（客户端、服务端）
- 私聊
- 群聊
- 发文件
- 服务器推送新闻
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-qx7r92UM-1657954763740)(C:\Users\YHS\Desktop\202207121539372.png)]
1.项目功能：
- 用户登录
- 拉取在线用户列表
- 无异常退出（客户端，服务端）
- 群聊
- 发文件
- 服务器推送新闻
2.项目代码
（1）客户端
项目结构
1】QQView 客户端界面类
package QQclient.view;
import QQclient.Service.FileClientService;
import QQclient.Service.MessageClientService;
import QQclient.Service.UserClientService;
import QQclient.utlils.Utility;
public class QQView {
public static void main(String[] args) {
QQView qqView = new QQView();
qqView.mainMenu();
System.out.println("客户端退出系统...");
}
private boolean loop = true;//控制是否显示菜单
private String key = "";//接收用户输入
private UserClientService userClientService = new UserClientService();//对象用于登录服务/注册用户
private MessageClientService messageClientService = new MessageClientService();//对象消息的私聊/群聊...
private FileClientService fileClientService = new FileClientService();//对象用于文件传输
//显示主菜单
public void mainMenu() {
while (loop) {
System.out.println("===========欢迎登陆网络通信系统===========");
System.out.println("\t\t 1 登录系统");
System.out.println("\t\t 9 退出系统");
System.out.print("请输入你的选择: ");
key = Utility.readString(1);
//根据用户输入处理不同的逻辑
switch (key) {
case "1":
System.out.print("请输入用户号: ");
String userID = Utility.readString(50);
System.out.print("请输入密 码：");
String passwd = Utility.readString(50);
//需要到服务器去验证该用户是否合法
//代码很多，需要编写一个类 UserClientService[用户登录/注册]
if (userClientService.checkUser(userID, passwd)) {
System.out.println("===========欢迎(用户" + userID + ") 登录成功===========");
//进入到二级菜单
while (loop) {
System.out.println("\n===========网络通信系统二级菜单(用户 " + userID + " )===============");
System.out.println("\t\t 1 显示在线用户列表");
System.out.println("\t\t 2 群发消息");
System.out.println("\t\t 3 私聊消息");
System.out.println("\t\t 4 发送文件");
System.out.println("\t\t 9 退出系统");
System.out.print("请输入你的选择：");
key = Utility.readString(1);
switch (key) {
case "1":
//这里编写一个方法，来获取在线用户列表
userClientService.onlineFriendList();
break;
case "2":
System.out.print("请输入群发的内容： ");
String AllContent = Utility.readString(100);
//调用一个方法，将消息封装成message对象，发送给服务端
messageClientService.sendMessageToAll(AllContent, userID);
break;
case "3":
System.out.print("请输入想聊天的用户号(在线) : ");
String getterID = Utility.readString(50);
System.out.print("请输入聊天内容： ");
String content = Utility.readString(100);
//编写方法，将私聊的信息发送给服务端
messageClientService.sendMessageToOne(content, userID, getterID);
break;
case "4":
System.out.print("请输入文件接收用户的ID(在线): ");
getterID = Utility.readString(50);
System.out.print("请输入发送文件的路径(形式 d://xx.jpg): ");
String src = Utility.readString(100);
System.out.print("请输入想把文件发送到对应的路径(形式 d:\\xx.xx): ");
String dest = Utility.readString(100);
fileClientService.sendFileToOne(src, dest, userID, getterID);
break;
case "9":
//调用方法，给服务端发送一个退出系统的message
userClientService.logout();
loop = false;
System.out.println("客户端退出系统");
break;
}
}
} else {//登录服务器失败
System.out.println("============登录失败===========");
}
break;
case "9":
System.out.println("退出系统...");
loop = false;
break;
}
}
}
}
2】Utility 工具类，接收键盘输入
package QQclient.utlils;
/**
工具类的作用:
处理各种情况的用户输入，并且能够按照程序员的需求，得到用户的控制台输入。
*/
import java.util.*;
/**
*/
public class Utility {
//静态属性。。。
private static Scanner scanner = new Scanner(System.in);
/**
* 功能：读取键盘输入的一个菜单选项，值：1——5的范围
* @return 1——5
*/
public static char readMenuSelection() {
char c;
for (; ; ) {
String str = readKeyBoard(1, false);//包含一个字符的字符串
c = str.charAt(0);//将字符串转换成字符char类型
if (c != '1' && c != '2' &&
c != '3' && c != '4' && c != '5') {
System.out.print("选择错误，请重新输入：");
} else break;
}
return c;
}
/**
* 功能：读取键盘输入的一个字符
* @return 一个字符
*/
public static char readChar() {
String str = readKeyBoard(1, false);//就是一个字符
return str.charAt(0);
}
/**
* 功能：读取键盘输入的一个字符，如果直接按回车，则返回指定的默认值；否则返回输入的那个字符
* @param defaultValue 指定的默认值
* @return 默认值或输入的字符
*/
public static char readChar(char defaultValue) {
String str = readKeyBoard(1, true);//要么是空字符串，要么是一个字符
return (str.length() == 0) ? defaultValue : str.charAt(0);
}
/**
* 功能：读取键盘输入的整型，长度小于2位
* @return 整数
*/
public static int readInt() {
int n;
for (; ; ) {
String str = readKeyBoard(2, false);//一个整数，长度<=2位
try {
n = Integer.parseInt(str);//将字符串转换成整数
break;
} catch (NumberFormatException e) {
System.out.print("数字输入错误，请重新输入：");
}
}
return n;
}
/**
* 功能：读取键盘输入的 整数或默认值，如果直接回车，则返回默认值，否则返回输入的整数
* @param defaultValue 指定的默认值
* @return 整数或默认值
*/
public static int readInt(int defaultValue) {
int n;
for (; ; ) {
String str = readKeyBoard(10, true);
if (str.equals("")) {
return defaultValue;
}
//异常处理...
try {
n = Integer.parseInt(str);
break;
} catch (NumberFormatException e) {
System.out.print("数字输入错误，请重新输入：");
}
}
return n;
}
/**
* 功能：读取键盘输入的指定长度的字符串
* @param limit 限制的长度
* @return 指定长度的字符串
*/
public static String readString(int limit) {
return readKeyBoard(limit, false);
}
/**
* 功能：读取键盘输入的指定长度的字符串或默认值，如果直接回车，返回默认值，否则返回字符串
* @param limit 限制的长度
* @param defaultValue 指定的默认值
* @return 指定长度的字符串
*/
public static String readString(int limit, String defaultValue) {
String str = readKeyBoard(limit, true);
return str.equals("")? defaultValue : str;
}
/**
* 功能：读取键盘输入的确认选项，Y或N
* 将小的功能，封装到一个方法中.
* @return Y或N
*/
public static char readConfirmSelection() {
System.out.println("请输入你的选择(Y/N)");
char c;
for (; ; ) {//无限循环
//在这里，将接受到字符，转成了大写字母
//y => Y n=>N
String str = readKeyBoard(1, false).toUpperCase();
c = str.charAt(0);
if (c == 'Y' || c == 'N') {
break;
} else {
System.out.print("选择错误，请重新输入：");
}
}
return c;
}
/**
* 功能： 读取一个字符串
* @param limit 读取的长度
* @param blankReturn 如果为true ,表示 可以读空字符串。
* 如果为false表示 不能读空字符串。
*
* 如果输入为空，或者输入大于limit的长度，就会提示重新输入。
* @return
*/
private static String readKeyBoard(int limit, boolean blankReturn) {
//定义了字符串
String line = "";
//scanner.hasNextLine() 判断有没有下一行
while (scanner.hasNextLine()) {
line = scanner.nextLine();//读取这一行
//如果line.length=0, 即用户没有输入任何内容，直接回车
if (line.length() == 0) {
if (blankReturn) return line;//如果blankReturn=true,可以返回空串
else continue; //如果blankReturn=false,不接受空串，必须输入内容
}
//如果用户输入的内容大于了 limit，就提示重写输入
//如果用户如的内容 >0 <= limit ,我就接受
if (line.length() < 1 || line.length() > limit) {
System.out.print("输入长度（不能大于" + limit + "）错误，请重新输入：");
continue;
}
break;
}
return line;
}
}
3】UserClientService 用户请求处理类
package QQclient.Service;
import QQcommon.Message;
import QQcommon.MessageType;
import QQcommon.User;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.InetAddress;
import java.net.Socket;
/**
* 该类完成用户登录验证和用户注册功能
*/
public class UserClientService {
//因为其他敌方可能使用user信息,因此做成成员属性
private static User u = new User();
private Socket socket;
//根据userID 和 pwd 到服务器验证该用户是否合法
public boolean checkUser(String userId, String pwd) {
boolean b = false;
//创建User对象
u.setUserID(userId);
u.setPasswd(pwd);
//连接到服务端，发送u对象
try {
socket = new Socket(InetAddress.getLocalHost(), 9999);
//得到ObjectOutputStream对象
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(u);//发送User对象
//读取从服务器回复的Message对象
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
Message ms = (Message) ois.readObject();
if (ms.getMessageType().equals(MessageType.MESSAGE_LOGIN_SUCCEED)) {
//如果有留言信息，就显示出来
if (! ("".equals(ms.getContent()))) {
System.out.println("您好，您有离线留言，请注意查收...");
System.out.println(ms.getSender() + "向你发送： " + ms.getContent());
}
//创建一个和服务器端保持通信的线程 --> 创建一个类 ClientConnectServerThread
ClientConnectServerThread ccst = new ClientConnectServerThread(socket);
//启动客户端线程
ccst.start();
//为了客户端的扩展，将线程放入到集合中
ManageClientConnectServerThread.addClientConnectServerThread(userId, ccst);
b = true;
} else {
//如果登录失败，我们就不能启动和服务通信的线程，关闭socket
socket.close();
}
} catch (Exception e) {
throw new RuntimeException(e);
}
return b;
}
public void onlineFriendList() {
Message message = new Message();
message.setMessageType(MessageType.MESSAGE_GET_ONLINE_FRIEND);
message.setSender(u.getUserID());
//发送给服务端
try {
//1. 从管理线程的集合中，通过userId，得到该线程
ClientConnectServerThread clientConnectServerThread = ManageClientConnectServerThread.getClientConnectServerThread(u.getUserID());
//2. 得到当前线程关联的Socket
Socket socket = clientConnectServerThread.getSocket();
//3. 得到当前线程的Socket对应的 ObjectOutputStream对象
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(message); //发送一个Message对象，向服务端要求在线用户列表
} catch (IOException e) {
throw new RuntimeException(e);
}
}
//编写方法退出客户端，并给服务端发送一个退出系统的message对象
public void logout() {
Message message = new Message();
message.setMessageType(MessageType.MESSAGE_CLIENT_EXIT);
message.setSender(u.getUserID());//一定要指定是那个客户端的id
//发送message
try {
// ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
ObjectOutputStream oos = new ObjectOutputStream(
ManageClientConnectServerThread.getClientConnectServerThread(u.getUserID()).getSocket().getOutputStream());
oos.writeObject(message);
System.out.println(u.getUserID() + " 退出系统 ");
System.exit(0);//结束进程
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
4】MessageClientService 消息请求处理类
package QQclient.Service;
import QQcommon.Message;
import QQcommon.MessageType;
import java.io.IOException;
import java.io.ObjectOutputStream;
/**
* 该类/对象，提供和消息相关的服务方法
*/
public class MessageClientService {
/**
* @param content 内容
* @param senderId 发送用户的ID
* @param getterId 接收用户的ID
*/
public void sendMessageToOne(String content, String senderId, String getterId) {
//构建message
Message message = new Message();
message.setMessageType(MessageType.MESSAGE_COMM_MES);
message.setSender(senderId);
message.setGetter(getterId);
message.setContent(content);
message.setSendTime(new java.util.Date().toString());//发送时间
System.out.println(senderId + " 对 " + getterId + " 说: " + content);
//发送给服务端
try {
ObjectOutputStream oos =
new ObjectOutputStream(ManageClientConnectServerThread.getClientConnectServerThread(senderId).getSocket().getOutputStream());
oos.writeObject(message);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
/**
* 群发内容
* @param content 内容
* @param senderId 发送用户ID
*/
public void sendMessageToAll(String content, String senderId) {
//构建message
Message message = new Message();
message.setMessageType(MessageType.MESSAGE_TO_ALL_MES);
message.setSender(senderId);
message.setContent(content);
message.setSendTime(new java.util.Date().toString());
System.out.println(senderId + " 对大家说：" + content);
//发送给服务端
try {
ObjectOutputStream oos = new ObjectOutputStream(ManageClientConnectServerThread.getClientConnectServerThread(senderId).getSocket().getOutputStream());
oos.writeObject(message);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
/**
* 移除用户离线留言的内容
* @param userId
*/
public void removeMsg(String userId) {
Message message = new Message();
message.setMessageType(MessageType.MESSAGE_REMOVE_MES);
message.setSender(userId);
try {
ObjectOutputStream oos =
new ObjectOutputStream(ManageClientConnectServerThread.getClientConnectServerThread(userId).getSocket().getOutputStream());
oos.writeObject(message);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
5】FileClientService 文件请求处理类
package QQclient.Service;
import QQcommon.Message;
import QQcommon.MessageType;
import java.io.*;
/**
* 该类/对象 完成文件传输服务
*/
public class FileClientService {
/**
* 发送文件
* @param src 源文件
* @param dest 把该文件传输到对方目录
* @param senderId 发送用户的ID
* @param getterId 接收用户的ID
*/
public void sendFileToOne(String src, String dest, String senderId, String getterId) {
//读取src文件 --> message
Message message = new Message();
message.setMessageType(MessageType.MESSAGE_FILE_MES);
message.setSender(senderId);
message.setGetter(getterId);
message.setSrc(src);
message.setDest(dest);
//将文件读取
FileInputStream fileInputStream = null;
byte[] FileBytes = new byte[(int) new File(src).length()];
try {
fileInputStream = new FileInputStream(src);
fileInputStream.read(FileBytes); //将src文件读入到程序的字节数组
//将文件对应的字节数组，放入到message
message.setFileBytes(FileBytes);
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
//关闭流
try {
fileInputStream.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
//提示信息
System.out.println("\n" + senderId
+ " 给 " + getterId
+ " 发送文件：" + src
+ "到" + dest + "目录" );
//发送
try {
ObjectOutputStream oos =
new ObjectOutputStream(ManageClientConnectServerThread
.getClientConnectServerThread(senderId)
.getSocket()
.getOutputStream());
oos.writeObject(message);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
6】ManageClientConnectServerThread 管理客户端连接到服务端的线程 的类
package QQclient.Service;
import java.util.HashMap;
/**
* 该类管理客户端连接到服务器的线程
*/
public class ManageClientConnectServerThread {
//把多个线程放入到一个HashMap集合，key就是用户id，value 就是线程
private static HashMap<String, ClientConnectServerThread> hm = new HashMap<>();
//将某个线程加入到集合
public static void addClientConnectServerThread(String userId, ClientConnectServerThread clientConnectServerThread) {
hm.put(userId, clientConnectServerThread);
}
//通过userId 可以得到对应的线程
public static ClientConnectServerThread getClientConnectServerThread(String userId) {
return hm.get(userId);
}
}
7】ClientConnectServerThread 客户端连接线程类
package QQclient.Service;
import QQclient.utlils.Utility;
import QQcommon.Message;
import QQcommon.MessageType;
import java.io.File;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.net.Socket;
import java.util.Scanner;
public class ClientConnectServerThread extends Thread {
//该进程需要持有Socket
private Socket socket;
public ClientConnectServerThread(Socket socket) {
this.socket = socket;
}
//为了更方便的得到Socket
public Socket getSocket() {
return socket;
}
@Override
public void run() {
//因为Thread需要在后台和服务器通信，因此我们while循环
while (true) {
try {
System.out.println("\n客户端线程，等该读取从服务端发送的消息...");
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
//如果服务器没有发送Message对象，线程会阻塞在这里
Message message = (Message) ois.readObject();
//判断message类型，然后做相应的业务处理
//如果读取到的是 服务器返回在线用户列表
if (message.getMessageType().equals(MessageType.MESSAGE_RET_ONLINE_FRIEND)) {
//取出在线列表信息，并显示
//规定
String[] onlineUsers = message.getContent().split(" ");
System.out.println("\n=========当前在线用户列表=========");
for (int i = 0; i < onlineUsers.length; i++) {
System.out.println("用户： " + onlineUsers[i]);
}
} else if (message.getMessageType().equals(MessageType.MESSAGE_COMM_MES)) {
//把服务端转发的消息，显示到控制台
System.out.println("\n" + message.getSender() +
" 对 " + message.getGetter() +
" 说 " + message.getContent() +
" 时间：" + message.getSendTime());
} else if (message.getMessageType().equals(MessageType.MESSAGE_TO_ALL_MES)) {
//把服务端发来的 群发消息，显示到控制台
System.out.println("\n" + message.getSender() + " 对大家说：" + message.getContent());
} else if (message.getMessageType().equals(MessageType.MESSAGE_FILE_MES)) {
System.out.println("\n" + message.getSender()
+ " 给 " + message.getGetter()
+ " 发送文件: " + message.getSrc()
+ "到我的电脑的目录 " + message.getDest());
//取出message的文件字节数组，通过文件输出流，写出到磁盘
FileOutputStream fileOutputStream = new FileOutputStream(message.getDest());
fileOutputStream.write(message.getFileBytes());
fileOutputStream.close();
System.out.println("\n 保存文件成功~~~");
}
else {
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
}
（2）服务端
1】QQFrame 服务端启动类
package QQFrame;
import QQServer.service.QQServer;
/**
* 该类创建QQServer ，启动后台的服务
*/
public class QQFrame {
public static void main(String[] args) {
new QQServer();
}
}
2】Utility 工具类
package Utils;
/**
工具类的作用:
处理各种情况的用户输入，并且能够按照程序员的需求，得到用户的控制台输入。
*/
import java.util.Scanner;
/**
*/
public class Utility {
//静态属性。。。
private static Scanner scanner = new Scanner(System.in);
/**
* 功能：读取键盘输入的一个菜单选项，值：1——5的范围
* @return 1——5
*/
public static char readMenuSelection() {
char c;
for (; ; ) {
String str = readKeyBoard(1, false);//包含一个字符的字符串
c = str.charAt(0);//将字符串转换成字符char类型
if (c != '1' && c != '2' &&
c != '3' && c != '4' && c != '5') {
System.out.print("选择错误，请重新输入：");
} else break;
}
return c;
}
/**
* 功能：读取键盘输入的一个字符
* @return 一个字符
*/
public static char readChar() {
String str = readKeyBoard(1, false);//就是一个字符
return str.charAt(0);
}
/**
* 功能：读取键盘输入的一个字符，如果直接按回车，则返回指定的默认值；否则返回输入的那个字符
* @param defaultValue 指定的默认值
* @return 默认值或输入的字符
*/
public static char readChar(char defaultValue) {
String str = readKeyBoard(1, true);//要么是空字符串，要么是一个字符
return (str.length() == 0) ? defaultValue : str.charAt(0);
}
/**
* 功能：读取键盘输入的整型，长度小于2位
* @return 整数
*/
public static int readInt() {
int n;
for (; ; ) {
String str = readKeyBoard(2, false);//一个整数，长度<=2位
try {
n = Integer.parseInt(str);//将字符串转换成整数
break;
} catch (NumberFormatException e) {
System.out.print("数字输入错误，请重新输入：");
}
}
return n;
}
/**
* 功能：读取键盘输入的 整数或默认值，如果直接回车，则返回默认值，否则返回输入的整数
* @param defaultValue 指定的默认值
* @return 整数或默认值
*/
public static int readInt(int defaultValue) {
int n;
for (; ; ) {
String str = readKeyBoard(10, true);
if (str.equals("")) {
return defaultValue;
}
//异常处理...
try {
n = Integer.parseInt(str);
break;
} catch (NumberFormatException e) {
System.out.print("数字输入错误，请重新输入：");
}
}
return n;
}
/**
* 功能：读取键盘输入的指定长度的字符串
* @param limit 限制的长度
* @return 指定长度的字符串
*/
public static String readString(int limit) {
return readKeyBoard(limit, false);
}
/**
* 功能：读取键盘输入的指定长度的字符串或默认值，如果直接回车，返回默认值，否则返回字符串
* @param limit 限制的长度
* @param defaultValue 指定的默认值
* @return 指定长度的字符串
*/
public static String readString(int limit, String defaultValue) {
String str = readKeyBoard(limit, true);
return str.equals("")? defaultValue : str;
}
/**
* 功能：读取键盘输入的确认选项，Y或N
* 将小的功能，封装到一个方法中.
* @return Y或N
*/
public static char readConfirmSelection() {
System.out.println("请输入你的选择(Y/N)");
char c;
for (; ; ) {//无限循环
//在这里，将接受到字符，转成了大写字母
//y => Y n=>N
String str = readKeyBoard(1, false).toUpperCase();
c = str.charAt(0);
if (c == 'Y' || c == 'N') {
break;
} else {
System.out.print("选择错误，请重新输入：");
}
}
return c;
}
/**
* 功能： 读取一个字符串
* @param limit 读取的长度
* @param blankReturn 如果为true ,表示 可以读空字符串。
* 如果为false表示 不能读空字符串。
*
* 如果输入为空，或者输入大于limit的长度，就会提示重新输入。
* @return
*/
private static String readKeyBoard(int limit, boolean blankReturn) {
//定义了字符串
String line = "";
//scanner.hasNextLine() 判断有没有下一行
while (scanner.hasNextLine()) {
line = scanner.nextLine();//读取这一行
//如果line.length=0, 即用户没有输入任何内容，直接回车
if (line.length() == 0) {
if (blankReturn) return line;//如果blankReturn=true,可以返回空串
else continue; //如果blankReturn=false,不接受空串，必须输入内容
}
//如果用户输入的内容大于了 limit，就提示重写输入
//如果用户如的内容 >0 <= limit ,我就接受
if (line.length() < 1 || line.length() > limit) {
System.out.print("输入长度（不能大于" + limit + "）错误，请重新输入：");
continue;
}
break;
}
return line;
}
}
3】QQServer 服务端类
package QQServer.service;
import QQcommon.Message;
import QQcommon.MessageType;
import QQcommon.User;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.concurrent.ConcurrentHashMap;
/**
* 这是服务端，在监听9999， 等待客户端的连接，并保持通信
*/
@SuppressWarnings({"all"})
public class QQServer {
private ServerSocket ss = null;
//创建一个集合，存放多个用户，如果这些用户登录，就认为是合法
//这里也可以使用 ConcurrentHashMap 可以处理并发的集合，没有线程安全
//HashMap 没有处理线程安全，因此在多线程情况下不安全
//ConcurrentHashMap 处理线程安全，即线程同步处理，在多线程情况下安全
private static ConcurrentHashMap<String, User> validUser = new ConcurrentHashMap<>();
//存放离线用户接收的消息
private static ConcurrentHashMap<String, ArrayList<Message>> offLineDB = new ConcurrentHashMap<>();
static { //在静态代码块中，初始化 validUser
validUser.put("100", new User("100", "123"));
validUser.put("200", new User("200", "123"));
validUser.put("300", new User("300", "123"));
validUser.put("詹姆斯", new User("詹姆斯", "123"));
validUser.put("库里", new User("库里", "123"));
validUser.put("杜兰特", new User("杜兰特", "123"));
}
//验证用户是否有效的方法
private boolean checkUser(String userId, String passwd) {
User user = validUser.get(userId);
//过关斩将验证方式
if (user == null) { //说明userId没有存在validUsers 的key中
return false;
}
if (! user.getPasswd().equals(passwd)) { //userId正确，但是密码错误
return false;
}
return true;
}
public QQServer() {
try {
//注意：端口可以写在配置文件
System.out.println("服务端在9999端口监听...");
//启动推送新闻的线程
new Thread(new SendNewsToAllService()).start();
ss = new ServerSocket(9999);
while (true) { //当和某个客户端连接后，会继续监听，因此while循环
Socket socket = ss.accept(); //如果没有监听，就会阻塞在这里
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
User user = (User) ois.readObject(); //读取客户端发送的对象
Message message = new Message();
//验证
if (checkUser(user.getUserID(), user.getPasswd())) { //登录成功 Message message = new Message("系统", user.getUserID(), "登录成功", MessageType.MESSAGE_LOGIN_SUCCEED);
message.setMessageType(MessageType.MESSAGE_LOGIN_SUCCEED);
String msg = ManageUserMessage.getMessage(user.getUserID());
if (! ("".equals(msg))) {
message.setContent(msg);
}
oos.writeObject(message);
//创建一个线程，和客户端保持通信，该线程需要持有socket对象
ServerConnectClientThread scct = new ServerConnectClientThread(socket, user.getUserID());
//启动线程
scct.start();
//将该线程对象，放入到一个集合中，进行管理
ManageClientThreads.addManageClientThreads(user.getUserID(), scct);
} else { //登录失败
System.out.println("用户 id=" + user.getUserID() + " pwd=" + user.getPasswd() + " 验证失败");
message.setMessageType(MessageType.MESSAGE_LOGIN_FAIL);
//将message对象回复
oos.writeObject(message);
socket.close();
}
}
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
//如果服务端退出了while循环，说明服务端不再监听，因此需要关闭ServerSocket
try {
ss.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
4】SendNewsToAllService 群发消息类
package QQServer.service;
import QQcommon.Message;
import QQcommon.MessageType;
import Utils.Utility;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.util.HashMap;
import java.util.Iterator;
public class SendNewsToAllService implements Runnable{
@Override
public void run() {
//为了可以推送多次新闻，使用while
while (true) {
System.out.print("请输入服务端要推送的新闻/消息[输入exit表示退出推送服务]： ");
String news = Utility.readString(100);
if ("exit".equals(news)) {
break;
}
//构建一个消息，群发消息
Message message = new Message();
message.setSender("服务端");
message.setMessageType(MessageType.MESSAGE_TO_ALL_MES);
message.setContent(news);
message.setSendTime(new java.util.Date().toString());
System.out.println("服务端推送消息给大家(内容)： " + news);
//遍历当前所有的通信线程，得到socket，并发送message
HashMap<String, ServerConnectClientThread> hm = ManageClientThreads.getHm();
Iterator<String> iterator = hm.keySet().iterator();
while (iterator.hasNext()) {
String onLineUserId = iterator.next().toString();
ServerConnectClientThread serverConnectClientThread = hm.get(onLineUserId);
try {
ObjectOutputStream oos =
new ObjectOutputStream(serverConnectClientThread.getSocket().getOutputStream());
oos.writeObject(message);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
}
}
5】ManageUserMessage 用户请求处理类
package QQServer.service;
import java.util.ArrayList;
import java.util.HashMap;
public class ManageUserMessage {
private static HashMap<String , ArrayList<String>> tempMessage;
static {
tempMessage = new HashMap<>();
}
public static void addMessage(String userId, String message) {
ArrayList<String> arrayList = tempMessage.get(userId);
//是否为空
if (arrayList != null) {
arrayList.add(message);
} else {
ArrayList<String> array = new ArrayList<>();
array.add(message);
tempMessage.put(userId, array);
}
}
/**
* 根据用户id 获取离线内容
* @param userId 用户id
* @return 离线消息
*/
public static String getMessage(String userId) {
ArrayList<String> arrayList = tempMessage.get(userId);
StringBuffer sb = null;
if (arrayList != null && arrayList.size() > 0) {
sb = new StringBuffer();
for (String message : arrayList) {
sb.append(message).append("\r\n");
}
return sb.toString();
}
return "";
}
/**
* 根据用户id将消息从容器中删除
* @param userId 用户id
*/
public static void removeMessage(String userId) {
ArrayList<String> strings = tempMessage.get(userId);
strings = null;
tempMessage.remove(userId);
}
public static HashMap<String, ArrayList<String>> getTempMessage() {
return tempMessage;
}
}
6】ManagerClientThreads 用于管理和客户端通信的线程
package QQServer.service;
import java.util.HashMap;
import java.util.Iterator;
/**
* 该类管理和客户端通信的线程
*/
public class ManageClientThreads {
private static HashMap<String, ServerConnectClientThread> hm = new HashMap<>();
//返回hm
public static HashMap<String, ServerConnectClientThread> getHm() {
return hm;
}
//添加线程对象到 hm 集合
public static void addManageClientThreads(String userId, ServerConnectClientThread serverConnectClientThread) {
hm.put(userId, serverConnectClientThread);
}
//添加一个方法，从集合中移除某个线程对象
public static void removeServerConnectClientThread(String userId) {
hm.remove(userId);
}
//根据userId 返回 ServerConnectClientThread线程
public static ServerConnectClientThread getServerConnectClientThread(String userId) {
return hm.get(userId);
}
//在这编写方法，可以返回在线用户列表
public static String getOnlineUser() {
//集合遍历，遍历 hashmap的key
Iterator<String> iterator = hm.keySet().iterator();
String onlineUserList = "";
while (iterator.hasNext()) {
onlineUserList += iterator.next().toString() + " ";
}
return onlineUserList;
}
}
7】ServerConnectClientThread 服务端socket类
package QQServer.service;
import QQcommon.Message;
import QQcommon.MessageType;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.concurrent.ConcurrentHashMap;
/**
* 该类的一个对象和某个客户端保持通信
*/
public class ServerConnectClientThread extends Thread {
private Socket socket;
private String userId; //连接到服务端的用户id
public ServerConnectClientThread(Socket socket, String userId) {
this.socket = socket;
this.userId = userId;
}
public Socket getSocket() {
return socket;
}
@Override
public void run() { //这里线程处于 run状态，可以发送/接收消息
while (true) {
try {
System.out.println("服务端和 客户端:" + userId + " 保持通信，读取数据...");
ObjectInputStream ois = new ObjectInputStream(socket.getInputStream());
Message message = (Message) ois.readObject();
if (message.getMessageType().equals(MessageType.MESSAGE_GET_ONLINE_FRIEND)) {
//客户端要在线用户列表
/*
在线用户列表形式：100 200 詹姆斯
*/
System.out.println(message.getSender() + " 要在线用户列表");
String onlineUser = ManageClientThreads.getOnlineUser();
//返回message
//构建一个 Message对象, 返回给客户端
Message message2 = new Message();
message2.setMessageType(MessageType.MESSAGE_RET_ONLINE_FRIEND);
message2.setContent(onlineUser);
message2.setGetter(message.getSender());
//返回给客户端
ObjectOutputStream oos = new ObjectOutputStream(socket.getOutputStream());
oos.writeObject(message2);
} else if (message.getMessageType().equals(MessageType.MESSAGE_CLIENT_EXIT)) {
System.out.println(message.getSender() + " 退出");
//将这个客户端对应的线程，从集合删除
ManageClientThreads.removeServerConnectClientThread(message.getSender());
socket.close();
break;
} else if (message.getMessageType().equals(MessageType.MESSAGE_COMM_MES)) {
//根据message获取getterId，然后再得到对应的线程
ServerConnectClientThread serverConnectClientThread = ManageClientThreads.getServerConnectClientThread(message.getGetter());
if (serverConnectClientThread == null) {//用户不在线,存储到一个地方
ManageUserMessage.addMessage(message.getGetter(), message.getContent());
} else {
//得到对应的socket的对象输出流，将message对象转发给指定的客户端
ObjectOutputStream oos =
new ObjectOutputStream(serverConnectClientThread.getSocket().getOutputStream());
oos.writeObject(message); //转发，如果客户不在线，就可保存到数据库,实现离线留言
}
} else if (message.getMessageType().equals(MessageType.MESSAGE_TO_ALL_MES)) {
//需要遍历 管理线程的集合，把所有的线程的socket得到，，然后把message进行转发
HashMap<String, ServerConnectClientThread> hm = ManageClientThreads.getHm();
//遍历
Iterator<String> iterator = hm.keySet().iterator();
while (iterator.hasNext()) {
//取出在线用户的id
String onlineUserId = iterator.next().toString();//? --> 取出key
if (! onlineUserId.equals(message.getSender())) { //排除群发消息的发起者
//进行转发message
ObjectOutputStream oos = new ObjectOutputStream(hm.get(onlineUserId).getSocket().getOutputStream());
oos.writeObject(message);
}
}
} else if (message.getMessageType().equals(MessageType.MESSAGE_FILE_MES)) {
//根据getterid 获取到对应的线程，将message对象转发
ServerConnectClientThread serverConnectClientThread = ManageClientThreads.getServerConnectClientThread(message.getGetter());
ObjectOutputStream oos = new ObjectOutputStream(serverConnectClientThread.getSocket().getOutputStream());
//转发
oos.writeObject(message);
} else {
System.out.println("其他类型暂时不处理。。。");
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
}
（3）公共代码
由于QQcommon下面的实体类代码是公共的，这里只贴一份
1】Message
package QQcommon;
import java.io.Serializable;
public class Message implements Serializable {
private static final long serialVersionUID = 1L;
private String sender;//发送者
private String getter;//接收者
private String content;//消息内容
private String sendTime;//发送时间
private String MessageType;//消息类型【可以在接口定义消息类型】
//进行拓展 和 文件相关的成员
private byte[] fileBytes;
private int fileLen = 0;
private String dest; //将文件传输到哪里
private String src; //源文件路径
public byte[] getFileBytes() {
return fileBytes;
}
public void setFileBytes(byte[] fileBytes) {
this.fileBytes = fileBytes;
}
public int getFileLen() {
return fileLen;
}
public void setFileLen(int fileLen) {
this.fileLen = fileLen;
}
public String getDest() {
return dest;
}
public void setDest(String dest) {
this.dest = dest;
}
public String getSrc() {
return src;
}
public void setSrc(String src) {
this.src = src;
}
public String getSender() {
return sender;
}
public void setSender(String sender) {
this.sender = sender;
}
public String getGetter() {
return getter;
}
public void setGetter(String getter) {
this.getter = getter;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public String getSendTime() {
return sendTime;
}
public void setSendTime(String sendTime) {
this.sendTime = sendTime;
}
public String getMessageType() {
return MessageType;
}
public void setMessageType(String messageType) {
MessageType = messageType;
}
public Message(String sender, String getter, String content, String messageType) {
this.sender = sender;
this.getter = getter;
this.content = content;
MessageType = messageType;
}
public Message() {};
}
2】MessageType 接口
package QQcommon;
/**
* 表示消息类型
*/
public interface MessageType {
//1. 在接口中定义一些常量
//2. 不同的常量的值，表示不同的消息类型
String MESSAGE_LOGIN_SUCCEED = "1"; //表示登录成功
String MESSAGE_LOGIN_FAIL = "2"; //表示登录失败
String MESSAGE_COMM_MES = "3"; //普通信息包
String MESSAGE_GET_ONLINE_FRIEND = "4"; //要求返回在线用户列表
String MESSAGE_RET_ONLINE_FRIEND = "5"; //返回在线用户列表
String MESSAGE_CLIENT_EXIT = "6"; //客户端请求退出
String MESSAGE_TO_ALL_MES = "7"; //群发信息报
String MESSAGE_FILE_MES = "8"; //文件消息(发送文件)
String MESSAGE_REMOVE_MES = "9"; //移除离线留言内容
}
3】User
package QQcommon;
import java.io.Serializable;
/**
* 表示一个用户 / 客户信息
*/
public class User implements Serializable {
/**
* serialVersionUID 序列化的版本号，可以提高兼容性
* 有了版本号，当加入新的属性时，不会被认定为新的类
*/
private static final long serialVersionUID = 1L;
private String userID; //用户ID/用户名
private String passwd; //用户密码
public User(String userID, String passwd) {
this.userID = userID;
this.passwd = passwd;
}
public String getUserID() {
return userID;
}
public void setUserID(String userID) {
this.userID = userID;
}
public String getPasswd() {
return passwd;
}
public void setPasswd(String passwd) {
this.passwd = passwd;
}
}
}
public void setGetter(String getter) {
this.getter = getter;
}
public String getContent() {
return content;
}
public void setContent(String content) {
this.content = content;
}
public String getSendTime() {
return sendTime;
}
public void setSendTime(String sendTime) {
this.sendTime = sendTime;
}
public String getMessageType() {
return MessageType;
}
public void setMessageType(String messageType) {
MessageType = messageType;
}
public Message(String sender, String getter, String content, String messageType) {
this.sender = sender;
this.getter = getter;
this.content = content;
MessageType = messageType;
}
public Message() {};
}
#### 2】MessageType 接口
```java
package QQcommon;
/**
* 表示消息类型
*/
public interface MessageType {
//1. 在接口中定义一些常量
//2. 不同的常量的值，表示不同的消息类型
String MESSAGE_LOGIN_SUCCEED = "1"; //表示登录成功
String MESSAGE_LOGIN_FAIL = "2"; //表示登录失败
String MESSAGE_COMM_MES = "3"; //普通信息包
String MESSAGE_GET_ONLINE_FRIEND = "4"; //要求返回在线用户列表
String MESSAGE_RET_ONLINE_FRIEND = "5"; //返回在线用户列表
String MESSAGE_CLIENT_EXIT = "6"; //客户端请求退出
String MESSAGE_TO_ALL_MES = "7"; //群发信息报
String MESSAGE_FILE_MES = "8"; //文件消息(发送文件)
String MESSAGE_REMOVE_MES = "9"; //移除离线留言内容
}
3】User
package QQcommon;
import java.io.Serializable;
/**
* 表示一个用户 / 客户信息
*/
public class User implements Serializable {
/**
* serialVersionUID 序列化的版本号，可以提高兼容性
* 有了版本号，当加入新的属性时，不会被认定为新的类
*/
private static final long serialVersionUID = 1L;
private String userID; //用户ID/用户名
private String passwd; //用户密码
public User(String userID, String passwd) {
this.userID = userID;
this.passwd = passwd;
}
public String getUserID() {
return userID;
}
public void setUserID(String userID) {
this.userID = userID;
}
public String getPasswd() {
return passwd;
}
public void setPasswd(String passwd) {
this.passwd = passwd;
}
}
669
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
