नेट्टी + जावा में एक उत्पादक गेम सर्वर का विकास

जैसा कि वादा किया गया था, मैं नेट्टी पर एक उत्पादक गेम सर्वर का विवरण देता हूं, जिसका उपयोग मैं अपनी परियोजनाओं में करता हूं।
नीचे वर्णित सब कुछ अंतिम रिज़ॉर्ट में सच नहीं है, लेकिन केवल वास्तविक परियोजनाओं में प्रौद्योगिकियों को लागू करने का अनुभव है।

शुरू से शुरू करते हैं।

गेम सर्वर बनाने के कार्य में हमारा सामना होता है।

गेम सर्वर के मुख्य कार्य क्या हैं?
संक्षेप में, तब:

• ग्राहक से पैकेज प्राप्त करें
• इस पैकेज को संसाधित करें (डिक्रिप्शन, डिसेरिएलाइज़ेशन, आदि)
• खेल की स्थिति की गणना करें
• ग्राहकों के खेल परिवर्तन भेजें

...

हम अब डेटाबेस और अन्य चीजों के साथ काम करने पर विचार नहीं करेंगे। चलो नेटवर्क भाग पर ध्यान केंद्रित करते हैं।

नेटी इस मामले में हमारी मदद कैसे कर सकती है?

नेट्टी एक नेटवर्क लाइब्रेरी है जो सॉकेट्स के साथ सीधा काम संभालेगी। कनेक्ट करें, ग्राहकों को डिस्कनेक्ट करें। प्राप्त करें, भेजें और टुकड़े के पैकेट। यानी नेट्टी, सॉकेट्स के साथ सभी निम्न-स्तरीय कार्यों का ध्यान रखेगा।

कुलीनता कैसे हमारी मदद करेगी?

नेट्टी एक बहुत ही सुविधाजनक वास्तुकला को लागू करता है। उदाहरण के लिए, यह आपको कई इनपुट हैंडलर कनेक्ट करने की अनुमति देता है। यानी पहले हैंडलर में, हम आने वाले डेटा स्ट्रीम को पैकेट में विभाजित करते हैं, और दूसरे में हम पहले से ही इन पैकेटों को प्रोसेस कर रहे हैं। उसी समय, आप लचीले ढंग से लाइब्रेरी की सेटिंग्स को नियंत्रित कर सकते हैं, आवश्यक संख्या में थ्रेड्स या मेमोरी आदि आवंटित कर सकते हैं।
नेट्टी का उपयोग करते समय सामान्य वास्तुकला इस तरह दिख सकती है:



हमें 3 हैंडलर मिलते हैं:
1. कनेक्शन हैंडलर एक हैंडलर है जो ग्राहकों को जोड़ने / डिस्कनेक्ट करने के लिए जिम्मेदार है। यह जाँच करेगा कि क्या क्लाइंट (काली सूची, श्वेतसूची, आईपी फ़िल्टर आदि) कनेक्ट कर सकते हैं और साथ ही उपयोग किए गए सभी संसाधनों को बंद करने के साथ ग्राहकों को सही ढंग से डिस्कनेक्ट कर सकते हैं।

2. फ़्रेम हैंडलर एक हैंडलर है जो डेटा स्ट्रीम को अलग-अलग पैकेट में विभाजित करता है।
सुविधा के लिए, हम मानते हैं कि पैकेज में दो भाग हैं। 1-हैडर, जो पैकेट की लंबाई और 2-सीधे पैकेट डेटा का वर्णन करता है।

3. पैकेट हैंडलर पहले से ही गेम मैसेज हैंडलर है। यहां हम पैकेज से डेटा प्राप्त करेंगे और उन्हें आगे प्रोसेस करेंगे।

कोड में प्रत्येक भाग का विश्लेषण करते हैं।

कनेक्शन हैंडलर

public class ConnectionHandler extends SimpleChannelHandler
{

    @Override
    public void channelOpen( ChannelHandlerContext ctx, ChannelStateEvent e ) throws Exception
    {
        if(       )
        {
	//  
            e.getChannel().close();
        }
    }
    
    @Override
    public void channelClosed( ChannelHandlerContext ctx, ChannelStateEvent e ) throws Exception
    {
        // ,   ,        .
    }
  
    
    @Override
    public void exceptionCaught( ChannelHandlerContext ctx, ExceptionEvent e ) throws Exception
    {
	//   
        log.error( "message: {}", e.getCause().getMessage() );
    }    
    
}

Frame handler.

. , .

public class FrameHandler extends ReplayingDecoder<DecoderState>
{
    public enum DecoderState
    {
        READ_LENGTH,
        READ_CONTENT;
    }  

    private int length;

    public ProtocolPacketFramer()
    {
        super( DecoderState.READ_LENGTH );
    }
    
    @Override
    protected Object decode( ChannelHandlerContext chc, Channel chnl, ChannelBuffer cb, DecoderState state ) throws Exception
    {
        switch ( state )
        {
            case READ_LENGTH:
                length = cb.readInt();
                checkpoint( DecoderState.READ_CONTENT );
                
            case READ_CONTENT:
                ChannelBuffer frame = cb.readBytes( length );
                checkpoint( DecoderState.READ_LENGTH );
                return frame;
                
            default:
                throw new Error( "Shouldn't reach here." );
        }
    }
}

Packet handler

public class ProtocolPacketHandler extends SimpleChannelHandler
{
    @Override
    public void messageReceived( ChannelHandlerContext ctx, MessageEvent e ) throws Exception
    {
	//  
            byte[] msg = ((ChannelBuffer)e.getMessage()).array();
            
	//     
            Packet packet = new Packet();
            packet.setData( msg );
            packet.setSender( session );

	//      
            session.addReadPacketQueue( packet );

	//      
            Server.getReader().addSessionToProcess( session );
    }
}

, . Packet . .

. . , , . . 2 . TCP , . . , . .
, TCP ( Akka ) . . TCP Netty , .

.



. . TCP Netty . .

. Session , 2 , . Packet . Netty , . , . . . . … - )) , , .

.

.

public final class ReadQueueHandler implements Runnable
{
    private final BlockingQueue<Session> sessionQueue;
    private final ExecutorService        threadPool;
    private int                          threadPoolSize;
    
    public ReadQueueHandler( int threadPoolSize )
    {
        this.threadPoolSize = threadPoolSize;
        this.threadPool     = Executors.newFixedThreadPool( threadPoolSize );
        this.sessionQueue   = new LinkedBlockingQueue();
        
        initThreadPool();
    }
    
    private void initThreadPool()
    {
        for ( int i = 0; i < this.threadPoolSize; i++ )
        {
            this.threadPool.execute( this );
        }
    }
    
    //      
    public void addSessionToProcess( Session session )
    {
        if ( session != null )
        {
            this.sessionQueue.add( session );
        }
    }    
    
    @Override
    public void run()
    {
        while ( isActive )
        {
                //     
                Session session = (Session) this.sessionQueue.take();
                
                //     
                //  
                packet = session.getReadPacketQueue().take();

                //       
                data =  packet.getData();
        }
    }    
}

. . . TCP . . Netty . .

protobuf. . , )

, AMD 1.4 (lenovo edge 13), 18-20 . .

P.S. — .