Java-网络编程（TCP-UDP）
Java-网络编程（TCP-UDP）
网络基础
- 网络编程最主要的工作就是在发送端把信息通过规定好的协议进行组装包，在接收端按照规定好的协议把包进行解析，从而提取出对应的信息，达到通信的目的。中间最主要的就是数据包的组装，数据包的过滤，数据包的捕获，数据包的分析，当然最后再做一些处理，代码、开发工具、数据库、服务器架设和网页设计这5部分你都要接触
简介
- 网络：两台或多台设备通过一定物理设备连接起来构成了网络
- 网络通信：将数据通过网络从一台设备传输到另一台设备
- TCP协议: 传输控制协议
- 1.使用TCP协议前，须先建立TCP连接，形成传输数据通道
- 2.传输前，采用”三次握手”方式，是可靠的
- 3.TCP协议进行通信的两个应用进程:客户端、服务端
- 4.在连接中可进行大数据量的传输
- 5.传输完毕，需释放已建立的连接，效率低
- UDP协议: 用户数据协议
- 1.将数据、源、目的封装成数据包，不需要建立连接
- 2.因无需连接，故是不可靠的
- 2.每个数据报的大小限制在64K内，不适合传输大量数据
- 4.发送数据结束时无需释放资源(因为不是面向连接的)，速度快
Java提供的网络功能类
- InetAddress： 用于标识网络上的硬件资源
- Socket和ServerSocket： 使用TCP协议实现网络通信的 Socket 相关的类
- Datagram： 使用UDP协议，将数据保存在数据报中，通过网络进行通信
InetAddress
- getLocalHost() 获取本机 InetAddress 对象
- getByName() 根据指定主机名/域名获取 ip 地址对象
- getHostName() 获取 InetAddress 对象的主机名
- getHostAddress() 获取 InetAddress 对象的地址
package com.jwt.network;
import java.net.InetAddress;
import java.net.UnknownHostException;
public class InetAddress_ {
public static void main(String[] args) throws UnknownHostException {
//获取本机InetAddress 对象
InetAddress localHost = InetAddress.getLocalHost();
System.out.println(localHost);
//根据指定主机名/域名获取对象
InetAddress host2 = InetAddress.getByName("jianjian");
System.out.println(host2);
InetAddress host3 = InetAddress.getByName("www.baidu.com");
System.out.println(host3);
//获取InetAddress对象的主机名
String host3Name = host3.getHostName();
System.out.println(host3Name);
//获取InetAddress对象的地址
String host3Address = host3.getHostAddress();
System.out.println(host3Address);
}
}
/**
jianjian/192.168.50.204
jianjian/192.168.50.204
www.baidu.com/14.215.177.39
www.baidu.com
14.215.177.39
**/
Socket
简介
- 套接字(Socket)开发网络应用程序被广泛采用，以至于成为事实上的标准。
- 通信的两端都要有Socket，是两台机器间通信的端点。
- 网络通信其实就是 Socket 间的通信。
- Socket 允许程序把网络连接当成一个流，数据在两个 Socket 间通过 IO 传输。
- 一般主动发起通信的应用程序属客户端，等待通信请求的为服务端。
TCP编程
简介
- 1.基于客户端-服务端的网络通信
- 2.底层使用的是TCP/IP协议
- 3.应用场景举例:客户端发送数据，服务端接受并显示控制台
 |
 |
|---|---|
流程
TCP，传输前先开服务端，accept，等客户端接入，然后获得客户端 socket 然后进行 IO 操作
服务端编写
-
Step 1
：创建ServerSocket对象，绑定监听的端口
- ServerSocket serverSocket = new ServerSocket(Port);
-
Step 2
：调用accept()方法监听客户端的请求
- Socket socket = serverSocket.accept();
-
step 3
：连接建立后，通过输入流读取客户端发送的请求信息
- InputStream inputStream = socket.getInputStream();
-
Step 4
：通过输出流向客户端发送响应信息
- OutputStream outputStream = socket.getOutputStream();
-
Step 5
：关闭相关资源
- outputStream.close();
- inputStream.close();
- socket.close();
- serverSocket.close();
客户端编写
- Step 1：创建Socket对象，指明需要链接的服务器的地址和端号
- Socket socket = new Socket(“server address”, port);
- Step 2：链接建立后，通过输出流向服务器发送请求信息
- OutputStream outputStream = socket.getOutputStream();
- Step 3：通过输入流获取服务器响应的信息
- InputStream inputStream = socket.getInputStream();
- Step 4：关闭相关资源
- inputStream.close();
- outputStream.close();
- socket.close();
例子1:使用字节流通信
- 1.编写一个服务器端和一个客户端
- 2.服务器端监听 9999 端口
- 3.客户端连接到服务器端， 发送”你好，服务端！”，并接收服务器端回发的”你好，客户端！”，再退出
- 4.服务器端接收到客户端发送的信息，输出，并发送”你好，客户端！”, 再退出
服务端
package com.jwt.socket;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
public class SocketTCP01Server {
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. 通过输入流，读取客户端写入到数据通道的数据, 显示
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. 通过输出流，写入数据到数据通道
OutputStream outputStream = socket.getOutputStream();
outputStream.write("服务端说：你好，客户端！".getBytes());
// 设置结束标记
socket.shutdownOutput();
//6.关闭流和socket
outputStream.close();
inputStream.close();
socket.close();
serverSocket.close();
System.out.println("服务端退出.....");
}
}
客户端
package com.jwt.socket;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
public class SocketTCP01Client {
public static void main(String[] args) throws IOException {
//1. 连接服务端(ip , 端口）如果连接成功，返回Socket 对象
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端socket返回=" + socket.getClass());
//2. 连接上后，生成Socket, 通过socket.getOutputStream()
OutputStream outputStream = socket.getOutputStream();
//3. 通过输出流，写入数据到数据通道
outputStream.write("客户端说：你好，服务端!".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("客户端退出.....");
}
}
例子2:使用字符流通信
- 1.编写一个服务端和一个客户端
- 2.服务端在9999端口监听
- 3.客户端连接到服务端，发送”你好，服务端！”，并接收服务端回发的”你好，客户端！”，再退出
- 4.服务端接收到客户端发送的信息，输出，并发送”你好，客户端！”，再退出
服务端
package com.jwt.socket;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
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 读取, 使用字符流, 使用InputStreamReader 将inputStream 转成字符流
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String s = bufferedReader.readLine();
System.out.println(s);
//5. 通过输出流，写入数据到数据通道
OutputStream outputStream = socket.getOutputStream();
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
bufferedWriter.write("服务端说：你好，客户端！");
// 设置结束标记
bufferedWriter.newLine();// 插入一个换行符，表示回复内容的结束
bufferedWriter.flush();//注意需要手动的flush
//6.关闭流和socket
bufferedWriter.close();
bufferedReader.close();
socket.close();
serverSocket.close();
System.out.println("服务端退出.....");
}
}
客户端
package com.jwt.socket;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
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 读取, 使用字符流, 使用InputStreamReader 将inputStream 转成字符流
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String s = bufferedReader.readLine();
System.out.println(s);
//5. 通过输出流，写入数据到数据通道
OutputStream outputStream = socket.getOutputStream();
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
bufferedWriter.write("服务端说：你好，客户端！");
// 设置结束标记
bufferedWriter.newLine();// 插入一个换行符，表示回复内容的结束
bufferedWriter.flush();//注意需要手动的flush
//6.关闭流和socket
bufferedWriter.close();
bufferedReader.close();
socket.close();
serverSocket.close();
System.out.println("服务端退出.....");
}
}
例子3:文件传输
- 1.编写一个服务端和一个客户端
- 2.服务器端在 8888 端口监听
- 3.客户端连接到服务端，发送一张图片 /Users/jianjian/Downloads/a.jpeg
- 4.服务器端接收到客户端发送的图片，保存到 src 下，发送”收到图片”再退出
- 5.客户端接收到服务端发送的”收到图片”，再退出
- 6.该程序要求使用 StreamUtils.java，我们直接使用
服务端
package com.jwt.socket;
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 得到输入流
System.out.println("服务端开始接收图片");
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
byte[] bytes = StreamUtils.streamToByteArray(bis);
//4. 将得到bytes 数组，写入到指定的路径，就得到一个文件了
String destFilePath = "src//a.jpeg";
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
bos.write(bytes);
bos.flush();
System.out.println("服务端接收图片成功");
//5.向客户端回复"收到图片"通过socket 获取到输出流(字符)
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
bw.write("服务端：收到图片");
bw.flush();//把内容刷新到数据通道
socket.shutdownOutput();//设置写入结束标记
//6.关闭其他资源
bw.close();
bos.close();
bis.close();
socket.close();
serverSocket.close();
System.out.println("服务端退出.....");
}
}
/**
服务端监听8888端口....
服务端开始接收图片
服务端接收图片成功
服务端退出.....
**/
客户端
package com.jwt.socket;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
public class TCPFileUploadClient {
public static void main(String[] args) throws Exception {
//1.客户端连接服务端8888，得到Socket 对象
Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
//2.创建读取磁盘文件的输入流
System.out.println("客户端开始发送图片");
String filePath = "/Users/jianjian/Downloads/a.jpeg";
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
//bytes 就是filePath 对应的字节数组
byte[] bytes = StreamUtils.streamToByteArray(bis);
//3.通过socket 获取到输出流, 将bytes 数据发送给服务端
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
bos.write(bytes);
bos.flush();
socket.shutdownOutput();//设置写入数据的结束标记
System.out.println("客户端发送图片成功");
//4.接收从服务端回复的消息
InputStream inputStream = socket.getInputStream();
//使用StreamUtils 的方法，直接将inputStream 读取到的内容转成字符串
String s = StreamUtils.streamToString(inputStream);
System.out.println(s);
//5.关闭相关的流
inputStream.close();
bos.close();
bis.close();
socket.close();
System.out.println("客户端退出.....");
}
}
/**
客户端开始发送图片
客户端发送图片成功
服务端：收到图片
客户端退出.....
**/
UDP编程
简介
- 类 DatagramSocket 和 DatagramPacket [数据包/数据报]实现了基于 UDP 协议网络程序。
- UDP 数据报通过数据报套接字 DatagramSocket 发送和接收，系统不保证 UDP 数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。
- DatagramPacket 对象封装了 UDP 数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号。
- UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接
流程
UDP，以数据报作为数据的传输载体，在进行传输时首先要把传输的数据定义成数据报(Datagram)，在数据报中指明数据要到达的Socket(主机地址和端口号)，然后再将数据以数据报的形式发送出去，然后就没有然后了，服务端收不收到我就不知道了，除非服务端收到后又给我回一段确认的数据报。
接收端编写
- Step 1：创建DatagramSocket，指定端口号
- DatagramSocket socket = new DatagramSocket(9999);
- Step 2：创建DatagramPacket
- DatagramPacket packet = new DatagramPacket(buf,buf.length);
- Step 3：接收发送端发送的数据信息
- socket.receive(packet);
- Step 4：读取数据
- packet.getLength();
- packet.getData();
- Step 5：关闭相关资源
- socket.close();
发送端编写
- Step 1：定义发送信息
- byte[] data = “发送端：hello 明天吃火锅~”.getBytes();
- Step 2：创建DatagramPacket，包含将要发送的信息
- DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName(“jianjian”), 9999);
- Step 3：创建DatagramSocket
- DatagramSocket socket = new DatagramSocket(9998);
- Step 4：发送数据
- socket.send(packet);
- Step 5：关闭相关资源
- socket.close();
例子：接受端发送端通信
- 1.编写一个接收端 A 和一个发送端 B
- 2.接收端 A 在 9999 端口等待接收数据
- 3.发送端 B 向接收端 A 发送数据”hello ,明天吃火锅~”
- 4.接收端 A 接收到发送端 B 发送的数据，回复”好的，明天见”，再退出
- 5.发送端接收回复的数据，再退出
接受端
package com.jwt.socket;
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);
System.out.println("接收端A等待接收数据..");
//3. 调用接收方法, 将通过网络传输的DatagramPacket 对象,填充到packet 对象
//当有数据包发送到本机的9999 端口时，就会接收到数据
// 如果没有数据包发送到本机的9999 端口, 就会阻塞等待.
socket.receive(packet);
//4. 把packet进行拆包，取出数据，并显示
int length = packet.getLength();
byte[] data = packet.getData();
String s = new String(data, 0, length);
System.out.println(s);
//5. 回复信息给B端,将需要发送的数据，封装到DatagramPacket 对象
data = "接收端：好的, 明天见".getBytes();
//内容字节数组, 数组长度,主机(IP),端口
packet = new DatagramPacket(data, data.length, InetAddress.getByName("jianjian"), 9998);
socket.send(packet);
//6. 关闭资源
socket.close();
System.out.println("A 端退出...");
}
}
/**
接收端A等待接收数据..
发送端：hello 明天吃火锅~
A 端退出...
**/
发送端
package com.jwt.socket;
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 packet = new DatagramPacket(data, data.length, InetAddress.getByName("jianjian"), 9999);
socket.send(packet);
//3. 接收从A 端回复的信息
//(1).构建一个DatagramPacket 对象，准备接收数据
byte[] buf = new byte[1024];
packet = new DatagramPacket(buf, buf.length);
//(2) 调用接收方法, 将通过网络传输的DatagramPacket 对象,填充到packet 对象
socket.receive(packet);
//(3) 可以把packet 进行拆包，取出数据，并显示.
int length = packet.getLength();//实际接收到的数据字节长度
data = packet.getData();//接收到数据
String s = new String(data, 0, length);
System.out.println(s);
//4. 关闭资源
socket.close();
System.out.println("B 端退出");
}
}
/**
接收端：好的, 明天见
B 端退出
**/
本章练习
1.编程题Homework01.java
- (1)使用字符流的方式，编写一个客户端程序和服务器端程序
- (2)客户端发送”name”,服务器端接收到后，返回”我是nova”，nova 是你自己的名字
- (3)客户端发送”hobby”,服务器端接收到后，返回”编写java程序”
- (4)不是这两个问题，回复”你说啥呢”
- 问题:目前，我们只能问一次，就退出了，怎么可以问多次? ->while ->聊天
服务端
package com.jwt.socket.homework;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class Homework01Server {
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("我是服务端，正在监听9999端口，等待连接...");
Socket socket = serverSocket.accept();
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String s = br.readLine();
System.out.println(s);
String answer = "";
if ("name".equals(s)) {
answer = "我是nova";
} else if("hobby".equals(s)) {
answer = "编写java程序";
} else {
answer = "你说啥呢";
}
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
bw.write(answer);
bw.flush();
socket.shutdownOutput();
bw.close();
br.close();
socket.close();
serverSocket.close();
System.out.println("服务端退出.....");
}
}
客户端
package com.jwt.socket.homework;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;
public class Homework01Client {
public static void main(String[] args) throws IOException {
Socket socket = new Socket(InetAddress.getByName("jianjian"),9999);
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
//从键盘读取用户的问题
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的问题:");
String question = scanner.next();
bw.write(question);
bw.flush();
socket.shutdownOutput();
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String s = br.readLine();
System.out.println(s);
br.close();
bw.close();
socket.close();
System.out.println("客户端退出.....");
}
}
2.编程题Homework02.java
- (1)编写一个接收端A和一个发送端B,使用UDP协议完成
- (2)接收端在8888端口等待接收数据
- (3)发送端向接收端发送数据”四大名著是哪些”
- (4)接收端接收到发送端发送的问题后，返回”四大名著是<<红楼梦>> ..”，否则返回what?
- (5)接收端和发送端程序退出
接受端
package com.jwt.socket.homework;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
public class Homework02ReceiverA {
//- (1)编写一个接收端A和一个发送端B,使用UDP协议完成
//- (2)接收端在8888端口等待接收数据
//- (3)发送端向接收端发送数据"四大名著是哪些"
//- (4)接收端接收到发送端发送的问题后，返回"四大名著是<<红楼梦>> ..”，否则返回what?
//- (5)接收端和发送端程序退出
public static void main(String[] args) throws IOException {
DatagramSocket socket = new DatagramSocket(8888);
byte[] buf = new byte[1024];
DatagramPacket packet = new DatagramPacket(buf,0,buf.length);
System.out.println("接收端A等待接收数据..");
socket.receive(packet);
int length = packet.getLength();
byte[] data = packet.getData();
String s = new String(data,0,length);
System.out.println(s);
String anser = "";
if("四大名著是哪些".equals(s)){
anser = "四大名著是<<红楼梦>>...";
} else {
anser = "What?";
}
buf = anser.getBytes();
packet = new DatagramPacket(buf, buf.length, InetAddress.getByName("jianjian"), 9999);
socket.send(packet);
socket.close();
System.out.println("A 端退出");
}
}
发送端
package com.jwt.socket.homework;
import java.io.IOException;
import java.net.*;
import java.util.Scanner;
public class Homework02SenderB {
//- (1)编写一个接收端A和一个发送端B,使用UDP协议完成
//- (2)接收端在8888端口等待接收数据
//- (3)发送端向接收端发送数据"四大名著是哪些"
//- (4)接收端接收到发送端发送的问题后，返回"四大名著是<<红楼梦>> ..”，否则返回what?
//- (5)接收端和发送端程序退出
public static void main(String[] args) throws IOException {
DatagramSocket socket = new DatagramSocket(9999);
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("jianjian"), 8888);
socket.send(packet);
buf = new byte[1024];
packet = new DatagramPacket(buf, buf.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("B 端退出");
}
}
3.编程题Homework03.java
- (1)编写客户端程序和服务器端程序
- (2)客户端可以输入一个音乐文件名，比如高山流水，服务端收到音乐名后，可以给客户端返回这个音乐文件，如果服务器没有这个文件，返回一个默认的音乐即可
- (3)客户端收到文件后，保存到本地
- (4)提示:该程序可以使用StreamUtils.java
- 本质:其实就是指定下载文件的应用先自己结合老师讲的文件上传来做
服务端
package com.jwt.socket.homework;
import com.jwt.socket.StreamUtils;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
public class Homework03Server {
public static void main(String[] args) throws Exception {
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务端监听9999端口....");
Socket socket = serverSocket.accept();
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String s = br.readLine();
System.out.println(s);
//发送音乐
System.out.println("服务端开始发送音乐");
String music = "";
if ("高山流水".equals(s)){
music = "高山流水.mp3";
} else {
music = "无名.mp3";
}
String filePath = "src//" + music;
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
byte[] bytes = StreamUtils.streamToByteArray(bis);
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
bos.write(bytes);
bos.flush();
socket.shutdownOutput();//设置写入数据的结束标记
System.out.println("客户端发送音乐成功");
bos.close();
bis.close();
socket.close();
serverSocket.close();
System.out.println("服务端退出...");
}
}
客户端
package com.jwt.socket.homework;
import com.jwt.socket.StreamUtils;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;
public class Homework03Client {
public static void main(String[] args) throws Exception {
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
Scanner scanner = new Scanner(System.in);
System.out.println("输入音乐名：");
String downMusic = scanner.next();
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
bw.write(downMusic);
bw.flush();
socket.shutdownOutput();
//读取客户端发送的数据,通过Socket 得到输入流
System.out.println("客户端开始接收音乐");
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
byte[] bytes = StreamUtils.streamToByteArray(bis);
// 将得到bytes 数组，写入到指定的路径，就得到一个文件了
String destFilePath = "/Users/jianjian/Downloads/" + downMusic + ".mp3";
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
bos.write(bytes);
bos.flush();
System.out.println("客户端接收音乐成功");
bos.close();
bis.close();
bw.close();
socket.close();
System.out.println("客户端退出...");
}
}
