netty实现javaweb服务器（JavaNetty实现HTTP代理服务器）

普通代理（Http）

Http，RFC 7230中描述为普通代理，其代理扮演的是“中间人”角色，对于连接到它的客户端来说，它是服务端，对于要连接的服务端来说，它是客户端，代理服务器负责在两端之间来回传送HTTP报文。

隧道代理（Https）

Https，代理服务器是一个web服务器，影响了客户端和服务器的TLS加密连接的。此时主要使用RFC中定义的通过 Web 代理服务器用隧道方式传输基于 TCP 的协议的隧道代理方式，它的主要流程为：

1、浏览器首先发送Http Connect请求给代理服务器，发送目标主机信息。

2、代理服务器建立和目标主机的tcp链接，并向浏览器回应Connection Established应答。

3、浏览器将请求发送给代理服务器，代理服务器透传给目标主机。

4、目标主机将响应回给代理服务器，代理服务器将响应回给浏览器。

Netty实现

Netty高性能网络框架，支持OIO（阻塞式传输）/NIO（非阻塞式传输）等能力，同时屏蔽了网络底层现，使开发人员专注于应用逻辑开发。

Netty框架中大量运用了直接内存用来提高效率，编写代码时要注意及时释放资源,避免内存泄漏问题。

<dependency> <groupId>org.bouncycastle</groupId> <artifactId>bcprov-jdk15to18</artifactId> <version>1.70</version> </dependency> <dependency> <groupId>org.bouncycastle</groupId> <artifactId>bcpkix-jdk15to18</artifactId> <version>1.70</version> </dependency> <!-- netty-all --> <dependency> <groupId>io.netty</groupId> <artifactId>netty-all</artifactId> <version>4.1.60.Final</version> </dependency>

package com.what21.netty03.demo01; import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.*; import io.netty.channel.nio.NioEventLoopGroup; import io.netty.channel.socket.nio.NioServerSocketChannel; import io.netty.handler.logging.LogLevel; import io.netty.handler.logging.LoggingHandler; import java.net.InetSocketAddress; public class HttpServer { private String serverName; private String bindHost; private int bindPort; public HttpServer(String serverName, String bindHost, int bindPort) { this.serverName = serverName; this.bindHost = bindHost; this.bindPort = bindPort; } public void start() throws Exception { // 用于Acceptor的主"线程池" EventLoopGroup bossEventGroup = new NioEventLoopGroup(); // 初始化==>用于I/O工作的从"线程池" EventLoopGroup workerEventGroup = new NioEventLoopGroup(); try { ServerBootstrap serverBootstrap = new ServerBootstrap(); // group方法设置主从线程池 serverBootstrap.group(bossEventGroup, workerEventGroup); // 指定通道channel类型，服务端为：NioServerSocketChannel serverBootstrap.channel(NioServerSocketChannel.class); serverBootstrap.option(ChannelOption.SO_BACKLOG, 1024); serverBootstrap.childOption(ChannelOption.TCP_NODELAY, true); serverBootstrap.handler(new LoggingHandler(LogLevel.INFO)); serverBootstrap.childHandler(new HttpServerInitializer()); ChannelFuture bindFuture = null; if ("0.0.0.0".equalsIgnoreCase(this.bindHost)) { bindFuture = serverBootstrap.bind(this.bindPort).sync(); } else { InetSocketAddress bindAddress = new InetSocketAddress(this.bindHost, this.bindPort); bindFuture = serverBootstrap.bind(bindAddress).sync(); } Channel parentChannel = bindFuture.channel(); bindFuture.addListener(new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture channelFuture) throws Exception { if (channelFuture.isSuccess()) { System.out.println(HttpServer.this.serverName "，绑定监听成功," channelFuture.channel().localAddress()); } else { System.err.println(HttpServer.this.serverName "，绑定监听失败!" channelFuture.cause()); } } }); ChannelFuture closeFuture = bindFuture.channel().closeFuture().sync(); closeFuture.addListener(new ChannelFutureListener() { @Override public void operationComplete(ChannelFuture channelFuture) throws Exception { if (channelFuture.isSuccess()) { System.out.println(HttpServer.this.serverName "，停止监听成功," channelFuture.channel().localAddress()); } else { System.err.println(HttpServer.this.serverName "，停止监听失败!" channelFuture.cause()); } } }); } catch (Exception e) { e.printStackTrace(); } finally { // 优雅退出，释放"线程池" if (bossEventGroup != null) { bossEventGroup.shutdownGracefully(); } if (workerEventGroup != null) { workerEventGroup.shutdownGracefully(); } } } public static void main(String[] args) { try { new HttpServer("HTTP代理服务器", "0.0.0.0", 8888).start(); } catch (Exception e) { e.printStackTrace(); } } }

package com.what21.netty03.demo01; import io.netty.channel.Channel; import io.netty.channel.ChannelInitializer; import io.netty.handler.codec.http.HttpObjectAggregator; import io.netty.handler.codec.http.HttpServerCodec; import io.netty.handler.ipfilter.IpFilterRule; import io.netty.handler.ipfilter.IpFilterRuleType; import io.netty.handler.ipfilter.IpSubnetFilterRule; import io.netty.handler.ipfilter.RuleBasedIpFilter; import java.net.InetSocketAddress; public class HttpServerInitializer extends ChannelInitializer<Channel> { @Override protected void initChannel(Channel ch) throws Exception { IpSubnetFilterRule rule1 = new IpSubnetFilterRule("192.168.119.1", 24, IpFilterRuleType.ACCEPT); IpSubnetFilterRule rule2 = new IpSubnetFilterRule("127.0.0.1", 32, IpFilterRuleType.REJECT); IpFilterRule rejectAll = new IpFilterRule() { @Override public boolean matches(InetSocketAddress remoteAddress) { return true; } @Override public IpFilterRuleType ruleType() { return IpFilterRuleType.REJECT; } }; RuleBasedIpFilter filter = new RuleBasedIpFilter(rule1, rejectAll); ch.pipeline().addLast("ipFilter", filter); ch.pipeline().addLast("httpServerCodec", new HttpServerCodec()); ch.pipeline().addLast("httpObjectAggregator", new HttpObjectAggregator(65536)); ch.pipeline().addLast("httpProxyServerHandler", new HttpProxyServerHandler()); } }

package com.what21.netty03.demo01; import io.netty.bootstrap.Bootstrap; import io.netty.channel.*; import io.netty.handler.codec.http.*; public class HttpProxyServerHandler extends ChannelInboundHandlerAdapter { private ChannelFuture cf; private String host; private int port; @Override public void channelRead(final ChannelHandlerContext ctx, final Object msg) throws Exception { if (msg instanceof FullHttpRequest) { FullHttpRequest request = (FullHttpRequest) msg; String host = request.headers().get("Host"); String[] temp = host.split(":"); int port = 80; if (temp.length > 1) { port = Integer.parseInt(temp[1]); } else { if (request.uri().indexOf("https") == 0) { port = 443; } } this.host = temp[0]; this.port = port; String authorization = request.headers().get("Authorization"); System.out.println("http basic认证信息：" authorization); if ("CONNECT".equalsIgnoreCase(request.method().name())) { // HTTPS建立代理握手 HttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK); ctx.writeAndFlush(response); ctx.pipeline().remove("httpServerCodec"); ctx.pipeline().remove("httpObjectAggregator"); return; } //连接至目标服务器 Bootstrap bootstrap = new Bootstrap(); bootstrap.group(ctx.channel().eventLoop()) // 注册线程池 .channel(ctx.channel().getClass()) // 使用NioSocketChannel来作为连接用的channel类 .handler(new HttpProxyInitializer(ctx.channel())); ChannelFuture cf = bootstrap.connect(temp[0], port); cf.addListener(new ChannelFutureListener() { public void operationComplete(ChannelFuture future) throws Exception { if (future.isSuccess()) { future.channel().writeAndFlush(msg); } else { ctx.channel().close(); } } }); // ChannelFuture cf = bootstrap.connect(temp[0], port).sync(); // cf.channel().writeAndFlush(request); } else { // https 只转发数据，不做处理 if (cf == null) { //连接至目标服务器 Bootstrap bootstrap = new Bootstrap(); bootstrap.group(ctx.channel().eventLoop()) // 复用客户端连接线程池 .channel(ctx.channel().getClass()) // 使用NioSocketChannel来作为连接用的channel类 .handler(new ChannelInitializer() { @Override protected void initChannel(Channel ch) throws Exception { ch.pipeline().addLast(new ChannelInboundHandlerAdapter() { @Override public void channelRead(ChannelHandlerContext ctx0, Object msg) throws Exception { ctx.channel().writeAndFlush(msg); } }); } }); cf = bootstrap.connect(host, port); cf.addListener(new ChannelFutureListener() { public void operationComplete(ChannelFuture future) throws Exception { if (future.isSuccess()) { future.channel().writeAndFlush(msg); } else { ctx.channel().close(); } } }); } else { cf.channel().writeAndFlush(msg); } } } }

package com.what21.netty03.demo01; import io.netty.channel.Channel; import io.netty.channel.ChannelInitializer; import io.netty.handler.codec.http.HttpClientCodec; import io.netty.handler.codec.http.HttpObjectAggregator; public class HttpProxyInitializer extends ChannelInitializer { private Channel clientChannel; public HttpProxyInitializer(Channel clientChannel) { this.clientChannel = clientChannel; } @Override protected void initChannel(Channel ch) throws Exception { ch.pipeline().addLast(new HttpClientCodec()); ch.pipeline().addLast(new HttpObjectAggregator(512 * 1024)); ch.pipeline().addLast(new HttpProxyClientHandler(clientChannel)); } }

package com.what21.netty03.demo01; import io.netty.channel.Channel; import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInboundHandlerAdapter; import io.netty.handler.codec.http.FullHttpResponse; public class HttpProxyClientHandler extends ChannelInboundHandlerAdapter { private Channel clientChannel; public HttpProxyClientHandler(Channel clientChannel) { this.clientChannel = clientChannel; } @Override public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception { FullHttpResponse response = (FullHttpResponse) msg; //修改http响应体返回至客户端 response.headers().add("response", "from proxy"); clientChannel.writeAndFlush(msg); } }