java netty httpreq_netty实现http api功能

无可致疑，netty是java的网络通讯框架，支持高并发。本文扫描使用netty完成简单的http的能力，不涉及安全，业务过滤等内容。

片段1

/**

* 启动http服务器

* @throws InterruptedException

*/

private void runHttpServer(final EventProducer evtProducer) throws InterruptedException {

// 配置TCP服务器.

EventLoopGroup bossGroup = new NioEventLoopGroup(ServerBootOption.Parent_EventLoopGroup_ThreadNum);

EventLoopGroup workerGroup = new NioEventLoopGroup(ServerBootOption.Child_EventLoopGroup_ThreadNum);

try {

ServerBootstrap b = new ServerBootstrap();

b.group(bossGroup, workerGroup)

.channel(NioServerSocketChannel.class)

.option(ChannelOption.SO_BACKLOG, 10240)

.option(ChannelOption.TCP_NODELAY, true)

.option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 10000)

.option(ChannelOption.SO_REUSEADDR, true)

.option(ChannelOption.SO_KEEPALIVE, true)

.option(ChannelOption.SO_LINGER, 0)

//.childOption(ChannelOption.SO_TIMEOUT, ServerBootOption.SO_TIMEOUT)

// .handler(new LoggingHandler(LogLevel.INFO))

.childHandler(new ChannelInitializer(){

@Override

protected void initChannel(SocketChannel ch) throws Exception {

ChannelPipeline p = ch.pipeline();

p.addLast("idleStateHandler", new IdleStateHandler(60, 60, 30));//读信道空闲60s,写信道空闲60s,读，写信道空闲30s

p.addLast("http_server_codec", new HttpServerCodec());//http消息转换

p.addLast("http_server_handler",new HttpProxyServerHandler(manager,evtProducer));//消息处理器

}

});

// Start the tcp server.

ChannelFuture f = b.bind(new InetSocketAddress(ip, port)).sync();//启动http服务进程

logger.info("start http server ok");

// Wait until the server socket is closed.

f.channel().closeFuture().sync();

} finally {

// Shut down all event loops to terminate all threads.

logger.info("Shut down all event loops to terminate all threads.");

bossGroup.shutdownGracefully();//关闭服务进程

workerGroup.shutdownGracefully();//关闭服务进程

}

}片段2HttpProxyServerHandler

/**

*

* @author

* http 请求事件处理器，负责分发http请求事件

*/

public class HttpProxyServerHandler extends ChannelHandlerAdapter{

private static final Logger logger = Logger.getLogger(HttpProxyServerHandler.class);

private SessionContextManager manager;//会话管理

private final AttributeKey timestamp = AttributeKey.valueOf("timestamp");

private final StringBuilder buf = new StringBuilder();

public HttpProxyServerHandler(SessionContextManager manager){

this.manager=manager;

}

@Override

public void handlerAdded(final ChannelHandlerContext ctx)

throws Exception{

logger.info("["+ctx.channel().id().asLongText()+" ] is Added ");

}

@Override 会话关闭，失效事件

public void channelInactive(ChannelHandlerContext ctx) throws Exception {

manager.getSession().remove(ctx.channel().id().asLongText());

super.channelInactive(ctx);

}

@Override 读消息事件,业务处理的入口

public void channelRead(final ChannelHandlerContext ctx, Object msg) throws Exception {

logger.info("HttpProxyServerHandler[channelRead] ");

Attribute attr_timestamp = ctx.channel().attr(timestamp);

attr_timestamp.set(System.currentTimeMillis());//测试信道中保存状态消息，如消息处理的开如时间

SessionContext sctx=new SessionContext();

sctx.setCtx(ctx);

sctx.setChannelId(ctx.channel().id());

sctx.setSessionActiveTime(""+System.currentTimeMillis());

manager.getSession().put(sctx.getChannelId().asLongText(), sctx);//manager.getSession() 为并发Map结构,用于会话保持

logger.info(sctx.getChannelId().asLongText()+" req time "+System.currentTimeMillis());

try {

dispatchMeesage(ctx,manager ,msg);

} finally {

ReferenceCountUtil.release(msg);

}

}

private QueryStringDecoder qdecoder = null;

private String uri="";//http uri

private String url="";//http url

private Map> httpReqParams=null;//http请求参数

/**

* 消息分发

* @param ctx

* @param manager

* @param msg 消息

* @return

* @throws Exception

*/

private String dispatchMeesage(final ChannelHandlerContext ctx,

final SessionContextManager manager, final Object msg)

throws Exception{

String decode_message = "";

HttpResponseUtils util = new HttpResponseUtils();

String result_code="1";

if (msg instanceof HttpRequest) {// http请求头

HttpRequest req = (HttpRequest) msg;

url = req.getUri();

if (url.equals("/favicon.ico")) {

ctx.close();

return "0";

}

if(!url.equals("/billing")){

ctx.close();

return "0";

}

//if (is100ContinueExpected(req)) {

// ctx.write(new DefaultFullHttpResponse(HTTP_1_1, CONTINUE));

// }

qdecoder = new QueryStringDecoder(url);

httpReqParams = qdecoder.parameters();

uri = qdecoder.path();

/* TODO：身份认证

* if(qdecoder.parameters().containsKey("crendial")){

* crendial=(String

* )qdecoder.parameters().get("crendial").get(0).toUpperCase(); }

*/

} else if (msg instanceof HttpContent) { // http请求体

HttpContent httpContent = (HttpContent) msg;

ByteBuf content = httpContent.content();

if (content.isReadable()) {

String chunk_message=content.toString(CharsetUtil.UTF_8);

buf.append(chunk_message);

}

if (!(msg instanceof LastHttpContent)) {//不是最后一个chunk包块，此项非常 重要，当http分多片传输时，需要将多块内容合并

return "0";

}else{

decode_message= buf.toString(); //

logger.info(decode_message);

}

if (msg instanceof LastHttpContent) {

//LastHttpContent trailer = (LastHttpContent) msg;

String sessionId=ctx.channel().id().asLongText();

System.out.println("请求"+decode_message);

System.out.println("请求参数"+httpReqParams);

System.out.println("请求地址"+uri);

System.out.println("会话Id"+sessionId);

//TODO：模拟发送请求消息给后端处理,可以放入消息队列，ctx对象进入会话保持(Map对象)中，等消息队列中处理完成后，恢复会话，并完成消息应答。

}

}

return result_code;

}

private static AtomicInteger counter = new AtomicInteger(0);

@Override

public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {

manager.getSession().remove(ctx.channel().id().asLongText());

cause.printStackTrace();

ctx.close();

}

@Override

public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {

logger.error("HttpProxyServerHandler[userEventTriggered] ");

if (evt instanceof IdleStateEvent) {

IdleStateEvent e = (IdleStateEvent) evt;

if (e.state() == IdleState.ALL_IDLE) {

logger.error("ALL_IDLE");

} else if (e.state() == IdleState.READER_IDLE){

logger.error("READER_IDLE");

}else if (e.state() == IdleState.WRITER_IDLE){

logger.error("WRITER_IDLE");

}

ctx.close();

}else if(evt instanceof ErrorEvent){

logger.error(((ErrorEvent) evt).getErrorCode());

ctx.close();

}

}

}

SessionContext

import io.netty.channel.ChannelHandlerContext;

import io.netty.channel.ChannelId;

/**

* http请求会话

* @author wanghao

*

*/

public class SessionContext {

private ChannelId channelId =null ;/**会话 channel ID*/

private ChannelHandlerContext ctx;/**会话*/

private String sessionActiveTime;/**会话创建时间*/

private String sessionUnActiveTime;/**会话失效时间*/

public String getSessionActiveTime() {

return sessionActiveTime;

}

public void setSessionActiveTime(String sessionActiveTime) {

this.sessionActiveTime = sessionActiveTime;

}

public String getSessionUnActiveTime() {

return sessionUnActiveTime;

}

public void setSessionunActiveTime(String sessionUnActiveTime) {

this.sessionUnActiveTime = sessionUnActiveTime;

}

public ChannelHandlerContext getCtx() {

return ctx;

}

public void setCtx(ChannelHandlerContext ctx) {

this.ctx = ctx;

}

public ChannelId getChannelId() {

return channelId;

}

public void setChannelId(ChannelId channelId) {

this.channelId = channelId;

}

}

http请求会话管理器

import java.util.Map;

/**

* http请求会话管理器

* @author

*

*/

public interface SessionContextManager {

abstract Map getSession();

}