第 21 章网络编程

最新推荐文章于 2024-07-04 22:10:49 发布

青衫..

最新推荐文章于 2024-07-04 22:10:49 发布

阅读量169

点赞数

分类专栏： Java笔记文章标签：网络

原文链接：https://www.bilibili.com/video/BV1fh411y7R8?p=669

版权

Java笔记专栏收录该内容

13 篇文章 0 订阅

订阅专栏

21.1网络的相关概念

21.1.1网络通信

1、概念：两台设备之间通过网络实现数据传输

2、网络通信：将数据通过网络从一台设备传输到另一台设备

3、java.net包下提供了一系列的类或接口，来完成网络通信使用

21.1.2网络

21.1.3ip地址

1、概念：用于唯一标识网络中的每台计算机/主机

2、查看ip地址：(管理员)Dos窗口下输出：ipconfig

3、ip地址的表示形式：点分十进制 xx.xx.xx.xx

4、每一个十进制数的范围:0~255

5、ip地址的组成：网络地址+主机地址，eg：192.168.16.69

6、ipv6是互联网工程任务组设计的用于替代IPv4的下一代IP协议，其地址数量号称可以为全世界的每一粒沙子编上一个地址

21.1.4ipv4地址分类

21.1.5域名

21.1.6网络通信协议

21.1.7TCP和UDP

TCP协议：

1、使用TCP协议前，必须先建立TCP连接，形成传输数据通道

2、传输前，采用“三次握手”方式，证明其可靠

3、TCP协议进行通信的两个应用进程：客户端、服务端

4、在连接中可进行大量数据传输

5、传输完毕，须释放已建立的连接，才能建立下一次连接，效率低。

21.2InetAddress类

21.2.1相关方法

package Ex1;
/*演示InetAddress类的使用*/
import java.net.*;
@SuppressWarnings("unused")
public class InetAddress01 {

	public static void main(String[] args) throws UnknownHostException {
		// TODO Auto-generated method stub
		//1、获取本机InetAddress对象（主机名和IP地址）	//静态方法
		InetAddress localhost = InetAddress.getLocalHost();
		System.out.println(localhost);//LAPTOP-DKIBMF58/192.168.43.195
		
		//2、根据指定主机名 获取 InetAddress对象
		InetAddress host1 = InetAddress.getByName("LAPTOP-DKIBMF58");//
//		InetAddress host1 = InetAddress.getByName("LAPTOP-DKIBMF59");//不知道这样的主机
		System.out.println("host1="+host1);//host1=LAPTOP-DKIBMF58/192.168.43.195
		
		//3、根据域名 返回InetAddress对象，比如www.baidu.com 
		InetAddress host2 = InetAddress.getByName("www.baidu.com");
		System.out.println("host2="+host2);//host2=www.baidu.com/223.109.81.10
		
		//4、通过InetAddress 对象，获取对应地址
		String hostAddress = host2.getHostAddress();//IP:223.109.81.10
		System.out.println("host2 对应的ip = "+hostAddress);//223.109.81.10
		
		//5、通过 InetAddress 对象，获取对应的主机名/或者域名
		String hostName  = host2.getHostName();
		System.out.println("host2对应的主机名/域名="+hostName);//host2对应的主机名/域名=www.baidu.com
	}

}

21.2.2编写代码获取计算机主机名和IP地址相关API

21.3Socket

21.3.1基本介绍

1、套接字(Socket)开发网络应用程序被广泛采用，以至于成为事实上的标准

2、通信的两端都要用Socket,是两台机器间通信的端点

3、网络通信其实就是Socket间的通信

4、Socket允许程序把网络连接当成一个流，数据在两个Socket间通过IO传输

5、一般主动发起通信的应用属于客户端，等待通信请求的为服务端

21.4TCP网络通信编程

21.4.1基本介绍

1、基于客户端--服务端的网络通信

2、底层使用的是TCP/IP协议

3、应用场景距离：客户端发生数据，服务端接受并显示到控制台

4、基于Socket的TCP编程

21.4.2应用案例

1、（使用字节流）

package Ex2;
/*服务端：
 * 1、在本机的9999端口监听，等待连接
 *2、当没有客户端连接9999端口时，程序会阻塞，等待连接
 *3、通过socket.getInputStream()读取客户端写入到数据通道的数据，并显示
 * */
import java.io.*;
import java.net.*;
public class SocketTCP01Server {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		//1、在本机（服务器）的9999端口监听，等待连接、
		//细节1：要求在本机没有其它服务在监听9999
		//细节2：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());
		System.out.println("已被连接");
		//3、通过socket.getInputStream()读取,客户端写入到数据通道的数据。显示
		InputStream inputStream = socket.getInputStream();
		//4、IO读取
		byte[] buf = new byte[1024];
		int readLen = 0;
		while((readLen = inputStream.read(buf))!=-1) {
			System.out.println(new String(buf,0,readLen));//解码从0开始，长度为readLen的数组buf为字符
		}
		//5、关闭流和socket
		inputStream.close();
		socket.close();
		serverSocket.close();
	}

}

package Ex2;
/*客户端：
 * 1、连接服务端（ip、端口）
 * 2、连接上后，生成Socket，通过socket.getOutputStream()
 * 3、通过输出流，写入数据到数据通道
 * */
import java.io.*;
import java.net.*;
public class SocketTCP01Client {

	public static void main(String[] args) throws UnknownHostException, IOException {
		// TODO Auto-generated method stub
		//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、通过输出流，写入数据到输出流
		//使用平台的默认字符集将此 String 编码为 byte 序列，并将结果存储到一个新的 byte 数组中
		outputStream.write("hello,server".getBytes());
		//4、关闭流对象和socket,
		outputStream.close();
		socket.close();
		System.out.println("客户端退出");
	}

}

2、（使用字节流）

设置写入结束标记shutdownOutputStream();

1、编写一个服务端和一个客户端

2、服务端在9999端口监听

3、客户端连接到服务端，发送给“hello,server”，并接收服务端回发的"hello,client",再退出

4、当服务端接收到客户端发送的“hello,server”信息，输出，并发送"hello,client"，再退出

package SocketTCP02;
/*为什么第一个不用写shutdownOutputStream:
 * 因为第一个只有一次数据传输，结束之后直接手动关闭连接了，后续没有要继续执行的代码了
 * */
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

/*1、编写一个服务端和一个客户端
2、服务端在9999端口监听
3、客户端连接到服务端，发送给“hello,server”，并接收服务端回发的"hello,client",再退出
4、当服务端接收到客户端发送的“hello,server”信息，输出，并发送"hello,client"，再退出
 * */
public class SocketTCP02Server {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		System.out.println("服务端");
		//1、在本机(服务器)的9999端口监听，等待连接
		ServerSocket serverSocket = new ServerSocket(9999);
		System.out.println("服务端，在9999端口监听，等待监听");
		//2、当没有客户端连接9999端口时，程序会阻塞，等待连接；
		//如果有，则返回Socket对象，程序继续
		Socket socket = serverSocket.accept();
		System.out.println("已经连接");
		//3、读取客户端写入到数据通道的数据，并显示
		InputStream inputStream = socket.getInputStream();
		byte[] buf = new byte[1024];
		int readLen = 0;
		while((readLen = inputStream.read(buf))!=-1) {
			System.out.println(new String(buf,0,readLen));
		}
		//4、服务端写入数据到数据通道
		OutputStream outputStream = socket.getOutputStream();
		outputStream.write("hello,client".getBytes());
		//细节：设置写入结束标记
		socket.shutdownOutput();
		//5、关闭流和socket
		outputStream.close();
		inputStream.close();
		socket.close();
		serverSocket.close();
	}

}

package SocketTCP02;
/*为什么第一个不用写shutdownOutputStream:
 * 因为第一个只有一次数据传输，结束之后直接手动关闭连接了，后续没有要继续执行的代码了
 * */
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

public class SocketTCP02Client {

	public static void main(String[] args) throws UnknownHostException, IOException {
		// TODO Auto-generated method stub
		System.out.println("客户端");
		//1、连接服务器(ip,端口)
		Socket socket = new Socket(InetAddress.getLocalHost(), 9999);
		System.out.println("客户端,Socket返回="+socket.getClass());
		//2、连接上后，生成Socket,通过socket.getOutputStream()得到和socket关联的输出流
		OutputStream outputStream = socket.getOutputStream();
		outputStream.write("hello,server".getBytes());
		//细节：设置写入结束标记
		socket.shutdownOutput();
		//3、通过socket,getInputStream读取，服务端写入数据通道的数据。并显示
		InputStream inputStream = socket.getInputStream();
		byte[] buf = new byte[1024];
		int readLen = 0;
		while((readLen = inputStream.read(buf))!=-1) {
			System.out.println(new String(buf,0,readLen));
		}
		//4、关闭流和socket
		inputStream.close();
		outputStream.close();
		socket.close();
	}

}

3、（使用字符流）

package SocketTCP03;
/*服务端，使用字符流读写*/
import java.io.*;
import java.net.*;
public class SocketTCP03Server {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		System.out.println("服务端");
		//1、在本机的9999端口监听，等待连接；
		//要求在本机没有其它服务监听9999;这个ServerSocket可以通过accept()返回多个Socket
		ServerSocket serverSocket = new ServerSocket(9998);
		System.out.println("服务端，在9999端口监听，等待连接");
		//2、当没有客户端连接9999端口时，程序会阻塞，等待连接，
		//如果有客户端连接，则返回Socket对象，程序继续
		Socket socket  = serverSocket.accept();
		System.out.println("已被连接");
		//3、通过socket.getInputStream(),读取客户端写入到数据通道的数据，并显示
		InputStream inputStream = socket.getInputStream();
		//4、IO,读取，这里使用InputStreamReader将inputSteam转成字符流
		BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
		String s  = bufferedReader.readLine();
		System.out.println(s);
		//5、获取socket相关联的输出流
		OutputStream outputStream = socket.getOutputStream();
		//使用字符输出流的方式回复信息
		BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
		bufferedWriter.write("hello,client 字符流");
		bufferedWriter.newLine();//插入一个换行符，表示回复内容的结束
		bufferedWriter.flush();//需要手动的flush;
		//6、关闭流和socket
		bufferedReader.close();
		bufferedWriter.close();
		socket.close();
		serverSocket.close();
	}

}

package SocketTCP03;
/*客户端，发送"hello,server"给服务端，使用字符流*/
import java.io.*;
import java.net.*;
public class SocketTCP03Client {

	public static void main(String[] args) throws UnknownHostException, IOException {
		// TODO Auto-generated method stub
		System.out.println("客户端");
		//1、连接服务端(ip,端口)
		Socket socket = new Socket(InetAddress.getLocalHost(),9998);
		System.out.println("客户端，socket返回="+socket.getClass());
		//2、连接上后，生成Socket,通过socket.getOutStream(),得到和socket对象关联的输出流对象
		OutputStream outputStream = socket.getOutputStream();
		//3、通过输出流，使用字符流写入数据到 数据通道
		BufferedWriter bufferedWriter = new BufferedWriter(new OutputStreamWriter(outputStream));
		bufferedWriter.write("hello,server字符流");
		bufferedWriter.newLine();//插入一个换行符，表示写入的内容结束，注意，要求对方使用readLine()!!!
		bufferedWriter.flush();//如果使用的字符流，则需要手动刷新，否则内容不会写入数据通道
		//4、获取和socket关联的输入流，读取数据(字符)，并显示
		InputStream inputStream = socket.getInputStream();
		BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
		String s = bufferedReader.readLine();
		System.out.println(s);
		//5、关闭对象和socket，必须关闭
		bufferedReader.close();
		bufferedWriter.close();
		socket.close();
		System.out.println("客户端退出");
	}

}

4、接发图片

1、编写一个服务端和一个客户端

2、服务端在8888端口监听

3、客户端连接到服务端，发送一张图片：d:\\yellowDog.jpg

4、服务器端接收到客户端发送的图片，保存到src下，发送"收到图片"再退出

5、客户端接收到服务端发送的"发送图片"再退出

21.4.3netstart指令

21.4.4TCP网络通讯再理解

21.5UDP网络通信编程

21.5.1基本介绍

21.5.2基本流程

21.5.3案例

1、编写一个接受端A，和一个发送端B

2、接受端A在9999端口等待接收数据(receive)

3、发送端B向接收端A 发送数据“hello,明天吃火锅”

4、接收端A接收到发送端B发送的数据，回复“好的，明天见”，再退出

5、发送端接受回复的数据后，再退出

package UDP01;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

//UDP接收端
public class UDPReceiverA {
    public static void main(String[] args) throws IOException {
        //1、创建一个DatagramSocket对象，准备再9999端口接收数据
        DatagramSocket socket = new DatagramSocket(9999);
        //2、构建一个DatagramPack 对象，准备接收数据
        //前面UDP讲解协议时，韩老师提过一个数据包最大64K
        byte[] buf = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buf,buf.length);
        //3、调用接收方法，将通过网络传输的DatagramPack对象，填充到packet对象
        //注：如果没数据包发送到本机的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端
        //将需要发送的数据，封装到DatagramPack对象
        data = "好的，明天见".getBytes();
        packet = new DatagramPacket(data, data.length, InetAddress.getLocalHost(),9998);
        socket.send(packet);//发送

        //5、关闭资源
        socket.close();
        System.out.println("A端退出");
    }
}

package UDP01;

import java.io.IOException;
import java.net.*;

//发送端B，也可以接收数据
public class UDPSenderB {
    public static void main(String[] args) throws IOException {
        //1、创建DatagramSocket 对象，准备在9998端口接收数据
        DatagramSocket socket = new DatagramSocket(9998);
        //2、将需要发送的数据，封装到 DatagramPack对象
        byte[] data = "hello 明天吃火锅".getBytes();
        //说明：封装的DatagramPacket对象 data内容字节数字,data.length,主机(IP),端口
        DatagramPacket packet = new DatagramPacket(data, data.length, InetAddress.getLocalHost(),9999);
        socket.send(packet);
        //3、====接收A端回复的信息
        //(1)构建一个DatagramPack对象，准备接收数据
        byte[] buf = new byte[1024];
        packet = new DatagramPacket(buf, buf.length);
        //(2)调用接收方法，将通过网络传输的DatagramPack对象填充到packet对象中
        socket.receive(packet);
        //(3)把packet进行拆包，取出数据，并显示
        int length = packet.getLength();//实际收到的数据字节长度
        data = packet.getData();//接收到的数据
        String s = new String(data,0,length);
        System.out.println(s);
        //关闭资源
        socket.close();
        System.out.println("B端退出");
    }
}