网络编程之BIO(一)

矫情吗；* 2022-02-25 11:16 301阅读 0赞

**一.编程套路**

服务端:

创建服务器端实例  ServerSocket ss = new ServerSocket();
    指定服务器的监听端口 ss.bind(new InetSocketAddress(9999));
    创建Socket进行请求转发给Socket  Socket s = ss.accept();
    获取客户端意图 InputStream  request = s.getInputStream();
    给出客户端响应 OutputStream response = s.getOutputStream();
    关闭资源 Socket  s.close();

客户端:

创建客户端实例 Socket s = new Socket();
    连接服务器 s.connect(new InetSocketAddress(host,port));
    发送请求 OutputStream out = s.getOutputStream();
    获取响应 InputStream result = s.getInputStream();
    关闭资源 s.close();

**二.demo实践**

1.服务端:

import java.io.*;
    import java.net.InetSocketAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.Date;
    /**
     * Created by ${ligh} on 2019/2/22 上午10:03
     * 
     * 服务端
     *
     * 缺点: 请求转发只能发生一次服务器就关闭了
     */
    public class BIOServerbootstrap {
        public static void main(String[] args) throws Exception{
              //1. 创建服务器端实例  接受客户端请求,转发给Socket对象
              ServerSocket ss = new ServerSocket();
              //2. 指定服务器的监听端口
              ss.bind(new InetSocketAddress(9999));
              //3. 创建Socket进行请求转发 blocking(阻塞操作) 因为没有请求过来的话一直处于等待状态
              System.out.println("我在9999监听...");
              Socket s = ss.accept();
              System.out.println("转发成功");
              //4. 获取客户端意图
              InputStream request = s.getInputStream();
              //通过桥转换把字节流转换成字符流
              InputStreamReader isr = new InputStreamReader(request);
              //转换成缓冲流
              BufferedReader br = new BufferedReader(isr);
              //
              String line = null;
              StringBuffer sb = new StringBuffer();
    
              while((line=br.readLine())!=null){
                  sb.append(line);
              }
              System.out.println("服务器收到: "+sb.toString());
              //5. 给出客户端响应
              OutputStream response = s.getOutputStream();
              PrintWriter pw = new PrintWriter(response);
              pw.println("服务端响应时间: "+new Date());
              pw.flush();
              //告诉客户端 写结束
              s.shutdownOutput();
             //6. 关闭资源 Socket
              s.close();
        }
    }

2.客户端:

import java.io.*;
    import java.net.InetSocketAddress;
    import java.net.Socket;
    
    /**
     * Created by ${ligh} on 2019/2/22 上午10:08
     *
     * 稍微升级一下服务器端可以一直监听端口,但是还差得远
     *
     * 客户端
     *
     */
    public class BIOClientbootstrap {
        public static void main(String[] args) throws Exception{
            //1. 创建客户端实例
            Socket s = new Socket();
            //2. 连接服务器
            s.connect(new InetSocketAddress("127.0.0.1",9999));
            //3. 发送请求
            OutputStream out = s.getOutputStream();
            PrintWriter pw = new PrintWriter(out);
            pw.println("你好,我是客户端...");
            pw.flush();
    
            //告诉服务器 写结束
            s.shutdownOutput();
            //4. 获取响应
            InputStream result = s.getInputStream();
            InputStreamReader isr= new InputStreamReader(result);
            BufferedReader reader= new BufferedReader(isr);
    
            //读取响应
            String line = null;
            StringBuffer sb = new StringBuffer();
            while ((line = reader.readLine())!=null){
                sb.append(line);
            }
            System.out.println("客户端收到: "+sb.toString());
            //5. 关闭资源
            s.close();
        }
    }

缺点: 不能进行持续监听,因此对服务端进行升级如下:

3.升级之后的服务端:

import java.io.*;
    import java.net.InetSocketAddress;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.Date;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    /**
     * Created by ${ligh} on 2019/2/22 上午10:03
     *服务端
     * 优点:
     *   是请求转发是放在main函数中执行的,如果不适用多线程只是单纯的使用while(true),
     * 相当于把请求转发交给客户了,客户每发一次请求服务器就请求转发一次,会过度的浪费服务器资源
     * 缺点:
     *   先启动线程再动用IO资源,会造成IO资源的浪费,因为可能IO还没有就绪就会处于等待状态
     *
     */
    public class BIOServerbootstrap1 {
        public static void main(String[] args) throws Exception {
              //通过线程池实现多线程响应
              ExecutorService pool = Executors.newFixedThreadPool(100);
              //1. 创建服务器端实例  接受客户端请求,转发给Socket对象
              ServerSocket ss = new ServerSocket();
              //2. 指定服务器的监听端口
              ss.bind(new InetSocketAddress(9999));
              while (true) {
              //3. 创建Socket进行请求转发 blocking(阻塞操作) 因为没有请求过来的话一直处于等待状态
                    System.out.println("我在9999监听...");
                    final Socket s = ss.accept();
                    pool.submit(new Runnable() {
                      @Override
                      public void run() {
                            try{
                                  System.out.println("转发成功");
                                  //4. 获取客户端意图
                                  InputStream request = s.getInputStream();
                                  //通过桥转换把字节流转换成字符流
                                  InputStreamReader isr = new InputStreamReader(request);
                                  //转换成缓冲流
                                  BufferedReader br = new BufferedReader(isr);
                                  //
                                  String line = null;
                                  StringBuffer sb = new StringBuffer();
    
                                  while ((line = br.readLine()) != null) {
                                        sb.append(line);
                                  }
                                  System.out.println("服务器收到: " + sb.toString());
                                  //5. 给出客户端响应
                                  OutputStream response = s.getOutputStream();
                                  PrintWriter pw = new PrintWriter(response);
                                  pw.println("服务端响应时间: " + new Date());
                                  pw.flush();
                                  //告诉客户端 写结束
                                  s.shutdownOutput();
                                  //6. 关闭资源 Socket
                                  s.close();
                            }catch (Exception e){
                                  e.printStackTrace();
                            }
                      }
                    });
              }
        }
    }

以上就完成了对BIO编程的研究学习,但是BIO毕竟是一种多线程阻塞IO,耗费资源比较大,所以由此产生了NIO网络编程.