网络编程

一、网络编程的一些基本概念
（一）网络通信的三个基本要素
1、通信协议：
    在计算机网络中，这些连接和通信的规则被称为网络通信协议，它对数据的传输格式、传输速率、传输步骤等做了统一规定，通信双方必须同时遵守才能完成数据交换。
    理论上有7层，OSI参考模型。物理层、数据链路层、网络层、传输层、会话层、表示层、应用层。
    这个理论太过于精细，过了理论化，实际中没有真正实施，而是有另一个模型代替。
    实际发挥作用的是TCP/IP协议参考模型。
    这个模型是分为四层：物理层+数据链路层、网络层、传输层、应用层。
    TCP/IP协议参考模型的协议有很多，为什么用TCP和IP两个协议作为命名呢？
    因为TCP/IP协议是在最早定下来的（大家最早达成一致协议），并且这两个协议是最最重要的。

TCP：传输控制协议 (Transmission Control Protocol)。面向连接的，可靠的，基于字节流的网络协议。
     面向连接：如果通信双方要通信之前，必须是联通状态的。
            在传输数据之前，会进行“三次握手”来确保网络连接是正常的。
            TCP协议的程序是分为客户端（包括B和C）和服务器端。
            第一次握手：客户端先发起请求，会给服务器发一些状态码
                    比喻：问服务器，我能和你连接吗？  暗号：今晚约吗？
            第二次握手：服务器响应客户端，会给客户端返回状态码，并且加一些状态码信息
                    比喻：可以连接？    回复：你刚才问的是“今晚约吗？”，我回答“可以约”
                    服务器回复你刚才问的是“今晚约吗？”的意义，是让客户端确认它刚才给服务器的消息是正确传递的。
            第三次握手：客户端再次回应服务器。       回复：你刚才说的是“可以约”，我回答“老地方见”
                    客户端回复你刚才说的是“可以约”，让服务器确认它发给客户端的消息是正确传递的

            三次握手没问题之后，再发送真实的数据。

            在传输数据结束，会进行“四次挥手”来断开连接。
            第一次挥手：客户端先发起断开连接的请求。
                    服务器收到后，要关闭接收数据通道，表示服务器不再接收客户端发送的数据了。
            第二次挥手：服务器响应客户端，告诉客户端，它知道了要断开了，
                    但是要通知客户端，你别着急彻底断开，我给你的数据还没完，你要把剩下的数据接收完，再断开。
            第三次挥手：服务器把剩下的数据发送完了之后，告诉客户端，现在咱们可以彻底断开了。
            第四次挥手：客户端会告诉服务器，我准备好了，然后可以彻底断开了。
                    第四次挥手时，客户端在发送完最后的“拜拜”时，会等一会儿。
                    等待的意义是让服务器确实收到了最后的断开的消息。
                    如果对方没收到，TCP协议会让客户端重传，这个时候，客户端还发送一遍，再次等待。
    可靠的：如果中间丢包了，TCP会让对方重传。
UDP：用户数据报协议(User Datagram Protocol)非面向连接的，不可靠的，基于数据报的协议。
    非面向连接的：发送方不管接收方是否在线，都是直接发送消息。
    不可靠：如果丢包了，就丢了。
    优点：快
    适用于：实时会议，视频等

网络程序的结构：B/S,C/S结构
B:浏览器browser，它本质上也是客户端，只是统一的客户端
S：服务器端server
C：客户端   需要用户单独下载和安装的客户端程序

2、IP地址：消息（数据）从哪里来到哪里去，都需要通过IP地址标识
    IP地址是用来唯一的定位/标识一台主机用的。

    域名：为了方便用户记忆主机地址。
        www.atguigu.com  <=  域名解析器  =>IP地址

    本地回环IP：127.0.0.1

3、端口号
    同一台主机上同时有多个应用程序都在和网络进行通信，
    那么端口号就是用来唯一定位/标识一个应用程序的。

    mysql：3306
    tomcat：8080
    http:80
    。。。。

    公共端口：0-1023  1024个
    注册端口：被一些知名软件或应用程序注册
    动态/ 私有端口：49152~65535

  （二）Socket编程
无论基于TCP协议还是基于UDP协议的网络通信程序，都要用到Socket进行编程。
Socket（套接字）：代表网络通信的一个端点。负责和网卡驱动程序交换，发送或接收消息。涉及到IP地址、端口号等内容。
分为两大类：
（1）流套接字：用于TCP协议编程
        SeverSocket：负责客户端和服务器端的连接用，即是服务器端用来等待和接收客户端连接用的，不负责传输数据
        Socket：客户端和服务器端传输数据用的
（2）数据报套接字：用于UDP协议编程
        DatagramSocket：既要负责连接，又要负责传输数据。

端口号：int类型的数字，范围0-65535之间
IP地址：
    （1）字符串：“127.0.0.1”
        不是所有的API都支持字符串类型
    （2）byte[]:
        {127,0,0,1}
        不是所有的API都支持byte[]类型
      (3)InetAddress类的对象

public class TestIPAndPort {
    public static void main(String[] args) throws Exception{
        //获取本地IP地址
        InetAddress localHost = InetAddress.getLocalHost();
        System.out.println(localHost);//LAPTOP-AG8KORH9/192.168.131.1
                                    //LAPTOP-AG8KORH9/192.168.35.82

        //获取尚硅谷官网的ip地址
        InetAddress atguigu = InetAddress.getByName("www.atguigu.com");
        System.out.println(atguigu);

        byte[] ips = {(byte)192,(byte)168,35,82};
        InetAddress address = InetAddress.getByAddress(ips);
        /*
        192的二进制 00000000 00000000 00000000 11000000（int）
                    11000000（byte）
                    底层源码中是使用int处理的，会在11000000前面加24个0恢复原来
         ip地址的每一个数字是[0,255]      [00000000，11111111 ]
         */
    }
}

二、UDP：用户数据报协议(User Datagram Protocol)

接收方：（先运行才能收到消息）
第一步：准备一个Socket
    DatagramSocket ds = new DatagramSocket(8888);
    IP地址：默认是本机
第二步：准备数据报
    byte[] data = new byte[1024];
    DatagramPacket dp = new DatagramPacket(data, data.length);
第三步：接收数据
      ds.receive(dp);
第四步：处理数据
    数据在字节数组中，长度是dp.getLength()
第五步：关闭
    ds.close();

public class TestReceive {
    public static void main(String[] args)throws Exception {
//        第一步：准备一个Socket
        DatagramSocket ds = new DatagramSocket(8888);

//        第二步：准备数据报
        //DatagramPacket(byte[] buf, int length)
        byte[] data = new byte[1024];
        DatagramPacket dp = new DatagramPacket(data, data.length);

        //第三步：接收数据
        //通过socket，接收数据报
        ds.receive(dp);

        //第四步：处理数据
        int length = dp.getLength();//实际接收的数据的长度
        String str = new String(data, 0, length);
        System.out.println(str);

//        第五步：关闭
        ds.close();
    }
}

发送方：
步骤：
第一步：准备一个Socket
    DatagramSocket ds = new DatagramSocket();
    这边的端口号：随机分配
    IP地址：默认是本机
第二步：准备数据报
DatagramPacket(byte[] buf, int length)
          构造 DatagramPacket，用来接收长度为 length 的数据包。
DatagramPacket(byte[] buf, int length, InetAddress address, int port)
          构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。
DatagramPacket(byte[] buf, int offset, int length)
          构造 DatagramPacket，用来接收长度为 length 的包，在缓冲区中指定了偏移量。
DatagramPacket(byte[] buf, int offset, int length, InetAddress address, int port)
          构造数据报包，用来将长度为 length 偏移量为 offset 的包发送到指定主机上的指定端口号。
DatagramPacket(byte[] buf, int offset, int length, SocketAddress address)
          构造数据报包，用来将长度为 length 偏移量为 offset 的包发送到指定主机上的指定端口号。
DatagramPacket(byte[] buf, int length, SocketAddress address)
          构造数据报包，用来将长度为 length 的包发送到指定主机上的指定端口号。

第三步：发生数据
    ds.send(dp);
第四步：关闭
    ds.close();

public class TestSend {
    public static void main(String[] args)throws Exception {
        //第一步：准备一个Socket
        DatagramSocket ds = new DatagramSocket();

        //第二步：准备数据报
        //DatagramPacket(byte[] buf, int length, InetAddress address, int port)
        String data = "明天终于可以休息了";
        byte[] buf = data.getBytes();//默认使用平台的编码方式UTF-8进行编码
        //发给自己
        // InetAddress address = InetAddress.getLocalHost();//接收方现在也是本机
        /*
        发给同桌：

         */
        byte[] ips = {(byte)192,(byte)168,35,82};
        InetAddress address = InetAddress.getByAddress(ips);
        /*
        192的二进制 00000000 00000000 00000000 11000000（int）
                    11000000（byte）
                    底层源码中是使用int处理的，会在11000000前面加24个0恢复原来
         ip地址的每一个数字是[0,255]      [00000000，11111111 ]
         */
        DatagramPacket dp = new DatagramPacket(buf,buf.length, address, 8888);//8888接收方的端口号


        //第三步：发生数据
        //通过socket发生数据报
        ds.send(dp);
        System.out.println("发送完毕");

//        第四步：关闭
        ds.close();
    }
}

三、TCP：传输控制协议 (Transmission Control Protocol)

服务器端：
第一步：开启服务器，注册监听的端口号
    ServerSocket server = new ServerSocket(8888);
第二步：监听并接收客户端的连接  ，如果成功了，就会有一个Socket对象

第三步：可以接收也可以发送
    假设我这里是先演示接收一个消息

第四步：关闭

public class Server1{
    public static void main(String[] args)throws Exception {
//        第一步：开启服务器，注册监听的端口号
        ServerSocket server = new ServerSocket(8888);

        //第二步：监听并接收客户端的连接
        Socket socket = server.accept();
        System.out.println("一个客户端连接成功了");
        System.out.println("这个客户端的IP地址：" + socket.getInetAddress().getHostAddress());

  /*      第三步：可以接收也可以发送
                假设我这里是先演示接收一个消息*/
        //接收消息需要输入流
        InputStream inputStream = socket.getInputStream();
        byte[] data = new byte[1024];
        int len;
        while((len = inputStream.read(data)) != -1){
            System.out.println(new String(data,0,len));
        }

        //第四步：关闭
        inputStream.close();
        socket.close();
        server.close();
    }
}

public class Server2{
    public static void main(String[] args)throws Exception {
//        第一步：开启服务器，注册监听的端口号
        ServerSocket server = new ServerSocket(8888);

        //第二步：监听并接收客户端的连接
        Socket socket = server.accept();
        System.out.println("一个客户端连接成功了");
        System.out.println("这个客户端的IP地址：" + socket.getInetAddress().getHostAddress());

  /*      第三步：可以接收也可以发送*/
        //(1)接收消息需要输入流
        InputStream inputStream = socket.getInputStream();
        byte[] data = new byte[1024];
        int len;
        while((len = inputStream.read(data)) != -1){
            System.out.println(new String(data,0,len));
        }

        //(2)返回消息，使用输出流
        OutputStream outputStream = socket.getOutputStream();
        String str = "hi";
        outputStream.write(str.getBytes());


        //第四步：关闭
        outputStream.close();
        inputStream.close();
        socket.close();
        server.close();
    }
}

/*
TCP编程的服务器端：
    可以同时接收多个客户端的连接
    可以接收多次的客户端的消息，每次接收完客户端发送的消息后，反转消息内容返回
 */
public class Server3 {
    public static void main(String[] args)throws Exception {
        //第一步：开启服务器，并且注册端口号
        ServerSocket server = new ServerSocket(8888);

        int count = 0;
        while(true) {
            //第二步：接收客户端的连接
            Socket socket = server.accept();
            System.out.println("第" + ++count + "个客户端连接，它的IP是：" + socket.getInetAddress());

            //每接收一个客户端，就分配一个线程给他单独通信
            MessageThread thread = new MessageThread(socket);
            thread.start();
        }
//        server.close();//服务器不关了
    }
}

class MessageThread extends Thread{
    private Socket socket;

    public MessageThread(Socket socket) {
        this.socket = socket;
    }

    public void run(){
        try(
                //第三步：接收客户端发送的词语
                //因为本例中使用的是纯文本消息，所以可以使用按行读的方式
                InputStream inputStream = socket.getInputStream();
                InputStreamReader isr = new InputStreamReader(inputStream);
                BufferedReader br = new BufferedReader(isr);

                OutputStream outputStream = socket.getOutputStream();
                //为了对方能够按行读，我们这里按行写
                PrintStream ps = new PrintStream(outputStream);
        ) {
            String line;
            while ((line = br.readLine()) != null) {
                //第四步：返回给客户端
                StringBuilder s = new StringBuilder(line);
                ps.println(s.reverse());
            }
        }catch(IOException e){
            e.printStackTrace();
        }finally{
            //第五步：端开连接
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }

    }
}

/*
TCP编程服务器端：
    同时接收多个客户端上传文件，上传后的文件保存在服务器的upload文件夹下。
    每次接收完一个客户端的文件之后，返回一句话“接收xx文件完毕”
 */
public class Server4 {
    public static void main(String[] args)throws Exception {
        //第一步：开启服务器
        ServerSocket server = new ServerSocket(8888);

        //第二步：接收客户端连接
        while(true){
            Socket socket = server.accept();

            //每一个客户端分配一个线程
            FileUploadThread thread = new FileUploadThread(socket);
            thread.start();
        }
    }
}
class FileUploadThread extends Thread{
    private Socket socket;

    public FileUploadThread(Socket socket) {
        this.socket = socket;
    }

    public void run(){
        FileOutputStream fos = null;
        //第三步：准备接收文件的名字（含后缀名），文件内容
        //每次接收完一个客户端的文件之后，返回一句话“接收xx文件完毕”
        try(
                InputStream inputStream = socket.getInputStream();//负责从网络（客户端）接收数据
                DataInputStream dis = new DataInputStream(inputStream);
                /*
                使用DataInputStream的目的，是因为这个IO流有readUTF()读字符串的方法，
                又有read(byte[] data)读字节内容方法
                 */
                OutputStream outputStream = socket.getOutputStream();//负责返回给客户端结果
                PrintStream ps = new PrintStream(outputStream);
                //PrintStream也是一种输出流，因为它有println方法，可以在输出xxx内容之后换行，即可以实现按行输出
                //至于它的内容输出到哪里，要看它的构造器如何指定
                //PrintStream ps = new PrintStream(outputStream);  ps.println(xx)的数据xx就输出到outputStream流
                //PrintStream ps2 = new PrintStream(new File("文件名"));  ps.println(xx)的数据xx就输出到文件中
                
                ){

            //（1）先接收文件名
            String fileName = dis.readUTF();
            //(2)避免文件的重名问题
            //可以使用A：随机数，B：时间戳，C：IP地址加时间戳，D：UUID等工具类生成唯一的一串数字 E:时间戳+原来的文件名
            //这里演示时间戳的方式
            long time = System.currentTimeMillis();
            String newFileName = time+fileName;
            //(3）准备输出文件内容的FileOutputStream流
            fos = new FileOutputStream("upload/" + newFileName);//负责把接收的文件内容，存储到服务的upload文件夹的某个文件中

            //(4)从网络中接收文件内容，并输出到服务的newFileName文件中
            byte[] data = new byte[1024];
            int len;
            while((len = dis.read(data)) != -1){
                fos.write(data,0,len);
            }

            //(5)返回结果
            ps.println(fileName + "文件接收完毕！");

        }catch (IOException e){
            e.printStackTrace();
        }finally {
            try {
                if(fos!=null){
                    fos.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
            try {
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

//实现群聊，提醒上线、下线、掉线
public class Server5 {
    private static ArrayList<Socket> online = new ArrayList<>();

    public static void main(String[] args)throws Exception {
        //第一步：开启服务器
        ServerSocket server = new ServerSocket(8888);

        //第二步：接收客户端连接
        while(true){
            Socket socket = server.accept();

            //每连接一个客户端，需要把它添加online集合中
            online.add(socket);

            //每一个客户端分配一个线程
            MessageHandler thread = new MessageHandler(socket);
            thread.start();
        }
    }
    static class MessageHandler extends Thread{
        private Socket socket;//接收消息
        private String ip;

        public MessageHandler(Socket socket) {
            this.socket = socket;
            this.ip = socket.getInetAddress().getHostAddress();
        }

        public void run(){
            sendMessageToOthers(ip + "上线了");
            try(
                    InputStream inputStream = socket.getInputStream();
                    InputStreamReader isr = new InputStreamReader(inputStream);
                    BufferedReader br = new BufferedReader(isr);

                    ){

                String line;
                while((line = br.readLine()) != null){
                    if("bye".equalsIgnoreCase(line)){
                        PrintStream printStream = new PrintStream(socket.getOutputStream());
                        printStream.println("bye");//给自己返回bye，用于接收客户端的接收线程
                    }else {
                        sendMessageToOthers(ip + "说：" + line);
                    }
                }
            }catch (IOException e){
                e.printStackTrace();
                sendMessageToOthers(ip + "掉线了");
                //从online移除
                online.remove(socket);
            }finally{
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                sendMessageToOthers(ip + "下线了");
                //从online移除
                online.remove(socket);
            }
        }

        public void sendMessageToOthers(String content){
            //遍历online集合，可以拿的所有客户端的socket，可以给它们返回消息
            Iterator<Socket> iterator = online.iterator();
            while (iterator.hasNext()){
                Socket s = iterator.next();
                try {
                    if(!s.equals(socket)){//不要给自己发
                        PrintStream ps = new PrintStream(s.getOutputStream());
                        ps.println(content);
                        //这里不能关闭ps和s，因为这个客户端还要用呢
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                    //s客户端发送消息失败，说明s客户端已经“掉线”等异常，
                    //应该从online中把它删除
                    iterator.remove();
                }
            }
        }
    }
}

客户端：
如果服务器端没有开，或者你写的IP地址和端口号错，会遇到
    java.net.ConnectException: Connection refused: connect  拒绝连接，连接失败

第一步：主动连接服务器，需要指定服务器端的IP地址和端口号

第二步：可以接收也可以发送
    这里演示发送一个消息
第三步：关闭

public class Client1 {
    public static void main(String[] args) throws Exception{
//        第一步：主动连接服务器，需要指定服务器端的IP地址和端口号
        Socket socket = new Socket("127.0.0.1",8888);

//        第二步：可以接收也可以发送
        //发送消息需要输出流
        OutputStream outputStream = socket.getOutputStream();
        String str = "hello";
        outputStream.write(str.getBytes());

//        第三步：关闭
        outputStream.close();
        socket.close();
    }
}

public class Client2 {
    public static void main(String[] args) throws Exception{
        //第一步：主动连接服务器，需要指定服务器端的IP地址和端口号
        Socket socket = new Socket("127.0.0.1",8888);

//        第二步：可以接收也可以发送
        //(1)发送消息需要输出流
        OutputStream outputStream = socket.getOutputStream();
        String str = "hello";
        outputStream.write(str.getBytes());
//        outputStream.close();//错误的
        socket.shutdownOutput();//半关闭，关闭输出通道，但是不关闭输入通道

        //(2)接收返回的消息
        System.out.println("服务器返回的消息是：");
        InputStream inputStream = socket.getInputStream();
        byte[] data = new byte[1024];
        int len;
        while((len = inputStream.read(data)) != -1){
            System.out.println(new String(data,0,len));
        }

//        第三步：关闭
        outputStream.close();
        inputStream.close();
        socket.close();
    }
}

TCP编程的客户端：
    可以从键盘输入单词/成语等，给服务器发过去，并接收服务器反转后的内容。
    输入一个发送一个，直到从键盘输入stop为止。
 */
public class Client3 {
    public static void main(String[] args) throws Exception{
        //第一步：连接服务器,需要指定服务器的IP地址和端口号
        Socket socket = new Socket("127.0.0.1",8888);

        OutputStream outputStream = socket.getOutputStream();
        //为了对方能够按行读，我们这里按行写
        PrintStream ps = new PrintStream(outputStream);

        //因为本例中使用的是纯文本消息，所以可以使用按行读的方式
        InputStream inputStream = socket.getInputStream();
        InputStreamReader isr = new InputStreamReader(inputStream);
        BufferedReader br = new BufferedReader(isr);

        //第二步：从键盘输入单词、成语等，直到输入stop为止
        Scanner input = new Scanner(System.in);
        while(true){
            System.out.print("输入单词或成语等：");
            String word = input.next();

            if("stop".equalsIgnoreCase(word)){
                break;
            }

            //第三步：给服务器发送过程
            ps.println(word);

            //第四步：接收服务器返回的消息
            System.out.println("服务器返回的消息是：" + br.readLine()) ;
        }

        //第五步关闭
        ps.close();
        outputStream.close();
        br.close();
        isr.close();
        inputStream.close();
        socket.close();
    }
}

/*
TCP编程客户端：
    从键盘输入要上传的文件的具体路径，上传文件，并接收服务器反馈的消息
 */
public class Client4 {
    public static void main(String[] args)throws Exception {
        //第一步：连接服务器
        Socket socket = new Socket("127.0.0.1", 8888);

        //第二步，从键盘输入要上传的文件的具体路径
        Scanner input = new Scanner(System.in);
        System.out.print("请输入要上传的文件的路径：");
        String filePath = input.nextLine();
        //D:\Download\img\美女\15.jpg
        File file = new File(filePath);

        //第三步：给服务器上传文件名，文件内容
        OutputStream outputStream = socket.getOutputStream();
        //为了区别文件名和文件内容，使用DataOutputStream
        DataOutputStream dos = new DataOutputStream(outputStream);

        //输出文件名
        dos.writeUTF(file.getName());

        //输出文件内容
        FileInputStream fis = new FileInputStream(filePath);
        byte[] data = new byte[1024];
        int len;
        while((len = fis.read(data)) != -1){
            dos.write(data,0,len);
        }
        //半关闭
        socket.shutdownOutput();

        //第四步：接收服务器反馈的消息
        InputStream inputStream = socket.getInputStream();
        InputStreamReader isr = new InputStreamReader(inputStream);
        BufferedReader br = new BufferedReader(isr);

        System.out.println(br.readLine());

        //第五步关闭
        br.close();
        isr.close();
        inputStream.close();
        fis.close();
        dos.close();
        outputStream.close();
        input.close();
        socket.close();

    }
}

//实现群聊，提醒上线、下线、掉线
public class Client5 {
    public static void main(String[] args) throws Exception{
        //第一步：连接服务器
        Socket socket = new Socket("127.0.0.1", 8888);

        SendThread send = new SendThread(socket);
        send.start();

        ReceiveThread receiveThread = new ReceiveThread(socket);
        receiveThread.start();

        send.join();
        receiveThread.setFlag(false);
        receiveThread.join();

        socket.close();//socket关闭时，所有的IO流自动关闭了
    }
}

class SendThread extends Thread{
    private Socket socket;

    public SendThread(Socket socket) {
        this.socket = socket;
    }

    public void run(){
        Scanner input = null;
        PrintStream ps = null;
        try {
             input = new Scanner(System.in);
            ps = new PrintStream(socket.getOutputStream());
            while(true){
                System.out.print("请输入要发送的消息内容：");
                String message = input.next();

                ps.println(message);

                if("bye".equalsIgnoreCase(message)){
                    break;
                }

            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
//            ps.close();//在这里不能关闭IO流
            input.close();
        }
    }
}
class ReceiveThread extends Thread{
    private Socket socket;
    private boolean flag = true;

    public ReceiveThread(Socket socket) {
        this.socket = socket;
    }

    public void run(){
        try(
                InputStream inputStream = socket.getInputStream();
                InputStreamReader isr = new InputStreamReader(inputStream);
                BufferedReader br = new BufferedReader(isr);
                ){

            while(flag){
                String line =br.readLine();
                System.out.println("接收的消息：" + line);
            }
        }catch(IOException e){
            e.printStackTrace();
        }
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }
}