网络编程(三要素)、UDP通信程序(单播、组播、广播)、TCP通信程序(文件上传)、TCP程序服务器优化
活动地址：CSDN21天学习挑战赛
网络编程
概述
计算机网络
是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统
网络编程
在网络通信协议下，不同计算机上运行的程序，可以进行数据传输
网络编程三要素
IP地址（设备在网络中唯一的标识）
要想让网络中的计算机能够互相通信，必须为每台计算机指定一个标识号，通过这个标识号来指定要接收数据的计算机和识别发送的计算机，而IP地址就是这个标识号。也就是设备的标识
端口
端口号（应用程序在设备中唯一的标识）
网络的通信，本质上是两个应用程序的通信。每台计算机都有很多的应用程序，那么在网络通信时，如何区分这些应用程序呢？如果说IP地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的应用程序了。也就是应用程序的标识协议（数据在传输过程中遵守的规则）
通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。常见的协议有UDP协议和TCP协议
IP地址
IP地址：是网络中设备的唯一标识
IP地址分为两大类
IPv4：是给每个连接在网络上的主机分配一个32bit地址。按照TCP/IP规定，IP地址用二进制来表示，每个IP地址长32bit，也就是4个字节。例如一个采用二进制形式的IP地址是“11000000 10101000 00000001 01000010”，这么长的地址，处理起来也太费劲了。为了方便使用，IP地址经常被写成十进制的形式，中间使用符号“.”分隔不同的字节。于是，上面的IP地址可以表示为“192.168.1.66”。IP地址的这种表示法叫做“点分十进制表示法”，这显然比1和0容易记忆得多
IPv6：由于互联网的蓬勃发展，IP地址的需求量愈来愈大，但是网络地址资源有限，使得IP的分配越发紧张。为了扩大地址空间，通过IPv6重新定义地址空间，采用128位地址长度，每16个字节一组，分成8组十六进制数，这样就解决了网络地址资源数量不够的问题
DOS常用命令：
ipconfig：查看本机IP地址
ping IP地址：检查网络是否连通
特殊IP地址：
127.0.0.1：是回送地址，可以代表本机地址，一般用来测试使用
组播地址：224.0.0.0 ~ 239.255.255.255 ，其中224.0.0.0 ~ 224.0.0.255 为预留的组播地址
广播地址：255.255.255.255
InetAddress
InetAddress：此类表示Internet协议（IP）地址
相关方法
方法名 说明 static InetAddress getByName(String host) 确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址 String getHostName() 获取此IP地址的主机名 String getHostAddress() 返回文本显示中的IP地址字符串 代码演示
package cn.moming; import java.net.InetAddress; import java.net.UnknownHostException; public class InerAddressDemo { public static void main(String[] args) throws UnknownHostException { //根据主机名称获取网络地址 InetAddress inetAddress = InetAddress.getByName("沫洺"); System.out.println(inetAddress); //根据网络地址获取主机名 String hostName = inetAddress.getHostName(); System.out.println("主机名为："+hostName); //根据网络地址获取主机地址 String hostAddress = inetAddress.getHostAddress(); System.out.println("主机地址:"+hostAddress); } }沫洺/127.0.0.1 主机名为：沫洺 主机地址:127.0.0.1
端口和协议
端口
- 设备上应用程序的唯一标识
端口号
- 用两个字节表示的整数，它的取值范围是0~65535。其中，0~1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败
- 注意：一个端口号只能被一个应用程序使用。
协议
- 计算机网络中，连接和通信的规则被称为网络通信协议
UDP协议
- 用户数据报协议(User Datagram Protocol)
- UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。
- 由于使用UDP协议消耗系统资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输
- 例如视频会议通常采用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议
TCP协议
- 传输控制协议 (Transmission Control Protocol)
- TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”
- 三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠
第一次握手，客户端向服务器端发出连接请求，等待服务器确认
第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求
第三次握手，客户端再次向服务器端发送确认信息，确认连接
- 完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，TCP协议可以保证传输数据的安全，所以应用十分广泛。例如上传文件、下载文件、浏览网页等
UDP通信程序
UDP发送数据
Java中的UDP通信
UDP协议是一种不可靠的网络协议，它在通信的两端各建立一个Socket对象，但是这两个Socket只是发送，接收数据的对象，因此对于基于UDP协议的通信双方而言，没有所谓的客户端和服务器的概念
Java提供了DatagramSocket类作为基于UDP协议的Socket
构造方法
方法名 说明 DatagramSocket() 创建数据报套接字并将其绑定到本机地址上的任何可用端口 DatagramPacket(byte[] buf,int len,InetAddress add,int port) 创建数据包,发送长度为len的数据包到指定主机的指定端口 相关方法
方法名 说明 void send(DatagramPacket p) 发送数据报包 void close() 关闭数据报套接字 void receive(DatagramPacket p) 从此套接字接受数据报包 发送数据的步骤
创建发送端的Socket对象(DatagramSocket)
创建数据，并把数据打包
调用DatagramSocket对象的方法发送数据
关闭发送端
代码演示
package cn.moming; import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; public class SendDemo { public static void main(String[] args) throws IOException { //创建发送端的Socket对象(DatagramSocket) //创建数据报套接字并将其绑定到本机地址上的任何可用端口 DatagramSocket ds = new DatagramSocket(); byte[] bytes = "hello".getBytes(); //创建数据包,发送长度为len的数据包到指定主机的指定端口 DatagramPacket dp = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("127.0.0.1"),10086); //调用DatagramSocket对象的方法发送数据 ds.send(dp); //关闭发送端，释放资源 ds.close(); } }运行之后没结果，这是发送端，由于是UDP通信协议（无连接通信协议 ），所以不管是否通信连接，都将数据发送
UDP接收数据
接收数据的步骤
创建接收端的Socket对象(DatagramSocket)
创建一个数据包，用于接收数据
调用DatagramSocket对象的方法接收数据
解析数据包，并把数据在控制台显示
关闭接收端
构造方法
方法名 说明 DatagramPacket(byte[] buf, int len) 创建一个DatagramPacket用于接收长度为len的数据包 相关方法
方法名 说明 byte[] getData() 返回数据缓冲区 int getLength() 返回要发送的数据的长度或接收的数据的长度 代码演示
package cn.moming; import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; public class ReceiveDemo { public static void main(String[] args) throws IOException { //创建接收端的Socket对象(DatagramSocket) DatagramSocket ds = new DatagramSocket(10000); //创建一个数据包，用于接受数据 byte[] bytes = new byte[1024]; DatagramPacket dp= new DatagramPacket(bytes,bytes.length); //调用DatagramSocket对象的方法接收数据 ds.receive(dp); //解析数据包，并把数据在控制台显示 System.out.println("数据是："+new String(dp.getData(),0,dp.getLength())); //关闭发送端，释放资源 ds.close(); } }只有接收端先运行，再运行发送端，才能将发送端发送的数据发送到接收端
UDP通信程序练习
案例需求
UDP发送数据：数据来自于键盘录入，直到输入的数据是886，发送数据结束
UDP接收数据：因为接收端不知道发送端什么时候停止发送，故采用死循环接收
代码实现
发送端
package cn.moming; import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; import java.util.Scanner; public class SendDemo { public static void main(String[] args) throws IOException { Scanner scanner = new Scanner(System.in); //创建发送端的Socket对象(DatagramSocket) //创建数据报套接字并将其绑定到本机地址上的任何可用端口 DatagramSocket ds = new DatagramSocket(); while (true) { String s = scanner.nextLine(); if("886".equals(s))break; byte[] bytes = s.getBytes(); //创建数据包,发送长度为len的数据包到指定主机的指定端口 DatagramPacket dp = new DatagramPacket(bytes,bytes.length, InetAddress.getByName("127.0.0.1"),10000); //调用DatagramSocket对象的方法发送数据 ds.send(dp); } //关闭发送端 ds.close(); } }接收端
package cn.moming; import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; public class ReceiveDemo { public static void main(String[] args) throws IOException { //创建接收端的Socket对象(DatagramSocket) DatagramSocket ds = new DatagramSocket(10000); //创建一个数据包，用于接受数据 while (true) { byte[] bytes = new byte[1024]; DatagramPacket dp= new DatagramPacket(bytes,bytes.length); //调用DatagramSocket对象的方法接收数据 ds.receive(dp); //解析数据包，并把数据在控制台显示 System.out.println("数据是："+new String(dp.getData(),0,dp.getLength())); //关闭发送端 //ds.close(); } } }
UDP三种通信方式
单播
单播用于两个主机之间的端对端通信
组播
组播用于对一组特定的主机进行通信
广播
广播用于一个主机对整个局域网上所有主机上的数据通信
UDP组播实现
实现步骤
发送端
- 创建发送端的Socket对象(DatagramSocket)
- 创建数据，并把数据打包(DatagramPacket)
- 调用DatagramSocket对象的方法发送数据(在单播中,这里是发给指定IP的电脑但是在组播当中,这里是发给组播地址)
- 释放资源
接收端
- 创建接收端Socket对象(MulticastSocket)
- 创建一个箱子,用于接收数据
- 把当前计算机绑定一个组播地址
- 将数据接收到箱子中
- 解析数据包,并打印数据
- 释放资源
代码实现
发送端（单播地址改为组播地址）
package cn.moming; import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; import java.util.Scanner; public class SendDemo { public static void main(String[] args) throws IOException { Scanner scanner = new Scanner(System.in); //创建发送端的Socket对象(DatagramSocket) //创建数据报套接字并将其绑定到本机地址上的任何可用端口 DatagramSocket ds = new DatagramSocket(); String s = "组播发送内容"; byte[] bytes = s.getBytes(); //创建数据包,发送长度为len的数据包到指定主机的指定端口 //组播IP InetAddress address = InetAddress.getByName("224.0.1.0"); //端口号 int port = 10000; DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,port ); //调用DatagramSocket对象的方法发送数据（在单播中,这里是发给指定IP的电脑但是在组播当中,这里是发给组播地址） ds.send(dp); //关闭发送端，释放资源 ds.close(); } }接收端（组播接收端对象，并加入组播）
package cn.moming; import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; import java.net.MulticastSocket; public class ReceiveDemo { public static void main(String[] args) throws IOException { //创建接收端的Socket对象(MulticastSocket) MulticastSocket ms = new MulticastSocket(10000); //创建一个数据包，用于接受数据 DatagramPacket dp= new DatagramPacket(new byte[1024],1024); //把当前计算机绑定一个组播地址，表示添加到这一组 ms.joinGroup(InetAddress.getByName("224.0.1.0")); //调用DatagramSocket对象的方法接收数据 ms.receive(dp); //解析数据包，并把数据在控制台显示 byte[] data = dp.getData(); int length = dp.getLength(); System.out.println("数据是："+new String(data,0,length)); //关闭发送端,释放资源 ms.close(); } }
UDP广播实现
实现步骤
发送端
- 创建发送端Socket对象(DatagramSocket)
- 创建存储数据的箱子,将广播地址封装进去
- 发送数据
- 释放资源
接收端
- 创建接收端的Socket对象(DatagramSocket)
- 创建一个数据包，用于接收数据
- 调用DatagramSocket对象的方法接收数据
- 解析数据包，并把数据在控制台显示
- 关闭接收端
代码实现
发送端（IP改为广播IP255.255.255.255）
package cn.moming; import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; import java.util.Scanner; public class SendDemo { public static void main(String[] args) throws IOException { Scanner scanner = new Scanner(System.in); //创建发送端的Socket对象(DatagramSocket) DatagramSocket ds = new DatagramSocket(); String s = "广播发送内容"; byte[] bytes = s.getBytes(); //创建数据包,发送长度为len的数据包到指定主机的指定端口 //广播IP InetAddress address = InetAddress.getByName("255.255.255.255"); //端口号 int port = 10000; DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,port ); //调用DatagramSocket对象的方法发送数据（在单播中,这里是发给指定IP的电脑但是在组播当中,这里是发给广播地址） ds.send(dp); //关闭发送端，释放资源 ds.close(); } }接收端（和单播一样）
package cn.moming; import java.io.IOException; import java.net.DatagramPacket; import java.net.DatagramSocket; import java.net.InetAddress; import java.net.MulticastSocket; public class ReceiveDemo { public static void main(String[] args) throws IOException { //创建接收端的Socket对象(DatagramSocket) DatagramSocket ms = new DatagramSocket(10000); //创建一个数据包，用于接受数据 DatagramPacket dp= new DatagramPacket(new byte[1024],1024); //调用DatagramSocket对象的方法接收数据 ms.receive(dp); //解析数据包，并把数据在控制台显示 byte[] data = dp.getData(); int length = dp.getLength(); System.out.println("数据是："+new String(data,0,length)); //关闭发送端,释放资源 ms.close(); } }
TCP通信程序
TCP通信原理
- TCP通信协议是一种可靠的网络协议，它在通信的两端各建立一个Socket对象。
- 通信之前要保证连接已经建立。
- 基于IO流，通过Socket产生IO流来进行网络通信。
特点:
- 面向连接
- 没有数据大小限制;
- 效率低(资源消耗多);
- 安全
TCP发送数据
Java中的TCP通信
Java对基于TCP协议的的网络提供了良好的封装，使用Socket对象来代表两端的通信端口，并通过Socket产生IO流来进行网络通信。
Java为客户端提供了Socket类，为服务器端提供了ServerSocket类
TCP发送数据步骤
- 创建客户端的Socket对象(Socket)与指定服务端连接
- 获取输出流，写数据
- 释放资源
构造方法
方法名 说明 Socket(InetAddress address,int port) 创建流套接字并将其连接到指定IP指定端口号 Socket(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号 相关方法
方法名 说明 InputStream getInputStream() 返回此套接字的输入流 OutputStream getOutputStream() 返回此套接字的输出流 实例代码
package cn.moming1; import java.io.IOException; import java.io.OutputStream; import java.net.Socket; public class CilentDemo { public static void main(String[] args) throws IOException { //创建客户端的Socket对象（Socket） Socket s = new Socket("127.0.0.1",10000); //获取输出流，写数据 OutputStream os = s.getOutputStream(); os.write("TCP发送端发送的内容".getBytes()); //释放资源 s.close(); } }
TCP接收数据
TCP接收数据步骤
- 创建服务器端的Socket对象(ServerSocket)
- 获取输入流，读数据，并把数据显示在控制台
- 释放资源
构造方法
方法名 说明 ServletSocket(int port) 创建绑定到指定端口的服务器套接字 相关方法
方法名 说明 Socket accept() 监听要连接到此的套接字并接受它 注意事项
accept方法是阻塞的,作用就是等待客户端连接
客户端创建对象并连接服务器,此时是通过三次握手协议,保证跟服务器之间的连接
针对客户端来讲,是往外写的,所以是输出流 针对服务器来讲,是往里读的,所以是输入流
read方法也是阻塞的
客户端在关流的时候,还多了一个往服务器写结束标记的动作
最后一步断开连接,通过四次挥手协议保证连接终止
三次握手和四次挥手
三次握手：
- 由客户端发起请求连接,服务器同意,客户端确认;
- 代码体现: Socket s = new Socket(ip,端口);只要这一行代码执行成功了,那么三次握手就完成了!
四次挥手：
- 由客户端发起请求断开,服务器同意,服务器确认,客户端确认;
- 代码体现: close()方法;只要这一行代码执行成功了,那么四次挥手就完成了!
示例代码
package cn.moming1; import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; public class ServerDemo { public static void main(String[] args) throws IOException { //创建服务器端的Socket对象（ServerSocket） ServerSocket ss = new ServerSocket(10000); //侦听要连接到此套接字并接受它 Socket s = ss.accept(); //获取输入流，读数据，并把数据显示到控制台 InputStream is = s.getInputStream(); byte[] bytes = new byte[1024]; int len = is.read(bytes); String data = new String(bytes,0,len); System.out.println("服务器接收到："+data); //释放资源 s.close(); ss.close(); } }先开启服务器，客户端向服务器端发送连接请求，发送数据
服务器接收到：TCP发送端发送的内容
TCP程序文件上传练习
案例需求
- 客户端：数据来自于本地文件，接收服务器反馈
- 服务器：接收到的数据写入本地文件，给出反馈
案例分析
- 创建客户端对象，创建输入流对象指向文件，每读一次数据就给服务器输出一次数据，输出结束后使用shutdownOutput()方法告知服务端传输结束
- 创建服务器对象，创建输出流对象指向文件，每接受一次数据就使用输出流输出到文件中，传输结束后。使用输出流给客户端反馈信息
- 客户端接受服务端的回馈信息
相关方法
方法名 说明 void shutdownInput() 将此套接字的输入流放置在“流的末尾” void shutdownOutput() 禁止用此套接字的输出流 代码实现
客户端
package cn.moming2; import java.io.*; import java.net.Socket; public class ClientDemo { public static void main(String[] args) throws IOException { //创建客户端对象 Socket s = new Socket("127.0.0.1",10000); //获取输入流，写数据 OutputStream os = s.getOutputStream(); BufferedOutputStream bos = new BufferedOutputStream(os); //读取本地文件 BufferedInputStream bis = new BufferedInputStream(new FileInputStream("words.txt")); //写到服务器端 int b; while ((b=bis.read())!=-1){ bos.write(b); bos.flush(); } //给服务器一个结束标记 s.shutdownOutput(); //接收服务器端的提示信息 BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream())); String len; while ((len=br.readLine())!=null){ System.out.println(len); } //释放资源 bis.close(); s.close(); } }服务器端
package cn.moming2; import java.io.*; import java.net.ServerSocket; import java.net.Socket; public class ServerDemo { public static void main(String[] args) throws IOException { //创建服务器对象 ServerSocket ss = new ServerSocket(10000); //侦听要连接到此套接字并接受它 Socket s = ss.accept(); //获取客户端发送过来的数据，读数据，写入本地文件 InputStream is = s.getInputStream(); BufferedInputStream bis = new BufferedInputStream(is); //本地的IO流,把数据写到本地中,实现永久化存储 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("newWords.txt")); int b; while ((b=bis.read())!=-1){ bos.write(b); } //通过客户端的流向客户端提示 BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream())); bw.write("上传成功"); bw.newLine(); bw.flush(); //释放资源 bos.close(); s.close(); ss.close(); } }
TCP程序服务器优化
优化方案一
需求
- 服务器只能处理一个客户端请求，接收完一个图片之后，服务器就关闭了。
解决方案
- 使用循环
代码实现
服务器代码如下,客户端代码同上个案例,此处不再给出
public class ServerDemo { public static void main(String[] args) throws IOException { ServerSocket ss = new ServerSocket(10000); while (true) { Socket accept = ss.accept(); //网络中的流,从客户端读取数据的 BufferedInputStream bis = new BufferedInputStream(accept.getInputStream()); //本地的IO流,把数据写到本地中,实现永久化存储 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("newWords.txt")); int b; while((b = bis.read()) !=-1){ bos.write(b); } BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream())); bw.write("上传成功"); bw.newLine(); bw.flush(); bos.close(); accept.close(); } //ss.close(); } }
优化方案二
需求
- 第二次上传文件的时候，会把第一次的文件给覆盖。
解决方案
- UUID. randomUUID()方法生成随机的文件名
代码实现
服务器代码如下,客户端代码同上个案例,此处不再给出
public class ServerDemo { public static void main(String[] args) throws IOException { ServerSocket ss = new ServerSocket(10000); while (true) { Socket accept = ss.accept(); //网络中的流,从客户端读取数据的 BufferedInputStream bis = new BufferedInputStream(accept.getInputStream()); //本地的IO流,把数据写到本地中,实现永久化存储 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("mondule02\\src\\files\\" + UUID.randomUUID().toString() + ".jpg")); int b; while((b = bis.read()) !=-1){ bos.write(b); } BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream())); bw.write("上传成功"); bw.newLine(); bw.flush(); bos.close(); accept.close(); } //ss.close(); } }
优化方案三
需求
- 使用循环虽然可以让服务器处理多个客户端请求。但是还是无法同时跟多个客户端进行通信。
解决方案
- 开启多线程处理
代码实现
线程任务类客户端
public class ThreadSocket implements Runnable { private Socket acceptSocket; public ThreadSocket(Socket accept) { this.acceptSocket = accept; } @Override public void run() { BufferedOutputStream bos = null; try { //网络中的流,从客户端读取数据的 BufferedInputStream bis = new BufferedInputStream(acceptSocket.getInputStream()); //本地的IO流,把数据写到本地中,实现永久化存储 bos = new BufferedOutputStream(new FileOutputStream("mondule02\\src\\files\\" + UUID.randomUUID().toString() + ".jpg")); int b; while((b = bis.read()) !=-1){ bos.write(b); } BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(acceptSocket.getOutputStream())); bw.write("上传成功"); bw.newLine(); bw.flush(); } catch (IOException e) { e.printStackTrace(); } finally { if(bos != null){ try { bos.close(); } catch (IOException e) { e.printStackTrace(); } } if (acceptSocket != null){ try { acceptSocket.close(); } catch (IOException e) { e.printStackTrace(); } } } } }服务器端
public class ServerDemo { public static void main(String[] args) throws IOException { ServerSocket ss = new ServerSocket(10000); while (true) { Socket accept = ss.accept(); ThreadSocket ts = new ThreadSocket(accept); new Thread(ts).start(); } //ss.close(); } }
优化方案四
需求
- 使用多线程虽然可以让服务器同时处理多个客户端请求。但是资源消耗太大。
解决方案
- 加入线程池
代码实现
服务器代码如下,线程任务类代码同上,此处不再给出
public class ServerDemo { public static void main(String[] args) throws IOException { ServerSocket ss = new ServerSocket(10000); //创建线程池对象 ThreadPoolExecutor pool = new ThreadPoolExecutor( 3, //核心线程数量 10, //线程池的总数量 60, //临时线程空闲时间 TimeUnit.SECONDS, //临时线程空闲时间的单位 new ArrayBlockingQueue<>(5),//阻塞队列 Executors.defaultThreadFactory(),//创建线程的方式 new ThreadPoolExecutor.AbortPolicy()//任务拒绝策略 ); while (true) { Socket accept = ss.accept(); ThreadSocket ts = new ThreadSocket(accept); //new Thread(ts).start(); pool.submit(ts); } //ss.close(); } }
TCP程序文件下载练习
思路分析
服务器端（里边用到了类加载器，可以参考第二十天的内容）
package cn.moming5; import java.io.*; import java.net.ServerSocket; import java.net.Socket; public class ServerDemo { public static void main(String[] args) throws IOException { //读客户端发过来的文件名 ServerSocket ss = new ServerSocket(10001); Socket s = ss.accept();//此时的s就是客户端对象 //面向客户端对象，获取网络字节输入流，并包装成字符缓冲输入流（为了读字符串） InputStream is = s.getInputStream(); BufferedReader br = new BufferedReader(new InputStreamReader(is)); //读文件名,读一下即可 String fileName = br.readLine(); //根据文件名找到服务器电脑上的对应文件形成一个输入流 //类加载器获取输入流 InputStream in = ServerDemo.class.getClassLoader().getResourceAsStream(fileName); OutputStream os = s.getOutputStream(); //循环读写（需要利用网络输出流将文件中读到的字节都响应给客户端（字节输出流） byte[] bytes = new byte[8192]; int len; while ((len=in.read(bytes))!=-1){ os.write(bytes,0,len); os.flush(); } //循环结束了，证明文件读完了，给客户端一个结束标记 s.shutdownOutput(); System.out.println("文件下载完成"); //关闭服务器，释放资源 in.close(); s.close(); ss.close(); } }客户端
package cn.moming5; import java.io.*; import java.net.Socket; import java.util.Scanner; public class ClientDemo { public static void main(String[] args) throws IOException { //给服务器发现需要下载的文件名 Socket s = new Socket("127.0.0.1",10001); Scanner sc = new Scanner(System.in); System.out.println("请输入文件名："); String fileName = sc.next(); OutputStream os = s.getOutputStream(); BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os)); bw.write(fileName); bw.newLine();//告诉对方，这一行数据结束 bw.flush(); //准备一个文件字节输出流 FileOutputStream fos = new FileOutputStream("mondule03\\src\\"+fileName); InputStream is = s.getInputStream(); //循环读服务器响应的字节数据，保存到本地文件 byte[] bytes = new byte[8192]; int len; while ((len=is.read(bytes))!=-1){ fos.write(bytes,0,len); fos.flush(); } //释放资源 fos.close(); s.close(); System.out.println("客户端下载文件完成"); } }
下载优化
客户端代码同上，只改服务器端
服务器端
package cn.moming5; import java.io.*; import java.net.ServerSocket; import java.net.Socket; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; public class ServerDemo { public static void main(String[] args) throws IOException { //读客户端发过来的文件名 ServerSocket ss = new ServerSocket(10001); //创建线程池对象 ExecutorService pool = Executors.newFixedThreadPool(3); while (true){ System.out.println("等待客户端连接中"); Socket s = ss.accept();//此时的s就是客户端对象 //开启线程 pool.submit(()->{ try { //面向客户端对象，获取网络字节输入流，并包装成字符缓冲输入流（为了读字符串） InputStream is = s.getInputStream(); BufferedReader br = new BufferedReader(new InputStreamReader(is)); //读文件名,读一下即可 String fileName = br.readLine(); //根据文件名找到服务器电脑上的对应文件形成一个输入流 //类加载器获取输入流 InputStream in = ServerDemo.class.getClassLoader().getResourceAsStream(fileName); OutputStream os = s.getOutputStream(); //循环读写（需要利用网络输出流将文件中读到的字节都响应给客户端（字节输出流） byte[] bytes = new byte[8192]; int len; while ((len=in.read(bytes))!=-1){ os.write(bytes,0,len); os.flush(); } //循环结束了，证明文件读完了，给客户端一个结束标记 s.shutdownOutput(); System.out.println("文件下载完成"); //关闭服务器，释放资源 in.close(); s.close(); //ss.close();//让服务器一直开启，就可使下载多个文件 } catch (IOException e) { e.printStackTrace(); } }); } } }原则上下载文件不存在文件名冲突的问题，所以只需要使用线程池让服务器同时处理多个客户端请求即可
版权声明：本文为HeyVIrBbox原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接和本声明。