（十二）、Java复习笔记之网络编程

Myth丶恋晨 2022-06-05 09:19 241阅读 0赞

### 141、网络编程 ###

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

### 142、网络编程三要素之IP ###

*  每个设备在网络中的唯一标识
 *  每台网络终端在网络中都有一个独立的地址，我们在网络中传输数据就是使用这个地址。
 *  ipconfig：查看本机IP
 *  ping：测试连接
 *  本地回路地址：127.0.0.1 255.255.255.255是广播地址
 *  IPv4：4个字节组成，4个0-255。大概42亿，30亿都在北美，亚洲4亿。2011年初已经用尽。
 *  IPv6：8组，每组4个16进制数。

### 143、网络编程三要素之端口号 ###

*  每个程序在设备上的唯一标识
 *  每个网络程序都需要绑定一个端口号，传输数据的时候除了确定发到哪台机器上，还要明确发到哪个程序。
 *  端口号范围从0-65535
 *  编写网络应用就需要绑定一个端口号，尽量使用1024以上的，1024以下的基本上都被系统程序占用了。
 *  常用端口  
    
    
     *  mysql: 3306
     *  oracle: 1521
     *  web: 80
     *  tomcat: 8080
     *  QQ: 4000

### 144、网络编程三要素之协议 ###

*  概述  
    
    
     *  为计算机网络中进行数据交换而建立的规则、标准或约定的集合。
 *  UDP  
    
    
     *  面向无连接，数据不安全，速度快。不区分客户端与服务端。
 *  TCP  
    
    
     *  面向连接（三次握手），数据安全，速度略低。分为客户端和服务端。
     *  三次握手: 客户端先向服务端发起请求, 服务端响应请求, 传输数据

### 145、Socket套接字 ###

*  网络上具有唯一标识的IP地址和端口号组合在一起才能构成唯一能识别的标识符套接字。
 *  通信的两端都有Socket。
 *  网络通信其实就是Socket间的通信。
 *  数据在两个Socket间通过IO流传输。
 *  Socket在应用程序中创建，通过一种绑定机制与驱动程序建立关系，告诉自己所对应的IP和port。

### 146、UDP协议 ###

*  发送Send  
    
    
     *  创建DatagramSocket, 随机端口号
     *  创建DatagramPacket, 指定数据, 长度, 地址, 端口
     *  使用DatagramSocket发送DatagramPacket
     *  关闭DatagramSocket
 *  接收Receive  
    
    
     *  创建DatagramSocket, 指定端口号
     *  创建DatagramPacket, 指定数组, 长度
     *  使用DatagramSocket接收DatagramPacket
     *  关闭DatagramSocket
     *  从DatagramPacket中获取数据
 *  接收方获取ip和端口号  
    
    
     *  String ip = packet.getAddress().getHostAddress();
     *  int port = packet.getPort();
 *  实例
    
     *  接收端Receive
        
            DatagramSocket socket = new DatagramSocket(6666);   //创建socket相当于创建码头
            DatagramPacket packet = new DatagramPacket(new byte[1024], 1024); //创建packet相当于创建集装箱
            
            while(true) {
                socket.receive(packet); //接收货物
                byte[] arr = packet.getData();
                int len = packet.getLength();
                String ip = packet.getAddress().getHostAddress();
                System.out.println(ip + ":" + new String(arr,0,len));
            }
     *  发送端Send
        
            DatagramSocket socket = new DatagramSocket();//创建socket相当于创建码头
            Scanner sc = new Scanner(System.in);
            
            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"), 6666);
                socket.send(packet); //发货
            }
            socket.close();
 *  UDP传输-多线程
    
        public class Demo3_MoreThread {
            public static void main(String[] args) {
                new Receive().start();
                new Send().start();
            }
        }
        
        class Receive extends Thread {
            public void run() {
                try {
                    DatagramSocket socket = new DatagramSocket(6666);                   
                    DatagramPacket packet = new DatagramPacket(new byte[1024], 1024);   
        
                    while(true) {
                        socket.receive(packet);                                             
                        byte[] arr = packet.getData();
                        int len = packet.getLength();
                        String ip = packet.getAddress().getHostAddress();
                        System.out.println(ip + ":" + new String(arr,0,len));
                    }
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        
        class Send extends Thread {
            public void run() {
                try {
                    DatagramSocket socket = new DatagramSocket();       
                    Scanner sc = new Scanner(System.in);
        
                    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"), 6666);
                        socket.send(packet);            
                    }
                    socket.close();
                }  catch (IOException e) {
        
                    e.printStackTrace();
                }
            }
        }

### 147、TCP协议 ###

*  客户端  
    
    
     *  创建Socket 连接服务端(指定ip地址,端口号)，通过ip地址找对应的服务器
     *  调用Socket 的getInputStream()和getOutputStream()方法获取和服务端相连的IO 流
     *  输入流可以读取服务端输出流写出的数据
     *  输出流可以写出数据到服务端的输入流
 *  服务端  
    
    
     *  创建ServerSocket(需要指定端口号)
     *  调用ServerSocket 的accept()方法接收一个客户端请求，得到一个Socket
     *  调用Socket 的getInputStream()和getOutputStream()方法获取和客户端相连的IO流
     *  输入流可以读取客户端输出流写出的数据
     *  输出流可以写出数据到客户端的输入流
 *  实例
    
     *  客户端
        
            Socket socket = new Socket("127.0.0.1", 9999); //创建Socket指定ip地址和端口号
            InputStream is = socket.getInputStream(); //获取输入流
            OutputStream os = socket.getOutputStream(); //获取输出流
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            PrintStream ps = new PrintStream(os);
            
            System.out.println(br.readLine());
            ps.println("我真的好爱你。");
            System.out.println(br.readLine());
            ps.println("你呢？");
            socket.close();
     *  服务端
        
            ServerSocket server = new ServerSocket(9999);   //创建服务器
            Socket socket = server.accept(); //接受客户端的请求
            InputStream is = socket.getInputStream();   //获取输入流
            OutputStream os = socket.getOutputStream(); //获取输出流
            
            BufferedReader br = new BufferedReader(new InputStreamReader(is));
            PrintStream ps = new PrintStream(os);
            
            ps.println("求求你爱我好不好！");
            System.out.println(br.readLine());
            ps.println("你好好照顾自己。");
            System.out.println(br.readLine());
            server.close();
            socket.close();
 *  服务端-多线程
    
        ServerSocket server = new ServerSocket(9999);   //创建服务器
            while(true) {
                final Socket socket = server.accept();  //接受客户端的请求
                new Thread() {
                    public void run() {
                        try {
                            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();
            }
        }
 *  聊天案例：[JaveSE聊天案例][JaveSE]

### 148、网络编程练习 ###

*  客户端向服务器写字符串(键盘录入),服务器(多线程)将字符串反转后写回,客户端再次读取到是反转后的字符串
    
        //Client
        public static void main(String[] args) throws UnknownHostException, IOException {
            Scanner sc = new Scanner(System.in);                //创建键盘录入对象
            Socket socket = new Socket("127.0.0.1", 54321);     //创建客户端,指定ip地址和端口号
        
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream())); //获取输入流
            PrintStream ps = new PrintStream(socket.getOutputStream());//获取输出流
        
            ps.println(sc.nextLine());  //将字符串写到服务器去
            System.out.println(br.readLine());  //将反转后的结果读出来
        
            socket.close();
        }
        
        //Server
        public static void main(String[] args) throws IOException {
            ServerSocket server = new ServerSocket(54321);
            System.out.println("服务器启动,绑定54321端口");
        
            while(true) {
                final Socket socket = server.accept();  //接受客户端的请求
        
                new Thread() {  //开启一条线程
                    public void run() {
                        try {
                            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream())); //获取输入流
                            PrintStream ps = new PrintStream(socket.getOutputStream());//获取输出流
        
                            String line = br.readLine();    //将客户端写过来的数据读取出来
                            line = new StringBuilder(line).reverse().toString();    //链式编程
                            ps.println(line);   //反转后写回去
        
                            socket.close();
                        } catch (IOException e) {                       
                            e.printStackTrace();
                        }
                    }
                }.start();
            }
        }
 *  客户端向服务器上传文件
    
        //Client
        public static void main(String[] args) throws UnknownHostException, IOException {
            // 1.提示输入要上传的文件路径, 验证路径是否存在以及是否是文件夹
            File file = getFile();
            // 2.发送文件名到服务端
            Socket socket = new Socket("127.0.0.1", 12345);
            BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            PrintStream ps = new PrintStream(socket.getOutputStream());
            ps.println(file.getName());
            // 6.接收结果, 如果存在给予提示, 程序直接退出
            String result = br.readLine();  //读取存在后不存在的结果
            if("存在".equals(result)) {
                System.out.println("您上传的文件已经存在,请不要重复上传");
                socket.close();
                return;
            }
            // 7.如果不存在, 定义FileInputStream读取文件, 写出到网络
            FileInputStream fis = new FileInputStream(file);
            byte[] arr = new byte[8192];
            int len;
        
            while((len = fis.read(arr)) != -1) {
                ps.write(arr, 0, len);
            }
        
            fis.close();
            socket.close();
        }
        
        private static File getFile() {
            Scanner sc = new Scanner(System.in);                //创建键盘录入对象
            System.out.println("请输入一个文件路径:");
        
            while(true) {
                String line = sc.nextLine();
                File file = new File(line);
        
                if(!file.exists()) {
                    System.out.println("您录入的文件路径不存在,请重新录入:");
                }else if(file.isDirectory()) {
                    System.out.println("您录入的是文件夹路径,请输入一个文件路径:");
                }else {
                    return file;
                }
            }
        }

--------------------

//Server
        public static void main(String[] args) throws IOException {
            //3,建立多线程的服务器
            ServerSocket server = new ServerSocket(12345);
            System.out.println("服务器启动,绑定12345端口号");
    
            //4.读取文件名
            while(true) {
                final Socket socket = server.accept();  //接受请求
                new Thread() {
                    public void run() {
                        try {
                            InputStream is = socket.getInputStream();
                            BufferedReader br = new BufferedReader(new InputStreamReader(is));
                            PrintStream ps = new PrintStream(socket.getOutputStream());
                            String fileName = br.readLine();
    
                            //5.判断文件是否存在, 将结果发回客户端
                            File dir = new File("upload");
                            dir.mkdir();                                //创建文件夹
                            File file = new File(dir,fileName);         //封装成File对象
    
                            if(file.exists()) {                         //如果服务器已经存在这个文件
                                ps.println("存在");                       //将存在写给客户端
                                socket.close();                         //关闭socket
                                return;
                            }else {
                                ps.println("不存在");
                            }
    
                            //8.定义FileOutputStream, 从网络读取数据, 存储到本地
                            FileOutputStream fos = new FileOutputStream(file);
                            byte[] arr = new byte[8192];
                            int len;
    
                            while((len = is.read(arr)) != -1) {
                                fos.write(arr, 0, len);
                            }
    
                            fos.close();
                            socket.close();
                        } catch (IOException e) {
    
                            e.printStackTrace();
                        }
                    }
                }.start();
            }
        }

[JaveSE]: http://blog.csdn.net/litianxiang_kaola/article/details/70337872