ការសរសេរកម្មវិធីជាមួយនឹងមុខងាររបស់ Windows client-server utilities, part 02

ដោយបន្តស៊េរីអត្ថបទដែលកំពុងបន្តដែលឧទ្ទិសដល់ការអនុវត្តផ្ទាល់ខ្លួននៃឧបករណ៍ប្រើប្រាស់កុងសូល Windows យើងមិនអាចជួយបានក្រៅពីប៉ះលើ TFTP (Trivial File Transfer Protocol) ដែលជាពិធីការផ្ទេរឯកសារសាមញ្ញ។

ដូចលើកមុន សូមនិយាយដោយសង្ខេបអំពីទ្រឹស្តី សូមមើលកូដដែលអនុវត្តមុខងារស្រដៀងគ្នាទៅនឹងតម្រូវការមួយ ហើយវិភាគវា។ ព័ត៌មានលម្អិតបន្ថែម - នៅក្រោមការកាត់

ខ្ញុំនឹងមិនចម្លង-បិទភ្ជាប់ព័ត៌មានយោងទេ តំណភ្ជាប់ដែលជាធម្មតាអាចត្រូវបានរកឃើញនៅចុងបញ្ចប់នៃអត្ថបទនេះ ខ្ញុំនឹងនិយាយថា TFTP គឺជាបំរែបំរួលដ៏សាមញ្ញនៃពិធីការ FTP ដែលក្នុងនោះការកំណត់ការគ្រប់គ្រងការចូលប្រើ។ ត្រូវ​បាន​យក​ចេញ ហើយ​តាម​ពិត​គ្មាន​អ្វី​នៅ​ទី​នេះ​ទេ លើក​លែង​តែ​ពាក្យ​បញ្ជា​សម្រាប់​ទទួល និង​ផ្ទេរ​ឯកសារ។ ទោះយ៉ាងណាក៏ដោយ ដើម្បីធ្វើឱ្យការអនុវត្តរបស់យើងមានភាពឆើតឆាយបន្តិច និងសម្របតាមគោលការណ៍បច្ចុប្បន្ននៃការសរសេរកូដ វាក្យសម្ព័ន្ធត្រូវបានផ្លាស់ប្តូរបន្តិចបន្តួច - នេះមិនផ្លាស់ប្តូរគោលការណ៍ប្រតិបត្តិការទេ ប៉ុន្តែចំណុចប្រទាក់ IMHO ក្លាយជាឡូជីខលបន្តិចហើយ រួមបញ្ចូលគ្នានូវទិដ្ឋភាពវិជ្ជមាននៃ FTP និង TFTP ។

ជាពិសេស នៅពេលបើកដំណើរការ អតិថិជនស្នើសុំអាសយដ្ឋាន IP របស់ម៉ាស៊ីនមេ និងច្រកដែល TFTP ផ្ទាល់ខ្លួនត្រូវបានបើក (ដោយសារតែភាពមិនស៊ីគ្នាជាមួយនឹងពិធីការស្តង់ដារ ខ្ញុំបានចាត់ទុកថាវាសមស្របក្នុងការទុកឱ្យអ្នកប្រើប្រាស់មានលទ្ធភាពជ្រើសរើសច្រក) បន្ទាប់ពីនោះ ការតភ្ជាប់កើតឡើង ដែលជាលទ្ធផលដែលម៉ាស៊ីនភ្ញៀវអាចផ្ញើពាក្យបញ្ជាមួយ - ទទួល ឬដាក់ ដើម្បីទទួល ឬផ្ញើឯកសារទៅម៉ាស៊ីនមេ។ ឯកសារទាំងអស់ត្រូវបានផ្ញើក្នុងរបៀបគោលពីរ ដើម្បីសម្រួលតក្កវិជ្ជា។

ដើម្បីអនុវត្តពិធីការ ខ្ញុំបានប្រើ 4 classes ជាប្រពៃណី៖

• TTPClient
• ម៉ាស៊ីនមេ TFTPS
• TTPClientTester
• TFTPServerTester

ដោយសារតែការពិតដែលថាថ្នាក់សាកល្បងមានសម្រាប់តែបំបាត់កំហុសដែលសំខាន់នោះខ្ញុំនឹងមិនវិភាគពួកគេទេប៉ុន្តែកូដនឹងនៅក្នុងឃ្លាំងភ្ជាប់ទៅវាអាចរកបាននៅចុងបញ្ចប់នៃអត្ថបទ។ ឥឡូវនេះខ្ញុំនឹងមើលថ្នាក់សំខាន់ៗ។

TTPClient

ភារកិច្ចនៃថ្នាក់នេះគឺដើម្បីភ្ជាប់ទៅម៉ាស៊ីនមេពីចម្ងាយដោយប្រើ ip និងលេខច្រករបស់វា អានពាក្យបញ្ជាពីស្ទ្រីមបញ្ចូល (ក្នុងករណីនេះក្តារចុច) ញែកវាផ្ទេរវាទៅម៉ាស៊ីនមេ ហើយអាស្រ័យលើថាតើអ្នក ត្រូវការផ្ញើ ឬទទួលឯកសារ ផ្ទេរវា ឬទទួល។

កូដសម្រាប់បើកដំណើរការម៉ាស៊ីនភ្ញៀវដើម្បីភ្ជាប់ទៅម៉ាស៊ីនមេ ហើយរង់ចាំពាក្យបញ្ជាពីស្ទ្រីមបញ្ចូលមើលទៅដូចនេះ។ អថេរសកលមួយចំនួនដែលត្រូវបានប្រើនៅទីនេះត្រូវបានពិពណ៌នានៅខាងក្រៅអត្ថបទនៅក្នុងអត្ថបទពេញលេញនៃកម្មវិធី។ ដោយ​សារ​តែ​រឿង​តូចតាច​របស់​ពួក​គេ ខ្ញុំ​មិន​លើក​ឡើង​ដើម្បី​កុំ​ឲ្យ​អត្ថបទ​ផ្ទុក​លើស​ចំណុះ។

 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 បៃត្រូវបានទទួលយកនៅទីនេះ ដែលត្រូវបានបម្លែងជាបន្តបន្ទាប់ទៅជាលេខមួយ។ នេះមិនមែនជាវិធីសាស្រ្ត Java ទេ វាគឺស្រដៀងគ្នាសម្រាប់ 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());
       }
    }

ប្រសិនបើពាក្យបញ្ជាក្រៅពីទទួល ឬដាក់ត្រូវបានបញ្ចូលទៅក្នុងបង្អួចម៉ាស៊ីនភ្ញៀវ មុខងារ 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());
        }
    }

ឧបករណ៍ជ្រើសរើសគឺជាមុខងារដែលកំណត់សកម្មភាពរបស់កម្មវិធីអាស្រ័យលើខ្សែអក្សរដែលបានបញ្ចូល។ អ្វីៗនៅទីនេះមិនស្អាតខ្លាំងទេ ហើយល្បិចដែលប្រើគឺមិនមែនជាជម្រើសដ៏ល្អបំផុតជាមួយនឹងការបង្ខំឱ្យចេញក្រៅប្លុកកូដនោះទេ ប៉ុន្តែហេតុផលចម្បងសម្រាប់នេះគឺអវត្តមាននៅក្នុង Java នៃរឿងមួយចំនួនដូចជា delegates នៅក្នុង C# ទ្រនិចមុខងារពី C++ ឬនៅ យ៉ាងហោចណាស់ goto ដ៏គួរឱ្យភ័យខ្លាចនិងគួរឱ្យភ័យខ្លាចដែលអនុញ្ញាតឱ្យអ្នកអនុវត្តវាយ៉ាងស្រស់ស្អាត។ ប្រសិនបើអ្នកដឹងពីរបៀបធ្វើឱ្យកូដកាន់តែឆើតឆាយខ្ញុំស្វាគមន៍ការរិះគន់នៅក្នុងមតិយោបល់។ វាហាក់ដូចជាខ្ញុំថា វចនានុក្រម String-delegate គឺត្រូវការនៅទីនេះ ប៉ុន្តែមិនមានប្រតិភូទេ...

    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 ដែលបើកការសរសេរទៅឯកសារមួយ ហើយសរសេរបៃបញ្ចូលទាំងអស់ពី socket បង្ហាញសារដែលបង្ហាញពីការបញ្ចប់ការផ្ទេរដោយជោគជ័យ នៅពេលដែលការសរសេរបានបញ្ចប់។

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

វិធីសាស្ត្រ get ទាញយកឯកសារម៉ាស៊ីនមេ។ ដូចដែលបានបញ្ជាក់រួចមកហើយនៅក្នុងផ្នែកនៅផ្នែកខាងអតិថិជននៃកម្មវិធី ដើម្បីផ្ទេរឯកសារដោយជោគជ័យ អ្នកត្រូវដឹងពីទំហំរបស់វា រក្សាទុកក្នុងចំនួនគត់វែង ដូច្នេះខ្ញុំបានបំបែកវាទៅជាអារេនៃ 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());
        }
    }

សង្ខេប:

យើងទើបតែបានសរសេរបំរែបំរួលផ្ទាល់ខ្លួនរបស់យើងលើពិធីការផ្ទេរទិន្នន័យសាមញ្ញ ហើយស្វែងយល់ពីរបៀបដែលវាគួរតែដំណើរការ។ ជាគោលការណ៍ ខ្ញុំមិនបានរកឃើញអាមេរិចនៅទីនេះ ហើយមិនបានសរសេររឿងថ្មីច្រើនទេ ប៉ុន្តែមិនមានអត្ថបទស្រដៀងគ្នានៅលើ Habre ហើយជាផ្នែកមួយនៃការសរសេរអត្ថបទជាបន្តបន្ទាប់អំពីឧបករណ៍ប្រើប្រាស់ cmd វាមិនអាចទៅរួចទេដែលមិនប៉ះពាល់វា។

ឯកសារយោង:

ឃ្លាំងកូដប្រភព
ដោយសង្ខេបអំពី TFTP
រឿងដូចគ្នាប៉ុន្តែជាភាសារុស្សី

ប្រភព: www.habr.com