विंडोज़ क्लाइंट-सर्वर उपयोगिताओं की कार्यक्षमता के साथ सॉफ्टवेयर लिखना, भाग 02

विंडोज़ कंसोल उपयोगिताओं के कस्टम कार्यान्वयन के लिए समर्पित लेखों की चल रही श्रृंखला को जारी रखते हुए, हम टीएफटीपी (ट्रिवियल फाइल ट्रांसफर प्रोटोकॉल) - एक सरल फ़ाइल ट्रांसफर प्रोटोकॉल - को छूने से बच नहीं सकते।

पिछली बार की तरह, आइए संक्षेप में सिद्धांत पर गौर करें, उस कोड को देखें जो आवश्यक कार्यक्षमता के समान कार्यक्षमता लागू करता है, और उसका विश्लेषण करें। अधिक विवरण - कट के अंतर्गत

मैं संदर्भ जानकारी को कॉपी-पेस्ट नहीं करूंगा, जिसके लिंक परंपरागत रूप से लेख के अंत में पाए जा सकते हैं, मैं सिर्फ इतना कहूंगा कि इसके मूल में, टीएफटीपी एफ़टीपी प्रोटोकॉल का एक सरलीकृत रूप है, जिसमें एक्सेस कंट्रोल सेटिंग होती है हटा दिया गया है, और वास्तव में फ़ाइल प्राप्त करने और स्थानांतरित करने के आदेशों के अलावा यहां कुछ भी नहीं है। हालाँकि, हमारे कार्यान्वयन को थोड़ा और अधिक सुरुचिपूर्ण बनाने और कोड लिखने के वर्तमान सिद्धांतों के अनुकूल बनाने के लिए, वाक्यविन्यास को थोड़ा बदल दिया गया है - इससे ऑपरेशन के सिद्धांत नहीं बदलते हैं, लेकिन इंटरफ़ेस, IMHO, थोड़ा अधिक तार्किक हो जाता है और एफ़टीपी और टीएफटीपी के सकारात्मक पहलुओं को जोड़ती है।

विशेष रूप से, लॉन्च होने पर, क्लाइंट सर्वर के आईपी पते और उस पोर्ट का अनुरोध करता है जिस पर कस्टम टीएफटीपी खुला है (मानक प्रोटोकॉल के साथ असंगतता के कारण, मैंने उपयोगकर्ता को पोर्ट का चयन करने की क्षमता छोड़ना उचित समझा), जिसके बाद ए कनेक्शन होता है, जिसके परिणामस्वरूप क्लाइंट सर्वर पर फ़ाइल प्राप्त करने या भेजने के लिए कमांड में से एक भेज सकता है - प्राप्त करें या डालें। तर्क को सरल बनाने के लिए सभी फ़ाइलें बाइनरी मोड में भेजी जाती हैं।

प्रोटोकॉल को लागू करने के लिए, मैंने पारंपरिक रूप से 4 वर्गों का उपयोग किया:

• टीएफटीपीक्लाइंट
• TFTPServer
• टीएफटीपीक्लाइंटटेस्टर
• TFTPServerटेस्टर

इस तथ्य के कारण कि परीक्षण कक्षाएं केवल मुख्य डिबगिंग के लिए मौजूद हैं, मैं उनका विश्लेषण नहीं करूंगा, लेकिन कोड रिपॉजिटरी में होगा; इसका लिंक लेख के अंत में पाया जा सकता है। अब मैं मुख्य कक्षाओं को देखूंगा।

टीएफटीपीक्लाइंट

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

सर्वर से कनेक्ट करने के लिए क्लाइंट को लॉन्च करने और इनपुट स्ट्रीम से कमांड की प्रतीक्षा करने का कोड इस तरह दिखता है। यहां उपयोग किए जाने वाले कई वैश्विक चर का वर्णन लेख के बाहर, कार्यक्रम के पूर्ण पाठ में किया गया है। उनकी तुच्छता के कारण, मैं उन्हें उद्धृत नहीं करता ताकि लेख पर अधिक बोझ न पड़े।

 public void run(String ip, int port)
    {
        this.ip = ip;
        this.port = port;
        try {
            inicialization();
            Scanner keyboard = new Scanner(System.in);
            while (isRunning) {
                getAndParseInput(keyboard);
                sendCommand();
                selector();
                }
            }
        catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

आइए कोड के इस ब्लॉक में बताई गई विधियों पर नज़र डालें:

यहां फ़ाइल भेजी जाती है - एक स्कैनर का उपयोग करके, हम फ़ाइल की सामग्री को बाइट्स की एक सरणी के रूप में प्रस्तुत करते हैं, जिसे हम एक-एक करके सॉकेट में लिखते हैं, जिसके बाद हम इसे बंद करते हैं और इसे फिर से खोलते हैं (सबसे स्पष्ट समाधान नहीं, लेकिन यह संसाधनों की रिहाई की गारंटी देता है), जिसके बाद हम सफल स्थानांतरण के बारे में एक संदेश प्रदर्शित करते हैं।

private  void put(String sourcePath, String destPath)
    {

        File src = new File(sourcePath);
        try {

            InputStream scanner = new FileInputStream(src);
            byte[] bytes = scanner.readAllBytes();
            for (byte b : bytes)
                sout.write(b);
            sout.close();
            inicialization();
            System.out.println("nDonen");
            }

        catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }

यह कोड खंड सर्वर से डेटा पुनर्प्राप्त करने का वर्णन करता है। सब कुछ फिर से तुच्छ है, केवल कोड का पहला ब्लॉक ही रुचिकर है। यह समझने के लिए कि सॉकेट से कितने बाइट्स पढ़ने की आवश्यकता है, आपको यह जानना होगा कि स्थानांतरित फ़ाइल का वजन कितना है। सर्वर पर फ़ाइल का आकार एक लंबे पूर्णांक के रूप में दर्शाया जाता है, इसलिए यहां 4 बाइट्स स्वीकार किए जाते हैं, जिन्हें बाद में एक संख्या में बदल दिया जाता है। यह बहुत जावा दृष्टिकोण नहीं है, यह एसआई के समान है, लेकिन यह इसकी समस्या का समाधान करता है।

तब सब कुछ तुच्छ है - हम सॉकेट से ज्ञात संख्या में बाइट्स प्राप्त करते हैं और उन्हें एक फ़ाइल में लिखते हैं, जिसके बाद हम एक सफलता संदेश प्रदर्शित करते हैं।

   private void get(String sourcePath, String destPath){
        long sizeOfFile = 0;
        try {


            byte[] sizeBytes = new byte[Long.SIZE];
           for (int i =0; i< Long.SIZE/Byte.SIZE; i++)
           {
               sizeBytes[i] = (byte)sin.read();
               sizeOfFile*=256;
               sizeOfFile+=sizeBytes[i];
           }

           FileOutputStream writer = new FileOutputStream(new File(destPath));
           for (int i =0; i < sizeOfFile; i++)
           {
               writer.write(sin.read());
           }
           writer.close();
           System.out.println("nDONEn");
       }
       catch (Exception e){
            System.out.println(e.getMessage());
       }
    }

यदि क्लाइंट विंडो में get या put के अलावा कोई अन्य कमांड दर्ज किया गया था, तो showErrorMessage फ़ंक्शन को कॉल किया जाएगा, जो दर्शाता है कि इनपुट गलत था। तुच्छता के कारण, मैं इसका हवाला नहीं दूँगा। इनपुट स्ट्रिंग को प्राप्त करने और विभाजित करने का कार्य कुछ अधिक दिलचस्प है। हम इसमें स्कैनर पास करते हैं, जिससे हम दो स्थानों से अलग की गई एक लाइन प्राप्त करने की उम्मीद करते हैं और जिसमें कमांड, स्रोत पता और गंतव्य पता शामिल होता है।

    private void getAndParseInput(Scanner scanner)
    {
        try {

            input = scanner.nextLine().split(" ");
            typeOfCommand = input[0];
            sourcePath = input[1];
            destPath = input[2];
        }
        catch (Exception e) {
            System.out.println("Bad input");
        }
    }

एक कमांड भेजना - स्कैनर से दर्ज किए गए कमांड को सॉकेट तक पहुंचाता है और इसे भेजने के लिए मजबूर करता है

    private void sendCommand()
    {
        try {

            for (String str : input) {
                for (char ch : str.toCharArray()) {
                    sout.write(ch);
                }
                sout.write(' ');
            }
            sout.write('n');
        }
        catch (Exception e) {
            System.out.print(e.getMessage());
        }
    }

चयनकर्ता एक फ़ंक्शन है जो दर्ज की गई स्ट्रिंग के आधार पर प्रोग्राम की क्रियाओं को निर्धारित करता है। यहां सब कुछ बहुत सुंदर नहीं है और इस्तेमाल की गई ट्रिक कोड ब्लॉक के बाहर जबरन निकास के साथ सबसे अच्छी नहीं है, लेकिन इसका मुख्य कारण जावा में कुछ चीजों की अनुपस्थिति है, जैसे सी # में प्रतिनिधि, सी ++ से फ़ंक्शन पॉइंटर्स, या कम से कम भयानक और भयानक गोटो, जो आपको इसे खूबसूरती से लागू करने की अनुमति देता है। यदि आप जानते हैं कि कोड को थोड़ा और अधिक सुंदर कैसे बनाया जाए, तो मैं टिप्पणियों में आलोचना का स्वागत करता हूँ। मुझे ऐसा लगता है कि यहां एक स्ट्रिंग-प्रतिनिधि शब्दकोश की आवश्यकता है, लेकिन कोई प्रतिनिधि नहीं है...

    private void selector()
    {
        do{
            if (typeOfCommand.equals("get")){
                get(sourcePath, destPath);
                break;
            }
            if (typeOfCommand.equals("put")){
                put(sourcePath, destPath);
                break;
            }
            showErrorMessage();
        }
        while (false);
    }
}

TFTPServer

सर्वर की कार्यक्षमता क्लाइंट की कार्यक्षमता से भिन्न होती है, केवल इसमें कमांड कीबोर्ड से नहीं, बल्कि सॉकेट से आते हैं। कुछ विधियाँ आम तौर पर समान होती हैं, इसलिए मैं उनका हवाला नहीं दूँगा, मैं केवल अंतरों पर बात करूँगा।

शुरू करने के लिए, रन विधि का उपयोग किया जाता है, जो इनपुट के रूप में एक पोर्ट प्राप्त करता है और सॉकेट से इनपुट डेटा को एक शाश्वत लूप में संसाधित करता है।

    public void run(int port) {
            this.port = port;
            incialization();
            while (true) {
                getAndParseInput();
                selector();
            }
    }

पुट विधि, जो writeToFileFromSocket विधि को लपेटती है जो फ़ाइल में एक लेखन स्ट्रीम खोलती है और सॉकेट से सभी इनपुट बाइट्स लिखती है, लेखन पूरा होने पर स्थानांतरण के सफल समापन का संकेत देने वाला एक संदेश प्रदर्शित करती है।

    private  void put(String source, String dest){
            writeToFileFromSocket();
            System.out.print("nDonen");
    };
    private void writeToFileFromSocket()
    {
        try {
            FileOutputStream writer = new FileOutputStream(new File(destPath));
            byte[] bytes = sin.readAllBytes();
            for (byte b : bytes) {
                writer.write(b);
            }
            writer.close();
        }
        catch (Exception e){
            System.out.println(e.getMessage());
        }
    }

प्राप्त विधि सर्वर फ़ाइल को पुनः प्राप्त करती है। जैसा कि प्रोग्राम के क्लाइंट पक्ष के अनुभाग में पहले ही उल्लेख किया गया है, किसी फ़ाइल को सफलतापूर्वक स्थानांतरित करने के लिए आपको उसका आकार जानना होगा, जो एक लंबे पूर्णांक में संग्रहीत है, इसलिए मैंने इसे 4 बाइट्स की एक सरणी में विभाजित किया है, उन्हें बाइट-दर-बाइट स्थानांतरित किया है सॉकेट में, और फिर, उन्हें क्लाइंट पर एक नंबर में वापस प्राप्त करने और इकट्ठा करने के बाद, मैं फ़ाइल से इनपुट स्ट्रीम से पढ़े गए सभी बाइट्स को फ़ाइल में स्थानांतरित करता हूं।

 private  void get(String source, String dest){
        File sending = new File(source);
        try {
            FileInputStream readFromFile = new FileInputStream(sending);
            byte[] arr = readFromFile.readAllBytes();
            byte[] bytes = ByteBuffer.allocate(Long.SIZE / Byte.SIZE).putLong(sending.length()).array();
            for (int i = 0; i<Long.SIZE / Byte.SIZE; i++)
                sout.write(bytes[i]);
            sout.flush();
            for (byte b : arr)
                sout.write(b);
        }
        catch (Exception e){
            System.out.println(e.getMessage());
        }
    };

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

    private void  incialization()
    {
        try {
            serverSocket = new ServerSocket(port);
            socket = serverSocket.accept();
            sin = socket.getInputStream();
            sout = socket.getOutputStream();
        }
        catch (Exception e) {
            System.out.print(e.getMessage());
        }
    }

सारांश में:

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

कड़ियाँ:

स्रोत कोड भंडार
टीएफटीपी के बारे में संक्षेप में
वही बात, लेकिन रूसी में

स्रोत: www.habr.com