[网络协议]Java网络编程

前言

网络编程就是在两个或两个以上的设备(例如计算机)之间传输数据。程序员所作的事情就是把数据发送到指定的位置，或者接收到指定的数据，这个就是狭义的网络编程范畴。在发送和接收数据时，大部分的程序设计语言都设计了专门的API实现这些功能，程序员只需要调用即可。

一、网络编程概述

网络编程分为服务端和客户端。服务端就相当于我们平时说的服务器，有固定的IP地址，随时等待服务器连接并做出响应；而客户端相当于各种端系统，找到服务端进行连接获取服务。

二、网络通信协议与接口

1.网络通信协议

TCP/IP协议： 传输控制协议/因特网互联协议（Transmission Control Protocol/Internet Protocal），是Internet最基本、最广泛的协议。它定义了计算机如何连入因特网，以及数据如何在它们之间传输的标准。它的内部包含一系列的用于处理数据通信的协议，并采用了4层的分层模型，每一层都呼叫它的下一层所提供的协议来完成自己的需求。

2.网络通信接口

为了使两个节点之间能进行对话，必须在他们之间建立通信工具（即接口），使彼此之间，能进行信息交换。接口包括两部分：

• 硬件装置：实现结点之间的信息传送
• 软件装置：规定双方进行通信的约定协议

3.网络分层模型

OSI参考模型： 模型过于理想化，未能在因特网上进行广泛推广

TCP/IP参考模型(或TCP/IP协议)： 事实上的国际标准。

模型如下（图示例）：

上图中，TCP/IP协议中的四层分别是应用层、传输层、网络层和链路层，每层分别负责不同的通信功能。

• 应用层： 主要负责应用程序的协议，例如HTTP协议、FTP协议等。
• 传输层： 主要使网络程序进行通信，在进行网络通信时，可以采用TCP协议，也可以采用UDP协议。
• 网络层： 网络层是整个TCP/IP协议的核心，它主要用于将传输的数据进行分组，将分组数据发送到目标计算机或者网络。
• 数据链路层： 链路层是用于定义物理传输通道，通常是对某些网络连接设备的驱动协议，例如针对光纤、网线提供的驱动。

三、网络协议

1.IP地址

在网络中每台计算机都必须有一个的IP地址。每个人的电脑都有一个独一无二的IP地址，这样互相通信时就不会传错信息了。

• 127.0.0.1： 本机回环地址
• IPV4： 32为地址，以点分十进制表示，如192.168.0.1
• IPV6： 128位（16个字节）写成8个16位的无符号整数，每个整数用四个十六进制位表示，数之间用冒号（：）分开，如：3ffe:3201:1401:1280:c8ff:fe4d:db39:1984

代码如下（示例）：

//测试
public class Test  {
    public static void main(String[] args) throws UnknownHostException {
        //使用ip
        InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");
        System.out.println(inetAddress1);
        
        //使用域名
        InetAddress inetAddress2 = InetAddress.getByName("www.baidu.com");
        System.out.println(inetAddress2);
        
        //LocalHost获取本机回环ip（127.0.0.1）
        InetAddress inetAddress3 = InetAddress.getLocalHost();
        System.out.println(inetAddress3);

        System.out.println(inetAddress2.getAddress());			//返回IP
        System.out.println(inetAddress2.getCanonicalHostName());//返回规范的名字
        System.out.println(inetAddress2.getHostAddress());		//返回IP
        System.out.println(inetAddress2.getHostName());			//返回域名,或者自己电脑的名字
    }
}

2.端口（port）

端口表示计算机上的一个程序的进程。

IP地址用来标识一台计算机，但是一台计算机上可能提供多种网络应用程序，如何来区分这些不同的程序呢？这就要用到端口。端口号是用来区分一台机器上不同的应用程序的。

记住一点，我们编写的程序要占用端口号的话占用1024以上的端口号，1024以下的端口号不要去占用，因为系统有可能会随时征用。端口号本身又分为TCP端口和UDP端口，TCP的8888端口和UDP的8888端口是完全不同的两个端口。TCP端口和UDP端口都有65536个。

• 不同进程监听不同的端口
• 端口号0~65535
• UDP和TCP协议端口号独立，可以同时有UDP和TCP的80端口

windows 命名提示符：

netstat -ano 					#查看所有端口
netstat -ano | findstr "XXXXX" 	#查看指定的端口
tasklist | findstr "XXXX" 		#查看指定端口发进程

代码如下（示例）：

public class TestInetSocketAddress {
    public static void main(String[] args) {
        InetSocketAddress socketAddress1 = new InetSocketAddress("localhost",8080);
        InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1",8080);
        System.out.println(socketAddress);
        System.out.println(socketAddress1);

        System.out.println(socketAddress.getAddress());
        System.out.println(socketAddress.getHostName());//地址
        System.out.println(socketAddress.getPort());	//端口
    }
}

四、网络通信协议

1.TCP协议

TCP：传输控制协议 (Transmission Control Protocol)。 TCP协议是面向连接的通信协议，即传输数据之前，在发送端和接收端建立逻辑连接，然后再传输数据，它提供了两台计算机之间可靠无差错的数据传输。

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

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

完成三次握手，连接建立后，客户端和服务器就可以开始进行数据传输了。由于这种面向连接的特性，TCP协议可以保证传输数据的安全，所以应用十分广泛，例如下载文件、浏览网页等。

四次挥手： 四次挥手即终止TCP连接，就是指断开一个TCP连接时，需要客户端和服务端总共发送4个包以确认连接的断开。在socket编程中，这一过程由客户端或服务端任一方执行close来触发。

TCP实现步骤：

• 客户端
  • 连接服务器Socket
  • 发生消息
• 服务端
  • 建立服务端口ServerSocket
  • 等待用户的连接accept
  • 接受用户的消息

Socket实现TCP

代码如下（示例）：

//客户端
public class Test {
    public static void main(String[] args) throws IOException {
        //1、要知道服务器地址
        InetAddress sAddress = InetAddress.getByName("127.0.0.1");
        //2、端口号
        int port = 9999;
        //3、创建socket连接
        Socket socket = new Socket(sAddress,port);
        //4、发送消息，IO流
        OutputStream os = socket.getOutputStream();
        os.write("hello你好！".getBytes(StandardCharsets.UTF_8));
        //5、关闭资源
        os.close();
        socket.close();
    }
}

//服务端
public class Test {
    public static void main(String[] args) throws IOException {
        //1、需要有一个地址
        ServerSocket serverSocket = new ServerSocket(9999);
        //2、等待客户端连接
        Socket socket = serverSocket.accept();
        //3、读取消息
        InputStream is = socket.getInputStream();
        //4、管道流
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] buffer = new byte[1024];
        int len;
        while ((len=is.read(buffer))!=-1){
            baos.write(buffer,0,len);
        }
        System.out.println(baos.toString());
        if (baos!=null){
            baos.close();
        }
        if (is!=null){
            is.close();
        }
        if (socket!=null) {
            socket.close();
        }
        if (serverSocket!=null) {
            serverSocket.close();
        }
    }
}

TCP文件上传

客户端：

//客户端
public class Test {
    public static void main(String[] args) throws IOException {
        //1.要知道服务器的地址
        InetAddress ServerIp = InetAddress.getByName("127.0.0.1");
        //2.端口号
        int port = 9999;
        //3.创建一个socket连接
        Socket socket = new Socket(ServerIp, port);
        //4.发送消息 IO流
        OutputStream outputStream = socket.getOutputStream();

        //读取文件
        FileInputStream fis = new FileInputStream(new File("hello.jpg"));
        byte[] buffer = new byte[1024];
        int len;
        while((len=fis.read())!=-1){
            outputStream.write(buffer,0,len);
        }

        //通知服务器,我已经结束了
        socket.shutdownOutput();
        
        InputStream inputStream = socket.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        byte [] buffer2 = new byte[2014];
        int len2;
        while((len2=inputStream.read(buffer2))!=-1){
            baos.write(buffer2,0,len2);
        }
        System.out.println(baos.toString());
        if(outputStream!=null){
            outputStream.close();
        }
        if (socket!=null){
            socket.close();
        }
    }
}

服务端：

//服务端
public class Test {
    public static void main(String[] args) throws IOException {
        //1.我得有一个地址
        ServerSocket serverSocket = new ServerSocket(9999);
        //2.等待客户端连接过来
        Socket socket = serverSocket.accept();
        //3.读取客户端的消息
        InputStream is = socket.getInputStream();

        //文件输出
        FileOutputStream fos = new FileOutputStream(new File("re.jpg"));
        byte[] buffer = new byte[1024];
        int len;
        while ((len=is.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }

        //通知客户端我接受完毕了
        OutputStream os = socket.getOutputStream();
        os.write("我接受完毕了".getBytes(StandardCharsets.UTF_8));
        if (fos!=null){
            fos.close();
        }
        if (is!=null){
            is.close();
        }
        if (socket!=null) {
            socket.close();
        }
        if (serverSocket!=null) {
            serverSocket.close();
        }
    }
}

2.UDP协议

UDP：用户数据报协议(User Datagram Protocol)。 UDP协议是一个面向无连接的协议。传输数据时，不需要建立连接，不管对方端服务是否启动，直接将数据、数据源和目的地都封装在数据包中，直接发送。每个数据包的大小限制在64k以内。它是不可靠协议，因为无连接，所以传输速度快，但是容易丢失数据。日常应用中，例如视频会议、QQ聊天等。

由于使用UDP协议消耗资源小，通信效率高，所以通常都会用于音频、视频和普通数据的传输例如视频会议都使用UDP协议，因为这种情况即使偶尔丢失一两个数据包，也不会对接收结果产生太大影响。

但是在使用UDP协议传送数据时，由于UDP的面向无连接性，不能保证数据的完整性，因此在传输重要数据时，不建议使用UDP协议。

特点： 数据被限制在64kb以内，超出这个范围就不能发送了。

Socket实现UDP

代码如下（示例）：

//客户端
public class Test {
    public static void main(String[] args) throws Exception {
        //1、建立Socket
        DatagramSocket socket = new DatagramSocket();
        //2、建立包
        String msg = "hello，你好服务器！";
        //发送给谁
        InetAddress address = InetAddress.getByName("127.0.0.1");
        int port = 9090;
        DatagramPacket packet = new DatagramPacket(msg.getBytes(),0,msg.getBytes().length,address,port);
		//3、发送包
        socket.send(packet);
        //4、关闭流
        socket.close();
    }
}

//服务端
public class Test {
    public static void main(String[] args) throws Exception {
        //1、开放端口
        DatagramSocket socket = new DatagramSocket(9090);
        //2、接受数据包
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);
        //3、接收
        socket.receive(packet);//阻塞接受
        System.out.println(new String(packet.getData()));
        //4、关闭连接
        socket.close();
    }
}

UDP实现聊天室

发送端：

//发送
public class UdpSend implements Runnable {
    DatagramSocket socket = null;
    BufferedReader reader = null;
    private int fromPort;//从哪个端口出去
    private String toIP; //发送到哪个地址
    private int toPort;	 //发送到哪个端口

    public UdpSend(int fromPort,String toIP, int toPort) {
        this.fromPort = fromPort;
        this.toIP = toIP;
        this.toPort = toPort;
        try {
            //1.建立一个socket、创建键盘输入
            socket = new DatagramSocket(fromPort);
            reader = new BufferedReader(new InputStreamReader(System.in));
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while(true){
            //2.创建一个包
            try {
                String str = reader.readLine();
                //数据发给谁
                DatagramPacket packet = new DatagramPacket(str.getBytes(),0,
                        str.getBytes().length, new InetSocketAddress(this.toIP,this.toPort));
                //3.发送包
                socket.send(packet);
                if (str.equals("bye")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //4.关闭连接
        socket.close();
    }
}

接收端：

//接收端
public class UdpAccept implements Runnable {
    DatagramSocket socket = null;
    private int port1;
    private String msgfrom;

    public UdpAccept(int port1,String msgfrom) {
        this.port1 = port1;
        this.msgfrom = msgfrom;
        try {
            //开放端口
            socket = new DatagramSocket(port1);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while (true){
            try {
                //接受数据
                byte[] buffer = new byte[1024];
                DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);
                socket.receive(packet);//阻塞接收

                byte[] data =packet.getData();
                String str = new String(data,0,data.length).trim(); //加上.trim()是为了去除空格
                System.out.println(msgfrom + "：" + str);
                if (str.equals("bye")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        //关闭连接
        socket.close();
    }
}

学生

public class Student {
    public static void main(String[] args) {
        new Thread(new UdpSend(8000,"localhost",9999)).start(); //发送到9999端口的接收方
        new Thread(new UdpAccept(8888,"老师")).start();		   //8888端口的接收方
    }
}

老师

public class Teacher {
    public static void main(String[] args) {
        new Thread(new UdpSend(5555,"localhost",8888)).start(); //发送到8888端口的接收方
        new Thread(new UdpAccept(9999,"学生")).start();		   //9999端口的接收方
    }
}

五、Socket套接字

Socket套接字是通信的基石，是支持TCP/IP协议的网络通信的基本操作单元。它是网络通信过程中端点的抽象表示，包含进行网络通信的五种必须信息：连接使用的协议、本地主机的IP地址、本地进程的协议端口、远程主机的IP地址、远程进程的协议端口。

套接字（socket）是一个抽象层，传输层连接的端点叫做套接字（socket）。应用程序可以通过它发送或接收数据，可对其进行像对文件一样的打开、读写和关闭等操作。套接字允许应用程序将I/O插入到网络中，并与网络中的其他应用程序进行通信。网络套接字是IP地址与端口的组合。

JDK中也封装了Socket，TCP协议的实现是Socket和ServerSocket，UDP协议的实现是DatagramSocket。

Java中UDP协议的socket实现是DatagramSocket，并且不区分客户端和服务端。

代码如下（示例）：

1.Socket实现TCP协议

服务端：

public class ServerSocketTest {
	public static void main(String[] args) throws Exception {
		// 监听指定的端口
		int port = 55533;
		ServerSocket server = new ServerSocket(port);
		// server将一直等待连接的到来
		System.out.println("server将一直等待连接的到来");
		Socket socket = server.accept();
		// 建立好连接后，从socket中获取输入流，并建立缓冲区进行读取
		InputStream inputStream = socket.getInputStream();
		byte[] bytes = new byte[1024];
		int len;
		StringBuilder sb = new StringBuilder();
		while ((len = inputStream.read(bytes)) != -1) {
			// 注意指定编码格式，发送方和接收方一定要统一，建议使用UTF-8
			sb.append(new String(bytes, 0, len, "UTF-8"));
		}
		System.out.println("get message from client: " + sb);
		inputStream.close();
		socket.close();
		server.close();
	}
}

客户端：

public class ClientSocketTest {
	public static void main(String args[]) throws Exception {
		// 要连接的服务端IP地址和端口
		String host = "127.0.0.1";
		int port = 55533;
		// 与服务端建立连接
		Socket socket = new Socket(host, port);
		// 建立连接后获得输出流
		OutputStream outputStream = socket.getOutputStream();
		String message = "林深时见鹿";
		socket.getOutputStream().write(message.getBytes("UTF-8"));
		outputStream.close();
		socket.close();
	}
}

总结： 这是一个客户端单向发送消息到服务器端的demo，且服务器端是只等待接收一次连接请求。从示例代码中可以看到创建socket需要指的IP地址和端口，发送和接收消息是需要通过输入输出流的。

2.Socket实现UDP协议

服务端

public class DatagramSocketServerTest {
	public static void main(String[] args) {
		try {
			// 要接收的报文
			byte[] bytes = new byte[1024];
			DatagramPacket packet = new DatagramPacket(bytes, bytes.length);
			// 创建socket并指定端口
			DatagramSocket socket = new DatagramSocket(8088);
			System.out.println("服务器端正在等待客户端连接...");
			// 接收socket客户端发送的数据。如果未收到会一致阻塞
			socket.receive(packet);
			String receiveMsg = new String(packet.getData(), 0, packet.getLength());
			System.out.println(packet.getLength());
			System.out.println(receiveMsg);
			// 关闭socket
			socket.close();
		} catch (Exception e) {
			// TODO: handle exception
			e.printStackTrace();
		}
	}

}

客户端

public class DatagramSocketClientTest {
	public static void main(String[] args) {
		try {
			// 要发送的消息
			String sendMsg = "客户端发送的消息";
			// 获取服务器的地址
			InetAddress addr = InetAddress.getByName("localhost");
			// 创建packet包对象，封装要发送的包数据和服务器地址和端口号
			DatagramPacket packet = new DatagramPacket(sendMsg.getBytes(), sendMsg.getBytes().length, addr, 8088);
			// 创建Socket对象
			DatagramSocket socket = new DatagramSocket();
			// 发送消息到服务器
			socket.send(packet);
			// 关闭socket
			socket.close();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}

}

总结： 这也是一个客户端单向发送消息到服务器端的demo，且服务器端是只等待接收一次连接请求。从示例代码中可以看到使用DatagramSocket进行通信需要将消息、消息长度和对方地址、端口号封装在DatagramPacket中，DatagramSocket发送出的每一个DatagramPacket都包含了IP地址和端口号。

六、HTTP协议

1.http和https

HTTP （Hyper Text Transfer Protocol），超文本传输协议HTTP协议被用于在Web浏览器和网站服务器之间传递信息，HTTP协议以明文方式发送内容，不提供任何方式的数据加密，如果攻击者截取了Web浏览器和网站服务器之间的传输报文，就可以直接读懂其中的信息，因此，HTTP协议不适合传输一些敏感信息，比如：信用卡号、密码等支付信息。

HTTPS（Hyper Text Transfer Protocol Secure），安全套接字层超文本传输协议，为了数据传输的安全，HTTPS在HTTP的基础上加入了SSL协议，SSL依靠证书来验证服务器的身份，并为浏览器和服务器之间的通信加密。

• http是HTTP协议运行在TCP之上。所有传输的内容都是明文，客户端和服务器端都无法验证对方的身份。
• https是HTTP运行在SSL/TLS之上，SSL/TLS运行在TCP之上。所有传输的内容都经过加密，加密采用对称加密，但对称加密的密钥用服务器方的证书进行了非对称加密。此外客户端可以验证服务器端的身份，如果配置了客户端验证，服务器方也可以验证客户端的身份。

HTTP和HTTPS的区别：

2.URL

URL 称为统一资源定位符，用于定位互联网上的某个资源。

• URL对应的path不同，获取到的页面也是不同的
• URL中的服务器的ip来确定一个服务器
• URL中的服务器端口来确定这个主机上的哪个进程
• URL中的path来确定这个进程中所管理的哪个文件/资源

代码如下（示例）：

public class URLDemo {
    public static void main(String[] args) throws MalformedURLException {
        URL ur1 = new URL("http://1oca1host/");
        System.out.println(ur1.getProtocol()); 	//协议
        System.out.println(url.getHost()); 		//主机ip
        System.out.print1n(url.getPort()); 		//端口
        System.out.println(url.getPath()); 		//文件
        System.out.print1n(url.getFile()); 		//全路径
        System.out.println(url.getQuery()); 	//参数
    }
}

下载网络资源

public class UrlDown {
    public static void main(String[] args) throws IOException {
        //1.下载地址
        URL url = new URL("xxxxxxx");

        //2.连接到这个资源HTTP
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

        InputStream inputStream = urlConnection.getInputStream();

        FileOutputStream fos = new FileOutputStream("图标.png"); //输出的名字

        byte[] buffer = new byte[1024];
        int len;
        while((len=inputStream.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }
        fos.close();
        inputStream.close();
        urlConnection.disconnect(); //断开连接
    }
}

3.HTTP方法

根据HTTP标准，HTTP请求可以使用多种请求方法。

4.HTTP状态码

HTTP状态码表示客户端HTTP请求的返回结果、标识服务器处理是否正常、表明请求出现的错误等。

5.GET和POST的区别

HTTP的底层是TCP/IP。所以GET和POST的底层也是TCP/IP，也就是说，GET/POST都是TCP链接。

总结

本次Java网络编程基础就到这里，看完记得点个赞收藏哦！