网络编程之BIO(一)

一.编程套路

服务端:

创建服务器端实例  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网络编程.