Java——网络编程

寻梦人12138

已于 2024-03-15 08:44:49 修改

阅读量925

点赞数 23

分类专栏： Java 文章标签：服务器 java

于 2024-03-15 08:43:42 首次发布

本文链接：https://blog.csdn.net/weixin_44212870/article/details/136727363

版权

Java 专栏收录该内容

25 篇文章 0 订阅

订阅专栏

网络编程基础类

InetAddress类

java.net.InetAddress类用来封装计算机的IP地址和DNS(没有端口信息),它包括一个主机名和一个ip地址,是java对IP地址的高层表示。大多数其他网络类都要用到这个类，包括Sorket、ServerSocker、URL、DatagramSorket、DatagramPacket等
常用静态方法

- getLocalHost()得到本机的InetAddress对象,其中封装了IP地址和主机名
- getByName(String host)传入目标主机的名字或IP地址得到对应的InetAddress对象,其中封装了IP地址和主机名(底层会自动连接DNS服务器进行域名解析)

常用实例方法

- getHostAddress() 获取IP地址
- getHostName() 获取主机名/域名

public class Test01 {
    public static void main(String[] args) throws UnknownHostException {
        //获取本机InetAddress对象(包含ip地址和封装对象)
        InetAddress ia = InetAddress.getLocalHost();

        //获取本机ip地址
        String ip = ia.getHostAddress();

        //获取本机主机名
        String hostName = ia.getHostName();

        System.out.println(ip + " -> " + hostName); //10.6.43.36 -> DESKTOP-D4BI28V

        //通过getByName(String host) 获取指定地址的InetAddress对象
        InetAddress baidu = InetAddress.getByName("baidu.com");
        System.out.println(baidu.getHostAddress()); //39.156.66.10
        System.out.println(baidu.getHostName()); //baidu.com
    }
}

URL类

URL由4部分组长城：协议、存放资源的主机域名、端口号、资源文件名。未指定端口号则使用协议默认的端口
标准格式 <协议>://<域名/IP>:<端口号>/<路径>

- <协议>://<域名/IP>是必须的
- <端口号>/<路径>有时可省略

为了方便程序员编程，JDK中提供了URL类，该类的全名是java.net.URL，该类封装了大量复杂的涉及从远程站点获取信息的细节，可以使用它的各种方法来对URL对象进行分割、合并等处理

- 构造方法

- - Url url = new URL(String url);

- 常用方法

- - 获取协议

- - - url.getPtotocol()

- - 获取域名

- - - url.getHost()

- - 获取默认端口

- - - url.getDefaultPort()

- - 获取端口

- - - url.getPort()

- - 获取路径

- - - url.getPath()

- - 获取资源

- - - url.getFile()

- - 获取数据

- - - url.getQuery()

- - 获取锚点

- - - url.getRef()

public class Test01 {
    public static void main(String[] args) throws UnknownHostException, MalformedURLException {
        URL url = new URL("https://www.baidu.com/s?wd=%E5%BC%A0%E4%B8%89&rsv_spt=1&rsv_iqid=0x901ef519004b0a02&issp=1&f=8&rsv_bp=1&rsv_idx=2&ie=utf-8&rqlang=&tn=baiduhome_pg&ch=&rsv_enter=1&rsv_btype=i&rsv_dl=ib&inputT=2117");

        //获取协议
        String protocol = url.getProtocol();
        System.out.println("协议" + protocol);
        //获取域名
        String host = url.getHost();
        System.out.println("域名" + host);
        //获取默认端口
        int defaultPort = url.getDefaultPort();
        System.out.println("默认端口" + defaultPort);
        //获取端口
        int port = url.getPort();
        System.out.println("端口" + port);
        //获取路径
        String path = url.getPath();
        System.out.println("路径" + path);
        //获取资源
        String file = url.getFile();
        System.out.println("资源" + file);
        //获取数据
        String query = url.getQuery();
        System.out.println("数据" + query);
        //获取锚点
        String ref = url.getRef();
        System.out.println("锚点" + ref);
    }
}

- 使用URL类的openStream()方法可以打开到此URL的连接并返回一个用于从该链接读入的InputStream,实现最简单的网络爬虫

public class Test01 {
    public static void main(String[] args){
        //获取URL对象指向tianqi.qq.com
        URL url = null;
        InputStream is = null;
        BufferedReader br = null;
        try {
            url = new URL("https://tianqi.qq.com/");

            //获取简单输入流
            is = url.openStream();

            //通过转换流获取包装流
            br = new BufferedReader(new InputStreamReader(is));


            String str = null;

            while ((str = br.readLine()) != null) {
                System.out.println(str);
            }
        } catch (MalformedURLException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
        finally {
            //关闭流
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

TCP协议用到的类

Socket套接字类

我们开发的网络应用程序位于应用层，TCP和UDP属于传输层协议，在应用层如何使用传输层的服务呢?在应用层和传输层之间，则是使用套接Socket来进行分离。
套接字就像是传输层为应用层开的一个小口，应用程序通过这个小口向远程发送数据，或者接收远程发来的数据。而这个小口以内，也就是数据进入这个口之后，或者数据从这个口出来之前，是不知道也不需要知道的，也不会关心它如何传输，这属于网络其它层次工作。
Socket实际是传输层供给应用层的编程接口。Socket就是应用层与传输层之间的桥梁。使用Socket编程可以开发客户机和服务器应用程序，可以在本地网络上进行通信，也可通过Internet在全球范围内通信。
TCP协议和UDP协议是传输层的两种协议。Socket是传输层供给应用层的编程接口，所以Socket编程就分为TCP编程和UDP编程两类。

构造方法

public Socket(InetAddress a,int p)

- 创建套接字并连接到指定IP地址的端口号

public Socket(String ip,int p)

- 创建套接字并连接到指定IP地址的端口号

实例方法

- getInetAddress()

- - 返回此Socket对象连接到的ip地址

- getInputStream()

- - 返回此Soket对象的输入流（接收网络消息）

- getOutputStream()

- - 返回此Soket对象的输出流(发送网络消息)

- shutdownInput()

- - 禁用此Soket对象的输入流

- shutdownOutput()

- - 禁用此Soket对象的输出流

- close()

- - 关闭此Soket对象(默认会关闭IO流)

ServerSocket类

ServerSocket类用于实现服务器套接字（Server服务端）。服务器套接字等待请求通过网络传入。它基于该请求执行某些操作，然后可能向请求者返回结果

构造方法

- public ServerSocket(int port)

实例方法

- accept()

- - 侦听要连接此Socket并接受它

- getInetAddress()

- - 返回此服务器套接字的本地地址

- close()

- - 关闭此套接字

UDP协议用到的的类

DatagramPacket类

DatagramSocket类作为基于UDP协议的Socket,使用DatagramSocket类可以用于接收和发送数据,同时创建接收端时还需指定端口号
构造方法

- DatagramSocket()

- - 创建发送端的数据报套接字

- DatagramSocket(int port)

- - 创建接收端的数据报套接字并指定端口号

实例方法

- send(DatagramPacket p)

- - 发送数据报

- receive(DatagramPacket p)

- - 接收数据报

- close()

- - 关闭数据报套接字

DatagramPacket类

DatagramPacket类负责把发送的数据打包(打包的数据为byte类型的数组)，并且创建发送端时需指定接收端的IP地址和端口
构造方法

- DatagramPacket(byte bufp[],int offset,int length)

- - 创建接收端的数据

- DatagramPacket(byte bufp[],int offset,int length,InetAddress address,int port)

- - 创建发送端的数据

实例方法

- public synchronized byte[] getDate()

- - 返回数据报中存储的数据

- public synchronized int getLength()

- - 获得发送或接收数据报中的长度

基于TCP协议的程序

服务端与客户端的单项通讯（client -> server）

public class Server {
    public static void main(String[] args) {
        //新建ServerSocket对象
        ServerSocket server = null;
        Socket client = null;
        BufferedReader br = null;
        try {

            int port = 8888;

            server = new ServerSocket(port);
            System.out.println("服务器启动成功，端口号为" + port);
            //服务端开始侦听并接收请求，获取到来自服务端的Socket对象
            client = server.accept();
            System.out.println("已经与" + client.getInetAddress() + ':' + client.getPort() + "建立连接");

            //获取服务端输入流
            br = new BufferedReader(new InputStreamReader(client.getInputStream()));
            System.out.println(br);

            String str = null;

            while ((str = br.readLine()) != null) {
                System.out.println("客户端:");
                System.out.println(str);
            }

        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (server != null) {
                try {
                    server.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }

            if (client != null) {
                try {
                    client.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

public class Client {
    public static void main(String[] args) {
        //创建客户端Socket对象
        Socket client = null;
        BufferedWriter bw = null;
        try {
            InetAddress localHost = InetAddress.getLocalHost();
            client = new Socket(localHost,8888);
            //client = new Socket("127.0.0.1",8888); 传ip地址也可以

            //转换为增强字符流
            bw = new BufferedWriter(new OutputStreamWriter(client.getOutputStream()));

            Scanner sc = new Scanner(System.in);
            //发送内容
            while (true) {
                bw.write(sc.next() + '\n');
                bw.flush();
                Thread.sleep(1000L);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } finally {
            if (client != null) {
                try {
                    client.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

细节：readLine()是读一行，因此必须有换行符才能连续读取

服务端客户端双向通信(客户端--->服务端-->客户端)

public class Server {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket clientSocket = null;
        BufferedInputStream bis = null;
        BufferedOutputStream bos = null;
        BufferedWriter bw = null;

        try {
            //新建服务器对象
            serverSocket = new ServerSocket(8888);

            //开始侦听8888端口接受连接并返回Socket套接字对象
            clientSocket = serverSocket.accept();
            System.out.println("已经连接到" + clientSocket.getInetAddress() + ':' + clientSocket.getPort());

            //获取缓冲字节输入/出流,缓冲字符输出流
            bis = new BufferedInputStream(clientSocket.getInputStream());
            bos = new BufferedOutputStream(new FileOutputStream("C:\\temp\\temp2.png"));
            bw = new BufferedWriter(new OutputStreamWriter(clientSocket.getOutputStream()));

            byte[] bytes = new byte[1024];

            int i = 0;
            int len = 0;
            while ((len = bis.read(bytes)) != -1) {
                bos.write(bytes,0,len);
                //刷新缓冲流
                bos.flush();
            }

            bw.write("传输成功");
            //传输完成,返回信息
            bw.flush();

        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (serverSocket == null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (clientSocket != null) {
                try {
                    clientSocket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (bis != null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (bw != null) {
                try {
                    bw.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

public class Client {
    public static void main(String[] args) {
        Socket clientSocket = null;
        BufferedOutputStream bos = null;
        BufferedInputStream bis = null;

        BufferedReader br = null;

        try {
            //创建客户端Socket
            clientSocket = new Socket(InetAddress.getLocalHost(),8888);
            //获取缓冲输出/入字节流,缓冲字符输入流
            bis = new BufferedInputStream(new FileInputStream(new File("C:\\temp\\temp1.png")));
            bos = new BufferedOutputStream(clientSocket.getOutputStream());
            br = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));

            byte[] bytes = new byte[1024];
            //发送图片
            int len = 0;
            while ((len = bis.read(bytes)) != -1) {
                //发送图片
                bos.write(bytes,0,len);
                //刷新缓冲流
                bos.flush();
                len = bis.read(bytes);
            }

            //输出结束，Server端停止接收数据
            clientSocket.shutdownOutput();

            String str = null;
            //等待接收消息
            while ((str = br.readLine()) != null) {
                System.out.println(str);
            }


        } catch (UnknownHostException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (clientSocket != null) {
                try {
                    clientSocket.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (bos != null) {
                try {
                    bos.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (bis != null) {
                try {
                    bis.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            if (br != null) {
                try {
                    br.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }
    }
}

细节

- 服务端的输入流是从客户端得到的，客户端while循环结束后，服务器仍在监听客户端，等待客户端发送消息，因此客户端不会继续往下执行,必须调用shutdownOutput()方法，声明输出流已停止输出，客户端才会继续往下执行

基于UDP协议的程序

public class Recive {
    public static void main(String[] args) {
        DatagramSocket recive = null;
        DatagramPacket datagramPacket = null;
        try {
            //新建接收端DatagramSocket对象
            recive = new DatagramSocket(8888);

            //创建数据包
            byte[] bytes = new byte[1024];
            datagramPacket = new DatagramPacket(bytes,0,bytes.length);
            //接收数据报
            recive.receive(datagramPacket);

            //转实际长度
            System.out.println(new String(bytes,0,datagramPacket.getLength()));

        } catch (SocketException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (recive != null) {
                recive.close();
            }
        }
    }
}

public class Send {
    public static void main(String[] args) {
        DatagramSocket send = null;
        DatagramPacket datagramPacket = null;

        try {
            //新建发送端DatagramSocket对象
            send = new DatagramSocket();

            //准备要发送的数据
            byte[] bytes = "Hello,world".getBytes();

            //创建发送包
            datagramPacket = new DatagramPacket(bytes,0,bytes.length,InetAddress.getByName("127.0.0.1"),8888);
            //发送数据
            send.send(datagramPacket);
        } catch (SocketException e) {
            throw new RuntimeException(e);
        } catch (UnknownHostException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        } finally {
            if (send != null) {
                send.close();
            }
        }
    }
}