Запуск сайта на Spring MVC и tcp-сервера

Используйте для таких целей Spring Integration

Sample:

public TcpNioServerConnectionFactory gameConnectionFactory() {
    TcpNioServerConnectionFactory serverConnectionFactory = new TcpNioServerConnectionFactory(port);
    serverConnectionFactory.setDeserializer(new ProtocolByteArrayLengthHeaderSerializer());
    serverConnectionFactory.setSerializer(new ProtocolByteArrayLengthHeaderSerializer());
    return serverConnectionFactory;
}
@Bean
public TcpReceivingChannelAdapter tcpIn(AbstractServerConnectionFactory connectionFactory) {
    TcpReceivingChannelAdapter gateway = new TcpReceivingChannelAdapter();
    gateway.setConnectionFactory(connectionFactory);
    gateway.setOutputChannel(tcpInputChannel());
    return gateway;
}
@Bean
public MessageChannel tcpInputChannel() {
    return new DirectChannel();
}
/**
 * Ingoing message flow
 *
 * @return - complete message transformation flow
 */
@Bean
public IntegrationFlow recvFlow() {
    return IntegrationFlows
            .from(tcpInputChannel())
            .transform(byte[].class, b -> wrappedBuffer(b).order(ByteOrder.LITTLE_ENDIAN))
            // no crypt for RequestProtocolVersion
            .route(ByteBuf.class, b -> b.readableBytes() > 0 && b.getByte(0) == 0x0E,
                    invoker -> invoker
                            .subFlowMapping("true",
                                    sf -> sf.transform(b -> b))
                            .subFlowMapping("false",
                                    sf -> sf.transform(encoder, "decrypt")))
            .transform(clientPacketHandler, "handle")
            .channel(incomingPacketExecutorChannel())
            .get();
}
@Bean
public MessageChannel incomingPacketExecutorChannel() {
    // TODO: 07.12.15 investigate, may be should replace with spring TaskExecutor
    return new ExecutorChannel(Executors.newCachedThreadPool());
}
@ServiceActivator(inputChannel = "incomingPacketExecutorChannel")
public void executePacket(IncomingMessageWrapper msg) {
    msg.prepare();
    msg.run();
    if (log.isDebugEnabled() && msg.getPayload().readableBytes() > 0) {
        final StringBuilder leftStr = new StringBuilder("[");
        msg.getPayload().forEachByte(
                msg.getPayload().readerIndex(),
                msg.getPayload().readableBytes(),
                b -> {
                    leftStr.append(" ");
                    leftStr.append(String.format("%02X", b));
                    return true;
                });
        leftStr.append(" ]");
        log.debug(msg.getPayload().readableBytes() + " byte(s) left in "
                + msg.getClass().getSimpleName() + " buffer: "
                + leftStr);
    }
    msg.release();
}
/**
 * Channel for raw object messages, unwrited and unencrypted
 *
 * @return - channel
 */
@Bean
public MessageChannel packetChannel() {
    return new DirectChannel();
}
/**
 * Channel for outgoing packets
 *
 * @return - channel
 */
@Bean
public MessageChannel tcpOutChannel() {
    return new PublishSubscribeChannel();
}
/**
 * Endpoint for output messages.
 * Receives message from tcpOutputChannel, and send it to client with corresponding {@link IpHeaders#CONNECTION_ID}
 *
 * @param connectionFactory - server factory bean
 * @return - tcp message handler bean
 */
@Bean
@ServiceActivator(inputChannel = "tcpOutChannel")
public TcpSendingMessageHandler tcpOut(AbstractServerConnectionFactory connectionFactory) {
    TcpSendingMessageHandler gateway = new TcpSendingMessageHandler();
    gateway.setConnectionFactory(connectionFactory);
    return gateway;
}
/**
 * Outgoing message flow
 * // TODO rewrite to reactive
 *
 * @return - complete message transformations flow
 */
@Bean
public IntegrationFlow sendFlow(@Qualifier("packetChannel") MessageChannel packetChannel,
                                @Qualifier("tcpOutChannel") MessageChannel tcpOutputChannel) {
    return IntegrationFlows
            .from(packetChannel)
            .route(OutgoingMessageWrapper.class, msg -> msg.isStatic(),
                    invoker -> invoker
                            .subFlowMapping("true",
                                    sf -> sf.transform(StaticOutgoingMessageWrapper.class,
                                            msg -> {
                                                try {
                                                    return msg.clone();
                                                } catch (CloneNotSupportedException e) {
                                                    // just rethrow to unchecked
                                                    throw new RuntimeException(e);
                                                }
                                            }))
                            .subFlowMapping("false",
                                    sf -> sf.transform(OutgoingMessageWrapper.class, msg -> msg))
            )
            .transform(OutgoingMessageWrapper.class, msg -> {
                msg.write();
                return msg;
            })
            .route(OutgoingMessageWrapper.class, msg -> msg instanceof VersionCheck, // TODO: 14.12.15 unencrypted LoginFail
                    invoker -> invoker
                            .subFlowMapping("true",
                                    sf -> sf.transform(OutgoingMessageWrapper.class, OutgoingMessageWrapper::getPayload))
                            .subFlowMapping("false",
                                    sf -> sf
                                            .transform(OutgoingMessageWrapper.class, OutgoingMessageWrapper::getPayload)
                                            .transform(encoder, "encrypt")))
            .transform(ByteBuf.class, buf -> {
                byte[] data = new byte[buf.readableBytes()];
                buf.readBytes(data);
                buf.release();
                return data;
            })
            .channel(tcpOutputChannel)
            .get();
}

P.s. с телефона, поправьте разметку, если не трудно

Вот это надо стартовать отдельным потоком, иначе у вас бин зависает после создания. Далее если вы обрабатываете сообщения в новом потоке, то его тоже надо стартавать.

new Thread(() -> {
    // слушаем порт
    while(true)
    {
        // ждём нового подключения, после чего запускаем обработку клиента
        // в новый вычислительный поток и увеличиваем счётчик на единичку
        new SimpleServer(i, server.accept())
        .start();
        i++;
    }
})
.start();