Java RuntimeIoException类代码示例

import org.apache.mina.core.RuntimeIoException; //导入依赖的package包/类
public Object getMessage() {
    if (isDone()) {
        Object v = getValue();
        if (v == CLOSED) {
            return null;
        }

        if (v instanceof ExceptionHolder) {
            v = ((ExceptionHolder) v).exception;
            if (v instanceof RuntimeException) {
                throw (RuntimeException) v;
            }
            if (v instanceof Error) {
                throw (Error) v;
            }
            if (v instanceof IOException || v instanceof Exception) {
                throw new RuntimeIoException((Exception) v);
            }
        }

        return v;
    }

    return null;
}
 

import org.apache.mina.core.RuntimeIoException; //导入依赖的package包/类
/**
 * Attempt to connect to the info server.
 */
public void connect()
{
	try
	{
		ConnectFuture future = connector.connect(new InetSocketAddress(IP, PORT));
		future.awaitUninterruptibly(AWAIT_TIME);

		IoSession session = future.getSession();
		session.getFilterChain().addFirst("protocol", new ProtocolCodecFilter(factory));
		state = State.READY;
		this.onConnect(session);
	}
	catch(RuntimeIoException e)
	{
		this.onFailure(e);
	}
}
 

import org.apache.mina.core.RuntimeIoException; //导入依赖的package包/类
public static void main(String[] args) {
	NioSocketConnector connector = new NioSocketConnector(); //TCP Connector
	connector.getFilterChain().addLast("logging", new LoggingFilter());
	connector.getFilterChain().addLast("codec",new ProtocolCodecFilter(new ObjectSerializationCodecFactory()));
    connector.getFilterChain().addLast("mdc", new MdcInjectionFilter());
	connector.setHandler(new HelloClientHandler());
    IoSession session;

    for (;;) {
        try {
            ConnectFuture future = connector.connect(new InetSocketAddress(HOSTNAME, PORT));
            future.awaitUninterruptibly();
            session = future.getSession();
            break;
        } catch (RuntimeIoException e) {
            System.err.println("Failed to connect.");
            e.printStackTrace();
        }
    }
    session.getCloseFuture().awaitUninterruptibly();
    connector.dispose();
}
 

import org.apache.mina.core.RuntimeIoException; //导入依赖的package包/类
/**
 *
 * Creates a new instance of NioProcessor.
 *
 * @param executor
 */
public NioProcessor(Executor executor) {
    super(executor);

    try {
        // Open a new selector
        selector = Selector.open();
    } catch (IOException e) {
        throw new RuntimeIoException("Failed to open a selector.", e);
    }
}
 

import org.apache.mina.core.RuntimeIoException; //导入依赖的package包/类
/**
 * Tells if SO_BROADCAST is enabled.
 * 
 * @return <code>true</code> if SO_BROADCAST is enabled
 * @throws RuntimeIoException If the socket is closed or if we get an
 * {@link SocketException} 
 */
public boolean isBroadcast() {
    try {
        return channel.socket().getBroadcast();
    } catch (SocketException e) {
        throw new RuntimeIoException(e);
    }
}
 

import org.apache.mina.core.RuntimeIoException; //导入依赖的package包/类
public void setBroadcast(boolean broadcast) {
    try {
        channel.socket().setBroadcast(broadcast);
    } catch (SocketException e) {
        throw new RuntimeIoException(e);
    }
}
 

import org.apache.mina.core.RuntimeIoException; //导入依赖的package包/类
/**
 * 
 * @throws RuntimeIoException If the socket is closed or if we get an
 * {@link SocketException} 
 */
public int getSendBufferSize() {
    try {
        return channel.socket().getSendBufferSize();
    } catch (SocketException e) {
        throw new RuntimeIoException(e);
    }
}
 

import org.apache.mina.core.RuntimeIoException; //导入依赖的package包/类
/**
 * 
 * @throws RuntimeIoException If the socket is closed or if we get an
 * {@link SocketException} 
 */
public void setSendBufferSize(int sendBufferSize) {
    try {
        channel.socket().setSendBufferSize(sendBufferSize);
    } catch (SocketException e) {
        throw new RuntimeIoException(e);
    }
}
 

import org.apache.mina.core.RuntimeIoException; //导入依赖的package包/类
/**
 * Tells if SO_REUSEADDR is enabled.
 * 
 * @return <code>true</code> if SO_REUSEADDR is enabled
 * @throws RuntimeIoException If the socket is closed or if we get an
 * {@link SocketException} 
 */
public boolean isReuseAddress() {
    try {
        return channel.socket().getReuseAddress();
    } catch (SocketException e) {
        throw new RuntimeIoException(e);
    }
}
 

import org.apache.mina.core.RuntimeIoException; //导入依赖的package包/类
/**
 * 
 * @throws RuntimeIoException If the socket is closed or if we get an
 * {@link SocketException} 
 */
public void setReuseAddress(boolean reuseAddress) {
    try {
        channel.socket().setReuseAddress(reuseAddress);
    } catch (SocketException e) {
        throw new RuntimeIoException(e);
    }
}
 

import org.apache.mina.core.RuntimeIoException; //导入依赖的package包/类
/**
 * {@inheritDoc}
 * @throws RuntimeIoException If the socket is closed or if we get an
 * {@link SocketException} 
 */
public void setTrafficClass(int trafficClass) {
    try {
        channel.socket().setTrafficClass(trafficClass);
    } catch (SocketException e) {
        throw new RuntimeIoException(e);
    }
}
 

import org.apache.mina.core.RuntimeIoException; //导入依赖的package包/类
public boolean isKeepAlive() {
    try {
        return getSocket().getKeepAlive();
    } catch (SocketException e) {
        throw new RuntimeIoException(e);
    }
}
 

import org.apache.mina.core.RuntimeIoException; //导入依赖的package包/类
public void setKeepAlive(boolean on) {
    try {
        getSocket().setKeepAlive(on);
    } catch (SocketException e) {
        throw new RuntimeIoException(e);
    }
}
 

import org.apache.mina.core.RuntimeIoException; //导入依赖的package包/类
public boolean isOobInline() {
    try {
        return getSocket().getOOBInline();
    } catch (SocketException e) {
        throw new RuntimeIoException(e);
    }
}
 

import org.apache.mina.core.RuntimeIoException; //导入依赖的package包/类
public void setOobInline(boolean on) {
    try {
        getSocket().setOOBInline(on);
    } catch (SocketException e) {
        throw new RuntimeIoException(e);
    }
}