ჩაწერის პროგრამა Windows კლიენტ-სერვერის კომუნალური პროგრამების ფუნქციონირებით, ნაწილი 02

ვაგრძელებთ სტატიების სერიის მიმდინარე სერიებს, რომლებიც ეძღვნება Windows-ის კონსოლის კომუნალური პროგრამების პერსონალურ განხორციელებას, ჩვენ არ შეგვიძლია არ შევეხოთ TFTP (Trivial File Transfer Protocol) - მარტივი ფაილის გადაცემის პროტოკოლს.

როგორც ბოლო დროს, მოდით მოკლედ გადავიდეთ თეორიაზე, ვნახოთ კოდი, რომელიც ახორციელებს საჭირო ფუნქციის მსგავსს და გავაანალიზოთ. მეტი დეტალი - ჭრილის ქვეშ

მე არ ვაკოპირებ-პასტის საცნობარო ინფორმაციას, რომლის ბმულები ტრადიციულად შეგიძლიათ იხილოთ სტატიის ბოლოს, მე მხოლოდ ვიტყვი, რომ მისი ძირითადი ნაწილი TFTP არის FTP პროტოკოლის გამარტივებული ვარიაცია, რომელშიც წვდომის კონტროლის პარამეტრია. წაშლილია და სინამდვილეში არაფერია აქ ფაილის მიღებისა და გადაცემის ბრძანებების გარდა. ამასთან, იმისათვის, რომ ჩვენი განხორციელება ცოტა უფრო ელეგანტური და ადაპტირებული იყოს კოდის დაწერის ამჟამინდელ პრინციპებთან, სინტაქსი ოდნავ შეიცვალა - ეს არ ცვლის მოქმედების პრინციპებს, მაგრამ ინტერფეისი, IMHO, ცოტა უფრო ლოგიკური ხდება და აერთიანებს FTP და TFTP დადებით ასპექტებს.

კერძოდ, გაშვებისას კლიენტი ითხოვს სერვერის IP მისამართს და პორტს, რომელზეც ღიაა მორგებული TFTP (სტანდარტულ პროტოკოლთან შეუთავსებლობის გამო, მიზანშეწონილად მივიჩნიე მომხმარებლისთვის პორტის არჩევის შესაძლებლობა), რის შემდეგაც ხდება კავშირი, რის შედეგადაც კლიენტს შეუძლია გაგზავნოს ერთ-ერთი ბრძანება - მიიღოს ან დააყენოს, მიიღოს ან გაგზავნოს ფაილი სერვერზე. ყველა ფაილი იგზავნება ორობით რეჟიმში ლოგიკის გასამარტივებლად.

პროტოკოლის განსახორციელებლად მე ტრადიციულად ვიყენებდი 4 კლასს:

• TFTPClient
• TFTPS სერვერი
• TFTPClientTester
• TFTPServerTester

იმის გამო, რომ ტესტირების კლასები არსებობს მხოლოდ ძირითადის გამართვისთვის, მე მათ არ გავაანალიზებ, მაგრამ კოდი იქნება საცავში; მისი ბმული შეგიძლიათ იხილოთ სტატიის ბოლოს. ახლა მე გადავხედავ მთავარ კლასებს.

TFTPClient

ამ კლასის ამოცანაა დისტანციურ სერვერთან დაკავშირება მისი 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());
       }
    }

თუ კლიენტის ფანჯარაში შეყვანილი იქნება სხვა ბრძანება, გარდა 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());
        }
    }

სელექტორი არის ფუნქცია, რომელიც განსაზღვრავს პროგრამის მოქმედებებს შეყვანილი სტრიქონის მიხედვით. აქ ყველაფერი არც თუ ისე ლამაზია და გამოყენებული ხრიკი არ არის საუკეთესო კოდის ბლოკის გარეთ იძულებითი გასვლით, მაგრამ ამის მთავარი მიზეზი არის Java-ში ზოგიერთი რამის არარსებობა, როგორიცაა დელეგატები C#-ში, ფუნქციის მაჩვენებლები C++-დან ან მინიმუმ საშინელი და საშინელი goto, რომელიც საშუალებას გაძლევთ განახორციელოთ ეს ლამაზად. თუ იცით როგორ გააკეთოთ კოდი ცოტა უფრო ელეგანტური, მივესალმები კრიტიკას კომენტარებში. მეჩვენება, რომ აქ სტრინგ-დელეგატური ლექსიკონია საჭირო, მაგრამ დელეგატი არ არის...

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

put მეთოდი, რომელიც ახვევს 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());
        }
    }

რეზიუმე:

ჩვენ ახლახან დავწერეთ ჩვენი ვარიაცია მონაცემთა გადაცემის მარტივ პროტოკოლზე და გავარკვიეთ, როგორ უნდა იმუშაოს. პრინციპში, მე აქ ამერიკა არ აღმოვაჩინე და ბევრი ახალი რამ არ დამიწერია, მაგრამ ჰაბრეზე მსგავსი სტატიები არ ყოფილა და cmd-ის კომუნალური პროგრამების შესახებ სტატიების სერიის დაწერის ფარგლებში შეუძლებელი იყო მასზე არ შევეხოთ.

ბმულები:

წყარო კოდის საცავი
მოკლედ TFTP-ის შესახებ
იგივე, მაგრამ რუსულად

წყარო: www.habr.com