网络编程

概述

计算机网络:

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

网络通信的要素

网络编程中有两个主要的问题:

1. 如何准确地定位到网络上的一台或者多台主机
2. 找到主机后如何进行通信

网络编程中的要素:

1. IP和端口号
2. 网络通信协议 udp,tcp

IP

ip地址:InetAddress

• 唯一定位一台计算机
• 127.0.0.1:本机localhost
• ip地址的分类:
  • IPV4/IPV6
    • IPV4:127.0.0.1,4个字节组成
    • IPV6:128位,8个无符号整数
  • 公网(互联网)/私网(局域网)

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

/**
 * 测试ip
 */
public class Demo01 {
    public static void main(String[] args) {
        try {
            InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");
            System.out.println(inetAddress1);

            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());
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }

    }
}

端口

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

• 不同的进程有不同的端口号,用来区分软件

• 被规定为0~65535

• 单个协议下,端口号不能冲突

• 端口分类

  • 公有端口0~1023

    • HTTP:80
    • HTTPS:443
    • FTP:21
    • Telent:23

  • 程序注册端口:1024~49151,分配用户或者程序

    • Tomcat:8080
    • MySQL:3306
    • Oracle:1521

  • 动态.私有:49152~65535

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

通信协议

网络通信协议:速率,传输码率,代码结构,传输控制...

TCP/IP协议簇

重要:

• TCP:用户传输协议
• UDP:用户数据报协议
  • 对比:
    • TCP是面向连接的，UDP是无连接的
    • TCP是可靠的，UDP是不可靠的
    • TCP是面向字节流的，UDP是面向数据报文的
    • TCP只支持点对点通信，UDP支持一对一，一对多，多对多
    • TCP报文首部20个字节，UDP首部8个字节
    • TCP有拥塞控制机制，UDP没有
    • TCP协议下双方发送接受缓冲区都有，UDP并无实际意义上的发送缓冲区，但是存在接受缓冲区

出名的协议:

• TCP
• IP:网络互联协议

TCP

客户端

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

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

//客户端
public class TcpClient {
    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("你好".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. 等待用户的连接 accept
3. 接受用户的消息

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

//服务端
public class TcpServer {
    public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        ByteArrayOutputStream bos = null;
        try {
            //1.有一个地址
            serverSocket = new ServerSocket(9999);

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

        }
    }
}

文件上传

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

//服务端
public class TcpServer {
    public static void main(String[] args) throws IOException {
        //1.创建服务
        ServerSocket serverSocket = new ServerSocket(9000);
        //2.监听客户端的连接
        Socket socket = serverSocket.accept(); //阻塞式监听,会一直等待客户端连接
        //3.获取输入流
        InputStream is = socket.getInputStream();
        //4.文件输出
        FileOutputStream fos = new FileOutputStream(new File("receive.txt"));
        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();
    }
}

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

//客户端
public class TcpClient {
    public static void main(String[] args) throws IOException {
        //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("F:\\code\\基础语法\\a.txt"));
        //4.写出文件
        byte[] buffer = new byte[1024];
        int len;
        while ((len = fis.read(buffer)) != -1){
            os.write(buffer,0,len);
        }

        //通知服务端,我已经传输结束了
        socket.shutdownOutput();

        //确定服务端接收完毕,才能断开连接
        InputStream is = socket.getInputStream();
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        byte[] buffer2 = new byte[2048];
        int len2;
        while ((len2 = is.read(buffer2)) != -1){
            bos.write(buffer2,0,len2);
        }
        System.out.println(bos.toString());

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

UDP

发送消息

发送端

import java.io.IOException;
import java.net.*;

//不需要连接服务器
public class UdpClient {
    public static void main(String[] args) throws IOException {
        //1.建立一个Socket
        DatagramSocket socket = new DatagramSocket();
        //2.建个包
        String msg = "你好";
        //发送给谁
        InetAddress localhost = InetAddress.getByName("localhost");
        int port = 9090;
        //参数:1.数据 2.数据长度起始 3.要发送给谁
        DatagramPacket packet = new DatagramPacket(msg.getBytes(),0,msg.getBytes().length,localhost,port);
        //3.发送包
        socket.send(packet);
        //4.关闭流
        socket.close();
    }
}

接收端

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

public class UdpServer {
    public static void main(String[] args) throws IOException {
        //开放端口
        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();
    }
}

循环发送

发送端

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 UdpSender {
    public static void main(String[] args) throws IOException {
        DatagramSocket socket = new DatagramSocket(8888);
        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 java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;

public class UdpReceiver {
    public static void main(String[] args) throws IOException {
        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 datas = new String(data,0, data.length);
            System.out.println(datas);
            if (datas.equals("bye")) {
                break;
            }
        }
        socket.close();
    }
}

在线咨询

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

import java.io.BufferedReader;
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() {
        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 (Exception e){
                e.printStackTrace();
            }

        }

        socket.close();
    }
}

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

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);
                //断开连接
                byte[] data = packet.getData();
                String datas = new String(data,0, data.length);
                System.out.println(msgFrom+":"+datas);
                if (datas.equals("bye")) {
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

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

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

URL

统一资源定位符

import java.net.MalformedURLException;
import java.net.URL;

public class Demo01 {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("http://localhost/index.jsp?username=gy&&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()); //参数
    }
}

本栏目推荐文章
• 网络攻击技术(二)——Cross-site scripting
• 网络攻击技术开篇——SQL Injection
• Scala编程语言day1
• 学了这么多编程语言，你学会了几种“Hello world”呢？
• socket编程 [补档-2023-07-10]
• 【LeetCode 2701. 连续递增交易】MySQL用户变量编程得到严格递增连续子序列的开始位置，结束位置，长度等统计信息
• 实验七：Spark机器学习库Mtlib编程实践
• 【Leetcode 2474. 购买量严格增加的客户】MySQL用户变量编程解决严格递增连续子序列问题
• 【LeetCode 2494. 合并在同一个大厅重叠的活动】MySQL用户变量编程解决区间合并问题
• 探索短链接：让网络分享更便捷

网络编程 网络网络 网络编程 网络16 网络cl ubuntu网络 网络13 网络10 linux网络 android网络 cisco网络