Day22Java学习笔记——认识网络编程

最新推荐文章于 2022-09-05 08:45:15 发布

fenglgC

最新推荐文章于 2022-09-05 08:45:15 发布

阅读量166

点赞数

本文链接：https://blog.csdn.net/u013583756/article/details/103353787

版权

网络编程

1、1概述

计算机网络：

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

网络编程目的：

传播交流信息，数据交换。通信

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

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

Javaweb ：网页编程 B/S

网络编程：TCP/IP C/S

1、2网络通信的要素

如何实现网络的通信？

通信双方地址：

IP
端口号
192.168.16.124:5900

规则：网络通信协议

TCP/IP 参考模型：四层参考模型
在这里插入图片描述

小结：

1、网络编程中两个问题
- 如何准确定位网络上一台或多台主机
- 找到主机后如何通信
2、网络编程中要素
- IP和端口号
- 网络通信协议 udp tcp
3、万物皆对象

1、3IP

IP地址：InetAddress

唯一定位一台网络上计算机
127.0.0.1 ：本机localhost
IP地址分类
- IPV4、IPV6
  - IPV4：127.0.0.1 4个字节组成
  - IPV6：128位，8个无符号整数
- 公网（互联网）-私网（局域网）
  - ABCD类地址
  - 192.168.xx.xx专门给组织内部类使用
域名：记忆IP问题！
- IP：www.jd.com

代码

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-M2T8TT3/192.168.1.27
www.baidu.com/14.215.177.38
14.215.177.38
14.215.177.38
www.baidu.com

1、4端口

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

不同的进程有不同的端口号！用来区分软件！
端口被规定0~65535
TCP，UDP：65535*2 tcp:80,udp:80 ;单个协议下，端口号不能冲突
端口分类
- 公有端口 0~1023
  - HTTP：80
  - HTTPS：443
  - FTP：21
  - Telent：23
- 程序注册端口：1024~49151，分配用户或者程序
  - Tomcat：8080
  - MySQL：3306
  - Oracle：1521
- 动态、私有：49152~65535

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

Ctrl+shift+ESC 打开任务管理器

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协议簇：实际是一组协议

TCP：用户传输协议
UDP：用户数据报协议

TCP UDP 对比

TCP：打电话

连接、稳定

“三次握手”、“四次挥手”

最少需要三次，保证稳定连接
A：你瞅啥？
B：瞅你咋地？
A：干一场！

A：我要走了
B：我真的要走了吗
B：你真的真的要走了吗
A：我真的要走了！

客户端、服务端
传输完成、释放连接、效率低

UDP：发短信

不连接、不稳定
客户端、服务段：没有明确的界限
不管有没有准备好，都能发给你
DDOS：洪水攻击（饱和攻击）

1、6 TCP

客户端

1、连接服务器 Socket

2、发送消息

package com.fengcheng.practice1;
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("welcome to learn 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();
                }
            }
        }

    }
}

服务器

1、建立服务的端口ServerSocket

2、等待

3、接收用的消息

package com.fengcheng.practice1;

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

运行结果是：每启动一次客户端，在Server端会打印welcome to learn Java

1、7文件上传

服务器端

package com.fengcheng.practice1;

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.fengcheng.practice1;

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

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

运行结果：先启动服务器端，在启动客户端，当传输图片成功完成后，在客户端打印，我接受完毕了，你可以断开了，此时两方关闭程序

Tomcat

tomcat是一个中间件，在B/S架构中，浏览器发出的http请求经过tpmcat中间件，转发到最终的目的服务器上，响应消息再通过tomcat返回给浏览器。
tomcat所做的事情主要有：开启监听端口监听用户的请求，解析用户发来的http请求然后访问到你指定的应用系统，然后你返回的页面经过tomcat返回给用户。

服务端

自定义 S
Tomcat服务器Ｓ

客户端

自定义 C
浏览器 B

1、7 UDP

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

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

接收端

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），以及内容（你好啊，服务器！）

咨询:一方去发送，一方去接收

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

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

运行结果：启动程序后，在发送方输入文本，在接收方显示，发送方输入bye，会停止程序

1、8 URL

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

DNS 域名解析 www.baidu.com———>xxx.xxx.xxx.xxx

组成：协议；//IP地址：端口/项目名/资源

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

//http://http://localhost:8080/fc/fc.txt

public class URLDemo01 {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("http://localhost:8080/fc/fc.txt");

        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
/fc/fc.txt
/fc/fc.txt
null

fenglgC

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Day22Java学习笔记——认识网络编程

网络编程1、1概述计算机网络：计算机网络是指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来，在网络操作系统，网络管理软件及网络通信协议的管理和协调下，实现资源共享和信息传递的计算机系统。网络编程目的：传播交流信息，数据交换。通信想要达到这个效果需要什么：如何准确定位网络上的一台主机，端口；定位到计算机上某个资源找到了这个主机，如何传输数据？...
复制链接

扫一扫