【JAVA高级&网络编程】知识点整理

【JAVA高级&网络编程】知识点整理

概述

通过本篇笔记的整理,对网络通讯相关的知识点进行整理,以及巩固对 JAVA 基础体系中 “网络编程” 相关的知识点。

目录

主要内容

0x01:概述

问题一:如何准确地定位网络上一台或多台主机;以及定位主机上的特定的应用

  • IP地址
  • 端口号

问题二:找到主机后,如何可靠、高效的进行数据传输

遵循一定的规则(即:网络通信协议。有两套参考模型)

  • OSI参考模型:模型过于理想化,未能在因特网上进行广泛推广
  • TCP/IP参考模型(或TCP/IP协议):事实上的国际标准。
OSI参考模型TCP/IP参考模型TCP/IP参考模型各层对应协议
应用层应用层HTTP、FTP、Telnet、DNS…
表示层
会话层
传输层传输层TCP、UDP、…
网络层网络层IP、ICMP、ARP…
数据链路层物理+数据链路层Link

数据包的封装与解封过程

0x02:网络通讯的要素概述

要素一:IP地址和端口号

IP地址:InetAddress

  • 唯一的标识 Internet 上的计算机(通信实体)
  • 本地回环地址(hostAddress):127.0.0.1 主机名(hostName):localhost
  • IP地址分类方式一:IPV4IPV6
    • IPV4:由4个字节组成,4个0-255。大概 42亿个,其中30亿都在北美,亚洲4亿。在2011年初就已经用尽。以点分十进制表示,如 192.168.0.1
    • IPV6:128位(16个字节),写成8个无符号整数,每个整数用 4 个十六进制位表示,数之间用冒号:分开,如:3ffe:3201:1401:1280:c8ff:fe4d:db39:1984
  • IP地址分类方式二:公网地址(万维网使用)和私有地址(局域网使用)。通常192.168.以及172.16.10.开头的就是私有址址,范围即为192.168.0.0-192.168.255.255172.16.0.0-172.16.255.25510.0.0.0-10.255.255.255,专门为组织机构内部使用。

特点:不易记忆

端口号:标识正在计算机上运行的进程(程序)

  • 不同的进程有不同的端口号
  • 被规定为一个16位的整数0~65535
  • 端口分类:
    • 公认端口:0~1023。被预先定义的服务通信占用(如:HTTP占用端口80,FTP占用端口21,Telnet占用端口23)
    • 注册端口:1024~49151。分配给用户进程或应用程序。(如:Tomcat占用端口8080MySQL占用端口3306Oracle占用端口1521等)。
    • 动态/私有端口:49152~65535。

应用使用端口进行通信,如下图

  • “端口号”与“IP地址”的组合得出一个网络套接字:Socket

工具类:InetAddress

Internet上的主机有两种方式表示地址:

  • 域名(hostName):www.atguigu.com
  • IP地址(hostAddress):202.108.35.210

InetAddress 类主要表示 “IP地址” ,并且有两个子类:

  • Inet4Address

  • Inet6Address

  • InetAddress 类对象含有一个 Internet 主机地址的域名和IP地址:www.atguigu.com202.108.35.210

域名容易记忆,当在连接网络时输入一个主机的域名后,域名服务 (DNS) 负责将 "域名" 转化成 "IP地址",这样才能和主机建立连接。这个过也称作为 "域名解析" 。

InetAddress 类没有提供 “公共的构造器” ,而是提供了如下几个静态方法来获取 InetAddress 实例

  • public static InetAddress getLocalHost()
  • public static InetAddress getByName(String host)

InetAddress 提供了如下几个常用的方法

  • public String getHostAddress()

    返回 IP 地址字符串(以文本表现形式)

  • public String getHostName()

    获取此 IP 地址的主机名

  • public boolean isReachable(int timeout)

    测试是否可以达到该地址

使用例子

public static void main(String[] args) {

    try {
        //File file = new File("hello.txt");
        InetAddress inet1 = InetAddress.getByName("192.168.10.14");

        System.out.println(inet1);

        InetAddress inet2 = InetAddress.getByName("www.atguigu.com");
        System.out.println(inet2);

        InetAddress inet3 = InetAddress.getByName("127.0.0.1");
        System.out.println(inet3);

        //获取本地ip
        InetAddress inet4 = InetAddress.getLocalHost();
        System.out.println(inet4);

        //getHostName()
        System.out.println(inet2.getHostName());
        //getHostAddress()
        System.out.println(inet2.getHostAddress());

    } catch (UnknownHostException e) {
        e.printStackTrace();
    }

}

输出结果

/192.168.10.14
www.atguigu.com/223.111.24.71
/127.0.0.1
DESKTOP-OE6FHSH/192.168.43.196
www.atguigu.com
223.111.24.71

Process finished with exit code 0

要素二:网络协议

概述

网络通信协议

  • 计算机网络中实现通信必须有一些约定,即通信协议, 对速率、传输代码、代码结构、传输控制步骤、出错控制等制定标准。

问题:网络协议太复杂

  • 计算机网络通信涉及内容很多,比如指定源地址和目标地址,加密解密,压缩解压缩,差错控制,流量控制,路由控制,如何实现如此复杂的网络协议呢?

通信协议分层的思想

  • 在制定协议时,把复杂成份分解成一些简单的成份,再将它们复合起来。最常用的复合方式是层次方式,即同层间可以通信、上一层可以调用下一层,而与再下一层不发生关系。各层互不影响,利于系统的开发和扩展。

TCP/IP协议簇

  • 传输层协议中有两个非常重要的协议:
    • 传输控制协议 TCP(Transmission Control Protocol)
    • 用户数据报协议 UDP (User Datagram Protocol)。
  • TCP/IP 以其两个主要协议:传输控制协议(TCP)和网络互联协议(IP)而得名,实际上是一组协议,包括多个具有不同功能且互为关联的协议。
  • IP(Internet Protocol)协议是网络层的主要协议,支持网间互连的数据通信。
  • TCP/IP协议模型从更实用的角度出发,形成了高效的四层体系结构,即物理链路层、 IP层、传输层和应用层。

TCP和UDP概述

TCP协议:

  • 使用TCP协议前,须先建立 TCP 连接,形成传输数据通道
  • 传输前,采用 “三次握手” 方式对连接可靠性进行验证,点对点通信。
  • TCP 协议进行通信的两个应用进程:客户端、 服务端。
  • 在连接中可进行大数据量的传输。
  • 传输完毕,需释放已建立的连接, 效率低。

常见的使用场景:对数据的可靠性较高,例如即时通讯(微信、QQ等)

TCP 三次握手过程

为什么不进行第四次握手?

经过三次握手后,基本就能保证这次连接是可靠的。再进行第四次握手的花对于可靠性提升较小,且会使整个握手流程的耗时增加,性价比低。

在TCP连接结束时需要经过四次挥手,过程如下图所示

UDP 协议:

  • 将数据、源、目的封装成数据包, 不需要建立连接。
  • 每个数据报的大小限制在 64K
  • 发送不管对方是否准备好,接收方收到也不确认, 故是不可靠的。
  • 可以广播发送。
  • 发送数据结束时无需释放资源,开销小,速度快。

使用场景:对数据的可靠性要求较低,允许一部分数据的丢失、追求性能,例如 网络视频、其他流媒体、游戏等。

Socket 套接字

概述

  • 利用套接字(Socket)开发网络应用程序早已被广泛的采用,以至于成为事实上的标准。
  • 网络上具有唯一标识的 IP 地址和端口号组合在一起才能构成唯一能识别的标识符套接字。
  • 通信的两端都要有Socket,是两台机器间通信的端点。
  • 网络通信其实就是 Socket 间的通信。
  • Socket 允许程序把网络连接当成一个流, 数据在两个 Socket 间通过 IO 传输。
  • 一般主动发起通信的应用程序属客户端,等待通信请求的为服务端。

Socket的分类

  • 流套接字(stream socket):使用 TCP提供可依赖的字节流服务
  • 数据报套接字(datagram socket):使用 UDP 提供“尽力而为”的数据报服务

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()

    获取套接字绑定的本地地址。 即本端的IP地址

  • public int getPort()

    此套接字连接到的远程端口号;如果尚未连接套接字, 则返回 0。

  • public int getLocalPort()

    返回此套接字绑定到的本地端口。 如果尚未绑定套接字, 则返回 -1。 即本端的端口号。

  • public void close()

    关闭此套接字。 套接字被关闭后, 便不可在以后的网络连接中使用(即无法重新连接或重新绑定)。需要创建新的套接字对象。 关闭此套接字也将会关闭该套接字的 InputStreamOutputStream

  • public void shutdownInput()

    如果在套接字上调用 shutdownInput() 后从套接字输入流读取内容, 则流将返回 EOF(文件结束符) 。 即不能在从此套接字的输入流中接收任何数据。

  • public void shutdownOutput()

    禁用此套接字的输出流。 对于 TCP 套接字, 任何以前写入的数据都将被发送, 并且后跟 TCP 的正常连接终止序列。如果在套接字上调用 shutdownOutput() 后写入套接字输出流,则该流将抛出 IOException。 即不能通过此套接字的输出流发送任何数据。

0x03:TCP网络编程

基于Socket的TCP编程

Java 语言的基于套接字编程分为 "服务端 " 编程和 "客户端编程",其通信模型如图所示:

客户端

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

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

客户端程序可以使用 Socket 类创建对象, 创建的同时会自动向服务器方发起连接。 Socket 的构造器是:

  • Socket(String host,int port)throws UnknownHostException,IOException

    向服务器(域名是 host。端口号为port )发起 TCP连接,若成功,则创建 Socket 对象,否则抛出异常。

  • Socket(InetAddress address,int port) throws IOException

    根据 InetAddress 对象所表示的IP地址以及端口号 port 发起连接。

客户端建立 socketAtClient 对象的过程就是向服务器发出套接字连接请求

Socket s = newSocket(“192.168.40.165” ,9999);
OutputStream out = s.getOutputStream();
out.write(" hello".getBytes());
s.close();

服务端

  • 服务器程序的工作过程包含以下四个基本的步骤:
  • 调用 ServerSocket(int port) : 创建一个服务器端套接字,并绑定到指定端口上。用于监听客户端的请求。
  • 调用 accept(): 监听连接请求,如果客户端请求连接,则接受连接,返回通信套接字对象。
  • 调用 该 Socket类对象的 getOutputStream()getInputStream (): 获取输出流和输入流,开始网络数据的发送和接收。
  • 关闭 ServerSocketSocket 对象: 客户端访问结束,关闭通信套接字

ServerSocket 对象负责等待客户端 "请求建立" 套接字连接,类似邮局某个窗口中的业务员。也就是说, 服务器必须事先建立一个等待客户请求建立套接字连接的 ServerSocket 对象。

所谓“接收”客户的套接字请求,就是 accept() 方法会返回一个 Socket 对象,如下代码所示

ServerSocket ss = new ServerSocket(9999);
Socket s = ss.accept ();
InputStream in = s.getInputStream();
byte[] buf = new byte[1024];
int num = in.read(buf);
String str = new String(buf,0,num);
System.out.println(s.getInetAddress().toString()+” :” +str);
s.close();
ss.close();

案例一:实现基本的字符串收发

需求:客户端向服务端发送一个字符串,服务端收到后输出到控制台。

客户端代码

@Test
public void client()  {
    Socket socket = null;
    OutputStream os = null;
    try {
        //1.创建Socket对象,指明服务器端的ip和端口号
        InetAddress inet = InetAddress.getByName("127.0.0.1");  //IP地址可以填自己的内网IP地址
        socket = new Socket(inet,8899);
        //2.获取一个输出流,用于输出数据
        os = socket.getOutputStream();
        //3.写出数据的操作
        os.write("你好,我是客户端mm".getBytes());
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //4.资源的关闭
        if(os != null){
            try {
                os.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        if(socket != null){
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
    }

}

服务端代码

//服务端
@Test
public void server()  {

    ServerSocket ss = null;
    Socket socket = null;
    InputStream is = null;
    ByteArrayOutputStream baos = null;
    try {
        //1.创建服务器端的ServerSocket,指明自己的端口号
        ss = new ServerSocket(8899);
        //2.调用accept()表示接收来自于客户端的socket
        socket = ss.accept();
        //3.获取输入流
        is = socket.getInputStream();

        //不建议这样写,可能会有乱码
        // byte[] buffer = new byte[1024];
        //int len;
        // while((len = is.read(buffer)) != -1){
        //    String str = new String(buffer,0,len);
        //      System.out.print(str);
        //   }

        //4.读取输入流中的数据
        baos = new ByteArrayOutputStream();
        byte[] buffer = new byte[5];
        int len;
        while((len = is.read(buffer)) != -1){
            baos.write(buffer,0,len);
        }

        System.out.println(baos.toString());

        System.out.println("收到了来自于:" + socket.getInetAddress().getHostAddress() + "的数据");

    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        if(baos != null){
            //5.关闭资源
            try {
                baos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(is != null){
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(socket != null){
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(ss != null){
            try {
                ss.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

输出结果

案例二:文件的发送与接收

需求:客户端向服务端发送一个文件,服务端接收文件并且写入到本地

客户端代码

/*
    这里涉及到的异常,应该使用try-catch-finally处理
     */
@Test
public void client() throws IOException {
    //1.
    Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
    //2.
    OutputStream os = socket.getOutputStream();
    //3.
    FileInputStream fis = new FileInputStream(new File("beauty.jpg"));
    //4.
    byte[] buffer = new byte[1024];
    int len;
    while((len = fis.read(buffer)) != -1){
        os.write(buffer,0,len);
    }
    //5.
    fis.close();
    os.close();
    socket.close();
}

服务端代码

/*
    这里涉及到的异常,应该使用try-catch-finally处理
     */
@Test
public void server() throws IOException {
    //1.
    ServerSocket ss = new ServerSocket(9090);
    //2.
    Socket socket = ss.accept();
    //3.
    InputStream is = socket.getInputStream();
    //4.
    FileOutputStream fos = new FileOutputStream(new File("beauty1.jpg"));
    //5.
    byte[] buffer = new byte[1024];
    int len;
    while((len = is.read(buffer)) != -1){
        fos.write(buffer,0,len);
    }

    System.out.println("文件接收成功!");

    //6.
    fos.close();
    is.close();
    socket.close();
    ss.close();

}

运行结果如下

并且将接收到的文件写入到了本地

在上述的代码基础上,我们增加一个功能:服务端接收到文件后, 向客户端返回一个 “接收成功” 的消息给客户端。

客户端代码,作出以下的修改

  • 完成文件的发送后,使用 shutdownOutput() 关闭输出流
  • 并构建一个"输入流"输入流,接收服务端的反馈信息
/*
        这里涉及到的异常,应该使用try-catch-finally处理
         */
@Test
public void client() throws IOException {
    //1.
    Socket socket = new Socket(InetAddress.getByName("127.0.0.1"),9090);
    //2.
    OutputStream os = socket.getOutputStream();
    //3.
    FileInputStream fis = new FileInputStream(new File("beauty.jpg"));
    //4.
    byte[] buffer = new byte[1024];
    int len;
    while((len = fis.read(buffer)) != -1){
        os.write(buffer,0,len);
    }
    //关闭数据的输出
    socket.shutdownOutput();

    //5.接收来自于服务器端的数据,并显示到控制台上
    InputStream is = socket.getInputStream();
    ByteArrayOutputStream baos = new ByteArrayOutputStream();
    byte[] bufferr = new byte[20];
    int len1;
    while((len1 = is.read(buffer)) != -1){
        baos.write(buffer,0,len1);
    }

    System.out.println(baos.toString());

    //6.
    fis.close();
    os.close();
    socket.close();
    baos.close();
}

服务端代码,作出以下的修改

  • 在完成文件的接收后,创建一个输出流向客户端发送指定的字符串信息
/*
    这里涉及到的异常,应该使用try-catch-finally处理
     */
    @Test
    public void server() throws IOException {
        //1.
        ServerSocket ss = new ServerSocket(9090);
        //2.
        Socket socket = ss.accept();
        //3.
        InputStream is = socket.getInputStream();
        //4.
        FileOutputStream fos = new FileOutputStream(new File("beauty2.jpg"));
        //5.
        byte[] buffer = new byte[1024];
        int len;
        while((len = is.read(buffer)) != -1){
            fos.write(buffer,0,len);
        }

        System.out.println("图片传输完成");

        //6.服务器端给予客户端反馈
        OutputStream os = socket.getOutputStream();
        os.write("你好,美女,照片我已收到,非常漂亮!".getBytes());

        //7.
        fos.close();
        is.close();
        socket.close();
        ss.close();
        os.close();

    }

输出结果

服务端

客户端

接收到的文件写入到本地

0x04:UDP网络编程

需求:发送端(客户端)向接收端你发送一段字符串信息,接收端(服务端)接收到数据后输出到控制台

发送端代码如下

//发送端
@Test
public void sender() throws IOException {

    DatagramSocket socket = new DatagramSocket();

    String str = "我是UDP方式发送的导弹";
    byte[] data = str.getBytes();
    InetAddress inet = InetAddress.getLocalHost();
    DatagramPacket packet = new DatagramPacket(data,0,data.length,inet,9090);

    socket.send(packet);

    socket.close();

}

接收端代码如下

//接收端
@Test
public void receiver() throws IOException {

    DatagramSocket socket = new DatagramSocket(9090);

    byte[] buffer = new byte[100];
    DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length);

    socket.receive(packet);

    System.out.println(new String(packet.getData(),0,packet.getLength()));

    socket.close();
}

输出结果如下

在以 UDP 方式进行传输数据时,发送端无需等待服务端的确认(无论是否连接成功),相对于以 TCP 的方式进行传输时,如果客户端无法连接到服务端,会抛出 ConnectException 异常 ,如下

0x05:URL编程

URL(Uniform Resource Locator):统一资源定位符,它表示 Internet 上某一资源的地址。

通过 URL 我们可以访问 Internet 上的各种网络资源,比如最常见的 wwwftp 站点。浏览器通过解析给定的 URL 可以在网络上查找相应的文件或其他资源。

URL 的基本结构由 5 部分组成:

<传输协议>://<主机名>:<端口号>/<文件名>#片段名?参数列表

例如:

http://192.168.1.100:8080/helloworld/index.jsp#a?username=shkstart&password=123

片段名:即锚点,例如看小说,直接定位到章节

参数列表格式:参数名=参数值&参数名=参数值....

为了表示 URLjava.net 中实现了类 URL。我们可以通过下面的构造器来初始化一个 URL 对象:

  • public URL (String spec):

    通过一个表示URL地址的字符串可以构造一个URL对象。

    例如: URL url = new URL ("http://www. atguigu.com/");

  • public URL(URL context, String spec):

    通过 “基URL” 和 “相对 URL” 构造一个 "URL对象"。

    例如: URL downloadUrl = new URL(url, “download.html")

  • public URL(String protocol, String host, String file);

    例如: new URL("http","www.atguigu.com", “download. html");

  • public URL(String protocol, String host, int port, String file);

    例如: URL gamelan = newURL("http", "www.atguigu.com", 80, “download.html");

URL 类的构造器都声明抛出非运行时异常,必须要对这一异常进行处理,通常是用 try-catch 语句进行捕获 。

一个 URL 对象生成后,其属性是不能被改变的,但可以通过它给定的方法来获取这些属性:

  • public String getProtocol( )

    获取该URL的协议名

  • public String getHost( )

    获取该URL的主机名

  • public String getPort( )

    获取该URL的端口号

  • public String getPath( )

    获取该URL的文件路径

  • public String getFile( )

    获取该URL的文件名

  • public String getQuery( )

    获取该URL的查询名

如下案例

public static void main(String[] args) {

    try {

        URL url = new URL("http://localhost:8080/examples/beauty.jpg?username=Tom");

        //            public String getProtocol(  )     获取该URL的协议名
        System.out.println(url.getProtocol());
        //            public String getHost(  )           获取该URL的主机名
        System.out.println(url.getHost());
        //            public String getPort(  )            获取该URL的端口号
        System.out.println(url.getPort());
        //            public String getPath(  )           获取该URL的文件路径
        System.out.println(url.getPath());
        //            public String getFile(  )             获取该URL的文件名
        System.out.println(url.getFile());
        //            public String getQuery(   )        获取该URL的查询名
        System.out.println(url.getQuery());

    } catch (MalformedURLException e) {
        e.printStackTrace();
    }

}

输出结果

http
localhost
8080
/examples/beauty.jpg
/examples/beauty.jpg?username=Tom
username=Tom

Process finished with exit code 0

案例:将图片文件下载至本地

public static void main(String[] args) {

    HttpURLConnection urlConnection = null;
    InputStream is = null;
    FileOutputStream fos = null;
    try {
        URL url = new URL("https://uposs.codeyee.com/blog/chrome_sHWOX5JaYu.png");

        urlConnection = (HttpURLConnection) url.openConnection();

        urlConnection.connect();

        is = urlConnection.getInputStream();
        fos = new FileOutputStream("day10\\blog.png");

        byte[] buffer = new byte[1024];
        int len;
        while((len = is.read(buffer)) != -1){
            fos.write(buffer,0,len);
        }

        System.out.println("下载完成");
    } catch (IOException e) {
        e.printStackTrace();
    } finally {
        //关闭资源
        if(is != null){
            try {
                is.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(fos != null){
            try {
                fos.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        if(urlConnection != null){
            urlConnection.disconnect();
        }
    }


}

运行结果

成功将文件下载至本地

预览文件

总结

通过上述的内容的复习整理,巩固了 JAVA 的网络编程相关的知识点,例如通过编写 JAVA 代码来实现“文件、数据”在不同协议下的网络传输,以及其一些相关的理论知识。

Copyright: 采用 知识共享署名4.0 国际许可协议进行许可

Links: https://codeyee.com/archives/java-socket.html