网络编程

1.1、概述

计算机网络

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

网络编程

就是用来实现网络互联的不同计算机上运行的程序间可以进行数据交换

1.2、网络通讯的要素

如何实现网络的通信？

通信双方地址

IP
端口号
192.168.xx.xx：5900

规则：网络通信协议

OSI七层网络模型

OSI中的层	功能	TCP/IP协议簇
应用层	文件传输，电子邮件，文件服务，虚拟终端	TFTP，HTTP，SNMP，FTP，SMTP，DNS，Telnet
表示层	数据格式化，代码转换，数据加密	没有协议
会话层	解除或建立与别的接点的联系	没有协议
传输层	提供端对端的接口	TCP/UDP
网络层	为数据包选择路由	IP，ICMP，RIP，OSPF，BGP，IGMP
数据链路层	传输有地址的帧以及错误检测功能	SLIP，CSLIP，PPP，ARP，RARP，MTU
物理层	以二进制数据形式在物理媒体上传输数据	ISO2110，IEEE802，IEEE802.2

P和端口号
网络通讯协议（UDP，TCP）

1.3、IP

IP地址：InetAddress

唯一定位一台网络计算机
127.0.0.1：本机localhost
IP地址的分类
- ip地址分类（ipv/ipv6）
  - == ipv4：127.0.0.1 ==，四个字节组成，长度为0-255，42亿
  - == ipv6：如（2020:0bb2:aaaa:0256:0000:0000:da59:3684）==，128位，无符号整数！公网(互联网) \ 私网(局域网)分类
  - ABCD类地址
  - 192.168.xx.xx：专门给组织机构使用的
- 域名：记忆IP问题

代码示例

package com.wl.lesson01;

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

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

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

            // 常用方法
            System.out.println(inetAddress.getAddress());
            System.out.println(inetAddress.getHostAddress());
            System.out.println(inetAddress.getHostName());
            System.out.println(inetAddress.getCanonicalHostName());
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }
}

1.4、端口

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

不同的进程有不同的端口号，用来区分软件
被规定 0-65535
分为 TCP：UDP
端口分类
- 公用端口 0-1023
  - HTTP：80
  - HTTPS：443
  - FTP：21
  - Telent：23
- 程序注册端口：1024-49151，分配给用户或者程序
  - Tomcat：8080
  - MySQL：3306
  - Oracle：1521
- 动态，私有端口：19152-65535

// doc命令
netstat -ano：#查看所有端口
netstat -ano|findstr"本机端口号"：#查看指定的端口
tasklist|findstr"指定查询的端口号(PID)"：#查看指定端口的进程

代码示例： Socket(插座)

package com.wl.lesson01;

import java.net.InetSocketAddress;

// Socket（套接字） 插座
public class TestInetSocketAddress {
    public static void main(String[] args) {
        InetSocketAddress socketAddress = new InetSocketAddress("127.0.0.1",8080);
        InetSocketAddress socketAddress1 = new InetSocketAddress("localhost", 8080);
        System.out.println(socketAddress);
        System.out.println(socketAddress1);

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

1.5、通信协议

网络通信协议：涉及到速率，传输码率，代码结构，传输控制…
TCP/IP协议簇（实际上是一组协议）
- TCP协议：用户传输协议
- UDP协议：用户数据报协议
- IP协议：网络互联协议
TCP/UDP对比：
- TCP：打电话
  - 连接，稳定
  - “三次握手”，“四次挥手”
    - 三次握手：最少需要三次，保证连接稳定
      - A：你瞅啥？
      - B：瞅你咋地！
      - A：干一场！
    - 四次挥手：断开连接
      - A：我要走了
      - B：我知道你要走了
      - B：你真的要走了吗？
      - A：我真的要走了
  - 客户端，服务端
  - 传输完成后，释放连接，效率低
- UDP：发短信
  - 不连接，不稳定
  - 客户端，服务端（没有明确的界限）
  - 随时随地都可以发送
  - 导弹
  - DDOS：分布式拒绝服务（也叫洪水攻击，饱和攻击）

1.6、TCP

客户端
- 1. 连接服务器 Socket
  2. 发送消息
服务器
- 1. 建立服务端口 ServerSocket
  2. 等待用户的连接 accpt()
  3. 接受用户的消息

客户端代码示例：

package com.wl.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) {
        OutputStream os = null;
        Socket socket = 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 (UnknownHostException e) {
            e.printStackTrace();
        } catch (IOException 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();
                }
            }
        }
    }
}

服务器代码示例：

package com.wl.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);
            // 2.等待客户端连接过来 accept()
            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());
        } 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();
                }
            }
        }

    }
}

实现文件上传

客户端代码示例：

package com.wl.lesson03;

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("2.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[2048];
        int len2;
        while ((len2=inputStream.read(buffer2))!=-1){
            baos.write(buffer,0,len2);
        }
        System.out.println(baos.toString());

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

服务器示例代码

package com.wl.lesson03;

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

        // 5.关闭资源
        fos.close();
        is.close();
        socket.close();
        serverSocket.close();
    }
}

Tomcat

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

1.7、UDP

发短信：不用连接，但是需要对方的地址!

DatagramSocket(Packet)

send() 发送

receive() 阻塞接收

发送消息代码示例：

package com.wl.lesson04;

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

// 不需要连接服务器
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.wl.lesson04;

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

// 这边也是需要等待发送端的连接
public class UdpServerDemo01 {
    public static void main(String[] args) throws Exception {
        // 1.开放端口
        DatagramSocket socket = new DatagramSocket(9090);

        // 2.接收数据（即接收包）
        byte[] buffer = new byte[1024];
        DatagramPacket packet = new DatagramPacket(buffer,0,buffer.length); // 接收
        // 这里将 DatagramPacket封装 成一个对象

        socket.receive(packet); // 阻塞接收
        System.out.println(packet.getAddress());
        System.out.println(new String(packet.getData(),0, packet.getLength()));

        // 3.关闭连接
        socket.close();
    }
}

UDP聊天实现（咨询）

循环发送消息

发送端代码示例：

package com.wl.lesson05;

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

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

        // 准备数据，控制台读取 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();

    }
}

接收端代码示例：

package com.wl.lesson05;

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

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); // 阻塞式接收包裹

            // 断开连接
            byte[] data = packet.getData();
            String receiveData = new String(data, 0, data.length).trim();
            System.out.println(receiveData);

            if (receiveData.equals("bye")){
                break;
            }
        }

        socket.close();
    }
}

在线咨询：俩个人都可以是发送方，也可以是接收方

发送端：

package com.wl.lesson06;

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

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() {
        // 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 e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

接收端

package com.wl.lesson06;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class TalkReceive implements Runnable{
    DatagramSocket socket;
    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); // 阻塞式接收包裹

                // 断开连接
                byte[] data = packet.getData();
                String receiveData = new String(data, 0, data.length).trim();
                System.out.println(msgFrom + ":" + receiveData);

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

老师端

package com.wl.lesson06;

public class TalkTeacher {
    public static void main(String[] args) {
        // 开启线程
        // 从5555端口发出，发给本地，发送到9999端口
        new Thread(new TalkSend(5555,"localhost",9999)).start();
        // 接收8888端口的消息，来自学生的消息
        new Thread(new TalkReceive(8888,"学生")).start();

    }
}

学生端

package com.wl.lesson06;

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

1.8 、URL

https://www.baidu.com/

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

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

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

代码示例：

package com.wl.lesson07;

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("http:www.baidu.com");
        // 2.连接到这个资源，用HTTP连接
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

        InputStream inputStream = urlConnection.getInputStream();
        FileOutputStream fos = new FileOutputStream("a.txt");

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

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

    }
}

1.网络编程

网络编程

1.1、概述

计算机网络

网络编程

1.2、网络通讯的要素

1.3、IP

1.4、端口

1.5、通信协议

1.6、TCP

1.7、UDP

1.8 、URL

猜你喜欢