[Java知识库]java网络编程

一、网络编程概述

1、网络基础

计算机网络：

把分布在不同地理区域的计算机与专门的外部设备用通信线路互连成一个规 模大、功能强的网络系统，从而使众多的计算机可以方便地互相传递信息、 共享硬件、软件、数据信息等资源。

网络编程的目的：

直接或间接地通过网络协议与其它计算机实现数据交换，进行通讯。

网络编程中有两个主要的问题：

如何准确地定位网络上一台或多台主机；定位主机上的特定的应用

找到主机后如何可靠高效地进行数据传输

二、网络通信要素概述

如何实现网络中的主机互相通信

1. 通信双方地址
   • IP
   • 端口号
2. 一定的规则（即：网络通信协议。有两套参考模型）、
   • OSI参考模型：模型过于理想化，未能在因特网上进行广泛推广
   • TCP/IP参考模型(或TCP/IP协议)：事实上的国际标准

三、通信要素1： IP和端口号

1. IP:唯一的标识 Internet 上的计算机（通信实体）
2. 在Java中使用InetAddress类代表IP
3. IP分类：IPv4 和 IPv6 ; 万维网 和 局域网
4. 域名: www.baidu.com www.mi.com www.sina.com www.jd.com
   www.vip.com
5. 本地回路地址：127.0.0.1 对应着：localhost
6. 如何实例化InetAddress:两个方法：getByName(String host) 、 getLocalHost()
   两个常用方法：getHostName() / getHostAddress()

public class InetAdressTest {
    public static void main(String[] args) {
        try {
            InetAddress inet1 = InetAddress.getByName("192.168.10.14");
            System.out.println(inet1);

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

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

            InetAddress inet4 = InetAddress.getLocalHost();
            System.out.println(inet4);

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

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

• 端口号标识正在计算机上运行的进程（程序）
  • 不同的进程有不同的端口号
  • 被规定为一个 16 位的整数 0~65535
  • 端口分类：
    • 公认端口：0~1023。被预先定义的服务通信占用（如：HTTP占用端口 80，FTP占用端口21，Telnet占用端口23）
    • 注册端口：1024~49151。分配给用户进程或应用程序。（如：Tomcat占 用端口8080，MySQL占用端口3306，Oracle占用端口1521等）
    • 动态/私有端口：49152~65535
• 端口号与IP地址的组合得出一个网络套接字：Socket。

四、通信要素2：网络协议

网络通信协议

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

通信协议分层的思想

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

TCP和UDP

TCP协议：

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

UDP协议：

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

socket类、ServerSocket类

socket可以使一个应用从网络中读取和写入数据，不同计算机上的两个应用可以通过连接发送和接受字节流，当发送消息时，你需要知道对方的ip和端口，在java中，socket指的是java.net.Socket类。

以public Socket(String host, int port)为例，host为远程机器名称或ip地址，port为端口号。若连接本地的Server，其端口号为8080，可以写成如下格式 ：new Socket(“localhost”, 8080)；
一旦成功创建一个Socket类的实例，可以用它来发送和接收字节流，发送时调用getOutputStream方法获取一个java.io.OutputStream对象，接收远程对象发送来的信息可以调用getInputStream方法来返回一个java.io.InputStream对象。
ServerSocket类

Socket类代表一个客户端套接字，即任何时候连接到一个远程服务器应用时构建所需的socket。现在，要实现一个服务器应用，需要不同的做法。服务器需随时待命，因为不知道客户端什么时候会发来请求，此时，我们需要使用ServerSocket，对应的是java.net.ServerSocket类。
　　ServerSocket与Socket不同，ServerSocket是等待客户端的请求，一旦获得一个连接请求，就创建一个Socket示例来与客户端进行通信。

ServerSocket 有一个不带参数的默认构造方法。通过该方法创建的 ServerSocket 不与任何端口绑定，接下来还需要通过 bind()方法与特定端口绑定。这个默认构造方法的用途是，允许服务器在绑定到特定端口之前，先设置ServerSocket 的一些选项。因为一旦服务器与特定端口绑定，有些选项就不能再改变了。

把连接请求队列的长度设为 3。这意味着当队列中有了 3 个连接请求时，如果 Client 再请求连接，就会被 Server拒绝，因为服务器队列已经满了。我们使用的 serverSocket.accept()方法就是从队列中取出连接请求。

五、TCP网络编程例题

import org.junit.Test;
import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
/**
 * @author WJR
 * @create 2021-11-16 18:41
 * 客户端发信息给服务端，服务端将数据显示在控制台上
 */
public class TCPTest1 {
    //客户端
    @Test
    public void client() {
        Socket socket = null;
        OutputStream os = null;
        try {
            InetAddress inet = InetAddress.getByName("127.0.0.1");
            socket = new Socket(inet , 8899);
            os = socket.getOutputStream();
            os.write("你好我是客户端".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            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 {
            ss = new ServerSocket(8899);
            socket = ss.accept();
            is = socket.getInputStream();
            //可能有乱码
       /* byte[] buffer = new byte[20];
        int len;
        while((len = is.read(buffer))!=-1){
            String str = new String(buffer , 0 ,len);
            System.out.println(str);
        }*/
            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());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(baos != null)
            {
                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();
                }
            }
        }
    }
}

客户端向服务器发送请求可分为以下步骤： 
　　1.创建一个Socket实例 
　　2.利用I/O流与服务器进行通信 
　　3.关闭socket 
服务器接收客户端请求步骤： 
 　　１.创建一个ServerSocket实例，监听客户端发来的请求。 
　　2.与客户端获取连接后，创建一个Socket实例，利用I/O流与客户端进行通信，完毕后关闭Socket。

import org.junit.Test;

import java.io.*;
import java.net.InetAddress;
import java.net.ServerSocket;
import java.net.Socket;
/**
 * @author WJR
 * @create 2021-11-17 17:29
 * 从客户端发送文件给服务端，服务端保存到本地，并返回“发送成功”给客户端，并关闭相应的连接
 */
public class TCPTest3 {
    @Test
    public void client() throws IOException {
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1") , 9090);
        OutputStream os = socket.getOutputStream();
        FileInputStream fis = new FileInputStream(new File("IoTest.jpg"));
        byte[] buffer = new byte[1024];
        int len;
        while((len = fis.read(buffer)) != -1){
            os.write(buffer , 0 , len);
        }
        //关闭数据的输出
        socket.shutdownOutput();
//     接受服务端的反馈
        InputStream is = socket.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();//为了使数据不乱码
        byte[] bufferr = new byte[20];
        int lens;
        while((lens = is.read(bufferr)) != -1){
            baos.write(bufferr, 0 , lens);
        }
        System.out.println(baos.toString());
//        is.close();
        fis.close();
        os.close();
        socket.close();
        baos.close();
    }
    @Test
    public void server() throws IOException {
        ServerSocket ss = new ServerSocket((9090));
        Socket socket = ss.accept();
        InputStream is = socket.getInputStream();
        FileOutputStream fos = new FileOutputStream(new File("IoTest3.jpg"));
        byte[] buffer = new byte[1024];
        int len;
        while((len = is.read(buffer)) != -1){
            fos.write(buffer , 0 , len);
        }
        System.out.println("图片传输完成");
        //服务器给客户端反馈
        OutputStream os = socket.getOutputStream();
        os.write("你好客户端 ".getBytes());
        fos.close();
        is.close();
        ss.close();
        socket.close();
        os.close();
    }
}

六、UDP网络通信

public class UDPTest {

    //发送端
    @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();
    }
}

七、URL类

/**
 * URL网络编程
 * 1.URL:统一资源定位符，对应着互联网的某一资源地址
 * 2.格式：
 *  http://localhost:8080/examples/beauty.jpg?username=Tom
 *  协议   主机名    端口号  资源地址           参数列表
 *
 * @author shkstart
 * @create 2019 下午 4:47
 */
public class URLTest {
    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();
        }
    }
}