java零基础Ⅲ-- 1.网络编程
一、网络基础
网络通信
1、概念: 两台设备之间通过网络实现数据传输
2、网络通信: 将数据通过网络从一台设备传输到另外一台设备
3、java.net
包下提供了一系列的类或接口,供程序员使用,完成网络通信
网络
1、概念:两台或多台设备通过一定物理设备连接起来构成了 网络
2、根据网络的覆盖范围不同,对网络进行父类;
- 局域网:覆盖范围最小,仅仅覆盖一个教室或一个机房
- 城域网:覆盖范围较大,可以覆盖一个城市
- 广域网:覆盖范围最大,可以覆盖全国,甚至全球,万维网是广域网的代表
ip 地址
1、概念:用于唯一标识网络中计算机的每台计算机/主机
2、查看ip地址:ipconfig
3、ip地址的表示形式:点分十进制 xx.xx.xx.xx
4、每一个十进制数的范围:0~255
5、ip地址的组成 = 网络地址 + 主机地址,比如:192.168.16. 69
6、iIPv6是互联网工程任务组设计的用于代替IPv4的下一代IP协议,其地址数量号称可以为全世界的每一粒沙子编上一个地址
7、由于IPv4最大问题在于网络地址资源有限,严重制约了互联网的应用和发展。IPv6的使用,不仅能解决网络地址资源数量的问题,而且也解决了多种接入设备连入互联网的障碍。
ipv4地址分类
域名
1、www.baidu.com
2、好处:为了方便记忆,解决记ip的困难
3、概念:将ip地址映射成域名,这里怎么映射上,HTTP协议
端口号
1、概念:用于标识计算机上某个特定的网络程序
2、表示形式:以整数形式,端口范围 0~65535
[2个字节表示端口 2^16-1=0-65535]
3、0~1024
已经被占用,比如:ssh 22,ftp 21,smtp 25,http 80
4、常见的网络程序端口号:
- tomcat:8080
- mysql:3306
- oracle:1521
- sqlserver:1433
网络通信协议
协议(tcp/ip)
TCP/IP (Transmission Control Protocol/Internet Protocol)
的简写,中文译文为 传输控制协议/因特网互联协议 ,又叫 网络通讯协议,这个协议是 Internet
最基本的协议, Internet
国际互联网络的基础,简单来说,就是有网络层的IP协议和传输层的TCP协议组成的。
TCP 和 UDP
TCP协议 (传输控制协议)
1、使用TCP协议之前,须先建立TCP连接,形成传输数据通道
2、传输前,采用 “三次握手” 方式,是可靠的
3、TCP协议进行通信的两个进程:客户端、服务端
4、在连接中可进行大数据量的传输
5、传输完毕,需释放已建立的连接,效率低
UDP协议 (用户数据协议)
1、将数据、源、目的封装成数据包,不需要建立连接
2、每个数据报的大小限制在64k内【不适合传输大量数据】
3、因无需连接,故是不可靠的
4、发送数据结束时无需释放资源(因为不是面向连接的),速度快
5、举例:厕所通知:发短信
二、InteAddress
相关方法
1、获取本地InetAddress
对象 getLocalHost
2、根据指定主机名/域名获取ip地址对象 getByName
3、获取InetAddress
对象的主机名 getHostName
4、获取InetAddress
对象的地址 getHostAddress
应用案例
编写代码,获取计算机的主机名和IP地址相关API
package com.zzpedu.api;
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=" + localHost);// 本计算机名/192.168.2.26
//2. 根据指定主机名 获取InetAddress 对象
InetAddress host1 = InetAddress.getByName("本计算机名");
System.out.println("host1=" + host1);// 本计算机名/192.168.2.26
//3. 根据域名返回 InetAddress 对象,比如 www.baidu.com 对应 InetAddress
InetAddress host2 = InetAddress.getByName("www.baidu.com");
System.out.println("host2=" + host2);// www.baidu.com/183.232.231.172
//4. 通过 InetAddress 对象,获取对应的地址
String hostAddress = host2.getHostAddress();//IP
System.out.println("host2 对应的IP =" + hostAddress);//183.232.231.172
//5. 通过 InetAddress 对象,获取对应的主机名/域名
String hostName = host2.getHostName();
System.out.println("host2 对应的主机名/域名=" + hostName);//www.baidu.com
}
}
电脑【1.获取本地的信息[主机名/IP];2.通过域名获取远程服务器的IP】------> 服务器
三、Socket
基本介绍
1、套接字(Socket
)开发网络应用程序被广泛采用,以至于成为事实上的标准。
2、通信的两端都要有Socket
,是两台机器间通信的端点
3、网络通信其实是就是Socket
间的通信。
4、Socket
允许程序把网络连接当成一个流,数据在两个Socket
间通过IO流传输
5、一般主动发起通信的应用程序属于 客户端,等待通信请求的为 服务端
示意图:
四、TCP 网络通信编程
基本介绍
1、基于客户端–服务端的网络通信
2、底层使用的是 TCP/IP 协议
3、应用场景举例:客户端发生数据,服务端接收并显示控制台
4、基于Socket
的TCP编程
应用案例1(使用字节流)
1、编写一个服务器端,和一个客户端
2、服务器端在 9999端口监听
3、客户端连接到服务器端,发生 “hello,server”,然后退出
4、服务器端接收到 客户端发生的 信息,输出,并退出
示意图:注意写的是两个程序,服务器端 和 客户端
package com.zzpedu.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端口监听,等待连接
// 细节:new ServerSocket(9999) 要求在本机9999端口 没有其它服务在监听9999
// 细节:这个 serverSocket 通过 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[] bytes = new byte[1024];
int readLen = 0;
while ((readLen = inputStream.read(bytes)) != -1){
//根据读取到的实际长度,显示内容
System.out.println(new String(bytes,0,readLen));
}
//5. 关闭流和socket
inputStream.close();
socket.close();
serverSocket.close();//关闭
System.out.println("服务端退出了...");
}
}
package com.zzpedu.socket;
import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
/**
* 客户端 发送 "hello,server" 给服务端
*/
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("客户端退出了...");
}
}
运行效果:
应用案例2(使用字节流)
1、编写一个服务器端,和一个客户端
2、服务器端在 9999端口监听
3、客户端连接到服务器端,发送 “hello,server”,并接收服务器端回发的 “hello,client” ,在退出
4、服务器端收到 客户端发送的 信息,输出,并发送 “hello,client”,在退出
示意图:
/**
* 服务器端
*/
@SuppressWarnings({"all"})
public class SocketTCP02Server {
public static void main(String[] args) throws IOException {
//思路:
//1. 在本机 的9999端口监听,等待连接
// 细节:new ServerSocket(9999) 要求在本机9999端口 没有其它服务在监听9999
// 细节:这个 serverSocket 通过 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[] bytes = new byte[1024];
int readLen = 0;
while ((readLen = inputStream.read(bytes)) != -1){
//根据读取到的实际长度,显示内容
System.out.println(new String(bytes,0,readLen));
}
//5. 获取socket相关联的输出流
OutputStream outputStream = socket.getOutputStream();
outputStream.write("hello,client".getBytes());
// 设置写入结束标记
socket.shutdownOutput();
//6. 关闭流和socket
inputStream.close();
outputStream.close();
socket.close();
serverSocket.close();//关闭
System.out.println("服务端退出了...");
}
}
/**
* 客户端 发送 "hello,server" 给服务端
*/
@SuppressWarnings({"all"})
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[] bytes = new byte[1024];
int readLen = 0;
while ((readLen = inputStream.read(bytes)) != -1){
System.out.println(new String(bytes,0,readLen));
}
//5. 关闭流对象和socket,必须关闭
outputStream.close();
inputStream.close();
socket.close();
System.out.println("客户端退出了...");
}
}
运行效果:
应用案例3(使用字符流)
1、编写一个服务器端,和一个客户端
2、服务器端在 9999端口监听
3、客户端连接到服务器端,发送 “hello,server”,并接收服务器端回发的 “hello,client” ,在退出
4、服务器端收到 客户端发送的 信息,输出,并发送 “hello,client”,在退出
示意图:
/**
* 服务器端 使用字符流 方式读写
*/
@SuppressWarnings({"all"})
public class SocketTCP03Server {
public static void main(String[] args) throws IOException {
//思路:
//1. 在本机 的9999端口监听,等待连接
// 细节:new ServerSocket(9999) 要求在本机9999端口 没有其它服务在监听9999
// 细节:这个 serverSocket 通过 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 br = new BufferedReader(new InputStreamReader(inputStream));
String s = br.readLine();
System.out.println(s);//输出
//5. 获取socket相关联的输出流
OutputStream outputStream = socket.getOutputStream();
// 使用字符流输出流的方式回复信息
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
bw.write("hello,client 字符流");
bw.newLine();//插入一个换行符,表示回复的内容结束,注意,要求对方使用readLine()方式!!!
bw.flush();//如果使用字符流,需要手动刷新,否则数据不会写入数据通道
//6. 关闭流和socket
bw.close();
br.close();
socket.close();
serverSocket.close();//关闭
System.out.println("服务端退出了...");
}
}
/**
* 客户端 发送 "hello,server" 给服务端,使用字符流 方式读写
*/
@SuppressWarnings({"all"})
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 bw = new BufferedWriter(new OutputStreamWriter(outputStream));
bw.write("hello,server 字符流");
bw.newLine();//插入一个换行符,表示写入的内容结束,注意,要求对方使用readLine()方式!!!
bw.flush();//如果使用字符流,需要手动刷新,否则数据不会写入数据通道
//4. 获取socket关联的输入流,读取数据,使用字符流,并显示
InputStream inputStream = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
String s = br.readLine();
System.out.println(s);//输出
//5. 关闭流对象和socket,必须关闭
br.close();
bw.close();
socket.close();
System.out.println("客户端退出了...");
}
}
运行效果:
应用案例4(上传文件)
1、编写一个服务端,和一个客户端
2、服务器端在 8888端口监听
3、客户端连接到服务端,发送 一张图片 F:\data\45.jpg
4、服务器端接收到 客户端发送的图片,保存到 src下,发送 “收到图片” 再退出
5、客户端收到服务器端发送的 “收到图片”,在退出
6、该程序要求使用 StreamUtils.java
说明:使用BufferedInputStream 和 BufferedOutputStream 字节流
示意图:
/**
* 此类用于演示关于流的读写方法
*/
public class StreamUtils {
/**
* 功能:将输入流转成 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对象
}
//然后将bos 转成 字节数组
byte[] array = bos.toByteArray();
bos.close();
return array;
}
/**
* 功能: 将InputStream转换成String
* @param is
* @return
* @throws IOException
*/
public static String streamToString(InputStream is) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
StringBuilder sb = new StringBuilder();
String line;
while ((line = reader.readLine()) != null){//当读取到 null,就表示结束
sb.append(line + "\r\n");
}
return sb.toString();
}
}
/**
* 文件上传的服务端
*/
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得到输入流
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
byte[] bytes = StreamUtils.streamToByteArray(bis);
//4. 将得到 bytes 数组,写入到指定的路径,就得到一个文件了
String destFilePath = "src\\45.jpg";
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.close();
bis.close();
socket.close();
serverSocket.close();
}
}
/**
* 文件上传的客户端
*/
public class TCPFileUploadClient {
public static void main(String[] args) throws Exception {
//客户端连接服务端 8888,得到Socket对象
Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
//创建读取磁盘文件的输入流
String filePath = "F:\\data\\45.jpg";
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
//bytes 就是 filePath 对应的字节数组
byte[] bytes = StreamUtils.streamToByteArray(bis);
//通过socket获取到输出流,将bytes数据发送到服务端
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
bos.write(bytes);//将文件对应字节数组的内容,写入到数据通道
bis.close();
//设置写入数据的结束标记
socket.shutdownOutput();
// 接收从服务端回复的信息
InputStream inputStream = socket.getInputStream();
//使用StreamUtils 的方法,直接将 inputStream 读取到的内容 转成字符串
String s = StreamUtils.streamToString(inputStream);
System.out.println(s);
//关闭相关流
inputStream.close();
bos.close();
socket.close();
}
}
运行效果:
netstat 指令
1、netstat -an
可以查看当前主机网络情况,包括端口监听情况和网络连接情况
2、netstat -an | more 可以分页显示
3、要求在dos控制台下执行 快捷键 win + r
说明:
(1)Listening 表示某个端口在监听
(2)如果有一个外部程序(客户端)连接到该接口,就会显示一条连接信息。
(3)可以输入 ctrl + c
退出指令
测试:启动服务端 8888
在dos控制台,输入 netstat -an | more
netstat -anb | more
– 要以管理员身份 执行,可以 查看哪个一个程序在监听端口
TCP网络通讯不为人知的秘密
1、当客户端连接服务端后,实际上客户端也是通过一个端口号和服务端进行通讯的,这个端口号是由 TCP/IP 来分配的,是不确定的,是随机的
2、示意图
3、程序验证 + netstat
在TCPFileUploadServer类和TCPFileUploadClient类准备一个大点的文件,
然后在idea窗口的Terminal 终端执行 netstat -an | more
命令
五、UDP 网络通信编程
基本介绍
1、类 DatagramSocket
和 DatagramPacket
[数据包/数据报] 实现了基于 UDP
协议网络程序。
2、UDP
数据报通过数据报套接字 DatagramSocket
发送和接收,系统不保证 UDP
数据报一定能够安全送到目的地,也不能确定什么时候可以抵达。
3、DatagramPacket
对象封装了 UDP
数据报,在数据报中含了发送端的 IP地址和端口号以及接收端的 IP地址和端口号
4、UDP
协议中每个数据报都给出了完整的地址信息,因此无须建立发送方和接收方的连接
示意图:
基本流程
1、核心的两个类/对象 DatagramSocket
和 DatagramPacket
2、建立发送端,接收端(没有服务端和客户端概念)
3、发生数据前,建立数据包/报,DatagramPacket
对象
4、调用 DatagramSocket
的发送、接收方法
5、关闭 DatagramSocket
应用案例
1、编写一个接收端A,和一个发送端B
2、接收端A在 9999端口等待接收数据(receive)
3、发送端B向接收端A 发送 数据 “hello,明天去吃火锅~”
4、接收端A收到 发送端B发送的数据,回复 “好的,明天见”,再退出
5、发送端接收 回复的数据,再退出
/**
* UDP接收端A
*/
public class UDPReceiverA {
public static void main(String[] args) throws IOException {
//1. 创建一个 DatagramSocket 对象,准备在9999端口接收数据
DatagramSocket socket = new DatagramSocket(9999);
//2. 构建一个DatagramPacket 对象,准备接收数据
// 在前面讲解UDP 协议时,UDP一个数据包,最大 64k
byte[] buf = new byte[64 * 1024];
DatagramPacket packet = new DatagramPacket(buf,buf.length);
//3. 调用 接收方法,通过网络传输的 DatagramPacket 对象
// 填充到 packet对象
//提示:当有数据包发生到 本机9999端口时,receive()方法就会接收数据到packet
// 如果没有数据包发送到 本机9999端口时,就会阻塞等待...
System.out.println("接收端A 等待接收数据....");
socket.receive(packet);
//4. 可以把packet 进行拆包,取出数据并显示
int length = packet.getLength();//实际接收到的数据字节长度
byte[] data = packet.getData();//接收到的数据
String str = new String(data, 0, length);
System.out.println("接收端A 接收到的数据=" + str);
//==== 回复信息给B端 =====
data = "好的,明天见".getBytes();
//说明:封装的 DatagramPacket对象,data 内容字节数组; data.length 字节长度; 主机(ip); 端口
packet = new DatagramPacket(data,data.length, InetAddress.getByName("192.168.1.7"),9998);
// 发送
socket.send(packet);
//5. 关闭资源
socket.close();
System.out.println("接收端A 退出!");
}
}
/**
* UDP发送端B ===> 也可以接收数据
*/
public class UDPSenderB {
public static void main(String[] args) throws IOException {
//1. 创建一个 DatagramSocket 对象,准备在 9998端口 发送和接收数据
DatagramSocket socket = new DatagramSocket(9998);
//2. 将要发送的数据,封装到 DatagramPacket对象中
System.out.println("发送端B,准备发送数据....");
byte[] data = "hello,明天去吃火锅~".getBytes();
//说明:封装的 DatagramPacket对象,data 内容字节数组; data.length 字节长度; 主机(ip); 端口
DatagramPacket packet =
new DatagramPacket(data,data.length, InetAddress.getByName("192.168.1.7"),9999);
// 发送
socket.send(packet);
System.out.println("发送端B,发送数据完毕!");
//==== 接收从A端回复的数据 ====
//(1) 构建一个DatagramPacket 对象,准备接收数据
// UDP一个数据包,最大 64k
byte[] buf = new byte[64 * 1024];
packet = new DatagramPacket(buf,buf.length);
//(2) 调用 接收方法,通过网络传输的 DatagramPacket 对象
// 填充到 packet对象
//提示:当有数据包发生到 本机9998端口时,receive()方法就会接收数据到packet
// 如果没有数据包发送到 本机9998端口时,就会阻塞等待...
socket.receive(packet);
//(3) 可以把packet 进行拆包,取出数据并显示
int length = packet.getLength();//实际接收到的数据字节长度
data = packet.getData();//接收到的数据
String str = new String(data, 0, length);
System.out.println("发送端B 接收到的回复数据=" + str);
//关闭资源
socket.close();
System.out.println("发送端B,退出!");
}
}
运行效果:
netstat -an
命令执行:
作业
1、编程题
(1)使用字符流的方式,编写一个客户端程序和服务器端程序
(2)客户端发送 “name”,服务器端接收后,返回 “我是 nova”,nova 是你的名字
(3)客户端发送 “hobby”,服务器接收到后,返回 “编写java程序”
(4)不是这两个问题,回复 “你说啥呢”
/**
* 服务器端 使用字符流 方式读写
*/
@SuppressWarnings({"all"})
public class Homework01Server{
public static void main(String[] args) throws IOException {
//思路:
//1. 在本机 的9999端口监听,等待连接
// 细节:new ServerSocket(9999) 要求在本机9999端口 没有其它服务在监听9999
// 细节:这个 serverSocket 通过 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 br = new BufferedReader(new InputStreamReader(inputStream));
String str = br.readLine();
System.out.println(str);//输出
String answer = "";
if("name".equals(str)){
answer = "我是 zzp先生";
}else if("hobby".equals(str)){
answer = "编写java程序";
}else {
answer = "你说啥呢";
}
//5. 获取socket相关联的输出流
OutputStream outputStream = socket.getOutputStream();
// 使用字符流输出流的方式回复信息
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(outputStream));
bw.write(answer);
bw.newLine();//插入一个换行符,表示回复的内容结束,注意,要求对方使用readLine()方式!!!
bw.flush();//如果使用字符流,需要手动刷新,否则数据不会写入数据通道
//6. 关闭流和socket
bw.close();
br.close();
socket.close();
serverSocket.close();//关闭
System.out.println("服务端退出了...");
}
}
/**
* 客户端 ,使用字符流 方式读写
*/
@SuppressWarnings({"all"})
public class Homework01Clientr{
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 bw = new BufferedWriter(new OutputStreamWriter(outputStream));
//从键盘读取用户的问题
Scanner scanner = new Scanner(System.in);
System.out.println("请输入您的问题:");
String question = scanner.next();
bw.write(question);
bw.newLine();//插入一个换行符,表示写入的内容结束,注意,要求对方使用readLine()方式!!!
bw.flush();//如果使用字符流,需要手动刷新,否则数据不会写入数据通道
//4. 获取socket关联的输入流,读取数据,使用字符流,并显示
InputStream inputStream = socket.getInputStream();
BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
String s = br.readLine();
System.out.println(s);//输出
//5. 关闭流对象和socket,必须关闭
br.close();
bw.close();
socket.close();
System.out.println("客户端退出了...");
}
}
运行效果:
2、编程题
(1)编写一个接收端A,和一个发送端B,使用UDP协议完成
(2)接收端在 8888端口等待接收数据(receive)
(3)发送端向接收端 发送 数据 “四大名著是哪些”
(4)接收端接收到 发送端的 问题后,返回 “四大名著是《西游记》…”,否则返回what?
(5)接收端和发送端程序退出
/**
* UDP接收端A
*/
@SuppressWarnings({"all"})
public class Homework02ReceiverA {
public static void main(String[] args) throws IOException {
//1. 创建一个 DatagramSocket 对象,准备在8888端口接收数据
DatagramSocket socket = new DatagramSocket(8888);
//2. 构建一个DatagramPacket 对象,准备接收数据
// 在前面讲解UDP 协议时,UDP一个数据包,最大 64k
byte[] buf = new byte[64 * 1024];
DatagramPacket packet = new DatagramPacket(buf,buf.length);
//3. 调用 接收方法,通过网络传输的 DatagramPacket 对象
// 填充到 packet对象
System.out.println("接收端A,等待接收问题...");
socket.receive(packet);
//4. 可以把packet 进行拆包,取出数据并显示
int length = packet.getLength();//实际接收到的数据字节长度
byte[] data = packet.getData();//接收到的数据
String str = new String(data, 0, length);
//判断接收到的信息是什么
String answer = "";
if("四大名著是哪些".equals(str)){
answer = "四大名著 《红楼梦》《西游记》《三国演义》《水浒传》";
}else {
answer = "what?";
}
//==== 回复信息给B端 =====
data =answer.getBytes();
//说明:封装的 DatagramPacket对象,data 内容字节数组; data.length 字节长度; 主机(ip); 端口
packet = new DatagramPacket(data,data.length, InetAddress.getByName("192.168.1.7"),9998);
// 发送
socket.send(packet);
//5. 关闭资源
socket.close();
System.out.println("接收端A 退出!");
}
}
/**
* UDP发送端B ===> 也可以接收数据
*/
@SuppressWarnings({"all"})
public class Homework02SenderB {
public static void main(String[] args) throws IOException {
//1. 创建一个 DatagramSocket 对象,准备在 9998端口 发送和接收数据
DatagramSocket socket = new DatagramSocket(9998);
//2. 将要发送的数据,封装到 DatagramPacket对象中
Scanner scanner = new Scanner(System.in);
System.out.println("请求输入您的问题:");
String question = scanner.next();
byte[] data = question.getBytes();
//说明:封装的 DatagramPacket对象,data 内容字节数组; data.length 字节长度; 主机(ip); 端口
DatagramPacket packet =
new DatagramPacket(data,data.length, InetAddress.getByName("192.168.1.7"),8888);
// 发送
socket.send(packet);
//==== 接收从A端回复的数据 ====
//(1) 构建一个DatagramPacket 对象,准备接收数据
// UDP一个数据包,最大 64k
byte[] buf = new byte[64 * 1024];
packet = new DatagramPacket(buf,buf.length);
//(2) 调用 接收方法,通过网络传输的 DatagramPacket 对象
// 填充到 packet对象
//提示:当有数据包发生到 本机9998端口时,receive()方法就会接收数据到packet
// 如果没有数据包发送到 本机9998端口时,就会阻塞等待...
socket.receive(packet);
//(3) 可以把packet 进行拆包,取出数据并显示
int length = packet.getLength();//实际接收到的数据字节长度
data = packet.getData();//接收到的数据
String str = new String(data, 0, length);
System.out.println("发送端B 接收到的回复数据=" + str);
//关闭资源
socket.close();
System.out.println("发送端B,退出!");
}
}
运行效果:
3、编程题
(1)编写客户端程序和服务器端程序
(2)客户端可以输入 一个 音乐 文件名,比如 xxx,服务端 收到音乐名后,可以给客户端 返回这个 音乐文件,如果服务器没有这个文件,返回 一个默认的音乐即可
(3)客户端接收到文件后,保存到本地 f:\data
(4)提示:该程序可以使用 StreamUtils.java
/**
* 此类用于演示关于流的读写方法
*/
public class StreamUtils {
/**
* 功能:将输入流转成 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对象
}
//然后将bos 转成 字节数组
byte[] array = bos.toByteArray();
bos.close();
return array;
}
/**
* 功能: 将InputStream转换成String
* @param is
* @return
* @throws IOException
*/
public static String streamToString(InputStream is) throws IOException {
BufferedReader reader = new BufferedReader(new InputStreamReader(is));
StringBuilder sb = new StringBuilder();
String line;
while ((line = reader.readLine()) != null){//当读取到 null,就表示结束
sb.append(line + "\r\n");
}
return sb.toString();
}
}
/**
* 服务端 文件下载
*/
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();
byte[] b = new byte[1024];
int len = 0;
StringBuilder downLoadFileName = new StringBuilder();
//这里使用了 while读取文件,是考虑将来客户端发送的数据较大的情况下
while ((len = inputStream.read(b)) != -1){
downLoadFileName.append(new String(b,0,len));
}
System.out.println("客户端希望下载文件名=" + downLoadFileName);
//在服务器上传两个文件,xxx.mp3 无名.mp3
//如果客户端下载的是 xxx 我们就返回该文件,否则返回 default.mp3
String resFileName = "";
if("xxx".equals(downLoadFileName.toString())){
resFileName = "src\\xxx.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. 关闭相关资源
bos.close();
bis.close();
inputStream.close();
socket.close();
serverSocket.close();
System.out.println("服务端退出~");
}
}
/**
* 客户端 文件下载
*/
public class Homework03Client {
public static void main(String[] args) throws Exception {
//1. 接收用户输入,指定下载文件
Scanner scanner = new Scanner(System.in);
System.out.println("请求下载文件名:");
String downFileName = scanner.next();
//2. 客户端连接服务端,准备发送
Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
//3. 获取和socket关联的输出流
OutputStream outputStream = socket.getOutputStream();
outputStream.write(downFileName.getBytes());
//设置写入结束标记
socket.shutdownOutput();
//4. 读取服务端返回的文件(字节数据)
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
byte[] bytes = StreamUtils.streamToByteArray(bis);
//5. 得到一个输出流,准备将 bytes 写入到磁盘文件
String filePath = "f:\\data\\" + downFileName + ".mp3";
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(filePath));
bos.write(bytes);
//6. 关闭相关资源
bos.close();
bis.close();
outputStream.close();
socket.close();
System.out.println("客户端下载完毕,退出~");
}
}
运行效果: