Java пишет сервер и клиент, который может загружать файлы. Конкретный контент заключается в следующем
Серверная сторона
Class Server {public static void main (String [] args) бросает исключение {// Создание сервера Scocket Serversocket ss = new Serversocket (10005); // получение клиентского сокета fileLoaderSocket = ss.accept (); // Распечатать информацию о подключении string ip = fileLoaderSocket.getInetAddress (). GethostAddress (); System.out.println (ip + "... connectected"); // получение файла и сохранить inputstream in = fileLoaderSocket.getInputStream (); // создание объектных файлов outputstream filesave = new FileOutputStream ("e: //3.mp3"); // Создать массив BUF BYTE [] BUF = новый байт [1024]; int len = 0; // защищать, прочитал ли конец файла while ((len = in.read (buf))! = -1) {filesave.write (buf, 0, len); // обновить filesave.flush (); } // Вернуть файл Копирование информации BufferedWriter Out = new BufferedWriter (новый outputStreamWriter (fileLoaderSocket.getOutputStream ())); out.write ("Загрузка файла успешно"); // обновить out.flush (); // Ресурс закрывать ss.close (); fileLoaderSocket.close (); filesave.close (); }}Клиент:
Class Client {public static void main (string [] args) бросает исключение {// Создание сокета Service Socket FileLoaderSocket = New Socket ("168.168.168.94", 10005); // Читать файл локально от клиента и записать в выходной поток Socket OutputStream OUT = fileLoaderSocket.getOutputStream (); // создание объекта FileReader inputStream fileread = new FileInputStream ("g: //2.mp3"); // Создать массив байт [] buf = new Byte [1024]; int len = 0; // судить, прочитан ли конец файла while ((len = fileRead.read (buf))! = -1) {out.write (buf, 0, len); } // Расскажите серверу, что файл был перенесен fileLoaderSocket.shutDownOutput (); // Получить обратную связь с информацией от сервера BufferedReader in = new BufferedReader (New InputStreamReader (fileLoaderSocket.getInputStream ())); String serverback = in.readline (); System.out.println (Serverback); // ресурс закрывать fileLoaderSocket.close (); fileread.close (); }}Следующая программа копируется непосредственно из других мест для обучения:
Java Socket Programming
Для программирования сокетов Java есть две концепции, одна - Serversocket, а другой - гнездо. Сервер и клиент подключены через розетку, а затем они могут общаться. Во -первых, Serversocket будет прослушать порт на сервере. Когда будет обнаружено, что у клиента есть розетка, чтобы попытаться подключиться к нему, он примет запрос на соединение сокета и в то же время установит соответствующий сокет на сервере для связи с ним. Таким образом, есть два розета, один на клиенте и один на сервере.
Связь между розетками на самом деле очень проста. Когда сервер записывает что -то в выходной поток Socket, клиент может прочитать соответствующий контент через входной поток сокета. Гребень и сокет подключены в двух направлениях, поэтому клиент также может записать вещи в соответствующий выходной поток розетки, а затем соответствующий входной поток сокета сервера может считывать соответствующий содержимое. Вот несколько примеров связи на стороне сервера с клиентами:
1. Клиент записи и чтение сервера
Сервер Java код
Общедоступный сервер класса {public static void main (String args []) бросает ioException {// Для простоты, вся информация об исключении выброшена int port = 8899; // Определите прослушивание Serversocket на порте 8899 Serversocket Server = New Serversocket (Port); // Сервер пытается получить запросы на соединение из других сокетов. Метод принятия сервера представляет собой блокирующее сокет сокета = server.accept (); // После установления соединения с клиентом мы можем получить входной сериал сокета и прочитать информацию, отправленную клиентом. Reader Reader = new InputStreamReader (socket.getInputStream ()); char chars [] = new char [64]; int len; StringBuilder SB = new StringBuilder (); while ((len = reader.read (chars))! = -1) {sb.append (new String (chars, 0, len)); } System.out.println ("от client:" + sb); reader.close (); Socket.Close (); server.close (); }}Операция сервера для чтения данных из входного потока сокета также блокируется. Если данные не будут считываются из входного потока, программа останется там, пока клиент не записывает данные в выходной поток сокета или не закроет выходной поток розкета. Конечно, то же самое относится и к клиентским гнездам. После завершения операции не забудьте закрыть соответствующие ресурсы до завершения всей программы, то есть закройте соответствующий поток и сокет IO.
Клиент код Java
Public Class Client {public static void main (String args []) бросает исключение {// Для простоты все исключения выброшены непосредственно String host = "127.0.0.1"; // IP -адрес сервера подключена int port = 8899; // Соответствующий порт прослушивания сервера, который будет подключен // Соединение установлено с помощью Server Socket Client = New Socket (Host, Port); // После установления соединения вы можете записать данные в Server Writer Writer = New OutputStreamWriter (client.getOutputStream ()); writer.write ("Hello Server.); writer.flush (); // запомнить flush writer.close (); client.close (); }}При написании данных в выходной поток розетка вы должны обратить внимание на одну вещь. Если программа не соответствует выключению выходного потока после операции записи, но выполняет другие операции блокировки (например, чтение данных из входного потока), не забудьте снять его. Только таким образом сервер может получить данные, отправленные клиентом, в противном случае он может привести к неограниченному ожиданию друг друга. Эта проблема будет упомянута позже, когда рассказывают о чтении и написании клиента и сервера.
2. Клиент и сервер читают и пишут одновременно
Как упоминалось ранее, гнезда общаются двусторонними способами, которые могут получать данные и отправлять данные.
Сервер Java код
Общедоступный сервер класса {public static void main (String args []) бросает ioException {// Для простоты, вся информация об исключении выброшена int port = 8899; // Определите прослушивание Serversocket на порте 8899 Serversocket Server = New Serversocket (Port); // Сервер пытается получить запросы на соединение из других сокетов. Метод принятия сервера представляет собой блокирующее сокет сокета = server.accept (); // После установления соединения с клиентом мы можем получить входной сериал сокета и прочитать информацию, отправленную клиентом. Reader Reader = new InputStreamReader (socket.getInputStream ()); char chars [] = new char [64]; int len; StringBuilder SB = new StringBuilder (); while ((len = reader.read (chars))! = -1) {sb.append (new String (chars, 0, len)); } System.out.println ("от client:" + sb); // Напишите предложение после прочтения ИТ -автора Writer = New OutputStreamWriter (socket.getOutputStream ()); writer.write ("Привет, клиент"); writer.flush (); writer.close (); reader.close (); Socket.Close (); server.close (); }}В приведенном выше коде мы сначала считываем данные, отправленные клиентом из входного потока, а затем запишем данные в выходной поток для клиента, а затем закрываем соответствующий файл ресурса. Фактически, приведенный выше код может не работать так, как мы предполагаем заранее, потому что чтение данных из входного потока является операцией блокировки. Когда данные считываются в вышесказанном во время цикла, тело цикла будет выполнено, в противном случае он будет заблокирован, так что последующие операции записи никогда не будут выполнены. Петля while остановится, если только соответствующий сокет клиента не будет закрыт и заблокирован. Решение этой ситуации, когда она никогда не может быть выполнена, заключается в том, что в то время как петля необходимо условно выскочить. Глядя на приведенный выше код, единственное, что меняется, - это длина LEN и данные, которые читаются. Лен больше не пригодна для использования, и единственное, что можно использовать, - это данные, которые читаются. В этом случае мы обычно соглашаемся с конечной тегом. Когда данные, отправленные клиентом, содержат определенную конечную тег, это означает, что текущие данные отправлены, и в настоящее время мы можем измерить. Тогда улучшенный код будет выглядеть так:
Код Java
Общедоступный сервер класса {public static void main (String args []) бросает ioException {// Для простоты, вся информация об исключении выброшена int port = 8899; // Определите прослушивание Serversocket на порте 8899 Serversocket Server = New Serversocket (Port); // Сервер пытается получить запросы на соединение из других сокетов. Метод принятия сервера представляет собой блокирующее сокет сокета = server.accept (); // После установления соединения с клиентом мы можем получить входной сериал сокета и прочитать информацию, отправленную клиентом. Reader Reader = new InputStreamReader (socket.getInputStream ()); char chars [] = new char [64]; int len; StringBuilder SB = new StringBuilder (); Строка температура; int index; while ((len = reader.read (chars))! = -1) {temp = new String (chars, 0, len); if ((index = temp.indexof ("eof"))! = -1) {// прием заканчивается, когда EOF встречается sb.append (temp.substring (0, index)); перерыв; } sb.append (temp); } System.out.println ("от client:" + sb); // Напишите предложение после прочтения Writer Writer = New OutputStreamWriter (socket.getOutputStream ()); writer.write ("Привет, клиент"); writer.flush (); writer.close (); reader.close (); Socket.Close (); server.close (); }}В приведенном выше коде, когда сервер считывает конечную марку, отправленную клиентом, то есть «EOF», прием данных будет прекращен, а цикл будет прекращен, так что последующий код может продолжаться.
Клиент код Java
Public Class Client {public static void main (String args []) бросает исключение {// Для простоты все исключения выброшены непосредственно String host = "127.0.0.1"; // IP -адрес сервера подключена int port = 8899; // Соответствующий порт прослушивания сервера, который будет подключен // Соединение установлено с помощью Server Socket Client = New Socket (Host, Port); // После установления соединения вы можете записать данные в Server Writer Writer = New OutputStreamWriter (client.getOutputStream ()); writer.write ("Hello Server.); writer.flush (); // Читать после написания Reader Reader = new InputStreamReader (client.getInputStream ()); char chars [] = new char [64]; int len; StringBuffer sb = new StringBuffer (); while ((len = reader.read (chars))! = -1) {sb.append (new String (chars, 0, len)); } System.out.println ("от server:" + sb); writer.close (); reader.close (); client.close (); }}В приведенном выше коде мы сначала отправили кусок данных на сервер, а затем прочитали данные, возвращаемые сервером. Как и в предыдущем сервере, это может привести к тому, что программа все время висит там и никогда не выпрыгивать из цикла. Этот код объединяется с первым кодом сервера, просто позвольте нам проанализировать, что сервер всегда будет получать данные там, и никогда не будет выпрыгивать из цикла WHEL, поэтому не будет последующего сервера для возврата данных клиенту, и клиент не сможет получать данные, возвращаемые сервером. Решение показано во втором коде сервера. После того, как клиент отправляет данные, запишите конечную отметку в выходной поток, чтобы сообщить серверу, что данные были отправлены. Сервер также отправляет отметку, чтобы сообщить клиенту после возврата данных. Тогда измененный клиент -код должен выглядеть так:
Код Java
Public Class Client {public static void main (String args []) бросает исключение {// Для простоты все исключения выброшены непосредственно String host = "127.0.0.1"; // IP -адрес сервера подключена int port = 8899; // Соответствующий порт прослушивания сервера, который будет подключен // Соединение установлено с помощью Server Socket Client = New Socket (Host, Port); // После установления соединения вы можете записать данные в Server Writer Writer = New OutputStreamWriter (client.getOutputStream ()); writer.write ("Hello Server.); writer.write ("EOF"); writer.flush (); // Читать после написания Reader Reader = new InputStreamReader (client.getInputStream ()); char chars [] = new char [64]; int len; StringBuffer sb = new StringBuffer (); Строка температура; int index; while ((len = reader.read (chars))! = -1) {temp = new String (chars, 0, len); if ((index = temp.indexof ("eof"))! = -1) {sb.append (temp.substring (0, index)); перерыв; } sb.append (новая строка (chars, 0, len)); } System.out.println ("от server:" + sb); writer.close (); reader.close (); client.close (); }}Наиболее распространенная форма, которую мы используем в повседневной жизни, заключается в том, что клиент отправляет данные на сервер, а сервер получает данные и возвращает соответствующие результаты клиенту. Тем не менее, между клиентом и сервером больше нет такой связи, но ситуация, когда несколько клиентов соответствуют тому же серверу, что и упомянуто ниже.
3. Несколько клиентов подключаются к одному и тому же серверу
Для двух примеров, упомянутых выше, сервер заканчивается после получения запроса клиента и не может получать запросы от других клиентов, что часто не может соответствовать нашим требованиям. Обычно мы делаем это:
Код Java
Общедоступный сервер класса {public static void main (String args []) бросает ioException {// Для простоты, вся информация об исключении выброшена int port = 8899; // Определите прослушивание Serversocket на порте 8899 Serversocket Server = New Serversocket (Port); В то время как (true) {// Сервер пытается получить запросы на соединение из других сокетов. Метод принятия сервера представляет собой блокирующее сокет сокета = server.accept (); // После установления соединения с клиентом мы можем получить входной сериал сокета и прочитать информацию, отправленную клиентом. Reader Reader = new InputStreamReader (socket.getInputStream ()); char chars [] = new char [64]; int len; StringBuilder SB = new StringBuilder (); Строка температура; int index; while ((len = reader.read (chars))! = -1) {temp = new String (chars, 0, len); if ((index = temp.indexof ("eof"))! = -1) {// прием заканчивается, когда EOF встречается sb.append (temp.substring (0, index)); перерыв; } sb.append (temp); } System.out.println ("от client:" + sb); // Напишите предложение после прочтения Writer Writer = New OutputStreamWriter (socket.getOutputStream ()); writer.write ("Привет, клиент"); writer.flush (); writer.close (); reader.close (); Socket.Close (); }}} В приведенном выше коде мы использовали мертвый цикл, где Serversocket вызывает свой метод принятия, чтобы попытаться получить запрос на соединение от клиента. Когда запрос не будет получен, программа будет блокировать здесь, пока не получит запрос на соединение от клиента, а затем общаться с клиентом, который установил соединение. После этого он затем выполнит корпус цикла и попытается снова получить новый запрос на соединение. Таким образом, наш серверсколет может получать запросы на соединение от всех клиентов и общаться с ними. Это реализует простой режим связи с несколькими клиентами на одном сервере.
В приведенном выше примере, хотя один сервер реализован для связи с несколькими клиентами, все еще есть проблема. В приведенном выше примере наш сервер обрабатывает синхронно запрос на подключение клиента. Каждый раз, когда мы получаем запрос на соединение от клиента, мы должны сначала общаться с текущим клиентом, прежде чем мы сможем обработать следующий запрос на соединение. Это серьезно повлияет на производительность программы, когда будет больше параллелизма. По этой причине мы можем изменить его на следующую асинхронную обработку общения с клиентом:
Код Java
Общедоступный сервер класса {public static void main (String args []) бросает ioException {// Для простоты, вся информация об исключении выброшена int port = 8899; // Определите прослушивание Serversocket на порте 8899 Serversocket Server = New Serversocket (Port); В то время как (true) {// Сервер пытается получить запросы на соединение из других сокетов. Метод принятия сервера представляет собой блокирующее сокет сокета = server.accept (); // Каждый раз, когда получается розетка, создается новый поток для обработки новой поток (новая задача (сокет)). Start (); }} / ** * * / Статическое задание класса реализует runnable {private сокет сокета; публичная задача (сокет сокета) {this.socket = ocket; } public void run () {try {handlesocket (); } catch (Exception e) {e.printstackTrace (); }} / *** Общайтесь с клиентским сокетом* @Throws Exception* / private void handlesocket () бросает исключение {reader Reader = new InputStreamReader (socket.getInputStream ()); char chars [] = new char [64]; int len; StringBuilder SB = new StringBuilder (); Строка температура; int index; while ((len = reader.read (chars))! = -1) {temp = new String (chars, 0, len); if ((index = temp.indexof ("eof"))! = -1) {// прием заканчивается, когда EOF встречается sb.append (temp.substring (0, index)); перерыв; } sb.append (temp); } System.out.println ("от client:" + sb); // Напишите предложение после прочтения Writer Writer = New OutputStreamWriter (socket.getOutputStream ()); writer.write ("Привет, клиент"); writer.flush (); writer.close (); reader.close (); Socket.Close (); }}} В приведенном выше коде каждый раз, когда Serversocke получает новый запрос на подключение к сокетам, будет создан новый поток для связи с текущим розетком, который достигнет асинхронной обработки связи с клиентским сокетом.
При получении данных от InputStream Socket, чтение немного похоже на вышеупомянутое, слишком сложно. Иногда мы будем использовать BufferedReader, чтобы читать по одной строке за раз, например:
Код Java
Общедоступный сервер класса {public static void main (String args []) бросает ioException {// Для простоты, вся информация об исключении выброшена int port = 8899; // Определите прослушивание Serversocket на порте 8899 Serversocket Server = New Serversocket (Port); В то время как (true) {// Сервер пытается получить запросы на соединение из других сокетов. Метод принятия сервера представляет собой блокирующее сокет сокета = server.accept (); // Каждый раз, когда получается розетка, создается новый поток для обработки новой поток (новая задача (сокет)). Start (); }} / ** * * / Статическое задание класса реализует runnable {private сокет сокета; публичная задача (сокет сокета) {this.socket = ocket; } public void run () {try {handlesocket (); } catch (Exception e) {e.printstackTrace (); }} / *** Сообщайтесь с клиентским сокетом* @Throws Exception* / private void hardlesocket () бросает исключение {bufferedReader br = new BufferedReader (new InputStreamReader (socket.getInputStream ())); StringBuilder SB = new StringBuilder (); Строка температура; int index; while ((temp = br.readline ())! = null) {System.out.println (temp); if ((index = temp.indexof ("eof"))! = -1) {// end прием, когда EOF встречается sb.append (temp.substring (0, index)); перерыв; } sb.append (temp); } System.out.println ("от client:" + sb); // Напишите предложение после прочтения Writer Writer = New OutputStreamWriter (socket.getOutputStream ()); writer.write ("Привет, клиент"); writer.write ("eof/n"); writer.flush (); writer.close (); br.close (); Socket.Close (); }}}В настоящее время следует отметить, что метод чтения BufferedReader читает одну строку за раз. Этот метод заблокирован. Программа не будет продолжать выполнять, пока не будет прочитать одну строку данных. Итак, когда Readline будет прочитать строку? Метод считывания не будет думать, что он прочитал строку, пока программа не встретит новую линию или конечный символ соответствующего потока. Это завершит свою блокировку и позволит программе продолжать выполняться. Поэтому, когда мы используем линию чтения BufferedReader для чтения данных, мы должны помнить, чтобы записать разрывы строк в соответствующем выходном потоке (она будет автоматически помечена как конец после окончания потока, а линия чтения может быть распознана). После написания разрывов строки мы должны помнить, чтобы промыть, если выходной поток не закрыт немедленно, так что данные будут действительно написаны из буфера. Соответственно с приведенным выше кодом, наша клиентская программа должна быть написана так:
Код Java
Public Class Client {public static void main (String args []) бросает исключение {// Для простоты все исключения выброшены непосредственно String host = "127.0.0.1"; // IP -адрес сервера подключена int port = 8899; // Соответствующий порт прослушивания сервера, который будет подключен // Соединение установлено с помощью Server Socket Client = New Socket (Host, Port); // После установления соединения вы можете записать данные в Server Writer Writer = New OutputStreamWriter (client.getOutputStream ()); writer.write ("Hello Server.); writer.write ("eof/n"); writer.flush (); // Читать после написания BufferedReader br = new BufferedReader (New InputStreamReader (client.getInputStream ())); StringBuffer sb = new StringBuffer (); Строка температура; int index; while ((temp = br.readline ())! = null) {if ((index = temp.indexof ("eof"))! = -1) {sb.append (temp.substring (0, index)); перерыв; } sb.append (temp); } System.out.println ("от server:" + sb); writer.close (); br.close (); client.close (); }}4. Установите время ожидания
Предположим, что существует такое требование, что нашему клиенту необходимо получить информацию XX с сервера через сокет, а затем отобразить ее пользователю на странице. Мы знаем, что сокет блокирует при чтении данных, и если вы не читаете данные, программа будет продолжать блокироваться. При синхронизации запроса мы не должны допускать, чтобы такая ситуация произошла. Это требует, чтобы мы контролировали блокирующее прерывание после того, как запрос достиг определенного времени, чтобы программа могла продолжать работать. Socket предоставляет нам метод setSotimeout () для установки времени ожидания полученных данных в миллисекундах. Когда время ожидания превышает 0, и после этого времени розетка не получила возвращаемых данных, розетка бросит Sockettimeoutexexception.
Предположим, нам нужно контролировать нашего клиента, чтобы прерывать и блокировать, прежде чем читать данные в течение 10 секунд после начала чтения данных, мы можем сделать это:
Код Java
Public Class Client {public static void main (String args []) бросает исключение {// Для простоты все исключения выброшены непосредственно String host = "127.0.0.1"; // IP -адрес сервера подключена int port = 8899; // Соответствующий порт прослушивания сервера, который будет подключен // Соединение установлено с помощью Server Socket Client = New Socket (Host, Port); // После установления соединения вы можете записать данные в Server Writer Writer = New OutputStreamWriter (client.getOutputStream ()); writer.write ("Hello Server.); writer.write ("eof/n"); writer.flush (); // Читать после написания BufferedReader br = new BufferedReader (New InputStreamReader (client.getInputStream ())); // Установить тайм -аут на 10 секунд client.setsotimeout (10*1000); StringBuffer sb = new StringBuffer (); Строка температура; int index; try {while ((temp = br.readline ())! = null) {if ((index = temp.indexof ("eof"))! = -1) {sb.append (temp.substring (0, index)); перерыв; } sb.append (temp); }} catch (sockettimeoutexception e) {System.out.println ("Тайм -аут чтения данных."); } System.out.println ("от server:" + sb); writer.close (); br.close (); client.close (); }}5. Получить искаженную код данных
Для таких случаев, когда сервер или клиент получают искаженную китайскую код, это обычно происходит потому, что кодирование, используемое при отправке данных, противоречит кодированию, используемому при получении данных. Например, есть код сервера, как это:
Код Java
Общедоступный сервер класса {public static void main (String args []) бросает ioException {// Для простоты, вся информация об исключении выброшена int port = 8899; // Определите прослушивание Serversocket на порте 8899 Serversocket Server = New Serversocket (Port); В то время как (true) {// Сервер пытается получить запросы на соединение из других сокетов. Метод принятия сервера представляет собой блокирующее сокет сокета = server.accept (); // Каждый раз, когда получается розетка, создается новый поток для обработки новой поток (новая задача (сокет)). Start (); }} / ** * * / Статическое задание класса реализует runnable {private сокет сокета; публичная задача (сокет сокета) {this.socket = ocket; } public void run () {try {handlesocket (); } catch (Exception e) {e.printstackTrace (); }} / *** Общайтесь с клиентским сокетом* @Throws Exception* / private void handlesocket () бросает исключение {bufferedReader br = new BufferedReader (new InputStreamReader (socket.getInputStream (), "gbk")); StringBuilder SB = new StringBuilder (); Строка температура; int index; while ((temp = br.readline ())! = null) {System.out.println (temp); if ((index = temp.indexof ("eof"))! = -1) {// end reception Когда EOF встречается sb.append (temp.substring (0, index)); перерыв; } sb.append (temp); } System.out.println ("client:" + sb); // написать предложение после прочтения Writer Writer = new OutputStreamWriter (socket.getOutputStream (), "UTF-8"); writer.write ("Привет, клиент"); writer.write ("eof/n"); writer.flush (); writer.close (); br.close (); Socket.Close (); }}}Я немного смущен, когда использовал его здесь для тестирования. В приведенном выше коде сервера мы четко определяем использование кодирования GBK для считывания данных при определении входного потока, и четко указываем, что использование кодирования UTF-8 для отправки данных при определении выходного потока. Если клиент не отправляет данные в кодировании GBK при отправке данных на клиенту, данные, полученные сервером, могут быть искажены; Аналогичным образом, если клиент не отправляет кодирование данных при отправке данных на сервере, то есть кодирование UTF-8 для получения данных, также очень вероятно, что будут происходить искаженные данные. Поэтому для приведенного выше кода сервера, чтобы позволить нашей программе прочитать данные, отправленные другой стороной без искаженного кода, наш клиент должен быть таким:
Код Java
Public Class Client {public static void main (String args []) бросает исключение {// Для простоты все исключения выброшены непосредственно String host = "127.0.0.1"; // IP -адрес сервера подключена int port = 8899; // Соответствующий порт прослушивания сервера, который будет подключен // Соединение установлено с помощью Server Socket Client = New Socket (Host, Port); // После установления соединения вы можете записать данные в Server Writer Writer = New OutputStreamWriter (client.getOutputStream (), «GBK»); writer.write («Привет, сервер.»); writer.write ("eof/n"); writer.flush (); // Читать после написания BufferedReader br = new BufferedReader (New InputStreamReader (client.getInputStream (), "UTF-8")); // Установить тайм -аут на 10 секунд client.setsotimeout (10*1000); StringBuffer sb = new StringBuffer (); Строка температура; int index; try {while ((temp = br.readline ())! = null) {if ((index = temp.indexof ("eof"))! = -1) {sb.append (temp.substring (0, index)); перерыв; } sb.append (temp); }} catch (sockettimeoutexception e) {System.out.println ("Тайм -аут чтения данных."); } System.out.println ("Server:" + SB); writer.close (); br.close (); client.close (); }}Эта статья была составлена в «Краткое описание методов операции загрузки Java», и все могут учиться и прочитать.
Выше всего содержание этой статьи. Я надеюсь, что это будет полезно для каждого обучения, и я надеюсь, что все будут поддерживать Wulin.com больше.