Java-网络编程
前言
哈喽！大家好，我是小简。今天开始学习《Java-网络编程》，此系列是我做的一个 “Java 从 0 到 1 ” 实验，给自己一年左右时间，按照我自己总结的 Java-学习路线，从 0 开始学 Java 知识，并不定期更新所学笔记，期待一年后的蜕变吧！
网络基础
简介
- 网络：两台或多台设备通过一定物理设备连接起来构成了网络
- 网络通信：将数据通过网络从一台设备传输到另一台设备
- 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("客户端退出...");
}
}本文参与 腾讯云自媒体分享计划，分享自作者个人站点/博客。
原始发表：2022-03-04，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读
目录