Java网络编程

目录

一 网络编程概念

1 软件结构

2 概念

3 网络通信协议

4 网络编程三要素

二 TCP通信程序

1 概述

2 Socket类

3 ServerSocket类

4 简单的TCP网络程序

5 文件上传程序

6 总结

三 UDP通信

1 DatagramPacket类

2 DatagramSocket类

四 InetAddress类

---

一 网络编程概念

1 软件结构

C/S结构：全称为Cilent/Server结构，是指客户端和服务器结构。常见有QQ，迅雷等软件。

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

2 概念

网络编程就是在一定的协议下，实现两台计算机的通信的程序。

3 网络通信协议

网络通信协议：通信协议是对计算机必须遵守的规则，只有遵守这些规则，计算机之间才能进行通信。协议中对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守，最终完成数据交换。

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

 java.net 包中提供了两种常见的网络协议的支持：

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

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

第一次握手，客户端向服务器端发出连接请求，等待服务器确认。

第二次握手，服务器端向客户端回送一个响应，通知客户端收到了连接请求。

第三次握手，客户端再次向服务器端发送确认信息，确认连接。整个交互过程如下图所示。

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

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

4 网络编程三要素

三要素分别是：协议，IP地址和端口号。

协议：计算机网络通信必须遵守的规则

IP 地址：指互联网协议地址（ Internet Protocol Address ） ，俗称 IP 。 IP 地址用来给一个网络中的计算机设备做唯一的编号。

常用命令

查看本机IP地址，在控制台输入：ipconfig

检查网络是否连通，在控制台输入：ping 空格 IP地址

特殊的IP地址

本机IP地址：127.0.0.1

端口号

网络的通信，本质上是两个进程（应用程序）的通信。如果说IP地址可以唯一标识网络中的设备，那么端口号就可以唯一标识设备中的进程（应用程序）了。

端口号：用两个字节表示的整数，它的取值范围是0~65535。其中，0~1023之间的端口号用于一些知名的网络服务和应用，普通的应用程序需要使用1024以上的端口号。如果端口号被另外一个服务或应用所占用，会导致当前程序启动失败。

利用 协议 + IP地址 + 端口号 三元组合，就可以标识网络中的进程了，那么进程间的通信就可以利用这个标识与其它进程进行交互。

二 TCP通信程序

1 概述

TCP通信能实现两台计算机之间的数据交互，通信的两端，要严格区分为客户端（Client）与服务端（Server）。

两端通信时步骤：

1. 服务端程序，需要事先启动，等待客户端的连接。
2. 客户端主动连接服务器端，连接成功才能通信。服务端不可以主动连接客户端。 

在Java中，提供了两个类用于实现TCP通信程序：

1. 客户端： java.net.Socket 类表示。创建 Socket 对象，向服务端发出连接请求，服务端响应请求，两者建立连接开始通信。
2. 服务端： java.net.ServerSocket类表示。创建 ServerSocket 对象，相当于开启一个服务，并等待客户端的连接。

2 Socket类

 

Socket 类：该类实现客户端套接字，套接字指的是两台设备之间通讯的端点。

构造方法

public Socket(String host, int port) ：创建套接字对象并将其连接到指定主机上的指定端口号。如果指定的host是null ，则相当于指定地址为回送地址。回送地址(127.x.x.x) 是本机回送地址（Loopback Address），主要用于网络软件测试以及本地机进程间通信，无论什么程序，一旦使用回送地址发送数据，立即返回，不进行任何网络传输。

举例：Socket client = new Socket("127.0.0.1", 6666);

成员方法

1. public InputStream getInputStream() ： 返回此套接字的输入流。

• 如果此Scoket具有相关联的通道，则生成的InputStream 的所有操作也关联该通道。
• 关闭生成的InputStream也将关闭相关的Socket。

2. public OutputStream getOutputStream() ： 返回此套接字的输出流。

• 如果此Scoket具有相关联的通道，则生成的OutputStream 的所有操作也关联该通道。
• 关闭生成的OutputStream也将关闭相关的Socket。

3. public void close() ：关闭此套接字。

• 一旦一个socket被关闭，它不可再使用。
• 关闭此socket也将关闭相关的InputStream和OutputStream 。

4. public void shutdownOutput() ： 禁用此套接字的输出流。

• 任何先前写出的数据将被发送，随后终止输出流。  

3 ServerSocket类

ServerSocket类：这个类实现了服务器套接字，该对象等待通过网络的请求。

构造方法

public ServerSocket(int port) ：使用该构造方法在创建ServerSocket对象时，就可以将其绑定到一个指定的端口号上，参数port就是端口号。

举例：ServerSocket server = new ServerSocket(6666);

成员方法

public Socket accept() ：侦听并接受连接，返回一个新的Socket对象，用于和客户端实现通信。该方法会一直阻塞直到建立连接。 

4 简单的TCP网络程序

TCP通信分析步骤

1. 【服务端】启动,创建ServerSocket对象，等待连接。
2. 【客户端】启动,创建Socket对象，请求连接。
3. 【服务端】接收连接,调用accept方法，并返回一个Socket对象。
4. 【客户端】Socket对象，获取OutputStream，向服务端写出数据。
5. 【服务端】Scoket对象，获取InputStream，读取客户端发送的数据。

   ---

   到此，客户端想服务端发送数据成功。并且服务端向客户端回写数据。

6. 【服务端】Socket对象，获取OutputStream，向客户端回写数据。
7. 【客户端】Scoket对象，获取InputStream，解析回写数据。
8. 【客户端】释放资源，断开连接。

程序演示客户端向服务器发送数据，服务器将客户端发送的数据接受并解析打印到控制台上，然后服务器再向客户端回写数据，客户端将回写的数据解析并打印到控制台上。

服务器端程序

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class ServerTcp {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器启动，等待连接");
        //1.创建ServerSocket对象，绑定端口，开始等待连接
        ServerSocket serverSocket = new ServerSocket(6666);
        //2.接受连接accept方法，返回socket对象
        Socket server = serverSocket.accept();
        //3.通过socket获取输入流
        InputStream is = server.getInputStream();
        //4.一次性读取数据
        //4.1创建字节数组
        byte[] b = new byte[1024];
        //4.2读取数据到字节数组中
        int len = is.read(b);
        //4.3解析数据，打印字符串信息
        String msg = new String(b,0,len);
        System.out.println(msg);

        //=======================回写数据=========================
        //5.通过socket获取输出流
        OutputStream out = server.getOutputStream();
        //6.回写数据
        out.write("我很好，谢谢你".getBytes());
        //7.关闭资源
        out.close();
        is.close();
        server.close();
    }
}

 客户端程序

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class ClientTcp {
    public static void main(String[] args) throws IOException {
        System.out.println("客户端 发送数据");
        //1.创建Socket(ip,port) ，确定连接到哪里
        Socket clinet = new Socket("localhost",6666);
        //2.获取流对象，输出流
        OutputStream os = clinet.getOutputStream();
        //3.写出数据
        os.write("你好么？tcp，我来了".getBytes());
        //===================解析回写============================
        //4.通过socket，获取输入流对象
        InputStream in = clinet.getInputStream();
        //5.读取数据
        byte[] b = new byte[100];
        int len = in.read(b);
        System.out.println(new String(b,0,len));
        //6.关闭资源
        in.close();
        os.close();
        clinet.close();
    }
}

5 文件上传程序

1. 【客户端】输入流，从硬盘读取文件数据到程序中。
2. 【客户端】输出流，写出文件数据到服务端。
3. 【服务端】输入流，读取文件数据到服务端程序。
4. 【服务端】输出流，写出文件数据到服务器硬盘中。
5. 【服务端】获取输出流，回写数据。
6. 【客户端】获取输入流，解析回写数据。

服务器端

import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

public class FileUpload_Server {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器启动");
        //1.创建服务器端ServerSocket
        ServerSocket serverSocket = new ServerSocket(6666);
        //2.循环接受，建立连接
        while(true){
            Socket accept = serverSocket.accept();
            /**
             * 3.socket对象交给子线程处理，进行读写操作
             *   Runnable接口中，只有一个run方法，使用lambda表示式简化格式
             */
            new Thread(()->{
                try{
                    //3.创建流对象
                    //3.1获取输入流，读取文件数据
                    BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
                    //3.2创建输出流，保存到本地
                    BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.ipg"));
                    //3.3.读写数据
                    byte[] b = new byte[1024*8];
                    int len;
                    while((len = bis.read(b))!=-1){
                        bos.write(b,0,len);
                    }

                    //4.==================信息回写=================================
                    System.out.println("back....");
                    OutputStream out = accept.getOutputStream();
                    out.write("上传成功".getBytes());
                    out.close();

                    //5.关闭资源
                    bos.close();
                    bis.close();
                    accept.close();
                    System.out.println("文件已上传并保存");
                }catch (IOException e){
                    e.printStackTrace();
                }
            }).start();
        }



    }
}

客户端

import java.io.*;
import java.net.Socket;

public class FileUpload_Client {
    public static void main(String[] args) throws IOException {
        //1.创建流对象
        //1.1创建输入流，读取本地文件
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("test.jpg"));
        //1.2创建输出流，写到服务端
        Socket socket = new Socket("localhost",6666);
        BufferedOutputStream bos = new BufferedOutputStream(socket.getOutputStream());
        //2.写出数据
        byte[] b = new byte[1024*8];
        int len;
        while((len = bis.read(b))!=-1){
            bos.write(b,0,len);
        }
        //3.关闭输出流，通知服务端，写出数据完毕
        socket.shutdownOutput();
        System.out.println("文件发送完毕");
        //4.=================解析回写========================
        InputStream in = socket.getInputStream();
        byte[] back = new byte[20];
        in.read(back);
        System.out.println(new String(back));
        in.close();
        //5.释放资源
        bos.close();
        socket.close();
        bis.close();
        System.out.println("文件上传完毕");
    }
}

6 总结

TCP程序交互的流程

客户端：

1,创建客户端的Socket对象

2,获取Socket的输出流对象

3,写数据给服务器

4,获取Socket的输入流对象

5，使用输入流，读反馈信息

6,关闭流资源

服务器端：

1，创建服务器端ServerSocket对象，指定服务器端端口号

2，开启服务器，等待着客户端Socket对象的连接，如有客户端连接，返回客户端的Socket对象

3,通过客户端的Socket对象，获取客户端的输入流，为了实现获取客户端发来的数据

4,通过客户端的输入流，获取流中的数据

5,通过客户端的Socket对象，获取客户端的输出流，为了实现给客户端反馈信息

6,通过客户端的输出流，写数据到流中

7,关闭流资源

三 UDP通信

在UPD通信中有2个常用的类,一个是数据包类DatagramPacket，一个是数据包发送接收器类DatagramSocket

1 DatagramPacket类

前面介绍了UDP是一种面向无连接的协议，因此，在通信时发送端和接收端不用建立连接。

在创建发送端和接收端的DatagramPacket对象时，使用的构造方法有所不同，接收端的构造方法只需要接收一个字节数组来存放接收到的数据，而发送端的构造方法不但要接收存放了发送数据的字节数组，还需要指定发送端IP地址和端口号。

DatagramPacket构造方法

DatagramPacket(byte[] buf,int  length) ：构造DatagramPacket，用来接收长度为length的数据包。

DatagramPacket(byte[]  buf, int length, InetAddress address, int port)：构造数据报包，用来将长度为length的包发送到指定主机上的指定端口号。

常用方法

InetAddress getAddress() 返回某台机器的IP地址，此数据报将要发往该机器或者是从该机器接受到的。

int getPort()  返回某台远程主机的端口号，此数据报将要发往该主机或者是从该主机接受到的。

byte[] getData()   返回数据缓冲区

int getLength()  返回将要发送或接受到的数据的长度

2 DatagramSocket类

使用这个类的实例对象就可以发送和接收DatagramPacket数据包

构造方法：

• 发送端：构造方法中可以指定端口号也可以不指定端口号
• 接收端：构造方法中必须要指定端口号

常用方法

void receive(DatagramPacket p)  从此套接字接受数据报包

void send(DatagramPacket p) 从此套接字发送数据报包

 发送端

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

public class UDPSender {
    /**
     * 发送端
     * 1.创建DatagramSocket对象
     * 2.创建DatagramPacket对象，并封装数据
     * 3.发送数据
     * 4.释放资源
     */
    public static void main(String[] args) throws IOException {
        //1.创建DatagramSocket对象
        DatagramSocket ds = new DatagramSocket();
        //2.创建DatagramPacket对象，并封装数据
        //2.1构造数据报包，用来将长度为length的包发送到指定主机上的指定端口号
        byte[] buffer = "hello.UDP".getBytes();
        InetAddress ip = InetAddress.getByName("127.0.0.1");
        int port = 12345;
        DatagramPacket dp = new DatagramPacket(buffer,buffer.length,ip,port);
        //3.发送数据
        ds.send(dp);
        //4.释放资源
        ds.close();
    }
}

接收端

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

public class UDPReceiver {
    /**
     * UDP接收端
     * 1.创建DatagramSocket对象
     * 2.创建DatagramPacket对象
     * 3.接收数据存储到DatagramPacket对象中
     * 4.获取DatagramPacket对象的内容
     * 5.释放资源
     */
    public static void main(String[] args) throws IOException {
        //1.创建DatagramSocket对象，并指定端口号
        int port = 12345;
        DatagramSocket ds = new DatagramSocket(port);
        byte[] buffer = new byte[1024];
        DatagramPacket dp = new DatagramPacket(buffer,1024);
        System.out.println("等待发送端发送数据");
        ds.receive(dp);
        InetAddress inetAddress = dp.getAddress();
        String ip = inetAddress.getHostAddress();
        byte[] data = dp.getData();
        int length = dp.getLength();
        String dataStr = new String(data,0,length);
        System.out.println("IP地址："+ip+"数据是"+dataStr);
        ds.close();
    }
}

四 InetAddress类

列举了InetAddress的四个常用方法：

• 前两个方法用于获得该类的实例对象，
• 第一个方法用于获得表示指定主机的InetAddress对象，
• 第二个方法用于获得表示本地的InetAddress对象。
• 另外通过InetAddress对象便可获取指定主机名，IP地址等

import java.net.*;

// INetAddress实例
public class INetAddressDemo {
    public static void main(String[] args) throws UnknownHostException {
        InetAddress local = InetAddress.getLocalHost();
        System.out.println(local);      // 打印格式: 用户名/IP地址
        InetAddress remote = InetAddress.getByName("www.baidu.com");

        System.out.println("本机的IP地址：" + local.getHostAddress());
        System.out.println("本机的主机名为: " + local.getHostName());
        System.out.println("itcast的IP地址：" + remote.getHostAddress());
        System.out.println("itcast的主机名为：" + remote.getHostName());
    }
}