学习：韩顺平java—网络编程（第21章）

程序员_小马

已于 2024-05-09 23:44:10 修改

阅读量1.5k

点赞数 48

文章标签：学习 java 网络

于 2024-03-17 10:36:03 首次发布

本文链接：https://blog.csdn.net/weixin_47095832/article/details/136778221

版权

在这里插入图片描述

一、网络基础

网络的相关概念

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)：“这就是全部了，你可以开始处理了。”没有这个明确的结束标记，接收方可能会陷入不确定性，无法准确判断何时可以安全地停止接收数据，从而导致通信问题。因此，结束标记在数据传输中充当了清晰的边界标识，确保信息的完整性和正常处理。

案例三（使用字符流）

在这里插入图片描述

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("客户端下载完毕, 退出...");
}

}

程序员_小马

关注

48
点赞
踩
52

收藏

觉得还不错? 一键收藏
0
评论
学习：韩顺平java—网络编程（第21章）

（1）套接字（Socket）开发网络应用程序被广泛采用，以至于成为事实上的标准（2）通信的两端都要有Socket，是两台机器间通信的端点（3）网络通信其实就是Socket间的通信（4）Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输（5）一般主动发起通信的应用程序属客户端，等待通信请求的为服务端客户端发起连接，服务器端接收请求连接，形成一个数据通道，通过socke获取输入流/输出流，就可以进行数据的读取操作（1）基于客户端—服务端的网络通信。
复制链接

扫一扫