JavaStudy10(21章-网络编程)—B站hsp
1.1网络的相关概念
1.1.1网络通信
1.1.2 网络
1.1.3 ip 地址
画图解释：
1.1.4 ipv4 地址分类
1.1.5 域名
1.1.6 网络通信协议
1.1.7 网络通信协议****
1.1.8 TCP 和 UDP
举例子
1.2 InetAddress 类
1.2.1 相关方法
1.2.2 应用案例 API_.java
/**
* @ClassName API
* @Author ：BLWY-1124
* @Date ：2022/4/25 7:51
* @Description： 编写代码，获取计算机的主机名和 IP 地址相关 API
* @Version: 1.0
*/
public class API {
public static void main(String[] args) throws UnknownHostException {
//1.获取本机 InetAddress 对象 getLocalHost
InetAddress localHost = InetAddress.getLocalHost();
System.out.println(localHost); //DESKTOP-KCMN6AE/192.168.125.3
//2.根据指定主机名/域名获取 ip 地址对象 getByName
InetAddress localHost1 = InetAddress.getByName("DESKTOP-KCMN6AE");
System.out.println("localHost1:" + localHost1); //DESKTOP-KCMN6AE/192.168.125.3
//3.根据域名返回 InetAddress 对象,比如www.baidu.com 对应
InetAddress localHost2 = InetAddress.getByName("www.baidu.com");
System.out.println("localHost2:" + localHost2); //localHost2:www.baidu.com/14.215.177.38
//4.通过InetAddress对象，获取对应的地址
String hostAddress = localHost2.getHostAddress();
System.out.println("hostAddress:" + hostAddress); //hostAddress:14.215.177.38
//5.通过InetAddress对象，获取对应的主机名/或者的域名
String hostName = localHost2.getHostName();
System.out.println("hostName:" + hostName); //hostName:www.baidu.com
}
}
1.3 Socket
1.3.1 基本介绍
示意图：
1.4 TCP 网络通信编程
1.4.1 基本介绍
1.4.2 应用案例 1(使用字节流)
/**
* @ClassName SocketTCP01Client
* @Author ：BLWY-1124
* @Date ：2022/4/25 9:51
* @Description： 客户端
* 发送"hello,server" 给服务器
* @Version: 1.0
*/
public class SocketTCP01Client {
public static void main(String[] args) throws IOException {
//思路
// 1. 连接服务端 (ip , 端口）
// 解读: 连接本机的 9999 端口, 如果连接成功，返回 Socket 对象
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端 socket 返回=" + socket.getClass());
//2. 连接上后，生成 Socket, 通过 socket.getOutputStream()
// 得到 和 socket 对象关联的输出流对象
OutputStream outputStream = socket.getOutputStream();
//3. 通过输出流，写入数据到 数据通道
outputStream.write("hello,server".getBytes());
//4. 关闭流对象和 socket, 必须关闭
outputStream.close();
socket.close();
System.out.println("客户端退出");
}
}
/**
* @ClassName SocketTCP01Server
* @Author ：BLWY-1124
* @Date ：2022/4/25 9:50
* @Description： 服务端
* @Version: 1.0
*/
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. 通过 socket.getInputStream() 读取客户端写入到数据通道的数据, 显示
InputStream inputStream = socket.getInputStream();
//4. IO 读取
byte[] buf = new byte[1024];
int readLine = 0;
while ((readLine = inputStream.read(buf)) != -1){
System.out.println(new String(buf,0,readLine));//根据读取到的实际长度，显示内容
}
//5.关闭流和 socket
inputStream.close();
socket.close();
serverSocket.close();//关闭
}
}
1.4.3 应用案例 2(使用字节流) SocketTCP02.java
代码演示：
/**
* @ClassName SocketTCP01Server
* @Author ：BLWY-1124
* @Date ：2022/4/25 9:50
* @Description： 服务端
* @Version: 1.0
*/
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 读取
byte[] buf = new byte[1024];
int readLine = 0;
while ((readLine = inputStream.read(buf)) != -1){
System.out.println(new String(buf,0,readLine));//根据读取到的实际长度，显示内容
}
//5. 获取 socket 相关联的输出流
OutputStream outputStream = socket.getOutputStream();
outputStream.write("hello,Cilent".getBytes());
//设置结束标记
socket.shutdownInput();
//6.关闭流和 socket
inputStream.close();
socket.close();
serverSocket.close();//关闭
outputStream.close();
}
}
/**
* @ClassName SocketTCP01Client
* @Author ：BLWY-1124
* @Date ：2022/4/25 9:51
* @Description： 客户端
* 发送"hello,server" 给服务器
* @Version: 1.0
*/
public class SocketTCP02Client {
public static void main(String[] args) throws IOException {
//思路
// 1. 连接服务端 (ip , 端口）
// 解读: 连接本机的 9999 端口, 如果连接成功，返回 Socket 对象
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端 socket 返回=" + socket.getClass());
//2. 连接上后，生成 Socket, 通过 socket.getOutputStream()
// 得到 和 socket 对象关联的输出流对象
OutputStream outputStream = socket.getOutputStream();
//3. 通过输出流，写入数据到 数据通道
outputStream.write("hello,server".getBytes());
//设置结束标记
socket.shutdownOutput();
//4.获取和 socket 关联的输入流. 读取数据(字节)，并显示
InputStream inputStream = socket.getInputStream();
byte[] buf = new byte[1024];
int readLine = 0;
while ((readLine = inputStream.read(buf)) != -1){
System.out.println(new String(buf,0,readLine));
}
//5. 关闭流对象和 socket, 必须关闭
outputStream.close();
socket.close();
inputStream.close();
System.out.println("客户端退出");
}
}
1.4.4 应用案例 3(使用字符流)
代码演示：
/**
* @ClassName SocketTCP01Client
* @Author ：BLWY-1124
* @Date ：2022/4/25 9:51
* @Description： 客户端
* 发送"hello,server" 给服务器
* @Version: 1.0
*/
public class SocketTCP03Client {
public static void main(String[] args) throws IOException {
//思路
// 1. 连接服务端 (ip , 端口）
// 解读: 连接本机的 9999 端口, 如果连接成功，返回 Socket 对象
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端 socket 返回=" + socket.getClass());
//2. 连接上后，生成 Socket, 通过 socket.getOutputStream()
// 得到 和 socket 对象关联的输出流对象
OutputStream outputStream = socket.getOutputStream();
//3. 通过输出流，写入数据到 数据通道
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
bufferedWriter.write("hello,server 字符流");
bufferedWriter.newLine(); //插入一个换行符，表示写入的内容结束, 注意，要求对方使用 readLine()!!!!
bufferedWriter.flush(); // 如果使用的字符流，需要手动刷新，否则数据不会写入数据通道
//设置结束标记
socket.shutdownOutput();
//4.获取和 socket 关联的输入流. 读取数据(字符)，并显示
InputStream inputStream = socket.getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String s = bufferedReader.readLine();
System.out.println(s); //输出
//5. 关闭流对象和 socket, 必须关闭
bufferedReader.close(); // 关闭外层
bufferedWriter.close();
socket.close();
System.out.println("客户端退出");
}
}
/**
* @ClassName SocketTCP01Server
* @Author ：BLWY-1124
* @Date ：2022/4/25 9:50
* @Description： 服务端 使用字符流方式读写
* @Version: 1.0
*/
public class SocketTCP03Server {
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. 获取 socket 相关联的输出流
OutputStream outputStream = socket.getOutputStream();
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
bufferedWriter.write("hello,Cilent 字符流");
bufferedWriter.newLine(); 插入一个换行符，表示写入的内容结束, 注意，要求对方使用 readLine()!!!!
bufferedWriter.flush(); // 如果使用的字符流，需要手动刷新，否则数据不会写入数据通道
//设置结束标记
socket.shutdownInput();
//6.关闭流和 socket
bufferedReader.close(); //关闭外层
bufferedWriter.close();
socket.close();
serverSocket.close();//关闭
}
}
1.4.5 应用案例 4 TCPFileUploadServer.java TCPFileUploadClient.java
代码演示：
/**
* 此类用于演示关于流的读写方法
*
*/
public class StreamUtils {
/**
* 功能：将输入流转换成byte[]， 即可以把文件的内容读入到byte[]
* @param is
* @return
* @throws Exception
*/
public static byte[] streamToByteArray(InputStream is) throws Exception{
ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
byte[] b = new byte[1024];//字节数组
int len;
while((len=is.read(b))!=-1){//循环读取
bos.write(b, 0, len);//把读取到的数据，写入bos
}
byte[] array = bos.toByteArray();//然后将bos 转成字节数组
bos.close();
return array;
}
/**
* 功能：将InputStream转换成String
* @param is
* @return
* @throws Exception
*/
public static String streamToString(InputStream is) throws Exception{
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
StringBuilder builder= new StringBuilder();
String line;
while((line=reader.readLine())!=null){
builder.append(line+"\r\n");
}
return builder.toString();
}
}
/**
* @ClassName TCPFileUploadClient
* @Author ：BLWY-1124
* @Date ：2022/4/25 15:57
* @Description： 文件上传的客户端
* @Version: 1.0
*/
public class TCPFileUploadClient {
public static void main(String[] args) throws Exception {
//客户端连接服务端 8888，得到Socket对象
Socket socket = new Socket(InetAddress.getLocalHost(),8888);
//创建读取磁盘文件的输入流
String filePath = "e:\\mg.png";
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
//bytes 就是filePath对应的字节数组
byte[] bytes = StreamUtils.streamToByteArray(bis);
//通过socket获取到输出流, 将bytes数据发送给服务端
OutputStream outputStream = socket.getOutputStream();
BufferedOutputStream bos = new BufferedOutputStream(outputStream); //获得服务器端输出流
bos.write(bytes);//将文件对应的字节数组的内容，写入到数据通道
bis.close();
socket.shutdownOutput();//设置写入数据的结束标记
//=====接收从服务端回复的消息=====
InputStream inputStream = socket.getInputStream();
//使用StreamUtils 的方法，直接将 inputStream 读取到的内容 转成字符串
String s = StreamUtils.streamToString(inputStream);
System.out.println(s);
//关闭相关的流
socket.close();
bos.close();
inputStream.close();
}
}
/**
* @ClassName TCPFileUploadServer
* @Author ：BLWY-1124
* @Date ：2022/4/25 15:57
* @Description： 文件上传的服务端
* @Version: 1.0
*/
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得到输入流
InputStream inputStream = socket.getInputStream();
BufferedInputStream bis = new BufferedInputStream(inputStream);
byte[] bytes = StreamUtils.streamToByteArray(bis);
//4. 将得到 bytes 数组，写入到指定的路径，就得到一个文件了
String destFilePath = "e:\\mg1.png";
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
bos.write(bytes);
bos.close();
//向客户端回复 "收到图片"
// 通过socket 获取到输出流(字符)
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
bw.write("收到图片");
bw.flush();//把内容刷新到数据通道
socket.shutdownOutput();//设置写入结束标记
//关闭其他资源
bw.newLine();
socket.close();
serverSocket.close();
bis.close();
}
}
1.4.6 netstat 指令
1.4.7 TCP 网络通讯不为人知的秘密
1.5 UDP 网络通信编程[了解]
1.5.1 基本介绍
1.5.2 基本流程
1.5.3 应用案例
代码演示：
/**
* @ClassName UDPReceiverA
* @Author ：BLWY-1124
* @Date ：2022/4/26 9:05
* @Description： UDP接收端A
* @Version: 1.0
*/
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);
//3. 调用 接收方法, 将通过网络传输的 DatagramPacket 对象
// 填充到 packet 对象
// 老师提示: 当有数据包发送到 本机的 9999 端口时，就会接收到数据
// 如果没有数据包发送到 本机的 9999 端口, 就会阻塞等待.
System.out.println("接收端A等待接收数据..");
socket.receive(packet);
//4.可以把packet 进行拆包，并取出数据，并显示。
int length = packet.getLength(); //实际接受到的数据长度
byte[] data = packet.getData(); //接收到的数据
String s = new String(data,0,length);
System.out.println(s);
//===回复信息给 B 端
// 将需要发送的数据，封装到 DatagramPacket 对象
data = "好的，明天见".getBytes();
//说明: 封装的 DatagramPacket 对象 data 内容字节数组 , data.length , 主机(IP) , 端口
packet = new DatagramPacket(data,0,data.length,
InetAddress.getByName("192.168.173.3"),9998);
socket.send(packet); //发送
//关闭资源
socket.close();
System.out.println("A端退出..");
}
}
/**
* @ClassName UDPSenderB
* @Author ：BLWY-1124
* @Date ：2022/4/26 9:06
* @Description： UDP发送端B
* @Version: 1.0
*/
@SuppressWarnings({"all"})
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 对象 data 内容字节数组 , data.length , 主机(IP) , 端口
DatagramPacket packet = new DatagramPacket(data, 0, data.length,
InetAddress.getByName("192.168.173.3"), 9999);
socket.send(packet);
//3.=== 接收从 A 端回复的信息
//(1). 构建一个 DatagramPacket 对象，准备接收数据
// 在前面讲解 UDP 协议时，老师说过一个数据包最大64k
byte[] buf = new byte[1024];
packet = new DatagramPacket(buf, buf.length);
//(2). 调用 接收方法, 将通过网络传输的 DatagramPacket 对象
// 填充到 packet 对象
// 老师提示: 当有数据包发送到 本机的 9998 端口时，就会接收到数据
// 如果没有数据包发送到 本机的 9998 端口, 就会阻塞等待.
System.out.println("接收端A等待接收数据..");
socket.receive(packet);
//(3).可以把packet 进行拆包，并取出数据，并显示。
int length = packet.getLength();//实际接收到的数据字节长度
data = packet.getData();//接收到数据
String s = new String(data,0,length);
System.out.println(s);
}
}
1.6 本章作业
代码演示：
/**
* @ClassName SocketTCP01Client
* @Author ：BLWY-1124
* @Date ：2022/4/25 9:51
* @Description： 客户端
* 发送"name" 给服务器
* @Version: 1.0
*/
public class HomeWork01Client {
public static void main(String[] args) throws IOException {
//思路
// 1. 连接服务端 (ip , 端口）
// 解读: 连接本机的 9999 端口, 如果连接成功，返回 Socket 对象
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
//2. 连接上后，生成 Socket, 通过 socket.getOutputStream()
// 得到 和 socket 对象关联的输出流对象
OutputStream outputStream = socket.getOutputStream();
//3. 通过输出流，写入数据到 数据通道
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的问题：");
String question = scanner.next();
bufferedWriter.write(question);
bufferedWriter.newLine(); //插入一个换行符，表示写入的内容结束, 注意，要求对方使用 readLine()!!!!
bufferedWriter.flush(); // 如果使用的字符流，需要手动刷新，否则数据不会写入数据通道
//设置结束标记
socket.shutdownOutput();
//4.获取和 socket 关联的输入流. 读取数据(字符)，并显示
InputStream inputStream = socket.getInputStream();
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String s = bufferedReader.readLine();
System.out.println(s); //输出
//5. 关闭流对象和 socket, 必须关闭
bufferedReader.close(); // 关闭外层
bufferedWriter.close();
socket.close();
System.out.println("客户端退出");
}
}
/**
* @ClassName SocketTCP01Server
* @Author ：BLWY-1124
* @Date ：2022/4/25 9:50
* @Description： 服务端 使用字符流方式读写
* @Version: 1.0
*/
public class HomeWork01Server {
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();
//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. 获取 socket 相关联的输出流
OutputStream outputStream = socket.getOutputStream();
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
String answer = "";
if (s.equals("name")) {
answer = "我是覃波";
} else if (s.equals("hobby")) {
answer = "我爱编程";
} else {
answer = "你说啥???";
}
bufferedWriter.write(answer);
bufferedWriter.newLine(); 插入一个换行符，表示写入的内容结束, 注意，要求对方使用 readLine()!!!!
bufferedWriter.flush(); // 如果使用的字符流，需要手动刷新，否则数据不会写入数据通道
// 相当于设置结束标记//socket.shutdownInput();
//6.关闭流和 socket
System.out.println("服务器退出");
bufferedReader.close(); //关闭外层
bufferedWriter.close();
socket.close();
serverSocket.close();//关闭
}
}
代码演示
/**
* @ClassName HomeWork02UDPReceiverA
* @Author ：BLWY-1124
* @Date ：2022/4/26 14:52
* @Description： UDP接收端A
* @Version: 1.0
*/
public class HomeWork02UDPReceiverA {
public static void main(String[] args) throws IOException {
//1. 创建一个 DatagramSocket 对象，准备在 8888 接收数据
DatagramSocket socket = new DatagramSocket(8888);
//2. 构建一个 DatagramPacket 对象，准备接收数据
// 在前面讲解 UDP 协议时，老师说过一个数据包最大64k
byte[] buf = new byte[1024];
DatagramPacket packet = new DatagramPacket(buf,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 answer = "";
if (s.equals("四大名著是哪些")){
answer = "四大名著是：《红楼梦》，《西游记》，《三国演义》，《水浒传》";
}else {
answer = "what???";
}
data = answer.getBytes();
packet = new DatagramPacket(data, 0, data.length,
InetAddress.getByName("192.168.173.3"), 7777);
socket.send(packet);//发送数据
//关闭资源
socket.close();
}
}
/**
* @ClassName HomeWork02UDPSenderB
* @Author ：BLWY-1124
* @Date ：2022/4/26 14:53
* @Description： UDP发送端B
* @Version: 1.0
*/
public class HomeWork02UDPSenderB {
public static void main(String[] args) throws IOException {
//1. 创建一个 DatagramSocket 对象，准备在 7777 接收数据
DatagramSocket socket = new DatagramSocket(7777);
//2. 将需要发送的数据，封装到 DatagramPacket 对象
Scanner scanner = new Scanner(System.in);
System.out.println("请输入问题:");
String question = scanner.next();
byte[] data = question.getBytes();
DatagramPacket packet = new DatagramPacket(data, 0, data.length,
InetAddress.getByName("192.168.173.3"), 8888);
//发送数据
socket.send(packet);
//接收答案
byte[] buf = new byte[1024];
packet = new DatagramPacket(buf,buf.length);
System.out.println("B端准备接收数据..");
socket.receive(packet);//准备接收数据
int length = packet.getLength();
data = packet.getData();
String s = new String(data,0,length);
System.out.println(s);
//关闭资源
socket.close();
}
}
代码演示：
文件下载客户端
/**
* @ClassName HomeWork034Client
* @Author ：BLWY-1124
* @Date ：2022/4/27 10:28
* @Description： 文件下载客户端
* @Version: 1.0
*/
public class HomeWork03Client {
public static void main(String[] args) throws Exception {
//1.客户端连接服务端 6666，得到Socket对象
Socket socket = new Socket(InetAddress.getLocalHost(),6666);
//2. 连接上后，生成 Socket, 通过 socket.getOutputStream()
// 得到 和 socket 对象关联的输出流对象
OutputStream outputStream = socket.getOutputStream();
//3. 通过输出流，写入数据到 数据通道
//BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
Scanner scanner = new Scanner(System.in);
System.out.println("请输入要下载的文件名");
String fileName = scanner.next();
outputStream.write(fileName.getBytes());
//bufferedWriter.write(fileName);
//bufferedWriter.flush(); // 如果使用的字符流，需要手动刷新，否则数据不会写入数据通道
//设置结束标记
socket.shutdownOutput();
//接受服务器端发送的文件
//4. 读取服务器发送的数据 通过Socket得到输入流
InputStream inputStream = socket.getInputStream();
BufferedInputStream bis = new BufferedInputStream(inputStream);
byte[] bytes = StreamUtils.streamToByteArray(bis);
//5. 将得到 bytes 数组，写入到指定的路径，就得到一个文件了
String destFilePath = "e:\\music.mp3";
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
bos.write(bytes);
System.out.println("写入成功~");
//6.关闭资源
bos.close();
inputStream.close();
outputStream.close();
bis.close();
}
}
文件上传服务端
/**
* @ClassName HomeWork03Server
* @Author ：BLWY-1124
* @Date ：2022/4/27 10:28
* @Description： 文件上传服务端
* @Version: 1.0
*/
public class HomeWork03Server {
public static void main(String[] args) throws Exception {
//1. 服务端在本机监听6666端口
ServerSocket serverSocket = new ServerSocket(6666);
System.out.println("服务端在本机监听6666端口...");
//2. 等待连接
Socket socket = serverSocket.accept();
InputStream inputStream = socket.getInputStream();
//3.读取 客户端发送要下载的文件名
// 这里老师使用了while读取文件名，时考虑将来客户端发送的数据较大的情况
/* 字节转字符流
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String s = bufferedReader.readLine();*/
//字节流
byte[] b = new byte[1024];
int len = 0;
String downLoadFileName= "";
while ((len = inputStream.read()) != -1){
downLoadFileName = new String(b,0,len);
}
System.out.println("客户端希望下载文件名=" + downLoadFileName);
//如果客户下载的是 高山流水 我们就返回该文件，否则一律返回 无名.mp3
String filePath = "";
if (downLoadFileName.equals("高山流水")){
filePath = "src\\高山流水.mp3";
}else {
filePath = "src\\无名.mp3";
}
// 4.创建一个输入流，读取文件
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
//5.使用工具类StreamUtils ，读取文件到一个字节数组
//bytes 就是filePath对应的字节数组
byte[] bytes = StreamUtils.streamToByteArray(bis);
//6.通过socket获取到输出流, 将bytes数据发送给服务端
OutputStream outputStream = socket.getOutputStream();
BufferedOutputStream bos = new BufferedOutputStream(outputStream); //获得服务器端输出流
//7. 写入到数据通道，返回给客户端
bos.write(bytes);//将文件对应的字节数组的内容，写入到数据通道
System.out.println("发送成功!");
//8.关闭资源
bis.close();
socket.shutdownOutput();//设置写入数据的结束标记
inputStream.close();
socket.close();
}
}
此类用于演示关于流的读写方法
/**
* 此类用于演示关于流的读写方法
*
*/
public class StreamUtils {
/**
* 功能：将输入流转换成byte[]， 即可以把文件的内容读入到byte[]
* @param is
* @return
* @throws Exception
*/
public static byte[] streamToByteArray(InputStream is) throws Exception{
ByteArrayOutputStream bos = new ByteArrayOutputStream();//创建输出流对象
byte[] b = new byte[1024];//字节数组
int len;
while((len=is.read(b))!=-1){//循环读取
bos.write(b, 0, len);//把读取到的数据，写入bos
}
byte[] array = bos.toByteArray();//然后将bos 转成字节数组
bos.close();
return array;
}
/**
* 功能：将InputStream转换成String
* @param is
* @return
* @throws Exception
*/
public static String streamToString(InputStream is) throws Exception{
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
StringBuilder builder= new StringBuilder();
String line;
while((line=reader.readLine())!=null){
builder.append(line+"\r\n");
}
return builder.toString();
}
}
韩老师代码
**
* @author 韩顺平
* @version 1.0
* 文件下载的客户端
*/
public class Homework03Client {
public static void main(String[] args) throws Exception {
//1. 接收用户输入，指定下载文件名
Scanner scanner = new Scanner(System.in);
System.out.println("请输入下载文件名");
String downloadFileName = scanner.next();
//2. 客户端连接服务端，准备发送
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
//3. 获取和Socket关联的输出流
OutputStream outputStream = socket.getOutputStream();
outputStream.write(downloadFileName.getBytes());
//设置写入结束的标志
socket.shutdownOutput();
//4. 读取服务端返回的文件(字节数据)
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
byte[] bytes = StreamUtils.streamToByteArray(bis);
//5. 得到一个输出流，准备将 bytes 写入到磁盘文件
//比如你下载的是 高山流水 => 下载的就是 高山流水.mp3
// 你下载的是 韩顺平 => 下载的就是 无名.mp3 文件名 韩顺平.mp3
String filePath = "e:\\" + downloadFileName + ".mp3";
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));
bos.write(bytes);
//6. 关闭相关的资源
bos.close();
bis.close();
outputStream.close();
socket.close();
System.out.println("客户端下载完毕，正确退出..");
}
}
/**
* @author 韩顺平
* @version 1.0
* 先写文件下载的服务端
*/
public class Homework03Server {
public static void main(String[] args) throws Exception {
//1 监听 9999端口
ServerSocket serverSocket = new ServerSocket(9999);
//2.等待客户端连接
System.out.println("服务端，在9999端口监听，等待下载文件");
Socket socket = serverSocket.accept();
//3.读取 客户端发送要下载的文件名
// 这里老师使用了while读取文件名，时考虑将来客户端发送的数据较大的情况
InputStream inputStream = socket.getInputStream();
byte[] b = new byte[1024];
int len = 0;
String downLoadFileName = "";
while ((len = inputStream.read(b)) != -1) {
downLoadFileName += new String(b, 0 , len);
}
System.out.println("客户端希望下载文件名=" + downLoadFileName);
//老师在服务器上有两个文件, 无名.mp3 高山流水.mp3
//如果客户下载的是 高山流水 我们就返回该文件，否则一律返回 无名.mp3
String resFileName = "";
if("高山流水".equals(downLoadFileName)) {
resFileName = "src\\高山流水.mp3";
} else {
resFileName = "src\\无名.mp3";
}
//4. 创建一个输入流，读取文件
BufferedInputStream bis =
new BufferedInputStream(new FileInputStream(resFileName));
//5. 使用工具类StreamUtils ，读取文件到一个字节数组
byte[] bytes = StreamUtils.streamToByteArray(bis);
//6. 得到Socket关联的输出流
BufferedOutputStream bos =
new BufferedOutputStream(socket.getOutputStream());
//7. 写入到数据通道，返回给客户端
bos.write(bytes);
socket.shutdownOutput();//很关键.
//8 关闭相关的资源
bis.close();
inputStream.close();
socket.close();
serverSocket.close();
System.out.println("服务端退出...");
}
}
我亦无他，惟手熟尔
乘风破浪会有时，直挂云帆济沧海