网络编程

# 网络编程

一、计算机网络是什么？

计算机网络主要是由一些通用的、可编程的硬件互连而成，通过这些硬件，可以传送不同类型的数据，并且可以支持广泛和日益增长的应用。

二、OSI七层网络模型和TCP/IP四层概念模型：

三、IP

3.1、IPV4

32位，4个无符号整数，可分配42亿，30亿在北美，亚洲4亿，2011年就已用尽

3.2、IPV6

128位，8个无符号整数

3.3、公网（互联网）/ 私网（局域网）

192.168.xx.xx：专门给组织内部使用

四、端口

4.1、范围：

0~65536

4.2、端口分类：

共有端口（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" # 查看指定端口的进程

五、通信协议

5.1、TCP（用户传输协议）

打电话，连接稳定，传输完成，释放连接，效率低
三次握手、四次挥手
客户端、服务端

5.2、UDP（传输控制协议）

发短信，连接不稳定
DDOS：洪水攻击（饱和攻击）

六、代码实战

TCP

TCP通话

服务端

package com.xx.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 accept = null;
        InputStream inputStream = null;
        ByteArrayOutputStream byteArrayOutputStream = null;
        try {
            // 创建服务器
            serverSocket = new ServerSocket(9999);

            // 等待客户端连接
            accept = serverSocket.accept();

            // 读取客户端信息
            inputStream = accept.getInputStream();

            // 管道流
            byteArrayOutputStream = new ByteArrayOutputStream();

            byte[] bytes = new byte[1024];
            int len;
            while ((len = inputStream.read(bytes)) != -1) {
                byteArrayOutputStream.write(bytes, 0, len);
            }
            System.out.println(byteArrayOutputStream.toString());

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

        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            // 关闭资源
            if (serverSocket != null) {
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (accept != null) {
                try {
                    accept.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (byteArrayOutputStream != null) {
                try {
                    byteArrayOutputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

客户端

package com.xx.lesson02;

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

public class TcpClientDemo01 {
    public static void main(String[] args) {
        Socket socket = null;
        OutputStream outputStream = null;
        try {
            // 要知道服务器地址和端口号
            InetAddress serverIP = InetAddress.getByName("127.0.0.1");
            int port = 9999;

            // 创建socket连接
            socket = new Socket(serverIP, port);

            // 发送消息IO流
            outputStream = socket.getOutputStream();
            outputStream.write("我是你爹".getBytes());
        } catch (Exception exception) {
            exception.printStackTrace();
        } finally {
            if (socket != null) {
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (outputStream != null) {
                try {
                    outputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

TCP文件传输

服务端

package com.xx.lesson02;

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

public class TcpServerDemo02 {
    public static void main(String[] args) throws Exception {
        // 创建服务
        ServerSocket serverSocket = new ServerSocket(9000);

        // 监听客户端的连接
        Socket accept = serverSocket.accept();

        // 获取输入流
        InputStream inputStream = accept.getInputStream();

        // 文件输出
        FileOutputStream fileOutputStream = new FileOutputStream(new File("temp-bak.txt"));
        byte[] buffer = new byte[1024];
        int len;
        while ((len = inputStream.read(buffer)) != -1) {
            fileOutputStream.write(buffer, 0, len);
        }

        // 告诉客户端我已经接受完毕了
        OutputStream outputStream = accept.getOutputStream();
        outputStream.write("我已经完毕了，你可以断开了".getBytes());

        // 关闭资源
        outputStream.close();
        fileOutputStream.close();
        inputStream.close();
        accept.close();
        serverSocket.close();
    }
}

客户端

package com.xx.lesson02;

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

public class TcpClientDemo02 {
    public static void main(String[] args) throws Exception {
        // 创建Socket连接
        Socket socket = new Socket("127.0.0.1", 9000);

        // 创建文件输出流
        OutputStream os = socket.getOutputStream();

        // 读取文件
        FileInputStream fileInputStream = new FileInputStream(new File("temp.txt"));

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

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

        // 服务器告诉我已经接收完毕了，才能断开
        InputStream inputStream = socket.getInputStream();
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

        byte[] bytes = new byte[1024];
        int len2;
        while ((len2 = inputStream.read(bytes)) != -1) {
            byteArrayOutputStream.write(bytes, 0, len2);
        }
        System.out.println(byteArrayOutputStream.toString());

        // 关闭资源
        byteArrayOutputStream.close();
        inputStream.close();
        fileInputStream.close();
        os.close();
        socket.close();
    }
}

UDP

UDP半双工通信

发送方

package com.xx.udp;

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

public class send02 {
    public static void main(String[] args) throws Exception {
        DatagramSocket datagramSocket = new DatagramSocket(8081);
        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(System.in));

        while (true) {
            String data = bufferedReader.readLine();
            byte[] bytes = data.getBytes();
            DatagramPacket datagramPacket = new DatagramPacket(bytes, 0, bytes.length, new InetSocketAddress("localhost", 8082));

            datagramSocket.send(datagramPacket);
            if (data.equals("bb")) {
                break;
            }
        }

        datagramSocket.close();
    }
}

接收方

package com.xx.udp;

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

public class receive02 {
    public static void main(String[] args) throws Exception {
        DatagramSocket datagramSocket = new DatagramSocket(8082);

        while (true) {
            byte[] bytes = new byte[1024];
            DatagramPacket datagramPacket = new DatagramPacket(bytes, 0, bytes.length);
            datagramSocket.receive(datagramPacket);

            byte[] data = datagramPacket.getData();
            String receiveData = new String(data, 0, datagramPacket.getLength());

            System.out.println(receiveData);
            if (receiveData.equals("bb")) {
                break;
            }
        }
        datagramSocket.close();
    }
}

UDP全双工通信

发送线程

package com.xx.udp;

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

public class SendThread implements Runnable {
    private final String IP = "localhost";
    private int fromPort;
    private String toIP;
    private int toPort;
    DatagramSocket datagramSocket = null;
    BufferedReader bufferedReader = null;

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

        try {
            this.datagramSocket = new DatagramSocket(fromPort);
            this.bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

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

                datagramSocket.send(datagramPacket);
                if (data.equals("bb")) {
                    break;
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        datagramSocket.close();
    }
}

接收线程

package com.xx.udp;

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

public class ReceiveThread implements Runnable {
    private int fromPort;
    String name;
    DatagramSocket datagramSocket = null;
    BufferedReader bufferedReader = null;

    public ReceiveThread(int fromPort, String name) {
        this.fromPort = fromPort;
        this.name = name;

        try {
            this.datagramSocket = new DatagramSocket(fromPort);
            this.bufferedReader = new BufferedReader(new InputStreamReader(System.in));
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        try {
            while (true) {
                byte[] bytes = new byte[1024];
                DatagramPacket datagramPacket = new DatagramPacket(bytes, 0, bytes.length);
                datagramSocket.receive(datagramPacket);

                byte[] data = datagramPacket.getData();
                String receiveData = new String(data, 0, datagramPacket.getLength());

                System.out.println(this.name + ":" + receiveData);
                if (receiveData.equals("bb")) {
                    break;
                }
            }
            datagramSocket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

用户1

package com.xx.udp;

public class Talk01 {
    public static void main(String[] args) {
        new Thread(new SendThread(8081, "localhost", 8082)).start();
        new Thread(new ReceiveThread(8084, "xx")).start();
    }
}

用户2

package com.xx.udp;

public class Talk02 {
    public static void main(String[] args) {
        new Thread(new SendThread(8083, "localhost", 8084)).start();
        new Thread(new ReceiveThread(8082, "yy")).start();
    }
}

posted @ 2021-07-06 19:25 存在即合理吧阅读(123) 评论(0) 收藏举报

刷新页面返回顶部

存在即合理吧