java通訊編程

Ⅰ 編程技巧：java串口通信簡介

嵌入式系統或感測器網路的很多應用和測試都需要通過PC機與嵌入式設備或感測器節點進行通信 其中 最常用的介面就是RS 串口和並口(鑒於USB介面的復雜性以及不需要很大的數據傳輸量 USB介面用在這里還是顯得過於奢侈 況且目前除了SUN有一個支持USB的包之外 我還沒有看到其他直接支持USB的Java類庫) SUN的CommAPI分別提供了對常用的RS 串列埠和IEEE 並行埠通訊的支持 RS C(又稱EIA RS C 以下簡稱RS )是在 年由美國電子工業協會(EIA)聯合貝爾系統 數據機廠家及計算機終端生產廠家共同制定的用於串列通訊的標准 RS 是一個全雙工的通訊協議 它可以同時進行數據接收和發送的工作

常見的Java串口包

目前 常見的Java串口包有SUN在 年發布的串口通信API m jar(Windows下) m jar(Linux/Solaris);IBM的串口通信API以及一個開源的實現 鑒於在Windows下SUN的API比較常用以及IBM的實現和SUN的在API層面都是一樣的 那個開源的實現又不像兩家大廠的產品那樣讓人放心 這里就只介紹SUN的串口通信API在Windows平台下的使用

串口包的安裝(Windows下)

到SUN的網站下載javam win zip 包含的東西如下所示

按照其使用說明(l)的說法 要想使用串口包進行串口通信 除了設置好環境變數之外 還要將win dll復制到 in目錄下;將m jar復制到 lib;把m properties也同樣拷貝到 lib目錄下 然而在真正運行使用串口包的時候 僅作這些是不夠的 因為通常當運行 java MyApp 的時候 是由JRE下的虛擬機啟動MyApp的 而我們只復制上述文件到JDK相應目錄下 所以應用程序將會提示找不到串口 解決這個問題的方法很簡單 我們只須將上面提到的文件放到JRE相應的目錄下就可以了

值得注意的是 在網路應用程序中使用串口API的時候 還會遇到其他更復雜問題 有興趣的話 你可以查看CSDN社區中 關於網頁上Applet用javam 讀取客戶端串口的問題 的帖子

串口API概覽

m CommPort

這是用於描述一個被底層系統支持的埠的抽象類 它包含一些高層的IO控制方法 這些方法對於所有不同的通訊埠來說是通用的 SerialPort 和ParallelPort都是它的子類 前者用於控制串列埠而後者用於控這並口 二者對於各自底層的物理埠都有不同的控制方法 這里我們只關心SerialPort

m CommPortIdentifier

這個類主要用於對串口進行管理和設置 是對串口進行訪問控制的核心類 主要包括以下方法

l 確定是否有可用的通信埠

l 為IO操作打開通信埠

l 決定埠的所有權

l 處理埠所有權的爭用

l 管理埠所有權變化引發的事件(Event)

m SerialPort

這個類用於描述一個RS 串列通信埠的底層介面 它定義了串口通信所需的最小功能集 通過它 用戶可以直接對串口進行讀 寫及設置工作

串口API實例

大段的文字怎麼也不如一個小例子來的清晰 下面我們就一起看一下串口包自帶的例子 SerialDemo中的一小段代碼來加深對串口API核心類的使用方法的認識

列舉出本機所有可用串口

voidlistPortChoices(){ CommPortIdentifierportId; Enumerationen=CommPortIdentifier getPortIdentifiers(); //iteratethroughtheports while(en hasMoreElements()){ portId=(CommPortIdentifier)en nextElement(); if(portId getPortType()==CommPortIdentifier PORT_SERIAL){ System out println(portId getName()); } } portChoice select(parameters getPortName()); }

以上代碼可以列舉出當前系統所有可用的串口名稱 我的機器上輸出的結果是 和

串口參數的配置

串口一般有如下參數可以在該串口打開以前配置進行配置

包括波特率 輸入/輸出流控制 數據位數 停止位和齊偶校驗

SerialPortsPort; try{ sPort setSerialPortParams(BaudRate Databits Stopbits Parity); //設置輸入/輸出控制流 sPort setFlowControlMode(FlowControlIn|FlowControlOut); }catch(){}

串口的讀寫

對串口讀寫之前需要先打開一個串口

CommPortIdentifierportId=CommPortIdentifier getPortIdentifier(PortName); try{ SerialPortsPort=(SerialPort)portId open( 串口所有者名稱 超時等待時間); }catch(PortInUseExceptione){//如果埠被佔用就拋出這個異常 (e getMessage()); } //用於對串口寫數據 OutputStreamos=newBufferedOutputStream(sPort getOutputStream()); os write(intdata); //用於從串口讀數據 InputStreamis=newBufferedInputStream(sPort getInputStream()); intreceivedData=is read();

讀出來的是int型 你可以把它轉換成需要的其他類型

這里要注意的是 由於Java語言沒有無符號類型 即所有的類型都是帶符號的 在由byte到int的時候應該尤其注意 因為如果byte的最高位是 則轉成int類型時將用 來佔位 這樣 原本是 的byte類型的數變成int型就成了 這是很嚴重的問題 應該注意避免

串口通信的通用模式及其問題

終於嘮叨完我最討厭的基礎知識了 下面開始我們本次的重點 串口應用的研究 由於向串口寫數據很簡單 所以這里我們只關注於從串口讀數據的情況 通常 串口通信應用程序有兩種模式 一種是實現SerialPortEventListener介面 監聽各種串口事件並作相應處理;另一種就是建立一個獨立的接收線程專門負責數據的接收 由於這兩種方法在某些情況下存在很嚴重的問題(至於什麼問題這里先賣個關子J) 所以我的實現是採用第三種方法來解決這個問題

事件監聽模型

現在我們來看看事件監聽模型是如何運作的

l 首先需要在你的埠控制類(例如SManager)加上 implements SerialPortEventListener

l 在初始化時加入如下代碼

try{ SerialPortsPort addEventListener(SManager); }catch(TooManyListenersExceptione){ sPort close(); ( toomanylistenersadded ); } sPort notifyOnDataAvailable(true);

l 覆寫public void serialEvent(SerialPortEvent e)方法 在其中對如下事件進行判斷

BI 通訊中斷

CD 載波檢測

CTS 清除發送

DATA_AVAILABLE 有數據到達

DSR 數據設備准備好

FE 幀錯誤

OE 溢位錯誤

OUTPUT_BUFFER_EMPTY 輸出緩沖區已清空

PE 奇偶校驗錯

RI 振鈴指示

一般最常用的就是DATA_AVAILABLE 串口有數據到達事件 也就是說當串口有數據到達時 你可以在serialEvent中接收並處理所收到的數據 然而在我的實踐中 遇到了一個十分嚴重的問題

首先描述一下我的實驗 我的應用程序需要接收感測器節點從串口發回的查詢數據 並將結果以圖標的形式顯示出來 串口設定的波特率是 川口每隔 毫秒返回一組數據(大約是 位元組左右) 周期(即持續時間)為 秒 實測的時候在一個周期內應該返回 多個位元組 而用事件監聽模型我最多隻能收到不到 位元組 不知道這些位元組都跑哪裡去了 也不清楚到底丟失的是那部分數據 值得注意的是 這是我將serialEvent()中所有處理代碼都注掉 只剩下列印代碼所得的結果 數據丟失的如此嚴重是我所不能忍受的 於是我決定採用其他方法

串口讀數據的線程模型

這個模型顧名思義 就是將接收數據的操作寫成一個線程的形式:

(){ ThreadreadDataProcess=newThread(newRunnable(){ publicvoidrun(){ while(newData!= ){ try{ newData=is read(); System out println(newData); //其他的處理過程 ……… }catch(IOExceptionex){ System err println(ex); return; } } readDataProcess start(); }

在我的應用程序中 我將收到的數據打包放到一個緩存中 然後啟動另一個線程從緩存中獲取並處理數據 兩個線程以生產者—消費者模式協同工作 數據的流向如下圖所示

這樣 我就圓滿解決了丟數據問題 然而 沒高興多久我就又發現了一個同樣嚴重的問題 雖然這回不再丟數據了 可是原本一個周期( 秒)之後 感測器節電已經停止傳送數據了 但我的串口線程依然在努力的執行讀串口操作 在控制台也可以看見收到的數據仍在不斷的列印 原來 由於感測器節點發送的數據過快 而我的接收線程處理不過來 所以InputStream就先把已到達卻還沒處理的位元組緩存起來 於是就導致了明明感測器節點已經不再發數據了 而控制台卻還能看見數據不斷列印這一奇怪的現象 唯一值得慶幸的是最後收到數據確實是 左右位元組 沒出現丟失現象 然而當處理完最後一個數據的時候已經快 分半鍾了 這個時間遠遠大於節點運行周期 這一延遲對於一個實時的顯示系統來說簡直是災難!

後來我想 是不是由於兩個線程之間的同步和通信導致了數據接收緩慢呢?於是我在接收線程的代碼中去掉了所有處理代碼 僅保留列印收到數據的語句 結果依然如故 看來並不是線程間的通信阻礙了數據的接收速度 而是用線程模型導致了對於發送端數據發送速率過快的情況下的數據接收延遲 這里申明一點 就是對於數據發送速率不是如此快的情況下前面者兩種模型應該還是好用的 只是特殊情況還是應該特殊處理

第三種方法

痛苦了許久(Boss天天催我L)之後 偶然的機會 我聽說TinyOS中(又是開源的)有一部分是和我的應用程序類似的串口通信部分 於是我下載了它的 x版的Java代碼部分 參考了它的處理方法 解決問題的方法說穿了其實很簡單 就是從根源入手 根源不就是接收線程導致的嗎 那好 我就乾脆取消接收線程和作為中介的共享緩存 而直接在處理線程中調用串口讀數據的方法來解決問題(什麼 為什麼不把處理線程也一並取消? 都取消應用程序界面不就鎖死了嗎?所以必須保留)於是程序變成了這樣

publicbyte[]getPack(){ while(true){ //PacketLength為數據包長度 byte[]msgPack=newbyte[PacketLength]; for(inti= ;i<PacketLength;i++){ if((newData=is read())!= ){ msgPack[i]=(byte)newData; System out println(msgPack[i]); } } returnmsgPack; } }

在處理線程中調用這個方法返回所需要的數據序列並處理之 這樣不但沒有丟失數據的現象行出現 也沒有數據接收延遲了 這里唯一需要注意的就是當串口停止發送數據或沒有數據的時候is read()一直都返回 如果一旦在開始接收數據的時候發現 就不要理它 繼續接收 直到收到真正的數據為止

結束語

Ⅱ java 網路編程： 如何實現客戶端與客戶端之間的之間通信

伺服器告知雙方對方的ip地址，並協調由哪一方主動連接。
如 協調結果是： 把c2的地址告訴c1，讓c1主動連接c2，讓c2打開埠等待連接。

要考慮認證問題，比如c2如何知道連接上來的是c1，而不是其他人，就需要有認證機制。
另外要考慮內網問題。由於從外部連接內網裡面的IP地址是相當繁瑣復雜的，所以需要特別的機制處理。

Ⅲ 通過java編程中socket應用,編寫一個基於c/s架構的區域網通信軟體,

//伺服器端
importjava.io.*;
importjava.net.*;
importjava.util.*;
publicclassChatServer{
booleanstarted=false;
ServerSocketss=null;
Socketsocket=null;
List<Client>clients=newArrayList<Client>();

publicstaticvoidmain(String[]args){
newChatServer().start();
}

publicvoidstart(){

try{
ss=newServerSocket(8888);
started=true;
}catch(BindExceptione){
System.out.println("埠使用中。。。。。");
System.out.println("請關掉相關程序，並重新運行伺服器！");
System.exit(0);
}catch(IOExceptione){
e.printStackTrace();
}

try{

while(started){
socket=ss.accept();
Clientc=newClient(socket);

newThread(c).start();
clients.add(c);
}
}catch(IOExceptione){
e.printStackTrace();
}

}classClientimplementsRunnable{
privateSocketsocket=null;
privateDataInputStreamdis=null;
privateDataOutputStreamdos=null;
privatebooleanbConnected=false;

publicClient(Socketsocket){
bConnected=true;
this.socket=socket;
try{
dis=newDataInputStream(socket.getInputStream());
dos=newDataOutputStream(socket.getOutputStream());
}catch(IOExceptione){
e.printStackTrace();
}
}

publicvoidsend(Stringstr){
try{
dos.writeUTF(str);
}catch(IOExceptione){
clients.remove(this);
System.out.println("對方退出了，我從List裡面去掉了！");
}
}

@Override
publicvoidrun(){
try{
while(bConnected){
Strings=dis.readUTF();
System.out.println(s);
for(inti=0;i<clients.size();i++){
Clientc=clients.get(i);
c.send(s);
}

}
}catch(EOFExceptione){
System.out.println("clientclosed!");
}catch(IOExceptione){
e.printStackTrace();
}finally{
try{
if(dis!=null)dis.close();
if(dos!=null)dos.close();
if(socket!=null)socket.close();
}catch(IOExceptione){
e.printStackTrace();
}
}

}
}
}
//客戶端
importjava.awt.event.*;
importjava.awt.*;
importjava.io.*;
importjava.net.*;
{
TextFieldtfTxt=newTextField();
TextAreataContent=newTextArea();

Socketsocket=null;
DataOutputStreamdos=null;
DataInputStreamdis=null;
booleanbConnected=false;
ThreadtRecv=newThread(newServer());

publicstaticvoidmain(String[]args){
newChatClient().launchFrame();
}

publicvoidlaunchFrame(){
setBounds(400,300,300,300);
setVisible(true);
this.setTitle("ChatClient");
this.add(tfTxt,BorderLayout.SOUTH);
this.add(taContent,BorderLayout.NORTH);
this.pack();
this.addWindowListener(newWindowAdapter(){
@Override
publicvoidwindowClosing(WindowEvente){
disconnect();
setVisible(false);
System.exit(0);
}

});
tfTxt.addActionListener(newTFMonitor());

connect();

tRecv.start();
}

publicvoidconnect(){
try{
socket=newSocket("127.0.0.1",8888);
dos=newDataOutputStream(socket.getOutputStream());
dis=newDataInputStream(this.socket.getInputStream());
System.out.println("Connected!");
bConnected=true;
}catch(UnknownHostExceptione){
e.printStackTrace();
}catch(IOExceptione){
e.printStackTrace();
}
}

publicvoiddisconnect(){
try{
dos.close();
dis.close();
socket.close();
}catch(IOExceptione){
e.printStackTrace();
}

/*
try{
bConnected=false;
tRecv.join();
}catch(InterruptedExceptione){
e.printStackTrace();
}finally{
try{
dos.close();
dis.close();
socket.close();
}catch(IOExceptione){
e.printStackTrace();
}
}
*/
}


{
@Override
publicvoidactionPerformed(ActionEvente){
Stringstr=tfTxt.getText().trim();
//taContent.setText(str);
tfTxt.setText("");
try{
//System.out.println(socket);
dos.writeUTF(str);
dos.flush();
//dos.close();
}catch(IOExceptione1){
e1.printStackTrace();
}
}

}
{

@Override
publicvoidrun(){
try{
while(bConnected){
Strings=dis.readUTF();
//System.out.println(s);
taContent.setText(taContent.getText()+s+'
');
}
}catch(IOExceptione){
System.out.println("talkover,byebye");
//e.printStackTrace();
}
}

}
}

Ⅳ java網路技術編程

一、 客戶端網路編程步驟
客戶端(Client)是指網路編程中首先發起連接的程序，客戶端一般實現程序界面和基本邏輯實現，在進行實際的客戶端編程時，無論客戶端復雜還是簡單，以及客戶端實現的方式，客戶端的編程主要由三個步驟實現：
1、 建立網路連接
客戶端網路編程的第一步都是建立網路連接。在建立網路連接時需要指定連接到的伺服器的IP地址和埠號，建立完成以後，會形成一條虛擬的連接，後續的操作就可以通過該連接實現數據交換了。
2、 交換數據
連接建立以後，就可以通過這個連接交換數據了。交換數據嚴格按照請求響應模型進行，由客戶端發送一個請求數據到伺服器，伺服器反饋一個響應數據給客戶端，如果客戶端不發送請求則伺服器端就不響應。
根據邏輯需要，可以多次交換數據，但是還是必須遵循請求響應模型。
3、 關閉網路連接
在數據交換完成以後，關閉網路連接，釋放程序佔用的埠、內存等系統資源，結束網路編程。
最基本的步驟一般都是這三個步驟，在實際實現時，步驟2會出現重復，在進行代碼組織時，由於網路編程是比較耗時的操作，所以一般開啟專門的現場進行網路通訊。

二、伺服器端網路編程步驟
伺服器端(Server)是指在網路編程中被動等待連接的程序，伺服器端一般實現程序的核心邏輯以及數據存儲等核心功能。伺服器端的編程步驟和客戶端不同，是由四個步驟實現，依次是：
1、 監聽埠
伺服器端屬於被動等待連接，所以伺服器端啟動以後，不需要發起連接，而只需要監聽本地計算機的某個固定埠即可。
這個埠就是伺服器端開放給客戶端的埠，伺服器端程序運行的本地計算機的IP地址就是伺服器端程序的IP地址。
2、 獲得連接
當客戶端連接到伺服器端時，伺服器端就可以獲得一個連接，這個連接包含客戶端的信息，例如客戶端IP地址等等，伺服器端和客戶端也通過該連接進行數據交換。
一般在伺服器端編程中，當獲得連接時，需要開啟專門的線程處理該連接，每個連接都由獨立的線程實現。
3、 交換數據
伺服器端通過獲得的連接進行數據交換。伺服器端的數據交換步驟是首先接收客戶端發送過來的數據，然後進行邏輯處理，再把處理以後的結果數據發送給客戶端。簡單來說，就是先接收再發送，這個和客戶端的數據交換數序不同。
其實，伺服器端獲得的連接和客戶端連接是一樣的，只是數據交換的步驟不同。
當然，伺服器端的數據交換也是可以多次進行的。
在數據交換完成以後，關閉和客戶端的連接。
4、 關閉連接
當伺服器程序關閉時，需要關閉伺服器端，通過關閉伺服器端使得伺服器監聽的埠以及佔用的內存可以釋放出來，實現了連接的關閉。
其實伺服器端編程的模型和呼叫中心的實現是類似的，例如移動的客服電話10086就是典型的呼叫中心，當一個用戶撥打10086時，轉接給一個專門的客服人員，由該客服實現和該用戶的問題解決，當另外一個用戶撥打10086時，則轉接給另一個客服，實現問題解決，依次類推。
在伺服器端編程時，10086這個電話號碼就類似於伺服器端的埠號碼，每個用戶就相當於一個客戶端程序，每個客服人員就相當於伺服器端啟動的專門和客戶端連接的線程，每個線程都是獨立進行交互的。
這就是伺服器端編程的模型，只是TCP方式是需要建立連接的，對於伺服器端的壓力比較大，而UDP是不需要建立連接的，對於伺服器端的壓力比較小罷了。

Ⅳ java編程中，Socket通信是怎麼實現的

java編程對於Socket之間的通信過程如下：

服務端往Socket的輸出流裡面寫東西，客戶端就可以通過Socket的輸入流讀取對應的內容。Socket與Socket之間是雙向連通的，所以客戶端也可以往對應的Socket輸出流裡面寫東西，然後服務端對應的Socket的輸入流就可以讀出對應的內容。下面來看一些服務端與客戶端通信的例子：

publicclassServer{

publicstaticvoidmain(Stringargs[])throwsIOException{
//為了簡單起見，所有的異常信息都往外拋
intport=8899;
//定義一個ServerSocket監聽在埠8899上
ServerSocketserver=newServerSocket(port);
//server嘗試接收其他Socket的連接請求，server的accept方法是阻塞式的
Socketsocket=server.accept();
//跟客戶端建立好連接之後，我們就可以獲取socket的InputStream，並從中讀取客戶端發過來的信息了。
Readerreader=newInputStreamReader(socket.getInputStream());
charchars[]=newchar[64];
intlen;
StringBuildersb=newStringBuilder();
while((len=reader.read(chars))!=-1){
sb.append(newString(chars,0,len));
}
System.out.println("fromclient:"+sb);
reader.close();
socket.close();
server.close();
}

}

客戶端代碼
Java代碼publicclassClient{

publicstaticvoidmain(Stringargs[])throwsException{
//為了簡單起見，所有的異常都直接往外拋
Stringhost="127.0.0.1";//要連接的服務端IP地址
intport=8899;//要連接的服務端對應的監聽埠
//與服務端建立連接
Socketclient=newSocket(host,port);
//建立連接後就可以往服務端寫數據了
Writerwriter=newOutputStreamWriter(client.getOutputStream());
writer.write("HelloServer.");
writer.flush();//寫完後要記得flush
writer.close();
client.close();
}

}

Ⅵ java網路編程應該怎樣在客戶端和伺服器間實現通信

以前寫的，照貼了。。。伺服器端：import java.awt.*;x0dx0aimport java.awt.event.WindowAdapter;x0dx0aimport java.awt.event.WindowEvent;x0dx0aimport java.io.*;x0dx0aimport java.net.*;/*6、 採用UDP協議，編寫一個Java網路應用程序，該應用分伺服器端程序和客戶端程序兩部分。x0dx0a* 客戶端指定一個伺服器上的文件名，讓伺服器發回該文件的內容，或者提示文件不存在。x0dx0a* （20分）（服務端程序和客戶端程序分別命名為Server.java和Client.java）*/x0dx0apublic class N4BT6 extends Framex0dx0a{x0dx0aDatagramSocket socket ;x0dx0aDatagramPacket packet ;byte[] buf ;x0dx0aFile file ;x0dx0aFileInputStream input;x0dx0aString message = "該文件不存在";x0dx0aTextArea text;x0dx0apublic N4BT6(String title)x0dx0a{x0dx0asuper(title);x0dx0atext = new TextArea(6,4);x0dx0aadd(text);x0dx0asetSize(400, 300);x0dx0asetVisible(true);x0dx0aaddWindowListener(new WindowAdapter()x0dx0a{x0dx0apublic void windowClosing(WindowEvent e)x0dx0a{x0dx0adispose();x0dx0a}x0dx0a});x0dx0ax0dx0abuf = new byte[1024];x0dx0atryx0dx0a{x0dx0asocket = new DatagramSocket(1230);x0dx0apacket = new DatagramPacket(buf, buf.length);x0dx0asocket.receive(packet);x0dx0afile = new File(new String(packet.getData()));x0dx0asocket = new DatagramSocket();x0dx0a} x0dx0acatch (Exception e)x0dx0a{e.printStackTrace();x0dx0a}x0dx0ax0dx0aif(file.exists())x0dx0a{x0dx0atryx0dx0a{x0dx0abuf = new byte[(int)file.length()];x0dx0apacket = new DatagramPacket(buf,buf.length,InetAddress.getLocalHost(),1234);x0dx0ainput = new FileInputStream(file);x0dx0ainput.read(buf);x0dx0asocket.send(packet);x0dx0a}x0dx0acatch (IOException e) x0dx0a{x0dx0ae.printStackTrace();x0dx0a}x0dx0a}x0dx0aelsex0dx0a{x0dx0atryx0dx0a{x0dx0apacket = new DatagramPacket(message.getBytes(),message.getBytes().length,x0dx0aInetAddress.getLocalHost(),1234);x0dx0asocket.send(packet);x0dx0a}x0dx0acatch (Exception e) x0dx0a{x0dx0ae.printStackTrace();x0dx0a}x0dx0a}x0dx0ax0dx0a}x0dx0apublic static void main(String[] args)x0dx0a{x0dx0anew N4BT6("Server");x0dx0a}x0dx0a}x0dx0a客戶端：import java.awt.*;x0dx0aimport java.awt.event.*;x0dx0aimport java.net.DatagramPacket;x0dx0aimport java.net.DatagramSocket;x0dx0aimport java.net.InetAddress;public class N4BT6_2 extends Framex0dx0a{x0dx0aTextArea text;x0dx0aString message = "Q.txt";x0dx0aDatagramSocket socket ;x0dx0aDatagramPacket packet;x0dx0abyte[] buf;x0dx0apublic N4BT6_2(String title)x0dx0a{x0dx0asuper(title);x0dx0atext = new TextArea(6,4);x0dx0aadd(text);x0dx0asetSize(400, 300);x0dx0asetVisible(true);x0dx0aaddWindowListener(new WindowAdapter()x0dx0a{x0dx0apublic void windowClosing(WindowEvent e)x0dx0a{x0dx0adispose();x0dx0a}x0dx0a});x0dx0atryx0dx0a{x0dx0ax0dx0asocket = new DatagramSocket();x0dx0apacket = new DatagramPacket(message.getBytes(),message.getBytes().length,x0dx0aInetAddress.getLocalHost(),1230);x0dx0asocket.send(packet);x0dx0a}x0dx0acatch (Exception e) x0dx0a{x0dx0ae.printStackTrace();x0dx0a}x0dx0ax0dx0atryx0dx0a{x0dx0abuf = new byte[1024];x0dx0asocket = new DatagramSocket(1234);x0dx0apacket = new DatagramPacket(buf,buf.length);x0dx0asocket.receive(packet);x0dx0atext.append(new String(buf));x0dx0a}x0dx0acatch (Exception e) x0dx0a{x0dx0ae.printStackTrace();x0dx0a}x0dx0a}x0dx0apublic static void main(String[] args)x0dx0a{x0dx0anew N4BT6_2("Client");x0dx0a}x0dx0a}

Ⅶ 在java網路編程中，客戶端/伺服器怎麼實現不同電腦之間的通信

1、首先兩台電腦和伺服器都在同一個網路中
2、相互之間可以用sokect<--->server
相互進行通信