一、网络编程概述
1.1 网络编程简介
其实,所谓的网络编程,就是编写程序,实现让同一个网络中的机器实现数据的传递,实现通信。
Java是 Internet 的语言,它从语言级上提供了对网络应用程序的支持。
Java提供的网络类库,可以实现无痛的网络连接,联网的底层细节被隐藏在 Java 的本机安装系统里,由 JVM 进行控制,并且Java 实现了一个跨平台的网络库,因此程序员面对的是一个统一的网络编程环境,很容易开发常见的网络应用程序。
1.2 网络编程需要具备的条件
如果要实现两台机器之间的通信,必须满足以下几点要求:
1、需要知道对方的 IP 地址。
2 、需要知道对方的哪一个端口号来做数据的接受。
3 、通信的双方,需要遵循相同的通信协议。
1.3 IP地址和端口号的简介
1.3.1 IP地址
IP是 Internet Protocol (网络互连协议),在计算机中,使用IP地址来描述一个上网终端的唯一的地址编号。分为 IPv4 和 IPv6。
IPv4 : 使用4个字节来描述一个IP地址,由四部分组成,每一部分一个字节。
IPv6 : 使用6个字节来描述一个IP地址,由六部分组成,每一部分一个字节。
IP地址的分类:
A类: 1.0.0.1 ~ 126.255.255.254 :保留给政府机构
B类: 128.0.0.1 ~ 191.255.255.254 :分配给大中型企业
C类: 192.0.0.1 ~ 223.255.255.254 :分配给任何有需要的个人
D类: 224.0.0.1 ~ 239.255.255.254 :用于组播
E类: 240.0.0.1 ~ 255.255.255.254 :用于实验
1.3.2 端口号的简介
端口是设备与外界进行通信的数据的出口。
端口号的范围: [0,65535]。
常见的端口占用:
3306: MySQL
1521 :Oracle
8080 :Tomcat
1.4 通信协议
常用的通信协议有:TCP 、UDP 、HTTP;而OSI模型过于理想化,未能在因特网上进行广泛推广,下面,我们着重讲解一下TCP协议。
1.4.1 TCP协议
是一个传输层的通信协议,是一个安全的,面向连接的通信协议。所谓的安全,指的是在数据传递的过程中,不会出现数据丢失的问题。特点:安全的、面向连接。
TCP/IP 因其传输控制协议(TCP)和网络互联协议(IP)而得名。实际上是一组协议,其包含多个具有不同功能且互为关联的协议。
TCP/IP协议模型从更实用的角度出发,形成了高效的四层体系结构,即网络接口层、IP层、传输层和应用层。下图表示了TCP/IP的分层结构和与OSI参考模型的对应关系:
1.4.2 TCP的三次握手
使用TCP实现数据在两个计算机之间进行传递,需要先在两个计算机之间建立一个安全的连接,然后再通过这个连接,进行数据的传递。因此,TCP是一个安全的通信协议。
在使用TCP进行数据传递的时候,存在两个角色,客户端和服务端。
在TCP中,连接的建立过程会经历如下几个步骤:
1. 第一次握手:建立连接时,由客户端向服务端发送一个 syn 包, syn包中是同步序列编号, 并进入SYN_SENT 状态,并等待服务器确认。
2. 第二次握手:服务器收到了 syn 包,服务器必须确认客户端的syn,同时自己也发送一个syn包给客户端,即 SYN_ACK 包,并进入到 SYN_RECV 状态。
3. 第三次握手:客户端收到了服务端 SYN_ACK 包,并向服务端回复一个 ACK 包,此时客户端和服务端会进 入到TCP连接成功状态。 ESTABLISHED。
1.4.3 TCP与UDP的区别
运输层协议中有两个非常重要的协议:
1. 传输控制协议TCP(Transmission Control Protocol)
2. 用户数据报协议UDP(User Datagram Protocol)
TCP是面向连接的运输层协议。即应用进程(或程序)在使用TCP协议之前,必须先建立TCP连接,在传输完毕后,释放已经建立的连接。利用TCP协议进行通信的两个应用进程,一个是服务器进程。另一个是客户进程。
UDP是面向无连接的运输层协议。即应用进程(或程序)在使用UDP协议之前,不必先建立连接。自然,发送数据结束时也没有连接需要释放。因此,减少了开销和发送数据之前的时延。
二、TCP/IP程序编程
2.1 TCP/IP编程简介
2.1.1 C/S架构模型
CS架构由客户端和服务器两个部分组成,通常采用C/S模式进行通信。其中,客户端负责向用户提供界面和交互功能,而服务器则负责存储和处理数据。在这种架构中,客户端和服务器之间通过网络进行通信,客户端向服务器发出请求,服务器响应并返回相应的结果。
目前,CS架构已被广泛应用于各种场景中,如Web应用程序、电子邮件、数据库管理等,并且具有可扩展性、可靠性和安全性等优点。
TCP利用Socket(套接字)接口来实现C/S模型的网络程序开发,其早已被广泛的采用。通常,主动发起通信的应用程序属于客户端。而服务器则是等待通信请求,当服务器收到客户端的请求,执行需要的运算然后向客户端返回结果。
如我们使用QQ软件时,我们电脑上安装的就是一个客户端软件,而腾讯必需运行一个服务器。
2.1.2 Socket套接字的介绍
socket被称为套接字,用于描述IP地址和端口号。主机上一般运行了多个服务软件,同时提供多种服务,每种服务都会打开一个Socket,并绑定到一个端口上,不同的端口对应不同的服务。
Socket和ServerSocket类位于java.net包中,ServerSocket用于服务端,Socket是建立网络连接时使用的。在连接成功时,应用程序两端都会产生一个Socket实例,两个Socket构成一个通信管道。操作这个实例,完成所需要的通信。
套接字的基本操作有七个基本操作:
1. 连接到远程主机
2. 绑定到端口
3. 接收从远程机器来的连接请求
4. 监听到达的数据
5. 发送数据
6. 接收数据
7. 关闭连接
2.1.3 Socket编程步骤
套接字编程分为服务器编程和客户端编程,其通信模型如图所示:
1)服务端编程步骤如下:
1. 调用 ServerSocket(int port) 创建一个服务器端套接字,并绑定到指定端口上。
2. 调用 accept(),监听连接请求,如果客户端请求连接,则接受连接,返回通信套接字。
3. 调用 Socket类的 getOutputStream 和 getInputStream 获取输出流和输入流,开始网络数据的 发送和接收。
4. 最后关闭通信套接字。
2)客户端编程步骤如下:
1. 创建 Socket。根据指定的 IP和port构造 Socket 类对象,并发送连接请求。如服务器端响应,则建立客户端到服务器的通信线路。
2. 通过Socket获取与服务器的通信流。 使用 getInputStream()方法获得输入流,使用 getOutputStream()方法获得输出流。
3. 按照一定的协议对 Socket进行读/写操作。通过输入流读取服务端响应的信息,通过输出流将信息发送给服务端。
4. 关闭 Socket。断开客户端到服务器的连接,释放线路。
3)流连接
1. 客户端和服务器端的套接字对象诞生以后,必须进行输入、输出流的连接。
2. 套接字调用 close()方法 可以关闭双方的套接字连接,只要一方关闭连接,就会导致对方发生 IOException异常。
2.2 三个常用类的API
2.2.1 InetAddress
InetAddress,该类用于描述一台机器的IP和主机名信息;常用的两个子类,分别是Inet4Address、Inet6Address。
InetAddress的实例对象由一个IP地址和可能与之对应的主机名(域名)组成。
互联网中的主机地址有两种表现形式:
域名: www.baidu.com
IP地址: 110.242.68.4
域名容易记忆,当在连接网络时输入一个主机的域名后,域名服务器(DNS)负责将域名转化成IP地址,
这样才能和主机建立连接。
常用API:
1. static InetAddress getLocalHost():返回本地主机名和IP地址。
2. static InetAddress getByName(String host):返回一个确定主机名称的IP地址。
3. String getHostAddress():返回文本显示中的IP地址字符串。
4. String getHostName():获取此IP地址的主机名。
描述本机的形式有:
1. 127.0.0.1
2. localhost
3. 具体IP
public static void main(String[] args) {
//获取一个描述本机信息的InetAddress对象: 包括主机名称和IP地址
try {
InetAddress addr = InetAddress.getLocalHost();
System.out.println(addr);
//获取里面的主机名称
System.out.println("主机名称:"+addr.getHostName());
//获取里面的IP地址 192.168.1.124
System.out.println("IP地址:"+addr.getHostAddress());
//IP的字节序列使用 [-64, -88, 1, 124]
System.out.println(Arrays.toString(addr.getAddress()));
//描述本机的形式有: 1. 127.0.0.1 2. localhost 3. 具体IP
InetAddress addr2 = InetAddress.getByName("127.0.0.1");
System.out.println(addr2);
//获取其他域名或者指定IP的信息
InetAddress inet2 = InetAddress.getByName("www.baidu.com");
System.out.println(inet2);
System.out.println(inet2.getHostAddress());
System.out.println(inet2.getHostName());
//获取域名对应的所有的主机
InetAddress[] allByName = InetAddress.getAllByName("www.baidu.com");
System.out.println(allByName.length);
for (InetAddress inet : allByName) {
System.out.println(inet.getHostAddress());
}
} catch (UnknownHostException e) {
e.printStackTrace();
}
}
运行结果:
LAPTOP-PKV7GBLS/192.168.1.124
主机名称:LAPTOP-PKV7GBLS
IP地址:192.168.1.124
[-64, -88, 1, 124]
/127.0.0.1
www.baidu.com/110.242.68.3
110.242.68.3
www.baidu.com
2
110.242.68.3
110.242.68.4
2.2.2 Socket
Socket这个类用于描述TCP的客户端。
常用构造器:
1. Socket(InetAdress address,int port):指定要连接的服务器的地址和端口号。
Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9999);
2. Socket(String host,int port):指定要连接的服务器的IP和端口号。
Socket socket = new Socket("127.0.0.1", 9999);
常用方法:
1. InetAddress getLocalAddress():返回客户端的地址信息。
2. int getLocalPort():返回客户端自己用于通信的端口号(系统分配的)。
3. InetAddress getInetAddress():返回远程服务端的地址信息。
4. int getInetPort():返回远程服务端的端口号。
5. void close() throws IOException:关闭Socket,释放资源。
6. InputStream getInputStream() throws Exception:获取字节输入流,用于读取远程服务端发送的数据。
7. OutputStream getOutputStream() throws IOException:获取字节输出流,用于向远程服务端发送数据。
2.2.3 ServerSocket
ServerSocket这个类用来描述TCP的服务端。
常用构造器:
ServerSocket(int port): 用于指定一个端口号,返回具体实例。
ServerSocket server = new ServerSocket(9999);
常用方法:
1. setSoTimeOut(int timeOut): 用于定义一个阻塞的超时时间,单位是毫秒,超过指定时间,抛异常。
server.setSoTimeout(10000);
2. accept(): 一个阻塞方法,用于监听客户端的连接,如果监听到,则返回一个Socket对象。
//如果指定了超时时间,该时间段内没有客户端连接,抛异常 SocketTimeoutException
Socket socket = server.accept();
3. 其他方法
System.out.println("服务端IP: "+server.getInetAddress().getHostAddress());
System.out.println("服务端IP: "+server.getInetAddress().getHostName());
System.out.println("详细内容: "+server.getLocalSocketAddress());
System.out.println("正在使用的端口号: "+server.getLocalPort());
System.out.println("服务端是否关闭: "+server.isClosed());
System.out.println("超时时间: "+server.getSoTimeout());
System.out.println("服务器绑定的端口是否是正确的: "+server.isBound());
三、聊天小项目
3.1 第一个小版本
客户端向服务端发送信息,服务端打印消息。
3.1.1 服务端的代码
package com.se.day12.Exercise;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 服务端
*/
public class ChatServer01 {
private ServerSocket server;
public ChatServer01(int port) {
try {
server = new ServerSocket(port);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public void start() {
System.out.println("---等待客户端连接---");
Socket socket = null;
try {
server.setSoTimeout(10000);
socket = server.accept();
System.out.println("---一个客户端已经连接---");
InputStream in = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(in, "utf-8"));
String info = br.readLine();
System.out.println("客户端发送过来的信息:"+info);
} catch (IOException e) {
System.out.println("10s内没有客户端进行连接");
}
}
public static void main(String[] args) {
ChatServer01 chatServer = new ChatServer01(1020);
chatServer.start();
}
}
3.1.2 客户端的代码
package com.se.day12.Exercise;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.net.Socket;
/**
* 客户端
*/
public class ChatClient01 {
private Socket client;
public ChatClient01() {
try {
client = new Socket("localhost",1020);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
public void start() {
PrintWriter out = null;
try {
OutputStream os = client.getOutputStream();
out = new PrintWriter(new OutputStreamWriter(os,"UTF-8"), true);
out.println("你好!");
} catch (IOException e) {
throw new RuntimeException(e);
}finally {
out.close();
}
}
public static void main(String[] args) {
ChatClient01 chatClient = new ChatClient01();
chatClient.start();
}
}
3.2 第二个小版本
客户端循环向服务端发送信息,服务端负责打印。
3.2.1 服务端代码
3.2.2 客户端代码
3.3 第三个小版本
客户端收到服务端转发的消息。
3.3.1 服务端代码
package com.se.day12.Exercise;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 3.客户端收到服务端转发的消息。
* 服务端
*/
public class ChatServer03 {
//定义一个TCP通信协议的服务端属性
private ServerSocket server;
public ChatServer03(int port) {
try {
server = new ServerSocket(port);
} catch (IOException e) {
System.out.println("---服务器启动失败---");
}
}
/**
* 聊天的主方法
*/
public void start() {
try {
System.out.println("---等待客户端连接---");
Socket socket = server.accept();
System.out.println("---一个客户端连接上了---");
//通过服务端的Socket对象,获取输入流,接受客户端发送过来的数据
InputStream inputStream = socket.getInputStream();
BufferedReader br = new BufferedReader(
new InputStreamReader(inputStream,"utf-8"));
//通过服务端的Socket对象,获取输出流,将信息返回给客户端
OutputStream outputStream = socket.getOutputStream();
PrintWriter pw = new PrintWriter(
new OutputStreamWriter(outputStream,"utf-8"),true);
//循环打印客户端发送过来的信息
String info = "";
while ((info = br.readLine()) != null) {
//使用输出流,将其返回即可
pw.println(info);
}
} catch (IOException e) {
System.out.println("---一个客户端离线了---");
}
}
public static void main(String[] args) {
//创建一个具体的服务器对象
ChatServer03 chatServer = new ChatServer03(8888);
//调用聊天的主方法
chatServer.start();
}
}
3.3.2 客户端代码
package com.se.day12.Exercise;
import java.io.*;
import java.net.Socket;
import java.util.Scanner;
/**
* 3. 客户端收到服务端转发的消息。
* 客户端
*/
public class ChatClient03 {
//定义一个TCP通信协议的客户端属性
private Socket socket;
public ChatClient03() {
//获取Socket对象,同时向服务端发送连接请求, 连接失败:Connection reset
try {
socket = new Socket("localhost",8888);
} catch (IOException e) {
System.out.println("---服务器崩溃中---");
}
}
// 聊天的主方法
public void start(){
try {
//获取一个获取服务端信息的处理器任务
Runnable task = new GetServerInfoHandler();
Thread thread = new Thread(task);
thread.start();
//获取向服务器发送信息的输出流对象
OutputStream outputStream = socket.getOutputStream();
//封装成字符缓存流,可以按行输出
PrintWriter out = new PrintWriter(
new OutputStreamWriter(outputStream,"UTF-8"),
true);
//使用控制台扫描对象类型,不断的扫描控制台上的文字
Scanner scan = new Scanner(System.in);
System.out.println("====开始聊天====");
while(true){
String info = scan.nextLine();
//将扫描的信息发送到服务端
out.println(info);
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
//创建一个具体的聊天客户端对象
ChatClient03 client = new ChatClient03();
//调用客户端的主方法
client.start();
}
/**
* 编写一个获取服务端信息的处理器。即一个任务体
*/
class GetServerInfoHandler implements Runnable{
public void run(){
try {
//获取接受服务端发送过来的数据的输入流对象
InputStream inputStream = socket.getInputStream();
BufferedReader br = new BufferedReader(
new InputStreamReader(inputStream,"utf-8"));
String line = "";
while((line = br.readLine()) != null){
System.out.println("服务端返回的数据:"+line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
3.4 第四个版本
客户端多开,客户端自己和自己聊天。
3.4.1 服务端代码
将第三个版本的代码,改成多客户端(多线程)并发执行。
package com.se.day12.Exercise;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 4. 客户端多开,客户端自己和自己聊天。
* 服务端
*/
public class ChatServer04 {
//定义一个TCP通信协议的服务端属性
private ServerSocket server;
public ChatServer04(int port) {
try {
server = new ServerSocket(port);
} catch (IOException e) {
System.out.println("---服务器启动失败---");
}
}
/**
* 聊天的主方法
*/
public void start() {
try {
while (true) {
System.out.println("---等待客户端连接---");
Socket socket = server.accept();
System.out.println("---一个客户端连接上了---");
//每获取一个客户端的Socket对象,就应该将其放入一个并发线程中
Runnable task = new GetClientInfoHandler(socket);
Thread thread = new Thread(task);
thread.start();
}
} catch (IOException e) {
System.out.println("---一个客户端离线了---");
}
}
public static void main(String[] args) {
//创建一个具体的服务器对象
ChatServer04 chatServer = new ChatServer04(8888);
//调用聊天的主方法
chatServer.start();
}
/**
* 定义一个处理客户端信息的处理器,即一个任务体
*/
class GetClientInfoHandler implements Runnable {
//因为run方法中使用了 start方法中的socket局部变量
//所以可以在该类中添加一个属性,run方法中可以访问该类的属性
private Socket socket;
//提供一个构造器,将start方法中的局部变量socket传进来,给属性赋值, 这样,run方法中使用的socket就是
//start方法中的局部变量指向的对象
public GetClientInfoHandler(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
try {
//通过服务端的Socket对象,获取输入流,接受客户端发送过来的数据
InputStream inputStream = socket.getInputStream();
BufferedReader br = new BufferedReader(
new InputStreamReader(inputStream,"utf-8"));
//通过服务端的Socket对象,获取输出流,将信息返回给客户端
OutputStream outputStream = socket.getOutputStream();
PrintWriter pw = new PrintWriter(
new OutputStreamWriter(outputStream,"utf-8"),true);
//循环打印客户端发送过来的信息
String info = "";
while ((info = br.readLine()) != null) {
//使用输出流,将其返回即可
pw.println(info);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
3.4.2 客户端代码
与第三个版本一致。
3.5 第五个版本
一个客户端与多个客户端对话,同时处理某一个客户端下线的问题。
3.5.1 服务端代码
package com.se.day12.Exercise;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* 5.一个客户端与多个客户端对话,同时处理某一个客户端下线的问题。
* 服务端
*/
public class ChatServer05 {
//定义一个TCP通信协议的服务端属性
private ServerSocket server;
//添加一个Map属性,用于存储多个客户端的标识与输出流对象。 Map集合(散列表)
private Map<String,PrintWriter> allOut;
public ChatServer05(int port) {
try {
server = new ServerSocket(port);
//给map集合赋值
allOut = new HashMap<String,PrintWriter>();
} catch (IOException e) {
System.out.println("---服务器启动失败---");
}
}
/**
* 聊天的主方法
*/
public void start() {
try {
while (true) {
System.out.println("---等待客户端连接---");
Socket socket = server.accept();
System.out.println("---一个客户端连接上了---");
//每获取一个客户端的Socket对象,就应该将其放入一个并发线程中
Runnable task = new GetClientInfoHandler(socket);
Thread thread = new Thread(task);
thread.start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
//创建一个具体的服务器对象
ChatServer05 chatServer = new ChatServer05(8888);
//调用聊天的主方法
chatServer.start();
}
/**
* 定义一个处理客户端信息的处理器,即一个任务体
*/
class GetClientInfoHandler implements Runnable {
//因为run方法中使用了 start方法中的socket局部变量
//所以可以在该类中添加一个属性,run方法中可以访问该类的属性
private Socket socket;
//提供一个构造器,将start方法中的局部变量socket传进来,给属性赋值, 这样,run方法中使用的socket就是
//start方法中的局部变量指向的对象
public GetClientInfoHandler(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
String nickname = null;
try {
//通过服务端的Socket对象,获取输入流,接受客户端发送过来的数据
InputStream inputStream = socket.getInputStream();
BufferedReader br = new BufferedReader(
new InputStreamReader(inputStream,"utf-8"));
//通过服务端的Socket对象,获取输出流,将信息返回给客户端
OutputStream outputStream = socket.getOutputStream();
PrintWriter pw = new PrintWriter(
new OutputStreamWriter(outputStream,"utf-8"),true);
//先获取客户端的昵称
nickname = br.readLine();
//判断是否已经被占用,如果已经被占用,加后缀
while(allOut.containsKey(nickname)){
nickname = nickname+Math.random();
}
//将昵称告诉客户端
pw.println(nickname);
//将输出流添加到Map集合中
allOut.put(nickname,pw);
System.out.println("-----在线人数:"+allOut.size()+"--------");
//循环打印客户端发送过来的信息
String info = "";
while ((info = br.readLine()) != null) {
//将信息info发送到所有的客户端里
sendToAllClient(nickname,info);
}
} catch (IOException e) {
System.out.println("---一个客户端离线了---");
//删除对应的键值对
allOut.remove(nickname);
System.out.println("-----在线人数:"+allOut.size()+"--------");
}
}
}
public void sendToAllClient(String nickname, String info) {
//遍历Map里的所有输出流,来发送info信息
Set<String> nicks = allOut.keySet();
for (String nick : nicks) {
//获取对应的输出流,然后发送信息
PrintWriter writer = allOut.get(nick);
writer.println(nickname+"说:"+info);
}
}
}
3.5.2 客户端代码
package com.se.day12.Exercise;
import java.io.*;
import java.net.Socket;
import java.util.Scanner;
/**
* 6.一个客户端与多个客户端对话,同时处理某一个客户端下线的问题。
* 客户端
*/
public class ChatClient05 {
//定义一个TCP通信协议的客户端属性
private Socket socket;
public ChatClient05() {
//获取Socket对象,同时向服务端发送连接请求, 连接失败:Connection reset
try {
socket = new Socket("localhost",8888);
} catch (IOException e) {
System.out.println("---服务器崩溃中---");
}
}
// 聊天的主方法
public void start(){
try {
//获取一个获取服务端信息的处理器任务
Runnable task = new GetServerInfoHandler();
Thread thread = new Thread(task);
thread.start();
//获取向服务器发送信息的输出流对象
OutputStream outputStream = socket.getOutputStream();
//封装成字符缓存流,可以按行输出
PrintWriter out = new PrintWriter(
new OutputStreamWriter(outputStream,"UTF-8"),
true);
//使用控制台扫描对象类型,不断的扫描控制台上的文字
Scanner scan = new Scanner(System.in);
//先设置昵称
System.out.println("请输入您的昵称:");
String nickname = scan.nextLine();
//将昵称发送给服务器,让服务器校验昵称是否已经被占用
out.println(nickname);
System.out.println("====开始聊天====");
while(true){
String info = scan.nextLine();
//将扫描的信息发送到服务端
out.println(info);
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
//创建一个具体的聊天客户端对象
ChatClient05 client = new ChatClient05();
//调用客户端的主方法
client.start();
}
/**
* 编写一个获取服务端信息的处理器。即一个任务体
*/
class GetServerInfoHandler implements Runnable{
public void run(){
try {
//获取接受服务端发送过来的数据的输入流对象
InputStream inputStream = socket.getInputStream();
BufferedReader br = new BufferedReader(
new InputStreamReader(inputStream,"utf-8"));
//获取自己的昵称:
String nickname = br.readLine();
System.out.println("您的昵称:"+nickname);
String line = "";
while((line = br.readLine()) != null){
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
3.6 第六个版本
客户端私聊模式。
3.6.1 服务端代码
package com.se.day12.chat;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
/**
* 6.私聊模式
* 聊天服务端
*/
public class ChatServer {
//定义一个TCP通信协议的服务端属性
private ServerSocket server;
//添加一个Map属性,用于存储多个客户端的标识与输出流对象。 Map集合(散列表)
private Map<String,PrintWriter> allOut;
public ChatServer(int port) {
try {
server = new ServerSocket(port);
//给map集合赋值
allOut = new HashMap<String,PrintWriter>();
} catch (IOException e) {
System.out.println("---服务器启动失败---");
}
}
/**
* 聊天的主方法
*/
public void start() {
try {
while (true) {
System.out.println("---等待客户端连接---");
Socket socket = server.accept();
System.out.println("---一个客户端连接上了---");
Runnable task = new GetClientInfoHandler(socket);
Thread thread = new Thread(task);
thread.start();
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
//创建一个具体的服务器对象
ChatServer chatServer = new ChatServer(8888);
//调用聊天的主方法
chatServer.start();
}
/**
* 定义一个处理客户端信息的处理器,即一个任务体。
*/
class GetClientInfoHandler implements Runnable {
//因为run方法中使用了 start方法中的socket局部变量
//所以可以在该类中添加一个属性,run方法中可以访问该类的属性
private Socket socket;
//提供一个构造器,将start方法中的局部变量socket传进来,给属性赋值, 这样,run方法中使用的socket就是
//start方法中的局部变量指向的对象
public GetClientInfoHandler(Socket socket) {
this.socket = socket;
}
@Override
public void run() {
String nickname = null;
try {
//通过服务端的Socket对象,获取输入流,接受客户端发送过来的数据
InputStream inputStream = socket.getInputStream();
BufferedReader br = new BufferedReader(
new InputStreamReader(inputStream,"utf-8"));
//通过服务端的Socket对象,获取输出流,将信息返回给客户端
OutputStream outputStream = socket.getOutputStream();
PrintWriter pw = new PrintWriter(
new OutputStreamWriter(outputStream,"utf-8"),true);
//先获取客户端的昵称
nickname = br.readLine();
//判断是否已经被占用,如果已经被占用,加后缀
while (allOut.containsKey(nickname)) {
nickname = nickname + Math.random();
}
//将昵称告诉客户端
pw.println(nickname);
//将该客户端的输出流添加到Map集合中
allOut.put(nickname, pw);
System.out.println("-----在线人数:" + allOut.size() + "-----------");
//循环打印客户端发送过来的信息
String info = "";
while ((info = br.readLine()) != null) {
if(info.startsWith("@")){
sendPrivate(nickname,info);
}else{
//将信息info发送到所有的客户端里
sendToAllClient(nickname, info);
}
}
} catch (IOException e) {
System.out.println("---一个客户端离线了---");
//删除对应的键值对
allOut.remove(nickname);
System.out.println("-----在线人数:" + allOut.size() + "-----------");
}
}
public void sendToAllClient(String nickname, String info) {
//遍历Map里的所有输出流,来发送info信息。
Set<String> nicks = allOut.keySet();
for (String nick : nicks) {
//获取对应的输出流,然后发送信息。
allOut.get(nick).println(nickname + "说:" + info);
}
}
public void sendPrivate(String nickname, String info) {
Set<Map.Entry<String, PrintWriter>> entries = allOut.entrySet();
for (Map.Entry<String, PrintWriter> entry : entries) {
if (info.startsWith("@" + entry.getKey())) {
entry.getValue().println(nickname + "说:" + info);
}
}
PrintWriter value = allOut.get(nickname);
value.println(nickname + "说:" + info);
}
}
}
3.6.2 客户端代码
package com.se.day12.chat;
import java.io.*;
import java.net.Socket;
import java.util.Scanner;
/**
* 6.私聊模式
* 聊天客户端
*/
public class ChatClient {
//定义一个TCP通信协议的客户端属性
private Socket socket;
public ChatClient() {
//获取Socket对象,同时向服务端发送连接请求, 连接失败:Connection reset
try {
socket = new Socket("localhost",8888);
} catch (IOException e) {
System.out.println("---服务器崩溃中---");
}
}
// 聊天的主方法
public void start(){
try {
//获取一个获取服务端信息的处理器任务
Runnable task = new GetServerInfoHandler();
Thread thread = new Thread(task);
thread.start();
//获取向服务器发送信息的输出流对象
OutputStream outputStream = socket.getOutputStream();
//封装成字符缓存流,可以按行输出
PrintWriter out = new PrintWriter(
new OutputStreamWriter(outputStream,"UTF-8"),
true);
//使用控制台扫描对象类型,不断的扫描控制台上的文字
Scanner scan = new Scanner(System.in);
//先设置昵称
System.out.println("请输入您的昵称:");
String nickname = scan.nextLine();
//将昵称发送给服务器,让服务器校验昵称是否已经被占用
out.println(nickname);
System.out.println("====开始聊天====");
while(true){
String info = scan.nextLine();
//将扫描的信息发送到服务端
out.println(info);
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
//创建一个具体的聊天客户端对象
ChatClient client = new ChatClient();
//调用客户端的主方法
client.start();
}
/**
* 编写一个获取服务端信息的处理器,即一个任务体。
*/
class GetServerInfoHandler implements Runnable{
public void run(){
try {
//获取接受服务端发送过来的数据的输入流对象
InputStream inputStream = socket.getInputStream();
BufferedReader br = new BufferedReader(
new InputStreamReader(inputStream,"utf-8"));
//获取自己的昵称:
String nickname = br.readLine();
System.out.println("您的昵称:"+nickname);
String line = "";
while((line = br.readLine()) != null){
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
}