Java之网络编程

最新推荐文章于 2023-06-24 21:33:09 发布

君不见代码

最新推荐文章于 2023-06-24 21:33:09 发布

阅读量950

点赞数

本文链接：https://blog.csdn.net/weixin_35995730/article/details/103398490

版权

文章目录

1.1、概述

信件的模型：
计算机网络：(百度百科)
计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，==实现资源共享==和信息传递的计算机系统。
网络编程的目的： 数据交换。通信
想要达到这个效果需要什么：
1. 如何准确的定位网络上的一台主机 192.168.16.124：端口，定位到这个计算机上的某个资源
2. 找到了这个主机，如何传输数据呢？
常见服务架构：
javaweb：网页编程 B/S
网络编程：TCP/IP C/S

1.2、网络通信的要素

如何实现网络的通信？
(1). 通信双方地址：
a. ip
b. 端口号
c. 192.168.16,124:5900
(2). 规则：网络通信的协议（TCP/IP网络参考模型）
其中，在编程过程中，一般使用最多的即使：TCP、UDP、IP协议！
小结：
(1). 网络编程中有两个主要的问题：
a. 如何准确的定位到网络上的一台或者多台主机？（IP寻址）
b. 找到主机之后如何进行通信？(TCP/IP参考模型)
(2). 网络编程中的要素：
a. IP 和端口号。
b. 网络通信协议： udp，tcp
(3). 万物皆对象：
Java的核心理念！

1.3、IP

ip地址：InetAddress

唯一定位一台网络上计算机
127.0.0.1 ：本机 localhost 的ip地址。
ip地址的分类：
- ipv4 / ipv6
  - IPV4 127.0.0.1 , 4个字节组成。， 0~255， 42亿~ ； 30亿都在北美，亚洲4亿。2011年就用尽；
  - IPV6 :128位。8个无符号整数！
```
2001：0bb2：aaaa：0015:0000:0000:1aaa：1312！
```
- 公网（互联网）- 私网（局域网）
  - ABCD类地址（其中包括了公网和私网段的地址）
  - 192.168.xx.xx,专门给组织内部使用的 (典型代表的私网地址)
域名：解决IP记忆问题！

代码示例：

package com.kuang.lesson01;

import java.net.InetAddress;
import java.net.UnknownHostException;

//测试IP
public class TestInetAddress {
    public static void main(String[] args) {
        try {
            //查询本机地址
            InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");
            System.out.println(inetAddress1);
            InetAddress inetAddress3 = InetAddress.getByName("localhost");
            System.out.println(inetAddress3);
            InetAddress inetAddress4 = InetAddress.getLocalHost();
            System.out.println(inetAddress4);

            //查询网站ip地址
            InetAddress inetAddress2 = InetAddress.getByName("www.baidu.com");
            System.out.println(inetAddress2);

            //常用方法
            // System.out.println(inetAddress2.getAddress());
            System.out.println(inetAddress2.getCanonicalHostName()); //规范的名字
            System.out.println(inetAddress2.getHostAddress()); //ip
            System.out.println(inetAddress2.getHostName()); //域名，或者自己电脑的名字


        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}
-----------------
输出：
/127.0.0.1
localhost/127.0.0.1
DESKTOP-5TMVNJL/10.18.203.244
www.baidu.com/39.156.66.14
39.156.66.14
39.156.66.14
www.baidu.com

1.4、端口

概念：端口表示计算机上的一个程序的进程；

不同的进程有不同的端口号！用来区分软件！被规定为： 0~65535
TCP,UDP ： 65535 * 2(TCP和UDP的端口总数)

注意：单个协议下，端口号不能冲突
端口分类

(1). 公有端口 0~1023
- HTTP : 80
- HTTPS : 443
- FTP : 21
- Telent : 23
(2). 程序注册端口：1024~49151, 分配用户或者程序
- Tomcat ： 8080
- MySQL ： 3306
- Oracle ：1521
(3). 动态、私有：49152~ 65535

Windows下的一些查看网络端口的命令：

netstat -ano #查看所有的端口
netstat -ano|findstr "5900" # 查看指定的端口
tasklist|findstr "8696" #查看指定端口的进程
Ctrl+ shift + ESC

代码示例：(运行本地的Tomcat服务器)

package com.kuang.lesson01;


import java.net.InetSocketAddress;

public class TestInetSocketAddress {
    public static void main(String[] args) {

        InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1", 8080);
        InetSocketAddress socketAddress2 = new InetSocketAddress("localhost", 8080);
        System.out.println(socketAddress);
        System.out.println(socketAddress2);

        System.out.println(socketAddress.getAddress());
        System.out.println(socketAddress.getHostName()); //地址
        System.out.println(socketAddress.getPort()); //端口


    }
}
-------------
输出：
/127.0.0.1:8080
localhost/127.0.0.1:8080
/127.0.0.1
127.0.0.1
8080

1.5、通信协议

协议：约定，就好比我们现在说的是普通话。
网络通信协议： 速率，传输码率，代码结构，传输控制等等……
协议的问题： 看起来非常的复杂，需要管理的事情太多太多…
解决方法： 计算机著名的思想：分层设计处理思想 (即：大事化小，专注于某一点解决！)
TCP/IP协议簇：实际上不是一个协议，而是一组协议！
重要的协议：
(1). IP ：网络互连协议
(2). TCP ：用户传输协议
(3). UDP : 用户数据报协议
TCP udp 对比

(1). TCP : 类似于打电话
a. 特点：连接，稳定
b. 连接：三次握手。断开：四次挥手
c: 客户端、服务端
d: 传输完成，释放连接，效率低，安全和可靠性高！
(2). UDP ：类似于发短信
a. 不连接，不稳定
b. 客户端、服务端：没有明确的界限
c. 不管有没有准备好，都可以发给你…

1.6、TCP

传输消息：

客户端任务：

(1). 连接服务器 Socket
(2). 发送消息

客户端代码示例：

package com.kuang.lesson02;

import java.io.IOException;
import java.io.OutputStream;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

//客户端
public class TcpClientDemo01 {
    public static void main(String[] args) {

        Socket socket = null;
        OutputStream os = null;

        try {
            //1. 要知道服务器的地址，端口号
            InetAddress serverIP = InetAddress.getByName("127.0.0.1");
            int port = 9999;
            //2. 创建一个socket连接
            socket = new Socket(serverIP,port);
            //3. 发送消息 IO流
            os = socket.getOutputStream();
            os.write("你好,欢迎学习狂神说Java".getBytes());
            
        } catch (Exception 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();
                }
            }
        }

    }
}

特点：在Java的网络通信中，都是基于"I/O流"来进行消息的接受和发送的！

服务器任务：

建立服务的端口 ServerSocket
等待用户的链接 accept
接收用的消息

服务器代码示例：

package com.kuang.lesson02;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

//服务端
public class TcpServerDemo01 {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream baos = null;

        try {
            //1. 我得有一个地址
            serverSocket = new ServerSocket(9999);

            while (true){  //持续通信,每次只能处理一个客户端的访问请求，其他客户端阻塞！
                //2. 等待客户端连接过来
                socket = serverSocket.accept();
                System.out.println(socket); //打印套接字消息！
                //3. 读取客户端的消息
                is = socket.getInputStream();

                //管道流
                baos = new ByteArrayOutputStream();
                byte[] buffer = new byte[1024];
                int len;
                while ((len=is.read(buffer))!=-1){
                    baos.write(buffer,0,len);
                }

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

            /*
                byte[] buffer = new byte[1024];
                int len;
                while ((len=is.read(buffer))!=-1){
                    String msg = new String(buffer, 0, len);
                    System.out.println(msg);
                }
             */


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

        }

    }
}
---------------
输出：(每启动一次客户端程序，这里的打印就多一行,且客户端每次用来访问的端口都不一致！(随机分配的！))
Socket[addr=/127.0.0.1,port=54638,localport=9999]
你好,欢迎学习狂神说Java
Socket[addr=/127.0.0.1,port=54647,localport=9999]
你好,欢迎学习狂神说Java
......

特点：
持续处理客户端请求，每次只能处理一个客户端的访问，其他访问则进入排队等待的阻塞状态，serverSocket每收到一次客户端访问就能够调用accept()返回对应的socket套接字，然后再利用这个socket套接字来和客户端进行通信！
问题：
这个套接字每个进程可以拥有的数量好像不止一个，只是每次通信只能针对一个套接字来进行。这里应该通过什么手段来达到及时通信且不浪费大量资源的目的？

文件上传：

服务器端代码：

package com.kuang.lesson02;

import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class TcpServerDemo02 {
    public static void main(String[] args) throws Exception {
        //1. 创建服务
        ServerSocket serverSocket = new ServerSocket(9000);
        //2. 监听客户端的连接
        Socket socket = serverSocket.accept(); //阻塞式监听，会一直等待客户端连接
        //3. 获取输入流
        InputStream is = socket.getInputStream();

        //4. 文件输出
        FileOutputStream fos = new FileOutputStream(new File("receive.jpg"));
        byte[] buffer = new byte[1024];
        int len;
        while ((len=is.read(buffer))!=-1){
            fos.write(buffer,0,len);
        }


        //通知客户端我接收完毕了
        OutputStream os = socket.getOutputStream();
        os.write("我接受完毕了，你可以断开了".getBytes());
        
        //关闭资源
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();

    }
}

客户端代码：

package com.kuang.lesson02;

import java.io.*;
import java.net.InetAddress;
import java.net.Socket;
import java.net.UnknownHostException;

public class TcpClientDemo02 {
    public static void main(String[] args) throws Exception {
        //1.创建一个Socket连接
        Socket socket = new Socket(InetAddress.getByName("127.0.0.1"), 9000);
        //2、 创建一个输出流
        OutputStream os = socket.getOutputStream();

        //3. 读取文件
        FileInputStream fis = new FileInputStream(new File("qinjiang.jpg"));
        //4. 写出文件
        byte[] buffer = new byte[1024];
        int len;
        while ((len=fis.read(buffer))!=-1){
            os.write(buffer,0,len);
        }

        //通知服务器，我已经结束了
        socket.shutdownOutput(); //我已经传输完了！

        //确定服务器接收完毕，才能够断开连接
        InputStream inputStream = socket.getInputStream();
        //String byte[]
        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        byte[] buffer2 = new byte[2014];
        int len2;
        while ((len2=inputStream.read(buffer2))!=-1){
            baos.write(buffer2,0,len2);
        }

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

        //5.关闭资源
        baos.close();
        inputStream.close();
        fis.close();
        os.close();
        socket.close();
    }
}

注意：
（1）最重要的是那个 socket.shutdownOutput(); 这条代码调用后，socket才会往网络通信的输出流中写一个结束标志符，标志着写出结束，这样服务器端才能从网络I/O流中读取到相应的结束标志符，从而完成信息读取，否则，如果此时客户端没有调用shutdownOutput, 服务器会一直卡在文件等待读取结束标志符那里(while循环中)。
注：socket.close()也能达到此效果！
（2）此时，虽然socket连接并没有中断，但此时，客户端不能再调用 os.write() 向服务器发送消息了，如果再次调用会产生：java.net.SocketException: Cannot send after socket shutdown: socket write error。
（3）但是，客户端此时还是可以接受消息的。所以可以读取服务器发来的消息！整个过程有点像是在模拟4次分手协议似的，难道四次分手协议不是底层代码已经实现了的吗？
（4）注意关闭接口的顺序，是与接收相反的顺序！

Tomcat

服务端
- 自定义 S
- Tomcat服务器 S ： Java后台开发！
客户端
- 自定义 C
- 浏览器 B

1.7、UDP

发短信：不用连接，只需要知道对方的地址即可！

发送消息

发送端代码示例：

package com.kuang.lesson03;

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;

//不需要连接服务器
public class UdpClientDemo01 {
    public static void main(String[] args) throws Exception {
        //1. 建立一个Socket
        DatagramSocket socket = new DatagramSocket();

        //2. 建个包
        String msg = "你好啊，服务器！";
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 9090;

        // 数据，数据的长度起始，要发送给谁
        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);

        //3. 发送包
        socket.send(packet);

        //4. 关闭流
        socket.close();
    }
}

接收端代码：

package com.kuang.lesson03;

import java.net.DatagramPacket;
import java.net.DatagramSocket;


//还是要等待客户端的链接！
public class UdpServerDemo01 {
    public static void main(String[] args) throws Exception {
        //开放端口
        DatagramSocket socket = new DatagramSocket(9090);
        // 接收数据包
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer, 0, buffer.length);

        socket.receive(packet); //阻塞接收

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


        //关闭连接
        socket.close();
    }
}
-----------
输出：
127.0.0.1
你好啊，服务器！

咨询

概念：
在线咨询：两个人都可以是发送方，也都可以是接收方！

发送方代码示例：

package com.kuang.chat;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
import java.net.SocketException;

public class UdpSenderDemo01 {
    public static void main(String[] args) throws Exception {

        DatagramSocket socket = new DatagramSocket(8888);

        //准备数据： 控制台读取 System.in
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        while (true) {
        	System.out.println("请输入您要发送的消息：");
            String data = reader.readLine();
            byte[] datas = data.getBytes();
            DatagramPacket packet = new DatagramPacket(datas,0,datas.length,new InetSocketAddress("localhost",6666));

            socket.send(packet);
            if (data.equals("bye")){
                break;
            }
        }
        socket.close();
    }
}
----------
输出：
请输入您要发送的消息：
1111
请输入您要发送的消息：
hahahaha
请输入您要发送的消息：
byt
请输入您要发送的消息：
nye
请输入您要发送的消息：
bye

接收方代码示例：

package com.kuang.chat;

import javax.xml.stream.FactoryConfigurationError;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UdpReceiveDemo01 {
    public static void main(String[] args) throws Exception {
        DatagramSocket socket = new DatagramSocket(6666);

        while (true){


            //准备接收包裹
            byte[] container = new byte[1024];
            DatagramPacket packet = new DatagramPacket(container,0,container.length);
            socket.receive(packet); //阻塞式接收包裹
            
            //断开连接  bye
            byte[] data = packet.getData();
            String receiveData = new String(data, 0, data.length);
            
            System.out.println(receiveData);
            
            if (receiveData.equals("bye")){
                break;
            }

            
        }
        
        socket.close();
        
    }
}
---------
输出：
1111
hahahaha
byt
nye
bye

小结：
在示例中，发送方和接收方都采用端口号的形式声明了自己的socket地址，所以，不管是发送方还是接收方，都可以通过改写以上的相关代码从而达到互为发送方和接收方的效果。

1.8、URL

概念：
URL 是统一资源定位符（Uniform Resource Locator）的简称，它表示 Internet 上某一资源的地址。通过 URL 用户可以访问各种网络资源，比如常见的 WWW 以及 FTP 站点。浏览器可以通过解析给定的 URL 在网络上查找相应的文件或其他资源。
问题：那之前在学习Java GUI的时候，用到的那种本地资源定位算什么？那种又不是网络资源？

URL协议：//ip地址：端口/项目名/资源

测试代码：

package com.kuang.lesson04;

import java.net.MalformedURLException;
import java.net.URL;
import java.time.Year;

//http://localhost:8080/qinjiang/SecurityFile.txt

public class URLDemo01 {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("http://localhost:8080/helloworld/index.jsp?username=kuangshen&password=123");

        System.out.println(url.getProtocol()); //协议
        System.out.println(url.getHost()); //主机ip
        System.out.println(url.getPort()); //端口
        System.out.println(url.getPath()); //文件
        System.out.println(url.getFile()); //全路径
        System.out.println(url.getQuery()); //参数
    }
}
-------------
输出：
http
localhost
8080
/helloworld/index.jsp
/helloworld/index.jsp?username=kuangshen&password=123
username=kuangshen&password=123

下载网络资源：

package com.kuang.lesson04;

import java.io.FileOutputStream;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;


public class UrlDown {
    public static void main(String[] args) throws Exception {
        //1. 下载地址
        URL url = new URL("https://m10.music.126.net/20191201174818/c09b1932384617e535421702c26ccc5c/yyaac/0708/0652/0508/0b9b6827b718aa223af92bd52aa2424f.m4a");

        //2. 连接到这个资源  HTTP
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

        InputStream inputStream = urlConnection.getInputStream();

        FileOutputStream fos = new FileOutputStream("f.m4a");

        byte[] buffer = new byte[1024];
        int len;
        while ((len=inputStream.read(buffer))!=-1){
            fos.write(buffer,0,len); //写出这个数据
        }

        fos.close();
        inputStream.close();
        urlConnection.disconnect(); //断开连接
    }
}

君不见代码

关注

0
点赞
踩
0

收藏

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

文章目录1.1、概述1.2、网络通信的要素1.3、IP1.4、端口1.5、通信协议1.6、TCP传输消息：文件上传：Tomcat1.7、UDP发送消息咨询1.8、URL1.1、概述信件的模型：计算机网络：(百度百科) 计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，==实现资源共享...
复制链接

扫一扫