20、网络编程

最新推荐文章于 2022-05-06 21:23:08 发布

wiscourper_

最新推荐文章于 2022-05-06 21:23:08 发布

阅读量819

点赞数

分类专栏： java 文章标签： java 开发语言后端

本文链接：https://blog.csdn.net/lanwangxia/article/details/121382412

版权

java 专栏收录该内容

59 篇文章 0 订阅

订阅专栏

一、网络通信协议

1、InetAddress类

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)： 测试是否可以达到该地址

2、Socket

端口分类：

公认端口： 0~1023 。被预先定义的服务通信占用（如： HTTP 占用端口80， FTP 占用端口 21 ， Telnet 占用端口 23 ）

注册端口： 1024~49151 。分配给用户进程或应用程序。（如： Tomcat 占用端口8080 ， MySQL 占用端口 3306 ， Oracle 占用端口 1521 等）。

动态 / 私有端口： 49152~65535 。

>网络上具有唯一标识的 IP 地址和端口号组合在一起才能构成唯一能识别的标识符套接字。

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 。即不能通过此套接字的输出流发送任何数据。

二、tcp网络编程

基于 Socket 的 TCP 编程

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

1）创建 Socket ：根据指定服务端的 IP 地址或端口号构造 Socket 类对象。若服务器端响应，则建立客户端到服务器的通信线路。若连接失败，会出现异常。

2） 打开连接到 Socket 的输入 / 出流： 使用 getInputStream() 方法获得输入流，使用getOutputStream()方法获得输出流，进行数据传输

3） 按照一定的协议对 Socket 进行读 / 写操作： 通过输入流读取服务器放入线路的信息（但不能读取自己放入线路的信息），通过输出流将信息写入线程。

4）关闭 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 = new 
Socket(“192.168.40.165”,9999);
OutputStream out = s.getOutputStream();
out.write(" hello".getBytes());
s.close();

基于 Socket 的 TCP 编程

服务器程序的工作过程包含以下四个基本的步骤：

1) 调用 ServerSocket(int port) ：创建一个服务器端套接字，并绑定到指定端口上。用于监听客户端的请求。

2) 调用 accept() ：监听连接请求，如果客户端请求连接，则接受连接，返回通信套接字对象。

3) 调用该 Socket 类对象的 getOutputStream() 和 getInputStream () ：获取输出流和输入流，开始网络数据的发送和接收。

4) 关闭 ServerSocket 和 Socket 对象： 客户端访问结束，关闭通信套接字。

服务器建立 ServerSocket 对象

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

public class TCPTest2 {
    @Test
    public void client() {
        Socket socket = null;
        OutputStream os = null;
        FileInputStream fis = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;

        try {
            socket = new Socket(InetAddress.getByName("127.0.0.1"), 9090);
            os = socket.getOutputStream();
            fis = new FileInputStream(new File("WX20210930-145733@2x.png"));
            byte[] buffer = new byte[1024];
            int len;
            while((len=fis.read(buffer)) != -1) {
                os.write(buffer, 0, len);
            }
            socket.shutdownOutput();

            is = socket.getInputStream();
            baos = new ByteArrayOutputStream();
            byte[] buffer1 = new byte[20];
            int len1;
            while((len1=is.read(buffer1)) != -1) {
                baos.write(buffer1, 0, len1);
            }
            System.out.println(baos);
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(baos != null) {
                try {
                    baos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    @Test
    public void server(){
        ServerSocket ss = null;
        Socket socket = null;
        InputStream is = null;
        FileOutputStream fos = null;
        OutputStream os = null;
        try {
            ss = new ServerSocket(9090);

            socket = ss.accept();

            is = socket.getInputStream();
            fos = new FileOutputStream(new File("1.png"));


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

            os = socket.getOutputStream();
            os.write("我是服务器，已收到数据".getBytes());

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(fos != null) {
                try {
                    fos.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();
                }
            }
            if(os != null) {
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }

    }
}

//应该使用try-catch-finally
@Test
    public void client() throws IOException {
        //1.
        InetAddress inet = InetAddress.getByName("127.0.0.1");
        //2.
        Socket socket = new Socket(inet, 8899);
        //3.
        OutputStream os = socket.getOutputStream();
        os.write("您好，我是客户端，请在服务器端输出我".getBytes());

        //注意点
        socket.shutdownOutput();

        InputStream is = socket.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] bytes = new byte[20];
        int len;
        while((len = is.read(bytes)) != -1) {
            baos.write(bytes, 0, len);
        }
        System.out.println(baos.toString());

        baos.close();
        is.close();
        os.close();
        socket.close();

    }

//应该使用try-catch-finally
    @Test
    public void server() throws IOException {
        //1.
        ServerSocket serverSocket = new ServerSocket(8899);
        //2.
        Socket socket = serverSocket.accept();
        //3.
        InputStream is = socket.getInputStream();
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        byte[] bytes = new byte[20];
        int len;
        while((len = is.read(bytes)) != -1) {
            baos.write(bytes, 0, len);
        }
        System.out.println(baos.toString());

        OutputStream os = socket.getOutputStream();
        os.write("我是服务器，收到你的信息".getBytes());

        baos.close();
        os.close();
        is.close();
        socket.close();
        serverSocket.close();
    }

三、UDP网络通信

> 类 DatagramSocket 和 DatagramPacket 实现了基于 UDP 协议网络程序。

>UDP 数据报通过数据报套接字 DatagramSocket 发送和接收，系统不保证UDP数据报一定能够安全送到目的地，也不能确定什么时候可以抵达。

> DatagramPacket 对象封装了 UDP 数据报，在数据报中包含了发送端的 IP地址和端口号以及接收端的IP 地址和端口号。

> UDP 协议中每个数据报都给出了完整的地址信息，因此无须建立发送方和接收方的连接。如同发快递包裹一样。

1、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 。

2、DatagramPacket类的常用方法

> public DatagramPacket(byte[] buf,int length) 构造 DatagramPacket ，用来接收长度为 length 的数据包。 length 参数必须小于等于 buf.length 。

> public DatagramPacket(byte[] buf,int length,InetAddress address,int port) 构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。 length参数必须小于等于 buf.length 。

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

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

> public byte[] getData() 返回数据缓冲区。接收到的或将要发送的数据从缓冲区中的偏移量 offset 处开始，持续 length 长度。

> public int getLength() 返回将要发送或接收到的数据的长度。

3、UDP网络通信流程：

1）. DatagramSocket 与 DatagramPacket

2）. 建立发送端，接收端

3）. 建立数据包

4）. 调用 Socket 的发送、接收方法

5）. 关闭 Socket

发送端与接收端是两个独立的运行程序

@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, 9900);

        socket.send(packet);
        socket.close();
    }

    @Test
    public void receiver() throws IOException {
        DatagramSocket socket = new DatagramSocket(9900);

        byte[] buffer = new byte[1024];//要设置足够长度
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);

        socket.receive(packet);
        String str = new String(packet.getData(), 0, packet.getLength());
        System.out.println(str);

        socket.close();

    }

四、URL编程

1、URL类

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

> 它是一种具体的 URI ，即 URL 可以用来标识一个资源，而且还指明了如何 locate这个资源。

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

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

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

2、URL类构造器

> 为了表示 URL ， java.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 = new

URL("http", "www.atguigu.com", 80, “download.html");

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

3、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 的查询名

4、针对HTTP协议的URLConnection类

>URL 的方法 openStream() ：能从网络上读取数据

> 若希望输出数据，例如向服务器端的 CGI （公共网关接口 -Common Gateway Interface-的简称，是用户浏览器和服务器端的应用程序进行连接的接口）程序发送一些数据，则必须先与URL 建立连接，然后才能对其进行读写，此时需要使用URLConnection 。

> URLConnection ：表示到 URL 所引用的远程对象的连接。当与一个 URL 建立连接时，首先要在一个 URL 对象上通过方法 openConnection() 生成对应的 URLConnection对象。如果连接过程失败，将产生IOException.

URL netchinaren = new URL ("http://www.atguigu.com/index.shtml");

URLConnectonn u = netchinaren.openConnection( );

> 通过 URLConnection 对象获取的输入流和输出流，即可以与现有的 CGI程序进行交互。

public Object getContent( ) throws IOException

public int getContentLength( )

public String getContentType( )

public long getDate( )

public long getLastModified( )

public InputStream getInputStream( )throws IOException

public OutputSteram getOutputStream( )throws IOException

public static void main(String[] args) {

        HttpURLConnection urlConnection = null;
        InputStream is = null;
        FileOutputStream fos = null;
        try {
            URL url = new URL("http://localhost:8080/examples/beauty.jpg");

            urlConnection = (HttpURLConnection) url.openConnection();

            urlConnection.connect();

            is = urlConnection.getInputStream();
            fos = new FileOutputStream("day10\\beauty3.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();
            }
        }

wiscourper_

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
20、网络编程

一、网络通信协议1、InetAddress类InetAddress类没有提供公共的构造器，而是提供了如下几个静态方法来获取InetAddress实例 >public static InetAddress getLocalHost() >public static InetAddress getByName(String host) InetAddress提供了如下几个常用的方法 >public String getHo...
复制链接

扫一扫

专栏目录