Day26 --网络编程

网络编程
        概述
            * 计算机网络
                * 指将地理位置不同的具有独立功能的多台计算机及其外部设备，通过通信线路连接起来。
                * 在 网络操作系统 ，网络管理软件 及 网络通信协议 的管理和协调下，实现资源共享和信息传递的计算机系统
            * 网络编程
                * 用来实现网络互连的不同计算机上 运行的程序间 可以进行数据交换

    网络编程三要素之一（IP地址）
        概述
            * 每个【设备】网络中都具有唯一标识
            * 每台网络终端在网络中都有一个独立的地址，我们在网络中传输数据就是使用这个地址作为依据
            * ipconfig：查看本机IP地址：192.168.0.100
            * ping 网站：测试连接网络(测试外网，测试网络是否连接) ping www.baidu.com
            * 本地回路地址：127.0.0.1 （没有外网的情况下局域网的情况，自己跟自己进行网络通信）
            * 广播地址：255.255.255.255（广播室地址【直播】）
            * IPv4:4个字节组成，4个0-255.大概42亿。30亿都在北美，亚洲占4亿。2011年年初已经用完
            * IPv6:8个字节组成，每组4个16进制数
            * IPv6的表现形式
                * 1a2b:0000:aaaa:0000:0000:0000:aabb:1f2f
                * 1a2b::aaaa:0000:0000:0000:aabb:1f2f
                * 1a2b:0000:aaaa::aabb:1f2f
                * 1a2b:0000:aaaa::0000:aabb:1f2f
                * 1a2b:0000:aaaa:0000::aabb:1f2f


    网络编程三要素之二（端口号）
        概述
            * 每个【程序】在设备上同样具有唯一标识
            * 每个网络程序都需要绑定一个端口号，传输数据的时候除了确定发送到哪台机器设备上，还要明确发送到哪个具体的程序上，每个程序都具有唯一的端口号。
            * 端口号范围：0-65535（char的取值范围）
            * 编写网络应用就需要绑定一个端口号，尽量使用1024以上的，1024以下的端口号基本被系统程序给占用了。
            * 常见端口号：
                * mysql：3306
                * oracle：1521
                * web：80
                * tomact：8080
                * qq：4000
                * 飞秋：2425
                

    网络编程三要素之三（网络协议）
        概述 
            * 为计算机网络中进行数据交换而建立的规则，标准或约定的集合
            * 分为：UDP 和 TCP
            * UPD：
                * 面向无连接
                * 不区分 客户端 和 服务端
                * 数据有大小限制，每个包的大小不能超过64K,。
                * 数据传输过程不安全，不可靠协议。
                * 效率高，速度快
            
            * TCP: 
                * 面向有连接（又称3次握手）
                * 区分 客户端 和 服务端
                * 数据传输过程安全，可靠协议（安全）。
                * 数据没有大小限制
                * 但效率低，速度慢。
                
                
                * 3次握手：先客户端向服务端发起请求，服务器再响应请求，服务端响应请求后将数据传递给客户端
                * （简称：请求，响应，传输数据）
                
            * HTTP协议底层就是使用到TCP协议
            


    Socket通信原理图解
        概述
            * 网络上具有唯一标识的ip地址和端口号组合在一起，才能构成唯一能识别的标识符套接字
            * 通信的两端都有Socket
            * 网络通信其实就是Socket之间的通信
            * 数据在两个Socket间通过IO流传输
            * Socket在应用程序中创建，通过一种绑定机制和驱动程序建立关系，告诉数据所对应的IP和port（端口号）
            * HTTP协议底层就是使用到TCP协议
        p.s.
            网络通信也叫Socket通信，通信两端都独有自己的Socket。
            通信就是在两个Socket之间通过IO流进行数据交换。


            

b.
    UDP传输 （不区分客户端和服务端）
        DatagramSocket：该类表示用来发送和接收数据报包的套接字
            * 数据报套接字是包投递服务的发送或接收点。
            * 每个在数据报套接字上发送或接收的包都是单独编址和路由的
        DatagramRevice：该类表示数据报包
            * 数据报包用来实现无连接包投递服务（接收方未知）。
        
        概述
            * 发送send
                1. 创建DatagramSocket()对象；
                     * 构造数据报套接字并将其绑定到本地主机上任何可用的端口
                     * （用来发送和接收数据报包的套接字）
                            
                2. 创建DatagramPacket(byte[] buf, int length, InetAddress address, int port) 对象；
                    * 构造数据报包，用来将长度为 length 的数据包发送到指定主机上的指定端口号
                    
                3.  创建DatagramSocket发送DatagramPacket，使用 socket.send(DatagramPacket p) 方法
                    * 将定义好的数据报包给套接字
                    * 从此套接字发送数据报包
                
                4.  关闭DatagramSocket()对象，采用socket.close()方法
                    * 关闭此数据报套接字


            * 接收Receive
                1. 创建 DatagramSocket(int port)，指定端口号
                      * 创建数据报套接字并将其绑定到本地主机上的指定端口。
                      
                2. 创建DatagramPacket，指定数组，长度
                    * 构造 DatagramPacket，用来接收长度为 length 的数据包。
                    
                3. 使用DatagramSocket获取DatagramPacket，使用 socket.receive(DatagramPacket p) 方法
                    * 从此套接字接收数据报包。 
                4. 关闭DatagramSocket，采用socket.close()方法
                    * 关闭此数据报套接字
                5. 从DatagramPacket中获取数据，采用byte[] arr = packet.getData()方法返回数据缓冲区。
                    
                6. 获取有效字节个数，使用int len = packet.getLength()方法。
                    
                7. 打印输出 数据报包中的内容
                    * sop(new String(arr,0,len));
                
        使用：
            发送端
                A：创建 DatagramSocket 对象。
                    public DatagramSocket();
                B：创建数据报包对象(DatagramPacket)，用来发送数据。
                    public DatagramPacket(内容，长度，IP，端口号);    //端口号可以随机给
                C：调用 DatagramSocket 的 send() 方法发送 数据报包(DatagramPacket)。
                D：关闭 DatagramSocket 对象。

            接收端
                A：创建 DatagramSocket 对象，指定端口号。
                    public DatagramSocket(端口号);        //端口号必须和发送端一致
                B：创建数据报包对象(DatagramPacket)，用来接收数据。//指定数组，指定长度
                    public DatagramPacket(字节数组，长度);
                C：调用 DatagramSocket 的 receive() 方法发送 数据报包(DatagramPacket)。
                D：关闭 DatagramSocket 对象。
                E：从数据报包中获取数据。
                    获取数据：                packet.getData();
                    获取有效的字节数：        packet.getLength();
                    获取发送端的IP地址:        packet.getAddress().getHostAddress();
                    获取发送端的端口号：    packet.getPort();

    * 接收方获取IP地址 和 端口号的方式
        * String ipAddress = packet.getAddress().getHostAddress(); IP地址
        * int port = packet.getPort(); 端口号


    UDP传输优化
        public class Demo02_01_UDP协议优化_Send_发送方 {
        public static void main(String[] args) throws IOException {
    
            Scanner sc = new Scanner(System.in);
            DatagramSocket socket = new DatagramSocket();
            
            while(true){
                String str = sc.nextLine();
                if("quit".equals(str)){
                    break;
                }
                DatagramPacket packet = new DatagramPacket(str.getBytes(), str.getBytes().length, InetAddress.getByName("127.0.0.1"), 3333);
                socket.send(packet);
            }
            socket.close();
        }
    
    }

        public class Demo02_02_UDP协议优化_Revice_接收方 {
        public static void main(String[] args) throws IOException {
            DatagramSocket socket = new DatagramSocket(3333);
            DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);
            while(true){
                socket.receive(packet);
                
                byte[] data = packet.getData();
                int length = packet.getLength();
                String hostAddress = packet.getAddress().getHostAddress();
                int port = packet.getPort();
                System.out.println(hostAddress + ":" + port + " : " +new String(data, 0, length));
            }
            
        }
    
    }

    
服务器端的输出流可以 写出数据到 客户端的输入流



    UDP传输多线程
        在一个窗口中完成多个线程的send和revice


c.
    UDP聊天窗口工具
        * UDP聊天生成jar文件
            步骤：
                1. 单击要生成的.java文件，选择导出为：JAR file
                2. 设置要保存的位置JAR file：路径.jar,然后next,再next    
                3. Main class中设置要导出的.java,最后finish即可 
d.
    TCP协议
        * 客户端（Client） --android开发
            * 1.创建Socket连接服务端（指定ip地址， 端口号），通过ip地址找到对应的服务器
            * 2.通过调用Socket的getInputstream() 和 getOutputStream()方法获取和服务端的相连接的IO流
            * 3.输入流可以读取服务端输出流写出的数据
            * 4.输出流可以写出数据到客户端的输入流
            
        * 服务端（Server） --javaee开发
            * 1.创建ServerSocket(需要指定端口号)
            * 2.调用ServerSocket的accept()方法接收一个客户端请求，得到一个Socket
            * 3.调用Socket的getInputStream()和getOutputStream()方法获取和客户端相连的IO流
            * 4.输入流可以读取客户端输出流写出的数据
            * 5.输出流可以写出数据到客户端的输入流

    使用：
        客户端
            A：创建客户端的 Socket 对象，指定 IP（写服务器的IP），端口号。
            B：通过 Socket 类中的 getInputStream() 和 getOutputStream()可以获取和服务器端相关联的流。
                客户端的输入流可以 读取 服务器端的输出流写出的数据
                客户端的输出流可以 写入数据到 服务器端的输入流

        服务器端
            A：创建服务器端的Socket对象:ServerSocket.
            B：通过 ServerSocket 类中的 accept() 可以获取客户端的监听，创建Socket与该客户端进行连接。
            C：通过 Socket 类中的 getInputStream() 和 getOutputStream()可以获取和客户器端相关联的流。
                服务器端的输入流可以 读取 客户端的输出流写出的数据


注意：www.baidu.com是域名，而底层都是ip地址，即每个公司的ip地址
            
    TCP协议代码优化
客户端：
    public class Demo02_TCP代码优化_client {
        @SuppressWarnings("resource")
        public static void main(String[] args) throws IOException{
            Socket socket = new Socket("127.0.0.1", 4455);
            
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintStream ps = new PrintStream(socket.getOutputStream());
            
            System.out.println(br.readLine());  //发送请求，希望读取服务器中的一行数据
            ps.println("女：还好"); //发送请求，往服务器中写数据
            System.out.println(br.readLine());
            ps.println("女：你还好么？");
        
            
            socket.close();
        }
    
    }
    
服务端：
    public class Demo02_TCP代码优化_server {
        @SuppressWarnings("resource")
        public static void main(String[] args) throws IOException {
            demo01();
        }
        private static void demo01() throws IOException {
            ServerSocket ss = new ServerSocket(4455);
            
            Socket socket = ss.accept();
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintStream ps = new PrintStream(socket.getOutputStream());
                
            ps.println("男：你最近还吗？");     //接收请求，将结果数据给客户端
            System.out.println(br.readLine()); //接收请求，接收客户端的一条数据
            
            ps.println("男：没有你的日子我好孤独");
            System.out.println(br.readLine());
            
            
            
            socket.close();
        }

    }


    


    服务端是多线程的
    ServerSocket ss = new ServerSocket(4455);
        while(true){
            new Thread(){
                public void run() {
                    try {
                        Socket socket = ss.accept();
                        BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
                        PrintStream ps = new PrintStream(socket.getOutputStream());
                            
                        ps.println("男：你最近还吗？");     //接收请求，将结果数据给客户端
                        System.out.println(br.readLine()); //接收请求，接收客户端的一条数据
                        
                        ps.println("男：没有你的日子我好孤独");
                        System.out.println(br.readLine());
                        
                        socket.close();
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                };
            }.start();
        }


e.
    网络编程练习
        案例一：客户端向服务器写字符串(键盘录入),服务器(多线程)将字符串反转后写回,客户端再次读取到是反转后的字符串
        案例二：客户端向服务器上传文件