Java NetworkChannel类代码示例

import java.nio.channels.NetworkChannel; //导入依赖的package包/类
@Override
protected FrontendConnection getConnection(NetworkChannel channel) throws IOException {
    SystemConfig sys = MycatServer.getInstance().getConfig().getSystem();
    ServerConnection c = new ServerConnection(channel);
    MycatServer.getInstance().getConfig().setSocketParams(c, true);
    c.setPrivileges(MycatPrivileges.instance());
    // 每个新的ServerConnection都会绑定
    // 一个新的ServerQueryHandler负责处理sql指令
    c.setQueryHandler(new ServerQueryHandler(c));
    // 一个ServerLoadDataInfileHandler负责处理文件载入命令
    c.setLoadDataInfileHandler(new ServerLoadDataInfileHandler(c));
    c.setPrepareHandler(new ServerPrepareHandler(c));
    c.setTxIsolation(sys.getTxIsolation());
    // 一个session负责处理事务
    c.setSession2(new NonBlockingSession(c));
    return c;
}
 

import java.nio.channels.NetworkChannel; //导入依赖的package包/类
public void setSocketParams(Connection con, boolean isFrontChannel) throws IOException {
	int sorcvbuf = 0;
	int sosndbuf = 0;
	int soNoDelay = 0;
	if (isFrontChannel) {
		sorcvbuf = netConfig.getFrontsocketsorcvbuf();
		sosndbuf = netConfig.getFrontsocketsosndbuf();
		soNoDelay = netConfig.getFrontSocketNoDelay();
	} else {
		sorcvbuf = netConfig.getBacksocketsorcvbuf();
		sosndbuf = netConfig.getBacksocketsosndbuf();
		soNoDelay = netConfig.getBackSocketNoDelay();
	}
	NetworkChannel channel = con.getChannel();
	channel.setOption(StandardSocketOptions.SO_RCVBUF, sorcvbuf);
	channel.setOption(StandardSocketOptions.SO_SNDBUF, sosndbuf);
	channel.setOption(StandardSocketOptions.TCP_NODELAY, soNoDelay == 1);
	channel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
	channel.setOption(StandardSocketOptions.SO_KEEPALIVE, true);
}
 

import java.nio.channels.NetworkChannel; //导入依赖的package包/类
@SuppressWarnings({"unchecked", "rawtypes"})
public MySQLConnection make(MySQLDataSource pool, ResponseHandler handler,
                            String schema) throws IOException {

    DBHostConfig dsc = pool.getConfig();
    NetworkChannel channel = openSocketChannel(DbleServer.getInstance().isAIO());

    MySQLConnection c = new MySQLConnection(channel, pool.isReadNode());
    c.setSocketParams(false);
    c.setHost(dsc.getIp());
    c.setPort(dsc.getPort());
    c.setUser(dsc.getUser());
    c.setPassword(dsc.getPassword());
    c.setSchema(schema);
    c.setHandler(new MySQLConnectionAuthenticator(c, handler));
    c.setPool(pool);
    c.setIdleTimeout(pool.getConfig().getIdleTimeout());
    if (channel instanceof AsynchronousSocketChannel) {
        ((AsynchronousSocketChannel) channel).connect(
                new InetSocketAddress(dsc.getIp(), dsc.getPort()), c,
                (CompletionHandler) DbleServer.getInstance().getConnector());
    } else {
        ((NIOConnector) DbleServer.getInstance().getConnector()).postConnect(c);
    }
    return c;
}
 

import java.nio.channels.NetworkChannel; //导入依赖的package包/类
public void setSocketParams(Connection con, boolean isFrontChannel) throws IOException {
	int sorcvbuf = 0;
	int sosndbuf = 0;
	int soNoDelay = 0;
	if (isFrontChannel) {
		sorcvbuf = netConfig.getFrontsocketsorcvbuf();
		sosndbuf = netConfig.getFrontsocketsosndbuf();
		soNoDelay = netConfig.getFrontSocketNoDelay();
	} else {
		sorcvbuf = netConfig.getBacksocketsorcvbuf();
		sosndbuf = netConfig.getBacksocketsosndbuf();
		soNoDelay = netConfig.getBackSocketNoDelay();
	}
	NetworkChannel channel = con.getChannel();
	channel.setOption(StandardSocketOptions.SO_RCVBUF, sorcvbuf);
	channel.setOption(StandardSocketOptions.SO_SNDBUF, sosndbuf);
	channel.setOption(StandardSocketOptions.TCP_NODELAY, soNoDelay == 1);
	channel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
	channel.setOption(StandardSocketOptions.SO_KEEPALIVE, true);

	con.setMaxPacketSize(netConfig.getMaxPacketSize());
	con.setPacketHeaderSize(netConfig.getPacketHeaderSize());

}
 

import java.nio.channels.NetworkChannel; //导入依赖的package包/类
/**
 * {@inheritDoc}
 */
@Override
public NetworkChannel bind(final SocketAddress local, final int backlog) throws IOException {
	if (!(local instanceof GroupSocketAddress)) {
		throw new IllegalArgumentException("GroupChannel can only bind to a GroupSocketAddress");
	}
	final GroupSocketAddress group = (GroupSocketAddress) local;
	if (group.size() != channels.length) {
		throw new IllegalArgumentException("local.size() != channels.length");
	}
	final int k = channels.length;
	for (int i = 0; i < k; i++) {
		channels[i].bind(group.get(i), backlog);
	}
	return this;
}
 

import java.nio.channels.NetworkChannel; //导入依赖的package包/类
@Override
protected FrontendConnection getConnection(NetworkChannel channel) throws IOException {
    ManagerConnection c = new ManagerConnection(channel);
    MycatServer.getInstance().getConfig().setSocketParams(c, true);
    c.setPrivileges(MycatPrivileges.instance());
    c.setQueryHandler(new ManagerQueryHandler(c));
    return c;
}
 

import java.nio.channels.NetworkChannel; //导入依赖的package包/类
public void setSocketParams(AbstractConnection con, boolean isFrontChannel)
		throws IOException {
	
	int sorcvbuf = 0;
	int sosndbuf = 0;
	int soNoDelay = 0;
	if ( isFrontChannel ) {
		sorcvbuf = system.getFrontsocketsorcvbuf();
		sosndbuf = system.getFrontsocketsosndbuf();
		soNoDelay = system.getFrontSocketNoDelay();
	} else {
		sorcvbuf = system.getBacksocketsorcvbuf();
		sosndbuf = system.getBacksocketsosndbuf();
		soNoDelay = system.getBackSocketNoDelay();
	}
	
	NetworkChannel channel = con.getChannel();
	channel.setOption(StandardSocketOptions.SO_RCVBUF, sorcvbuf);
	channel.setOption(StandardSocketOptions.SO_SNDBUF, sosndbuf);
	channel.setOption(StandardSocketOptions.TCP_NODELAY, soNoDelay == 1);
	channel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
	channel.setOption(StandardSocketOptions.SO_KEEPALIVE, true);
	
	con.setMaxPacketSize(system.getMaxPacketSize());
	con.setPacketHeaderSize(system.getPacketHeaderSize());
	con.setIdleTimeout(system.getIdleTimeout());
	con.setCharset(system.getCharset());

}
 

import java.nio.channels.NetworkChannel; //导入依赖的package包/类
protected NetworkChannel openSocketChannel(boolean isAIO)
		throws IOException {
	if (isAIO) {
		return AsynchronousSocketChannel
               .open(MycatServer.getInstance().getNextAsyncChannelGroup());
	} else {
		SocketChannel channel = null;
		channel = SocketChannel.open();
		channel.configureBlocking(false);
		return channel;
	}

}
 

import java.nio.channels.NetworkChannel; //导入依赖的package包/类
public FrontendConnection make(NetworkChannel channel) throws IOException {
	channel.setOption(StandardSocketOptions.SO_REUSEADDR, true);
	channel.setOption(StandardSocketOptions.SO_KEEPALIVE, true);

	FrontendConnection c = getConnection(channel);
	MycatServer.getInstance().getConfig().setSocketParams(c, true);
	return c;
}
 

import java.nio.channels.NetworkChannel; //导入依赖的package包/类
public AbstractConnection(NetworkChannel channel) {
	this.channel = channel;
	boolean isAIO = (channel instanceof AsynchronousChannel);
	if (isAIO) {
		socketWR = new AIOSocketWR(this);
	} else {
		socketWR = new NIOSocketWR(this);
	}
	this.isClosed = new AtomicBoolean(false);
	this.startupTime = TimeUtil.currentTimeMillis();
	this.lastReadTime = startupTime;
	this.lastWriteTime = startupTime;
}
 

import java.nio.channels.NetworkChannel; //导入依赖的package包/类
private void accept(NetworkChannel channel, Long id) {
	try {
		FrontendConnection c = factory.make(channel);
		c.setAccepted(true);
		c.setId(id);
		NIOProcessor processor = MycatServer.getInstance().nextProcessor();
		c.setProcessor(processor);
		c.register();
	} catch (Exception e) {
	    LOGGER.error("AioAcceptorError", e);
		closeChannel(channel);
	}
}
 

import java.nio.channels.NetworkChannel; //导入依赖的package包/类
private static void closeChannel(NetworkChannel channel) {
	if (channel == null) {
		return;
	}
	try {
		channel.close();
	} catch (IOException e) {
        LOGGER.error("AioAcceptorError", e);
	}
}
 

import java.nio.channels.NetworkChannel; //导入依赖的package包/类
@SuppressWarnings({ "unchecked", "rawtypes" })
public PostgreSQLBackendConnection make(PostgreSQLDataSource pool,
		ResponseHandler handler, final String schema) throws IOException {

	final DBHostConfig dsc = pool.getConfig();
	NetworkChannel channel = this.openSocketChannel(MycatServer
			.getInstance().isAIO());

	final PostgreSQLBackendConnection c = new PostgreSQLBackendConnection(
			channel, pool.isReadNode());
	MycatServer.getInstance().getConfig().setSocketParams(c, false);
	// 设置NIOHandler
	c.setHandler(new PostgreSQLBackendConnectionHandler(c));
	c.setHost(dsc.getIp());
	c.setPort(dsc.getPort());
	c.setUser(dsc.getUser());
	c.setPassword(dsc.getPassword());
	c.setSchema(schema);
	c.setPool(pool);
	c.setResponseHandler(handler);
	c.setIdleTimeout(pool.getConfig().getIdleTimeout());
	if (channel instanceof AsynchronousSocketChannel) {
		((AsynchronousSocketChannel) channel).connect(
				new InetSocketAddress(dsc.getIp(), dsc.getPort()), c,
				(CompletionHandler) MycatServer.getInstance()
						.getConnector());
	} else {
		((NIOConnector) MycatServer.getInstance().getConnector())
				.postConnect(c);

	}
	return c;
}
 

import java.nio.channels.NetworkChannel; //导入依赖的package包/类
public MySQLConnection(NetworkChannel channel, boolean fromSlaveDB) {
	super(channel);
	this.clientFlags = CLIENT_FLAGS;
	this.lastTime = TimeUtil.currentTimeMillis();
	this.isQuit = new AtomicBoolean(false);
	this.autocommit = true;
	this.fromSlaveDB = fromSlaveDB;
	// 设为默认值，免得每个初始化好的连接都要去同步一下
	this.txIsolation = MycatServer.getInstance().getConfig().getSystem().getTxIsolation();
}
 

import java.nio.channels.NetworkChannel; //导入依赖的package包/类
@SuppressWarnings({ "unchecked", "rawtypes" })
// 这里传入的ResponseHandler为DelegateResponseHandler，在连接建立验证之后，会调用
public MySQLConnection make(MySQLDataSource pool, ResponseHandler handler,
		String schema) throws IOException {
	// DBHost配置
	DBHostConfig dsc = pool.getConfig();
	// 根据是否为NIO返回SocketChannel或者AIO的AsynchronousSocketChannel
	NetworkChannel channel = openSocketChannel(MycatServer.getInstance()
			.isAIO());
	// 新建MySQLConnection
	MySQLConnection c = new MySQLConnection(channel, pool.isReadNode());
	// 根据配置初始化MySQLConnection
	MycatServer.getInstance().getConfig().setSocketParams(c, false);
	c.setHost(dsc.getIp());
	c.setPort(dsc.getPort());
	c.setUser(dsc.getUser());
	c.setPassword(dsc.getPassword());
	c.setSchema(schema);
	// 目前实际连接还未建立，handler为MySQL连接认证MySQLConnectionAuthenticatorHandler
	c.setHandler(new MySQLConnectionAuthenticatorHandler(c, handler));
	c.setPool(pool);
	c.setIdleTimeout(pool.getConfig().getIdleTimeout());
	// AIO和NIO连接方式建立实际的MySQL连接
	if (channel instanceof AsynchronousSocketChannel) {
		((AsynchronousSocketChannel) channel).connect(
				new InetSocketAddress(dsc.getIp(), dsc.getPort()), c,
				(CompletionHandler) MycatServer.getInstance()
						.getConnector());
	} else {
		// 通过NIOConnector建立连接
		// 通过NIOConnector建立实际连接的过程与前端连接的建立相似，
		// 也是先放在队列中，之后由NIOConnector去建立连接
		((NIOConnector) MycatServer.getInstance().getConnector())
				.postConnect(c);

	}
	return c;
}