javatcp通信

A. 在java中實現TCP協議編程中怎麼傳

在Java中實現TCP協議編程

ServerSocket：編寫TCP網路服務程序,首先要用到java.net.ServerSocket類用以創建伺服器Socket

構造方法：

ServerSocket(intport)：創建綁定到特定埠的伺服器套接字

ServerSocket(intport,intbacklog)：利用指定的backlog(伺服器忙時保持連接請求的等待客戶數量),創建伺服器套接字並將其綁定到指定的本地埠號。

ServerSocket(intport,intbacklog,InetAddressbindAddr)：使用指定的埠、偵聽backlog和要綁定到的本地IP地址創建伺服器。

Socket：客戶端要與伺服器建立連接,必須先創建一個Socket對象

常用構造方法

Socket(Stringhost,intport)：創建一個流套接字並將其連接到指定主機上的指定埠號。

Socket(InetAddressaddress,intport)：創建一個流套接字並將其連接到指定IP地址的指定埠號。

伺服器端程序調用ServerSocket類中的accept()方法等待客戶端的連接請求，一旦accept()接收了客戶端連接請求，該方法返回一個與該客戶端建立了專線連接的Socket對象，不用程序去創建這個Socket對象。建立了連接的兩個Socket是以IO流的方式進行數據交換的，Java提供了Socket類中的getInputStream()返回Socket的輸入流對象，getOutputStream()返回Socket的輸出流對象。

TCP伺服器與TCP客戶端間的數據的接受圖示：

用TCP實現伺服器與客戶端的「聊天」：

實例代碼：

客戶端：

packagecom.hbsi.net;

importjava.net.Socket;

importjava.io.*;

publicclassTcpClient{

publicstaticvoidmain(String[]args)throwsException{

//1.建立tcp客戶端socket，要確定要連接的伺服器ip，port

Sockets=newSocket("192.168.49.87",9009);

//獲取鍵盤錄入

BufferedReaderbr=newBufferedReader(newInputStreamReader(System.in));

//2.通過建立的socket，獲取輸出流對象

//數據輸出給伺服器端

OutputStreamout=s.getOutputStream();

BufferedWriterbwout=newBufferedWriter(newOutputStreamWriter(out));

//獲取伺服器端返回的數據

//讀取伺服器端發過來的信息InputStreamReader()

BufferedReaderbrin=newBufferedReader(newInputStreamReader(

s.getInputStream()));

Stringline=null;

while((line=br.readLine())!=null){

if(line.equals("over"))

break;

bwout.write(line);

bwout.newLine();

bwout.flush();

Stringstr=brin.readLine();

System.out.println("server:"+str);

}

br.close();

s.close();

}

}

伺服器端：

packagecom.hbsi.net;

importjava.io.BufferedReader;

importjava.io.BufferedWriter;

importjava.io.InputStream;

importjava.io.InputStreamReader;

importjava.io.OutputStreamWriter;

importjava.net.ServerSocket;

importjava.net.Socket;

publicclassTcpServer{

publicstaticvoidmain(String[]args)throwsException{

//1.建立伺服器socket

ServerSocketss=newServerSocket(9009);

//2.調用accept()

Sockets=ss.accept();

System.out.println(s.getInetAddress().getHostAddress()

+"...connection");

//讀取客戶的信息的輸入流

InputStreamin=s.getInputStream();

BufferedReaderbrin=newBufferedReader(newInputStreamReader(in));

//向客戶端發送信息輸出流，服務端向客戶端返回信息OutputStreamWriter()

BufferedWriterbrout=newBufferedWriter(newOutputStreamWriter(

s.getOutputStream())); Stringline=null;

while((line=brin.readLine())!=null){

System.out.println("client:"+line);

brout.write(line.toUpperCase());//伺服器端收到信息後，將信息轉為大寫返回給客戶端toUpperCase()

brout.newLine();

brout.flush();

}

s.close();

ss.close();

}

}

B. JAVA Socket 底層是怎樣基於TCP/IP 實現的

首先必須明確：TCP/IP模型中有四層結構：
應用層（Application Layer）、傳輸層（Transport Layer）、網路層（Internet Layer ）、鏈路層（LinkLayer）
其中Ip協議（Internet Protocol）是位於網路層的，TCP協議時位於傳輸層的。通過Ip協議可以使可以使兩台計算機使用同一種語言，從而允許Internet上連接不同類型的計算機和不同操作系統的網路。Ip協議只保證計算機能夠接收和發送分組數據。 當計算機要和遠程的計算機建立連接時，TCP協議會讓他們建立連接：用於發送和接收數據的虛擬電路。

在JAVA中，我們用 ServerSocket、Socket類創建一個套接字連接，從套接字得到的結果是一個InputStream以及OutputStream對象，以便將連接作為一個IO流對象對待。通過IO流可以從流中讀取數據或者寫數據到流中，讀寫IO流會有異常IOException產生。

套接字或插座(socket)是一種軟體形 式的抽象，用於表達兩台機器間一個連接的「終端」。針對一個特定的連接，每台機器上都有一個「套接字」，可以想像它們之間有一條虛擬的「線纜」。JAVA 有兩個基於數據流的套接字類：ServerSocket，伺服器用它「偵聽」進入的連接；Socket，客戶端用它初始一次連接。偵聽套接字只能接收新的 連接請求，不能接收實際的數據包，即ServerSocket不能接收實際的數據包。
套接字是基於TCP/IP實現的，它是用來提供一個訪問TCP的服務介面，或者說套接字socket是TCP的應用編程介面API，通過它應用層就可以訪問TCP提供的服務。
在JAVA中，我們用 ServerSocket、Socket類創建一個套接字連接，從套接字得到的結果是一個InputStream以及OutputStream對象，以便 將連接作為一個IO流對象對待。通過IO流可以從流中讀取數據或者寫數據到流中，讀寫IO流會有異常IOException產生。

C. 編寫一個簡單的TCP通信程序。伺服器發送「你好我是伺服器」，客戶端接收該信息並顯示在屏幕上。用Java寫

1、伺服器端

importjava.io.DataOutputStream;
importjava.io.IOException;
importjava.net.ServerSocket;
importjava.net.Socket;

publicclassSocketServer{

privatestaticfinalintPORT=8088;

publicstaticvoidmain(String[]args){
ServerSocketserver=null;
try{
server=newServerSocket(PORT);
while(true){
Socketclient=server.accept();
newThread(newServer(client)).start();
}
}catch(IOExceptione){
e.printStackTrace();
}
}

}

classServerimplementsRunnable{

privateSocketclient;

publicServer(Socketclient){
this.client=client;
}

publicvoidrun(){
DataOutputStreamoutput=null;
try{
output=newDataOutputStream(client.getOutputStream());
output.writeUTF("你好我是伺服器");
}catch(IOExceptione){
e.printStackTrace();
}finally{
try{
if(output!=null)output.close();
output=null;
}catch(IOExceptione){}
}
}

}

2、客戶端

importjava.io.DataInputStream;
importjava.io.IOException;
importjava.net.Socket;
importjava.net.UnknownHostException;

{

privatestaticfinalintPORT=8088;

publicstaticvoidmain(String[]args){
Socketsocket=null;
try{
socket=newSocket("127.0.0.1",PORT);
DataInputStreamin=newDataInputStream(socket.getInputStream());
Stringres=in.readUTF();
System.out.println(res);
if(in!=null)in.close();
}catch(UnknownHostExceptione){
e.printStackTrace();
}catch(IOExceptione){
e.printStackTrace();
}finally{
if(socket!=null){
try{
socket.close();
}catch(IOExceptione){}
}
}
}
}

D. Java TCP socket通信，如何實現發送十六進制值，並在數據接收窗口中顯示這些數據對應的字元串，非常感謝！

我自己的電腦上有一段源代碼，就是基於TCP聊天小代碼，能進行相互之間的消息接受。我的代碼是直接傳輸字元串的,不是16進制滴。嗯，也貼出來看看吧！

運行伺服器，c1,c2就可以了，c1與c2可進行通信。

Client.java

import java.net.*;
public class Client{
static byte num=1;
private int portNum;

public Client(int portnum){
this.portNum=portnum;
System.out.println("您是第"+num+"位客服端");
num++;
}

public void sentMessage(String me){
//都是向伺服器發信息埠號1999
try{
DatagramSocket ds=new DatagramSocket();
DatagramPacket dp=new DatagramPacket(me.getBytes(),me.length(),InetAddress.getByName("127.0.0.1"),1999);
ds.send(dp);
ds.close();
}catch(Exception e){
e.printStackTrace();
}

}

public String receiveMessage(){
String str="";
try{
DatagramSocket ds=new DatagramSocket(this.portNum);//表示哦自己的接收埠號是1999
byte[] buf=new byte[1024];
DatagramPacket dp=new DatagramPacket(buf,1024);
ds.receive(dp);
str=new String(dp.getData(),0,dp.getLength());
ds.close();
}catch(Exception e){
e.printStackTrace();
}

return str;
}
}

c1.java

import java.util.*;
public class c1 implements Runnable{
Client cl;
boolean goon=true;
Scanner sc=new Scanner(System.in);
public c1(){
cl=new Client(2000);
System.out.println("這里是2000客戶端\n你可以發送信息。請輸入要發送的信息。out退出");

new Thread(this).start();
while(this.goon==true){
say();
}
if(goon==false){
System.exit(0);
}
}

public static void main(String[] args){
new c1();
}

public void say(){
String mess=sc.nextLine();
System.out.println("是否發送y/n");
String key=sc.nextLine();
if(key.equals("y")){
System.out.println("信息信息發送中……");
try{
cl.sentMessage(mess);
}catch(Exception e){
e.printStackTrace();
}
}
else if(key.equals("out")){
goon=false;
}
}

public void run(){
while(this.goon==true){
String sst="";
try{
sst=cl.receiveMessage();
}catch(Exception e){
e.printStackTrace();
}

if(sst.length()>0){
System.out.println(sst);
}
try{
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}

}
System.out.println("程序結束！");
}
}

c2.java

import java.util.*;
public class c2 implements Runnable{
Client cl;
boolean goon=true;
Scanner sc=new Scanner(System.in);
public c2(){
cl=new Client(2001);
System.out.println("這里是2001客戶端\n你可以發送信息。請輸入要發送的信息。out退出");
new Thread(this).start();
while(goon==true){
say();
}
if(goon==false){
System.exit(0);
}
}

public static void main(String[] args){
new c2();
}

public void say(){
String mess=sc.nextLine();
System.out.println("是否發送y/n");
String key=sc.nextLine();
if(key.equals("y")){
System.out.println("信息信息發送中……");
try{
cl.sentMessage(mess);
}catch(Exception e){
e.printStackTrace();
}
}
else if(key.equals("out")){
this.goon=false;
}
}

public void run(){
while(this.goon==true){
String sst="";
try{
sst=cl.receiveMessage();
}catch(Exception e){
e.printStackTrace();
}

if(sst.length()>0){
System.out.println(sst);
}
try{
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}

}
System.out.println("聊天關閉！");
}
}

Server.java

import java.net.*;
import java.util.*;
public class Server implements Runnable{
private String message;
boolean work=true;
byte tm=10;
String[] clomessage={"信息：正在斷開網路連接.",".",".\n","信息：設置保存中……","","","完成\n","信息：歡迎下次使用\n","信息：完成\n","Goodbye!"};
public Server(){
new Thread(this).start();
System.out.println("本程序為服務端Server");
Scanner sc=new Scanner(System.in);
System.out.println("輸入命令out關閉伺服器");
String clo=sc.nextLine();
if(clo.equals("out")){
System.out.println("正在關閉伺服器……");
setwork(false);
System.exit(0);
}

}

public static void main(String[] args){
new Server();

}

public void setwork(boolean bo)
{
this.work=bo;
}

public void setMessage(String str){
this.message=str;
}

public String getMessage(){
return this.message;
}

public void sentMessage(){
String mes=this.getMessage();
try{
DatagramSocket ds=new DatagramSocket();
DatagramPacket dp=new DatagramPacket(mes.getBytes(),mes.length(),InetAddress.getByName("127.0.0.1"),2000);
DatagramPacket dp2=new DatagramPacket(mes.getBytes(),mes.length(),InetAddress.getByName("127.0.0.1"),2001);
ds.send(dp);
ds.send(dp2);
ds.close();
System.out.println("信息發送至：127.0.0.1：2000 & 127.0.0.1：2001");
this.setMessage("");
}catch(Exception e){
e.printStackTrace();
}
}

public void receiveMessage() throws Exception{
try{
DatagramSocket ds=new DatagramSocket(1999);//表示哦自己的接收埠號是1999
byte[] buf=new byte[1024];
DatagramPacket dp=new DatagramPacket(buf,1024);
ds.receive(dp);
String str=new String(dp.getData(),0,dp.getLength());
if(str.length()>0){
this.setMessage(str);
System.out.println("信息：Server從"+dp.getAddress().getHostAddress()+"主機(埠號："+dp.getPort()+")收到信息:"+this.getMessage());
}

ds.close();
}catch(Exception e){
e.printStackTrace();
}
}

public void run(){
while(tm>0){
if(work==false){
tm--;
System.out.print(clomessage[9-tm]);
}
try{
receiveMessage();//時刻接受信息
}catch(Exception e){
e.printStackTrace();
}

if(this.getMessage().length()>0){//如果接收到信息則發送信息

try{
sentMessage();
}catch(Exception e){
e.printStackTrace();
}
try{
Thread.sleep(100);
}catch(InterruptedException e){
e.printStackTrace();
}

}
}
}
}

呵呵，請指教啊！

E. JAVA TCP通信，客戶端給伺服器傳送JAVA對象通信出錯了，求各位大神指教

在java中用socket傳輸對象的時候，底層是把java對象序列化，然後以二進制數據進行傳輸的。socket的服務端和客戶端都需要有這個對象的聲明，比如客戶端發送的是com.client.MsgPackage對象，那麼這個對象的class文件必須在服務端的classpath中。否則就會是接收方接收了tcp的數據包，但是無法還原成對象。
底層要能把對象序列化，這個對象要實現一個可序列化的介面：java.io.Serializable。
類通過實現 java.io.Serializable
介面以啟用其序列化功能。未實現此介面的類將無法使其任何狀態序列化或反序列化。可序列化類的所有子類型本身都是可序列化的。序列化介面沒有方法或欄位，僅用於標識可序列化的語義。
writeObject 方法負責寫入特定類的對象的狀態，以便相應的 readObject 方法可以恢復它。通過調用
out.defaultWriteObject 可以調用保存 Object 的欄位的默認機制。該方法本身不需要涉及屬於其超類或子類的狀態。通過使用
writeObject 方法或使用 DataOutput 支持的用於基本數據類型的方法將各個欄位寫入 ObjectOutputStream，狀態可以被保存。
readObject 方法負責從流中讀取並恢復類欄位。它可以調用 in.defaultReadObject
來調用默認機制，以恢復對象的非靜態和非瞬態欄位。defaultReadObject
方法使用流中的信息來分配流中通過當前對象中相應指定欄位保存的對象的欄位。這用於處理類演化後需要添加新欄位的情形。該方法本身不需要涉及屬於其超類或子類的狀態。通過使用
writeObject 方法或使用 DataOutput 支持的用於基本數據類型的方法將各個欄位寫入 ObjectOutputStream，狀態可以被保存。

F. java的TCP和HTTP有什麼區別

TCP協議對應於抄傳輸層，而HTTP協議對應於應用層，從本質上來說，二者沒有可比性。Http協議是建立在TCP協議基礎之上的，當瀏覽器需要從伺服器獲取網頁數據的時候，會發出一次Http請求。Http會通過TCP建立起一個到伺服器的連接通道，當本次請求需要的數據完畢後，Http會立即將TCP連接斷開，這個過程是很短的。所以Http連接是一種短連接，是一種無狀態的連接。所謂的無狀態，是指瀏覽器每次向伺服器發起請求的時候，不是通過一個連接，而是每次都建立一個新的連接。如果是一個連接的話，伺服器進程中就能保持住這個連接並且在內存中記住一些信息狀態。而每次請求結束後，連接就關閉，相關的內容就釋放了，所以記不住任何狀態，成為無狀態連接。

G. java如何通過tcp向指定的IP發送指令並獲得返回的包

以下是一個展示java使用tcp通訊的簡單例子，包括伺服器和客戶端代碼：

/**
*TCPServer
*/
import java.io.*;
import java.net.*;
class TCPServer{
public static void main(String[] args)throws IOException{
ServerSocket listen = new ServerSocket(5050);

Socket server = listen.accept();
InputStream in = server.getInputStream();
OutputStream out = server.getOutputStream();
char c = (char)in.read();
System.out.println("收到:" + c);
out.write('s');

out.close();
in.close();
server.close();
listen.close();
}
}

/**
*TCPClient
*/
import java.io.*;
import java.net.*;
class TCPClient{
public static void main(String[] args)throws IOException{
Socket client = new Socket("127.0.0.1" , 5050);
InputStream in = client.getInputStream();
OutputStream out = client.getOutputStream();

out.write('c');
char c = (char)in.read();
System.out.println("收到:" + c);
out.close();
in.close();
client.close();
}
}