netty搭建游戏服务器
Ⅰ 如何构建一个基于netty的后端服务器
统一继承ClientRequestModel，经过编码统一转化为domainMessage，交由disruptor来处理，其实oop里什么继承，实现，封装思想，大部分都在围绕一个东西在走，一句话，把看似各有棱角的东西如何转化为共同的东西，求同存异啊
Ⅱ 如何构建一个基于netty的后端服务器
最近在研究Netty来构建SOA架构，其中也包括了前端接入的HTTP/WebSocket方面的接入响应，而WebSocket方面的接入响应对于移动端的消息推送研发至关重要，这里就将在这块研发时的异步socket响应服务例子程序笔记记录下来，系统总共分为4个处理类，即：
HttpRequestHandler -- HTTP请求处理类
TextWebSocketFrameHandler -- 对应Text消息的处理类
WebSocketServer -- 系统主类
WebSocketServerInitializer -- 服务主程序的初始化类
WebSocketServer 类代码：
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
public final class WebSocketServer {
private int port = 0;
public WebSocketServer(int port) {
this.port = port;
}
public void run() throws Exception {
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.childHandler(new WebSocketServerInitializer())
.option(ChannelOption.SO_BACKLOG, 128)
.childOption(ChannelOption.SO_KEEPALIVE, true);
System.out.println("WebsocketChatServer 启动了");
// 绑定端口，开始接收进来的连接
ChannelFuture f = b.bind(port).sync();
// 等待服务器 socket 关闭 。在这个例子中，这不会发生，但你可以优雅地关闭你的服务器。
f.channel().closeFuture().sync();
} finally {
workerGroup.shutdownGracefully();
bossGroup.shutdownGracefully();
System.out.println("WebsocketChatServer 关闭了");
}
}
Ⅲ 如何构建一个基于netty的后端服务器
HttpRequestHandler -- HTTP请求处理类
TextWebSocketFrameHandler -- 对应Text消息的处理类
WebSocketServer -- 系统主类
WebSocketServerInitializer -- 服务主程序的初始化类
WebSocketServer 类代码：
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
public final class WebSocketServer {
private int port = 0;
public WebSocketServer(int port) {
this.port = port;
}
public void run() throws Exception {
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.childHandler(new WebSocketServerInitializer())
.option(ChannelOption.SO_BACKLOG, 128)
.childOption(ChannelOption.SO_KEEPALIVE, true);
System.out.println("WebsocketChatServer 启动了");
// 绑定端口，开始接收进来的连接
ChannelFuture f = b.bind(port).sync();
// 等待服务器 socket 关闭 。在这个例子中，这不会发生，但你可以优雅地关闭你的服务器。
f.channel().closeFuture().sync();
} finally {
workerGroup.shutdownGracefully();
bossGroup.shutdownGracefully();
System.out.println("WebsocketChatServer 关闭了");
}
}
Ⅳ 基于Netty开发的游戏服务器，是如何做到分布式管理呢
看你是什么游戏了，不同的游戏其服务器分布式的实现方式也不相同。
Ⅳ netty框架做游戏服务器怎么样
如果你指的是单机的话，不说Netty会怎么样，服务器都有可能直接崩溃掉，你的算一下，按平均每链接传输数据1K，100W链接大概数据量会在1G左右，G级服务器网卡也受不了的，我们在网络编程中对单机来讲，成功解决了C10K的问题，这种M级别的链接，可能暂时解决不了。对于如此大的并发，一般我们都是通过负载均衡的方式进行处理，如新浪微博，同时在线100W以上，通过约100多个节点处理，每个节点也就才10000并发左右。
Ⅵ 如何构建一个基于netty的后端服务器
xml工具采用xstram来处理，两个字，方便。
json工具采用jackson\不知道和业界出名的fastjson\gson\sf.json有何区别，待鉴定。
客户端的请求，统一继承ClientRequestModel，经过编码统一转化为domainMessage，交由disruptor来处理，其实oop里什么继承，实现，封装思想，大部分都在围绕一个东西在走，一句话，把看似各有棱角的东西如何转化为共同的东西，求同存异啊（比如，水，石头，空气等，如果在这一层，我们没法统一用一个特征来表示，我们可以先把它转化为分子，那是不是可以用同一个东西来表示呢？如何高度抽象封装，这真是一门艺术）。
Ⅶ 如何构建一个基于netty的后端服务器
public class HttpServerPipelineFactory implements ChannelPipelineFactory {
private ChannelUpstreamHandler channelUpstreamHandler;
public ChannelPipeline getPipeline() throws Exception {
// Create a default pipeline implementation.
ChannelPipeline pipeline = pipeline();
// Uncomment the following line if you want HTTPS
//SSLEngine engine = SecureChatSslContextFactory.getServerContext().createSSLEngine();
//engine.setUseClientMode(false);
//pipeline.addLast("ssl", new SslHandler(engine));
pipeline.addLast("decoder", new HttpRequestDecoder());
// Uncomment the following line if you don't want to handle HttpChunks.
pipeline.addLast("aggregator", new HttpChunkAggregator(1048576));
pipeline.addLast("encoder", new HttpResponseEncoder());
// Remove the following line if you don't want automatic content compression.
pipeline.addLast("deflater", new HttpContentCompressor());
//pipeline.addLast("handler", new HttpRequestHandler());
pipeline.addLast("handler", channelUpstreamHandler);
return pipeline;
}
public void setChannelUpstreamHandler(ChannelUpstreamHandler channelUpstreamHandler) {
this.channelUpstreamHandler = channelUpstreamHandler;
}
}
相关spring配置
Java代码
<bean id="httpServerPipelineFactory" class="com.yunchao.cm.network.http.HttpServerPipelineFactory">
<property name="channelUpstreamHandler" ref="httpRequestHandler"/>
</bean>
Java代码
<bean id="httpRequestHandler" class="com.yunchao.cm.network.http.HttpRequestHandler">
<property name="urlMaps">
<map>
<entry key="/payorder">
<ref bean="payOrderCodecFactory"/>
</entry>
<entry key="/question">
<ref bean="questionCodecFactory"/>
</entry>
<entry key="/sms">
<ref bean="smsCodecFactory"/>
</entry>
代码太多，不全部贴出来，后面整理一下放到我的github上去。
基如此，我们还是得定义一个handler，继承simpleChannelUpstreamHander，并重写了messageReceied方法，具体在这里。
Java代码
QueryStringDecoder queryStringDecoder = new QueryStringDecoder(request.getUri());
String url = queryStringDecoder.getPath();
CodecFactory codecFactory = urlMaps.get(url);
if (null == codecFactory) {
logger.error("unsupported url:{} request.", url);
//sendError(ctx, BAD_REQUEST);
e.getChannel().close();
return;
}
//获取cmwap网络中的手机号码
String phone = PhoneUtils.getPhone(request.getHeader("x-up-calling-line-id"));
if (request.getMethod().equals(HttpMethod.POST)) {
ChannelBuffer content = request.getContent();
String postParams = content.toString(CharsetUtil.UTF_8);
logger.debug("request content:{}", postParams);
ClientRequestModel model = (ClientRequestModel) codecFactory.decode(postParams);
model.setProperty(model.MESSAGE_EVENT_KEY, e);
model.setProperty(model.HTTP_REQUEST_KEY, request);
model.setProperty(model.HTTP_PHONE_KEY, phone);
InetSocketAddress remoteAddress = (InetSocketAddress) e.getRemoteAddress();
model.setProperty(model.IP_KEY, remoteAddress.getAddress().getHostAddress());
logger.info("user request model:{}", model);
model.fireSelf();
Java代码
@Override
public DomainMessage fireSelf() {
DomainMessage em = new DomainMessage(this);
EventUtils.fireEvent(em, "alipayNotifyState");
return em;
}
看到这里基本上能够清楚了，是如何把客户端请求包装成ClientRequestModel了，且后面涉及到处理的对象，全部继承它，在整个架构之
中，has a 优于 is
a，对于客户端netty的一些对象，也是存储在ClientRequestModel中，codec无非也是采用了xml/json/kv，如斯，实现
了字节与对象之间的转换。
除
此之外，突然想到刚来杭州工作的第一家公司，基于此，采用的架构师servlet充当服务器，因为这是一个公司内部的server,而不是一个平台，采用
的数据格式也比较单一，就是xml，但是采用的外部类库也是xstream来处理的，但是整个系统维持的日调用量也是在百万级别，运用的client则是
采用httpclient，对于不同请求后面挂的handler，是在容器启动时加载到内存中，其余也没有什么亮点了。
Ⅷ 如何构建一个基于netty的后端服务器
Netty服务端创建
当我们直接使用JDK NIO的类库开发基于NIO的异步服务端时，需要使用到多路复用器Selector、ServerSocketChannel、SocketChannel、ByteBuffer、SelectionKey等等，相比于传统的BIO开发，NIO的开发要复杂很多，开发出稳定、高性能的异步通信框架，一直是个难题。
Netty为了向使用者屏蔽NIO通信的底层细节，在和用户交互的边界做了封装，目的就是为了减少用户开发工作量，降低开发难度。ServerBootstrap是Socket服务端的启动辅助类，用户通过ServerBootstrap可以方便的创建Netty的服务端。
Ⅸ 如何构建一个基于netty的后端服务器
最近在研究Netty来构建SOA架构，其中也包括了前端接入的HTTP/WebSocket方面的接入响应，而WebSocket方面的接入响应对于移动端的消息推送研发至关重要，这里就将在这块研发时的异步socket响应服务例子程序笔记记录下来，系统总共分为4个处理类，...