spring+netty 服务器

最新推荐文章于 2024-05-17 09:55:41 发布
最新推荐文章于 2024-05-17 09:55:41 发布
阅读量3.5k 收藏 3
点赞数
一、 java NIO简介
nio是java New IO的简称，在jdk1.4里提供的新api。Sun官方标榜的特性如下：
 为所有的原始类型提供(Buffer)缓存支持。
 字符集编码解码解决方案。
 Channel：一个新的原始I/O抽象。
 支持锁和内存映射文件的文件访问接口。
 提供多路(non-bloking)非阻塞式的高伸缩性网络I/O。
关于java NIO的实现部分不是本文讨论的重点，有兴趣的朋友可以访问JAVA夜无眠的博客JAVA NIO 实例。
二、 NIO框架简介
在Java社区，最知名的开源Java NIO框架要属Mina和Netty。实际上，Netty的作者原来就是Mina作者之一，所以可以想到，Netty和Mina在设计理念上会有很多共同点。而本文主要介绍的是使用netty搭建简单的游戏服务器，对于netty与mina的比较以及简单netty应用教程，将在其他文章中有所提及，敬请关注！
三、 netty游戏框架搭建
a) ServerBootstrap——netty框架的总入口
Java代码
  1. /**
  2. *  作者:chenpeng 
  3. * E-mail:46731706@qq.com 
  4. *  创建时间：2012-7-12 下午12:22:53 
  5. *  类说明  netty game
  6. */  
  7. public class ServerTest { 
  8.  
  9.  
  10. public static void main(String[] args) { 
  11.   DOMConfigurator.configureAndWatch("config/log4j.xml"); 
  12.   ApplicationContext factory = new FileSystemXmlApplicationContext( 
  13.     new String[] { "config/propholder.xml" }); 
  14.    
  15.      ServerBootstrap bootstrap = new ServerBootstrap(  
  16.              new NioServerSocketChannelFactory(  
  17.                      Executors.newCachedThreadPool(),  
  18.                      Executors.newCachedThreadPool()));  
  19.      ServerPipelineFactory httpServerPipelineFactory=(ServerPipelineFactory)factory.getBean("serverPipelineFactory"); 
  20.      bootstrap.setPipelineFactory(httpServerPipelineFactory);  
  21.      //启动端口 8888 
  22.      bootstrap.bind(new InetSocketAddress(8888));  
  23.      System.out.print("8888  server is starting……"); 
  24.  
  25.       
  26. } 
  27.  
  28. }  
/** 
*  作者:chenpeng  
* E-mail:46731706@qq.com  
*  创建时间：2012-7-12 下午12:22:53  
*  类说明  netty game 
*/ 
public class ServerTest {


 public static void main(String[] args) {
  DOMConfigurator.configureAndWatch("config/log4j.xml");
  ApplicationContext factory = new FileSystemXmlApplicationContext(
    new String[] { "config/propholder.xml" });
  
     ServerBootstrap bootstrap = new ServerBootstrap( 
             new NioServerSocketChannelFactory( 
                     Executors.newCachedThreadPool(), 
                     Executors.newCachedThreadPool())); 
     ServerPipelineFactory httpServerPipelineFactory=(ServerPipelineFactory)factory.getBean("serverPipelineFactory");
     bootstrap.setPipelineFactory(httpServerPipelineFactory); 
     //启动端口 8888
     bootstrap.bind(new InetSocketAddress(8888)); 
     System.out.print("8888  server is starting……");

     
 }

}

b) ChannelPipeline
channelPipeline是一系列channelHandler的集合，他参照J2ee中的Intercepting Filter模式来实现的，让用户完全掌握如果在一个handler中处理事件，同时让pipeline里面的多个handler可以相互交互。
Java代码
  1. import org.jboss.netty.channel.ChannelPipeline; 
  2. import org.jboss.netty.channel.ChannelPipelineFactory; 
  3. import org.jboss.netty.channel.Channels; 
  4.  
  5. import com.cp.netty.coder.Decoder; 
  6. import com.cp.netty.coder.Encoder; 
  7.  
  8. /**
  9. *   作者:chenpeng 
  10. *   E-mail:46731706@qq.com 
  11. *   创建时间：2012-7-12 上午11:28:56 
  12. *   channelPipeline是一系列channelHandler的集合，他参照J2ee中的Intercepting Filter模式来实现的，
  13. *   让用户完全掌握如果在一个handler中处理事件，同时让pipeline里面的多个handler可以相互交互
  14. */  
  15. public class ServerPipelineFactory implements ChannelPipelineFactory { 
  16.     public ServerHandler serverHandler; 
  17.  
  18.     public ChannelPipeline getPipeline() throws Exception { 
  19.         ChannelPipeline pipeLine = Channels.pipeline(); 
  20.         pipeLine.addLast("decoder", new Decoder(Integer.MAX_VALUE, 0, 4)); 
  21.         pipeLine.addLast("encoder", new Encoder(4)); 
  22.         pipeLine.addLast("handler", serverHandler); 
  23.         return pipeLine; 
  24.     } 
  25.  
  26.     public ServerHandler getServerHandler() { 
  27.         return serverHandler; 
  28.     } 
  29.  
  30.     public void setServerHandler(ServerHandler serverHandler) { 
  31.         this.serverHandler = serverHandler; 
  32.     } 
  33.  
  34. }  
import org.jboss.netty.channel.ChannelPipeline;
import org.jboss.netty.channel.ChannelPipelineFactory;
import org.jboss.netty.channel.Channels;

import com.cp.netty.coder.Decoder;
import com.cp.netty.coder.Encoder;

/** 
* 	作者:chenpeng  
*	E-mail:46731706@qq.com  
* 	创建时间：2012-7-12 上午11:28:56  
* 	channelPipeline是一系列channelHandler的集合，他参照J2ee中的Intercepting Filter模式来实现的，
* 	让用户完全掌握如果在一个handler中处理事件，同时让pipeline里面的多个handler可以相互交互 
*/ 
public class ServerPipelineFactory implements ChannelPipelineFactory {
	public ServerHandler serverHandler;

	public ChannelPipeline getPipeline() throws Exception {
		ChannelPipeline pipeLine = Channels.pipeline();
		pipeLine.addLast("decoder", new Decoder(Integer.MAX_VALUE, 0, 4));
		pipeLine.addLast("encoder", new Encoder(4));
		pipeLine.addLast("handler", serverHandler);
		return pipeLine;
	}

	public ServerHandler getServerHandler() {
		return serverHandler;
	}

	public void setServerHandler(ServerHandler serverHandler) {
		this.serverHandler = serverHandler;
	}

}


c) Decoder——消息解码器
Decoder解码器继承于FrameDecoder，FrameDecoder是Netty codec包中的辅助类，它是个ChannelUpstreamHandler，decode方法是FrameDecoder子类需要实现的。在本程序采用的是LengthFieldBasedFrameDecoder。LengthFieldBasedFrameDecoder是基于长度字段的解码器。如果协议格式类似“内容长度”+内容、“固定头”+“内容长度”+动态内容这样的格式，就可以使用该解码器 。至于其他类型的解码器，这里不再一一介绍。
Java代码
  1. import org.jboss.netty.buffer.ChannelBuffer; 
  2. import org.jboss.netty.channel.Channel; 
  3. import org.jboss.netty.channel.ChannelHandlerContext; 
  4. import org.jboss.netty.handler.codec.frame.LengthFieldBasedFrameDecoder; 
  5.  
  6.  
  7. /**
  8. *   作者:chenpeng 
  9. *   E-mail:46731706@qq.com 
  10. *   创建时间：2012-7-12 上午11:22:14 
  11. *   协议解码器 
  12. */  
  13. public class Decoder extends LengthFieldBasedFrameDecoder { 
  14.     // 第一个参数为信息最大长度，超过这个长度回报异常， 
  15.     // 第二参数为长度属性的起始（偏移）位，我们的协议中长度是0到第3个字节，所以这里写0， 
  16.     // 第三个参数为“长度属性”的长度，我们是4个字节，所以写4， 
  17.     // 第四个参数为长度调节值，在总长被定义为包含包头长度时，修正信息长度， 
  18.     // 第五个参数为跳过的字节数，根据需要我们跳过前4个字节，以便接收端直接接受到不含“长度属性”的内容。 
  19.  
  20.     public Decoder(int maxFrameLength, int lengthFieldOffset, 
  21.             int lengthFieldLength) { 
  22.         super(maxFrameLength, lengthFieldOffset, lengthFieldLength); 
  23.     } 
  24.  
  25.     @Override 
  26.     protected Object decode(ChannelHandlerContext ctx, Channel channel, 
  27.             ChannelBuffer buffer) throws Exception { 
  28.         ChannelBuffer buffs = (ChannelBuffer)super.decode(ctx, channel, buffer);  
  29.         return buffs; 
  30.     } 
  31.  
  32. }  
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.channel.Channel;
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.handler.codec.frame.LengthFieldBasedFrameDecoder;


/** 
* 	作者:chenpeng  
*	E-mail:46731706@qq.com  
* 	创建时间：2012-7-12 上午11:22:14  
* 	协议解码器  
*/ 
public class Decoder extends LengthFieldBasedFrameDecoder {
	// 第一个参数为信息最大长度，超过这个长度回报异常，
	// 第二参数为长度属性的起始（偏移）位，我们的协议中长度是0到第3个字节，所以这里写0，
	// 第三个参数为“长度属性”的长度，我们是4个字节，所以写4，
	// 第四个参数为长度调节值，在总长被定义为包含包头长度时，修正信息长度，
	// 第五个参数为跳过的字节数，根据需要我们跳过前4个字节，以便接收端直接接受到不含“长度属性”的内容。

	public Decoder(int maxFrameLength, int lengthFieldOffset,
			int lengthFieldLength) {
		super(maxFrameLength, lengthFieldOffset, lengthFieldLength);
	}

	@Override
	protected Object decode(ChannelHandlerContext ctx, Channel channel,
			ChannelBuffer buffer) throws Exception {
		ChannelBuffer buffs = (ChannelBuffer)super.decode(ctx, channel, buffer); 
		return buffs;
	}

}

d) ServerHandler——消息分发器
在介绍这个类之前，先对几个概念进行简要说明：
1. Channel：channel 是负责数据读、写的对象。channel是双向的，既可以write 也可以read。而且在NIO中用户不应该直接从channel中读写数据，而是应该通过buffer，通过buffer再将数据读写到channel中。
一个channel 可以提供给用户下面几个信息
(1)channel的当前状态，比如open 还是closed
(2)ChannelConfig对象，表示channel的一些参数，比如bufferSize
(3)channel支持的所有i/o操作（比如read,write,connect.bind）
2. channelEvent：ChannelEvent广义的认为Channel相关的事件处理。他分为Upstream events和downstream events两大块。如果以服务器端为主体，那么client到server的数据传输过程是Upstream，而server到client的数据传输过程则是downstream；以客户端为主体的过程正好相反。一下主要介绍以服务器端为主体的开发。
3. 常用的Upstream events包括
a) messageReceived：信息被接受时 ---MessageEvent
b) exceptionCaught：产生异常时 ---ExceptionEvent
c) channelOpen：channel被开启时 ---ChannelStateEvent
d) channelClosed：channel被关闭时 ---ChannelStateEvent
e) channelBound：channel被开启并准备去连接但还未连接上的时候 ---ChannelStateEvent
f) channelUnbound：channel被开启不准备去连接时候 ---ChannelStateEvent
g) channelConnected：channel被连接上的时候 ---ChannelStateEvent
h) channelDisconnected:channel连接断开的时候 ---ChannelStateEvent
在本游戏架构里，ServerHandler扮演着创建线程、验证消息、分发消息的重要角色，程序如下：
Java代码
  1. import java.util.concurrent.ConcurrentLinkedQueue; 
  2.  
  3. import org.apache.log4j.Logger; 
  4. import org.jboss.netty.buffer.ChannelBuffer; 
  5. import org.jboss.netty.channel.ChannelHandlerContext; 
  6. import org.jboss.netty.channel.ChannelStateEvent; 
  7. import org.jboss.netty.channel.ExceptionEvent; 
  8. import org.jboss.netty.channel.MessageEvent; 
  9. import org.jboss.netty.channel.SimpleChannelUpstreamHandler; 
  10.  
  11. import com.cp.game.HandlerDispatcher; 
  12. import com.cp.game.domain.MessageQueue; 
  13. import com.cp.netty.domain.GameRequest; 
  14.  
  15. /**
  16. *   作者:chenpeng 
  17. *   E-mail:46731706@qq.com 
  18. *   创建时间：2012-7-12 下午12:02:52 
  19. *   游戏协议接收分发器
  20. */  
  21. public class ServerHandler extends SimpleChannelUpstreamHandler { 
  22.     public Logger log = Logger.getLogger(this.getClass()); 
  23.     public static HandlerDispatcher handlerDispatcher; 
  24.  
  25.  
  26.     public void init() { 
  27.         new Thread(handlerDispatcher).start(); 
  28.     } 
  29.  
  30.      
  31.  
  32.     /* (non-Javadoc)
  33.      * @see org.jboss.netty.channel.SimpleChannelUpstreamHandler#channelConnected(org.jboss.netty.channel.ChannelHandlerContext, org.jboss.netty.channel.ChannelStateEvent)
  34.      *  建立一个新channel
  35.      */ 
  36.     @Override 
  37.     public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e) 
  38.             throws Exception { 
  39.         log.debug("进来一个channel：" + ctx.getChannel().getId()); 
  40.         MessageQueue messageQueue = new MessageQueue( 
  41.                 new ConcurrentLinkedQueue<GameRequest>()); 
  42.         handlerDispatcher.addMessageQueue(ctx.getChannel().getId(), messageQueue); 
  43.  
  44.     } 
  45.  
  46.     /* (non-Javadoc)
  47.      * @see org.jboss.netty.channel.SimpleChannelUpstreamHandler#channelDisconnected(org.jboss.netty.channel.ChannelHandlerContext, org.jboss.netty.channel.ChannelStateEvent)
  48.      *  玩家主动关闭channel
  49.      */ 
  50.     @Override 
  51.     public void channelDisconnected(ChannelHandlerContext ctx, 
  52.             ChannelStateEvent e) throws Exception { 
  53.         log.error("关掉一个channel：" + ctx.getChannel().getId()); 
  54.         handlerDispatcher.removeMessageQueue(e.getChannel().getId().toString()); 
  55.         e.getChannel().close(); 
  56.     } 
  57.  
  58.     /* (non-Javadoc)
  59.      * @see org.jboss.netty.channel.SimpleChannelUpstreamHandler#exceptionCaught(org.jboss.netty.channel.ChannelHandlerContext, org.jboss.netty.channel.ExceptionEvent)
  60.      *  玩家被动关闭channel
  61.      */ 
  62.     @Override 
  63.     public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e) 
  64.             throws Exception { 
  65.         log.error("出异常啦……" + ctx.getChannel().getId()); 
  66.         e.getCause().printStackTrace(); 
  67.         handlerDispatcher.removeMessageQueue(e.getChannel().getId().toString()); 
  68.         e.getChannel().close(); 
  69.     } 
  70.  
  71.     /* (non-Javadoc)
  72.      * @see org.jboss.netty.channel.SimpleChannelUpstreamHandler#messageReceived(org.jboss.netty.channel.ChannelHandlerContext, org.jboss.netty.channel.MessageEvent)
  73.      *  消息接收处理器
  74.      */ 
  75.     @Override 
  76.     public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) 
  77.             throws Exception { 
  78.         ChannelBuffer buffs = (ChannelBuffer) e.getMessage(); 
  79.         buffs.skipBytes(4);// 越过dataLength的字节 
  80.         byte[] decoded = new byte[buffs.readableBytes()]; 
  81.         buffs.readBytes(decoded); 
  82.         GameRequest gameRequest = new GameRequest(e.getChannel(), decoded); 
  83.  
  84.         // 通知回调协议 
  85.         handlerDispatcher.addMessage(gameRequest); 
  86.     } 
  87.  
  88.     public HandlerDispatcher getHandlerDispatcher() { 
  89.         return handlerDispatcher; 
  90.     } 
  91.  
  92.     public void setHandlerDispatcher(HandlerDispatcher handlerDispatcher) { 
  93.         ServerHandler.handlerDispatcher = handlerDispatcher; 
  94.     } 
  95.  
  96. }  
import java.util.concurrent.ConcurrentLinkedQueue;

import org.apache.log4j.Logger;
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.channel.ChannelStateEvent;
import org.jboss.netty.channel.ExceptionEvent;
import org.jboss.netty.channel.MessageEvent;
import org.jboss.netty.channel.SimpleChannelUpstreamHandler;

import com.cp.game.HandlerDispatcher;
import com.cp.game.domain.MessageQueue;
import com.cp.netty.domain.GameRequest;

/** 
* 	作者:chenpeng  
*	E-mail:46731706@qq.com  
* 	创建时间：2012-7-12 下午12:02:52  
* 	游戏协议接收分发器 
*/ 
public class ServerHandler extends SimpleChannelUpstreamHandler {
	public Logger log = Logger.getLogger(this.getClass());
	public static HandlerDispatcher handlerDispatcher;


	public void init() {
		new Thread(handlerDispatcher).start();
	}

	

	/* (non-Javadoc)
	 * @see org.jboss.netty.channel.SimpleChannelUpstreamHandler#channelConnected(org.jboss.netty.channel.ChannelHandlerContext, org.jboss.netty.channel.ChannelStateEvent)
	 *	建立一个新channel
	 */
	@Override
	public void channelConnected(ChannelHandlerContext ctx, ChannelStateEvent e)
			throws Exception {
		log.debug("进来一个channel：" + ctx.getChannel().getId());
		MessageQueue messageQueue = new MessageQueue(
				new ConcurrentLinkedQueue<GameRequest>());
		handlerDispatcher.addMessageQueue(ctx.getChannel().getId(), messageQueue);

	}

	/* (non-Javadoc)
	 * @see org.jboss.netty.channel.SimpleChannelUpstreamHandler#channelDisconnected(org.jboss.netty.channel.ChannelHandlerContext, org.jboss.netty.channel.ChannelStateEvent)
	 *	玩家主动关闭channel
	 */
	@Override
	public void channelDisconnected(ChannelHandlerContext ctx,
			ChannelStateEvent e) throws Exception {
		log.error("关掉一个channel：" + ctx.getChannel().getId());
		handlerDispatcher.removeMessageQueue(e.getChannel().getId().toString());
		e.getChannel().close();
	}

	/* (non-Javadoc)
	 * @see org.jboss.netty.channel.SimpleChannelUpstreamHandler#exceptionCaught(org.jboss.netty.channel.ChannelHandlerContext, org.jboss.netty.channel.ExceptionEvent)
	 *	玩家被动关闭channel
	 */
	@Override
	public void exceptionCaught(ChannelHandlerContext ctx, ExceptionEvent e)
			throws Exception {
		log.error("出异常啦……" + ctx.getChannel().getId());
		e.getCause().printStackTrace();
		handlerDispatcher.removeMessageQueue(e.getChannel().getId().toString());
		e.getChannel().close();
	}

	/* (non-Javadoc)
	 * @see org.jboss.netty.channel.SimpleChannelUpstreamHandler#messageReceived(org.jboss.netty.channel.ChannelHandlerContext, org.jboss.netty.channel.MessageEvent)
	 *	消息接收处理器
	 */
	@Override
	public void messageReceived(ChannelHandlerContext ctx, MessageEvent e)
			throws Exception {
		ChannelBuffer buffs = (ChannelBuffer) e.getMessage();
		buffs.skipBytes(4);// 越过dataLength的字节
		byte[] decoded = new byte[buffs.readableBytes()];
		buffs.readBytes(decoded);
		GameRequest gameRequest = new GameRequest(e.getChannel(), decoded);

		// 通知回调协议
		handlerDispatcher.addMessage(gameRequest);
	}

	public HandlerDispatcher getHandlerDispatcher() {
		return handlerDispatcher;
	}

	public void setHandlerDispatcher(HandlerDispatcher handlerDispatcher) {
		ServerHandler.handlerDispatcher = handlerDispatcher;
	}

}

需要注意的是：HandlerDispatcher是一个多线程处理器，用于处理游戏逻辑请求。这部分功能可根据用户的不同需求进行定制。
e) Encoder——消息编码器
消息编码器主要完成的是对游戏逻辑处理器返回的数据进行编码，组合成符合客户端规范的消息格式并发送。
Java代码
  1. import org.jboss.netty.buffer.ChannelBuffer; 
  2. import org.jboss.netty.buffer.ChannelBuffers; 
  3. import org.jboss.netty.channel.Channel; 
  4. import org.jboss.netty.channel.ChannelHandlerContext; 
  5. import org.jboss.netty.handler.codec.frame.LengthFieldPrepender; 
  6.  
  7. import com.cp.netty.domain.GameResponse; 
  8.  
  9. /**
  10. *   作者:chenpeng 
  11. *   E-mail:46731706@qq.com 
  12. *   创建时间：2012-7-12 上午11:43:11 
  13. *   类说明 
  14. */  
  15. public class Encoder extends LengthFieldPrepender { 
  16.  
  17.     public Encoder(int lengthFieldLength) { 
  18.         super(lengthFieldLength); 
  19.     } 
  20.  
  21.     @Override 
  22.     protected Object encode(ChannelHandlerContext cxt, Channel channel, 
  23.             Object msg) throws Exception { 
  24.          
  25.         ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(channel.getConfig().getBufferFactory()); 
  26.         GameResponse response = (GameResponse) msg; 
  27.         buffer.writeInt(response.getRtMessage().length+20); 
  28.         buffer.writeInt(response.getCommondId()); 
  29.         buffer.writeInt(response.getPlayerId()); 
  30.         buffer.writeInt(response.getCommandType()); 
  31.         buffer.writeLong(response.getTime()); 
  32.         System.out.println("send message "+response.getCommondId()); 
  33.         buffer.writeBytes(response.getRtObj().getBytesM()); 
  34.         return buffer; 
  35.  
  36.     } 
  37.  
  38. }  
import org.jboss.netty.buffer.ChannelBuffer;
import org.jboss.netty.buffer.ChannelBuffers;
import org.jboss.netty.channel.Channel;
import org.jboss.netty.channel.ChannelHandlerContext;
import org.jboss.netty.handler.codec.frame.LengthFieldPrepender;

import com.cp.netty.domain.GameResponse;

/** 
* 	作者:chenpeng  
*	E-mail:46731706@qq.com  
* 	创建时间：2012-7-12 上午11:43:11  
* 	类说明  
*/ 
public class Encoder extends LengthFieldPrepender {

	public Encoder(int lengthFieldLength) {
		super(lengthFieldLength);
	}

	@Override
	protected Object encode(ChannelHandlerContext cxt, Channel channel,
			Object msg) throws Exception {
		
		ChannelBuffer buffer = ChannelBuffers.dynamicBuffer(channel.getConfig().getBufferFactory());
		GameResponse response = (GameResponse) msg;
		buffer.writeInt(response.getRtMessage().length+20);
		buffer.writeInt(response.getCommondId());
		buffer.writeInt(response.getPlayerId());
		buffer.writeInt(response.getCommandType());
		buffer.writeLong(response.getTime());
		System.out.println("send message "+response.getCommondId());
		buffer.writeBytes(response.getRtObj().getBytesM());
		return buffer;

	}

}

Java代码
  1. <?xml version="1.0" encoding="UTF-8"?> 
  2. <beans xmlns="http://www.springframework.org/schema/beans" 
  3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
  4.     xmlns:aop="http://www.springframework.org/schema/aop" 
  5.     xmlns:tx="http://www.springframework.org/schema/tx" 
  6.     xsi:schemaLocation="  
  7.             http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd  
  8.             http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd  
  9.  
  10.             http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-2.5.xsd"> 
  11.  
  12.     <bean id="serverPipelineFactory" 
  13.         class="com.cp.netty.ServerPipelineFactory" 
  14.         scope="prototype"> 
  15.         <property name="serverHandler" ref="appHandler"></property> 
  16.     </bean> 
  17.  
  18.     <bean id="appHandler" class="com.cp.netty.ServerHandler" 
  19.         init-method="init"> 
  20.         <property name="handlerDispatcher" ref="handlerDispatcher" /> 
  21.     </bean> 
  22.     <bean id="handlerDispatcher" 
  23.         class="com.cp.game.HandlerDispatcher" init-method="init" 
  24.         destroy-method="stop"> 
  25.         <property name="messageExecutor"> 
  26.             <bean class="com.cp.netty.domain.FiexThreadPoolExecutor" 
  27.                 destroy-method="shutdown"> 
  28.                 <constructor-arg 
  29.                     value="${app.dispatcher.pool.corePoolSize}" /> 
  30.                 <constructor-arg 
  31.                     value="${app.dispatcher.pool.maximumPoolSize}" /> 
  32.                 <constructor-arg 
  33.                     value="${app.dispatcher.pool.keepAliveSecond}" /> 
  34.             </bean> 
  35.         </property> 
  36.         <property name="sleepTime" value="${app.dispatcher.sleepTime}" /> 
  37.         <property name="handlerMap" ref="serverHandlerMapping" /> 
  38.     </bean> 
  39.  
  40.     <bean id="serverMainController" class="com.cp.game.ServerMainHandler" 
  41.         abstract="true"> 
  42.     </bean> 
  43.      
  44.        <bean id="serverHandlerMapping" class="java.util.HashMap"> 
  45.         <constructor-arg> 
  46.             <map> 
  47.                 <!-- 测试协议 --> 
  48.                 <entry key="1000"> 
  49.                     <bean 
  50.                         class="com.cp.game.handler.common.InitHandler" 
  51.                         parent="serverMainController"> 
  52.                     </bean> 
  53.                 </entry> 
  54.             </map> 
  55.         </constructor-arg> 
  56.     </bean> 
  57.  
  58. </beans> 
ogre_怪兽
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
使用spring容器管理和配置netty
u012233832的专栏
08-07 1万+
使用spring容器管理和配置netty 为了使程序达到方便配置和管理，spring的ioc容器是特效药之一。本文将使用ioc来管理和配置netty服务器 服务端使用Reactor多线程模型，详见 李林锋老师的博文 Netty系列之Netty高性能之道 在本程序中Reactor Thread Acceptor对应BossGroup，Reactor Thread P
使用netty+spring搭建游戏框架
IT老兵
07-12 522
一、 java NIO简介 nio是java New IO的简称，在jdk1.4里提供的新api。Sun官方标榜的特性如下：  为所有的原始类型提供(Buffer)缓存支持。  字符集编码解码解决方案。  Channel：一个新的原始I/O抽象。  支持锁和内存映射文件的文件访问接口。  提供多路(non-bloking)非阻塞式的高伸缩性网络I/O。 关于java ...
SpringBoot整合Netty(服务端)
最新发布
m0_70554089的博客
05-17 3967
Netty是由JBOSS提供的一个Java开源框架，现为Github上的独立项目。它是一个异步的、基于事件驱动的网络应用框架，用以快速开发高性能、高可靠性的网络IO程序。Netty主要针对在TCP协议下，面向Clients端的高并发应用，或者Peer-to-Peer场景下的大量数据持续传输的应用。Netty提供了一套完整的API，用于处理网络IO操作，如TCP和UDP套接字。它封装了底层的网络编程细节，使得开发者可以更加专注于业务逻辑的实现。
Netty+Spring
cluzax的专栏
05-23 3620
转载自 落神飘渺云403 加载spring的方法。 基本上两种： 1、Netty启动Spring容器， 写一个启动Spring的类，读取Application-Context.xml。将ctx载入。 在启动Netty的main方法里面调用那个类的静态init方法。Spring就被加载了。 2、启动Spring容器，将NettyServer作为一个Sp
spring+netty服务器搭建
欧神的博客
06-26 2万+
游戏一般是长连接，自定义协议，不用http协议，BIO,NIO,AIO这些我就不说了，自己查资料 我现在用spring+netty搭起简单的游戏服 思路：1自定义协议和协议包；2spring+netty整合；3半包粘包处理，心跳机制等；4请求分发（目前自己搞的都是单例模式） 下个是测试用的，结构如下 首先自定义包头 Header.j
netty和spring结合
09-10
netty4.0和spring结合，可以处理tcp请求，用做游戏后台。方便简单。
spring+netty服务器搭建的方法
08-28
Spring+Netty服务器搭建方法详解 本文将详细介绍使用 Spring 和 Netty 搭建服务器的方法，涵盖自定义协议、协议包、半包粘包处理、心跳机制、请求分发等关键技术点。 自定义协议和协议包 在搭建服务器时，需要...
Spring+Netty+WebSocket实例
12-06
3. **Netty服务器**：创建一个Netty服务器，配置WebSocket服务器通道处理器，处理WebSocket的连接请求和数据帧。 4. **Spring与Netty的集成**：通过Spring的`WebSocketMessageBrokerConfigurer`接口，将Spring的...
Spring Boot + Netty 实现温湿度采集的展示
05-24
- **数据处理**：接收到的温湿度数据在Netty服务器上进行预处理，然后转发给Spring Boot应用，Spring Boot将数据持久化到数据库，并提供查询接口。 - **数据库存储**：可以选择关系型数据库如MySQL，或者非关系型...
spring+netty+mybatis整合实例
09-14
创建一个Spring配置文件，例如`applicationContext.xml`，在这里定义Bean，包括Netty服务器、MyBatis的数据源、SqlSessionFactory等。使用Spring的注解或者XML配置来声明Bean，例如： ```xml <!-- 数据库连接配置...
remote-desktop-control:远程桌面控制(Spring+Netty+Swing)
05-25
负责中转的第三方是服务器，控制端和傀儡端(被控制端)相对于服务器来说都是客户端，都和服务器直接相连，也就是说控制端不和傀儡端相连。款款深入约定:控制端M(Master)服务器S(Server)傀儡端P(Puppet)为了叙述方便,...
netty4与spring集成
06-11
netty4与spring集成；客户端服务端代码实现。netty4与spring集成。
spring netty 整合 源代码
11-08
疯狂创客圈原创案例： spring netty 整合 源代码 ，一个完整的maven 工程，可以开箱就跑
netty_springMvc:基于netty ,http默认跳转controller层,webSocket 走专门通道
05-14
netty_springMvc 基于netty ,http默认跳转controller层,webSocket 走专门通道 工程目标是支持eureka调用,使微服务通过http协议发送websocket给浏览器
SpringBoot使用netty
热门推荐
阿靖的博客
06-29 3万+
Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。也就是说，Netty 是一个基于NIO的客户、服务器端编程框架，使用Netty 可以确保你快速和简单的开发出一个网络应用，例如实现了某种协议的客户、服务端应用。Netty相当于简化和流线化了网络应用的编程开发过程，例如：基于TCP和UDP...
Spring - Netty原理剖析
迦南的专栏
02-09 653
1. Netty简介 Netty是一个高性能、异步事件驱动的NIO框架，基于JAVA NIO提供的API实现。它提供了对TCP、UDP和文件传输的支持，作为一个异步NIO框架，Netty的所有IO操作都是异步非阻塞的，通过Future-Listener机制，用户可以方便的主动获取或者通过通知机制获得IO操作结果。 作为当前最流行的NIO框架，Netty在互联网领域、大数据分布式计算领域、游戏行业、通信行业等获得了广泛的应用，一些业界著名的开源组件也基于Netty的NIO框架构建。 2. Netty线程模
【Netty4 简单项目实践】十四、用SpringBoot加载Netty
arctan90的专栏
02-08 7303
【前言】在没用SpringBoot加载Netty的时候，我觉得单独靠Thread启动一个Netty也挺好。后来因为工作习惯的改变，越来越多的依赖AOP、SOA，觉得SpringBoot管理起Netty后，其实也还好，因为很少在Netty上操作ORM，唯一有点喜欢的就是基于AOP的Log。【入口】之前我写好一个Netty Server后，会让他implements Runnable/Callable...
基于 Netty + Spring 实现一个 HTTP REST 服务器（一）Gevlet 使用与概述
Norman S L Dai 的博客
05-09 1038
Gevlet 的使用与概述 说明：本博客中涉及的代码为学习用demo 没有在任何生产环境使用 为什么要写一个 HTTP REST 服务器 在刚开始学习编程的时候就对服务器或者应用容器特别好奇，不明白应用服务器的运行原理是什么。最近个人时间比较多，所以歇下来看了看Tomcat的实现原理（只是看了看目前还在继续）。所以为了总结一下，写了这样一个Demo 我暂且叫它 Gevlet 吧...
Java常用框架（三）SpringBoot及Netty
folyh
02-23 3087
Java常用框架（三）SpringBoot及Netty
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值