java socket程式設計
對於Socket之間的通訊其實很簡單,服務端往Socket的輸出流裡面寫東西,客戶端就可以通過Socket的輸入流讀取對應的內容。Socket與Socket之間是雙向連通的,所以客戶端也可以往對應的Socket輸出流裡面寫東西,然後服務端對應的Socket的輸入流就可以讀出對應的內容。下面來看一些服務端與客戶端通訊的例子:
1、客戶端寫服務端讀
服務端程式碼
Java程式碼- public class Server {
- public static void main(String args[]) throws IOException {
- //為了簡單起見,所有的異常資訊都往外拋
- int port = 8899;
- //定義一個ServerSocket監聽在埠8899上
- ServerSocket server = new ServerSocket(port);
- //server嘗試接收其他Socket的連線請求,server的accept方法是阻塞式的
- Socket socket = server.accept();
- //跟客戶端建立好連線之後,我們就可以獲取socket的InputStream,並從中讀取客戶端發過來的資訊了。
- 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("from client: " + sb);
- reader.close();
- socket.close();
- server.close();
- }
- }
服務端從Socket的InputStream中讀取資料的操作也是阻塞式的,如果從輸入流中沒有讀取到資料程式會一直在那裡不動,直到客戶端往Socket的輸出流中寫入了資料,或關閉了Socket的輸出流。當然,對於客戶端的Socket也是同樣如此。在操作完以後,整個程式結束前記得關閉對應的資源,即關閉對應的IO流和Socket。
客戶端程式碼
Java程式碼- public class Client {
- public static void main(String args[]) throws Exception {
- //為了簡單起見,所有的異常都直接往外拋
- String host = "127.0.0.1"; //要連線的服務端IP地址
- int port = 8899; //要連線的服務端對應的監聽埠
- //與服務端建立連線
- Socket client = new Socket(host, port);
- //建立連線後就可以往服務端寫資料了
- Writer writer = new OutputStreamWriter(client.getOutputStream());
- writer.write("Hello Server.");
- writer.flush();//寫完後要記得flush
- writer.close();
- client.close();
- }
- }
2、客戶端和服務端同時讀和寫
前面已經說了Socket之間是雙向通訊的,它既可以接收資料,同時也可以傳送資料。
服務端程式碼
Java程式碼- public class Server {
- public static void main(String args[]) throws IOException {
- //為了簡單起見,所有的異常資訊都往外拋
- int port = 8899;
- //定義一個ServerSocket監聽在埠8899上
- ServerSocket server = new ServerSocket(port);
- //server嘗試接收其他Socket的連線請求,server的accept方法是阻塞式的
- Socket socket = server.accept();
- //跟客戶端建立好連線之後,我們就可以獲取socket的InputStream,並從中讀取客戶端發過來的資訊了。
- 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("from client: " + sb);
- //讀完後寫一句
- Writer writer = new OutputStreamWriter(socket.getOutputStream());
- writer.write("Hello Client.");
- writer.flush();
- writer.close();
- reader.close();
- socket.close();
- server.close();
- }
- }
在上述程式碼中首先我們從輸入流中讀取客戶端傳送過來的資料,接下來我們再往輸出流裡面寫入資料給客戶端,接下來關閉對應的資原始檔。而實際上上述程式碼可能並不會按照我們預先設想的方式執行,因為從輸入流中讀取資料是一個阻塞式操作,在上述的while迴圈中當讀到資料的時候就會執行迴圈體,否則就會阻塞,這樣後面的寫操作就永遠都執行不了了。除非客戶端對應的Socket關閉了阻塞才會停止,while迴圈也會跳出。針對這種可能永遠無法執行下去的情況的解決方法是while迴圈需要在裡面有條件的跳出來,縱觀上述程式碼,在不斷變化的也只有取到的長度len和讀到的資料了,len已經是不能用的了,唯一能用的就是讀到的資料了。針對這種情況,通常我們都會約定一個結束標記,當客戶端傳送過來的資料包含某個結束標記時就說明當前的資料已經發送完畢了,這個時候我們就可以進行迴圈的跳出了。那麼改進後的程式碼會是這個樣子:
Java程式碼- public class Server {
- public static void main(String args[]) throws IOException {
- //為了簡單起見,所有的異常資訊都往外拋
- int port = 8899;
- //定義一個ServerSocket監聽在埠8899上
- ServerSocket server = new ServerSocket(port);
- //server嘗試接收其他Socket的連線請求,server的accept方法是阻塞式的
- Socket socket = server.accept();
- //跟客戶端建立好連線之後,我們就可以獲取socket的InputStream,並從中讀取客戶端發過來的資訊了。
- Reader reader = new InputStreamReader(socket.getInputStream());
- char chars[] = new char[64];
- int len;
- StringBuilder sb = new StringBuilder();
- String temp;
- 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));
- break;
- }
- sb.append(temp);
- }
- System.out.println("from client: " + sb);
- //讀完後寫一句
- Writer writer = new OutputStreamWriter(socket.getOutputStream());
- writer.write("Hello Client.");
- writer.flush();
- writer.close();
- reader.close();
- socket.close();
- server.close();
- }
- }
客戶端程式碼
Java程式碼- public class Client {
- public static void main(String args[]) throws Exception {
- //為了簡單起見,所有的異常都直接往外拋
- String host = "127.0.0.1"; //要連線的服務端IP地址
- int port = 8899; //要連線的服務端對應的監聽埠
- //與服務端建立連線
- Socket client = new Socket(host, port);
- //建立連線後就可以往服務端寫資料了
- 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("from server: " + sb);
- writer.close();
- reader.close();
- client.close();
- }
- }
- public class Client {
- public static void main(String args[]) throws Exception {
- //為了簡單起見,所有的異常都直接往外拋
- String host = "127.0.0.1"; //要連線的服務端IP地址
- int port = 8899; //要連線的服務端對應的監聽埠
- //與服務端建立連線
- Socket client = new Socket(host, port);
- //建立連線後就可以往服務端寫資料了
- 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();
- String temp;
- 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));
- break;
- }
- sb.append(new String(chars, 0, len));
- }
- System.out.println("from server: " + sb);
- writer.close();
- reader.close();
- client.close();
- }
- }
3、多個客戶端連線同一個服務端
像前面講的兩個例子都是服務端接收一個客戶端的請求之後就結束了,不能再接收其他客戶端的請求了,這往往是不能滿足我們的要求的。通常我們會這樣做:
Java程式碼- public class Server {
- public static void main(String args[]) throws IOException {
- //為了簡單起見,所有的異常資訊都往外拋
- int port = 8899;
- //定義一個ServerSocket監聽在埠8899上
- ServerSocket server = new ServerSocket(port);
- while (true) {
- //server嘗試接收其他Socket的連線請求,server的accept方法是阻塞式的
- Socket socket = server.accept();
- //跟客戶端建立好連線之後,我們就可以獲取socket的InputStream,並從中讀取客戶端發過來的資訊了。
- Reader reader = new InputStreamReader(socket.getInputStream());
- char chars[] = new char[64];
- int len;
- StringBuilder sb = new StringBuilder();
- String temp;
- 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));
- break;
- }
- sb.append(temp);
- }
- System.out.println("from client: " + sb);
- //讀完後寫一句
- Writer writer = new OutputStreamWriter(socket.getOutputStream());
- writer.write("Hello Client.");
- writer.flush();
- writer.close();
- reader.close();
- socket.close();
- }
- }
- }
上述例子中雖然實現了一個服務端跟多個客戶端進行通訊,但是還存在一個問題。在上述例子中,我們的服務端處理客戶端的連線請求是同步進行的,每次接收到來自客戶端的連線請求後,都要先跟當前的客戶端通訊完之後才能再處理下一個連線請求。這在併發比較多的情況下會嚴重影響程式的效能,為此,我們可以把它改為如下這種非同步處理與客戶端通訊的方式:
Java程式碼- public class Server {
- public static void main(String args[]) throws IOException {
- //為了簡單起見,所有的異常資訊都往外拋
- int port = 8899;
- //定義一個ServerSocket監聽在埠8899上
- ServerSocket server = new ServerSocket(port);
- while (true) {
- //server嘗試接收其他Socket的連線請求,server的accept方法是阻塞式的
- Socket socket = server.accept();
- //每接收到一個Socket就建立一個新的執行緒來處理它
- new Thread(new Task(socket)).start();
- }
- }
- /**
- * 用來處理Socket請求的
- */
- static class Task implements Runnable {
- private Socket socket;
- public Task(Socket socket) {
- this.socket = socket;
- }
- public void run() {
- try {
- handleSocket();
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- /**
- * 跟客戶端Socket進行通訊
- * @throws Exception
- */
- private void handleSocket() throws Exception {
- Reader reader = new InputStreamReader(socket.getInputStream());
- char chars[] = new char[64];
- int len;
- StringBuilder sb = new StringBuilder();
- String temp;
- 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));
- break;
- }
- sb.append(temp);
- }
- System.out.println("from client: " + sb);
- //讀完後寫一句
- Writer writer = new OutputStreamWriter(socket.getOutputStream());
- writer.write("Hello Client.");
- writer.flush();
- writer.close();
- reader.close();
- socket.close();
- }
- }
- }
在從Socket的InputStream中接收資料時,像上面那樣一點點的讀就太複雜了,有時候我們就會換成使用BufferedReader來一次讀一行,如:
Java程式碼- public class Server {
- public static void main(String args[]) throws IOException {
- //為了簡單起見,所有的異常資訊都往外拋
- int port = 8899;
- //定義一個ServerSocket監聽在埠8899上
- ServerSocket server = new ServerSocket(port);
- while (true) {
- //server嘗試接收其他Socket的連線請求,server的accept方法是阻塞式的
- Socket socket = server.accept();
- //每接收到一個Socket就建立一個新的執行緒來處理它
- new Thread(new Task(socket)).start();
- }
- }
- /**
- * 用來處理Socket請求的
- */
- static class Task implements Runnable {
- private Socket socket;
- public Task(Socket socket) {
- this.socket = socket;
- }
- public void run() {
- try {
- handleSocket();
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- /**
- * 跟客戶端Socket進行通訊
- * @throws Exception
- */
- private void handleSocket() throws Exception {
- BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream()));
- StringBuilder sb = new StringBuilder();
- String temp;
- int index;
- while ((temp=br.readLine()) != null) {
- System.out.println(temp);
- if ((index = temp.indexOf("eof")) != -1) {//遇到eof時就結束接收
- sb.append(temp.substring(0, index));
- break;
- }
- sb.append(temp);
- }
- System.out.println("from client: " + sb);
- //讀完後寫一句
- Writer writer = new OutputStreamWriter(socket.getOutputStream());
- writer.write("Hello Client.");
- writer.write("eof\n");
- writer.flush();
- writer.close();
- br.close();
- socket.close();
- }
- }
- }
- public class Client {
- public static void main(String args[]) throws Exception {
- //為了簡單起見,所有的異常都直接往外拋
- String host = "127.0.0.1"; //要連線的服務端IP地址
- int port = 8899; //要連線的服務端對應的監聽埠
- //與服務端建立連線
- Socket client = new Socket(host, port);
- //建立連線後就可以往服務端寫資料了
- 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();
- String temp;
- int index;
- while ((temp=br.readLine()) != null) {
- if ((index = temp.indexOf("eof")) != -1) {
- sb.append(temp.substring(0, index));
- break;
- }
- sb.append(temp);
- }
- System.out.println("from server: " + sb);
- writer.close();
- br.close();
- client.close();
- }
- }
4、設定超時時間
假設有這樣一種需求,我們的客戶端需要通過Socket從服務端獲取到XX資訊,然後給使用者展示在頁面上。我們知道Socket在讀資料的時候是阻塞式的,如果沒有讀到資料程式會一直阻塞在那裡。在同步請求的時候我們肯定是不能允許這樣的情況發生的,這就需要我們在請求達到一定的時間後控制阻塞的中斷,讓程式得以繼續執行。Socket為我們提供了一個setSoTimeout()方法來設定接收資料的超時時間,單位是毫秒。當設定的超時時間大於0,並且超過了這一時間Socket還沒有接收到返回的資料的話,Socket就會丟擲一個SocketTimeoutException。
假設我們需要控制我們的客戶端在開始讀取資料10秒後還沒有讀到資料就中斷阻塞的話我們可以這樣做:
Java程式碼- public class Client {
- public static void main(String args[]) throws Exception {
- //為了簡單起見,所有的異常都直接往外拋
- String host = "127.0.0.1"; //要連線的服務端IP地址
- int port = 8899; //要連線的服務端對應的監聽埠
- //與服務端建立連線
- Socket client = new Socket(host, port);
- //建立連線後就可以往服務端寫資料了
- 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();
- String temp;
- int index;
- try {
- while ((temp=br.readLine()) != null) {
- if ((index = temp.indexOf("eof")) != -1) {
- sb.append(temp.substring(0, index));
- break;
- }
- sb.append(temp);
- }
- } catch (SocketTimeoutException e) {
- System.out.println("資料讀取超時。");
- }
- System.out.println("from server: " + sb);
- writer.close();
- br.close();
- client.close();
- }
- }
5、接收資料亂碼
對於這種服務端或客戶端接收中文亂碼的情況通常是因為資料傳送時使用的編碼跟接收時候使用的編碼不一致。比如有下面這樣一段服務端程式碼:
Java程式碼- public class Server {
- public static void main(String args[]) throws IOException {
- //為了簡單起見,所有的異常資訊都往外拋
- int port = 8899;
- //定義一個ServerSocket監聽在埠8899上
- ServerSocket server = new ServerSocket(port);
- while (true) {
- //server嘗試接收其他Socket的連線請求,server的accept方法是阻塞式的
- Socket socket = server.accept();
- //每接收到一個Socket就建立一個新的執行緒來處理它
- new Thread(new Task(socket)).start();
- }
- }
- /**
- * 用來處理Socket請求的
- */
- static class Task implements Runnable {
- private Socket socket;
- public Task(Socket socket) {
- this.socket = socket;
- }
- public void run() {
- try {
- handleSocket();
- } catch (Exception e) {
- e.printStackTrace();
- }
- }
- /**
- * 跟客戶端Socket進行通訊
- * @throws Exception
- */
- private void handleSocket() throws Exception {
- BufferedReader br = new BufferedReader(new InputStreamReader(socket.getInputStream(), "GBK"));
- StringBuilder sb = new StringBuilder();
- String temp;
- int index;
- while ((temp=br.readLine()) != null) {
- System.out.println(temp);
- if ((index = temp.indexOf("eof")) != -1) {//遇到eof時就結束接收
- sb.append(temp.substring(0, index));
- break;
- }
- sb.append(temp);
- }
- System.out.println("客戶端: " + sb);
- //讀完後寫一句
- Writer writer = new OutputStreamWriter(socket.getOutputStream(), "UTF-8");
- writer.write("你好,客戶端。");
- writer.write("eof\n");
- writer.flush();
- writer.close();
- br.close();
- socket.close();
- }
- }
- }
- public class Client {
- public static void main(String args[]) throws Exception {
- //為了簡單起見,所有的異常都直接往外拋
- String host = "127.0.0.1"; //要連線的服務端IP地址
- int port = 8899; //要連線的服務端對應的監聽埠
- //與服務端建立連線
- Socket client = new Socket(host, port);
- //建立連線後就可以往服務端寫資料了
- 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();
- String temp;
- int index;
- try {
- while ((temp=br.readLine()) != null) {
- if ((index = temp.indexOf("eof")) != -1) {
- sb.append(temp.substring(0, index));
- break;
- }
- sb.append(temp);
- }
- } catch (SocketTimeoutException e) {
- System.out.println("資料讀取超時。");
- }
- System.out.println("服務端: " + sb);
- writer.close();
- br.close();
- client.close();
- }
- }
http://haohaoxuexi.iteye.com/blog/1979837
相關推薦
java Socket程式設計呼叫ServerSocket的close方法
做一個簡單的聊天系統伺服器 伺服器中有一個輸入埠的控制元件,兩個JButton按鈕“停止”和“執行” 點選“執行”按鈕,啟動伺服器 點選“停止”按鈕,呼叫ServerSocket的close方法,停止伺服器。 上部分程式碼: btn_ok.setText(
java Socket程式設計之TCP基本原理
通訊原理: 1.伺服器程式建立一個ServerSocket,呼叫accept方法等待客戶機來連線。 2.客戶端程式建立一個Socket,請求與伺服器建立連線。 3.伺服器接收客戶機的連線請求,同時建立一個新的Socket與客戶端建立連線。伺服器繼續等待新的請求。 關鍵類: ServerS
【Socket】Java Socket程式設計基礎及深入講解
Socket是Java網路程式設計的基礎,瞭解還是有好處的, 這篇文章主要講解Socket的基礎程式設計。Socket用在哪呢,主要用在程序間,網路間通訊。本篇比較長,特別做了個目錄: 一、Socket通訊基本示例 這種模式是基礎,必須掌
Java Socket程式設計(五) 簡單的WEB伺服器
簡單的WEB伺服器一個簡單的WEB伺服器將由列表9.2這樣構建.當然,還必須要對方法和迴應事件進行改進.簡單的伺服器不會分析和儲存請求頭.新的WEB伺服器將分析和儲存請求,為以後的處理作準備.為了達到這個目的,你必須有一個包含HTTP請求的類.HTTPrequest類列表9.5列出了一個完整的HTTPrequ
JAVA Socket 程式設計學習
import java.io.*; import java.net.Socket; /** * 伺服器端執行緒處理類 * Created by Administrator on 2017/9/28. */ public class ServerThread extends Thread {
Java Socket程式設計中處理長連線的方法
因為實習可能要用Java,所以學習了一下Java,正好計算機網路實驗要寫一個Web伺服器,可以用來練練手。 實現Web伺服器時,最基本的流程就是當有客戶端連線伺服器時,把連線交給一個執行緒,由這個執行緒來處理這個連線。處理的流程也很簡單,就是讀取一個請求,然後
JAVA Socket程式設計基礎(轉載)
Java Socket程式設計 對於Java Socket程式設計而言,有兩個概念,一個是ServerSocket,一個是Socket。服務端和客戶端之間通過Socket建立連線,之後它們就可以進行通訊了。首先ServerSocket將在服務端監聽某個埠,當發現客
Java Socket程式設計基礎
1.簡述: Java Socket程式設計時對於TCP/IP 協議層的通訊進行封裝,簡化了相關的一些操作。//待續 2.Socket 通訊時序圖 3.Socket 資料流的互動 4.單客戶端和伺服器通訊的簡單例子:
Java Socket 程式設計原理及教程
對於Java Socket程式設計而言,有兩個概念,一個是ServerSocket,一個是Socket。服務端和客戶端之間通過Socket建立連線,之後它們就可以進行通訊了。首先ServerSocket將在服務端監聽某個埠,當發現客戶端有Socket來試圖連線它時,它會acc
Java Socket程式設計 檔案傳輸(客戶端從伺服器下載一個檔案)
用於客戶端從伺服器端下載檔案 伺服器(Server) package com.socket.sample; import java.io.BufferedInputStream; import java.io.DataInputStream; import java.i
Java Socket 程式設計學習(4)
Java 利用Socket實現UDP客戶端和伺服器端 伺服器端: ServerBean類 package yang.socket.udp; import java.io.IOException; import java.net.DatagramPacket; impo
Java Socket 程式設計學習(3)
Java Socket 程式設計學習,利用DatagramSocket和DatagramPacket實現UDP資料傳輸 場景描述: 客戶端建立資料包,繫結伺服器地址和埠,向伺服器傳送資料;伺服器繫結埠,從埠接受資料 伺服器程式碼: ServerBean類 package y
java socket程式設計
對於Java Socket程式設計而言,有兩個概念,一個是ServerSocket,一個是Socket。服務端和客戶端之間通過Socket建立連線,之後它們就可以進行通訊了。首先ServerSocket將在服務端監聽某個埠,當發現客戶端有Socket來試圖連線它時,
【Socket】Java Socket程式設計基礎及深入講解(轉載)
Socket是Java網路程式設計的基礎,瞭解還是有好處的, 這篇文章主要講解Socket的基礎程式設計。Socket用在哪呢,主要用在程序間,網路間通訊。本篇比較長,特別做了個目錄: 一、Socket通訊基本示例 這種模式是基礎,必須掌握,後
Socket 長連線 短連線 心跳 JAVA SOCKET程式設計
簡單解釋就是: 短連線:建立連線,傳送資料包,關閉連線 長連線:建立連線,傳送資料包,傳送心跳包,傳送資料包,傳送心跳包,傳送心跳包。。。。。。 所以又頻繁的資料收發的話,短連線會頻繁建立TCP連線,而對於長連線,則始終用的是同一個TCP連線 package com.
Java Socket程式設計(非阻塞多執行緒,NIO)
服務端:伺服器Server類public class Server implements Runnable { private int port; private volatile boolean stop; private Selector sele
Java Socket程式設計 標準範例(多執行緒)
伺服器端(Server)非多執行緒 package com.zeph.serverclient; import java.io.BufferedReader; import java.io.IOException; import java.io.InputStreamR
Java Socket程式設計之TCP協議
1、概述 網路程式設計,又稱為Socket程式設計,簡單來講就是通訊的兩個端點都是Socket服務,而Socket之間的資料傳輸本質上都是IO流。而由於網際層中不同的傳輸協議,主要指TCP與UDP協議,導致不同的Socket程式設計的方式,Java為它們提供的API實
Java:Java socket程式設計時讀取輸入流時掛起問題
byte[] bytes = new byte[64]; //讀取輸入流資料 int readLen = 0; while((readLen = input.available())>0){ System.out.println(readLen); input.read(bytes,0
java socket程式設計 長連結處理
在進行Java socket程式設計的時候,涉及到兩種連結方式,一種是短連線,一種是長連線。當我們在學習網路程式設計TCP的時候,一般都只是涉及到短連線程式設計,很少會涉及到長連線,那麼什麼是長連線,什麼是短連線呢? 1.概念: 短連線:指建立SOCKE