1. 网络编程入门
1.1 网络编程概述
-
计算机网络
是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统
-
网络编程
在网络通信协议下，不同计算机上运行的程序，可以进行数据传输
1.2 网络编程三要素
-
IP地址
要想让网络中的计算机能够互相通信，必须为每台计算机指定一个标识号，通过这个标识号来指定要接收数据的计算机和识别发送的计算机，而IP地址就是这个标识号。也就是设备的标识
-
端口
网络的通信，本质上是两个应用程序的通信。每台计算机都有很多的应用程序，那么在网络通信时，如何区分这些应用程序呢？如果说IP地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的应用程序了。也就是应用程序的标识
-
协议
通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则，这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。常见的协议有UDP协议和TCP协议
1.3 IP地址
可能换了一个地方，被分配的IP地址就发生变化了，是不一样的。
1.4 InetAddress
InetAddress：此类表示Internet协议（IP）地址
-
相关方法
方法名 说明 static InetAddress getByName(String host) 确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址 String getHostName() 获取此IP地址的主机名 String getHostAddress() 返回文本显示中的IP地址字符串 -
代码演示
public class Main { public static void main(String[] args) throws UnknownHostException { //IP的对象，也就是一台电脑 InetAddress address = InetAddress.getByName("ggh"); //输出主机名 System.out.println(address.getHostName()); //输出ip地址 System.out.println(address.getHostAddress()); } }
1.5 端口和协议
- 端口
-
协议
-
UDP协议
-
发送数据
public class Main { public static void main(String[] args) throws IOException { //1.创建DatagramSocket对象（快递公司） //细节: //绑定端口，以后我们就是通过这个端口往外发送 //空参:所有可用的端口中随机一个进行使用 //有参:指定端口号进行绑定 DatagramSocket datagramSocket = new DatagramSocket(); //2.打包数据 //2.1 创建数据 String str = "你好呀！"; //2.2 将数据转换为字节数组 byte[] bytes = str.getBytes(); //2.3 创建接收对象 InetAddress byName = InetAddress.getByName("127.0.0.1"); //2.4 设置端口 int port = 10086; //2.5 打包数据 DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length, byName, port); //3. 发送数据 datagramSocket.send(datagramPacket); //4.释放资源 datagramSocket.close(); } } -
接收数据
public class Main1 { public static void main(String[] args) throws IOException { //1. 创建DatagramSocket对象（找快递公司） //细节: //在接收的时候，一定要绑定端口 //而且绑定的端口一定要跟发送的端口保持一致 DatagramSocket datagramSocket = new DatagramSocket(10086); //2. 接受数据包 //2.1 先创建一个字节数组，用于装数据包 byte[] bytes = new byte[1024]; //2.2 将字节数组放到DatagramPacket中 DatagramPacket datagramPacket = new DatagramPacket(bytes, bytes.length); //2.3 接受数据放到数据包中 //细节：该方法是阻塞的，程序运行到这一步，会在这里等待，等待发送端发消息 //因此先运行接收端 datagramSocket.receive(datagramPacket); //3. 解析数据包 byte[] data = datagramPacket.getData(); int length = datagramPacket.getLength(); InetAddress address = datagramPacket.getAddress(); int port = datagramPacket.getPort(); System.out.println("接收到的数据是："+new String(data,0,length)); System.out.println("该数据是从"+address+"这台电脑中的"+port+"发出的！"); //4.释放资源 datagramSocket.close(); } }输出结果：
- 用户数据报协议(User Datagram Protocol)
- UDP是无连接通信协议，即在数据传输时，数据的发送端和接收端不建立逻辑连接。简单来说，当一台计算机向另外一台计算机发送数据时，发送端不会确认接收端是否存在，就会发出数据，同样接收端在收到数据时，也不会向发送端反馈是否收到数据。
- 由于使用UDP协议消耗系统资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输
- 例如视频会议通常采用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时不建议使用UDP协议
-
-
TCP协议
-
传输控制协议 (Transmission Control Protocol)
-
TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。在TCP连接中必须要明确客户端与服务器端，由客户端向服务端发出连接请求，每次连接的创建都需要经过“三次握手”
-
三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠
第一次握手，客户端向服务器端发出连接请求，等待服务器确认
第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求
第三次握手，客户端再次向服务器端发送确认信息，确认连接
-
完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，TCP协议可以保证传输数据的安全，所以应用十分广泛。例如上传文件、下载文件、浏览网页等
-
2.UDP通信程序
2.1 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对象的方法发送数据
- 关闭发送端
-
代码演示
public class SendDemo { public static void main(String[] args) throws IOException { //创建发送端的Socket对象(DatagramSocket) // DatagramSocket() 构造数据报套接字并将其绑定到本地主机上的任何可用端口 DatagramSocket ds = new DatagramSocket(); //创建数据，并把数据打包 //DatagramPacket(byte[] buf, int length, InetAddress address, int port) //构造一个数据包，发送长度为 length的数据包到指定主机上的指定端口号。 byte[] bys = "hello,udp,我来了".getBytes(); DatagramPacket dp = new DatagramPacket(bys,bys.length,InetAddress.getByName("127.0.0.1"),10086); //调用DatagramSocket对象的方法发送数据 //void send(DatagramPacket p) 从此套接字发送数据报包 ds.send(dp); //关闭发送端 //void close() 关闭此数据报套接字 ds.close(); } }
2.2UDP接收数据
-
接收数据的步骤
- 创建接收端的Socket对象(DatagramSocket)
- 创建一个数据包，用于接收数据
- 调用DatagramSocket对象的方法接收数据
- 解析数据包，并把数据在控制台显示
- 关闭接收端
-
构造方法
方法名 说明 DatagramPacket(byte[] buf, int len) 创建一个DatagramPacket用于接收长度为len的数据包 -
相关方法
方法名 说明 byte[] getData() 返回数据缓冲区 int getLength() 返回要发送的数据的长度或接收的数据的长度 -
示例代码
public class ReceiveDemo { public static void main(String[] args) throws IOException { //创建接收端的Socket对象(DatagramSocket) DatagramSocket ds = new DatagramSocket(12345); //创建一个数据包，用于接收数据 byte[] bys = new byte[1024]; DatagramPacket dp = new DatagramPacket(bys, bys.length); //调用DatagramSocket对象的方法接收数据 ds.receive(dp); //解析数据包，并把数据在控制台显示 System.out.println("数据是：" + new String(dp.getData(), 0, dp.getLength())); } } }
2.3UDP通信程序练习
-
案例需求
UDP发送数据：数据来自于键盘录入，直到输入的数据是886，发送数据结束
UDP接收数据：因为接收端不知道发送端什么时候停止发送，故采用死循环接收
-
代码实现
/* UDP发送数据： 数据来自于键盘录入，直到输入的数据是886，发送数据结束 */ public class Send { public static void main(String[] args) throws IOException { //1.创建DatagramSocket对象 DatagramSocket ds = new DatagramSocket(); //2.对数据进行打包 while (true) { String next = new Scanner(System.in).next(); if(next.equals("886")){ break; } byte[] bytes = next.getBytes(); InetAddress address = InetAddress.getByName("127.0.0.1"); int port = 10086; DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,port); //发送数据 ds.send(dp); } //关闭资源 ds.close(); } } /* UDP接收数据： 因为接收端不知道发送端什么时候停止发送，故采用死循环接收 */ public class Receive { public static void main(String[] args) throws IOException { //1.创建DatagramSocket对象 DatagramSocket ds = new DatagramSocket(10086); //创建数据包接收数据 byte[] bytes = new byte[1024]; DatagramPacket dp = new DatagramPacket(bytes, bytes.length); while (true) { ds.receive(dp); //接收数据 byte[] data = dp.getData(); String hostAddress = dp.getAddress().getHostAddress(); int length = dp.getLength(); String hostName = dp.getAddress().getHostName(); System.out.println("IP为："+hostAddress+"，主机名为"+hostName+"发送了：" + new String(data, 0,length)); } } }
2.4UDP三种通讯方式
-
单播
单播用于两个主机之间的端对端通信
-
组播
组播用于对一组特定的主机进行通信
-
广播
广播用于一个主机对整个局域网上所有主机上的数据通信
2.5UDP组播实现
-
实现步骤
- 发送端
- 创建发送端的Socket对象(DatagramSocket)
- 创建数据，并把数据打包(DatagramPacket)
- 调用DatagramSocket对象的方法发送数据(在单播中,这里是发给指定IP的电脑但是在组播当中,这里是发给组播地址)
- 释放资源
- 接收端
- 创建接收端Socket对象(MulticastSocket)
- 创建一个箱子,用于接收数据
- 把当前计算机绑定一个组播地址
- 将数据接收到箱子中
- 解析数据包,并打印数据
- 释放资源
- 发送端
-
代码实现
// 发送端 public class ClinetDemo { public static void main(String[] args) throws IOException { // 1. 创建发送端的Socket对象(DatagramSocket) DatagramSocket ds = new DatagramSocket(); String s = "hello 组播"; byte[] bytes = s.getBytes(); InetAddress address = InetAddress.getByName("224.0.1.0"); int port = 10000; // 2. 创建数据，并把数据打包(DatagramPacket) DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,port); // 3. 调用DatagramSocket对象的方法发送数据(在单播中,这里是发给指定IP的电脑但是在组播当中,这里是发给组播地址) ds.send(dp); // 4. 释放资源 ds.close(); } } // 接收端 public class ServerDemo { public static void main(String[] args) throws IOException { // 1. 创建接收端Socket对象(MulticastSocket) MulticastSocket ms = new MulticastSocket(10000); // 2. 创建一个箱子,用于接收数据 DatagramPacket dp = new DatagramPacket(new byte[1024],1024); // 3. 把当前计算机绑定一个组播地址,表示添加到这一组中. ms.joinGroup(InetAddress.getByName("224.0.1.0")); // 4. 将数据接收到箱子中 ms.receive(dp); // 5. 解析数据包,并打印数据 byte[] data = dp.getData(); int length = dp.getLength(); System.out.println(new String(data,0,length)); // 6. 释放资源 ms.close(); } }
2.6UDP广播实现
-
实现步骤
- 发送端
- 创建发送端Socket对象(DatagramSocket)
- 创建存储数据的箱子,将广播地址封装进去
- 发送数据
- 释放资源
- 接收端
- 创建接收端的Socket对象(DatagramSocket)
- 创建一个数据包，用于接收数据
- 调用DatagramSocket对象的方法接收数据
- 解析数据包，并把数据在控制台显示
- 关闭接收端
- 发送端
-
代码实现
// 发送端 public class ClientDemo { public static void main(String[] args) throws IOException { // 1. 创建发送端Socket对象(DatagramSocket) DatagramSocket ds = new DatagramSocket(); // 2. 创建存储数据的箱子,将广播地址封装进去 String s = "广播 hello"; byte[] bytes = s.getBytes(); InetAddress address = InetAddress.getByName("255.255.255.255"); int port = 10000; DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,port); // 3. 发送数据 ds.send(dp); // 4. 释放资源 ds.close(); } } // 接收端 public class ServerDemo { public static void main(String[] args) throws IOException { // 1. 创建接收端的Socket对象(DatagramSocket) DatagramSocket ds = new DatagramSocket(10000); // 2. 创建一个数据包，用于接收数据 DatagramPacket dp = new DatagramPacket(new byte[1024],1024); // 3. 调用DatagramSocket对象的方法接收数据 ds.receive(dp); // 4. 解析数据包，并把数据在控制台显示 byte[] data = dp.getData(); int length = dp.getLength(); System.out.println(new String(data,0,length)); // 5. 关闭接收端 ds.close(); } }
##3. TCP通信程序
3.1TCP发送数据
-
Java中的TCP通信
- Java对基于TCP协议的的网络提供了良好的封装，使用Socket对象来代表两端的通信端口，并通过Socket产生IO流来进行网络通信。
- Java为客户端提供了Socket类，为服务器端提供了ServerSocket类
-
构造方法
方法名 说明 Socket(InetAddress address,int port) 创建流套接字并将其连接到指定IP指定端口号 Socket(String host, int port) 创建流套接字并将其连接到指定主机上的指定端口号 -
相关方法
方法名 说明 InputStream getInputStream() 返回此套接字的输入流 OutputStream getOutputStream() 返回此套接字的输出流 -
示例代码
public class Client { public static void main(String[] args) throws IOException { //TCP协议，发送数据 //1.创建Socket对象 //细节：在创建对象的同时会连接服务端 // 如果连接不上，代码会报错 Socket socket = new Socket("127.0.0.1",10000); //2.可以从连接通道中获取输出流 OutputStream os = socket.getOutputStream(); //写出数据 os.write("aaa".getBytes()); //3.释放资源 os.close(); socket.close(); } }
3.2TCP接收数据
-
构造方法
方法名 说明 ServletSocket(int port) 创建绑定到指定端口的服务器套接字 -
相关方法
方法名 说明 Socket accept() 监听要连接到此的套接字并接受它 -
注意事项
- accept方法是阻塞的,作用就是等待客户端连接，因此需要先运行服务端
- 客户端创建对象并连接服务器,此时是通过三次握手协议,保证跟服务器之间的连接
- 针对客户端来讲,是往外写的,所以是输出流
针对服务器来讲,是往里读的,所以是输入流 - read方法也是阻塞的
- 客户端在关流的时候,还多了一个往服务器写结束标记的动作
- 最后一步断开连接,通过四次挥手协议保证连接终止
-
三次握手和四次挥手
-
三次握手
-
四次挥手
-
-
示例代码
public class Server { public static void main(String[] args) throws IOException { //TCP协议，接收数据 //1.创建对象ServerSocker ServerSocket ss = new ServerSocket(10000); //2.监听客户端的链接 Socket socket = ss.accept(); //3.从连接通道中获取输入流读取数据 InputStream is = socket.getInputStream(); int b; while ((b = is.read()) != -1){ System.out.println((char) b); } //4.释放资源 socket.close(); ss.close(); } }
3.3TCP程序练习（传输中文）
发送端：
public class Client {
public static void main(String[] args) throws IOException {
//TCP协议，发送数据
//1.创建Socket对象
//细节：在创建对象的同时会连接服务端
// 如果连接不上，代码会报错
Socket socket = new Socket("127.0.0.1",10000);
//2.可以从连接通道中获取输出流
OutputStream os = socket.getOutputStream();
//写出数据
os.write("你好你好".getBytes());//12字节
//3.释放资源
os.close();
socket.close();
}
}
接收端：
public class Server {
public static void main(String[] args) throws IOException {
//TCP协议，接收数据
//1.创建对象ServerSocker
ServerSocket ss = new ServerSocket(10000);
//2.监听客户端的链接
Socket socket = ss.accept();
//3.从连接通道中获取输入流读取数据
InputStream is = socket.getInputStream();
InputStreamReader isr = new InputStreamReader(is);
BufferedReader br = new BufferedReader(isr);
// BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
int b;
while ((b = br.read()) != -1){
System.out.print((char) b);
}
//4.释放资源
socket.close();
ss.close();
}
}
4. 综合练习
练习一：多发多收
需求：
客户端：多次发送数据
服务器：接收多次接收数据，并打印
代码示例：
public class Client {
public static void main(String[] args) throws IOException {
//客户端：多次发送数据
//服务器：接收多次接收数据，并打印
//1. 创建Socket对象并连接服务端
Socket socket = new Socket("127.0.0.1",10000);
//2.写出数据
Scanner sc = new Scanner(System.in);
OutputStream os = socket.getOutputStream();
while (true) {
System.out.println("请输入您要发送的信息");
String str = sc.nextLine();
if("886".equals(str)){
break;
}
os.write(str.getBytes());
}
//3.释放资源
socket.close();
}
}
public class Server {
public static void main(String[] args) throws IOException {
//客户端：多次发送数据
//服务器：接收多次接收数据，并打印
//1.创建对象绑定10000端口
ServerSocket ss = new ServerSocket(10000);
//2.等待客户端来连接
Socket socket = ss.accept();
//3.读取数据
InputStreamReader isr = new InputStreamReader(socket.getInputStream());
int b;
while ((b = isr.read()) != -1){
System.out.print((char)b);
}
//4.释放资源
socket.close();
ss.close();
}
}
练习二：接收并反馈
-
案例需求
客户端：发送数据，接受服务器反馈
服务器：收到消息后给出反馈
-
案例分析
- 客户端创建对象，使用输出流输出数据
- 服务端创建对象，使用输入流接受数据
- 服务端使用输出流给出反馈数据
- 客户端使用输入流接受反馈数据
-
代码实现
public class Client { public static void main(String[] args) throws IOException { //1. 创建Socket对象 Socket socket = new Socket("127.0.0.1",12306); //2.获取输出流对象 OutputStream outputStream = socket.getOutputStream(); outputStream.write("你好呀！".getBytes()); //3.写出一个结束标记 socket.shutdownOutput(); //4.接受回写的数据 InputStream inputStream = socket.getInputStream(); InputStreamReader inputStreamReader = new InputStreamReader(inputStream); int b; while ((b=inputStreamReader.read())!=-1){ System.out.print((char)b); } //4.关闭资源 socket.close(); } }public class Server { public static void main(String[] args) throws IOException { //1.创建对象绑定窗口 ServerSocket serverSocket = new ServerSocket(12306); //2.等待客户端连接 Socket socket = serverSocket.accept(); //3.获取输入流 InputStream inputStream = socket.getInputStream(); InputStreamReader inputStreamReader = new InputStreamReader(inputStream); int b; //细节: //read方法会从连接通道中读取数据 //但是，需要有一个结束标记，此处的循环才会停止 //否则，程序就会一直停在read方法这里，等待读取下面的数据 while ((b=inputStreamReader.read())!=-1){ System.out.print((char)b); } //4.回写数据 OutputStream outputStream = socket.getOutputStream(); outputStream.write("你也好呀！".getBytes()); //5.释放资源 socket.close(); serverSocket.close(); } }细节：
read方法会从连接通道中读取数据
但是，需要有一个结束标记，此处的循环才会停止
否则，程序就会一直停在read方法这里，等待读取下面的数据
练习三：上传练习（TCP协议）
-
相关方法
方法名 说明 void shutdownInput() 将此套接字的输入流放置在“流的末尾” void shutdownOutput() 禁止用此套接字的输出流 -
代码实现
public class Client { public static void main(String[] args) throws IOException { //1. 创建Socket对象 Socket socket = new Socket("127.0.0.1",12306); //2.读取本地文件中的数据，将文件输入流转换为缓冲输入流 BufferedInputStream bis = new BufferedInputStream(new FileInputStream("aaa.txt")); //3.获取输出流，把输出流转换为缓冲输出流 BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream()); //4.读取本地文件，将其传递给服务器 byte[] bytes = new byte[1024]; int len; while ((len=bis.read(bytes))!=-1){ bos.write(bytes,0,len); } bos.flush(); //5.结束标记 socket.shutdownOutput(); //6.接受服务器回写数据 BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream())); System.out.println(bufferedReader.readLine()); //7.释放资源 bis.close(); socket.close(); } }public class Server { public static void main(String[] args) throws IOException { //1.创建ServerSocket对象 ServerSocket serverSocket = new ServerSocket(12306); //2.等待客户端连接 Socket socket = serverSocket.accept(); //3.获取输入流并转换为缓存输入流 BufferedInputStream bis = new BufferedInputStream(socket.getInputStream()); //4.获取文件输出流，并转换为缓存输出流 BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("bbb.txt")); //5.保存文件 int len; byte[] bytes = new byte[1024]; while ((len=bis.read(bytes))!=-1){ System.out.println(Arrays.toString(bytes)); bos.write(bytes,0,len); } //6.关闭文件输出流 bos.close(); //7.回写数据 BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream())); bufferedWriter.write("上传成功！"); bufferedWriter.newLine(); bufferedWriter.flush(); //8.释放资源 socket.close(); serverSocket.close(); } }
练习四：文件名重复
public class UUIDTest {
public static void main(String[] args) {
String str = UUID.randomUUID().toString().replace("-", "");
System.out.println(str);//9f15b8c356c54f55bfcb0ee3023fce8a
}
}
练习五：服务器改写为多线程
服务器只能处理一个客户端请求，接收完一个图片之后，服务器就关闭了。
优化方案一：
使用循环
弊端：
第一个用户正在上传数据，第二个用户就来访问了，此时第二个用户是无法成功上传的。
所以，使用多线程改进
优化方案二：
每来一个用户，就开启多线程处理
public class Client {
public static void main(String[] args) throws IOException {
//1. 创建Socket对象
Socket socket = new Socket("127.0.0.1",12306);
//2.读取本地文件中的数据，将文件输入流转换为缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("aaa.txt"));
//3.获取输出流，把输出流转换为缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
//4.读取本地文件，将其传递给服务器
byte[] bytes = new byte[1024];
int len;
while ((len=bis.read(bytes))!=-1){
bos.write(bytes,0,len);
}
bos.flush();
//5.结束标记
socket.shutdownOutput();
//6.接受服务器回写数据
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
System.out.println(bufferedReader.readLine());
//7.释放资源
bis.close();
socket.close();
}
}
import java.io.*;
import java.net.Socket;
import java.util.UUID;
public class MyRunnable implements Runnable{
Socket socket;
public MyRunnable(Socket socket){
this.socket=socket;
}
@Override
public void run() {
try {
//3.获取输入流并转换为缓存输入流
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
//4.获取文件输出流，并转换为缓存输出流
String name = UUID.randomUUID().toString().replace("-", "");
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(name+".txt"));
//5.保存文件
int len;
byte[] bytes = new byte[1024];
while ((len=bis.read(bytes))!=-1){
bos.write(bytes,0,len);
}
//6.关闭文件输出流
bos.close();
//7.回写数据
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
bufferedWriter.write("上传成功！");
bufferedWriter.newLine();
bufferedWriter.flush();
//8.释放资源
socket.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
public class Server {
public static void main(String[] args) throws IOException {
//1.创建ServerSocket对象
ServerSocket serverSocket = new ServerSocket(12306);
while (true) {
//2.等待客户端连接
Socket socket = serverSocket.accept();
//开启一个线程，一个用户对应服务端一条线程
new Thread(new MyRunnable(socket)).start();
}
}
}
练习六：线程池改进
public class Client {
public static void main(String[] args) throws IOException {
//1. 创建Socket对象
Socket socket = new Socket("127.0.0.1",12306);
//2.读取本地文件中的数据，将文件输入流转换为缓冲输入流
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("aaa.txt"));
//3.获取输出流，把输出流转换为缓冲输出流
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
//4.读取本地文件，将其传递给服务器
byte[] bytes = new byte[1024];
int len;
while ((len=bis.read(bytes))!=-1){
bos.write(bytes,0,len);
}
bos.flush();
//5.结束标记
socket.shutdownOutput();
//6.接受服务器回写数据
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(socket.getInputStream()));
System.out.println(bufferedReader.readLine());
//7.释放资源
bis.close();
socket.close();
}
}
public class MyRunnable implements Runnable{
Socket socket;
public MyRunnable(Socket socket){
this.socket=socket;
}
@Override
public void run() {
try {
//3.获取输入流并转换为缓存输入流
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
//4.获取文件输出流，并转换为缓存输出流
String name = UUID.randomUUID().toString().replace("-", "");
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(name+".txt"));
//5.保存文件
int len;
byte[] bytes = new byte[1024];
while ((len=bis.read(bytes))!=-1){
bos.write(bytes,0,len);
}
//6.关闭文件输出流
bos.close();
//7.回写数据
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
bufferedWriter.write("上传成功！");
bufferedWriter.newLine();
bufferedWriter.flush();
//8.释放资源
socket.close();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
public class Server {
public static void main(String[] args) throws IOException {
//创建线程池
ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(
3,//核心线程数量
32,//最大线程数量
60,//最大存活时间
TimeUnit.SECONDS,//单位
new ArrayBlockingQueue<>(2),//阻塞队列
Executors.defaultThreadFactory(),//线程工厂
new ThreadPoolExecutor.AbortPolicy()//任务拒绝策略
);
//1.创建ServerSocket对象
ServerSocket serverSocket = new ServerSocket(12306);
while (true) {
//2.等待客户端连接
Socket socket = serverSocket.accept();
threadPoolExecutor.submit(new MyRunnable(socket));
}
}
}
368
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
