Windows क्लाइन्ट-सर्भर उपयोगिताहरूको कार्यक्षमतासँग सफ्टवेयर लेखन, भाग 02

विन्डोज कन्सोल उपयोगिताहरूको अनुकूलन कार्यान्वयनमा समर्पित लेखहरूको जारी श्रृंखला जारी राख्दै, हामी TFTP (ट्रिभियल फाइल ट्रान्सफर प्रोटोकल) - एक साधारण फाइल ट्रान्सफर प्रोटोकलमा छुनुहोस् तर मद्दत गर्न सक्दैनौं।

पछिल्लो पटकको रूपमा, हामी छोटकरीमा सिद्धान्तमा जाऔं, आवश्यकसँग मिल्दोजुल्दो कार्यक्षमता लागू गर्ने कोड हेर्नुहोस्, र यसलाई विश्लेषण गर्नुहोस्। थप विवरण - कट अन्तर्गत

म सन्दर्भ जानकारी प्रतिलिपि गर्न टाँस्ने छैन, जुन लिङ्कहरू परम्परागत रूपमा लेखको अन्त्यमा फेला पार्न सकिन्छ, म केवल भन्न चाहन्छु कि यसको मूलमा, TFTP FTP प्रोटोकलको एक सरल भिन्नता हो, जसमा पहुँच नियन्त्रण सेटिङ। हटाइएको छ, र वास्तवमा फाइल प्राप्त गर्न र स्थानान्तरण गर्न आदेशहरू बाहेक यहाँ केही छैन। जे होस्, हाम्रो कार्यान्वयनलाई अलि बढी सुरुचिपूर्ण र लेखन कोडको हालको सिद्धान्तहरूमा अनुकूल बनाउनको लागि, वाक्य रचना थोरै परिवर्तन गरिएको छ - यसले सञ्चालनका सिद्धान्तहरू परिवर्तन गर्दैन, तर इन्टरफेस, IMHO, अलि बढी तार्किक हुन्छ र FTP र TFTP को सकारात्मक पक्षहरू संयोजन गर्दछ।

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

प्रोटोकल लागू गर्न, मैले परम्परागत रूपमा 4 कक्षाहरू प्रयोग गरें:

• TFTPC ग्राहक
• TFTPS सर्भर
• TFTPClientTester
• TFTPS सर्भर टेस्टर

यस तथ्यको कारणले कि परीक्षण कक्षाहरू केवल मुख्य डिबग गर्नको लागि अवस्थित छन्, म तिनीहरूलाई विश्लेषण गर्नेछैन, तर कोड भण्डारमा हुनेछ; यसको लिङ्क लेखको अन्त्यमा फेला पार्न सकिन्छ। अब म मुख्य कक्षाहरू हेर्नेछु।

TFTPC ग्राहक

यस वर्गको कार्य भनेको रिमोट सर्भरमा यसको आईपी र पोर्ट नम्बरद्वारा जडान गर्नु, इनपुट स्ट्रिमबाट आदेश पढ्नु हो (यस अवस्थामा, किबोर्ड), यसलाई पार्स गर्नुहोस्, यसलाई सर्भरमा स्थानान्तरण गर्नुहोस्, र, तपाइँको आधारमा। फाइल पठाउन वा प्राप्त गर्न, यसलाई स्थानान्तरण गर्न वा प्राप्त गर्न आवश्यक छ।

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

 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 बाइटहरू स्वीकार गरिन्छ, जुन पछि एक नम्बरमा रूपान्तरण गरिन्छ। यो धेरै जाभा दृष्टिकोण होइन, यो SI को लागी समान छ, तर यसले यसको समस्या समाधान गर्दछ।

त्यसपछि सबै कुरा मामूली छ - हामीले सकेटबाट बाइटहरूको ज्ञात संख्या प्राप्त गर्छौं र तिनीहरूलाई फाइलमा लेख्छौं, जस पछि हामी सफलता सन्देश देखाउँछौं।

   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());
        }
    }

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

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

TFTPS सर्भर

सर्भरको कार्यक्षमता क्लाइन्टको कार्यक्षमताबाट भिन्न हुन्छ, र ठूलो, केवल त्यसमा आदेशहरू किबोर्डबाट होइन, तर सकेटबाट आउँछन्। केही विधिहरू सामान्यतया समान छन्, त्यसैले म तिनीहरूलाई उद्धृत गर्दिन, म केवल भिन्नताहरूमा छुनेछु।

सुरु गर्न, रन विधि प्रयोग गरिन्छ, जसले इनपुटको रूपमा पोर्ट प्राप्त गर्दछ र सकेटबाट इनपुट डाटालाई अनन्त लुपमा प्रशोधन गर्दछ।

    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());
        }
    }

संक्षेप गर्न:

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

सन्दर्भहरू:

स्रोत कोड भण्डार
TFTP को बारेमा छोटकरीमा
एउटै कुरा, तर रूसी मा

स्रोत: www.habr.com