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("客户端退出...");
}
}
Java-网络编程（TCP-UDP）的更多相关文章
- java 网络编程-tcp/udp
--转自:http://blog.csdn.net/nyzhl/article/details/1705039 直接把代码写在这里,解释看这里吧:http://blog.csdn.net/nyzhl/ ...
- Java网络编程——TCP/UDP
UDP:面向无连接 ☆ 将数据及源地址和目的地址封装成数据包中 ☆ 每个数据报的大小限制在64K ☆ 不可靠协议 ☆ 不需要建立连接,速度快 TCP:面向有连接 ☆ 建立连接,形成传输数据的通道 ☆ ...
- 32.网络编程TCP/UDP服务
网络编程TCP: 服务器端口了解: port:0~65535 web服务:80 邮箱服务:556 0~1024:为服务默认的公认端口,一般我们不能用 套接字:socket socket作用 ip:po ...
- java网络编程(TCP详解)
网络编程详解-TCP 一,TCP协议的特点 面向连接的协议(有发送端就一定要有接收端) 通过三次连接握手建立连接 通过四次握手断开连接 基于IO流传输数据 传输数据大小 ...
- iOS 网络编程 TCP/UDP HTTP
一.HTTP协议的主要特点: 1. CS模式 2. 简单快速:只需要传送请求方法和路径.(常用方法有GET,HEAD,POST) 3. 灵活:任意对象都可以,类型由Content-Type加以标记 4 ...
- 28_网络编程-TCP/UDP
一.传输层 1.定义 IP首部有一个协议字段,用来标识网络层(IP)的上一层所采用的是哪一种传输层协议.根据这个字段的协议号,就可以识别IP传输的数据部分究竟是TCP的内容还是 ...
- java网络编程TCP传输—流操作—拿到源后的写入动作
在网络编程中的TCP传输里,拿到Socket的源后,应该怎么进行读写操作呢,下面我列举了两种方法,希望大家帮忙补充···· 1.利用byte数组作为一个缓冲区进行读写 客户端上传 //获取socket ...
- JAVA网络编程TCP通信
Socket简介: Socket称为"套接字",描述IP地址和端口.在Internet上的主机一般运行多个服务软件,同时提供几种服务,每种服务都打开一个Socket,并绑定在一个端 ...
- Java分享笔记：Java网络编程--TCP程序设计
[1] TCP编程的主要步骤 客户端(client): 1.创建Socket对象,构造方法的形参列表中需要InetAddress类对象和int型值,用来指明对方的IP地址和端口号. 2.通过Socke ...
- java 网络编程基础 UDP协议的Socket：DatagramSocket；广播Socket：MulticastSocket
什么是UDP协议: UDP协议是一种不可靠的网络协议,它在通信实例的两端各建立一个Socket 但这两个 Socket之间并没有虚拟链路,这两个Socket只是发送.接收数据报的对象.Java 提供了 ...
随机推荐
- ResNet模型：在计算机视觉任务中实现深度学习
目录 1. 引言 2. 技术原理及概念 2.1 基本概念解释 2.2 技术原理介绍 3. 实现步骤与流程 3.1 准备工作:环境配置与依赖安装 3.2 核心模块实现 3.3 集成与测试 4. 示例与应 ...
- k8s驱逐篇(6)-kube-controller-manager驱逐-NodeLifecycleController源码分析
概述 k8s v1.16版本中NodeController已经分为了NodeIpamController与NodeLifecycleController,本文主要介绍NodeLifecycleCont ...
- 工作中必备的12个Git命令
前言 以下是工作中必备的12个Git命令,包括创建和初始化仓库.克隆远程仓库.添加和提交文件.查看状态和历史记录.创建和切换分支.合并分支以及推送和拉取远程仓库等操作.掌握这些命令可以帮助你进行基本的 ...
- Sentieon | 每周文献-Genetic Disease-第二期
遗传病系列文章-1 标题(英文):Answer ALS, a large-scale resource for sporadic and familial ALS combining clinical ...
- python笔记：第二章基本数据类型
基本数据类型 Python中的数据类型可以分为五大类:字符串.数字.容器.布尔.None 1.字符串 可以使用单引号或双引号创建字符串,可以用加号将两个字符串合并 name = '小明' age = ...
- UI自动化 --- 微软UI Automation
引言 自动化测试平台的意义就三个字 --- 稳定性. 无论是接口自动化测试,还是UI自动化测试,目的就是为了提高产品的稳定性,保证用户体验. 那常见的接口自动化测试比如有 Postman ,SoapU ...
- 从0开发WebGPU渲染引擎：实现路径追踪
大家好,本文基于WebGPU的计算着色器实现了基础的路径追踪器,支持Middle BVH和No BVH两种加速结构 我主要是将离线渲染零基础实战开发培训班(一期)->第二十九节课的代码移植到We ...
- Asp-Net-Core学习笔记：单元测试和集成测试
前言 我在使用 AspNetCore 的这段时间内,看了很多开源项目和博客,发现各种 .Net 体系的新技术很多人都有关注和使用,但却很少有人关注测试. 测试是软件生命周期中的一个非常重要的阶段,对于 ...
- Redis解决网络抖动问题
Redis解决网络抖动问题 所谓网络抖动问题, 简单来说就是防止用户短暂的时间内对同一个接口多次点击访问 这里利用的是redis锁的原子性和with Statement上下文管理器实现, 另外该类还支 ...
- 关于在modelsim中 仿真 ROM IP核 读取不了 mif文件 的解决方法
在modelsim中 仿真 ROM IP核 读取不了 mif文件 . 出现状况: 显示无法打开 rom_8x256.mif 文件 .点开modelsim下面文件的内存列表,可看到内存全为0. 查看自身 ...