网络编程

1.1、基本概念

首先理清一个概念：网络编程不等于网站编程，网络编程即使用套接字来达到进程间通信，现在一般称为TCP/IP编程。

计算机网络

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

网络编程的目的

无线电台…传播交流信息，数据交换。通信

Javaweb和网络编程的区别

Javaweb：主要用于网页编程开发,采用的b/s架构(网站又称浏览器-服务器应该程序，Browser/Server)。

网络编程：主要是网络通信，实现计算机之间的对话和文件传输。采用的是c/s架构（应用软件，桌面应用程序又称之为客户端-服务器应用程序，Client/Server）。

1.2、网络通信的要素

1.2.1、如何实现网络的通讯？

1.通信双方地址：ip+端口号

2.网络通信协议： UDP，TCP

现在我以QQ这个应用程序为例，来讲解双方互相通信的过程。

比如你正在用QQ正在和你的好朋友通信，你用QQ给它发了句“睡了吗”，那这句睡了吗？是通过怎样的路径到对方的qq中，让对方看到呢？

首先：我们的QQ会以“app+睡了吗”这样的形式先进行第一次封装，这一层是在操作系统内核的用户区进行的第一次封装。即只是进行一个普通的标识。

（2）这个消息被传送到传输层，传输层会以“tcp报头+应用数据”这样的形式进行封装。这个操作是内核做的，所谓内核即就是操作系统。

（3）然后这个消息到达网络层，网络层会以“IP报头+应用层数据”这样的形式进行封装，这个操作当然也是内核做的。

（4）再然后这个消息到达数据链路层，数据链路层会”以太网首部+应用数据+以太网尾部”这样的形式进行最后的封装，现在我们将这个数据已经封装好了。

（5）最后这个数据通过总线到达主机接口，再通过网线被送到主机A的接口，然后通过协议我我们在把报头层层去掉，最后数据到达我们的应用层。即实现了数据传输。

以上就是数据传输的5步，当然这是根据tcp/ip协议来进行传输的。
当我们的数据到达主机接口处时，其实我们的数据以经封装好了，而我们的网线只是负责传输即可。即以下4层都是由我们的内核实现的。

1.2.2、规则：网络通信的协议

TCP/IP参考模型：

1.3、IP地址

ip地址：InetAddress

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

• 127.0.0.1 ： 本机 localhost

• ip地址的分类

  • ipv4 / ipv6

    • IPV4 127.0.0.1 , 4个字节组成。， 0~255， 42亿~ ； 30亿都在北美，亚洲4亿。2011年就用尽；

    • IPV6 :128位。8个无符号整数！

      2001：0bb2：aaaa：0015:0000:0000:1aaa：1312！
      

  • 公网（互联网）- 私网（局域网）

    • ABCDE类地址

    A类IP地址 地址范围1.0.0.1-126.255.255.254

    B类IP地址地址范围128.1.0.1-191.254.255.254

    C类IP地址范围192.0.1.1-223.255.254.254

    D类IP地址范围224.0.0.1-239.255.255.254 。

    E类IP地址范围240.0.0.0---255.255.255.254。

    上述IP地址均为IPv4地址

    • 192.168.xx.xx,专门给组织内部使用的

• 域名：记忆IP问题！

  • IP： www.vip.com

案例演示：

package inetdemo;

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

public class TestInetAddress {
    public static void main(String[] args) throws UnknownHostException {
        InetAddress inetAddress1 = InetAddress.getByName("127.0.0.1");
        System.out.println(inetAddress1);
        InetAddress inetAddress2 = InetAddress.getByName("localhost");
        System.out.println(inetAddress2);
        InetAddress inetAddress3 = InetAddress.getLocalHost();
        System.out.println(inetAddress3);

        InetAddress inetAddress4 = InetAddress.getByName("www.baidu.com");
        System.out.println(inetAddress4);
        System.out.println(inetAddress2.getAddress());
        System.out.println(inetAddress2.getCanonicalHostName()); //规范的名字
        System.out.println(inetAddress2.getHostAddress()); //ip
        System.out.println(inetAddress2.getHostName()); //域名，或者自己电脑的名字
    }
}

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

    ​```java
    

    netstat -ano #查看所有的端口
    netstat -ano|findstr "5900" # 查看指定的端口
    tasklist|findstr "8696" #查看指定端口的进程
    Ctrl+ shift + ESC #任务管理器
    ```

案例演示：

package inetdemo;

import java.net.InetSocketAddress;

public class TestInetSockAdress {
    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()); //端口
            }
        }

展示图：

例子：QQ和QQ之间传输 ，两个QQ进程之间要交互，就必须要连接端口，例如两个都是8998，假设msn的端口叫7777，msn就接收不到（产生了丢失）

1.5、通信协议

协议：就是他们之间的共同达成的约定

网络通信协议： 速率，传输码率，代码结构，传输控制…..

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

重要：

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

出名的协议：

• TCP：
• IP ： 网络互连协议

TCP udp 对比

TCP : 打电话

• 连接，稳定

• 三次握手 四次挥手

• 举例子：

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

• 客户端、服务端

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

UDP ： 发短信

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

1.6、TCP

TCP（Transmission Control Protocol传输控制协议）是一种面向连接的、可靠的、基于字节流的传输层通信协议。

三次握手

所谓三次握手（Three-Way Handshake）即建立TCP连接，就是指建立一个TCP连接时，需要客户端和服务端总共发送3个包以确认连接的建立。在socket编程中，这一过程由客户端执行connect来触发，整个流程如下图所示：

（1）第一次握手：Client将标志位SYN置为1，随机产生一个值seq=J，并将该数据包发送给Server，Client进入SYN_SENT状态，等待Server确认。
（2）第二次握手：Server收到数据包后由标志位SYN=1知道Client请求建立连接，Server将标志位SYN和ACK都置为1，ack=J+1，随机产生一个值seq=K，并将该数据包发送给Client以确认连接请求，Server进入SYN_RCVD状态。
（3）第三次握手：Client收到确认后，检查ack是否为J+1，ACK是否为1，如果正确则将标志位ACK置为1，ack=K+1，并将该数据包发送给Server，Server检查ack是否为K+1，ACK是否为1，如果正确则连接建立成功，Client和Server进入ESTABLISHED状态，完成三次握手，随后Client与Server之间可以开始传输数据了。

四次挥手

由于TCP连接时全双工的，因此，每个方向都必须要单独进行关闭，这一原则是当一方完成数据发送任务后，发送一个FIN来终止这一方向的连接，收到一个FIN只是意味着这一方向上没有数据流动了，即不会再收到数据了，但是在这个TCP连接上仍然能够发送数据，直到这一方向也发送了FIN。首先进行关闭的一方将执行主动关闭，而另一方则执行被动关闭，上图描述的即是如此。
（1）第一次挥手：Client发送一个FIN，用来关闭Client到Server的数据传送，Client进入FIN_WAIT_1状态。
（2）第二次挥手：Server收到FIN后，发送一个ACK给Client，确认序号为收到序号+1（与SYN相同，一个FIN占用一个序号），Server进入CLOSE_WAIT状态。
（3）第三次挥手：Server发送一个FIN，用来关闭Server到Client的数据传送，Server进入LAST_ACK状态。
（4）第四次挥手：Client收到FIN后，Client进入TIME_WAIT状态，接着发送一个ACK给Server，确认序号为收到序号+1，Server进入CLOSED状态，完成四次挥手。
上面是一方主动关闭，另一方被动关闭的情况，实际中还会出现同时发起主动关闭的情况，具体流程如下图：

传输消息

客户端

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

package InetDemo01;

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 = 8080;
            //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. 接收用的消息

package InetDemo01;

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

            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);
                } 
                这个如果字节数组超过了1024会造成乱码 所以不用这种方法
             */


        } 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 InetDemo01;

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("D:\Java\1203\src\InetDemo01\zmx.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();
        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();
        }
    }

服务器端

package InetDemo01;

import java.io.*;
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("JJH.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();

    }
}

1.7、UDP

UDP 是User Datagram Protocol的简称， 中文名是用户数据报协议。

UDP是一个无连接协议，传输数据之前源端和终端不建立连接，当它想传送时就简单地去抓取来自应用程序的数据，并尽可能快地把它扔到网络上。在发送端，UDP传送数据的速度仅仅是受应用程序生成数据的速度、计算机的能力和传输带宽的限制；在接收端，UDP把每个消息段放在队列中，应用程序每次从队列中读一个消息段

由于传输数据不建立连接，因此也就不需要维护连接状态，包括收发状态等，因此一台服务机可同时向多个客户机传输相同的消息。

下面是案例的演示：

客户端：

package InetDemo01;

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

接收端：

package InetDemo01;

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

咨询

客户端：

package chat;

import sun.security.util.Length;

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(5500);
         //准备数据： 控制台读取 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",269));

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

        socket.close();


    }
}

接收端：

package InetDemo01;

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

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

在线咨询（两人都可以是发送方和接收方）

发送端：

package chat;

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 {
            DatagramSocket 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("localhost", 269));
                socket.send(packet);
                if (data.equals("bye")) {
                    break;
                }

            } catch (Exception e) {
                e.printStackTrace();
            }

        }
        socket.close();


    }
}

接收端：

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

    @Override
    public void run() {

        //准备接受包裹
        byte[] bytes = new byte[1024];
        while (true){
            try {
                DatagramPacket packet = new DatagramPacket(bytes,0,bytes.length);
                socket.receive(packet);
                //断开连接
                byte[] data = packet.getData();
                String receviceData = data.toString();
                System.out.println(msgFrom+"："+receviceData);
                if (receviceData.equals("bye")){
                    break;
                }
            } catch (IOException e) {
                e.printStackTrace();
            }

        }
        socket.close();
    }
}

学生：

package chat;

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

}

老师：

package chat;

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

实际应用：

UDP和TCP协议的主要区别是两者在如何实现信息的可靠传递方面不同。TCP协议中包含了专门的传递保证机制，当数据接收方收到发送方传来的信息时，会自动向发送方发出确认消息；发送方只有在接收到该确认消息之后才继续传送其它信息，否则将一直等待直到收到确认信息为止。与TCP不同，UDP协议并不提供数据传送的保证机制。如果在从发送方到接收方的传递过程中出现数据包的丢失，协议本身并不能做出任何检测或提示。因此，通常人们把UDP协议称为不可靠的传输协议。

既然UDP是一种不可靠的网络协议，那么还有什么使用价值或必要呢？其实不然，在有些情况下UDP协议可能会变得非常有用。因为UDP具有TCP所望尘莫及的速度优势。虽然TCP协议中植入了各种安全保障功能，但是在实际执行的过程中会占用大量的系统开销，无疑使速度受到严重的影响。反观UDP，由于排除了信息可靠传递机制，将安全和排序等功能移交给上层应用来完成，极大降低了执行时间，使速度得到了保证。

1.8、URL

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

DNS的域名解析：相当于把一个域名变成一个IP地址

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

package InetDemo01;

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

public class URLDemo01 {
    public static void main(String[] args) throws MalformedURLException {
        URL url = new URL("http://localhost:8080/helloworld/JJH.jpg?username=JJH&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()); //参数

    }
}

下载一首自己唱的歌（嘻嘻☺）

package url;

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

public class UrlDown {
    public static void main(String[] args) throws IOException {
        //1.下载地址
        URL url = new URL("http://ws.stream.kg.qq.com/szkge-btfs/5e38d91fd03ad768b016c045f3f1d74b1fcded1a?ftnrkey=7283396c89379347fa3c050a984bae260a6e9c113ed8b2125f58211a6cb05d58cbd3811da8a073ae8572778e57f72926b5e3197b768d20b655761640b7aa1387&vkey=4457C2ABFAC76C315FD8D06B4B8C5CE6D557B492BA4CE2AEE38ACEC0BDB5F7D28483ABBFA0FCC5D08651D301320A2C27F3B642533C0A3696E888BEAFBA401136CEDBD277BB4CD09580DD9CA406E0B63B9AC96A23CBDF51BA&fname=1021_0bc5c5ef5f26f0ba547e47ef80f99bfc6d81fdaf.0.m4a&fromtag=1506&sdtfrom=v1506&ugcid=32979786_1516791901_2714");
        //2.连接到这个资源 http
        HttpURLConnection urlConnection = (HttpURLConnection) url.openConnection();

        InputStream inputStream = urlConnection.getInputStream();

        FileOutputStream fos = new FileOutputStream("等你下课.m4a");

        byte[] buffer = new byte[1024];
        int len;
        while ((len=inputStream.read(buffer))!=-1){
            fos.write(buffer,0,len);//写出这个数据
        }
        fos.close();
        inputStream.close();
        urlConnection.disconnect();

    }
}