ವಿಂಡೋಸ್ ಕ್ಲೈಂಟ್-ಸರ್ವರ್ ಉಪಯುಕ್ತತೆಗಳ ಕ್ರಿಯಾತ್ಮಕತೆಯೊಂದಿಗೆ ಬರೆಯುವ ಸಾಫ್ಟ್‌ವೇರ್, ಭಾಗ 02

ವಿಂಡೋಸ್ ಕನ್ಸೋಲ್ ಉಪಯುಕ್ತತೆಗಳ ಕಸ್ಟಮ್ ಅಳವಡಿಕೆಗಳಿಗೆ ಮೀಸಲಾಗಿರುವ ಲೇಖನಗಳ ನಡೆಯುತ್ತಿರುವ ಸರಣಿಯನ್ನು ಮುಂದುವರೆಸುತ್ತಾ, ನಾವು ಸಹಾಯ ಮಾಡಲಾಗುವುದಿಲ್ಲ ಆದರೆ TFTP (ಟ್ರಿವಿಯಲ್ ಫೈಲ್ ಟ್ರಾನ್ಸ್ಫರ್ ಪ್ರೋಟೋಕಾಲ್) ಅನ್ನು ಸ್ಪರ್ಶಿಸುವುದಿಲ್ಲ - ಇದು ಸರಳವಾದ ಫೈಲ್ ವರ್ಗಾವಣೆ ಪ್ರೋಟೋಕಾಲ್.

ಕೊನೆಯ ಬಾರಿಯಂತೆ, ನಾವು ಸಿದ್ಧಾಂತದ ಮೇಲೆ ಸಂಕ್ಷಿಪ್ತವಾಗಿ ಹೋಗೋಣ, ಅಗತ್ಯವಿರುವ ಒಂದಕ್ಕೆ ಹೋಲುವ ಕಾರ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸುವ ಕೋಡ್ ಅನ್ನು ನೋಡಿ ಮತ್ತು ಅದನ್ನು ವಿಶ್ಲೇಷಿಸಿ. ಹೆಚ್ಚಿನ ವಿವರಗಳು - ಕಟ್ ಅಡಿಯಲ್ಲಿ

ನಾನು ಉಲ್ಲೇಖದ ಮಾಹಿತಿಯನ್ನು ನಕಲಿಸುವುದಿಲ್ಲ, ಲೇಖನದ ಕೊನೆಯಲ್ಲಿ ಸಾಂಪ್ರದಾಯಿಕವಾಗಿ ಕಂಡುಬರುವ ಲಿಂಕ್‌ಗಳು, TFTP ಎಂಬುದು ಎಫ್‌ಟಿಪಿ ಪ್ರೋಟೋಕಾಲ್‌ನ ಸರಳೀಕೃತ ಬದಲಾವಣೆಯಾಗಿದೆ, ಇದರಲ್ಲಿ ಪ್ರವೇಶ ನಿಯಂತ್ರಣ ಸೆಟ್ಟಿಂಗ್ ಅನ್ನು ಹೊಂದಿದೆ ಎಂದು ನಾನು ಹೇಳುತ್ತೇನೆ. ತೆಗೆದುಹಾಕಲಾಗಿದೆ, ಮತ್ತು ವಾಸ್ತವವಾಗಿ ಫೈಲ್ ಅನ್ನು ಸ್ವೀಕರಿಸಲು ಮತ್ತು ವರ್ಗಾಯಿಸಲು ಆಜ್ಞೆಗಳನ್ನು ಹೊರತುಪಡಿಸಿ ಇಲ್ಲಿ ಏನೂ ಇಲ್ಲ . ಆದಾಗ್ಯೂ, ನಮ್ಮ ಅನುಷ್ಠಾನವನ್ನು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಸೊಗಸಾಗಿ ಮಾಡಲು ಮತ್ತು ಪ್ರಸ್ತುತ ಕೋಡ್ ಬರೆಯುವ ತತ್ವಗಳಿಗೆ ಹೊಂದಿಕೊಳ್ಳಲು, ಸಿಂಟ್ಯಾಕ್ಸ್ ಅನ್ನು ಸ್ವಲ್ಪ ಬದಲಾಯಿಸಲಾಗಿದೆ - ಇದು ಕಾರ್ಯಾಚರಣೆಯ ತತ್ವಗಳನ್ನು ಬದಲಾಯಿಸುವುದಿಲ್ಲ, ಆದರೆ ಇಂಟರ್ಫೇಸ್, IMHO, ಸ್ವಲ್ಪ ಹೆಚ್ಚು ತಾರ್ಕಿಕ ಮತ್ತು FTP ಮತ್ತು TFTP ಯ ಧನಾತ್ಮಕ ಅಂಶಗಳನ್ನು ಸಂಯೋಜಿಸುತ್ತದೆ.

ನಿರ್ದಿಷ್ಟವಾಗಿ, ಪ್ರಾರಂಭಿಸಿದಾಗ, ಕ್ಲೈಂಟ್ ಸರ್ವರ್‌ನ IP ವಿಳಾಸ ಮತ್ತು ಕಸ್ಟಮ್ TFTP ತೆರೆದಿರುವ ಪೋರ್ಟ್ ಅನ್ನು ವಿನಂತಿಸುತ್ತದೆ (ಸ್ಟ್ಯಾಂಡರ್ಡ್ ಪ್ರೋಟೋಕಾಲ್‌ನೊಂದಿಗೆ ಹೊಂದಾಣಿಕೆಯಾಗದ ಕಾರಣ, ಪೋರ್ಟ್ ಅನ್ನು ಆಯ್ಕೆ ಮಾಡುವ ಸಾಮರ್ಥ್ಯವನ್ನು ಬಳಕೆದಾರರಿಗೆ ಬಿಡುವುದು ಸೂಕ್ತವೆಂದು ನಾನು ಪರಿಗಣಿಸಿದೆ), ಅದರ ನಂತರ a ಸಂಪರ್ಕವು ಸಂಭವಿಸುತ್ತದೆ, ಇದರ ಪರಿಣಾಮವಾಗಿ ಕ್ಲೈಂಟ್ ಆಜ್ಞೆಗಳಲ್ಲಿ ಒಂದನ್ನು ಕಳುಹಿಸಬಹುದು - ಪಡೆಯಿರಿ ಅಥವಾ ಇರಿಸಿ, ಫೈಲ್ ಅನ್ನು ಸ್ವೀಕರಿಸಲು ಅಥವಾ ಸರ್ವರ್‌ಗೆ ಕಳುಹಿಸಲು. ತರ್ಕವನ್ನು ಸರಳೀಕರಿಸಲು ಎಲ್ಲಾ ಫೈಲ್‌ಗಳನ್ನು ಬೈನರಿ ಮೋಡ್‌ನಲ್ಲಿ ಕಳುಹಿಸಲಾಗುತ್ತದೆ.

ಪ್ರೋಟೋಕಾಲ್ ಅನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು, ನಾನು ಸಾಂಪ್ರದಾಯಿಕವಾಗಿ 4 ವರ್ಗಗಳನ್ನು ಬಳಸಿದ್ದೇನೆ:

• TFTP ಕ್ಲೈಂಟ್
• TFTPS ಸರ್ವರ್
• TFTPClientTester
• TFTPS ಸರ್ವರ್ ಟೆಸ್ಟರ್

ಪರೀಕ್ಷಾ ತರಗತಿಗಳು ಮುಖ್ಯವಾದವುಗಳನ್ನು ಡೀಬಗ್ ಮಾಡಲು ಮಾತ್ರ ಅಸ್ತಿತ್ವದಲ್ಲಿವೆ ಎಂಬ ಅಂಶದಿಂದಾಗಿ, ನಾನು ಅವುಗಳನ್ನು ವಿಶ್ಲೇಷಿಸುವುದಿಲ್ಲ, ಆದರೆ ಕೋಡ್ ರೆಪೊಸಿಟರಿಯಲ್ಲಿರುತ್ತದೆ; ಅದರ ಲಿಂಕ್ ಅನ್ನು ಲೇಖನದ ಕೊನೆಯಲ್ಲಿ ಕಾಣಬಹುದು. ಈಗ ನಾನು ಮುಖ್ಯ ತರಗತಿಗಳನ್ನು ನೋಡುತ್ತೇನೆ.

TFTP ಕ್ಲೈಂಟ್

ಈ ವರ್ಗದ ಕಾರ್ಯವು ರಿಮೋಟ್ ಸರ್ವರ್‌ಗೆ ಅದರ ಐಪಿ ಮತ್ತು ಪೋರ್ಟ್ ಸಂಖ್ಯೆಯಿಂದ ಸಂಪರ್ಕಿಸುವುದು, ಇನ್‌ಪುಟ್ ಸ್ಟ್ರೀಮ್‌ನಿಂದ ಆಜ್ಞೆಯನ್ನು ಓದುವುದು (ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಕೀಬೋರ್ಡ್), ಅದನ್ನು ಪಾರ್ಸ್ ಮಾಡಿ, ಅದನ್ನು ಸರ್ವರ್‌ಗೆ ವರ್ಗಾಯಿಸಿ ಮತ್ತು ನೀವು ಎಂಬುದನ್ನು ಅವಲಂಬಿಸಿ ಫೈಲ್ ಅನ್ನು ಕಳುಹಿಸಲು ಅಥವಾ ಸ್ವೀಕರಿಸಲು, ಅದನ್ನು ವರ್ಗಾಯಿಸಲು ಅಥವಾ ಪಡೆದುಕೊಳ್ಳಲು ಅಗತ್ಯವಿದೆ.

ಸರ್ವರ್‌ಗೆ ಸಂಪರ್ಕಿಸಲು ಕ್ಲೈಂಟ್ ಅನ್ನು ಪ್ರಾರಂಭಿಸುವ ಕೋಡ್ ಮತ್ತು ಇನ್‌ಪುಟ್ ಸ್ಟ್ರೀಮ್‌ನಿಂದ ಆಜ್ಞೆಗಾಗಿ ಕಾಯುವುದು ಈ ರೀತಿ ಕಾಣುತ್ತದೆ. ಇಲ್ಲಿ ಬಳಸಲಾದ ಹಲವಾರು ಜಾಗತಿಕ ಅಸ್ಥಿರಗಳನ್ನು ಲೇಖನದ ಹೊರಗೆ, ಪ್ರೋಗ್ರಾಂನ ಪೂರ್ಣ ಪಠ್ಯದಲ್ಲಿ ವಿವರಿಸಲಾಗಿದೆ. ಅವರ ಕ್ಷುಲ್ಲಕತೆಯ ಕಾರಣದಿಂದಾಗಿ, ಲೇಖನವನ್ನು ಓವರ್ಲೋಡ್ ಮಾಡದಂತೆ ನಾನು ಅವುಗಳನ್ನು ಉಲ್ಲೇಖಿಸುವುದಿಲ್ಲ.

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

ಪಡೆಯಿರಿ ಅಥವಾ ಪುಟ್ ಹೊರತುಪಡಿಸಿ ಬೇರೆ ಆಜ್ಞೆಯನ್ನು ಕ್ಲೈಂಟ್ ವಿಂಡೋದಲ್ಲಿ ನಮೂದಿಸಿದರೆ, ಇನ್ಪುಟ್ ತಪ್ಪಾಗಿದೆ ಎಂದು ಸೂಚಿಸುವ ಶೋErrorMessage ಕಾರ್ಯವನ್ನು ಕರೆಯಲಾಗುತ್ತದೆ. ಕ್ಷುಲ್ಲಕತೆಯ ಕಾರಣ, ನಾನು ಅದನ್ನು ಉಲ್ಲೇಖಿಸುವುದಿಲ್ಲ. ಇನ್‌ಪುಟ್ ಸ್ಟ್ರಿಂಗ್ ಅನ್ನು ಸ್ವೀಕರಿಸುವ ಮತ್ತು ವಿಭಜಿಸುವ ಕಾರ್ಯವು ಸ್ವಲ್ಪ ಹೆಚ್ಚು ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ. ನಾವು ಸ್ಕ್ಯಾನರ್ ಅನ್ನು ಅದರೊಳಗೆ ಹಾದು ಹೋಗುತ್ತೇವೆ, ಇದರಿಂದ ನಾವು ಎರಡು ಸ್ಥಳಗಳಿಂದ ಪ್ರತ್ಯೇಕಿಸಲಾದ ಮತ್ತು ಆಜ್ಞೆ, ಮೂಲ ವಿಳಾಸ ಮತ್ತು ಗಮ್ಯಸ್ಥಾನದ ವಿಳಾಸವನ್ನು ಹೊಂದಿರುವ ರೇಖೆಯನ್ನು ಸ್ವೀಕರಿಸಲು ನಿರೀಕ್ಷಿಸುತ್ತೇವೆ.

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

ಫೈಲ್‌ಗೆ ಬರೆಯುವ ಸ್ಟ್ರೀಮ್ ಅನ್ನು ತೆರೆಯುವ ಮತ್ತು ಸಾಕೆಟ್‌ನಿಂದ ಎಲ್ಲಾ ಇನ್‌ಪುಟ್ ಬೈಟ್‌ಗಳನ್ನು ಬರೆಯುವ ರೈಟ್‌ಟೊಫೈಲ್‌ಫ್ರಾಮ್‌ಸಾಕೆಟ್ ವಿಧಾನವನ್ನು ಸುತ್ತುವ ಪುಟ್ ವಿಧಾನವು, ಬರಹ ಪೂರ್ಣಗೊಂಡಾಗ ವರ್ಗಾವಣೆಯ ಯಶಸ್ವಿ ಪೂರ್ಣಗೊಂಡ ಸಂದೇಶವನ್ನು ಪ್ರದರ್ಶಿಸುತ್ತದೆ.

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

ಸಾರಾಂಶಿಸು:

ಸರಳವಾದ ಡೇಟಾ ವರ್ಗಾವಣೆ ಪ್ರೋಟೋಕಾಲ್‌ನಲ್ಲಿ ನಾವು ನಮ್ಮದೇ ಆದ ಬದಲಾವಣೆಯನ್ನು ಬರೆದಿದ್ದೇವೆ ಮತ್ತು ಅದು ಹೇಗೆ ಕಾರ್ಯನಿರ್ವಹಿಸಬೇಕು ಎಂಬುದನ್ನು ಲೆಕ್ಕಾಚಾರ ಮಾಡಿದ್ದೇವೆ. ತಾತ್ವಿಕವಾಗಿ, ನಾನು ಇಲ್ಲಿ ಅಮೇರಿಕಾವನ್ನು ಕಂಡುಹಿಡಿಯಲಿಲ್ಲ ಮತ್ತು ಹೆಚ್ಚು ಹೊಸ ವಿಷಯಗಳನ್ನು ಬರೆಯಲಿಲ್ಲ, ಆದರೆ ಹಬ್ರೆಯಲ್ಲಿ ಯಾವುದೇ ರೀತಿಯ ಲೇಖನಗಳು ಇರಲಿಲ್ಲ, ಮತ್ತು cmd ಉಪಯುಕ್ತತೆಗಳ ಬಗ್ಗೆ ಲೇಖನಗಳ ಸರಣಿಯನ್ನು ಬರೆಯುವ ಭಾಗವಾಗಿ ಅದನ್ನು ಸ್ಪರ್ಶಿಸದಿರುವುದು ಅಸಾಧ್ಯವಾಗಿತ್ತು.

ಉಲ್ಲೇಖಗಳು:

ಮೂಲ ಕೋಡ್ ರೆಪೊಸಿಟರಿ
TFTP ಬಗ್ಗೆ ಸಂಕ್ಷಿಪ್ತವಾಗಿ
ಅದೇ ವಿಷಯ, ಆದರೆ ರಷ್ಯನ್ ಭಾಷೆಯಲ್ಲಿ

ಮೂಲ: www.habr.com