В качестве примера мы приведем исходные тексты двух приложений 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, "
");
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" +
"
Enter 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, "
");
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, "
");
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();