Java NioSocketAcceptor类代码示例

import org.apache.mina.transport.socket.nio.NioSocketAcceptor; //导入依赖的package包/类
public static void main(String[] args) throws IOException {

		IoAcceptor acceptor = new NioSocketAcceptor();
		// 这个过滤器用来记录所有的信息，比如创建session(会话)，接收消息，发送消息，关闭会话等
		acceptor.getFilterChain().addLast("logger", new LoggingFilter());
		// 用来转换二进制或协议的专用数据到消息对象中
		acceptor.getFilterChain().addLast("codec",
				new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));

		// 实时处理客户端的连接和请求
		acceptor.setHandler(new TimeServerHandler());
		acceptor.getSessionConfig().setReadBufferSize(2048);
		// 方法将定时调用一次会话，保持空闲状态。来设定时间间隔。
		acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, 10);
		acceptor.bind(new InetSocketAddress(PORT));
	}
 

import org.apache.mina.transport.socket.nio.NioSocketAcceptor; //导入依赖的package包/类
/**
 * start Mina serversocket
 * @throws Exception
 */
public void start() throws Exception {
	IoBuffer.setUseDirectBuffer(false);
	IoBuffer.setAllocator(new SimpleBufferAllocator());

	acceptor = new NioSocketAcceptor(pool);
	acceptor.setReuseAddress(true);
	acceptor.getSessionConfig().setAll(getSessionConfig());

	int serverPort = GateServerConfig.serverPort;
	logger.info("socket server start at port:{},正在监听客户端的连接...", serverPort);
	DefaultIoFilterChainBuilder filterChain = acceptor.getFilterChain();
	filterChain.addLast("codec", new ProtocolCodecFilter(MessageCodecFactory.getInstance()));
	acceptor.setHandler( new ServerSocketIoHandler() );//指定业务逻辑处理器
	acceptor.setDefaultLocalAddress(new InetSocketAddress(serverPort) );//设置端口号
	acceptor.bind();//启动监听

}
 

import org.apache.mina.transport.socket.nio.NioSocketAcceptor; //导入依赖的package包/类
/**
 * Create a new slave host and bind to a single TCP port
 *
 * @param options
 *            optional protocol options
 * @param port
 *            the TCP port to bind to
 */
public SlaveHost ( final ProtocolOptions options, final int port ) throws IOException
{
    this.options = makeOptions ( options );

    this.connector = null;

    this.processor = new SimpleIoProcessorPool<> ( NioProcessor.class );
    final SocketAcceptor nioAcceptor = new NioSocketAcceptor ( this.processor );
    this.acceptor = nioAcceptor;

    nioAcceptor.setReuseAddress ( true );
    nioAcceptor.setBacklog ( 5 );

    this.disposeAcceptor = true;

    setupAcceptor ( null );

    this.acceptor.bind ( new InetSocketAddress ( port ) );
}
 

import org.apache.mina.transport.socket.nio.NioSocketAcceptor; //导入依赖的package包/类
public SocketServer(int port,  int threadPoolSize) {
		NioSocketAcceptor acceptor = new NioSocketAcceptor();
		acceptor.setHandler(new ServerHandler());
//		acceptor.getFilterChain().addLast("mychian",new ProtocolCodecFilter(new TextLineCodecFactory()));
//		acceptor.getFilterChain().addLast("codec", new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));
		acceptor.getFilterChain().addLast("exector", new ExecutorFilter(new OrderedThreadPoolExecutor(threadPoolSize)));
		SocketSessionConfig ssc = acceptor.getSessionConfig();// 建立连接的配置文件
		ssc.setReadBufferSize(4096);// 设置接收最大字节默认4096
		ssc.setReceiveBufferSize(10240);// 设置输入缓冲区的大小
		ssc.setSendBufferSize(10240);// 设置输出缓冲区的大小
		ssc.setReuseAddress(true);// 设置每一个非主监听连接的端口可以重用
		
		try {
			// 绑定端口
			acceptor.bind(new InetSocketAddress(port));
			System.out.println("服务器启动正常，监听端口 " + port);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}
 

import org.apache.mina.transport.socket.nio.NioSocketAcceptor; //导入依赖的package包/类
public Channel(final int world, final int channel) {
    this.world = world;
    this.channel = channel;
    this.mapFactory = new MapleMapFactory(MapleDataProviderFactory.getDataProvider(new File(System.getProperty("wzpath") + "/Map.wz")), MapleDataProviderFactory.getDataProvider(new File(System.getProperty("wzpath") + "/String.wz")), world, channel);

    try {
        eventSM = new EventScriptManager(this, ServerConstants.EVENTS.split(" "));
        port = 7575 + this.channel - 1;
        port += (world * 100);
        ip = ServerConstants.HOST + ":" + port;
        IoBuffer.setUseDirectBuffer(false);
        IoBuffer.setAllocator(new SimpleBufferAllocator());
        acceptor = new NioSocketAcceptor();
        TimerManager.getInstance().register(new respawnMaps(), 10000);
        acceptor.setHandler(new MapleServerHandler(world, channel));
        acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, 30);
        acceptor.getFilterChain().addLast("codec", (IoFilter) new ProtocolCodecFilter(new MapleCodecFactory()));
        acceptor.bind(new InetSocketAddress(port));
        ((SocketSessionConfig) acceptor.getSessionConfig()).setTcpNoDelay(true);

        eventSM.init();
        System.out.println("    Channel " + getId() + ": Listening on port " + port);
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

import org.apache.mina.transport.socket.nio.NioSocketAcceptor; //导入依赖的package包/类
public static void main(String[] args) throws IOException {
    // 创建服务器端的监听器对象
    IoAcceptor acceptor = new NioSocketAcceptor();
    // 增加日志过滤器：用于日志存储
    acceptor.getFilterChain().addLast("logger", new LoggingFilter());
    // 增加消息编码过滤器，采用UTF-8编码
    acceptor.getFilterChain().addLast("codec",
            new ProtocolCodecFilter(new TextLineCodecFactory(Charset.forName("UTF-8"))));
    // 设置具体的事物逻辑处理器
    acceptor.setHandler(new TimeServerHandler());
    // 设置IoSession的一些属性
    acceptor.getSessionConfig().setReadBufferSize(2048);
    acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, 10);
    // 设置服务器监听的端口
    acceptor.bind(new InetSocketAddress(PORT));
}
 

import org.apache.mina.transport.socket.nio.NioSocketAcceptor; //导入依赖的package包/类
public static void main(String[] args) throws IOException {
        IoAcceptor acceptor = new NioSocketAcceptor();
//        acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, IDELTIMEOUT);

        acceptor.getFilterChain().addLast("logger", new LoggingFilter());
        acceptor.getFilterChain().addLast("myfliter", new MyFilter());
        acceptor.getFilterChain().addLast("codec", new ProtocolCodecFilter(new CommandCodecFactory("UTF-8")));

        KeepAliveMessageFactoryImpl kamfi = new KeepAliveMessageFactoryImpl();
        KeepAliveFilter kaf = new KeepAliveFilter(kamfi, IdleStatus.BOTH_IDLE);
        /** 是否回发 */
        kaf.setForwardEvent(true);
        acceptor.getFilterChain().addLast("heart", kaf);

        acceptor.setHandler(new CalculatorHandler());
        acceptor.bind(new InetSocketAddress(PORT));

        log.debug("socket通信服务端已启动，端口是" + PORT);
    }
 

import org.apache.mina.transport.socket.nio.NioSocketAcceptor; //导入依赖的package包/类
@Override
protected void serverStart() throws RemotingException {

    acceptor = new NioSocketAcceptor(); //TCP Acceptor

    // acceptor.getFilterChain().addFirst("logging", new MinaLoggingFilter());
    acceptor.getFilterChain().addLast("codec", new ProtocolCodecFilter(new MinaCodecFactory(getCodec())));
    acceptor.getFilterChain().addLast("mdc", new MdcInjectionFilter());

    acceptor.setHandler(new MinaHandler(this));
    IoSessionConfig cfg = acceptor.getSessionConfig();
    cfg.setReaderIdleTime(remotingServerConfig.getReaderIdleTimeSeconds());
    cfg.setWriterIdleTime(remotingServerConfig.getWriterIdleTimeSeconds());
    cfg.setBothIdleTime(remotingServerConfig.getServerChannelMaxIdleTimeSeconds());

    bindAddress = new InetSocketAddress(remotingServerConfig.getListenPort());
    try {
        acceptor.bind(bindAddress);
    } catch (IOException e) {
        throw new RemotingException("Start Mina server error", e);
    }
}
 

import org.apache.mina.transport.socket.nio.NioSocketAcceptor; //导入依赖的package包/类
private void init(Config config) {
    address = new InetSocketAddress(config.sourcePort);
    acceptor = new NioSocketAcceptor();
    if (acceptor.getFilterChain().get(LOGGER) == null) {
        acceptor.getFilterChain().addLast(LOGGER, new LoggingFilter());
    }
    if (acceptor.getFilterChain().get(CODEC) == null) {
        ProtocolCodecFactory codecFactory = config.codec == null ?
                MinaUtil.getTextLineCodecFactory() : (ProtocolCodecFactory) config.codec;
        acceptor.getFilterChain().addLast(CODEC, new ProtocolCodecFilter(codecFactory));
    }
    acceptor.setHandler(new MinaServerHandler());
    acceptor.getSessionConfig().setReadBufferSize(config.bufferSize);
    acceptor.getSessionConfig().setIdleTime(IdleStatus.WRITER_IDLE, 10);
    acceptor.setReuseAddress(true); //避免重启时提示地址被占用
    //设置主服务监听端口的监听队列的最大值为50，如果当前已经有50个连接，新的连接将被服务器拒绝
    acceptor.setBacklog(50);

    KeepAliveFilter keepAliveFilter = MinaUtil.initServerKeepAlive(config, this);
    if (keepAliveFilter != null) {
        acceptor.getFilterChain().addLast(HEARTBEAT, keepAliveFilter);
    }
}
 

import org.apache.mina.transport.socket.nio.NioSocketAcceptor; //导入依赖的package包/类
/**
 * �������
 * @param args
 * @throws IOException 
 */
public  void startServer()  {
	 server = new NioSocketAcceptor();
	//�������ݹ�����
	DefaultIoFilterChainBuilder  filterChain = server.getFilterChain();
	filterChain.addLast("myChin", new ProtocolCodecFilter(  
               new ObjectSerializationCodecFactory()));
	
	//filterChain.addLast("textCode",new ProtocolCodecFilter(
	//			new TextLineCodecFactory(Charset.forName("UTF-8"))));
	
	serverIOHandler = new ServerIOHandler(severFrame);
	server.setHandler(serverIOHandler);
	//�����������˿� --- ����������
	try {
		server.bind(new InetSocketAddress(port));
	} catch (IOException e) {
		Tools.show(severFrame, "�˿��Ѿ�ռ�ã��뻻���˿ڣ�");
	}
}
 

import org.apache.mina.transport.socket.nio.NioSocketAcceptor; //导入依赖的package包/类
protected void start() throws Exception{
		
		buildExecutors();
		IoProcessor<NioSession> processor = new SimpleIoProcessorPool<NioSession>(NioProcessor.class, ioExecutor, coreSize);
		acceptor = new NioSocketAcceptor(acceptorExecutor, processor);
//		acceptor.setBacklog(cfg.getBacklog());
		buildFilterChain();
		acceptor.setHandler(handler);
		try {
			List<SocketAddress> address = new ArrayList<SocketAddress>();
			//可添加多个
			address.add(new InetSocketAddress((String)rule.get("ip"), (Integer)rule.get("port")));
			acceptor.bind(address);
		} catch (IOException e) {
			stop();
			throw e;
		}
		
	}
 

import org.apache.mina.transport.socket.nio.NioSocketAcceptor; //导入依赖的package包/类
/**
 * 创建 Mina2 Core 服务核心并启动
 *
 * @return
 */
private boolean startupMinaCore() {
	_acceptor = new NioSocketAcceptor();
	// 禁用算法
	_acceptor.getSessionConfig().setTcpNoDelay(true);
	// 添加过滤链处理项
	_acceptor.getFilterChain().addLast("codec",
			new ProtocolCodecFilter(new CodecFactory()));
	// 设置处理器
	_acceptor.setHandler(new FrontendServerHandler(this));
	try {
		_acceptor.bind(new InetSocketAddress(getServerConfig()
				.getFrontendPort()));
	} catch (IOException e) {
		logger.error("启动 Mina Core 监听失败：", e);
		return false;
	}
	logger.error("Mina Core Startup Success On Port:"
			+ getServerConfig().getFrontendPort());
	return true;
}
 

import org.apache.mina.transport.socket.nio.NioSocketAcceptor; //导入依赖的package包/类
public static void main(String[] args) {
	int port = U.getInt("cleaner.server.port");
	int idleTime = U.getInt("cleaner.server.time");
	NioSocketAcceptor clientAcceptor = new NioSocketAcceptor();
	clientAcceptor.setReuseAddress(true);

	DefaultIoFilterChainBuilder chain = clientAcceptor.getFilterChain();
	SocketSessionConfig config = clientAcceptor.getSessionConfig();
	config.setIdleTime(IdleStatus.READER_IDLE, idleTime);// 读空闲 10秒
	config.setReuseAddress(true);
	config.setReadBufferSize(4096);// 默认2048
	config.setKeepAlive(true);
	config.setTcpNoDelay(true);// 开启nagle算法
	// 编解码
	chain.addLast("coder", new ProtocolCodecFilter(new TextLineCodecFactory(U.UTF8)));
	clientAcceptor.setHandler(new CleanerHandler());
	try {
		clientAcceptor.bind(new InetSocketAddress(port));
		log.info("心跳模块启动..");
	} catch (IOException e) {
		log.error("心跳模块启动失败", e);
	}
}
 

import org.apache.mina.transport.socket.nio.NioSocketAcceptor; //导入依赖的package包/类
public void initialize() {
	idleTime = U.getInt("chat.server.idleTime");
	System.out.println(idleTime);

	clientAcceptor = new NioSocketAcceptor();
	clientAcceptor.setReuseAddress(true);

	DefaultIoFilterChainBuilder chain = clientAcceptor.getFilterChain();
	SocketSessionConfig config = clientAcceptor.getSessionConfig();
	config.setReuseAddress(true);
	config.setIdleTime(IdleStatus.READER_IDLE, idleTime);// 读空闲 20秒
	config.setReadBufferSize(4096);// 默认2048
	config.setKeepAlive(true);
	config.setTcpNoDelay(true);// 禁用/开启nagle算法
	// 编解码
	chain.addLast("coder", new ProtocolCodecFilter(new MessageCodecFactory()));
	// 日志
	chain.addLast("logger", new LoggingFilter());
	// 业务逻辑处理线程池
	chain.addLast("threadPool", new ExecutorFilter());
}
 

import org.apache.mina.transport.socket.nio.NioSocketAcceptor; //导入依赖的package包/类
public static void run_startup_configurations() {
    autoPaoDian = Integer.parseInt(ServerProperties.getProperty("autoPaoDian", "1"));
    port = Short.parseShort(ServerProperties.getProperty("cashshop.port", String.valueOf(DEFAULT_PORT)));
    ip = ServerProperties.getProperty("world.host", ServerConstants.IP) + ":" + port;

    IoBuffer.setUseDirectBuffer(false);
    IoBuffer.setAllocator(new SimpleBufferAllocator());

    acceptor = new NioSocketAcceptor();
    acceptor.getFilterChain().addLast("codec", new ProtocolCodecFilter(new MapleCodecFactory()));
    acceptor.getSessionConfig().setIdleTime(IdleStatus.BOTH_IDLE, 30);
    players = new PlayerStorage(MapleServerHandler.CASH_SHOP_SERVER);
    try {
        acceptor.setHandler(new MapleServerHandler(MapleServerHandler.CASH_SHOP_SERVER));
        acceptor.bind(new InetSocketAddress(port));
        ((SocketSessionConfig) acceptor.getSessionConfig()).setTcpNoDelay(true);

        FileoutputUtil.log("完成!");
        FileoutputUtil.log("商城伺服器正在监听" + port + "端口\r\n");
    } catch (IOException e) {
        FileoutputUtil.log("失败!");
        System.err.println("无法绑定" + port + "端口");
        throw new RuntimeException("绑定端口失败.", e);
    }
}