`

java开发之netty里集成spring注入mysq连接池(一)

 
阅读更多

netty的性能非常高，能达到8000rps以上，见

各个web服务器的性能对比测试

1.准备好需要的jar包

 

点击(此处)折叠或打开

  1. spring.jar //spring包
  2. netty-3.2.4.Final.jar // netty库
  3. commons-dbcp.jar // dbcp数据库连接池
  4. mysql-connector-java-5.1.6.jar // dbcp数据库连接池需要依赖
  5. commons-logging.jar //spring.jar需要依赖
  6. commons-pool.jar

2.新建java工程TestNettyServer

2.1导入netty的例子
HttpServer.java

 

1.package org.jboss.netty.example.http.snoop; 

2. 

3.import java.net.InetSocketAddress; 

4.import java.util.concurrent.Executors; 

5.import org.jboss.netty.bootstrap.ServerBootstrap; 

6.import org.jboss.netty.channel.socket.nio.NioServerSocketChannelFactory; 

7. 

8.public class HttpServer { 

9.    public static void main(String[] args) { 

10.        // Configure the server. 

11.        ServerBootstrap bootstrap = new ServerBootstrap( 

12.                new NioServerSocketChannelFactory( 

13.                        Executors.newCachedThreadPool(), 

14.                        Executors.newCachedThreadPool())); 

15.        // Set up the event pipeline factory. 

16.        bootstrap.setPipelineFactory(new HttpServerPipelineFactory()); 

17. 

18.        // Bind and start to accept incoming connections. 

19.        bootstrap.bind(new InetSocketAddress(8081)); 

20.    } 

21.}

 

1.package org.jboss.netty.example.http.snoop; 

2.    

3.  import static org.jboss.netty.channel.Channels.*; 

4.    

5.  import org.jboss.netty.channel.ChannelPipeline; 

6.  import org.jboss.netty.channel.ChannelPipelineFactory; 

7.  import org.jboss.netty.handler.codec.http.HttpContentCompressor; 

8.  import org.jboss.netty.handler.codec.http.HttpRequestDecoder; 

9.  import org.jboss.netty.handler.codec.http.HttpResponseEncoder; 

10. 

11.  public class HttpServerPipelineFactory implements ChannelPipelineFactory { 

12.      public ChannelPipeline getPipeline() throws Exception { 

13.          // Create a default pipeline implementation. 

14.          ChannelPipeline pipeline = pipeline(); 

15.    

16.          // Uncomment the following line if you want HTTPS 

17.          //SSLEngine engine = SecureChatSslContextFactory.getServerContext().createSSLEngine(); 

18.          //engine.setUseClientMode(false); 

19.          //pipeline.addLast("ssl", new SslHandler(engine)); 

20.    

21.          pipeline.addLast("decoder", new HttpRequestDecoder()); 

22.          // Uncomment the following line if you don't want to handle HttpChunks. 

23.          //pipeline.addLast("aggregator", new HttpChunkAggregator(1048576)); 

24.          pipeline.addLast("encoder", new HttpResponseEncoder()); 

25.          // Remove the following line if you don't want automatic content compression. 

26.          pipeline.addLast("deflater", new HttpContentCompressor()); 

27.          pipeline.addLast("handler", new HttpRequestHandler()); 

28.          return pipeline; 

29.      } 

30.  }

 

1.package org.jboss.netty.example.http.snoop; 

2.    

3.  import static org.jboss.netty.handler.codec.http.HttpHeaders.*; 

4.  import static org.jboss.netty.handler.codec.http.HttpHeaders.Names.*; 

5.  import static org.jboss.netty.handler.codec.http.HttpResponseStatus.*; 

6.  import static org.jboss.netty.handler.codec.http.HttpVersion.*; 

7.    

8.  import java.util.List; 

9.  import java.util.Map; 

10.  import java.util.Map.Entry; 

11.  import java.util.Set; 

12.    

13.  import org.jboss.netty.buffer.ChannelBuffer; 

14.  import org.jboss.netty.buffer.ChannelBuffers; 

15.  import org.jboss.netty.channel.ChannelFuture; 

16.  import org.jboss.netty.channel.ChannelFutureListener; 

17.  import org.jboss.netty.channel.ChannelHandlerContext; 

18.  import org.jboss.netty.channel.ExceptionEvent; 

19.  import org.jboss.netty.channel.MessageEvent; 

20.  import org.jboss.netty.channel.SimpleChannelUpstreamHandler; 

21.  import org.jboss.netty.handler.codec.http.Cookie; 

22.  import org.jboss.netty.handler.codec.http.CookieDecoder; 

23.  import org.jboss.netty.handler.codec.http.CookieEncoder; 

24.  import org.jboss.netty.handler.codec.http.DefaultHttpResponse; 

25.  import org.jboss.netty.handler.codec.http.HttpChunk; 

26.  import org.jboss.netty.handler.codec.http.HttpChunkTrailer; 

27.  import org.jboss.netty.handler.codec.http.HttpRequest; 

28.  import org.jboss.netty.handler.codec.http.HttpResponse; 

29.  import org.jboss.netty.handler.codec.http.QueryStringDecoder; 

30.  import org.jboss.netty.util.CharsetUtil; 

31.    

32.  /** 

33.   * @author <a href="http://www.jboss.org/netty/">The Netty Project 

34.   * @author Andy Taylor (andy.taylor@jboss.org) 

35.   * @author <a href="http://gleamynode.net/">Trustin Lee 

36.   * 

37.   * @version $Rev: 2368 $, $Date: 2010-10-18 17:19:03 +0900 (Mon, 18 Oct 2010) $ 

38.   */ 

39.  public class HttpRequestHandler extends SimpleChannelUpstreamHandler { 

40.    

41.      private HttpRequest request; 

42.      private boolean readingChunks; 

43.      /** Buffer that stores the response content */ 

44.      private final StringBuilder buf = new StringBuilder(); 

45.    

46.      @Override 

47.      public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception { 

48.          if (!readingChunks) { 

49.              HttpRequest request = this.request = (HttpRequest) e.getMessage(); 

50.    

51.              if (is100ContinueExpected(request)) { 

52.                  send100Continue(e); 

53.              } 

54.    

55.              buf.setLength(0); 

56.              buf.append("WELCOME TO THE WILD WILD WEB SERVER\r\n"); 

57.              buf.append("===================================\r\n"); 

58.    

59.              buf.append("VERSION: " + request.getProtocolVersion() + "\r\n"); 

60.              buf.append("HOSTNAME: " + getHost(request, "unknown") + "\r\n"); 

61.              buf.append("REQUEST_URI: " + request.getUri() + "\r\n\r\n"); 

62.    

63.              for (Map.Entry<String, String> h: request.getHeaders()) { 

64.                  buf.append("HEADER: " + h.getKey() + " = " + h.getValue() + "\r\n"); 

65.              } 

66.              buf.append("\r\n"); 

67.    

68.              QueryStringDecoder queryStringDecoder = new QueryStringDecoder(request.getUri()); 

69.              Map<String, List<String>> params = queryStringDecoder.getParameters(); 

70.              if (!params.isEmpty()) { 

71.                  for (Entry<String, List<String>> p: params.entrySet()) { 

72.                      String key = p.getKey(); 

73.                      List<String> vals = p.getValue(); 

74.                      for (String val : vals) { 

75.                          buf.append("PARAM: " + key + " = " + val + "\r\n"); 

76.                      } 

77.                  } 

78.                  buf.append("\r\n"); 

79.              } 

80.    

81.              if (request.isChunked()) { 

82.                  readingChunks = true; 

83.              } else { 

84.                  ChannelBuffer content = request.getContent(); 

85.                 if (content.readable()) { 

86.                     buf.append("CONTENT: " + content.toString(CharsetUtil.UTF_8) + "\r\n"); 

87.                 } 

88.                 writeResponse(e); 

89.             } 

90.         } else { 

91.             HttpChunk chunk = (HttpChunk) e.getMessage(); 

92.             if (chunk.isLast()) { 

93.                 readingChunks = false; 

94.                 buf.append("END OF CONTENT\r\n"); 

95.   

96.                 HttpChunkTrailer trailer = (HttpChunkTrailer) chunk; 

97.                 if (!trailer.getHeaderNames().isEmpty()) { 

98.                     buf.append("\r\n"); 

99.                     for (String name: trailer.getHeaderNames()) { 

100.                         for (String value: trailer.getHeaders(name)) { 

101.                             buf.append("TRAILING HEADER: " + name + " = " + value + "\r\n"); 

102.                         } 

103.                     } 

104.                     buf.append("\r\n"); 

105.                 } 

106.   

107.                 writeResponse(e); 

108.             } else { 

109.                 buf.append("CHUNK: " + chunk.getContent().toString(CharsetUtil.UTF_8) + "\r\n"); 

110.             } 

111.         } 

112.     } 

113.   

114.     private void writeResponse(MessageEvent e) { 

115.         // Decide whether to close the connection or not. 

116.         boolean keepAlive = isKeepAlive(request); 

117.   

118.         // Build the response object. 

119.         HttpResponse response = new DefaultHttpResponse(HTTP_1_1, OK); 

120.         response.setContent(ChannelBuffers.copiedBuffer(buf.toString(), CharsetUtil.UTF_8)); 

121.         response.setHeader(CONTENT_TYPE, "text/plain; charset=UTF-8"); 

122.   

123.         if (keepAlive) { 

124.             // Add 'Content-Length' header only for a keep-alive connection. 

125.             response.setHeader(CONTENT_LENGTH, response.getContent().readableBytes()); 

126.         } 

127.   

128.         // Encode the cookie. 

129.         String cookieString = request.getHeader(COOKIE); 

130.         if (cookieString != null) { 

131.             CookieDecoder cookieDecoder = new CookieDecoder(); 

132.             Set<Cookie> cookies = cookieDecoder.decode(cookieString); 

133.             if(!cookies.isEmpty()) { 

134.                 // Reset the cookies if necessary. 

135.                 CookieEncoder cookieEncoder = new CookieEncoder(true); 

136.                 for (Cookie cookie : cookies) { 

137.                     cookieEncoder.addCookie(cookie); 

138.                 } 

139.                 response.addHeader(SET_COOKIE, cookieEncoder.encode()); 

140.             } 

141.         } 

142.   

143.         // Write the response. 

144.         ChannelFuture future = e.getChannel().write(response); 

145.   

146.         // Close the non-keep-alive connection after the write operation is done. 

147.         if (!keepAlive) { 

148.             future.addListener(ChannelFutureListener.CLOSE); 

149.         } 

150.     } 

151.   

152.     private void send100Continue(MessageEvent e) { 

153.         HttpResponse response = new DefaultHttpResponse(HTTP_1_1, CONTINUE); 

154.         e.getChannel().write(response); 

155.     } 

156.   

157.     @Override 

158.     public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) 

159.             throws Exception { 

160.         e.getCause().printStackTrace(); 

161.         e.getChannel().close(); 

162.     } 

163. }

 

1.package org.jboss.netty.example.http.snoop; 

2. 

3.import java.sql.Connection; 

4.import java.sql.PreparedStatement; 

5.import java.sql.ResultSet; 

6.import java.sql.SQLException; 

7.import java.sql.Statement; 

8. 

9.import org.apache.commons.dbcp.BasicDataSource; 

10. 

11./** 

12. * 连接和使用数据库资源的工具类 

13. * 

14. * @author yifangyou 

15. * @version gtm 2010-09-27 

16. */ 

17.public class DatabaseUtil { 

18. 

19.    /** 

20.     * 数据源 

21.     */ 

22.    private BasicDataSource dataSource; 

23.      

24.    /** 

25.     * 数据库连接 

26.     */ 

27.    public Connection conn; 

28. 

29.    /** 

30.     * 获取数据源 

31.     * @return 数据源 

32.     */ 

33.    public BasicDataSource getDataSource() { 

34.        return dataSource; 

35.    } 

36. 

37.    /** 

38.     * 设置数据源 

39.     * @param dataSource 数据源 

40.     */ 

41.    public void setDataSource(BasicDataSource dataSource) { 

42.        this.dataSource = dataSource; 

43.    } 

44.      

45.      

46.    /** 

47.     * 获取数据库连接 

48.     * @return conn 

49.     */ 

50.    public Connection getConnection() { 

51.        try { 

52.            conn = dataSource.getConnection(); 

53.        } catch (Exception e) { 

54.            e.printStackTrace(); 

55.            return null; 

56.        } 

57.        return conn; 

58.    } 

59.      

60.    /** 

61.     * 关闭数据库连接 

62.     * @param conn 

63.     */ 

64.    public void closeConnection(Connection conn) { 

65.        if (null != conn) { 

66.            try { 

67.                conn.close(); 

68.                conn = null; 

69.            } catch (SQLException e) { 

70.                e.printStackTrace(); 

71.            } 

72.        } 

73.    } 

74. 

75.      

76.      

77.    /** 

78.     * 获取执行SQL的工具 

79.     * @param conn 数据库连接 

80.     * @param sql SQL语句 

81.     * @return prepStmt 

82.     */ 

83.    public PreparedStatement getPrepStatement(Connection conn, String sql) { 

84.        PreparedStatement prepStmt = null; 

85.        try { 

86.            prepStmt = conn.prepareStatement(sql); 

87.        } catch (SQLException e) { 

88.            e.printStackTrace(); 

89.        } 

90.        return prepStmt; 

91.    } 

92.      

93.      

94.    /** 

95.     * 关闭数据库资源 

96.     * @param prepStmt 

97.     */ 

98.    public void closePrepStatement(PreparedStatement prepStmt) { 

99.        if (null != prepStmt) { 

100.            try { 

101.                prepStmt.close(); 

102.                prepStmt = null; 

103.            } catch (SQLException e) { 

104.                e.printStackTrace(); 

105.            } 

106.        } 

107.    } 

108. 

109.}

 

2.2 导入jar包
在工程下添加lib目录
把jar包拷进去
 
点击工程的右键“propertis”->Java Build Path->Libraries->Add JARS
3.分析如何注入
Netty的运行过程是
因此我们需要
Spring注入入口在HttpServer里的main函数
把HttpRequestHandler注入到HttpServerPipelineFactory，
把HttpServerPipelineFactory注入到HttpServer
另外我们在HttpRequestHandler需要用到mysql连接池，因此还要把mysql连接池注入到HttpRequestHandler

 

分享到：
| hibernate优化
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    netty4与spring集成

    Spring 是一个广泛使用的 Java 应用开发框架，尤其在企业级应用中非常流行，它提供了依赖注入、面向切面编程等功能，简化了Java应用的开发。将 Netty 与 Spring 集成，可以利用 Netty 的高性能网络通信能力，同时...

    JAVA版基于netty的物联网高并发智能网关.zip

    JAVA版基于netty的物联网高并发智能网关 JAVA版基于netty的物联网高并发智能网关 JAVA版基于netty的物联网高并发智能网关 JAVA版基于netty的物联网高并发智能网关 JAVA版基于netty的物联网高并发智能网关 JAVA...

    netty-spring-mvc-master.rar_netty_netty spring_netty4 spring_s

    本文将深入探讨如何在Netty中集成Spring MVC，并实现MySQL数据库连接池的注入，以构建一个完整的网络应用服务。 首先，我们要理解Netty的基本原理。Netty是一个基于NIO的客户机/服务器通信框架，它提供了一组高度可...

    Spring+Netty+WebSocket实例

    首先，Spring框架是Java领域最流行的后端开发框架之一，它提供了丰富的功能和强大的依赖注入机制。在WebSocket方面，Spring提供了一个名为`Spring Websocket`的模块，使得开发者可以方便地在Spring应用中集成...

    Netty+Spring Boot仿微信 全栈开发高性能后台及客户端

    综上所述，"Netty+Spring Boot仿微信 全栈开发高性能后台及客户端"项目是一个综合性的学习和实践平台，涵盖了网络编程、后端开发、全栈集成以及性能优化等多个领域。通过这个项目，开发者不仅可以提升自己的技术能力...

    Java编程方法论 之 Spring Reactor Reactor-Netty Spring Webflux 全面解读.pdf

    Java编程方法论中，Spring Reactor、Reactor-Netty和Spring Webflux是现代Java开发中用于构建反应式应用程序的关键组件。Spring Reactor是响应式流（Reactive Streams）规范的实现，它提供了用于处理异步事件和数据...

    基于Java的netty-mqtt MQTT 3.1.1协议服务端与客户端设计源码

    netty-mqtt是一个基于Java开发的MQTT 3.1.1协议服务端与客户端，包含113个文件，其中包括87个Java源文件、8个XML文件、7个Iml文件、3个YAML文件、3个JKS文件、2个Factories文件、1个LICENSE文件和1个Markdown文件。...

    netty和spring结合

    Netty和Spring是两个在Java开发领域非常重要的框架。Netty是一个高性能、异步事件驱动的网络应用程序框架，常用于创建高并发、低延迟的网络服务，如TCP、UDP等协议的应用。Spring则是一个全面的企业级应用开发框架，...

    spring-netty.zip

    Spring Netty项目是一个整合了Netty 4和Spring 5框架的应用示例，它展示了如何在Netty服务器中使用Spring的特性，特别是针对UDP通信、MyBatis持久化以及通过Netty Handler访问Spring Bean来实现数据库操作。...

    springboot整合netty的demo

    SpringBoot以其快速、简洁的特性，极大地简化了Spring应用的初始搭建以及开发过程，而Netty则是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。 SpringBoot整合Netty...

    c++客户端和java（Netty）服务器端tcp通讯

    在Java端，Netty是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。利用Netty，我们可以轻松实现TCP服务器，创建ServerBootstrap，配置通道处理器pipeline，监听客户端...

    spring boot 整合的netty 实现的socket的服务端和客户端

    Spring Boot 是一个流行的Java开发框架，它简化了创建独立、生产级别的基于Spring的应用程序的流程。Netty 是一个高性能、异步事件驱动的网络应用程序框架，用于快速开发可维护的高性能协议服务器和客户端。整合...

    1078解析推流源代码(netty+javacv+spring+maven+rtp+rtmp)

    Spring 是一个广泛使用的Java企业级应用开发框架，提供依赖注入、面向切面编程等功能。在这个项目中，Spring 可能被用来管理服务组件，如网络监听器（基于Netty）、视频处理逻辑（使用JavaCV）以及与RTMP服务器的...

    spring+netty+mybatis整合实例

    Spring是一个全面的Java应用框架，提供强大的依赖注入、AOP（面向切面编程）以及丰富的功能模块；Netty则是一个高性能、异步事件驱动的网络应用程序框架，常用于构建高并发、低延迟的网络服务；MyBatis是一个持久层...

    iot-ucy是使用java语言且基于netty, spring boot, redis等开源项目开发来的物联网网络中间件

    iot-ucy是基于netty, spring boot等框架实现的物联网中间件, 已支持tcp、udp、mqtt、mqtt网关、websocket、modbus、dtu适配(AT协议)、dtu+modbus(tcp和rtu) 适配，plc (西门子, 欧姆龙),串口等常用物联网协议，并且...

    java实现基于netty 的udp字节数据接收服务

    在Java编程环境中，Netty是一个高性能、异步事件驱动的网络应用程序框架，常用于构建可伸缩、高并发的服务器。本示例关注的是如何利用Netty实现一个基于UDP（User Datagram Protocol）的数据接收服务，这在需要进行...

    基于java的springboot和dubbo、netty的集成模板

    通过以上步骤，我们可以构建出一个强大的基于Java的后端服务架构，集成了Spring Boot的易用性、Dubbo的分布式服务治理和Netty的高性能网络通信能力。这种架构适用于大型、复杂的企业级应用，能够提供高效、稳定的...

    用nio实现异步连接池

    在现代Web应用程序开发中，为了提升系统性能和响应速度，常连接与连接池技术成为不可或缺的一部分。常连接是指一个持久存在的TCP连接，避免了频繁创建和销毁连接带来的系统资源消耗和性能损耗。然而，当应用需要与多...

    基于Java开发的一款基于Netty的内网穿透工具，主要用于将内网服务反向代理到公网访问.zip

    标题中的“基于Java开发的一款基于Netty的内网穿透工具”揭示了我们正在讨论的是一个使用Java编程语言，并且依赖于Netty框架的软件应用。Netty是一个高性能、异步事件驱动的网络应用程序框架，常用于开发服务器和...

Magicbox
Global site tag (gtag.js) - Google Analytics