Netty(一)

一、异步事件驱动NIO框架Netty介绍

简介：介绍Netty来源，版本，目前在哪些主流公司和产品框架使用

1、Netty是由JBOSS提供的一个java开源看框架，是业界最流行的NIO框架，整合了多种协议

包括FTP,SMTP,HTTP等各种二进制文本协议)的实验经验，精心设计的框架，在多个大型商业项目中得到充分验证。

         1）：API使用简单

         2）：成熟，稳定

         3）：社区活跃，有很多种NIO框架，如mina

         4)  ：经过大规模的验证(互联网，大数据，网络游戏，电信行业

2、哪些主流框架产品在用？
      1）： 搜索引擎框架(ElasticSerach,github里面的搜索是用es做的:底层是用Netty去做的通信的)。

         2）：Hadoop:子项目Avro项目，底层是用Netty作为底层通信框架

         3）：阿里巴巴的开源框架RPC框架  Dubbo
                 地址：http://dubbo.apache.org/zh-cn

二、使用JDK自带BIO编写一个Client-Server通信

1、BIO网络编程实战之编写BioServer服务端

    简介：使用jdk自带的Bio编写一个统一时间服务，这也是java的socket编程

代码如下：

1. package com.weizhaoyang;
   
2. 
   
3. import java.io.IOException;
   
4. import java.net.ServerSocket;
   
5. import java.net.Socket;
   
6. 
   
7. public class BioServer {
   
8.    public static final int PORT=8080;
   
9. 
   
10.    public static void main(String[] args) throws IOException {
    
11.        ServerSocket server=null;
    
12.        try{
    
13.            server=new ServerSocket(PORT);
    
14.            System.out.println("the server is start  in port:"+PORT);
    
15.            Socket socket=null;
    
16.            while(true){
    
17.                socket = server.accept();
    
18.                new Thread(new TimeServerHandler(socket)).start();
    
19.            }
    
20.           }catch(Exception e){
    
21.        }finally{
    
22.            if(server!=null){
    
23.                System.out.println("the time server close");
    
24.                server.close();
    
25.            }
    
26.        }
    
27.    }
    
28. }
    
29. package com.weizhaoyang;
    
30. import java.io.BufferedReader;
    
31. import java.io.InputStreamReader;
    
32. import java.io.PrintWriter;
    
33. import java.net.Socket;
    
34. import java.util.Date;
    
35. 
    
36. public class TimeServerHandler implements Runnable{
    
37.    private Socket socket;
    
38.    public TimeServerHandler(Socket socket){
    
39.        this.socket=socket;
    
40.    }
    
41.    @Override
    
42.    public void run() {
    
43.        BufferedReader  in=null;
    
44.        PrintWriter  out=null;
    
45.        try{
    
46.            in=new BufferedReader(new InputStreamReader(this.socket.getInputStream()));
    
47.            out=new PrintWriter(this.socket.getOutputStream(),true);
    
48.            String body=null;
    
49.            while((body=in.readLine())!=null&&body.length()!=0){
    
50.                System.out.println("the time server receive msg"+body);
    
51.                out.println(new Date().toString());
    
52.            }
    
53. 
    
54.        }catch(Exception e){
    
55.            e.printStackTrace();
    
56.        }finally{
    
57.            if(in!=null){
    
58.                try{
    
59.                    in.close();
    
60.                }catch(Exception e){
    
61.                    e.printStackTrace();
    
62.                }
    
63.            }
    
64.            if(out!=null){
    
65.                try{
    
66.                    out.close();
    
67.                }catch(Exception e){
    
68.                    e.printStackTrace();
    
69.                }
    
70.            }
    
71.            if(this.socket!=null){
    
72.                try{
    
73.                   this.socket.close();
    
74.                }catch(Exception e){
    
75.                    e.printStackTrace();
    
76.                }
    
77.            }
    
78.        }
    
79.    }
    
80. }
    
81. package com.weizhaoyang;
    
82. 
    
83. import java.io.BufferedReader;
    
84. import java.io.InputStreamReader;
    
85. import java.io.PrintWriter;
    
86. import java.net.Socket;
    
87. 
    
88. public class BioClient {
    
89.    private static final int PORT=8080;
    
90.    private static final String HOST="127.0.0.1";
    
91.    public static void main(String[] args) {
    
92.        Socket socket=null;
    
93.        BufferedReader in=null;
    
94.        PrintWriter out=null;
    
95.        try{
    
96.           socket=new Socket(HOST,PORT);
    
97.            in=new BufferedReader(new InputStreamReader(socket.getInputStream()));
    
98.            out=new PrintWriter(socket.getOutputStream(),true);
    
99.            out.println("i am client");
    
100.            String resp=in.readLine();
     
101.            System.out.println("当前服务时间"+resp);
     
102.        }catch(Exception e){
     
103.            e.printStackTrace();
     
104.        }finally{
     
105.            if(in!=null){
     
106.                try{
     
107.                    in.close();
     
108.                }catch(Exception e){
     
109.                    e.printStackTrace();
     
110.                }
     
111.            }
     
112.            if(out!=null){
     
113.                try{
     
114.                    out.close();
     
115.                }catch(Exception e){
     
116.                    e.printStackTrace();
     
117.                }
     
118.            }
     
119.            if(socket!=null){
     
120.                try{
     
121.                    socket.close();
     
122.                }catch(Exception e){
     
123.                    e.printStackTrace();
     
124.                }
     
125.            }
     
126.        }
     
127. 
     
128.    }
     
129. }
     

运行的结果如下：

三、BIO编写Client/Server通信优缺点分析

   简介：讲解BIO的优缺点，为啥不能高并发情况下性能弱

上面用BIO写了时间同步服务器，在很多项目的时候，做一些时间同步也是很有必要的，如果项目部署了很多的服务器，如果要同步每个服务的时间点，就需要这样的服务统一对应他们的时间。

1、服务端启动好，就在那里阻塞，accpet，等待客户端进行连接

2、一有连接进来，然后就会给它分配一个线程，处理对应的请求。

3、在TimeServerHandler处理对应的业务逻辑，编码和解码事件都会在这个类处理。

优点：模型简单

         编码简单

缺点：性能瓶颈，请求数和线程数属于  N:N关系

         高并发情况下，CPU切换线程上下文损耗大

案例：web服务器Tomcat7之前都使用BIO进行，7之后使用NIO,一个线程对应多个请求进行轮询的操作，或者一个线程池去操作。

改进：伪NIO,使用线程池处理业务逻辑，还会出现阻塞的。