文章目录
一、网络基础
网络的相关概念
1.网络通信
(1)概念:两台设备之间通过网络实现数据传输
(2)网络通信将数据通过网络从一台设备传输到另一台设备
(3)java.net包下提供了一系列的类或接口,供程序员使用,完成网络通信
2.网络
(1)概念:两台或多台设备通过一定物理设备连接起来构成了网络
(2)分类(根据网络覆盖范围分)
- 局域网:覆盖范围最小,仅仅覆盖一个教室或一个机房
- 城域网:覆盖范围较大,可以覆盖一个城市
- 广域网:覆盖范围最大,可以覆盖全国,甚至全球,万维网是广域网的代表
3.ip地址
(1)概念:用于唯一标识网络中的每台计算机
(2)查看ip地址:ipconfig
(3)ip地址的表示形式:点分十进制 xx.xx.xx.xx
(4)每一个十进制数的范围:0~255,IPv4由4个字节(32位)构成
0~255 | 0~255 | 0~255 | 0~255 |
---|
(5)ip地址的组成=网络地址+主机地址,比如:192.168.16.69
(6)IPv6是互联网工程任务组设计的用于代替IPv4的下一代IP协议,其地址数量号称为全世界的每一粒沙子编上一个地址
IPv6由16个字节(128位)构成,是IPv4的四倍
(7)由于IPv4最大的问题在于网络地址资源有限,严重制约了互联网的应用和发展。IPv6的使用,不仅能解决网络地址资源数量的问题,而且也解决了很多接入设备连入互联网的障碍
(8)IPv4地址分类
4.域名和端口
- 域名
(1)www.baidu.com
(2)好处:为了方便记忆,解决记ip的困难
(3)概念:将ip地址映射成域名
- 端口
(1)概念:用于标识计算机上某个特定的网络程序
(2)表示形式:以整数形式,范围0~65535(2个字节表示端口 0~2^16 - 1)
(3)0~1024已经被占用,比如 ssh 22,ftp 21,smtp 25,http 80
(4)常见的网络程序端口号:
tomcat:8080
mysql:3306
oracle:1521
sqlServer:1433
- 通过IP能确定到百度主机,端口能识别要和哪个服务发生通讯
5.网络通讯协议
(1)协议(tcp/ip)
TCP/IP(Transmission Control Protocol/Internet Protocol)的简写,中文译名为传输控制协议/因特网互联协议(又叫网络通讯协议),这个协议是Internet最基本的协议,简单地说,就是由网络层的IP协议和传输层的TCP协议组成的。
- 为了让双方彼此明白数据的含义,制定了一套规则,即网络协议。这样,双方在交流时使用协议,就能够理解数据的底层含义。
- 协议是数据的组织形式,通过协议,就能把数据准确无误地发送给对方。
(2)TCP和UDP
-
TCP协议(传输控制协议)
①使用TCP协议前,需要先建立TCP连接,形成数据传输通道
②传输前,采用"三次握手"方式,是可靠的
第三次保证双方是可以通讯的
③TCP协议进行通信的两个应用进程:客户端、服务端
④在连接中可进行大数据量的传输
⑤传输完毕,需释放已建立的连接,效率低
-
UDP协议(用户)
①将数据、源、目的封装成数据包,不需要建立连接
②每个数据包的大小限制在64K内,不适合传输大量数据
③因无需连接,故是不可靠的
④发送数据结束时无需释放资源(因为不是面向连接的),速度快
⑤举例:厕所通知、发短信
直接说正事,说完就走,没有等对方回应
二、InetAddress类
1.相关方法
(1)获取本机InetAddress对象 getLocalHost
(2)根据指定主机名/域名获取ip地址对象 getByName
(3)获取InetAddress对象的主机名 getHostName
(4)获取InetAddress对象的地址 getHostAddress
2.应用案例
package chapter21;
import java.net.InetAddress;
import java.net.UnknownHostException;
/**
* 演示InetAddress类的使用
*/
public class API_ {
public static void main(String[] args) throws UnknownHostException {
//1.获取本机InetAddress对象
InetAddress localHost = InetAddress.getLocalHost();
System.out.println(localHost);
//2.根据指定主机名获取InetAddress对象
InetAddress host1 = InetAddress.getByName("LAPTOP-G7U303RF");
System.out.println("host1=" + host1);
//3.根据指定域名获取InetAddress对象
InetAddress host2 = InetAddress.getByName("www.baidu.com");
System.out.println("host2=" + host2);
//4.通过InetAddress对象,获取对应地址
String hostAddress = host2.getHostAddress();
System.out.println("host2 对应的 ip地址为:" + hostAddress);
//4.通过InetAddress对象,获取对应主机名/域名
String hostName = host2.getHostName();
System.out.println("host2 对应的 主机名为:" + hostName);
}
}
三、Socket
基本介绍
(1)套接字(Socket)开发网络应用程序被广泛采用,以至于成为事实上的标准
(2)通信的两端都要有Socket,是两台机器间通信的端点
(3)网络通信其实就是Socket间的通信
(4)Socket允许程序把网络连接当成一个流,数据在两个Socket间通过IO传输
(5)一般主动发起通信的应用程序属客户端,等待通信请求的为服务端
- 客户端发起连接,服务器端接收请求连接,形成一个数据通道,通过socket获取输入流/输出流,就可以进行数据的读取操作
四、TCP编程
1.介绍
(1)基于客户端—服务端的网络通信
(2)底层使用的是TCP/IP协议
(3)应用场景举例:客户端发送数据,服务端接受并显示在控制台
(4)基于Socket的TCP编程
-
服务端首先监听并等待客户端的连接。一旦连接建立,客户端就可以通过Socket获取输出流,将数据发送给服务端;
-
服务端通过Socket获取输入流来读取客户端发送的数据,然后再通过Socket获取输出流将处理后的数据回送给客户端;
-
客户端接收数据时,也是通过Socket获取输入流进行读取。
-
数据传输完毕后,记得关闭socket连接!!!
-
客户端和服务端各有一个Socket对象
2.应用案例
案例一(使用字节流)
(1)编写一个服务端和一个客户端
(2)服务器端在9999端口监听
(3)客户端连接到服务端,发送"hello, server",然后退出
(4)服务器端接收到客户端发送的信息,输出并退出
package chapter21.socket;
import java.io.IOException;
import java.io.InputStream;
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);
System.out.println(socket.getClass());
//3.通过socket.getInputStream(),写入数据到数据通道
InputStream inputStream = socket.getInputStream();
//4.IO读取
byte[] buf = new byte[1024];
int readLen = 0;
//如果读取正常,返回实际读取的字节数,读完返回-1
while ((readLen = inputStream.read(buf)) != -1) {
System.out.println(new String(buf, 0, readLen));//根据读取到的实际长度,显示内容
}
//5.关闭流、socket和serverSocket
//ServerSocket 可以创建多个 Socket 对象,每个 Socket 对象代表了一个与客户端的连接。
inputStream.close();
socket.close();
serverSocket.close();
}
}
package chapter21.socket;
import java.io.IOException;
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,端口)
//解读:连接本机的9999端口,如果连接成功,返回Socket对象
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端 socket=" + socket);
System.out.println(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("客户端退出...");
}
}
案例二(引出写入结束标记)
(1)编写一个服务端和一个客户端
(2)服务端在9999端口监听
(3)客户端连接到服务端,发送"hello, server",并接受服务端回发的"hello, client"再退出
(4)服务器端接受到客户端发送的信息,输出,并发送"hello, client",再退出
package chapter21.socket;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 服务端
*/
public class SocketTCP02Server {
public static void main(String[] args) throws IOException {
//1.通过创建ServerSocket监听端口9999,等待连接
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务端 在9999端口监听,等待连接...");
//2.有客户端连接,返回Socket对象,程序继续执行
Socket socket = serverSocket.accept();
System.out.println("socket=" + socket);
//3.获取和socket相关的输入流,读取数据(字节),并显示
InputStream inputStream = socket.getInputStream();
int readLen = 0;
byte[] buf = new byte[1024];
while ((readLen = inputStream.read(buf)) != -1) {
System.out.println(new String(buf, 0, readLen));
}
//4.获取socket相关的输出流,写入数据到数据通道
OutputStream outputStream = socket.getOutputStream();
outputStream.write("hello, client".getBytes());
//设置结束标记
socket.shutdownInput();
//5.关闭流和socket
outputStream.close();
inputStream.close();
socket.close();
serverSocket.close();
}
}
package chapter21.socket;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
/**
* 客户端
*/
public class SocketTCP02Client {
public static void main(String[] args) throws IOException {
//1.连接本机的9999端口,如果连接成功,返回Socket对象
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端socket=" + socket);
//2.获取socket相关的输出流,写入数据到数据通道
OutputStream outputStream = socket.getOutputStream();
outputStream.write("hello, server".getBytes());
//设置结束标记
socket.shutdownOutput();
//3.获取和socket相关的输入流,读取数据(字节),并显示
InputStream inputStream = socket.getInputStream();
byte[] buf = new byte[1028];
int readLen = 0;
while ((readLen = inputStream.read(buf)) != -1) {
System.out.println(new String(buf, 0, readLen));
}
//4.关闭流和socket
inputStream.close();
outputStream.close();
socket.close();
System.out.println("客户端退出...");
}
}
- 结束标记
(1)在发送完数据后应该有一个结束标记,有了结束标记,接收方可以明确知道何时接收到了完整的信息。
(2)我们可以将数据传输中的结束标记比喻为对话的一个清晰信号,以确保信息的完整性和正常流程。
假设你和朋友正在对话:
朋友:明天一起去看电影
你:我看看明天有没有其他安排…(沉默)
如果你没有明确表示已经说完,你的朋友会不确定你是否还在考虑,而等待你继续发言。这可能导致通信不必要的延迟。
(3)类比到数据传输,结束标记就像你明确表示对话结束的信号,它告诉接收方(socket):“这就是全部了,你可以开始处理了。”没有这个明确的结束标记,接收方可能会陷入不确定性,无法准确判断何时可以安全地停止接收数据,从而导致通信问题。因此,结束标记在数据传输中充当了清晰的边界标识,确保信息的完整性和正常处理。
案例三(使用字符流)
(1)编写一个服务端和一个客户端
(2)服务端在9999端口监听
(3)客户端连接到服务端,发送"hello, server",并接受服务端回发的"hello, client"再退出
(4)服务器端接受到客户端发送的信息,输出,并发送"hello, client",再退出
package chapter21.socket;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 服务端,使用字符流
*/
public class SocketTCP03Server {
public static void main(String[] args) throws IOException {
//1.通过创建ServerSocket监听端口9999,等待连接
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务端 在9999端口监听,等待连接...");
//2.有客户端连接,返回Socket对象,程序继续执行
Socket socket = serverSocket.accept();
System.out.println("服务端 socket返回:" + socket.getClass());
//3.获取和socket相关的输入流,读取数据(字符),并显示
InputStream inputStream = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
String s = br.readLine();//读取一行
System.out.println(s);
//4.获取socket相关的输出流,写入数据到数据通道
OutputStream outputStream = socket.getOutputStream();
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
bw.write("hello, client 字符流");
bw.newLine();//插入一个换行符,表示回复内容的结束
bw.flush();//注意需要手动的flush
//5.关闭流和socket
bw.close();
br.close();
socket.close();
serverSocket.close();
}
}
package chapter21.socket;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
/**
* 客户端,使用字符流
*/
public class SocketTCP03Client {
public static void main(String[] args) throws IOException {
//1.连接本机的9999端口,如果连接成功,返回Socket对象
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
System.out.println("客户端 socket返回:" + socket.getClass());
//2.获取socket相关的输出流,用字符输出流写入数据到数据通道
OutputStream outputStream = socket.getOutputStream();
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
bw.write("hello, server 字符流");
bw.newLine();//插入一个换行符,表示写入的内容结束,要求对方使用readLine()!!!
bw.flush();//如果使用字符流,需要手动刷新,否则数据不会写入数据通道
//3.获取和socket相关的输入流,读取数据(字符),并显示
InputStream inputStream = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
String s = br.readLine();
System.out.println(s);
//4.关闭流和socket
br.close();
bw.close();
socket.close();
System.out.println("客户端退出...");
}
}
案例四(网络上传文件)
(1)编写一个服务端和一个客户端
(2)服务端在9999端口监听
(3)客户端连接到服务端,发送一张图片 e:\qie.png
(4)服务器端接收到客户端发送的图片,保存到src下,发送"收到图片"再退出
(5)客户端接收到服务端发送的"收到图片"再退出
(6)该程序要求使用StreamUtils.java,我们直接使用
说明:使用 BufferedInputStream 和 BufferedOutputStream 字节流
客户端:输入流读取图片文件,得到字节数组 -> 获取socket相关的输出流,传输文件内容到数据通道 -> 用socket相关输入流读取服务端发来的信息,并显示收到信息
服务端:socket相关的输入流接收文件 -> 得到文件数据对应的字节数组 -> 把文件数据刷新到磁盘上 -> socket相关输出流输出"收到图片"的信息
package chapter21.upload;
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 socket = serverSocket.accept();
//3.读取客户端发送的数据
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
byte[] bytes = StreamUtils.streamToByteArray(bis);
//4.将得到的bytes数组,写入到指定的路径,得到一个文件
String destFilePath = "src\\qie2.jpg";
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
bos.write(bytes);
//5.通过socket获取输出流(字符),向客户端回复“收到图片”
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
bw.write("收到图片");
bw.flush();//把内容刷新到数据通道
socket.shutdownOutput();//设置写入结束标记
//关闭流和socket
bw.close();
bos.close();
bis.close();
socket.close();
serverSocket.close();
}
}
package chapter21.upload;
import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
/**
* 文件上传的客户端
*/
public class TCPFileUploadClient {
public static void main(String[] args) throws Exception {
//1.客户端连接服务器(ip,端口),得到Socket对象
Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
//2.创建读取磁盘文件的输入流
String filePath = "e:\\qie.jpg";
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
byte[] bytes = StreamUtils.streamToByteArray(bis);//bytes就是文件数据对应的字节数组
//3.通过socket获取输出流,将bytes数据发送给服务端
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
bos.write(bytes);//将文件对应的字节数组内容,写入到数据通道
bis.close();
socket.shutdownOutput();//设置写入数据的结束标记
//4.接收服务端回复的消息
InputStream is = socket.getInputStream();
String s = StreamUtils.streamToString(is);//使用StreamUtils的方法,直接将inputStream读取到的内容转成字符串
System.out.print(s);
//关闭流和socket
is.close();
bos.close();
socket.close();
System.out.println("客户端退出...");
}
}
package chapter21.upload;
import java.io.BufferedReader;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
/**
* 此类用于演示关于流的读写方法
*
*/
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();
}
}
3.net指令
(1)netstat -an 可以查看当前主机网络情况,包括端口监听情况和网络连接情况
(2)netstat -an | more 可以分页显示,空格显示下一页的内容
(3)要求在dos控制台下执行(按win+R)
说明:
- Listening表示某个端口在监听
- 如果有一个外部程序(客户端)连接到该端口,就会显示一条连接信息
- 可以输入ctrl + c 退出指令
- 本地地址:主机地址+端口
- 外部地址:连接到主机的地址+端口
4.TCP连接网络通讯不为人知的秘密
当客户端连接到服务端后,实际上客户端也是通过一个端口和服务端进行通讯的,这个端口是TCP/IP来分配的,是不确定的、随机的
五、UDP编程【了解】
1.介绍
(1)类DatagramSocket 和 DatagramPacket(数据报/数据包) 实现了基于UDP协议的网络程序
(2)UDP数据报通过 (数据报套接字)DatagramSocket 发送和接受,系统不保证UDP数据报一定能够安全送到目的地,也不能确定什么时候可以抵达
(3)DatagramPacket 对象封装了UDP数据报,在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号
(4)UDP协议中每个数据报都给出了完整的地址信息,因此无需建立发送方和接收方的连接
2.基本流程
(1)核心的两个类/对象 DatagramSocket 与 DatagramPacket
(2)建立发送端,接收端
(3)建立数据包
(4)调用DatagramSocket的发送、接收方法
(5)关闭DatagramSocket
3.应用案例
(1)编写一个接收端A和一个发送端B
(2)接收端A在9999端口等待接收数据(receive)
(3)发送端向接收端A,发送数据"hello, 明天吃火锅~"
(4)接收端A接收到发送端B发送的信息,回复"好的,明天见",再退出
(5)发送端接收回复的数据,再退出
package chapter21.udp;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
/**
* UDP接收端A
*/
public class UDPReceiverA {
public static void main(String[] args) throws IOException {
//1.创建一个DatagramSocket对象,准备在9999端口接收数据
DatagramSocket socket = new DatagramSocket(9999);
//2.创建一个DatagramPacket对象,准备接收数据
//前面讲过: 一个数据包最大 64K
byte[] buf = new byte[1024];
DatagramPacket packet = new DatagramPacket(buf, buf.length);
//3.调用接收方法,通过网络传输DatagramPacket对象
//当有数据包发送到本机的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端
//5.将需要发送的数据,封装到DatagramPacket(data内容字节数组,数组大小,主机(IP),端口)
data = "好的,明天见!".getBytes();
packet = new DatagramPacket(data, data.length, InetAddress.getByName("10.23.31.163"), 9998);
socket.send(packet);
//6.关闭socket
socket.close();
System.out.println("接收端A 退出...");
}
}
package chapter21.udp;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
/**
* UDP发送端B
*/
public class UDPSenderB {
public static void main(String[] args) throws IOException {
//1.创建一个DatagramSocket对象,准备在9998端口接收数据
DatagramSocket socket = new DatagramSocket(9998);
//2.将需要发送的数据,封装到DatagramPacket(data内容字节数组,数组大小,主机(IP),端口)
byte[] data = "hello, 明天吃火锅~".getBytes();
DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName("10.23.31.163"), 9999);
socket.send(packet);
//3.======接收A端回复的信息
//(1)构建一个DatagramPacket对象,准备接收数据
byte[] buf = new byte[1024];
packet = new DatagramPacket(buf, buf.length);
//(2)调用接收方法,通过网络传输DatagramPacket对象
//当有数据包发送到本机的9998端口,就会接收到数据,否则就会阻塞等待
socket.receive(packet);
//(3)拆包, 取出数据并显示
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 退出...");
}
}
本章作业
作业1
(1)使用字符流的方式,编写一个客户端程序和一个服务器端程序
(2)客户端发送"name", 服务器端接收到后,返回"我是nova",nova是你自己的名字
(3)客户端发送"hobby",服务器端接收到后,返回"编写java程序"
(4)不是这两个问题,回复"你说啥呢?"
package chapter21.homework.h1;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 服务端
*/
public class Homework01Server {
public static void main(String[] args) throws IOException {
//1.在本机的9999端口监听,等待连接
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务端 在9999端口监听,等待连接...");
//2.如果客户连接9999端口,返回Socket对象
Socket socket = serverSocket.accept();
//3.获取和socket相关的输入流,读取数据(字符)
InputStream is = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(is));
String s = br.readLine();
String answer = "";
if ("name".equals(s)) {
answer ="我是韩顺平";
} else if ("hobby".equals(s)) {
answer = "编写java程序";
} else {
answer = "你说啥呢?";
}
//4.获取和socket相关的输出流,回复
OutputStream os = socket.getOutputStream();
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
bw.write(answer);
bw.newLine();//插入一个换行符,表示写入数据的结束
bw.flush();//手动刷新,才能将数据写入
//5.关闭流对象和socket
bw.close();
br.close();
socket.close();
serverSocket.close();
}
}
package chapter21.homework.h1;
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 {
//1.连接服务器(ip,端口)
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
//2.获取和socket相关的输出流,输出
OutputStream os = socket.getOutputStream();
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(os));
//从键盘读取用户的问题
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的问题:");
String question = scanner.next();
bw.write(question);
bw.newLine();//插入一个换行符,表示写入数据的结束
bw.flush();//注意需要手动的flush,才能将数据写入
//3.获取和socket相关的输入流,读取数据(字符)
InputStream is = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(is));
String s = br.readLine();
System.out.println(s);
//4.关闭流和socket
br.close();
bw.close();
socket.close();
System.out.println("客户端退出...");
}
}
作业2
(1)编写一个接收端A和一个发送端B, 使用UDP协议完成
(2)接收端在8888端口等待接收数据(receive)
(3)发送端向接收端发送数据"四大名著有哪些?"
(4)接收端接收到发送端发送的问题后, 返回"四大名著: 《水浒传》《三国演义》《西游记》《红楼梦》",否则返回what?
(5)接收端和发送端程序退出
package chapter21.homework.h2;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
/**
* 接收端A
*/
public class Homework02ReceiverA {
public static void main(String[] args) throws IOException {
//1.创建一个DatagramSocket对象, 准备在8888端口接收数据
DatagramSocket socket = new DatagramSocket(8888);
//2.创建一个DatagramPacket对象, 准备接收数据
byte[] buf = new byte[1024];
DatagramPacket packet = new DatagramPacket(buf, buf.length);
//3.调用receive接收数据
System.out.println("接收端A 等待接收数据...");
socket.receive(packet);
//4.拆包,取出数据
int length = packet.getLength();
byte[] data = packet.getData();
String s = new String(data, 0, length);
//判断接收的信息是什么
String answer = "";
if ("四大名著有哪些?".equals(s)) {
answer = "四大名著: 《水浒传》《三国演义》《西游记》《红楼梦》";
} else {
answer = "what?";
}
//======回复信息给B端
//5.将需要发送的数据,封装到DatagramPacket对象, 回复信息给发送端B
data = answer.getBytes();
packet = new DatagramPacket(data, data.length, InetAddress.getByName("10.23.31.163"), 8889);
socket.send(packet);
//关闭资源
socket.close();
System.out.println("接收端A 退出...");
}
}
package chapter21.homework.h2;
import java.io.IOException;
import java.net.*;
import java.util.Scanner;
/**
* 发送端B
*/
public class Homework02SenderB {
public static void main(String[] args) throws IOException {
//1.创建一个DatagramSocket对象, 准备在8889发送数据
DatagramSocket socket = new DatagramSocket(8889);
//2.将需要发送的数据,封装到DatagramPacket(data内容字节数组,数组大小,主机(IP),端口)
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的问题:");
String question = scanner.next();
byte[] data = question.getBytes();
DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getByName("10.23.31.163"), 8888);
socket.send(packet);
//3.======接收A端回复的信息
//(1)构建一个DatagramPacket对象,准备接收数据
byte[] buf = new byte[1024];
packet = new DatagramPacket(buf, buf.length);
//(2)调用接收方法,通过网络传输DatagramPacket对象
//当有数据包发送到本机的9998端口,就会接收到数据,否则就会阻塞等待
socket.receive(packet);
//(3)拆包, 取出数据并显示
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退出...");
}
}
作业3
(1)编写客户端程序和服务端程序
(2)客户端可以输入一个音乐文件名,比如高山流水,服务端收到音乐名后,可以给服务端返回这个音乐文件,如果服务端没有这个文件,返回一个默认的音乐即可
(3)客户端收到文件后,保存到本地e:\
(4)该程序可以使用StreamUtils.java
package chapter21.homework.h3;
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;
/**
* 服务端
*/
public class Homework03Server {
public static void main(String[] args) throws Exception {
//1.监听9999端口
ServerSocket serverSocket = new ServerSocket(9999);
System.out.println("服务端等待连接...");
//2.等待客户端连接
Socket socket = serverSocket.accept();
//3.读取客户端发来的数据
InputStream inputStream = socket.getInputStream();
int readLen = 0;//实际读取的长度
byte[] bytes = new byte[1024];//字节数组,使之一次性读取多个字节
String downloadFileName = "";//要下载的文件名
//这里使用了while读取文件名,是考虑到将来客户端发送的数据较大的情况
while ((readLen = inputStream.read(bytes)) != -1) {
downloadFileName += new String(bytes, 0, readLen);//拼接字符串,防止文件名太长
}
//4.创建输入流,读取磁盘的音乐文件
//服务器上有两个文件, 无名.mp3 高山流水.mp3
//如果客户端下载的是高山流水,返回该文件, 否则一律返回无名.mp3
String resFileName = "";
if ("高山流水".equals(downloadFileName)) {
resFileName = "src\\高山流水.mp3";
} else {
resFileName = "src\\无名.mp3";
}
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(resFileName));
//使用工具类StreamUtils,读取文件得到一个字节数组
bytes = StreamUtils.streamToByteArray(bis);
//5.获取socket相关输出流,将对应音乐文件写入数据通道
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
bos.write(bytes);
socket.shutdownOutput();
//6.关闭流和socket
bos.close();
bis.close();
socket.close();
serverSocket.close();
}
}
package chapter21.homework.h3;
import java.io.BufferedInputStream;
import java.io.FileOutputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.util.Scanner;
/**
* 客户端
*/
public class Homework03Client {
public static void main(String[] args) throws Exception {
//1.读取键盘输入
Scanner scanner = new Scanner(System.in);
System.out.print("请输入要下载的文件名:");
String downloadFileName = scanner.next();
//2.连接服务器(ip, 端口)
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
//3.向服务端发送数据
OutputStream outputStream = socket.getOutputStream();
outputStream.write(downloadFileName.getBytes());
socket.shutdownOutput();//设置写入结束的标志
//4.获取socket相关输入流,接受服务端传来的数据
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
byte[] bytes = StreamUtils.streamToByteArray(bis);//bytes是文件数据对应的字节数组
//5.将得到的bytes写入指定的位置
String destPath = "e:\\" + downloadFileName + ".mp3";
FileOutputStream fos = new FileOutputStream(destPath);
fos.write(bytes);
//6.关闭流和socket
fos.close();
bis.close();
outputStream.close();
socket.close();
System.out.println("客户端下载完毕, 退出...");
}
}
main(String[] args) throws Exception {
//1.读取键盘输入
Scanner scanner = new Scanner(System.in);
System.out.print(“请输入要下载的文件名:”);
String downloadFileName = scanner.next();
//2.连接服务器(ip, 端口)
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
//3.向服务端发送数据
OutputStream outputStream = socket.getOutputStream();
outputStream.write(downloadFileName.getBytes());
socket.shutdownOutput();//设置写入结束的标志
//4.获取socket相关输入流,接受服务端传来的数据
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
byte[] bytes = StreamUtils.streamToByteArray(bis);//bytes是文件数据对应的字节数组
//5.将得到的bytes写入指定的位置
String destPath = "e:\\" + downloadFileName + ".mp3";
FileOutputStream fos = new FileOutputStream(destPath);
fos.write(bytes);
//6.关闭流和socket
fos.close();
bis.close();
outputStream.close();
socket.close();
System.out.println("客户端下载完毕, 退出...");
}
}