Java网络编程

Posted on 2020-11-26 Edited on 2024-07-22 In 后端 , Java基础 Views: Word count in article: 10k Reading time ≈ 10 mins.

1、InetAddres类

InetAddress类主要表示IP地址，两个子类：Inet4Address、Inet6Address。
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 class InetAddressTest {
    public static void main(String[] args) {
        try {
            InetAddress inet1 = InetAddress.getByName("192.168.10.14");
            System.out.println(inet1);// /192.168.10.14

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

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

            //获取本地ip
            InetAddress inet4 = InetAddress.getLocalHost();
            System.out.println(inet4);//zhu-PC/127.0.1.1
            
            System.out.println(inet2.getHostName());//www.baidu.com
            System.out.println(inet2.getHostAddress());//14.215.177.39
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

2、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()关闭此套接字。套接字被关闭后，便不可在以后的网络连接中使用（即无法重新连接
  或重新绑定）。需要创建新的套接字对象。关闭此套接字也将会关闭该套接字的 InputStream 和
  OutputStream。
- public void shutdownInput()如果在套接字上调用 shutdownInput() 后从套接字输入流读取内容，则流将返回 EOF（文件结束符）。即不能在从此套接字的输入流中接收任何数据。
- public void shutdownOutput()禁用此套接字的输出流。对于 TCP 套接字，任何以前写入的数据都将被发
  送，并且后跟 TCP 的正常连接终止序列。如果在套接字上调用 shutdownOutput() 后写入套接字输出流，则该流将抛出 IOException。即不能通过此套接字的输出流发送任何数据。

3、TCP网络编程

客户端Socket的工作过程包含以下四个基本的步骤：
- 创建 Socket：根据指定服务端的 IP 地址或端口号构造 Socket 类对象。若服务器端响应，则建立客户端到服务器的通信线路。若连接失败，会出现异常。
- 打开连接到 Socket 的输入/出流：使用 getInputStream()方法获得输入流，使用getOutputStream()方法获得输出流，进行数据传输。
- 按照一定的协议对 Socket 进行读/写操作：通过输入流读取服务器放入线路的信息（但不能读取自己放入线路的信息），通过输出流将信息写入线程。
- 关闭 Socket：断开客户端到服务器的连接，释放线路。
服务器程序的工作过程包含以下四个基本的步骤：
- 调用 ServerSocket(int port) ：创建一个服务器端套接字，并绑定到指定端口上。用于监听客户端的请求。
- 调用 accept()：监听连接请求，如果客户端请求连接，则接受连接，返回通信套接字对象。
- 调用该Socket类对象的 getOutputStream() 和 getInputStream ()：获取输出流和输入流，开始网络数据的发送和接收。
- 关闭ServerSocket和Socket对象：客户端访问结束，关闭通信套接字。

例1：客户端发送信息给服务端，服务端将数据显示在控制台上。

   //客户端
    @Test
    public void client()  {
        Socket socket = null;
        OutputStream os = null;
        try {
            //1.创建Socket对象，指明服务器端的ip和端口号
            InetAddress inet = InetAddress.getByName("127.0.0.1");
            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对象中的数组中
                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();
                }
            }
        }
    }

例2：客户端发送文件给服务端，服务端将文件保存在本地。

@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("hello.jpg"));
    byte[] buffer = new byte[1024];
    int len;
    while((len = fis.read(buffer)) != -1){
        os.write(buffer,0,len);
    }
    fis.close();
    os.close();
    socket.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("hello1.jpg"));
    byte[] buffer = new byte[1024];
    int len;
    while((len = is.read(buffer)) != -1){
        fos.write(buffer,0,len);
    }
    fos.close();
    is.close();
    socket.close();
    ss.close();
}

例3：从客户端发送文件给服务端，服务端保存到本地。并返回“发送成功”给客户端。

@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("beauty.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 len1;
    while((len1 = is.read(buffer)) != -1){
        baos.write(buffer,0,len1);
    }
    System.out.println(baos.toString());
    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("beauty2.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();
    socket.close();
    ss.close();
    os.close();
}

4、UDP网络编程

类 DatagramSocket 和 DatagramPacket 实现了基于 UDP 协议网络程序。
UDP数据报通过数据报套接字 DatagramSocket 发送和接收，系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。
DatagramPacket 对象封装了UDP数据报，在数据报中包含了发送端的IP地址和端口号以及接收端的IP地址和端口号。
UDP协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接。如同发快递包裹一样。
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 字段包含所接收信息的长度。如果信息比包的
  长度长，该信息将被截短。
- public InetAddress getLocalAddress()获取套接字绑定的本地地址。
- public int getLocalPort()返回此套接字绑定的本地主机上的端口号。
- public InetAddress getInetAddress()返回此套接字连接的地址。如果套接字未连接，则返回 null
- public int getPort()返回此套接字的端口。如果套接字未连接，则返回 -1。

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

5、URL编程

URL(Uniform Resource Locator)：统一资源定位符，它表示 Internet 上某一资源的地址。
它是一种具体的URI，即URL可以用来标识一个资源，而且还指明了如何locate这个资源。
通过 URL 我们可以访问 Internet 上的各种网络资源，比如最常见的 www，ftp 站点。浏览器通过解析给定的 URL 可以在网络上查找相应的文件或其他资源。
一个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/myTest.txt?username=abc");
        System.out.println(url.getProtocol());//http
        System.out.println(url.getHost());//localhost
        System.out.println(url.getPort());//8080
        System.out.println(url.getPath());// /examples/myTest.txt
        System.out.println(url.getFile());// /examples/myTest.txt?username=abc
        System.out.println(url.getQuery());//username=abc
    } catch (MalformedURLException e) {
        e.printStackTrace();
    }
}

public static void main(String[] args) {
    HttpURLConnection urlConnection = null;
    InputStream is = null;
    FileOutputStream fos = null;
    try {
        URL url = new URL("http://localhost:8080/hello.jpg");

        urlConnection = (HttpURLConnection) url.openConnection();

        urlConnection.connect();

        is = urlConnection.getInputStream();
        
        fos = new FileOutputStream("hello2.jpg");

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