org.apache.mina.core.service.IoHandler Java Examples

/**
   * 初始化tcp连接
   * @param clientProtocolHandler
   */
  private void init(IoHandler clientProtocolHandler) {
      connector = new NioSocketConnector();
      DefaultIoFilterChainBuilder chain = connector.getFilterChain();
      chain.addLast("codec", codecFilter);
      if(filters != null){
          filters.forEach((key, filter)->{
		if("ssl".equalsIgnoreCase(key) || "tls".equalsIgnoreCase(key)){	//ssl过滤器必须添加到首部
			chain.addFirst(key, filter);
		}else{
			chain.addLast(key, filter);
		}
	});
}
      connector.setHandler(clientProtocolHandler);
      connector.setConnectTimeoutMillis(60000L);
      connector.setConnectTimeoutCheckInterval(10000);
  }
 

public  void startListner(IoHandler iohandler,int listenPort) throws Exception{
	acceptor = new NioSocketAcceptor();
	acceptor.setBacklog(100);
	acceptor.setReuseAddress(true);
	acceptor.setHandler(iohandler);
	
       DefaultIoFilterChainBuilder chain = acceptor.getFilterChain();
       IoFilter protocol = new ProtocolCodecFilter(new GameProtocolcodecFactory());
       chain.addLast("codec", protocol);
	threadpool = new OrderedThreadPoolExecutor(500);
	threadpool.setThreadFactory(new ServerThreadFactory("OrderedThreadPool"));
	chain.addLast("threadPool", new ExecutorFilter(threadpool));
	
	int recsize = 5120;
	int sendsize = 40480;                                                                                         
	int timeout = 10;
	SocketSessionConfig sc = acceptor.getSessionConfig();
	sc.setReuseAddress(true);// 设置每一个非主监听连接的端口可以重用
	sc.setReceiveBufferSize(recsize);// 设置输入缓冲区的大小
	sc.setSendBufferSize(sendsize);// 设置输出缓冲区的大小
	sc.setTcpNoDelay(true);// flush函数的调用 设置为非延迟发送，为true则不组装成大包发送，收到东西马上发出   
	sc.setSoLinger(0);
	sc.setIdleTime(IdleStatus.READER_IDLE, timeout);
	acceptor.bind(new InetSocketAddress(listenPort));
}
 

/**
 * Initialize the MINA server.
 */
public TCPTestServer(int port, boolean loopback, IoHandler handler) throws Exception {

    acceptor = new NioSocketAcceptor();

    IoFilter tupleEncoder = new ProtocolCodecFilter(new TestTupleEncoder(),
            new TestTupleDecoder());

    acceptor.getFilterChain().addLast("testtuples", tupleEncoder);

    acceptor.setHandler(handler);

    // Get the bind address now so the majority of
    // errors are caught at initialization time.
    bindAddress = new InetSocketAddress(
            loopback ? InetAddress.getLoopbackAddress() : InetAddress.getLocalHost(), port);
}
 

/**
 * Connects to the specified <code>address</code>.  If communication starts
 * successfully, events are fired to the connector's <code>handler</code>.
 * 
 * @param remoteAddress the remote address to connect to
 * @param localAddress the local address
 * @param sessionInitializer the session initializer
 * @return {@link ConnectFuture} that will tell the result of the connection attempt
 */
@SuppressWarnings("unchecked")
@Override
protected ConnectFuture connect0(final SocketAddress remoteAddress, final SocketAddress localAddress,
        final IoSessionInitializer<? extends ConnectFuture> sessionInitializer) {
    if (!proxyIoSession.isReconnectionNeeded()) {
        // First connection
        IoHandler handler = getHandler();
        if (!(handler instanceof AbstractProxyIoHandler)) {
            throw new IllegalArgumentException("IoHandler must be an instance of AbstractProxyIoHandler");
        }

        connector.setHandler(handler);
        future = new DefaultConnectFuture();
    }

    ConnectFuture conFuture = connector.connect(proxyIoSession.getProxyAddress(), new ProxyIoSessionInitializer(
            sessionInitializer, proxyIoSession));

    // If proxy does not use reconnection like socks the connector's 
    // future is returned. If we're in the middle of a reconnection
    // then we send back the connector's future which is only used
    // internally while <code>future</code> will be used to notify
    // the user of the connection state.
    if (proxyIoSession.getRequest() instanceof SocksProxyRequest || proxyIoSession.isReconnectionNeeded()) {
        return conFuture;
    }

    return future;
}
 

/**
 * 初始化tcp连接
 * 
 * @param clientProtocolHandler
 */
private void init(IoHandler clientProtocolHandler) {
       connector = new NioDatagramConnector();
       connector.getFilterChain().addLast("codec", codecFilter);
       connector.setHandler(clientProtocolHandler);
	connector.setConnectTimeoutMillis(60000L);
	connector.setConnectTimeoutCheckInterval(10000);
}
 

/**
 * <p>Constructor for MinaUdpClient.</p>
 *
 * @param minaClientConfig a {@link com.jzy.game.engine.mina.config.MinaClientConfig} object.
 * @param clientProtocolHandler a {@link org.apache.mina.core.service.IoHandler} object.
 * @param factory a {@link com.jzy.game.engine.mina.code.ProtocolCodecFactoryImpl} object.
 */
public MinaUdpClient(MinaClientConfig minaClientConfig, IoHandler clientProtocolHandler,
		ProtocolCodecFactoryImpl factory) {
       this.minaClientConfig = minaClientConfig;
	this.clientProtocolHandler = clientProtocolHandler;
	this.factory = factory;
       codecFilter =new ProtocolCodecFilter(this.factory);
	init(this.clientProtocolHandler);
	setMinaClientConfig(minaClientConfig);
}
 

private IoHandler createClientHandler() {
	String clzName = AppInfo.get("sumk.rpc.clientHandler", "org.yx.rpc.client.ClientHandler");
	try {
		return (IoHandler) Loader.newInstance(clzName, null, null);
	} catch (Exception e) {
		Logs.rpc().error("初始化clientHandler失败", e);
		throw ExceptionUtil.toRuntimeException(e);
	}
}
 

private IoHandler createServerHandler(List<RequestHandler> handlers) {
	String clzName = AppInfo.get("sumk.rpc.serverHandler", "org.yx.rpc.server.ServerHandler");
	try {
		return (IoHandler) Loader.newInstance(clzName, new Object[] { handlers }, new Class<?>[] { List.class });
	} catch (Exception e) {
		Logs.rpc().error("初始化serverHandler失败", e);
		throw ExceptionUtil.toRuntimeException(e);
	}
}
 

/**
 * 添加客户端
 *
 * @param service a {@link com.jzy.game.engine.mina.service.MinaClientService} object.
 * @param config a {@link com.jzy.game.engine.mina.config.MinaClientConfig} object.
 * @param clientProtocolHandler a {@link org.apache.mina.core.service.IoHandler} object.
 * @param factory a {@link com.jzy.game.engine.mina.code.ProtocolCodecFactoryImpl} object.
 */
public void addTcpClient(MinaClientService service, MinaClientConfig config, IoHandler clientProtocolHandler,
		ProtocolCodecFactoryImpl factory) {
	MinaTcpClient client = null;
	if (tcpClients.containsKey(config.getId())) {
		client = tcpClients.get(config.getId());
		client.setMinaClientConfig(config);
		return;
	}
	client = new MinaTcpClient(service, config, clientProtocolHandler, factory);
	tcpClients.put(config.getId(), client);
}
 

/**
 * 添加客户端
 *
 * @param service a {@link com.jzy.game.engine.mina.service.MinaClientService} object.
 * @param config a {@link com.jzy.game.engine.mina.config.MinaClientConfig} object.
 * @param clientProtocolHandler a {@link org.apache.mina.core.service.IoHandler} object.
 */
public void addTcpClient(MinaClientService service, MinaClientConfig config, IoHandler clientProtocolHandler) {
	MinaTcpClient client = null;
	if (tcpClients.containsKey(config.getId())) {
		client = tcpClients.get(config.getId());
		client.setMinaClientConfig(config);
		return;
	}
	client = new MinaTcpClient(service, config, clientProtocolHandler);
	tcpClients.put(config.getId(), client);
}
 

/**
 * Sets the {@link IoHandler} which handles this session.
 */
public void setHandler(IoHandler handler) {
    if (handler == null) {
        throw new IllegalArgumentException("handler");
    }

    this.handler = handler;
}
 

VmPipeSession(IoService service, IoServiceListenerSupport serviceListeners, VmPipeAddress localAddress,
        IoHandler handler, VmPipe remoteEntry) {
    super(service);
    config = new DefaultVmPipeSessionConfig();
    this.serviceListeners = serviceListeners;
    lock = new ReentrantLock();
    this.localAddress = localAddress;
    remoteAddress = serviceAddress = remoteEntry.getAddress();
    filterChain = new VmPipeFilterChain(this);
    receivedMessageQueue = new LinkedBlockingQueue<Object>();

    remoteSession = new VmPipeSession(this, remoteEntry);
}
 

public GameClient(String remoteHost, int remotePort, IoHandler handler) {
	this.remoteHost = remoteHost;
	this.remotePort = remotePort;
	if ( handler == null ) {
		this.handler = this;
	} else {
		this.handler = handler;
	}
}
 

/**
 * Create a new Client
 * @param filter
 * @param handler
 * @param remoteHost
 * @param remotePort
 */
public SimpleClient(IoFilter filter, IoHandler handler, 
		String remoteHost, int remotePort) {
	this.ioFilter = filter;
	this.ioHandler = handler;
	this.remoteHost = remoteHost;
	this.remotePort = remotePort;
	this.connectKey = StringUtil.concat(remoteHost, Constant.COLON, remotePort);
	this.clientNo = SimpleClient.totalClientNo++;
}
 

public ReloadProtocolCodecFilter(String ioFilterClassName, String ioHandlerClassName){
	try {
		this.ioFilterClassName = ioFilterClassName;
		this.ioHandlerClassName = ioHandlerClassName;
		this.classLoader = ReloadClassLoader.currentClassLoader();
		Class ioFilterClass = this.classLoader.loadClass(ioFilterClassName);
		Class ioHandlerClass = this.classLoader.loadClass(ioHandlerClassName);
		this.ioFilter = (IoFilter)ioFilterClass.newInstance();
		this.ioHandler = (IoHandler)ioHandlerClass.newInstance();
	} catch (Throwable e) {
		log.error("Failed to create ReloadProtocolCodecFilter", e);
	}
}
 

/**
 * 使用默认消息解码工厂
 *
 * @param service a {@link com.jzy.game.engine.mina.service.MinaClientService} object.
 * @param minaClientConfig a {@link com.jzy.game.engine.mina.config.MinaClientConfig} object.
 * @param clientProtocolHandler a {@link org.apache.mina.core.service.IoHandler} object.
 */
public MinaTcpClient(MinaClientService service, MinaClientConfig minaClientConfig, IoHandler clientProtocolHandler) {
    factory =new DefaultProtocolCodecFactory();
    codecFilter = new ProtocolCodecFilter(factory);
    this.service = service;
    this.clientProtocolHandler = clientProtocolHandler;
    init(clientProtocolHandler);
    setMinaClientConfig(minaClientConfig);
}
 

/**
 * <p>Constructor for MinaTcpClient.</p>
 *
 * @param service a {@link com.jzy.game.engine.mina.service.MinaClientService} object.
 * @param minaClientConfig a {@link com.jzy.game.engine.mina.config.MinaClientConfig} object.
 * @param clientProtocolHandler a {@link org.apache.mina.core.service.IoHandler} object.
 * @param factory a {@link com.jzy.game.engine.mina.code.ProtocolCodecFactoryImpl} object.
 */
public MinaTcpClient(MinaClientService service, MinaClientConfig minaClientConfig, IoHandler clientProtocolHandler, ProtocolCodecFactoryImpl factory) {
    this.factory=factory;
    codecFilter = new ProtocolCodecFilter(factory);
    this.service = service;
    this.clientProtocolHandler = clientProtocolHandler;
    init(clientProtocolHandler);
    setMinaClientConfig(minaClientConfig);
}
 

/**
 * <p>Constructor for MinaTcpClient.</p>
 *
 * @param service a {@link com.jzy.game.engine.mina.service.MinaClientService} object.
 * @param minaClientConfig a {@link com.jzy.game.engine.mina.config.MinaClientConfig} object.
 * @param clientProtocolHandler a {@link org.apache.mina.core.service.IoHandler} object.
 * @param factory a {@link com.jzy.game.engine.mina.code.ProtocolCodecFactoryImpl} object.
 * @param filters a {@link java.util.Map} object.
 */
public MinaTcpClient(MinaClientService service, MinaClientConfig minaClientConfig, IoHandler clientProtocolHandler, ProtocolCodecFactoryImpl factory,Map<String, IoFilter> filters) {
    this.factory=factory;
    codecFilter = new ProtocolCodecFilter(factory);
    this.service = service;
    this.clientProtocolHandler = clientProtocolHandler;
    this.filters=filters;
    init(clientProtocolHandler);
    setMinaClientConfig(minaClientConfig);
}
 

/**
 * Reload the internal instances.
 */
public void reload() {
	try {
		this.classLoader = ReloadClassLoader.newClassloader(this.classLoader.getClasspathURLs());
		Class ioFilterClass = this.classLoader.loadClass(ioFilterClassName);
		Class ioHandlerClass = this.classLoader.loadClass(ioHandlerClassName);
		this.ioFilter = (IoFilter)ioFilterClass.newInstance();
		this.ioHandler = (IoHandler)ioHandlerClass.newInstance();
	} catch (Throwable e) {
		log.error("Reload error", e);
	}
}
 

@Override
public IoHandler create ( final ClientBaseConnection clientBaseConnection ) throws Exception
{
    return new ClientProtocolConnectionHandler ( clientBaseConnection, this.protocolConfigurationFactory.createConfiguration ( true ) );
}
 

public IoHandler getHandler() {
    return handler;
}
 

public IoHandler getHandler()
{
    return handler;
}
 

@Override
public IoHandler create ( final ClientBaseConnection connection ) throws Exception
{
    return new ClientConnectionHandler ( connection );
}
 

public IoHandler getHandler()
{
    return handler;
}
 

public void setHandler(IoHandler handler) {
       nioSocketAcceptor.setHandler(handler);
}
 

@Override
public IoHandler getHandler() {
    // TODO Auto-generated method stub
    return null;
}
 

@Override
public IoHandler getHandler() {
	return service.getHandler();
}
 

public IoHandler getHandler() {
    return handler;
}
 

VmPipe(VmPipeAcceptor acceptor, VmPipeAddress address, IoHandler handler, IoServiceListenerSupport listeners) {
    this.acceptor = acceptor;
    this.address = address;
    this.handler = handler;
    this.listeners = listeners;
}
 

public void setHandler(IoHandler handler) {
       nioSocketConnector.setHandler(handler);
}