思路是使用executor来处理被分发的请求。
主类的代码：
package com.mytest.main;
import java.net.InetSocketAddress;
import java.util.HashMap;
import java.util.Map;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.mytest.executors.AbstractExecutor;
import com.mytest.executors.HelloExecutor;
import com.mytest.executors.TestExecutor;
import com.mytest.handles.Dispatcher;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.timeout.IdleStateHandler;
public class StartupDisPatchClass {
private static Logger logger = LoggerFactory.getLogger(StartupDisPatchClass.class);
private void launchServer() {
EventLoopGroup bossGroup = new NioEventLoopGroup(Runtime.getRuntime().availableProcessors()/2+1);
EventLoopGroup workerGroup = new NioEventLoopGroup(Runtime.getRuntime().availableProcessors()/2+1);
try {
//服务启动
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.childHandler(this.new ChildChannelHandler())
.option(ChannelOption.SO_BACKLOG, 1024)
.option(ChannelOption.SO_REUSEADDR, true)
.option(ChannelOption.SO_KEEPALIVE, true);
Channel ch = b.bind(new InetSocketAddress(9000)).sync().channel();
logger.info("httpserver started on port[" + 9000+ "]");
ch.closeFuture().sync();
} catch (InterruptedException e) {
logger.error(e.getMessage(),e);
} finally {
//服务关闭
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
public static void main(String [] args) throws InterruptedException {
new StartupDisPatchClass().launchServer();
}
class ChildChannelHandler extends ChannelInitializer<SocketChannel> {
@Override
protected void initChannel(SocketChannel arg0) throws Exception {
logger.info("server initChannel..");
ChannelPipeline p = arg0.pipeline();
//监控线程空闲事件
p.addLast("idleStateHandler", new IdleStateHandler(60, 60, 30));
//将httprequest和httpresponse处理合并成一个
p.addLast("ServiceDecoder", new HttpServerCodec());
//控制http消息的组合，参数表示支持的内容最大长度
p.addLast("httpAggregator",new HttpObjectAggregator(1024));
Dispatcher dispatcher = new Dispatcher();
Map<String, Class<? extends AbstractExecutor>> apiMappings = new HashMap<String, Class<? extends AbstractExecutor>>();
apiMappings.put("hello", HelloExecutor.class);
apiMappings.put("test", TestExecutor.class);
dispatcher.setApiMappings(apiMappings);
p.addLast("dispatcher",dispatcher);
}
}
}
分发器的代码：
package com.mytest.handles;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import com.mytest.executors.AbstractExecutor;
import com.mytest.executors.DefaultExecutor;
import com.mytest.utils.UrlUtil;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.handler.codec.http.FullHttpRequest;
public class Dispatcher extends ChannelInboundHandlerAdapter {
private Map<String,Class<? extends AbstractExecutor>> apiMappings = new HashMap<String,Class<? extends AbstractExecutor>>();
public Map<String, Class<? extends AbstractExecutor>> getApiMappings() {
return apiMappings;
}
public void setApiMappings(Map<String, Class<? extends AbstractExecutor>> apiMappings) {
this.apiMappings = apiMappings;
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
if (msg instanceof FullHttpRequest) {
FullHttpRequest request = (FullHttpRequest) msg;
String url = request.getUri();
System.out.println(url);
ExecutorService executorService = Executors.newFixedThreadPool(10);
String apiName = UrlUtil.getApiName(url);
AbstractExecutor executor = null;
if (this.apiMappings.containsKey(apiName)) {
//实现了分发
executor = this.apiMappings.get(apiName).newInstance();
}else{
//默认处理逻辑
executor = new DefaultExecutor();
}
executor.setCtx(ctx);
executor.setMsg(request);
executorService.submit(executor);
}
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
}
}
excutor抽象类
package com.mytest.executors;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.FullHttpResponse;
public abstract class AbstractExecutor extends Thread {
protected String apiName;
protected ChannelHandlerContext ctx;
protected FullHttpRequest msg;
protected FullHttpResponse response;
public ChannelHandlerContext getCtx() {
return ctx;
}
public void setCtx(ChannelHandlerContext ctx) {
this.ctx = ctx;
}
public FullHttpRequest getMsg() {
return msg;
}
public void setMsg(FullHttpRequest msg) {
this.msg = msg;
}
public FullHttpResponse getResponse() {
return response;
}
public void setResponse(FullHttpResponse response) {
this.response = response;
}
public String getApiName() {
return apiName;
}
public void setApiName(String apiName) {
this.apiName = apiName;
}
public abstract boolean preWork();
public abstract boolean doWork();
public abstract boolean postWork();
public final void run() {
boolean flag = this.preWork();
if (flag==true) {
this.doWork();
}
if (flag== true) {
this.postWork();
}
if (this.msg!= null) {
System.out.println("From " + this.getApiName() + " executor\t" + msg.getUri());
}
this.ctx.writeAndFlush(this.getResponse());
this.ctx.close();
}
}
抽象类的一个子类：默认处理单元
package com.mytest.executors;
import io.netty.buffer.Unpooled;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpResponse;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpVersion;
import io.netty.util.CharsetUtil;
public class DefaultExecutor extends AbstractExecutor {
@Override
public boolean preWork() {
return true;
}
@Override
public boolean doWork() {
String content = "{\"e\":0,\"api\":\"default\"}";
FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK, Unpooled.copiedBuffer(content.toCharArray(), CharsetUtil.UTF_8));
this.setApiName("default");
this.setResponse(response);
return true;
}
@Override
public boolean postWork() {
return true;
}
}
还有一个处理url的工具类：
package com.mytest.utils;
public class UrlUtil {
public static String getApiName(String url){
String result = "";
try {
int i = url.lastIndexOf("/");
String substr = url.substring(i+1);
int end = substr.indexOf("?");
if (end >0) {
result = substr.substring(0,substr.indexOf("?"));
}else {
result = substr.substring(0);
}
} catch (Exception e) {
e.printStackTrace();
}
return result;
}
public static void main(String [] args ) {
String url="/hello?uid=1";
System.out.println(UrlUtil.getApiName(url));
url = "/hello1";
System.out.println(UrlUtil.getApiName(url));
}
}
大概是这样。如果需要引入spring的话，还需要自己动动脑筋。以上代码，仅仅是抛砖引玉。