Java网络编程
1. 网络的相关概念
1.1 网络通信
- 概念:两台设备之间通过网络实现数据传输
- 网络通信: 将数据通过网络从一台设备传输到另一台设备
- java.net包下提供了一系列的类或接口,供程序员使用,完成网络通信
1.2 网络
- 概念:两台或多台设备通过一定物理设备连接起来构成了网络;
- 根据网络的覆盖范围不同,对网络进行分类:
- 局域网:覆盖范围最小,仅仅覆盖一个教室或一个机房
- 城域网:覆盖范围较大,可以覆盖个城市
- 广域网:覆盖范围最大,可以覆盖全国,甚至全球,万维网是广域网的代表
1.3 ip 地址
- 概念: 用于唯一标识网络中的每台计算机/主机
- 查看ip地址: ipconfig
- ip地址的表示形式:点分十进制 xx.xx.xx.xx
- 每一个十进制数的范围:0~255
- ip地址的组成=网络地址+主机地址,比如: 192.168.16.69
- IPv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议,其地址数量号称可以为全世界的每一粒沙子编上一个地址[1]
- 由于IPv4最大的问题在于网络地址资源有限,严重制约了互联网的应用和发展。IPv6的使用,不仅能解决网络地址资源数量的问题,而且也解决了多种接入设备连入互联网的障碍
1.4 ipv4 地址分类
1.5 域名
- 例如:www.baidu.com
- 好处:为了方便记忆,解决记ip的困难
- 概念:将ip地址映射成域名,这里怎么映射上,HTTP协议
端口号:
- 概念: 用于标识计算机上某个特定的网络程序
- 表示形式: 以整数形式,端口范围0~65535【2个字节表示端口 0~2^16-1]
- 0~1024已经被占用,比如 ssh 22 , ftp 21 , smtp 25 , http 80
- 常见的网络程序端口号:
- tomcat :8080
- mysql:3306
- oracle:1521
- sqlserver:1433
1.6 网络通信协议
网络协议的理解
- 在生活中,人与人之间的交流(通讯)依靠语言[中文,英文,日语。。。]
- 上面所述的语言本身就是一种协议;
- 通俗的讲,人与人之间的语言交流就类似计算机中程序与程序之间的数据传输;
- 在网络编程中,数据的组织形式就是协议;
- 回复数据的时候也需要按照规定好的协议方式;
协议(tcp/ip)
- TCP/IP是英文 Transmission ControlProtocol/Internet Protocol 的简写
- 中文译名为: 传输控制协议/因特网互联协议 ,又叫网络通讯协议;
- 这个协议是Internet最基本的协议、Internet国际互联网络的基础
- 简单地说,就是由网络层的IP协议和传输层的TCP协议组成的。[示意图]
1.7 TCP 和 UDP
TCP协议: 传输控制协议
- 使用TCP协议前,须先建立TCP连接,形成传输数据通道
- 传输前,采用"三次握手"方式,是可靠的
- TCP协议进行通信的两个应用进程: 客户端、服务端
- 在连接中可进行大数据量的传输
- 传输完毕,需释放已建立的连接,效率低
- 举例:给一个人打电话,等打通了以后:
- 先问对方在不在听,对方回应正在听,然后告诉对方接下来有事情要说(三次握手),接下来才开始说正事。。。
UDP协议: 用户数据协议
- 将数据、源、目的封装成数据包,不需要建立连接
- 每个数据包的大小限制在64K内,不适合传输大量数据
- 因无需连接,故是不可靠的
- 发送数据结束时无需释放资源(因为不是面向连接的),速度快
- 举例: 厕所通知、给一个未经确认的手机号码发短信
2. InetAddress 类
2.1 相关方法
-
获取本机InetAddress对象 getLocalHost
-
根据指定主机名/域名获取ip地址对象 getByName
-
获取InetAddress对象的主机名 getHostName
-
获取InetAddress对象的地址 getHostAddress
-
简单的代码演示:
public class API_ { //演示 InetAddress 类的使用 public static void main(String[] args) throws UnknownHostException { //1. 获取本机InetAddress对象 getLocalHost InetAddress localHost = InetAddress.getLocalHost(); System.out.println(localHost);//DREAM/192.168.0.106 //2. 根据指定主机名/域名获取ip地址对象 getByName //根据主机名 InetAddress host1 = InetAddress.getByName("DREAM"); System.out.println(host1);//DREAM/192.168.0.106 //根据域名 InetAddress host2 = InetAddress.getByName("www.baidu.com"); System.out.println(host2);//www.baidu.com/36.152.44.96 //3. 获取InetAddress对象的主机名 getHostName String hostName = host2.getHostName(); System.out.println("host2对应的地址 =" + hostName); //host2对应的地址 =www.baidu.com //4. 获取InetAddress对象的地址 getHostAddress String hostAddress = host2.getHostAddress(); System.out.println("host2对应的ip =" + hostAddress); //host2对应的ip =36.152.44.95 } }
3. Socket
3.1 基本介绍
- 套接字(Socket)开发网络应用程序被广泛采用,以至于成为事实上的标准。
- 通信的两端都要有Socket,是两台机器间通信的端点
- 网络通信其实就是Socket间的通信。
- Socket允许程序把网络连接当成一个流,数据在两个Socket间通过IO传输
- 一般主动发起通信的应用程序属客户端,等待通信请求的为服务端
- socket有两种编程:TCP编程(可靠的)和UDP编程(不可靠的)
- 示意图如下:
4. TCP 网络通信编程
4.1 基本介绍
- 基于客户端一服务端的网络通信
- 底层使用的是TCP/IP协议
- 应用场景举例: 客户端发送数据,服务端接受并显示控制台
- 基于Socket的TCP编程
4.2 应用案例
案例一
- 编写一个服务器端,和一个客户端
- 服务器端在 9999端口监听
- 客户端连接到服务器端,发送“hello,server”,然后退出
- 服务器端接收到 客户端发送的 信息,输出,并退出
思路:
客户端:
- 连接服务端(ip,端口)
- 连接上后,生成Socket,通过socket.getOutputStream()
- 通过输出流写数据到数据通道
- 客户端代码:
public class SocketTCP01Cilent {
//客户端
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());
//关闭流
outputStream.close();
socket.close();
System.out.println("客户端退出...");
}
}
服务器端:
- 在本机的9999端口监听,等待连接
- 当没有客户连接9999端口的时候,程序会阻塞,等待连接
- 通过socket.getInputStream()读取客户端写入到数据通道的数据,显示
- 服务器端代码:
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. 读取
byte[] buf = new byte[1024];
int readLen = 0;
while ((readLen = inputStream.read(buf)) != -1) {
System.out.println(new String(buf, 0, readLen));
}
//5. 关闭流
inputStream.close();
socket.close();
serverSocket.close();
}
}
案例二(使用字节流)
- 编写一个服务端,和一个客户端
- 服务器端在 9999端口监听
- 客户端连接到服务端,发送“hello,server”,并接收服务器端回发的"hello,client”再退出
- 服务器端接收到 客户端发送的 信息,输出,并发送“hello,client”,再退出
- 当我们双方都有发送信息的时候,要设置结束标记 socket.shutdownOutput();
思路:
- 相当于在案例一的代码上进行一个升级
- 增加一些相应的代码
客户端增加:
- 增加一个socket.getInputStream()
- 读取数据通道的数据
- 显示
- 关闭socket和io
- 客户端代码:
public class SocketTCP02Cilent {
//客户端
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();
//1. 增加一个socket.getInputStream()
InputStream inputStream = socket.getInputStream();
//2. 读取数据通道的数据
byte[] buf = new byte[1024];
int readLen = 0;
while ((readLen = inputStream.read(buf)) != -1) {
//3. 显示
System.out.println(new String(buf, 0, readLen));
}
//关闭流
outputStream.close();
inputStream.close();
socket.close();
System.out.println("客户端退出...");
}
}
服务器端添加:
- 增加一个socket.getOutputStream()
- 写入数据到数据通道
- 关闭socket和io
- 服务器端代码:
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. 读取
byte[] buf = new byte[1024];
int readLen = 0;
while ((readLen = inputStream.read(buf)) != -1) {
System.out.println(new String(buf, 0, readLen));
}
//1. 增加一个socket.getOutputStream()
OutputStream outputStream = socket.getOutputStream();
//2. 写入数据到数据通道
outputStream.write("hello,client".getBytes());
//设置结束标记
socket.shutdownOutput();
//5. 关闭流
inputStream.close();
outputStream.close();
socket.close();
serverSocket.close();
}
}
案例三(使用字符流)
- 编写一个服务端,和一个客户端
- 服务端在 9999端口监听
- 客户端连接到服务端,发送“hello, server”并接收服务端回发的”hello,client”再退出
- 服务端接收到 客户端发送的 信息,输出,并发送“hello,client”,再退出
客户端代码:
public class SocketTCP03Cilent {
//客户端
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));
bufferedWriter.write("hello,server~ 字符流");
//插入一个换行符,表示写入的内容结束
//注意:要求对方读取的时候使用readLine()!!!否则读取不到
bufferedWriter.newLine();
bufferedWriter.flush();//刷新一下
//写了newLine()结束就可以不用设置结束标记
//socket.shutdownOutput();
//1. 增加一个socket.getInputStream()
InputStream inputStream = socket.getInputStream();
//2. 读取数据通道的数据
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String line = bufferedReader.readLine();
//3. 显示
System.out.println(line);
//关闭流 一般后面打开的先关闭
bufferedReader.close();
bufferedWriter.close();
socket.close();
System.out.println("客户端关闭...");
}
}
服务端代码:
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();
//3. 通过socket.getInputStream()读取客户端写入到数据通道的数据,显示
InputStream inputStream = socket.getInputStream();
//4. IO读取 ,使用字符流 使用InputStreamReader将inputStream转成字符流
BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
String line = bufferedReader.readLine();
// 显示
System.out.println(line);
//1. 增加一个socket.getOutputStream()
OutputStream outputStream = socket.getOutputStream();
//2. 写入数据到数据通道,使用字符流
BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
bufferedWriter.write("hello,cilent~ 字符流");
bufferedWriter.newLine();//插入一个换行符,表示写入的内容结束
bufferedWriter.flush();//刷新
//写了newLine()结束就可以不用设置结束标记
//socket.shutdownOutput();
//5.关闭流 一般后面打开的先关闭
bufferedWriter.close();
bufferedReader.close();
socket.close();
serverSocket.close();
}
}
案例四
- 编写一个服务端,和一个客户端
- 服务器端在 8888端口监听
- 客户端连接到服务端,发送 一张图片 e: \\gie.png
- 服务器端接收到 客户端发送的 图片,保存到 src下,发送“收到图片”再退出
- 客户端接收到服务端发送的“收到图片”, 再退出
- 该程序要求使用 StreamUtils.java,我们直接使用
StreamUtils工具类
/**
* 此类用于演示关于流的读写方法
*/
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();
}
}
客户端
public class TCPFileUploadCilent {
//文件上传的客户端
public static void main(String[] args) throws Exception {
//1. 连接到服务端8888,得到Socket对象
Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
//2. 创建读取磁盘文件的输入流
String filePath = "e:\\java.png";
BufferedInputStream bis = new BufferedInputStream(new FileInputStream(filePath));
// bytes 就是filePath对应的字节数组
// byte[] bytes = streamToByteArray(bis);
// 使用 StreamUtils 的方法,获取对应的字节数组
byte[] bytes = StreamUtils.streamToByteArray(bis);
//接收服务端发送的消息
InputStream inputStream = socket.getInputStream();
//使用 StreamUtils 的方法,直接将 inputStream 读取到的内容 转成字符串
String s = StreamUtils.streamToString(inputStream);
//输出收到的信息
System.out.println(s);
//通过socket获取到输出流,将bytes数据发送给服务端
BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
//将文件对应的字节数组写入到数据通道
bos.write(bytes);
//关闭流
bis.close();
//设置写入数据的结束标记
socket.shutdownOutput();
//关闭相应的流
bos.close();
socket.close();
System.out.println("退出客户端...");
}
//我们先创建一个方法,用于保存图片
// 可以将其单独创建为一个类StreamUtils,然后直接调用
/*
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;
}
*/
}
服务端
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 = streamToByteArray(bis);
// 使用 StreamUtils 的方法,获取对应的字节数组
byte[] bytes = StreamUtils.streamToByteArray(bis);
//4. 将得到的bytes数组,写入到指定的路径,就得到一个文件了
String destFilePath = "src\\java2.png";
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
bos.write(bytes);
//向客户端发送信息
//通过socket得到输出流
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
bw.write("收到图片");
bw.flush();//刷新
//设置结束标记
socket.shutdownOutput();
//关闭流
bos.close();
//设置写入数据的结束标记
socket.shutdownOutput();
//关闭对应的流
bw.close();
bis.close();
socket.close();
serverSocket.close();
}
// 还是可以用客户端相同的方法用于接收客户端发送过来的文件
// 可以将其单独创建为一个类StreamUtils,然后直接调用
/*
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;
}
*/
}
4.3 netstat 指令
4.3.1 介绍
- netstat -an 可以查看当前主机网络情况,包括端口监听情况和网络连接情况
- netstat -an]more 可以分页显示
- 要求在dos控制台下执行 win+r
- 说明:
- Listening 表示某个端口在监听
- 如果有一个外部程序(客户端)连接到该端口,就会显示一条连接信息
- 可以输入ctrl + c 退出指令
4.3.2 TCP网络通讯不为人知的秘密
- 当客户端连接到服务端后,实际上客户端也是通过一个端口和服务端进行通讯的,这
个端口是TCP/IP 来分配的, 是不确定的,是随机的. - 示意图
- 程序验证+netstat
5. 网络通信编程[了解]
5.1 基本介绍
- 类 DatagramSocket 和 DatagramPacket[数据包/数据报] 实现了基于 UDP协议网络程序。
- UDP数据报通过数据报套接字 DatagramSocket 发送和接收,系统不保证UDP数据报一定能够安全送到目的地,也不能确定什么时候可以抵达。
- DatagramPacket 对象封装了UDP数据报,在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号。
- UDP协议中每个数据报都给出了完整的地址信息,因此无须建立发送方和接收方的连接
5.2 基本流程
- 核心的两个类/对象 DatagramSocket与DatagramPacket
- 建立发送端,接收端(没有服务端和客户端概念)
- 发送数据前,建立数据包/报 DatagramPacket对象
- 调用DatagramSocket的发送、接收方法
- 关闭DatagramSocket
- 类图如下
5.3 UDP网络编程原理
UDP说明:
- 没有明确的服务和客户端,演变成数据的发送端和接收端
- 接收数据和发送数据是通过 DatagramSocket 对象完成
- 将数据封装到 DatagramPacket 对象/装包
- 当接收到 DatagramPacket 对象,需要进行拆包,取出数据
- DatagramSocket 可以指定在哪个端口接受数据
- UDP网络编程原理示意图如下
5.4 应用案例
5.4.1 案例一
- 编写一个接收端A,和一个发送端B
- 接收端A在 9999端口等待接收数据(receive)
- 发送端B向接收端A 发送 数据“hello,明天吃火锅~“
- 接收端A接收到 发送端B发送的数据,回复“好的,明天见”再退出
- 发送端接收 回复的数据,再退出
- 代码演示
接收端A
public class UDPReceiverA {
//接收端 A
public static void main(String[] args) throws IOException {
//1. 创建一个 DatagramSocket 对象,准备在9999端口接收数据
DatagramSocket socket = new DatagramSocket(9999);
//2. 构建一个 DatagrmaPacket 对象,准备接收数据
// 每个数据包的大小限制在64K内
byte[] buf = new byte[1024];
DatagramPacket packet = new DatagramPacket(buf, 0, 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
String s = new String(data, 0, length);
//显示内容
System.out.println(s);
//5. 进行数据发送
byte[] data2 = "好的 B,明天见".getBytes();
// new DatagramPacket(data, data.length, 主机, 端口)
// 本机电脑IP地址 192.168.0.106
packet = new DatagramPacket(data2, data2.length,
InetAddress.getByName("192.168.0.106"), 9998);
socket.send(packet);
//6. 关闭资源
socket.close();
System.out.println("接收端A退出...");
}
}
发送端B
public class UDPSenderB {
//发送端 B
public static void main(String[] args) throws IOException {
//1. 创建一个 DatagramSocket 对象,准备在9998端口接收数据
DatagramSocket socket = new DatagramSocket(9998);
//2. 将需要发送的数据,封装到 DatagramPacket 对象中
// 先创建一个数组用于保存内容
byte[] data = "hello A,明天吃火锅~".getBytes();
//说明:封装到 DatagramPacket 对象的 data 内容字节数组 ,data.length , 主机(ip),端口
// new DatagramPacket(data, data.length, 主机, 端口)
// 本机电脑IP地址 192.168.0.106
DatagramPacket packet = new DatagramPacket(data, data.length,
InetAddress.getByName("192.168.0.106"), 9999);
socket.send(packet);
//3. 进行数据接收
byte[] buf2 = new byte[1024];
packet = new DatagramPacket(buf2, 0, buf2.length);
//4. 调用接收方法,将网络传输的 DatagramPacket 对象
// 填充到 packet 对象
socket.receive(packet);
//5. 可以把 packet 进行拆包,取出数据并显示。
int length = packet.getLength();//取出数据长度
byte[] data1 = packet.getData();//取出数据内容
//构建一个String
String s = new String(data1, 0, data1.length);
//显示内容
System.out.println(s);
//6. 关闭资源
socket.close();
System.out.println("发送端B退出...");
}
}
6. 练习题
练习一
- 使用字符流的方式,编写一个客户端程序和服务器端程序
- 客户端发送“name”,服务器端接收到后,返回“我是 nova "nova 是你自己的名字
- 客户端发送“hobby”,服务器端接收到后,返回“编写java程序”
- 不是这两个问题,回复你说啥呢”
客户端:
public class Homework01Cilent {
//客户端
public static void main(String[] args) throws IOException {
Socket socket = new Socket(InetAddress.getLocalHost(), 8888);
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.newLine();
//刷新
bw.flush();
//写了newLine()结束就可以不用设置结束标记
//socket.shutdownOutput();
//接收服务端的信息
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String line = br.readLine();
System.out.println(line);
//关闭流
bw.close();
socket.close();
}
}
服务端:
public class Homework01Server {
//服务端
public static void main(String[] args) throws IOException {
ServerSocket serverSocket = new ServerSocket(8888);
Socket socket = serverSocket.accept();
BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
String line = br.readLine();
String answer = "";
if ("name".equals(line)) {
answer = "我是nova";
} else if ("hobby".equals(line)) {
answer = "编写java程序";
} else {
answer = "你说啥呢?";
}
BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
//根据客户的问题作出相应的回答
bw.write(answer);
bw.newLine();
bw.flush();
//写了newLine()结束就可以不用设置结束标记
//socket.shutdownOutput();
//关闭流
bw.close();
br.close();
socket.close();
serverSocket.close();
}
}
练习二
- 编写一个接收端A,和一个发送端B,使用UDP协议完成
- 接收端在 8888端口等待接收数据(receive)
- 发送端向接收端 发送 数据“四大名著是哪些"
- 接收端接收到 发送端发送的 问题后,返回“四大名著是<<红楼梦>> …”否则返回what?
- 接收端和发送端程序退出
接收端:
public class Homework02ReceiveA {
//接收端
public static void main(String[] args) throws IOException {
DatagramSocket socket = new DatagramSocket(8888);
//接收数据
System.out.println("接收端等待接收...");
byte[] buf = new byte[1024];
DatagramPacket packet = new DatagramPacket(buf, 0, buf.length);
socket.receive(packet);
//接收到的数据进行拆包,并显示
byte[] data = packet.getData();
int length = packet.getLength();
String s = new String(data, 0, length);
String answer = "";
if ("四大名著是哪些".equals(s)) {
answer = "四大名著是<<红楼梦>> ...";
} else {
answer = "what?";
}
byte[] data2 = answer.getBytes();
packet = new DatagramPacket(data2, data2.length,
InetAddress.getByName("192.168.0.106"), 6666);
socket.send(packet);
//关闭资源
socket.close();
}
}
发送端:
public class Homework02SenderB {
//发送端B
public static void main(String[] args) throws IOException {
//1. 创建一个 DatagramSocket 对象,准备在6666端口接收数据
DatagramSocket socket = new DatagramSocket(6666);
//接收用户键盘输入
Scanner scanner = new Scanner(System.in);
System.out.println("请输入你的问题");
String question = scanner.next();
// 先创建一个数组用于保存内容
byte[] bytes = question.getBytes();
//说明:封装到 DatagramPacket 对象的 question 内容字节数组 ,data.length , 主机(ip),端口
DatagramPacket packet = new DatagramPacket(bytes, bytes.length,
InetAddress.getByName("192.168.0.106"), 8888);
socket.send(packet);
//接收数据
byte[] data = new byte[1024];
packet = new DatagramPacket(data, 0, data.length);
socket.receive(packet);
//接收到的数据进行拆包,并显示
int length = packet.getLength();
byte[] data1 = packet.getData();
String s = new String(data1, 0, length);
System.out.println(s);
//关闭资源
socket.close();
}
}
练习三
- 编写客户端程序和服务器端程序
- 客户端可以输入 一个 音乐 文件名,比如 高山流水,服务端 收到音乐名后,可以给客户端 返回这个 音乐文件,如果服务器没有这个文件,返回 一个默认的音乐即可
- 客户端收到文件后,保存到本地 e: \\
- 提示:该程序可以使用 StreamUtils.java
本质:其实就是 指定下载文件的应用.可以利用工具类StreamUtils
工具类StreamUtils
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();
}
}
客户端
public class Homework03Cilent {
//客户端
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(), 8888);
//3. 获取和Socket关联的输出流
OutputStream outputStream = socket.getOutputStream();
outputStream.write(downLoadFileName.getBytes());
// 设置写入结束的标志
socket.shutdownOutput();
//4. 读取服务端返回的文件
BufferedInputStream bis = new BufferedInputStream(socket.getInputStream());
//使用StreamUtils工具类,读取文件到一个字节数组
byte[] bytes = StreamUtils.streamToByteArray(bis);
//5. 得到一个输出流,准备将bytes写入到磁盘文件
// 比如下载的是高山流水,得到的文件名就是 高山流水.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("客户端下载完毕,退出...");
}
}
服务端
public class Homework03Server {
//服务端
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. 读取客户端发送的文件名
// 接收客户端的信息
InputStream inputStream = socket.getInputStream();
// 创建一个数组用于存放信息
byte[] b = new byte[1024];
int line = 0;
//记录文件名
//使用while循环是考虑到客户端发送的文件名比较大的时候
String downLoadFileName = "";
while ((line = inputStream.read(b)) != -1) {
downLoadFileName += new String(b, 0, line);
}
System.out.println("客户端希望下载的文件名 =" + downLoadFileName);
// 在服务器上有两个文件,无名.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. 关闭相关资源
bos.close();
bis.close();
inputStream.close();
socket.close();
serverSocket.close();
System.out.println("服务端退出...");
}
}