网络编程初识

目录

• 网络编程
  • 1.1、概述
    • 计算机网络：
    • 网络编程的目的：
    • 需要什么
  • 1.2、网络通信的要素
    • 规则：网络通信的协议
    • 小结
  • 1.3、IP
  • 1.4、端口
  • 1.5、通信协议
    • 网络通信协议：
    • TCP/IP协议簇[实际上是一组协议]
    • TCP UDP 对比
  • 1.6、TCP
    • 客户端
    • 服务器
    • 示例1：发送消息
    • 示例2：文件上传
    • Tomcat
  • 1.7、UDP
    • 示例：发送消息
    • 示例：循环发送消息
    • 示例：在线咨询
  • 1.8、URL
    • 示例1：
    • 示例2：
• 快捷键

网络编程

1.1、概述

计算机网络：

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

网络编程的目的：

无线电台---传播交流信息、数据交换、通信

需要什么

1、如何准确的定位网络上的一台主机 xxx.xxx.xxx.xxx:port ,定位到这个计算机上的某个资源

2、找到了这个主机，如果传输数据呢？

1.2、网络通信的要素

如何实现网络的通信？

通信双方的地址：

• ip
• 端口号

规则：网络通信的协议

TCP/IP参考模型

OSI七层网络模型	TVP/IP四层概念模型	对应网络协议
应用层	应用层	HTTP ，TFTP， FTP， NFS ，WAIS ，SMTP
表示层	应用层	Telnet ，Rlogin， SNMP， Gopher
会话层	应用层	SMTP ，DNS
传输层	传输层	TCP， UDP
网络层	网络层	IP， ICMP， ARP， RARP， AKP， UUCP
数据链路层	数据链路层	FDDI， Ethernet ，Arpanet， PDN ，SLIP ，PPP
物理层	数据链路层	IEEE 802.1A , IEEE 802.2到IEEE 802.11

小结

• 网络编程中有两个主要的问题
  • 如何准确的定位到网络上的一台或者多态主机
  • 找到主机之后如何进行通信
• 网络编程中的要素
  • IP和端口号【IP 和 PORT的一些类】
  • 网络通信协议【udp tcp 相关类】
• 万物皆对象【java】

1.3、IP

ip地址：InetAddress

• 唯一定位一台网络上计算机

• 127.0.0.1：本机localhost (ping 127.0.01 就是在给自己发包)

• IP地址分类

  • IPV4/IPV6

    • IPV4：127.0.0.1 四个字节组成 0-255 42亿个；30亿都在北美 亚洲4亿 2011年就用尽
    • IPV6：2402:9865:3214:c3e9:6932:ed14:2342:ba84 128位 8个无符号整数

  • 公网(互联网42亿)-私网(局域网)

    • ABCD类地址

      A类IP地址：1.0.0.0 ----- 127.255.255.255

      B类IP地址：128.0.0.0 ----- 191.255.255.255

      C类IP地址：192.0.0.0 ----- 223.255.255.255

      D类IP地址：224.0.0.0 ----- 239.255.255.255 组播地址

    • 192.168.xxx.xxx 专门给组织内部使用

• 域名：记忆IP问题

  • IP ： www.jd.com （好一点的域名很贵哦）(com国际域名 cn中国的 )

示例：

package ip;

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

/**
 * 测试IP
 */
public class Test {
    public static void main(String[] args) throws UnknownHostException {
        //查询本机地址
        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());// 域名
    }
}

结果：

/127.0.0.1
localhost/127.0.0.1
X6X8-20160220OC/172.20.10.3
www.baidu.com/183.232.231.172
[B@1b6d3586
183.232.231.172
183.232.231.172
www.baidu.com

1.4、端口

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

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

• 端口被规定 0-65535

• 会分TCP端口和UDP端口 每个都有65535 所以端口会65535*2 e.g. 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 "5900" #查询指定端口进程
    

【端口映射】

电脑1： qq(port : 1234) MSN(8888)

电脑2： qq(port : 1234) MSN(8888)

电脑1和电脑2 发送qq消息 要指定对的ip+port

示例：

package ip;

import java.net.InetSocketAddress;

/**
 *
 */
public class TestInetSocketAddress {
    public static void main(String[] args) {
        InetSocketAddress inetSocketAddress = new InetSocketAddress("127.0.0.1", 8080);
        InetSocketAddress inetSocketAddress2 = new InetSocketAddress("localhost", 8080);
        System.out.println(inetSocketAddress);
        System.out.println(inetSocketAddress2);

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

结果：

/127.0.0.1:8080
localhost/127.0.0.1:8080
/127.0.0.1
127.0.0.1
127.0.0.1
8080

1.5、通信协议

协议：约定，就好比我们现在说的普通话，我们能交流

网络通信协议：

速率、传输码率、代码结构、传输控制......

问题:非常的复杂？

大事化小： 分层？

TCP/IP协议簇[实际上是一组协议]

重要：

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

出名的协议：

• TCP：用户传输协议
• IP：网络互联协议
• .....

TCP UDP 对比

TCP：打电话

• 连接：稳定

• 三次握手，四次挥手

  最少需要三次才能保证稳定连接！
  A:你瞅啥？
  B:瞅你咋地？
  A:干一场！
  
  A:我要走了
  B:我知道你要走了
  B:你真的要走了吗？
  A:我真的要走了！
  

• 客户端、服务端【有主动和被动的过程】

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

UDP：发短信

• 不连接：不稳定
• 客户端、服务端，没有明确界限
• 不管有没有准备好，都可以发给你 【不知道接收没接收到】

1.6、TCP

客户端

• 连接服务器通过Socket
• 发送消息

服务器

• 建立服务的端口 ServerSocket
• 等待用户的连接 accept() 此方法会返回客户端的Socket [此时建立连接]
• 接收用户的消息

示例1：发送消息

客户端

package ip;

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 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("你好，我是小仙女".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();
                }
            }
        }
    }
}

服务端

package ip;


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 is = null;
        ByteArrayOutputStream baos = null;
        try {
            //1、我得有一个地址
            serverSocket = new ServerSocket(9999);
            while (true){
                //2、等待客户端连接过来   serverSocket.accept()-->监听
                accept = serverSocket.accept();
                //3、读取客户端的消息
                is = accept.getInputStream();

                /**
                 * byte[] buffer = new byte[1024];
                 *             int len=0;
                 *             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 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 (accept != null){
                try {
                    accept.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if (serverSocket != null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }


}

结果：

你好，我是小仙女
你好，我是小仙女

Process finished with exit code -1

示例2：文件上传

客户端：

package lesson02;

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("11-22-01.png"));
        //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();
        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        byte[] buffer2 = new byte[1024];
        int len2;
        while ((len2 = inputStream.read(buffer2)) != -1){
            byteArrayOutputStream.write(buffer2,0,len2);
        }
        System.out.println(byteArrayOutputStream.toString());

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

服务端：

package lesson02;

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

public class TcpServerDemo02 {
    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("receiver.png"));
        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());


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

客户端结果：

我接收完毕了，你可以断开了

Process finished with exit code 0s

Tomcat

服务器：

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

客户端：

• 自定义 C
• 浏览器 B

1.7、UDP

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

示例：发送消息

send端：

package lesson03;

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;
        //（数据，数据开始点，数据结束点，发送给谁 ip,端口号）
        DatagramPacket packet = new DatagramPacket(msg.getBytes(), 0, msg.getBytes().length, localhost, port);
        //3、发个包
        socket.send(packet);
        //4、关闭流
        socket.close();
    }
}

receive端：

package lesson03;


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
你好啊，服务器

示例：循环发送消息

一个循环发送 一个循环接收

发送方：

package lesson03.chat;

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

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

        while (true){
            String data = reader.readLine();
            byte[] data2 = data.getBytes();
            DatagramPacket packet = new DatagramPacket(data2,0,data2.length,new InetSocketAddress("localhost",6666));

            socket.send(packet);
            if (data.equals("bye")){
                break;
            }
        }

        socket.close();
    }
}

接收方：

package lesson03.chat;

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[] contain = new byte[1024];
            DatagramPacket packet = new DatagramPacket(contain,0,contain.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();
        }
}

结果：

UdpSenderDemo01：

哈哈哈
你好呀

UdpServerDemo01：

哈哈哈
你好呀

示例：在线咨询

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

发送类：

package lesson03.chat;

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

    }

    public TalkSend(){

    }

    @Override
    public void run() {


        while (true){
            try {
                String data = reader.readLine();
                byte[] data2 = data.getBytes();
                DatagramPacket packet = new DatagramPacket(data2,0,data2.length,new InetSocketAddress(this.toIP,this.toPort));
                socket.send(packet);
                if (data.equals("bye")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

接收类：

package lesson03.chat;

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.msgFrom = msgFrom;
        this.port = port;
        try {
            socket = new DatagramSocket(port);
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void run() {
        while (true){
            try {
                //准备接受包裹
                byte[] contain = new byte[1024];
                DatagramPacket packet = new DatagramPacket(contain,0,contain.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 e) {
                e.printStackTrace();
            }
        }
        socket.close();
    }
}

两个多线程：

package lesson03.chat;

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

package lesson03.chat;

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

结果：

TalkStudent

老师：你好       
你好老师
老师：今天数学作业是第八页                    
好的，我只呆了

TalkTeacher

你好
学生：你好老师       
今天数学作业是第八页
学生：好的，我只呆了                                           

1.8、URL

https://www.baidu.com/

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

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

组成： 协议://ip地址:端口号/项目名/资源

示例1：

package lesson04;

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

public class URLDemo01 {
    public static void main(String[] args) throws MalformedURLException {
       URL url = new URL("http://123:8080/helloworld/index.jsp?username=shuang&password=123");//8080是tomcat的端口号
        
        
        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
123
8080
/helloworld/index.jsp
/helloworld/index.jsp?username=shuang&password=123
username=shuang&password=123

Process finished with exit code 0

示例2：

package lesson04;

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;

public class URLDown {
    public static void main(String[] args) throws IOException {
        //1、下载地址
        URL url = new URL("https://c-ssl.duitang.com/uploads/item/202006/17/20200617124500_WTvxP.jpeg");
        //2、连接到这个资源 HTTP
        HttpURLConnection urlConnection= (HttpURLConnection)url.openConnection();

        InputStream inputStream = urlConnection.getInputStream();
        FileOutputStream fos = new FileOutputStream("20200617124500_WTvxP.jpeg");
        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、ctrl + shift + esc -----》 打开任务管理器