როგორ შევქმნათ ქსელის პროგრამა ჯავაში (სურათებით)

2024 ავტორი: Gilbert Ryder | [email protected]. ბოლოს შეცვლილი: 2023-12-16 17:35

კოდის წერა, რომელიც მუშაობს გარკვეულ მოწყობილობაზე, ძალიან დამაკმაყოფილებელია. მაგრამ, კოდის დაწერა, რომელიც მუშაობს რამდენიმე მოწყობილობაზე, რომლებიც ერთმანეთთან ურთიერთობენ, უბრალოდ სიცოცხლის დამამტკიცებელია. ეს სტატია გასწავლით თუ როგორ დააკავშიროთ და გაცვალოთ შეტყობინებები ქსელში გადაცემის კონტროლის პროტოკოლის (TCP) გამოყენებით.

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

მონაცემები და ობიექტური ნაკადები

სანამ კოდში ჩახვალ, სტატიაში გამოყენებულ ორ ნაკადს შორის განსხვავება უნდა განვასხვავო.

მონაცემთა ნაკადები

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

ობიექტის ნაკადები

ობიექტების ნაკადები ამუშავებენ მონაცემთა პრიმიტიულ ტიპებს და ობიექტებს, რომლებიც ახორციელებენ

სერიალიზებადი

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

ObjectOutputStream

ინიციალიზაციისთანავე აგზავნის სათაურს

InputStream

მეორე მხარისა, რომელიც ინიციალიზაციისას ბლოკავს შესრულებას სათაურის მიღებამდე.

ნაბიჯები

ნაბიჯი 1. შექმენით კლასი

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

NetworkApp მაგალითი

საჯარო კლასი NetworkAppExample {}

ნაბიჯი 2. შექმენით ძირითადი მეთოდი

შექმენით ძირითადი მეთოდი და განაცხადეთ, რომ შესაძლოა გამონაკლისი იყოს

გამონაკლისი

ტიპი და მისი ნებისმიერი ქვეკლასი - ყველა გამონაკლისი. ეს ითვლება ცუდი პრაქტიკა, მაგრამ მისაღებია შიშველი მაგალითებისთვის.

საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {}}

ნაბიჯი 3. გამოაცხადეთ სერვერის მისამართი

ეს მაგალითი გამოიყენებს ლოკალური მასპინძლის მისამართს და თვითნებური პორტის ნომერს. პორტის ნომერი უნდა იყოს 0 -დან 65535 -მდე (ჩათვლით). თუმცა, პორტების რიცხვები, რომლებიც თავიდან უნდა იქნას აცილებული, მერყეობს 0 -დან 1023 -მდე (ჩათვლით), რადგან ისინი დაცული სისტემის პორტებია.

საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; }}

ნაბიჯი 4. შექმენით სერვერი

სერვერი უკავშირდება მისამართს და პორტს და უსმენს შემომავალ კავშირებს. ჯავაში,

ServerSocket

წარმოადგენს სერვერის ბოლო წერტილს და მისი ფუნქციაა ახალი კავშირების მიღება.

ServerSocket

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

იმპორტი java.net. InetAddress; java.net. ServerSocket იმპორტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); }}

ნაბიჯი 5. სერვერის დაწყება

აღრიცხვის მიზნით, დაბეჭდეთ სერვერი დაწყებული კონსოლზე.

იმპორტი java.net. InetAddress; java.net. ServerSocket იმპორტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); }}

ნაბიჯი 6. შექმენით კლიენტი

კლიენტი აკავშირებს სერვერის მისამართს და პორტს და უსმენს პაკეტებს (შეტყობინებებს) კავშირის დამყარების შემდეგ. ჯავაში,

სოკეტი

წარმოადგენს ან კლიენტის მხრიდან საბოლოო წერტილს, რომელიც დაკავშირებულია სერვერთან, ან კავშირს (სერვერიდან) კლიენტთან და გამოიყენება მეორე მხარესთან კომუნიკაციისთვის.

იმპორტი java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. სოკეტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); სოკეტის კლიენტი = ახალი სოკეტი (მასპინძელი, პორტი); }}

ნაბიჯი 7. ჟურნალ კავშირის მცდელობა

აღრიცხვის მიზნით, დაბეჭდეთ კონსოლზე, რომ კავშირი იყო მცდელობა.

იმპორტი java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. სოკეტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); სოკეტის კლიენტი = ახალი სოკეტი (მასპინძელი, პორტი); System.out.println ("სერვერთან დაკავშირება …"); }}

ნაბიჯი 8. დაამყარეთ კავშირი

კლიენტები არასოდეს დაუკავშირდებიან, თუ სერვერი არ მოუსმენს და არ მიიღებს, სხვა სიტყვებით რომ ვთქვათ, კავშირებს. ჯავაში, კავშირები დამყარებულია გამოყენებით

მიიღე ()

მეთოდი

ServerSocket

კლასი. მეთოდი დაბლოკავს შესრულებას კლიენტის დაკავშირებამდე.

იმპორტი java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. სოკეტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); სოკეტის კლიენტი = ახალი სოკეტი (მასპინძელი, პორტი); System.out.println ("სერვერთან დაკავშირება …"); სოკეტის კავშირი = server.accept (); }}

ნაბიჯი 9. ჩაწერეთ კავშირი

შესვლის მიზნით, დაბეჭდეთ კონსოლზე, რომ დამყარებულია კავშირი სერვერსა და კლიენტს შორის.

იმპორტი java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. სოკეტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); სოკეტის კლიენტი = ახალი სოკეტი (მასპინძელი, პორტი); System.out.println ("სერვერთან დაკავშირება …"); სოკეტის კავშირი = server.accept (); System.out.println ("კავშირი დამყარდა."); }}

ნაბიჯი 10. მოამზადეთ საკომუნიკაციო ნაკადები

კომუნიკაცია ხდება ნაკადებზე და, ამ აპლიკაციაში, სერვერის (კლიენტისგან) და კლიენტის ნედლი ნაკადები უნდა იყოს მიჯაჭვული მონაცემთა ან ობიექტის ნაკადებზე. გახსოვდეთ, ორივე მხარემ უნდა გამოიყენოს ერთი და იგივე ნაკადის ტიპი.

• მონაცემთა ნაკადები

  java.io. DataInputStream იმპორტი; java.io. DataOutputStream იმპორტი; იმპორტი java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. სოკეტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); სოკეტის კლიენტი = ახალი სოკეტი (მასპინძელი, პორტი); System.out.println ("სერვერთან დაკავშირება …"); სოკეტის კავშირი = server.accept (); System.out.println ("კავშირი დამყარდა."); DataOutputStream clientOut = ახალი DataOutputStream (client.getOutputStream ()); DataInputStream clientIn = ახალი DataInputStream (client.getInputStream ()); DataOutputStream serverOut = ახალი DataOutputStream (connection.getOutputStream ()); DataInputStream serverIn = ახალი DataInputStream (connection.getInputStream ()); }}
  

• ობიექტის ნაკადები

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

  ObjectOutputStream

  უგზავნის სათაურს მეორე მხარეს და

  ObjectInputStream

  ბლოკავს შესრულებას სანამ არ წაიკითხავს სათაურს.

  java.io. ObjectInputStream იმპორტი; java.io. ObjectOutputStream იმპორტი; იმპორტი java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. სოკეტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); სოკეტის კლიენტი = ახალი სოკეტი (მასპინძელი, პორტი); System.out.println ("სერვერთან დაკავშირება …"); სოკეტის კავშირი = server.accept (); System.out.println ("კავშირი დამყარდა."); ObjectOutputStream clientOut = ახალი ObjectOutputStream (client.getOutputStream ()); ObjectOutputStream serverOut = ახალი ObjectOutputStream (connection.getOutputStream ()); ObjectInputStream clientIn = ახალი ObjectInputStream (client.getInputStream ()); ObjectInputStream serverIn = ახალი ObjectInputStream (connection.getInputStream ()); }}
  

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

  ObjectOutputStream clientOut = ახალი ObjectOutputStream (client.getOutputStream ()); ObjectInputStream serverIn = ახალი ObjectInputStream (connection.getInputStream ()); ObjectOutputStream serverOut = ახალი ObjectOutputStream (connection.getOutputStream ()); ObjectInputStream clientIn = ახალი ObjectInputStream (client.getInputStream ());
  

ნაბიჯი 11. შეაფასეთ, რომ კომუნიკაცია მზად არის

აღრიცხვის მიზნით, დაბეჭდეთ კონსოლზე, რომ კომუნიკაცია მზად არის.

// კოდი გამოტოვებული java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. სოკეტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); სოკეტის კლიენტი = ახალი სოკეტი (მასპინძელი, პორტი); System.out.println ("სერვერთან დაკავშირება …"); სოკეტის კავშირი = server.accept (); System.out.println ("კავშირი დამყარდა."); // კოდი გამოტოვებული System.out.println ("კომუნიკაცია მზად არის."); }}

ნაბიჯი 12. შექმენით შეტყობინება

ამ განაცხადში,

Გამარჯობა მსოფლიო

ტექსტი გაიგზავნება სერვერზე როგორც

ბაიტი

ან

სიმებიანი

რა გამოაცხადეთ ისეთი ცვლადი, რომელიც დამოკიდებულია გამოყენებულ ნაკადზე. გამოყენება

ბაიტი

მონაცემთა ნაკადებისთვის და

სიმებიანი

ობიექტების ნაკადებისთვის.

• მონაცემთა ნაკადები

  მონაცემთა ნაკადების გამოყენებით, სერიალიზაცია ხდება ობიექტების პრიმიტიულ ტიპებად ან ა

  სიმებიანი

  რა Ამ შემთხვევაში,

  სიმებიანი

  გარდაიქმნება

  ბაიტი

  ნაცვლად დაწერილი გამოყენებით

  writeBytes ()

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

  java.io. DataInputStream იმპორტი; java.io. DataOutputStream იმპორტი; იმპორტი java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. სოკეტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); სოკეტის კლიენტი = ახალი სოკეტი (მასპინძელი, პორტი); System.out.println ("სერვერთან დაკავშირება …"); სოკეტის კავშირი = server.accept (); System.out.println ("კავშირი დამყარდა."); DataOutputStream clientOut = ახალი DataOutputStream (client.getOutputStream ()); DataInputStream clientIn = ახალი DataInputStream (client.getInputStream ()); DataOutputStream serverOut = ახალი DataOutputStream (connection.getOutputStream ()); DataInputStream serverIn = ახალი DataInputStream (connection.getInputStream ()); System.out.println ("კომუნიკაცია მზად არის."); ბაიტი messageOut = "გამარჯობა მსოფლიო".getBytes (); }}
  

• ობიექტის ნაკადები

  java.io. ObjectInputStream იმპორტი; java.io. ObjectOutputStream იმპორტი; იმპორტი java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. სოკეტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); სოკეტის კლიენტი = ახალი სოკეტი (მასპინძელი, პორტი); System.out.println ("სერვერთან დაკავშირება …"); სოკეტის კავშირი = server.accept (); System.out.println ("კავშირი დამყარდა."); ObjectOutputStream clientOut = ახალი ObjectOutputStream (client.getOutputStream ()); ObjectOutputStream serverOut = ახალი ObjectOutputStream (connection.getOutputStream ()); ObjectInputStream clientIn = ახალი ObjectInputStream (client.getInputStream ()); ObjectInputStream serverIn = ახალი ObjectInputStream (connection.getInputStream ()); System.out.println ("კომუნიკაცია მზად არის."); String messageOut = "გამარჯობა მსოფლიო"; }}
  

ნაბიჯი 13. გაგზავნეთ შეტყობინება

ჩაწერეთ მონაცემები გამომავალ ნაკადზე და გაწურეთ ნაკადი, რათა დარწმუნდეთ, რომ მონაცემები მთლიანად დაიწერა.

• მონაცემთა ნაკადები

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

  java.io. DataInputStream იმპორტი; java.io. DataOutputStream იმპორტი; იმპორტი java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. სოკეტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); სოკეტის კლიენტი = ახალი სოკეტი (მასპინძელი, პორტი); System.out.println ("სერვერთან დაკავშირება …"); სოკეტის კავშირი = server.accept (); System.out.println ("კავშირი დამყარდა."); DataOutputStream clientOut = ახალი DataOutputStream (client.getOutputStream ()); DataInputStream clientIn = ახალი DataInputStream (client.getInputStream ()); DataOutputStream serverOut = ახალი DataOutputStream (connection.getOutputStream ()); DataInputStream serverIn = ახალი DataInputStream (connection.getInputStream ()); System.out.println ("კომუნიკაცია მზად არის."); ბაიტი messageOut = "გამარჯობა მსოფლიო".getBytes (); clientOut.writeInt (messageOut.length); clientOut.write (messageOut); clientOut.flush (); }}
  

• ობიექტის ნაკადები

  java.io. ObjectInputStream იმპორტი; java.io. ObjectOutputStream იმპორტი; იმპორტი java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. სოკეტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); სოკეტის კლიენტი = ახალი სოკეტი (მასპინძელი, პორტი); System.out.println ("სერვერთან დაკავშირება …"); სოკეტის კავშირი = server.accept (); System.out.println ("კავშირი დამყარდა."); ObjectOutputStream clientOut = ახალი ObjectOutputStream (client.getOutputStream ()); ObjectOutputStream serverOut = ახალი ObjectOutputStream (connection.getOutputStream ()); ObjectInputStream clientIn = ახალი ObjectInputStream (client.getInputStream ()); ObjectInputStream serverIn = ახალი ObjectInputStream (connection.getInputStream ()); System.out.println ("კომუნიკაცია მზად არის."); String messageOut = "გამარჯობა მსოფლიო"; clientOut.writeObject (messageOut); clientOut.flush (); }}
  

ნაბიჯი 14. შესული გაგზავნილი შეტყობინება

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

• მონაცემთა ნაკადები

  java.io. DataInputStream იმპორტი; java.io. DataOutputStream იმპორტი; იმპორტი java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. სოკეტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); სოკეტის კლიენტი = ახალი სოკეტი (მასპინძელი, პორტი); System.out.println ("სერვერთან დაკავშირება …"); სოკეტის კავშირი = server.accept (); System.out.println ("კავშირი დამყარდა."); DataOutputStream clientOut = ახალი DataOutputStream (client.getOutputStream ()); DataInputStream clientIn = ახალი DataInputStream (client.getInputStream ()); DataOutputStream serverOut = ახალი DataOutputStream (connection.getOutputStream ()); DataInputStream serverIn = ახალი DataInputStream (connection.getInputStream ()); System.out.println ("კომუნიკაცია მზად არის."); ბაიტი messageOut = "გამარჯობა მსოფლიო".getBytes (); clientOut.writeInt (messageOut.length); clientOut.write (messageOut); clientOut.flush (); System.out.println ("შეტყობინება გაიგზავნა სერვერზე:" + ახალი სიმებიანი (messageOut)); }}
  

• ობიექტის ნაკადები

  java.io. ObjectInputStream იმპორტი; java.io. ObjectOutputStream იმპორტი; იმპორტი java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. სოკეტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); სოკეტის კლიენტი = ახალი სოკეტი (მასპინძელი, პორტი); System.out.println ("სერვერთან დაკავშირება …"); სოკეტის კავშირი = server.accept (); System.out.println ("კავშირი დამყარდა."); ObjectOutputStream clientOut = ახალი ObjectOutputStream (client.getOutputStream ()); ObjectOutputStream serverOut = ახალი ObjectOutputStream (connection.getOutputStream ()); ObjectInputStream clientIn = ახალი ObjectInputStream (client.getInputStream ()); ObjectInputStream serverIn = ახალი ObjectInputStream (connection.getInputStream ()); System.out.println ("კომუნიკაცია მზად არის."); String messageOut = "გამარჯობა მსოფლიო"; clientOut.writeObject (messageOut); clientOut.flush (); System.out.println ("შეტყობინება გაიგზავნა სერვერზე:" + messageOut); }}
  

ნაბიჯი 15. წაიკითხეთ შეტყობინება

წაიკითხეთ მონაცემები შეყვანის ნაკადიდან და გადააკეთეთ იგი. ვინაიდან ჩვენ ზუსტად ვიცით გაგზავნილი მონაცემების ტიპი, ჩვენ ან შევქმნით a

სიმებიანი

დან

ბაიტი

ან მსახიობი

ობიექტი

რათა

სიმებიანი

შემოწმების გარეშე, გამოყენებული ნაკადიდან გამომდინარე.

• მონაცემთა ნაკადები

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

  სიმებიანი

  java.io. DataInputStream იმპორტი; java.io. DataOutputStream იმპორტი; იმპორტი java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. სოკეტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); სოკეტის კლიენტი = ახალი სოკეტი (მასპინძელი, პორტი); System.out.println ("სერვერთან დაკავშირება …"); სოკეტის კავშირი = server.accept (); System.out.println ("კავშირი დამყარდა."); DataOutputStream clientOut = ახალი DataOutputStream (client.getOutputStream ()); DataInputStream clientIn = ახალი DataInputStream (client.getInputStream ()); DataOutputStream serverOut = ახალი DataOutputStream (connection.getOutputStream ()); DataInputStream serverIn = ახალი DataInputStream (connection.getInputStream ()); System.out.println ("კომუნიკაცია მზად არის."); ბაიტი messageOut = "გამარჯობა მსოფლიო".getBytes (); clientOut.writeInt (messageOut.length); clientOut.write (messageOut); clientOut.flush (); System.out.println ("შეტყობინება გაიგზავნა სერვერზე:" + ახალი სიმებიანი (messageOut)); int სიგრძე = serverIn.readInt (); if (სიგრძე> 0) {ბაიტი messageIn = ახალი ბაიტი [სიგრძე]; serverIn.readFully (messageIn, 0, messageIn.length); }}}
  

• ობიექტის ნაკადები

  java.io. ObjectInputStream იმპორტი; java.io. ObjectOutputStream იმპორტი; იმპორტი java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. სოკეტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); სოკეტის კლიენტი = ახალი სოკეტი (მასპინძელი, პორტი); System.out.println ("სერვერთან დაკავშირება …"); სოკეტის კავშირი = server.accept (); System.out.println ("კავშირი დამყარდა."); ObjectOutputStream clientOut = ახალი ObjectOutputStream (client.getOutputStream ()); ObjectOutputStream serverOut = ახალი ObjectOutputStream (connection.getOutputStream ()); ObjectInputStream clientIn = ახალი ObjectInputStream (client.getInputStream ()); ObjectInputStream serverIn = ახალი ObjectInputStream (connection.getInputStream ()); System.out.println ("კომუნიკაცია მზად არის."); String messageOut = "გამარჯობა მსოფლიო"; clientOut.writeObject (messageOut); clientOut.flush (); System.out.println ("შეტყობინება გაიგზავნა სერვერზე:" + messageOut); სიმებიანი messageIn = (სიმებიანი) serverIn.readObject (); }}
  

ნაბიჯი 16. ჩაწერეთ წაკითხული შეტყობინება

შესვლის მიზნით, დაბეჭდეთ კონსოლზე, რომ შეტყობინება მიღებულია და დაბეჭდეთ მისი შინაარსი.

• მონაცემთა ნაკადები

  java.io. DataInputStream იმპორტი; java.io. DataOutputStream იმპორტი; იმპორტი java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. სოკეტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); სოკეტის კლიენტი = ახალი სოკეტი (მასპინძელი, პორტი); System.out.println ("სერვერთან დაკავშირება …"); სოკეტის კავშირი = server.accept (); System.out.println ("კავშირი დამყარდა."); DataOutputStream clientOut = ახალი DataOutputStream (client.getOutputStream ()); DataInputStream clientIn = ახალი DataInputStream (client.getInputStream ()); DataOutputStream serverOut = ახალი DataOutputStream (connection.getOutputStream ()); DataInputStream serverIn = ახალი DataInputStream (connection.getInputStream ()); System.out.println ("კომუნიკაცია მზად არის."); ბაიტი messageOut = "გამარჯობა მსოფლიო".getBytes (); clientOut.writeInt (messageOut.length); clientOut.write (messageOut); clientOut.flush (); System.out.println ("შეტყობინება გაიგზავნა სერვერზე:" + ახალი სიმებიანი (messageOut)); int სიგრძე = serverIn.readInt (); if (სიგრძე> 0) {ბაიტი messageIn = ახალი ბაიტი [სიგრძე]; serverIn.readFully (messageIn, 0, messageIn.length); System.out.println ("კლიენტისგან მიღებული შეტყობინება:" + ახალი სიმებიანი (messageIn)); }}}
  

• ობიექტის ნაკადები

  java.io. ObjectInputStream იმპორტი; java.io. ObjectOutputStream იმპორტი; იმპორტი java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. სოკეტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); სოკეტის კლიენტი = ახალი სოკეტი (მასპინძელი, პორტი); System.out.println ("სერვერთან დაკავშირება …"); სოკეტის კავშირი = server.accept (); System.out.println ("კავშირი დამყარდა."); ObjectOutputStream clientOut = ახალი ObjectOutputStream (client.getOutputStream ()); ObjectOutputStream serverOut = ახალი ObjectOutputStream (connection.getOutputStream ()); ObjectInputStream clientIn = ახალი ObjectInputStream (client.getInputStream ()); ObjectInputStream serverIn = ახალი ObjectInputStream (connection.getInputStream ()); System.out.println ("კომუნიკაცია მზად არის."); String messageOut = "გამარჯობა მსოფლიო"; clientOut.writeObject (messageOut); clientOut.flush (); System.out.println ("შეტყობინება გაიგზავნა სერვერზე:" + messageOut); სიმებიანი messageIn = (სიმებიანი) serverIn.readObject (); System.out.println ("კლიენტისგან მიღებული შეტყობინება:" + messageIn); }}
  

ნაბიჯი 17. კავშირების გაწყვეტა

კავშირი გათიშულია, როდესაც ერთი მხარე ხურავს თავის ნაკადებს. ჯავაში, გამომავალი ნაკადის დახურვით, დახურულია დაკავშირებული სოკეტი და შეყვანის ნაკადიც. მას შემდეგ, რაც მეორე მხარე აღმოაჩენს, რომ კავშირი მკვდარია, მას უნდა დახუროს მისი გამომავალი ნაკადი, ასევე მეხსიერების გაჟონვის თავიდან ასაცილებლად.

// კოდი გამოტოვებული java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. სოკეტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); სოკეტის კლიენტი = ახალი სოკეტი (მასპინძელი, პორტი); System.out.println ("სერვერთან დაკავშირება …"); სოკეტის კავშირი = server.accept (); System.out.println ("კავშირი დამყარდა."); // კოდი გამოტოვებული System.out.println ("კომუნიკაცია მზად არის."); // კოდი გამოტოვებული clientOut.close (); serverOut.close (); }}

ნაბიჯი 18. ჟურნალის გათიშვა

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

// კოდი გამოტოვებული java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. სოკეტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); სოკეტის კლიენტი = ახალი სოკეტი (მასპინძელი, პორტი); System.out.println ("სერვერთან დაკავშირება …"); სოკეტის კავშირი = server.accept (); System.out.println ("კავშირი დამყარდა."); // კოდი გამოტოვებული System.out.println ("კომუნიკაცია მზად არის."); // კოდი გამოტოვებული clientOut.close (); serverOut.close (); System.out.println ("კავშირები დაიხურა."); }}

ნაბიჯი 19. სერვერის შეწყვეტა

კავშირები გათიშულია, მაგრამ სერვერი კვლავ მუშაობს. როგორც

ServerSocket

არ არის დაკავშირებული რაიმე ნაკადთან, ის მკაფიოდ უნდა დაიხუროს დარეკვით

დახურვა ()

მეთოდი.

// კოდი გამოტოვებული java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. სოკეტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); სოკეტის კლიენტი = ახალი სოკეტი (მასპინძელი, პორტი); System.out.println ("სერვერთან დაკავშირება …"); სოკეტის კავშირი = server.accept (); System.out.println ("კავშირი დამყარდა."); // კოდი გამოტოვებული System.out.println ("კომუნიკაცია მზად არის."); // კოდი გამოტოვებული clientOut.close (); serverOut.close (); System.out.println ("კავშირები დაიხურა."); server.close (); }}

ნაბიჯი 20. ლოგის სერვერის შეწყვეტა

რეგისტრაციის მიზნით, კონსოლის სერვერზე დაბეჭდვა შეწყდა.

// კოდი გამოტოვებული java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. სოკეტი; საჯარო კლასი NetworkAppExample {public static void main (String args) აგდებს გამონაკლისს {String host = "localhost"; int პორტი = 10430; ServerSocket სერვერი = ახალი ServerSocket (პორტი, 50, InetAddress.getByName (მასპინძელი)); System.out.println ("სერვერი დაიწყო."); სოკეტის კლიენტი = ახალი სოკეტი (მასპინძელი, პორტი); System.out.println ("სერვერთან დაკავშირება …"); სოკეტის კავშირი = server.accept (); System.out.println ("კავშირი დამყარდა."); // კოდი გამოტოვებული System.out.println ("კომუნიკაცია მზად არის."); // კოდი გამოტოვებული clientOut.close (); serverOut.close (); System.out.println ("კავშირები დაიხურა."); server.close (); System.out.println ("სერვერი შეწყდა."); }}

ნაბიჯი 21. შეადგინეთ და გაუშვით

შესვლა გვაძლევს საშუალებას ვიცოდეთ პროგრამა წარმატებულია თუ არა. მოსალოდნელი გამომავალი:

სერვერი დაიწყო. სერვერთან დაკავშირება… კავშირი დამყარდა. კომუნიკაცია მზად არის. სერვერზე გაგზავნილი შეტყობინება: გამარჯობა მსოფლიო კლიენტისგან მიღებული შეტყობინება: გამარჯობა მსოფლიო კავშირები დაიხურა. სერვერი შეწყდა.

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

• თუ გამომავალი ხაზზე ჩერდება

  კავშირი დამყარდა.

  და ობიექტის ნაკადები გამოიყენება, ჩამოიბანეთ თითოეული

  ObjectOutputStream

• ინიციალიზაციისთანავე, რადგან სათაურები, რატომღაც, არ გაიგზავნა.

• თუ გამომავალი იბეჭდება

  java.net. BindException: მისამართი უკვე გამოიყენება

• აირჩიეთ სხვა პორტის ნომერი, რადგან მითითებული უკვე გამოიყენება.

Რჩევები

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

მაგალითები

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

სერვერი. Java

იმპორტი java.io. IOException; იმპორტი java.net. InetAddress; java.net. ServerSocket იმპორტი; იმპორტი java.net. SocketException; იმპორტი java.net. UnknownHostException; იმპორტი java.util. ArrayList; იმპორტი java.util. კოლექციები; იმპორტი java.util. List; /*** კლასი {@კოდი სერვერი} წარმოადგენს სერვერის საბოლოო წერტილს ქსელში. {@კოდი სერვერი}, როდესაც დაუკავშირდება გარკვეულ IP * მისამართს და პორტს, ამყარებს კავშირებს კლიენტებთან და შეუძლია მათთან კომუნიკაცია ან მათი გათიშვა. *
* ეს კლასი არის უსაფრთხო. * * @version 1.0 * @see Client * @see Connection */ public class სერვერი ახორციელებს Runnable {კერძო ServerSocket სერვერს; პირადი სია კავშირები; პირადი თემის თემა; კერძო საბოლოო ობიექტის კავშირები დაბლოკვა = ახალი ობიექტი (); /** * აშენებს {@კოდის სერვერს}, რომელიც ურთიერთობს კლიენტებთან მითითებული მასპინძლის სახელზე და პორტზე მითითებული * მოთხოვნილი მაქსიმალური სიგრძით შემომავალი კლიენტების რიგის. * * @param მასპინძლის მისამართი გამოსაყენებლად. * @param პორტი პორტის ნომერი გამოსაყენებლად. * @param backlog მოითხოვა შემომავალი კლიენტების რიგის მაქსიმალური სიგრძე. * @throws NetworkException თუ სერვერის გაშვებისას მოხდა შეცდომა. */ public server (სიმებიანი მასპინძელი, int პორტი, int backlog) ისვრის NetworkException {try {server = new ServerSocket (port, backlog, InetAddress.getByName (host)); } catch (UnknownHostException ე) {გადააგდე ახალი NetworkException ("მასპინძლის სახელი ვერ გადაწყდა:" + მასპინძელი, ე); } catch (IllegalArgumentException ე) {გადააგდე ახალი NetworkException ("პორტის ნომერი უნდა იყოს 0 -დან 65535 -მდე (ჩათვლით):" + პორტი); } catch (IOException ე) {გადააგდე ახალი NetworkException ("სერვერის დაწყება ვერ მოხერხდა.", ე); } connections = Collections.synchronizedList (ახალი ArrayList ()); ძაფი = ახალი თემა (ეს); ძაფი. დაწყება (); } /*** აშენებს {@კოდი სერვერს}, რომელიც ურთიერთობს კლიენტებთან მითითებული მასპინძლის სახელზე და პორტზე. * * @param მასპინძლის მისამართი სავალდებულოა. * @param port პორტის ნომერი დასაკავშირებლად. * @throws NetworkException თუ შეცდომები ხდება სერვერის დაწყებისას. */ public server (სიმებიანი მასპინძელი, int პორტი) ისვრის NetworkException {this (მასპინძელი, პორტი, 50); } /*** ისმენს, იღებს და აღრიცხავს კლიენტებისგან შემოსულ კავშირებს. */ @Override public void run () {while (! Server.isClosed ()) {try {connections.add (new Connection (server.accept ())); } catch (SocketException ე) {if (! e.getMessage (). უდრის ("სოკეტი დახურულია")) {e.printStackTrace (); }} catch (NetworkException | IOException ე) {e.printStackTrace (); }}} /*** უგზავნის მონაცემებს ყველა რეგისტრირებულ კლიენტს. * * @param მონაცემები გასაგზავნი მონაცემები. * @throws IllegalStateException თუ მონაცემთა ჩაწერა ხდება მაშინ, როდესაც სერვერი ხაზგარეშეა. * @throws IllegalArgumentException თუ გასაგზავნი მონაცემები არის ნულოვანი. */ public void broadcast (ობიექტის მონაცემები) {if (server.isClosed ()) {ჩააგდე ახალი IllegalStateException ("მონაცემები არ არის გაგზავნილი, სერვერი ხაზგარეშეა."); } if (data == null) {ჩააგდე ახალი IllegalArgumentException ("null data"); } სინქრონიზებული (connectionsLock) {for (კავშირის კავშირი: კავშირები) {try {connection.send (მონაცემები); System.out.println ("მონაცემები წარმატებით გაიგზავნა კლიენტთან."); } catch (NetworkException e) {e.printStackTrace (); }}}} /*** აგზავნის გათიშვის შეტყობინებას და წყვეტს მითითებულ კლიენტს. * * @param კავშირი კლიენტი გათიშულია. * @throws NetworkException თუ კავშირის დახურვისას მოხდა შეცდომა. */ public void disconnect (Connection connection) ისვრის NetworkException {if (connections.remove (connection)) {connection.close (); }} /*** უგზავნის გათიშვის შეტყობინებას ყველა კლიენტს, გათიშავს მათ და წყვეტს სერვერს. */ public void close () ისვრის NetworkException {სინქრონიზებული (connectionsLock) {for (კავშირის კავშირი: კავშირები) {try {connection.close (); } catch (NetworkException e) {e.printStackTrace (); }}} connections.clear (); სცადეთ {server.close (); } catch (IOException e) {ჩააგდე ახალი NetworkException ("შეცდომა სერვერის დახურვისას."); } საბოლოოდ {thread.interrupt (); }} /*** აბრუნებს თუ არა სერვერი ონლაინ რეჟიმში. * * @return True თუ სერვერი ონლაინ რეჟიმშია. ყალბი, სხვაგვარად. */ public boolean isOnline () {return! server.isClosed (); } /*** აბრუნებს რეგისტრირებული კლიენტების მასივს. */ public Connection getConnections () {სინქრონიზებული (connectionsLock) {დაბრუნება connections.toArray (ახალი კავშირი [connections.size ()]); }}} 

კლიენტი. Java

იმპორტი java.io. IOException; იმპორტი java.net. სოკეტი; იმპორტი java.net. UnknownHostException; /*** კლასი {@კოდი კლიენტი} წარმოადგენს კლიენტის საბოლოო წერტილს ქსელში. {@კოდი კლიენტი}, როდესაც დაკავშირებულია გარკვეულ * სერვერთან, გარანტირებულია მხოლოდ სერვერთან კომუნიკაციის შესაძლებლობა. მიიღებს თუ არა სხვა კლიენტები მონაცემებს * დამოკიდებულია სერვერის განხორციელებაზე. *
* ეს კლასი არის უსაფრთხო. * * @version 1.0 * @see Server * @see Connection */ public class Client {private Connection connection; /*** აშენებს სერვერთან დაკავშირებულ {@კოდი კლიენტს} მითითებულ მასპინძელსა და პორტში. * * @param მასპინძლის მისამართი სავალდებულოა. * @param port პორტის ნომერი დასაკავშირებლად. * @throws NetworkException თუ სერვერის გაშვებისას მოხდა შეცდომა. */ public Client (სიმებიანი მასპინძელი, int პორტი) ისვრის NetworkException {try {connection = new Connection (new Socket (host, port)); } catch (UnknownHostException ე) {გადააგდე ახალი NetworkException ("მასპინძლის სახელი ვერ გადაწყდა:" + მასპინძელი, ე); } catch (IllegalArgumentException ე) {გადააგდე ახალი NetworkException ("პორტის ნომერი უნდა იყოს 0 -დან 65535 -მდე (ჩათვლით):" + პორტი); } catch (IOException e) {გადააგდე ახალი NetworkException ("სერვერის დაწყება ვერ მოხერხდა.", ე); }} /*** უგზავნის მონაცემებს მეორე მხარეს. * * @param მონაცემები გასაგზავნი მონაცემები. * @throws NetworkException თუ გამომავალ ნაკადზე ჩაწერა ვერ მოხერხდება. * @throws IllegalStateException თუ კავშირის დახურვისას ხდება მონაცემთა ჩაწერის მცდელობა. * @throws IllegalArgumentException თუ გასაგზავნი მონაცემები არის ნულოვანი. * @throws UnsupportedOperationException თუ მონაცემთა დაუცველი ტიპის გაგზავნის მცდელობაა. */ public void send (ობიექტის მონაცემები) ისვრის NetworkException {connection.send (მონაცემები); } /*** აგზავნის გათიშვის შეტყობინებას და წყვეტს კავშირს სერვერთან. */ public void close () ისვრის NetworkException {connection.close (); } /*** აბრუნებს თუ არა კლიენტი სერვერთან დაკავშირებული. * * @return True თუ კლიენტი დაკავშირებულია. ყალბი, სხვაგვარად. */ public boolean isOnline () {return connection.isConnected (); } /*** აბრუნებს კლიენტის {@link Connection} მაგალითს. */ public Connection getConnection () {დაბრუნების კავშირი; }}

კავშირი. Java

java.io. DataInputStream იმპორტი; java.io. DataOutputStream იმპორტი; იმპორტი java.io. IOException; იმპორტი java.net. სოკეტი; იმპორტი java.net. SocketException; /** * კლასი {@code Connection} წარმოადგენს ან კავშირს სერვერიდან კლიენტთან, ან კლიენტის ბოლო წერტილს ქსელში * {@code Connection}, მას შემდეგ რაც დაკავშირდება, შეუძლია მონაცემების გაცვლა სხვა მხარეებთან ან მხარეებთან, რაც დამოკიდებულია სერვერზე * განხორციელება. *
* ეს კლასი არის უსაფრთხო. * * @version 1.0 * @see Server * @see Client */ public class Connection ახორციელებს Runnable {private Socket socket; პირადი DataOutputStream out; პირადი DataInputStream in; პირადი თემის თემა; პირადი საბოლოო ობიექტი writeLock = ახალი ობიექტი (); კერძო საბოლოო ობიექტი readLock = ახალი ობიექტი (); /*** აშენებს {@code Connection} განსაზღვრული {@link Socket} ნაკადების გამოყენებით. * * @param socket სოკეტი ნაკადების მოსატანად.*/ public Connection (Socket socket) ისვრის NetworkException {if (socket == null) {throw new IllegalArgumentException ("null socket"); } this.socket = სოკეტი; სცადეთ {out = new DataOutputStream (socket.getOutputStream ()); } catch (IOException ე) {გადააგდე ახალი NetworkException ("გამომავალ ნაკადზე წვდომა ვერ მოხერხდა.", ე); } ცადე {in = new DataInputStream (socket.getInputStream ()); } catch (IOException ე) {გადააგდე ახალი NetworkException ("შეყვანის ნაკადზე წვდომა ვერ მოხერხდა.", ე); } თემა = ახალი თემა (ეს); ძაფი. დაწყება (); } /*** კითხულობს შეტყობინებებს სანამ მეორე მხარესთან კავშირი ცოცხალია. */ @Override public void run () {while (! Socket.isClosed ()) {try {int identifier; ბაიტი ბაიტი; სინქრონიზებული (readLock) {იდენტიფიკატორი = in.readInt (); int სიგრძე = in.readInt (); if (სიგრძე> 0) {ბაიტი = ახალი ბაიტი [სიგრძე]; in.readFully (ბაიტი, 0, ბაიტი. სიგრძე); } სხვა {გაგრძელება; }} გადართვა (იდენტიფიკატორი) {case Identifier. INTERNAL: სიმებიანი ბრძანება = ახალი სტრიქონი (ბაიტი); if (command.equals ("გათიშვა")) {if (! socket.isClosed ()) {System.out.println ("გათიშვის პაკეტი მიღებულია."); სცადეთ {დახურვა (); } catch (NetworkException e) {return; }}} შესვენება; საქმის იდენტიფიკატორი. ტექსტი: System.out.println ("შეტყობინება მიღებულია:" + ახალი სტრიქონი (ბაიტი)); შესვენება; ნაგულისხმევი: System.out.println ("არაღიარებული მონაცემები მიღებულია."); }} დაჭერა (SocketException ე) {if (! e.getMessage (). უდრის ("სოკეტი დახურულია")) {e.printStackTrace (); }} დაჭერა (IOException e) {e.printStackTrace (); }}} /*** აგზავნის მონაცემებს მეორე მხარეს. * * @param მონაცემები გასაგზავნი მონაცემები. * @throws NetworkException თუ გამომავალ ნაკადზე ჩაწერა ვერ მოხერხდება. * @throws IllegalStateException თუ კავშირის დახურვისას ხდება მონაცემთა ჩაწერის მცდელობა. * @throws IllegalArgumentException თუ გასაგზავნი მონაცემები არის ნულოვანი. * @throws UnsupportedOperationException თუ მონაცემთა დაუცველი ტიპის გაგზავნის მცდელობაა. */ public void send (ობიექტის მონაცემები) ისვრის NetworkException {if (socket.isClosed ()) {ჩააგდოს ახალი IllegalStateException ("მონაცემები არ არის გაგზავნილი, კავშირი დახურულია."); } if (data == null) {ჩააგდე ახალი IllegalArgumentException ("null data"); } int იდენტიფიკატორი; ბაიტი ბაიტი; if (მონაცემების მაგალითი სიმებიანი) {იდენტიფიკატორი = იდენტიფიკატორი. ტექსტი; ბაიტი = ((სიმებიანი) მონაცემები).getBytes (); } else {ჩააგდე ახალი UnsupportedOperationException ("მონაცემთა მხარდაუჭერელი ტიპი:" + data.getClass ()); } სცადეთ {სინქრონიზებული (writeLock) {out.writeInt (იდენტიფიკატორი); out.writeInt (ბაიტი. სიგრძე); out.write (ბაიტი); out.flush (); }} დაჭერა (IOException ე) {გადააგდე ახალი NetworkException ("მონაცემები ვერ გაიგზავნა.", ე); }} /*** უგზავნის გათიშვის შეტყობინებას და წყვეტს კავშირს მეორე მხარესთან. */ public void close () ისვრის NetworkException {if (socket.isClosed ()) {გადააგდე ახალი IllegalStateException ("კავშირი უკვე დახურულია."); } try {byte message = "disconnect".getBytes (); სინქრონიზებული (writeLock) {out.writeInt (Identifier. INTERNAL); out.writeInt (შეტყობინება. სიგრძე); out.write (შეტყობინება); out.flush (); }} catch (IOException e) {System.out.println ("გათიშვის შეტყობინება ვერ გაიგზავნა."); } სცადეთ {სინქრონიზებული (writeLock) {out.close (); }} დაჭერა (IOException ე) {ჩააგდე ახალი NetworkException ("შეცდომა კავშირის დახურვისას.", ე); } საბოლოოდ {thread.interrupt (); }} /*** აბრუნებს თუ არა კავშირი მეორე მხარეს ცოცხალია თუ არა. * * @return True თუ კავშირი ცოცხალია. ყალბი, სხვაგვარად. */ public boolean isConnected () {return! socket.isClosed (); }}

იდენტიფიკატორი. Java

/** * კლასი {@კოდის იდენტიფიკატორი} შეიცავს მუდმივებს, რომლებიც გამოიყენება {@link Connection} მიერ ქსელში გაგზავნილი მონაცემების სერიალიზაციისა და დეერიალიზაციისათვის. * * @version 1.0 * @see Connection * / საჯარო ბოლო კლასის იდენტიფიკატორი { / ** * შიდა შეტყობინებების იდენტიფიკატორი. */ public static final int INTERNAL = 1; /*** ტექსტური შეტყობინებების იდენტიფიკატორი. */ საჯარო სტატიკური საბოლოო int TEXT = 2; }

NetworkException.java

/*** კლასი {@კოდი NetworkException} მიუთითებს ქსელთან დაკავშირებულ შეცდომას. * / საჯარო კლასი NetworkException აგრძელებს გამონაკლისს { / *** აშენებს {@code NetworkException} - ს {@code null}, როგორც შეტყობინება. * / public NetworkException () {} / *** აყალიბებს {@კოდი NetworkException} მითითებული შეტყობინებით. * * @param შეტყობინება შეტყობინება შეცდომის აღსაწერად. */ public NetworkException (სიმებიანი შეტყობინება) {სუპერ (შეტყობინება); } /*** აშენებს {@code NetworkException} მითითებული შეტყობინებითა და მიზეზით. * * @param შეტყობინება შეტყობინება შეცდომის აღსაწერად. * @param cause შეცდომის მიზეზი. */ public NetworkException (სიმებიანი შეტყობინება, გადასაგდები მიზეზი) {სუპერ (შეტყობინება, მიზეზი); } /*** აშენებს {@code NetworkException} მითითებული მიზეზით. * * @param მიზეზი შეცდომის მიზეზი. */ public NetworkException (განსახორციელებელი მიზეზი) {სუპერ (მიზეზი); }}

UsageExample.java

/*** კლასი {@code UsageExample} აჩვენებს {@link Server} - ის და {@link Client} - ის გამოყენებას. ეს მაგალითები იყენებს * {@ბმული თემა#ძილი (გრძელი)} ყველა სეგმენტის შესრულების უზრუნველსაყოფად, რადგან სწრაფად დაწყებული და დახურული იწვევს ზოგიერთი * სეგმენტის არ შესრულებას. * * @version 1.0 * @see Server * @see Client */ public class UsageExample {public static void main (String args) throws Exception {String host = "localhost"; int პორტი = 10430; სერვერის სერვერი = ახალი სერვერი (მასპინძელი, პორტი); კლიენტი კლიენტი = ახალი კლიენტი (მასპინძელი, პორტი); თემა. ძილი (100 ლ); client.send ("გამარჯობა."); server.broadcast ("ჰეი, ბიჭო!"); თემა. ძილი (100 ლ); server.disconnect (server.getConnections () [0]); // ან client.close () კლიენტის მხარის სერვერთან გათიშვისთვის. დახურვა (); }}