打怪升级之小白的大数据之旅(二十八)＜Java面向对象进阶之网络编程＞

打怪升级之小白的大数据之旅(二十八)

Java面向对象进阶之网络编程

上次回顾

上一章对Java的多线程进行分享，了解的多线程，可以更好的为以后大数据打好底子，毕竟我们的数据量是很大的，本章节介绍一下Java的网络编程，了解网络编程也只是为了让我们更好地了解网络传输的原理；同时，网络编程的案例可以加深一下我们对多任务和IO知识点的印象，具体的，请看今日的内容

网络编程

软件结构

手机已经是我们日常必不可少的一部分了，今天整章节就通过网络编程带大家了解我们手机软件是如何运行的

C/S结构

• C/S结构，全称为Client/Server结构，是指客户端和服务器结构。常见程序有ＱＱ、微信、抖音等软件
• 它的特点就是功能全，我们日常使用的各种APP都是C/S架构，缺点是下载需要时间，必须王者荣耀这款游戏，如果该游戏的版本升级了，我们就必须升级才可以继续使用

B/S结构

• B/S结构 ：全称为Browser/Server结构，是指浏览器和服务器结构。常见浏览器有IE、谷歌、火狐等

• 它的特点是方便，我们只需要下载一个浏览器，即可通过域名进行访问，它并没有客户端的限制，但正因如此，它的安全性就会相对差一些(我们通常提到的网络爬虫，多数都是通过B/S端进行的)

• 两种架构各有优势，但是无论哪种架构，都离不开网络的支持。网络编程，就是在一定的协议下，实现两台计算机的通信的程序

• 这里说句个人理解，对于许多公司来说，他们会更加倾向于开发C/S端，首先C/S端可以制定属于自己的安全规则，其次，可以开发出更多的功能。最重要的一点就是数据

• 大数据最重要的就是数据，如果只是B/S端，对于一个公司来说，产生价值远远不如自己开发C/S端将用户牢牢把握在自己的手里。因为可以根据自己的商业需求对APP进行埋点，就像淘宝等电商软件，他们通过埋点可以获取用户购买商品的习惯并针对性进行推荐(推荐系统是大数据的应用之一)

网络通信协议

• 这里提一下局域网和互联网的概念，局域网就是在一个区域内的计算机之间相互连接，比如在一个教室中，多台计算机连接后，我们就可以使用飞秋或者使用局域网打单机的CS（一不小心暴露的年纪）
• 互联网可以理解为一个大的网络，它并不仅仅只是一个小的区域，通过宽带，光纤，连接到千家万户

TCP/IP协议

• 网络通信协议：通过计算机网络可以使多台计算机实现连接，位于同一个网络中的计算机在进行连接和通信时需要遵守一定的规则
• 这就好比在道路中行驶的汽车一定要遵守交通规则一样。在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。
• TCP/IP协议： 传输控制协议/因特网互联协议( Transmission Control Protocol/Internet Protocol)，是Internet最基本、最广泛的协议。它定义了计算机如何连入因特网，以及数据如何在它们之间传输的标准。它的内部包含一系列的用于处理数据通信的协议，并采用了4层的分层模型，每一层都呼叫它的下一层所提供的协议来完成自己的需求
• OSI模型是一个过于理想化的模型，并没能在互联网中得到推广，所以我们大家就采用了TCP/IP模型来为网络通信制定标准
• 而通常我们说的TCP/IP协议，其实是指TCP/IP协议族，因为该协议家族的两个最核心协议：TCP（传输控制协议）和IP（网际协议），为该家族中最早通过的标准，所以简称为TCP/IP协议

TCP与UDP协议

• 有关TCP和UDP协议的相关介绍，网络上有很多，我就不再详细描述了，我就说一下它们之间的区别、个人理解以及TCP连接的方式

区别

	UDP	TCP
连接方式	非面向连接，不可靠	面向连接，可靠的
传输效率	传输效率高，消耗资源小	传输效率相对低，消耗资源高
数据传输	不能确保数据完整性	可靠无差错的数据传输
大小限制	数据限制在64kb内	可以连续传输大量数据

• UDP可以理解为短信，它无需关心我们是否收到，并且它也发不了太多的信息
• TCP可以理解为打电话，当双方建立连接后，就可以持续通话

TCP连接方式

• 三次握手：TCP协议中，在发送数据的准备阶段，客户端与服务器之间的三次交互，以保证连接的可靠。

  • 第一次握手，客户端向服务器端发出连接请求，等待服务器确认。
  • 第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。
  • 第三次握手，客户端再次向服务器端发送确认信息，确认连接

• 四次挥手：TCP协议中，在发送数据结束后，释放连接时需要经过四次挥手。

  • 第一次挥手：客户端向服务器端提出结束连接，让服务器做最后的准备工作。此时，客户端处于半关闭状态，即表示不再向服务器发送数据了，但是还可以接受数据。
  • 第二次挥手：服务器接收到客户端释放连接的请求后，会将最后的数据发给客户端。并告知上层的应用进程不再接收数据。
  • 第三次挥手：服务器发送完数据后，会给客户端发送一个释放连接的报文。那么客户端接收后就知道可以正式释放连接了。
  • 第四次挥手：客户端接收到服务器最后的释放连接报文后，要回复一个彻底断开的报文。这样服务器收到后才会彻底释放连接。这里客户端，发送完最后的报文后，会等待2MSL，因为有可能服务器没有收到最后的报文，那么服务器迟迟没收到，就会再次给客户端发送释放连接的报文，此时客户端在等待时间范围内接收到，会重新发送最后的报文，并重新计时。如果等待2MSL后，没有收到，那么彻底断开
    
    完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，TCP协议可以保证传输数据的安全，所以应用十分广泛，例如下载文件、浏览网页等

网络编程三要素

网络编程三要素：协议、IP地址、端口号

• 协议就是网络编程所需要遵守的协议，前面已经介绍到了
• IP地址就像我们家庭的门牌号，它是一台计算机的在网络中的标记，根据IP地址就可以在互联网中找到该计算机，当然了，这里说的是固定IP地址，我们家庭的IP通常是动态IP，因为我们家庭中多用的宽带拨号连接
• 端口号就是计算机中一个软件的标识，如果说IP地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的进程（应用程序）了

InetAddress类

• InetAddress类主要表示IP地址，两个子类：Inet4Address、Inet6Address
• lInetAddress 类没有提供公共的构造器，而是提供 了 如下几个 静态方法来获取InetAddress 实例
  • public static InetAddress getLocalHost()
  • public static InetAddress getByName(String host)
  • public static InetAddress getByAddress(byte[] addr)
• InetAddress 提供了如下几个常用的方法
  • public String getHostAddress() ：返回 IP 地址字符串（以文本表现形式）。
  • public String getHostName() ：获取此 IP 地址的主机名
  • 示例代码：

import java.net.InetAddress;
import java.net.UnknownHostException;

import org.junit.Test;

public class TestInetAddress {
	@Test
	public void test01() throws UnknownHostException{
		InetAddress localHost = InetAddress.getLocalHost();
		System.out.println(localHost);
	}
	
	@Test
	public void test02()throws UnknownHostException{
		InetAddress atguigu = InetAddress.getByName("www.baidu.com");
		System.out.println(atguigu);
	}

}

Socket

• 通信的两端都要有Socket,，是两台机器间通信的端点。网络通信其实就是Socket间的通信。Socket可以分为:
  • stream socket：使用TCP提供可依赖的字节流服务
    • ServerSocket：此类实现TCP服务器套接字。服务器套接字等待请求通过网络传入。
    • Socket：此类实现客户端,是两台机器间通信的端点。
  • datagram socket：使用UDP提供“尽力而为”的数据报服务
    • DatagramSocket：此类表示用来发送和接收UDP数据报包

TCP网络编程

首先介绍一下基于TCP的Socket通信模型
开发步骤
1、服务器端
服务器 程序的工作过程包含以下四个基本的 步骤：

• 调用 ServerSocket(int port) ：创建一个服务器端套接字，并绑定到指定端口上。用于监听客户端的请求。
• 调用 accept() ：监听连接请求，如果客户端请求连接，则接受连接，返回通信套接字对象。
• 调用 该Socket 类对象的 getOutputStream() 和 getInputStream () ：获取输出流和输入流，开始网络数据的发送和接收。
• 关闭Socket 对象：客户端访问结束，关闭通信套接字。

2、客户端
客户端Socket 的工作过程包含以下四个基本的步骤 ：

• 创建 Socket ：根据指定服务端的 IP 地址或端口号构造 Socket 类对象。若服务器端响应，则建立客户端到服务器的通信线路。若连接失败，会出现异常。
• 打开连接到 Socket 的输入/ 出流： 使用 getInputStream()方法获得输入流，使用getOutputStream()方法获得输出流，进行数据传输
• 按照一定的协议对 Socket 进行读/ 写操作：通过输入流读取服务器放入线路的信息（但不能读取自己放入线路的信息），通过输出流将信息写入线路。
• 关闭 Socket ：断开客户端到服务器的连接，释放线路

相关API

ServerSocket类的构造方法：

• ServerSocket(int port) ：创建绑定到特定端口的服务器套接字。
  ServerSocket类的常用方法：
• Socket accept()：侦听并接受到此套接字的连接。

Socket类的常用构造方法：

• public Socket(InetAddress address,int port)：创建一个流套接字并将其连接到指定 IP 地址的指定端口号。
• public Socket(String host,int port)：创建一个流套接字并将其连接到指定主机上的指定端口号。

Socket类的常用方法：

• public InputStream getInputStream()：返回此套接字的输入流，可以用于接收消息
• public OutputStream getOutputStream()：返回此套接字的输出流，可以用于发送消息
• public InetAddress getInetAddress()：此套接字连接到的远程 IP 地址；如果套接字是未连接的，则返回 null。
• public InetAddress getLocalAddress()：获取套接字绑定的本地地址。
• public int getPort()：此套接字连接到的远程端口号；如果尚未连接套接字，则返回 0。
• public int getLocalPort()：返回此套接字绑定到的本地端口。如果尚未绑定套接字，则返回 -1。
• public void close()：关闭此套接字。套接字被关闭后，便不可在以后的网络连接中使用（即无法重新连接或重新绑定）。需要创建新的套接字对象。 关闭此套接字也将会关闭该套接字的 InputStream 和 OutputStream。
• public void shutdownInput()：如果在套接字上调用 shutdownInput() 后从套接字输入流读取内容，则流将返回 EOF（文件结束符）。 即不能在从此套接字的输入流中接收任何数据。
• public void shutdownOutput()：禁用此套接字的输出流。对于 TCP 套接字，任何以前写入的数据都将被发送，并且后跟 TCP 的正常连接终止序列。 如果在套接字上调用 shutdownOutput() 后写入套接字输出流，则该流将抛出 IOException。 即不能通过此套接字的输出流发送任何数据。

下面我来使用案例来演示客户端与服务器的通信

• 单个客户端与服务器单次通信

  // 客户端代码
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.net.Socket;
  
  public class Client {
  
  	public static void main(String[] args) throws Exception {
  		// 1、准备Socket，连接服务器，需要指定服务器的IP地址和端口号
  		Socket socket = new Socket("127.0.0.1", 8888);
  
  		// 2、获取输出流，用来发送数据给服务器
  		OutputStream out = socket.getOutputStream();
  		// 发送数据
  		out.write("lalala".getBytes());
  		//会在流末尾写入一个“流的末尾”标记，对方才能读到-1，否则对方的读取方法会一致阻塞
  		socket.shutdownOutput();
  		
  		//3、获取输入流，用来接收服务器发送给该客户端的数据
  		InputStream input = socket.getInputStream();
  		// 接收数据
  		byte[] data = new byte[1024];
  		StringBuilder s = new StringBuilder();
  		int len;
  		while ((len = input.read(data)) != -1) {
  			s.append(new String(data, 0, len));
  		}
  		System.out.println("服务器返回的消息是：" + s);
  		
  		//4、关闭socket，不再与服务器通信，即断开与服务器的连接
  		//socket关闭，意味着InputStream和OutputStream也关闭了
  		socket.close();
  	}
  }
  // 服务器端代码
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.net.ServerSocket;
  import java.net.Socket;
  
  public class Server {
  
  	public static void main(String[] args)throws Exception {
  		//1、准备一个ServerSocket对象，并绑定8888端口
  		ServerSocket server =  new ServerSocket(8888);
  		System.out.println("等待连接....");
  		
  	//2、在8888端口监听客户端的连接，该方法是个阻塞的方法，如果没有客户端连接，将一直等待
  		Socket socket = server.accept();
  		System.out.println("一个客户端连接成功！！");
  		
  		//3、获取输入流，用来接收该客户端发送给服务器的数据
  		InputStream input = socket.getInputStream();
  		//接收数据
  		byte[] data = new byte[1024];
  		StringBuilder s = new StringBuilder();
  		int len;
  		while ((len = input.read(data)) != -1) {
  			s.append(new String(data, 0, len));
  		}
  		System.out.println("客户端发送的消息是：" + s);
  				
  		//4、获取输出流，用来发送数据给该客户端
  		OutputStream out = socket.getOutputStream();
  		//发送数据
  		out.write("欢迎登录".getBytes());
  		out.flush();
  		
  		//5、关闭socket，不再与该客户端通信
  		//socket关闭，意味着InputStream和OutputStream也关闭了
  		socket.close();
  		
  		//6、如果不再接收任何客户端通信，可以关闭ServerSocket
  		server.close();
  	}
  }
  

• 多个客户端与服务器之间的多次通信
• 如果服务器端要“同时”处理多个客户端的请求，因此服务器端需要为每一个客户端单独分配一个线程来处理，否则无法实现“同时

// 客户端
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintStream;
import java.net.Socket;
import java.util.Scanner;

public class Client2 {
	public static void main(String[] args) throws Exception {
		// 1、准备Socket，连接服务器，需要指定服务器的IP地址和端口号
		Socket socket = new Socket("127.0.0.1", 8888);

		// 2、获取输出流，用来发送数据给服务器
		OutputStream out = socket.getOutputStream();
		PrintStream ps = new PrintStream(out);
		
		// 3、获取输入流，用来接收服务器发送给该客户端的数据
		InputStream input = socket.getInputStream();
		BufferedReader br = new BufferedReader(new InputStreamReader(input));
		
		Scanner scanner = new Scanner(System.in);
		while(true){
			System.out.println("输入发送给服务器的单词或成语：");
			String message = scanner.nextLine();
			if(message.equals("stop")){
				socket.shutdownOutput();
				break;
			}
			
			// 4、 发送数据
			ps.println(message);
			// 接收数据
			String feedback  = br.readLine();
			System.out.println("从服务器收到的反馈是：" + feedback);
		}
		
		//5、关闭socket，断开与服务器的连接
		scanner.close();
		socket.close();
	}
}
// 服务器端
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server2 {
	public static void main(String[] args) throws IOException {
		// 1、准备一个ServerSocket
		ServerSocket server = new ServerSocket(8888);
		System.out.println("等待连接...");
		
		int count = 0;
		while(true){
			// 2、监听一个客户端的连接
			Socket socket = server.accept();
			System.out.println("第" + ++count + "个客户端"+socket.getInetAddress().getHostAddress()+"连接成功！！");
			
			ClientHandlerThread ct = new ClientHandlerThread(socket);
			ct.start();
		}
		
		//这里没有关闭server，永远监听
	}
	static class ClientHandlerThread extends Thread{
		private Socket socket;

		public ClientHandlerThread(Socket socket) {
			super();
			this.socket = socket;
		}
		
		public void run(){
			
			try{
				//（1）获取输入流，用来接收该客户端发送给服务器的数据
				BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
				//（2）获取输出流，用来发送数据给该客户端
				PrintStream ps = new PrintStream(socket.getOutputStream());
				String str;
				// （3）接收数据
				while ((str = br.readLine()) != null) {
					//（4）反转
					StringBuilder word = new StringBuilder(str);
					word.reverse();
					
					//（5）返回给客户端
					ps.println(word);
				}
				System.out.println(socket.getInetAddress().getHostAddress()+"正常退出");
			}catch(Exception  e){
				System.out.println(socket.getInetAddress().getHostAddress()+"意外退出");
			}finally{
				try {
					//（6）断开连接
					socket.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
	}
}

UDP网络编程

• 因为UDP并不需要面向连接,因此它只需要知道对方的IP地址和端口号,直接向对方发送数据就OK了

DatagramSocket 类的常用方法：

• public DatagramSocket(int port)创建数据报套接字并将其绑定到本地主机上的指定端口。套接字将被绑定到通配符地址，IP 地址由内核来选择。
• public DatagramSocket(int port,InetAddress laddr)创建数据报套接字，将其绑定到指定的本地地址。本地端口必须在 0 到 65535 之间（包括两者）。如果 IP 地址为 0.0.0.0，套接字将被绑定到通配符地址，IP 地址由内核选择。
• public void close()关闭此数据报套接字。
• public void send(DatagramPacket p)从此套接字发送数据报包。DatagramPacket 包含的信息指示：将要发送的数据、其长度、远程主机的 IP 地址和远程主机的端口号。
• public void receive(DatagramPacket p)从此套接字接收数据报包。当此方法返回时，DatagramPacket 的缓冲区填充了接收的数据。数据报包也包含发送方的 IP 地址和发送方机器上的端口号。 此方法在接收到数据报前一直阻塞。数据报包对象的 length 字段包含所接收信息的长度。如果信息比包的长度长，该信息将被截短。

DatagramPacket类的常用方法：

• public DatagramPacket(byte[] buf,int length)构造 DatagramPacket，用来接收长度为 length 的数据包。 length 参数必须小于等于 buf.length。
• public DatagramPacket(byte[] buf,int length,InetAddress address,int port)构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。length 参数必须小于等于 buf.length。
• public int getLength()返回将要发送或接收到的数据的长度
• 我就直接上代码了…

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.ArrayList;

public class Send {

	public static void main(String[] args)throws Exception {
//		1、建立发送端的DatagramSocket
		DatagramSocket ds = new DatagramSocket();
		
		//要发送的数据
		ArrayList<String> all = new ArrayList<String>();
		all.add("尚硅谷让天下没有难学的技术！");
		all.add("学高端前沿的IT技术来尚硅谷！");
		all.add("尚硅谷让你的梦想变得更具体！");
		all.add("尚硅谷让你的努力更有价值！");
		
		//接收方的IP地址
		InetAddress ip = InetAddress.getByName("127.0.0.1");
		//接收方的监听端口号
		int port = 9999;
         //发送多个数据报
		for (int i = 0; i < all.size(); i++) {
//			2、建立数据包DatagramPacket
			byte[] data = all.get(i).getBytes();
			DatagramPacket dp = new DatagramPacket(data, data.length, ip, port);
//			3、调用Socket的发送方法
			ds.send(dp);
		}
		
//		4、关闭Socket
		ds.close();
	}
}
// 接收端
package com.atguigu.udp;

import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class Receive {

	public static void main(String[] args) throws Exception {
//		1、建立接收端的DatagramSocket，需要指定本端的监听端口号
		DatagramSocket ds = new DatagramSocket(9999);
		
		//一直监听数据
		while(true){
	//		2、建立数据包DatagramPacket
			byte[] buffer = new byte[1024*64];
			DatagramPacket dp = new DatagramPacket(buffer , buffer.length);
			
	//		3、调用Socket的接收方法
			ds.receive(dp);
			
			//4、拆封数据
			String str = new String(buffer,0,dp.getLength());
			System.out.println(str);
		}
	}
}

总结

本章节介绍了网络编程的相关知识点，了解网络编程以及了解网络编程的过程，可以更好让我们理解数据的传输过程，对于我们大数据来说，理解它可以更好地为后面的数据采集服务…好了，下一期我来为大家带来反射的相关知识点