Приложения SocketServ и SocketClient

Оглавление

Сетевые приложения
Адрес IP
Адрес URL
Класс URL
Сокеты
Потоковые сокеты
Класс Socket
Датаграммные сокеты
Связь с Web
Аплет ShowChart
Приложения SocketServ и SocketClient
Аплет Form

## Приложения SocketServ и SocketClient

Назад Вперед

В качестве примера мы приведем исходные тексты двух приложений Java, работающих с потоковыми сокетами. Одно из этих приложений называется SocketServ и выполняет роль сервера, второе называется SocketClient и служит клиентом.

Приложение SocketServ выводит на консоль строку "Socket Server Application" и затем переходит в состояние ожидания соединения с клиентским приложением SocketClient.

Приложение SocketClient устанавливает соединение с сервером SocketServ, используя потоковый сокет с номером 9999 (этот номер выбран нами произвольно). Далее клиентское приложение выводит на свою консоль приглашение для ввода строк. Введенные строки отображаются на консоли и передаются серверному приложению. Сервер, получив строку, отображает ее в своем окне и посылает обратно клиенту. Клиент выводит полученную от сервера строку на консоли.

Когда пользователь вводит строку "quit", цикл ввода и передачи строк завершается.

Весь процесс показан на рис. 3 и 4.

Рис. 3. Окно клиентского приложения

Рис. 4. Окно серверного приложения

Здесь в окне клиентского приложения мы ввели несколько строк, причем последняя строка была строкой "quit", завершившая работу приложений.

### Исходный текст серверного приложения SocketServ

Исходный текст серверного приложения SocketServ приведен в листинге 3.

Листинг 3. Файл SocketServ.java

    import java.io.*;
    import java.net.*;
    import java.util.*;

    public class SocketServ
    {
      public static void main(String args[])
      {
        byte bKbdInput[] = new byte[256];
        ServerSocket ss;
        Socket s;
        InputStream is;
        OutputStream os;

        try
        {
          System.out.println(
            "Socket Server Application");
        }
        catch(Exception ioe)
        {
          System.out.println(ioe.toString());
        }

        try
        {
          ss = new ServerSocket(9999);
          s = ss.accept();
          is = s.getInputStream();
          os = s.getOutputStream();
          byte buf[] = new byte[512];
          int lenght;

          while(true)
          {
            lenght = is.read(buf);
            if(lenght == -1)
              break;

            String str = new String(buf, 0);

            StringTokenizer st;
            st   = new StringTokenizer(
               str, "\r\n");
            str = new String(
              (String)st.nextElement());

            System.out.println(">  " + str);
            os.write(buf, 0, lenght);
            os.flush();
          }

          is.close();
          os.close();
          s.close();
          ss.close();
        }
        catch(Exception ioe)
        {
          System.out.println(ioe.toString());
        }

        try
        {
          System.out.println(
            "Press <Enter> to terminate
     application...");
          System.in.read(bKbdInput);
        }
        catch(Exception ioe)
        {
          System.out.println(ioe.toString());
        }
      }
    }

### Описание исходного текста серверного приложения SocketServ

В методе main, получающем управление сразу после запуска приложения, мы определили несколько переменных.

Массив bKbdInput размером 256 байт предназначен для хранения строк, введенных при помощи клавиатуры.

В переменную ss класса ServerSocket будет записана ссылка на объект, предназначенный для установления канала связи через потоковый сокет (но не ссылка на сам сокет):

    ServerSocket ss;

Ссылка на сокет, с использованием которого будет происходить передача данных, хранится в переменной с именем s класса Socket:

    Socket s;

Кроме того, мы определили переменные is и os, соответственно, классов InputStream и OutputStream:

    InputStream is;
    OutputStream os;

В эти переменные будут записаны ссылки на входной и выходной поток данных, которые связаны с сокетом.

После отображения на консоли строки названия приложения, метод main создает объект класса ServerSocket, указывая конструктору номер порта 9999:

    ss = new ServerSocket(9999);

Конструктор возвращает ссылку на объект, с использованием которого можно установить канал передачи данных с клиентом.

Канал устанавливается методом accept:

    s = ss.accept();

Этот метод переводит приложение в состояние ожидания до тех пор, пока не будет установлен канал передачи данных.

Метод accept в случае успешного создания канала передачи данных возвращает ссылку на сокет, с применением которого нужно принимать и передавать данные.

На следующем этапе сервер создает входной и выходной потоки, вызывая для этого методы getInputStream и getOutputStream, соответственно:

    is = s.getInputStream();
    os = s.getOutputStream();

Далее приложение подготавливает буфер buf для приема данных и определяет переменную length, в которую будет записываться размер принятого блока данных:

    byte buf[] = new byte[512];
    int lenght;

Теперь все готово для запуска цикла приема и обработки строк от клиентского приложения.

Для чтения строки мы вызываем метод read применительно ко входному потоку:

    lenght = is.read(buf);

Этот метод возвращает управление только после того, как все данные будут прочитаны, блокируя приложение на время своей работы. Если такая блокировка нежелательна, вам следует выполнять обмен данными через сокет в отдельной задаче.

Метод read возвращает размер принятого блока данных или -1, если поток исчерпан. Мы воспользовались этим обстоятельством для завершения цикла приема данных:

    if(lenght == -1)
      break;

После завершения приема блока данных мы преобразуем массив в текстовую строку str класса String, удаляя из нее символ перевода строки, и отображаем результат на консоли сервера:

    System.out.println(">  " + str);

Затем полученная строка отправляется обратно клиентскому приложению, для чего вызывается метод write:

    os.write(buf, 0, lenght);

Методу write передается ссылка на массив, смещение начала данных в этом массиве, равное нулю, и размер принятого блока данных.

Для исключения задержек в передаче данных из-за накопления данных в буфере (при использовании буферизованных потоков) необходимо принудительно сбрасывать содержимое буфреа метдом flush:

    os.flush();

И хотя в нашем случае мы не пользуемся буферизованными потоками, мы включили вызов этого метода для примера.

Теперь о завершающих действиях после прерывания цикла получения, отображения и передачи строк.

Наше приложение явням образом закрывает входной и выходной потоки данных, сокет, а также объект класса ServerSocket, с использованием которого был создан канал передачи данных:

    is.close();
    os.close();
    s.close();
    ss.close();

### Исходный текст клиентского приложения SocketClient

Исходный текст клиентского приложения SocketClient приведен в листинге 4.

Листинг 4. Файл SocketClient.java

    import java.io.*;
    import java.net.*;
    import java.util.*;

    public class SocketClient
    {
      public static void main(String args[])
      {
        byte bKbdInput[] = new byte[256];
        Socket s;
        InputStream is;
        OutputStream os;

        try
        {
          System.out.println(
            "Socket Client Application" +
            "\nEnter any string or" +
            " 'quit' to exit...");
        }
        catch(Exception ioe)
        {
          System.out.println(ioe.toString());
        }

        try
        {
          s = new Socket("localhost",9999);
          is = s.getInputStream();
          os = s.getOutputStream();
          byte buf[] = new byte[512];
          int length;
          String str;

          while(true)
          {
            length = System.in.read(bKbdInput);
            if(length != 1)
            {
              str = new String(bKbdInput, 0);

              StringTokenizer st;
              st   = new StringTokenizer(
                str, "\r\n");
              str = new String(
                (String)st.nextElement());

              System.out.println(">  " + str);

              os.write(bKbdInput, 0, length);
              os.flush();

              length = is.read(buf);
              if(length == -1)
                break;

              str = new String(buf, 0);
              st   = new StringTokenizer(
                str, "\r\n");
              str = new String(
                  (String)st.nextElement());
              System.out.println(">> " + str);

              if(str.equals("quit"))
                break;
            }
          }
          is.close();
          os.close();
          s.close();
        }
        catch(Exception ioe)
        {
          System.out.println(ioe.toString());
        }

        try
        {
          System.out.println(
            "Press <Enter> to " +
             "terminate application...");
          System.in.read(bKbdInput);
        }
        catch(Exception ioe)
        {
          System.out.println(ioe.toString());
        }
      }
    }

### Описание исходного текста клиентского приложения SocketClient

Внутри метода main клиентского приложения SocketClient определены переменные для ввода строки с клавиатуры (массив bKbdInput), сокет s класса Socket для работы с сервером SocketServ, входной поток is и выходной поток os, которые связаны с сокетом s.

После вывода на консоль приглашающей строки клиентское приложение создает сокет, вызывая конструктор класса Socket:

    s = new Socket("localhost",9999);

В процессе отладки мы запускали сервер и клиент на одном и том же узле, поэтому в качестве адреса сервера указана строка "localhost". Номер порта сервера SocketServ равен 9999, поэтому мы и передали конструктору это значение.

После создания сокета наше клиентское приложение создает входной и выходной потоки, связанные с этим сокетом:

    is = s.getInputStream();
    os = s.getOutputStream();

Теперь клиентское приложение готово обмениваться данными с сервером.

Этот обмен выполняется в цикле, условием завершения которого является ввод пользователем строки "quit".

Внутри цикла приложение читает строку с клавиатуры, записывая ее в массив bKbdInput:

    length = System.in.read(bKbdInput);

Количество введенных символов сохраняется в переменной length.

Далее если пользователь ввел строку, а не просто нажал на клавишу <Enter>, эта строка отображается на консоли и передается серверу:

    os.write(bKbdInput, 0, length);
    os.flush();

Сразу после передачи сбрасывается буфер выходного потока.

Далее приложение читает ответ, посылаемый сервером, в буфер buf:

    length = is.read(buf);

Напомним, что наш сервер посылает клиенту принятую строку в неизменном виде.

Если сервер закрыл канал, то метод read возвращает значение -1. В этом случае мы прерываем цикл ввода и передачи строк:

    if(length == -1)
      break;

Если же ответ сервера принят успешно, принятые данные записываются в строку str, которая отображается на консоли клиента:

    System.out.println(">> " + str);

Перед завершением своей работы клиент закрывает входной и выходной потоки, а также сокет, на котором выполнялась передача данных:

    is.close();
    os.close();
    s.close();

Назад Вперед

Java | Продукты и решения | Технологии | Сервис и обучение
О компании | Партнеры | Новости | Поиск