【狂神说Java】阶段一笔记28. java网络编程

1.1 概述

• 地球村

• 打电话：通话 TCP

  • 发短信：接收 UDP

• 计算机网络：将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统中，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。

• 网络编程的目的：无线电台，传播信息交流，数据交换，通信

• 想要达到这个效果需要什么：

  • 如何准确地定位网络上的一台主机，192.168.16.124：端口，定位到这个计算机上的某个资源
  • 找到这个主机，如何传输数据

• javaweb：网页编程 B/S 网络编程：TCP/IP C/S

1.2 网络通信的要素

人工智能：智能汽车（伦理问题）

如何实现网络通信：通信双方的地址

- ip：192.168.16.124
- 端口号：5900

规则：网络通信的协议（TCP/IP，OSI七层模型）

• 小结：
  • 网络编程中有两个主要的问题
    • 如何准确的定位到网络上一台或者多台主机
  • 网络编程中的要素
    • IP和端口号 IP
    • 网络通信协议 UDP、TCP
  • 万物皆对象

1.3 IP

ip地址：InetAddress

• 唯一定位一台网络上计算机，查看本机ip：ipconfig

• 127.0.0.1：本机localhost

• ip地址的分类

  • IPV4 / IPV6

    • IPV4： 127.0.0.1，4个字节组成，0~255，42亿个，30亿都在北美，亚洲4亿，2011年就用尽了
    • IPV6： fe80::915d:470e:d522:4339%16，128位，8个无符号整数！abcde 0~9

    2001: 0bb2: aaaa: 0015: 0000: 0000: 1aaa: 1312
    

  • 公网（互联网）- 私网（局域网）

    • 192.168.xx.xx： 专门给组织内部使用的
    • ABCDE： A类适用的类型为大型网络；B类适用的类型为中型网络；C类适用的类型为小型网络。

    

• 域名：记忆IP问题

  • IP：www.vip.com

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

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

            //常用方法
            // System.out.println(inetAddress4.getAddress());
            System.out.println(inetAddress4.getCanonicalHostName()); //规范的名字
            System.out.println(inetAddress4.getHostAddress()); //ip
            System.out.println(inetAddress4.getHostName()); //域名，或者自己电脑的名字
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

1.4 端口

端口表示计算机上一个程序的进程

• 不同的进程有不同的端口号，端口号不能冲突，用来区分软件

• 端口被规定 0~65535

• TCP，UDP：65535 * 2，单个协议下，端口号不能冲突

• 端口分类

  • 公有端口0~1023
    • HTTP：80
    • HTTPS：443
    • FTP：21
    • Telent：23
  • 程序注册端口：1014~49151，分配用户或者程序
    • Tomcat 8080
    • MySQL：3306
    • Oracle：1521
  • 动态、私有：49152~65535

  public class TestInetSocketAddress {
      public static void main(String[] args) {
          InetSocketAddress socketAddress1 = new InetSocketAddress("127.0.0.1", 8080);
          InetSocketAddress socketAddress2 = new InetSocketAddress("localhost", 8080);
          System.out.println(socketAddress1);
          System.out.println(socketAddress2);
  
          System.out.println(socketAddress2.getAddress());
          System.out.println(socketAddress2.getHostName());  //地址
          System.out.println(socketAddress2.getPort());  //端口
      }
  }
  

  netstat -ano  # 查看所有的端口
  netstat -ano|findstr "5900"  # 查看指定的端口
  tasklist|findstr "8696"  # 查看指定端口的进程
  Ctrl + Shift +Esc  # 打开任务管理器
  

1.5 通信协议

协议：约定，互相说普通话

网络通信协议：速率，传输的码率，代码结构，传输控制…（非常复杂）

大事化小：分层！

TCP/IP协议簇：实际上一组协议

重要：

• TCP用户传输协议，UDP用户数据报协议（传输层）

出名的协议：

• TCP

• IP：网络互连协议

1.5.1 TCP、UDP对比

TCP：打电话

• 连接，稳定

• 三次握手 四次挥手

  • A：你瞅啥？ B：瞅你咋地？ A：干一场！（最少需要三次保证稳定连接）
  • A：我要走了。 B：你真的要走了么？ B：你真的真的要走了么？ A：我真的要走了。

• 客户端、服务端：有明确的界限

• 传输完成，释放连接，效率低

UDP：发短信

• 不连接，不稳定
• 客户端、服务端：没有明确的界限
• 不管有没有准备好，都可以发给你
• DDOS：洪水工具！饱和攻击

1.6 TCP

• 客户端

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

//客户端
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");
            //2.端口号
            int port = 9999;
            //3.创建一个socket连接
            socket = new Socket(serverIP, port);
            //4.发送消息 IO
            os = socket.getOutputStream();
            os.write("你好，欢迎学习狂神说Java".getBytes());

        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            if (os != null){
                try {
                    os.close();
                } catch (IOException exception) {
                    exception.printStackTrace();
                }
            }

            if (socket != null){
                try {
                    socket.close();
                } catch (IOException exception) {
                    exception.printStackTrace();
                }
            }
        }
    }
}

• 服务器

1. 建立服务端口 ServerSocket
2. 等待用户的连接 accept
3. 接收用户的消息

//服务端
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);
            //2.等待客户端连接过来
            while (true){
                socket = serverSocket.accept();
                //3.读取客户端的消息
                is = socket.getInputStream();
            /*
                byte[] buffer = new byte[1024];
                int len;
                while ((len=is.read(buffer)) != -1){
                    String msg = new String(buffer, 0, len);
                    System.out.println(msg);
                }
            */
                //管道流
                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());
            }
        } catch (IOException exception) {
            exception.printStackTrace();
        } finally{
            //关闭资源
            //谁先接的谁先断开
            if (baos != null){
                try {
                    baos.close();
                } catch (IOException exception) {
                    exception.printStackTrace();
                }
            }

            if (is != null){
                try {
                    is.close();
                } catch (IOException exception) {
                    exception.printStackTrace();
                }
            }

            if (socket != null){
                try {
                    socket.close();
                } catch (IOException exception) {
                    exception.printStackTrace();
                }
            }

            if (serverSocket != null){
                try {
                    serverSocket.close();
                } catch (IOException exception) {
                    exception.printStackTrace();
                }
            }
        }
    }
}

1.6.1 文件上传

• 客户端

public class TcpClientDemo02 {
    public static void main(String[] args) {
        try {
            //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("D:\\NEU\\learn\\java\\project\\src\\ip\\yy\\lesson02\\huo2.jpg"));

            //4.写出文件
            byte[] buffer = new byte[1024];
            int len;
            while ((len = fis.read(buffer)) != -1){
                os.write(buffer, 0, len);
            }

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

            //5.确定服务器接收完毕，才能够断开连接
            InputStream is = socket.getInputStream();
            //String byte[]
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            byte[] buffer2 = new byte[1024];
            int len2;
            while ((len2 = is.read(buffer2)) != -1){
                baos.write(buffer2, 0, len2);
            }

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

            //6.关闭资源
            fis.close();
            os.close();
            socket.close();
        } catch (IOException exception) {
            exception.printStackTrace();
        }
    }
}

• 服务器端

public class TcpServerDemo02 {
    public static void main(String[] args) {
        try {
            //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);
            }

            //5.通知客户端接收完毕了
            OutputStream os = socket.getOutputStream();
            os.write("我接受完毕了，你可以断开了！".getBytes());

            //6.关闭资源
            fos.close();
            is.close();
            socket.close();
            serverSocket.close();
        } catch (IOException exception) {
            exception.printStackTrace();
        }
    }
}

1.6.2 Tomcat

服务端

• 自定义 S
• Tomcat服务器 S：Java后台开发

客户端

• 自定义 C
• 浏览器 B

1.7 UDP

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

• 发送端：发送消息

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

            //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();
        } catch (IOException exception) {
            exception.printStackTrace();
        }
    }
}

• 接收端：接收消息

//还是要等待客户端的连接
public class UdpServerDemo01 {
    public static void main(String[] args) {
        try {
            //开放端口
            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();
        } catch (IOException exception) {
            exception.printStackTrace();
        }
    }
}

1.7.1 咨询

• 循环发送消息

public class UdpSenderDemo01 {
    public static void main(String[] args) {
        try {
            DatagramSocket socket = new DatagramSocket(8888);

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

            while (true){
                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();
        } catch (IOException exception) {
            exception.printStackTrace();
        }
    }
}

• 循环接收消息

public class UdpReceiveDemo02 {
    public static void main(String[] args) {
        try {
            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();
        } catch (IOException exception) {
            exception.printStackTrace();
        }
    }
}

1.7.2 在线咨询

两个人都可以是发送方，也可以是接收方

• 发送方

public class TalkSend implements Runnable{
    DatagramSocket socket = null;
    BufferedReader reader = null;

    private int fromPort;
    private String toIP;
    private int toPort;

    public TalkSend(int fromPort, String toIP, int toPort) {
        this.fromPort = fromPort;
        this.toIP = toIP;
        this.toPort = toPort;

        try {
            socket = new DatagramSocket(fromPort);
            reader = new BufferedReader(new InputStreamReader(System.in));
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while (true){
            try {
                String data = reader.readLine();
                byte[] datas = data.getBytes();
                DatagramPacket packet = new DatagramPacket(datas, 0, datas.length,
                        new InetSocketAddress(this.toIP, this.toPort));

                socket.send(packet);
                if (data.equals("bye")){
                    break;
                }
            } catch (IOException exception) {
                exception.printStackTrace();
            }
        }

        socket.close();
    }
}

• 接收方

public class TalkReceive implements Runnable{
    DatagramSocket socket = null;
    private int port;
    private String msgFrom;

    public TalkReceive(int port, String msgFrom) {
        this.port = port;
        this.msgFrom = msgFrom;

        try {
            socket = new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while (true){
            try {
                //准备接受包裹
                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(msgFrom + "：" + receiveData);

                if (receiveData.equals("bye")){
                    break;
                }
            } catch (IOException exception) {
                exception.printStackTrace();
            }
        }
        socket.close();
    }
}

public class TalkTeacher {
    public static void main(String[] args) {
        new Thread(new TalkSend(5555, "localhost", 8888)).start();
        new Thread(new TalkReceive(9999, "学生")).start();
    }
}

public class TalkStudent {
    public static void main(String[] args) {
        //开启两个线程
        new Thread(new TalkSend(7777, "localhost", 9999)).start();
        new Thread(new TalkReceive(8888, "老师")).start();
    }
}

1.8 URL

https://www.baidu.com/

统一资源定位符：定位资源的，定位互联网上的某一个资源

DNS 域名解析 www.baidu.com/ xxx.xxx.xxx

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

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

• 网络资源下载

public class UrlDown {
    public static void main(String[] args) throws Exception {
        //1.下载地址
        URL url = new URL("");

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

        FileOutputStream fos = new FileOutputStream("tu.jpg");

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

        fos.close();
        inputStream.close();
        urlConnection.connect();
    }
}

PS：学习自狂神说java