免责声明 - 我不是Java程序员。我可能需要根据给出的任何建议做作业，但我很乐意这样做：）
也就是说，我写了一个完整的数据库支持的套接字服务器，它对我的小测试工作得很好，现在我已经准备好进行初始发布了。因为我不太了解Java / Netty / BoneCP-我不知道我是否在某个地方犯了一个根本错误，这个错误会在它出现之前伤害我的服务器。
例如，我不知道执行者组究竟做了什么以及我应该使用什么号码。是否可以将BoneCP实现为单例，是否真的有必要为每个数据库查询使用所有try / catch？等
我试图将我的整个服务器减少到一个基本的例子，它的操作方式与真实的一样（我在文本中删除了所有内容，没有在java本身进行测试，所以请原谅任何语法错误）。
基本思想是客户端可以连接，与服务器交换消息，断开其他客户端，并无限期保持连接，直到他们选择或被迫断开连接。 （客户端将每分钟发送一次ping消息以保持连接活动）
除了测试这个例子之外，唯一的主要区别是clientID是如何设置的（安全地假设它对每个连接的客户端来说真的是唯一的），并且在检查值等时还有一些更多的业务逻辑。
底线 - 可以做些什么来改善这一点，以便它可以处理最多的并发用户？谢谢！
//MAIN
public class MainServer {
public static void main(String[] args) {
EdgeController edgeController = new EdgeController();
edgeController.connect();
}
}
//EdgeController
public class EdgeController {
public void connect() throws Exception {
ServerBootstrap b = new ServerBootstrap();
ChannelFuture f;
try {
b.group(new NioEventLoopGroup(), new NioEventLoopGroup())
.channel(NioServerSocketChannel.class)
.localAddress(9100)
.childOption(ChannelOption.TCP_NODELAY, true)
.childOption(ChannelOption.SO_KEEPALIVE, true)
.childHandler(new EdgeInitializer(new DefaultEventExecutorGroup(10)));
// Start the server.
f = b.bind().sync();
// Wait until the server socket is closed.
f.channel().closeFuture().sync();
} finally { //Not quite sure how to get here yet... but no matter
// Shut down all event loops to terminate all threads.
b.shutdown();
}
}
}
//EdgeInitializer
public class EdgeInitializer extends ChannelInitializer<SocketChannel> {
private EventExecutorGroup executorGroup;
public EdgeInitializer(EventExecutorGroup _executorGroup) {
executorGroup = _executorGroup;
}
@Override
public void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast("idleStateHandler", new IdleStateHandler(200,0,0));
pipeline.addLast("idleStateEventHandler", new EdgeIdleHandler());
pipeline.addLast("framer", new DelimiterBasedFrameDecoder(8192, Delimiters.nulDelimiter()));
pipeline.addLast("decoder", new StringDecoder(CharsetUtil.UTF_8));
pipeline.addLast("encoder", new StringEncoder(CharsetUtil.UTF_8));
pipeline.addLast(this.executorGroup, "handler", new EdgeHandler());
}
}
//EdgeIdleHandler
public class EdgeIdleHandler extends ChannelHandlerAdapter {
private static final Logger logger = Logger.getLogger( EdgeIdleHandler.class.getName());
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception{
if(evt instanceof IdleStateEvent) {
ctx.close();
}
}
private void trace(String msg) {
logger.log(Level.INFO, msg);
}
}
//DBController
public enum DBController {
INSTANCE;
private BoneCP connectionPool = null;
private BoneCPConfig connectionPoolConfig = null;
public boolean setupPool() {
boolean ret = true;
try {
Class.forName("com.mysql.jdbc.Driver");
connectionPoolConfig = new BoneCPConfig();
connectionPoolConfig.setJdbcUrl("jdbc:mysql://" + DB_HOST + ":" + DB_PORT + "/" + DB_NAME);
connectionPoolConfig.setUsername(DB_USER);
connectionPoolConfig.setPassword(DB_PASS);
try {
connectionPool = new BoneCP(connectionPoolConfig);
} catch(SQLException ex) {
ret = false;
}
} catch(ClassNotFoundException ex) {
ret = false;
}
return(ret);
}
public Connection getConnection() {
Connection ret;
try {
ret = connectionPool.getConnection();
} catch(SQLException ex) {
ret = null;
}
return(ret);
}
}
//EdgeHandler
public class EdgeHandler extends ChannelInboundMessageHandlerAdapter<String> {
private final Charset CHARSET_UTF8 = Charset.forName("UTF-8");
private long clientID;
static final ChannelGroup channels = new DefaultChannelGroup();
@Override
public void channelActive(ChannelHandlerContext ctx) throws Exception {
Connection dbConnection = null;
Statement statement = null;
ResultSet resultSet = null;
String query;
Boolean okToPlay = false;
//Check if status for ID #1 is true
try {
query = "SELECT `Status` FROM `ServerTable` WHERE `ID` = 1";
dbConnection = DBController.INSTANCE.getConnection();
statement = dbConnection.createStatement();
resultSet = statement.executeQuery(query);
if (resultSet.first()) {
if (resultSet.getInt("Status") > 0) {
okToPlay = true;
}
}
} catch (SQLException ex) {
okToPlay = false;
} finally {
if (resultSet != null) {
try {
resultSet.close();
} catch (SQLException logOrIgnore) {
}
}
if (statement != null) {
try {
statement.close();
} catch (SQLException logOrIgnore) {
}
}
if (dbConnection != null) {
try {
dbConnection.close();
} catch (SQLException logOrIgnore) {
}
}
}
if (okToPlay) {
//clientID = setClientID();
sendCommand(ctx, "HELLO", "WORLD");
} else {
sendErrorAndClose(ctx, "CLOSED");
}
}
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
channels.remove(ctx.channel());
}
@Override
public void messageReceived(ChannelHandlerContext ctx, String request) throws Exception {
// Generate and write a response.
String[] segments_whitespace;
String command, command_args;
if (request.length() > 0) {
segments_whitespace = request.split("\\s+");
if (segments_whitespace.length > 1) {
command = segments_whitespace[0];
command_args = segments_whitespace[1];
if (command.length() > 0 && command_args.length() > 0) {
switch (command) {
case "HOWDY": processHowdy(ctx, command_args); break;
default: break;
}
}
}
}
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
TraceUtils.severe("Unexpected exception from downstream - " + cause.toString());
ctx.close();
}
/* */
/* STATES - / CLIENT SETUP */
/* */
private void processHowdy(ChannelHandlerContext ctx, String howdyTo) {
Connection dbConnection = null;
Statement statement = null;
ResultSet resultSet = null;
String replyBack = null;
try {
dbConnection = DBController.INSTANCE.getConnection();
statement = dbConnection.createStatement();
resultSet = statement.executeQuery("SELECT `to` FROM `ServerTable` WHERE `To`='" + howdyTo + "'");
if (resultSet.first()) {
replyBack = "you!";
}
} catch (SQLException ex) {
} finally {
if (resultSet != null) {
try {
resultSet.close();
} catch (SQLException logOrIgnore) {
}
}
if (statement != null) {
try {
statement.close();
} catch (SQLException logOrIgnore) {
}
}
if (dbConnection != null) {
try {
dbConnection.close();
} catch (SQLException logOrIgnore) {
}
}
}
if (replyBack != null) {
sendCommand(ctx, "HOWDY", replyBack);
} else {
sendErrorAndClose(ctx, "ERROR");
}
}
private boolean closePeer(ChannelHandlerContext ctx, long peerClientID) {
boolean success = false;
ChannelFuture future;
for (Channel c : channels) {
if (c != ctx.channel()) {
if (c.pipeline().get(EdgeHandler.class).receiveClose(c, peerClientID)) {
success = true;
break;
}
}
}
return (success);
}
public boolean receiveClose(Channel thisChannel, long remoteClientID) {
ChannelFuture future;
boolean didclose = false;
long thisClientID = (clientID == null ? 0 : clientID);
if (remoteClientID == thisClientID) {
future = thisChannel.write("CLOSED BY PEER" + '\n');
future.addListener(ChannelFutureListener.CLOSE);
didclose = true;
}
return (didclose);
}
private ChannelFuture sendCommand(ChannelHandlerContext ctx, String cmd, String outgoingCommandArgs) {
return (ctx.write(cmd + " " + outgoingCommandArgs + '\n'));
}
private ChannelFuture sendErrorAndClose(ChannelHandlerContext ctx, String error_args) {
ChannelFuture future = sendCommand(ctx, "ERROR", error_args);
future.addListener(ChannelFutureListener.CLOSE);
return (future);
}
}
答案 0 :(得分：2)
当网络消息到达服务器时，它将被解码并将释放messageReceived事件。
如果你看一下你的管道，最后添加到管道的东西就是执行者。因为执行者将接收已解码的内容并将释放messageReceived事件。
执行者是事件的处理者，服务器将告诉他们通过它们发生的事件。因此，如何使用执行者是一个重要的主题。如果只有一个执行程序，并且因此，所有使用此相同执行程序的客户端都会有一个队列来使用同一个执行程序。
当执行者很多时，事件的处理时间会减少，因为没有任何等待免费执行者的事。
在您的代码中
new DefaultEventExecutorGroup（10）
表示此ServerBootstrap在其生命周期内仅使用10个执行程序。
在初始化新频道时，使用相同的执行者组：
pipeline.addLast（this.executorGroup，“handler”，new EdgeHandler（））;
因此每个新的客户端通道将使用相同的执行程序组（10个执行程序线程）。
如果10个线程能够正确处理传入事件，那就足够了。但是，如果我们可以看到消息被解码/编码但不能快速处理为事件，那就意味着需要增加它们的数量。
我们可以将执行者的数量从10增加到100：
new DefaultEventExecutorGroup（100）
如果有足够的CPU能力，这将更快地处理事件队列。
不应该做的是为每个新频道创建新的执行者：
pipeline.addLast（new DefaultEventExecutorGroup（10），“handler”，new EdgeHandler（））;
以上一行是为每个新频道创建一个新的执行者组，这将大大减慢速度，例如，如果有3000个客户端，将有3000个执行组（线程）。这正在消除NIO的主要优势，即使用低线程量的能力。
我们可以在启动时创建3000个执行程序，而不是为每个通道创建1个执行程序，每次客户端连接/断开连接时，至少不会删除和创建它们。
.childHandler（new EdgeInitializer（new DefaultEventExecutorGroup（3000）））;
上面的行比为每个客户端创建1个执行程序更容易接受，因为所有客户端都连接到同一个ExecutorGroup，并且当客户端断开Executors时，即使客户端数据被删除，仍然存在。
如果我们必须谈论数据库请求，一些数据库查询可能需要很长时间才能完成，因此如果有10个执行程序并且有10个作业正在处理中，则第11个作业将不得不等到其中一个完成。如果服务器同时接收超过10个非常耗时的数据库作业，则这是一个瓶颈。增加执行者数量将在一定程度上解决瓶颈问题。