socketjava

⑴ 運用socket編寫一個java程序

/*伺服器端程序：*/
mport java.net.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import javax.swing.*;

class ChatServer extends JFrame{
private JTextField inputBox;
private JTextArea outFrame;
private ObjectOutputStream outputS;
private ObjectInputStream inputS;
private ServerSocket toserver;
private Socket server;
private String message = "";
private int counter = 1;

ChatServer(){
super("Server");

Container container = getContentPane();
inputBox = new JTextField();
inputBox.setEditable(false);
//輸出
inputBox.addActionListener(
//監聽
new ActionListener(){
public void actionPerformed(ActionEvent ev)
{
sendMsg(ev.getActionCommand());
inputBox.setText(" ");
}
});
container.add(inputBox,BorderLayout.NORTH);
//輸出框
outFrame = new JTextArea();
container.add(new JScrollPane(outFrame),
BorderLayout.CENTER);
setSize(208,160);
setVisible(true);
}

public void connectServer(){

try{
//創建一個ServerSocket
toserver = new ServerSocket(4000);
while(true){
//等待連接
wait1Connection();
//獲取輸出流
getStreams();
//處理連接
processConnection();
//關閉連接
closeConnection();
++counter;

}
}
catch(EOFException eofException){
System.out.println("Client terminated connection");
}
catch(IOException ee){
ee.printStackTrace();

}
}
private void wait1Connection() throws IOException
{
outFrame.setText("等待連接....\n");
server = toserver.accept();
outFrame.append("連接 " + counter +
" 來自於:" + server.getInetAddress().getHostName());
}
private void getStreams() throws IOException
{
outputS = new ObjectOutputStream(server.getOutputStream());
outputS.flush();
inputS = new ObjectInputStream(server.getInputStream());
outFrame.append("\n成功建立連接。\n");
}
//處理客戶端連接：
private void processConnection() throws IOException
{
//連接成功
message = "成功連接到-->>^_^小粉條";
outputS.writeObject(message);
outputS.flush();//刷新輸出流
//輸入框
inputBox.setEditable(true);
//處理來自客戶端的消息
do{
//讀取消息；
try{
message = (String) inputS.readObject();
outFrame.append("\n" + message);

outFrame.setCaretPosition(outFrame.getText().length());
}
catch(ClassNotFoundException ex){
outFrame.append("\n UnKown object type received");
}
}
while(!message.equals("一肩秋色>> TERMINATE"));

}
private void closeConnection() throws IOException
{
outFrame.append("\n User terminated connction");
inputBox.setEditable(true);
outputS.close();
inputS.close();
server.close();
}
//向客戶端發送消息
private void sendMsg(String message)
{
try{
outputS.writeObject("^_^小粉條>> " + message);
outputS.flush();
outFrame.append("\n^_^小粉條>>" + message);
}catch(IOException em){
outFrame.append("\nError writing object");
}

}
}
public class chat {

public static void main(String[] args) {
// TODO code application logic here
ChatServer process = new ChatServer();
process.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
process.connectServer();
}
}

/*客戶端程序：*/
import java.io.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.net.*;

class CClient extends JFrame{
private JTextField inputBox;
private JTextArea outFrame;
private ObjectOutputStream outputS;
private ObjectInputStream inputS;
private String message = "";
private String ChatServer;
private Socket toclient;
CClient(String srhost)
{
super("Client");
ChatServer = srhost;
//設置客戶端連接的伺服器
Container container = getContentPane();
inputBox = new JTextField();
//建立輸入框
inputBox.setEditable(false);
inputBox.addActionListener(
//監聽
new ActionListener(){
public void actionPerformed(ActionEvent e)
{
sendMsg(e.getActionCommand());
inputBox.setText(" ");
}
}
);
container.add(inputBox,BorderLayout.NORTH);
//輸出框
outFrame = new JTextArea();
container.add(new JScrollPane(outFrame),
BorderLayout.CENTER);
setSize(208,160);
setVisible(true);
}
public void connectClient()
{
try{

//用於連接的Socket
connect1Server();
//得到輸入輸出流
getStreams();
//處理連接
processConnection();
//關閉連接
closeConnection();
}
catch(EOFException eofException){
System.out.println("Client terminated connection");
}
catch(IOException ee){
ee.printStackTrace();

}
}
//捕獲異常
private void getStreams() throws IOException
{
outputS = new ObjectOutputStream(toclient.getOutputStream());
outputS.flush();
inputS = new ObjectInputStream(toclient.getInputStream());
outFrame.append("\n成功建立連接。\n");
}
private void connect1Server() throws IOException
{
outFrame.setText("連接中....\n");
toclient = new Socket(InetAddress.getByName(ChatServer),4000);
outFrame.append("連接至：" + toclient.getInetAddress().getHostName());
}
private void processConnection() throws IOException
{

inputBox.setEditable(true);
//處理來自客戶端的消息
do{
//讀取消息；
try{
message = (String) inputS.readObject();
outFrame.append("\n" + message);

outFrame.setCaretPosition(outFrame.getText().length());
}
catch(ClassNotFoundException ex){
outFrame.append("\n UnKown object type received");
}
}
while(!message.equals("^_^小粉條>> TERMINATE"));

}
private void closeConnection() throws IOException
{
outFrame.append("\n 關閉連接");
inputBox.setEditable(false);
outputS.close();
inputS.close();
toclient.close();
}
//向伺服器端發送消息
private void sendMsg(String message)
{
try{
outputS.writeObject("一肩秋色>> " + message);
outputS.flush();
outFrame.append("\n一肩秋色>>" + message);
}catch(IOException em){
outFrame.append("\nError writing object");
}
}

}
public class ChatClient {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
CClient beginning;
if(args.length == 0)
beginning = new CClient("192.168.1.100");//連接到IP
else
beginning = new CClient(args[0]);
beginning.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
beginning.connectClient();
}

}
//無聊寫的簡單Socket程序，你把裡面的名字改下應該就可以用

⑵ java socket有什麼作用

所謂socket通常也稱作"套接字"，用於描述IP地址和埠，是一個通信鏈的句柄。應用程序通常通過"套接字"向網路發出請求或者應答網路請求。
以J2SDK-1.3為例，Socket和ServerSocket類庫位於java.net包中。ServerSocket用於伺服器端，Socket是建立網路連接時使用的。在連接成功時，應用程序兩端都會產生一個Socket實例，操作這個實例，完成所需的會話。對於一個網路連接來說，套接字是平等的，並沒有差別，不因為在伺服器端或在客戶端而產生不同級別。不管是Socket還是ServerSocket它們的工作都是通過SocketImpl類及其子類完成的。
重要的Socket API：
java.net.Socket繼承於java.lang.Object，有八個構造器，其方法並不多，下面介紹使用最頻繁的三個方法，其它方法大家可以見JDK-1.3文檔。
. Accept方法用於產生"阻塞"，直到接受到一個連接，並且返回一個客戶端的Socket對象實例。"阻塞"是一個術語，它使程序運行暫時"停留"在這個地方，直到一個會話產生，然後程序繼續；通常"阻塞"是由循環產生的。
. getInputStream方法獲得網路連接輸入，同時返回一個InputStream對象實例，。
. getOutputStream方法連接的另一端將得到輸入，同時返回一個OutputStream對象實例。
注意：其中getInputStream和getOutputStream方法均會產生一個IOException，它必須被捕獲，因為它們返回的流對象，通常都會被另一個流對象使用。
編輯本段ServerSocket類例子
int PORT = 8888; // 偵聽埠
// 創建ServerSocket
ServerSocket serverSocket = new ServerSocket(PORT);
// 開始循環
while (true) {
// 等待連接
Socket socket = serverSocket.accept();
// 處理鏈接的線程類
ServerThread st = new ServerThread(socket);
// 啟動線程處理
new Thread(st).start();
}
編輯本段客戶端的例子
int PORT = 8888; // 偵聽埠
// 建立連接
socket = new Socket(「127.0.0.1」, 8888);
// 輸入數據的讀取
BufferedReader netIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
// 寫入數據
PrintWriter netOut = new PrintWriter(socket.getOutputStream());

⑶ java做什麼會用到socket

1、web項目的話一般用到的socket比較少，因為web項目的話一般運用了一些框架，它們幫你把這些東西都封裝了，所以一般不會用到。
2、socket能然你較常接觸主要是在網路編程中，很多東西沒人幫你封裝好，你要自己親手去敲，去了解。比如你自己寫一個聊天系統，你就會較廣泛的去運用到socket

⑷ java中的socket是什麼意思

所謂socket通常也稱作"套接字"，用於描述IP地址和埠，是一個通信鏈的句柄。應用程序通常通過"套接字"向網路發出請求或者應答網路請求。
以J2SDK-1.3為例，Socket和ServerSocket類庫位於java.net包中。ServerSocket用於伺服器端，Socket是建立網路連接時使用的。在連接成功時，應用程序兩端都會產生一個Socket實例，操作這個實例，完成所需的會話。對於一個網路連接來說，套接字是平等的，並沒有差別，不因為在伺服器端或在客戶端而產生不同級別。不管是Socket還是ServerSocket它們的工作都是通過SocketImpl類及其子類完成的。
重要的Socket API：
java.net.Socket繼承於java.lang.Object，有八個構造器，其方法並不多，下面介紹使用最頻繁的三個方法，其它方法大家可以見JDK-1.3文檔。
. Accept方法用於產生"阻塞"，直到接受到一個連接，並且返回一個客戶端的Socket對象實例。"阻塞"是一個術語，它使程序運行暫時"停留"在這個地方，直到一個會話產生，然後程序繼續；通常"阻塞"是由循環產生的。
. getInputStream方法獲得網路連接輸入，同時返回一個InputStream對象實例。
. getOutputStream方法連接的另一端將得到輸入，同時返回一個OutputStream對象實例。
注意：其中getInputStream和getOutputStream方法均會產生一個IOException，它必須被捕獲，因為它們返回的流對象，通常都會被另一個流對象使用。
2ServerSocket類例子編輯

package com.lanber.socket;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerDemo {
/**
* 注意：Socket的發送與接收是需要同步進行的，即客戶端發送一條信息，伺服器必需先接收這條信息，
* 而後才可以向客戶端發送信息，否則將會有運行時出錯。
* @param args
*/
public static void main(String[] args) {
ServerSocket ss = null;
try {
ss = new ServerSocket(8888);
//伺服器接收到客戶端的數據後，創建與此客戶端對話的Socket
Socket socket = ss.accept();
//用於向客戶端發送數據的輸出流
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
//用於接收客戶端發來的數據的輸入流
DataInputStream dis = new DataInputStream(socket.getInputStream());
System.out.println("伺服器接收到客戶端的連接請求：" + dis.readUTF());
//伺服器向客戶端發送連接成功確認信息
dos.writeUTF("接受連接請求，連接成功!");
//不需要繼續使用此連接時，關閉連接
socket.close();
ss.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

3客戶端的例子編輯
package com.lanber.socket;
importjava.io.DataInputStream;
import java.io.DataOutputStream;
importjava.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
public class ClientDemo {
/**
* @param args
*/
public static void main(String[] args) {
Socket socket = null;
try {
socket = new Socket("localhost",8888);
//獲取輸出流，用於客戶端向伺服器端發送數據
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
//獲取輸入流，用於接收伺服器端發送來的數據
DataInputStream dis = new DataInputStream(socket.getInputStream());
//客戶端向伺服器端發送數據
dos.writeUTF("我是客戶端，請求連接!");
//列印出從伺服器端接收到的數據
System.out.println(dis.readUTF());
//不需要繼續使用此連接時，記得關閉哦
socket.close();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

⑸ java socket編程 用在哪裡 為什麼要用

進程通信用，建議網路

簡單的Client/Server程序

1.客戶端程序

importjava.io.*;
importjava.net.*;

publicclassTalkClient{

publicstaticvoidmain(Stringargs[]){

try{
Socketsocket=newSocket("127.0.0.1",4700);
//向本機的4700埠發出客戶請求
BufferedReadersin=newBufferedReader(newInputStreamReader(System.in));
//由系統標准輸入設備構造BufferedReader對象
PrintWriteros=newPrintWriter(socket.getOutputStream());
//由Socket對象得到輸出流，並構造PrintWriter對象
BufferedReaderis=newBufferedReader(newInputStreamReader(socket.getInputStream()));
//由Socket對象得到輸入流，並構造相應的BufferedReader對象
Stringreadline;
readline=sin.readLine();//從系統標准輸入讀入一字元串
while(!readline.equals("bye")){
//若從標准輸入讀入的字元串為"bye"則停止循環
os.println(readline);
//將從系統標准輸入讀入的字元串輸出到Server
os.flush();
//刷新輸出流，使Server馬上收到該字元串
System.out.println("Client:"+readline);
//在系統標准輸出上列印讀入的字元串
System.out.println("Server:"+is.readLine());
//從Server讀入一字元串，並列印到標准輸出上
readline=sin.readLine();//從系統標准輸入讀入一字元串
}//繼續循環
os.close();//關閉Socket輸出流
is.close();//關閉Socket輸入流
socket.close();//關閉Socket
}catch(Exceptione){
System.out.println("Error"+e);//出錯，則列印出錯信息
}
}
}

2.伺服器端程序

importjava.io.*;

importjava.net.*;

importjava.applet.Applet;

publicclassTalkServer{

publicstaticvoidmain(Stringargs[]){

try{

ServerSocketserver=null;

try{

server=newServerSocket(4700);

//創建一個ServerSocket在埠4700監聽客戶請求

}catch(Exceptione){

System.out.println("cannotlistento:"+e);

//出錯，列印出錯信息

}

Socketsocket=null;

try{

socket=server.accept();

//使用accept()阻塞等待客戶請求，有客戶

//請求到來則產生一個Socket對象，並繼續執行

}catch(Exceptione){

System.out.println("Error."+e);

//出錯，列印出錯信息

}

Stringline;

BufferedReaderis=newBufferedReader(newInputStreamReader(socket.getInputStream()));

//由Socket對象得到輸入流，並構造相應的BufferedReader對象

PrintWriteros=newPrintWriter(socket.getOutputStream());

//由Socket對象得到輸出流，並構造PrintWriter對象

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

//由系統標准輸入設備構造BufferedReader對象

System.out.println("Client:"+is.readLine());

//在標准輸出上列印從客戶端讀入的字元串

line=sin.readLine();

//從標准輸入讀入一字元串

while(!line.equals("bye")){

//如果該字元串為"bye"，則停止循環

os.println(line);

//向客戶端輸出該字元串

os.flush();

//刷新輸出流，使Client馬上收到該字元串

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

//在系統標准輸出上列印讀入的字元串

System.out.println("Client:"+is.readLine());

//從Client讀入一字元串，並列印到標准輸出上

line=sin.readLine();

//從系統標准輸入讀入一字元串

}//繼續循環

os.close();//關閉Socket輸出流

is.close();//關閉Socket輸入流

socket.close();//關閉Socket

server.close();//關閉ServerSocket

}catch(Exceptione){

System.out.println("Error:"+e);

//出錯，列印出錯信息

}

}

}

⑹ java Socket通信原理

具體如下：

首先socket 通信是基於TCP/IP 網路層上的一種傳送方式，我們通常把TCP和UDP稱為傳輸層。其中UDP是一種面向無連接的傳輸層協議。UDP不關心對端是否真正收到了傳送過去的數據。

如果需要檢查對端是否收到分組數據包，或者對端是否連接到網路，則需要在應用程序中實現。UDP常用在分組數據較少或多播、廣播通信以及視頻通信等多媒體領域。

在這里我們不進行詳細討論，這里主要講解的是基於TCP/IP協議下的socket通信。

socket是基於應用服務與TCP/IP通信之間的一個抽象，他將TCP/IP協議裡面復雜的通信邏輯進行分裝。

服務端初始化ServerSocket，然後對指定的埠進行綁定，接著對埠及進行監聽，通過調用accept方法阻塞。

此時，如果客戶端有一個socket連接到服務端，那麼服務端通過監聽和accept方法可以與客戶端進行連接。

Java是一門面向對象編程語言，不僅吸收了C++語言的各種優點，還摒棄了C++里難以理解的多繼承、指針等概念，因此Java語言具有功能強大和簡單易用兩個特徵。

Java語言作為靜態面向對象編程語言的代表，極好地實現了面向對象理論，允許程序員以優雅的思維方式進行復雜的編程。

Java具有簡單性、面向對象、分布式、健壯性、安全性、平台獨立與可移植性、多線程、動態性等特點。Java可以編寫桌面應用程序、Web應用程序、分布式系統和嵌入式系統應用程序等。

⑺ java中如何創建socket連接的過程

這是我寫過的一個簡單聊天軟體客戶端 你參考下

importjava.util.*;
importjava.io.*;
importjava.net.*;
importjava.awt.*;
importjavax.swing.*;
importjava.awt.event.*;

{
	privateJTextAreajta=newJTextArea();
	privateJTextFieldjtf=newJTextField();
	privateJComboBox<String>jcb=newJComboBox<String>();
	privateJButtonjbsend=newJButton("send");
	privateJButtonjbrefresh=newJButton("refresh");
	privateInputStreaminput;
	privateOutputStreamoutput;
	private	Socketsocket;
	publicstaticStringSERVER_IP="192.168.1.101";
	publicstaticintSERVER_PORT=8888;
	//Message1->refreshmessage
	//Message2->sendmessage
	publictestChatClient()
	{
		initComponents();
		try
		{
			socket=newSocket(SERVER_IP,SERVER_PORT);
			input=socket.getInputStream();
			output=socket.getOutputStream();	
		}
		catch(IOExceptione)
		{
			System.err.println(e);
		}
		jbrefresh.addActionListener(newActionListener()
		{
			publicvoidactionPerformed(ActionEvente)
			{
				jta.setText("");
				try
				{
					if(socket==null)
						socket=newSocket(SERVER_IP,SERVER_PORT);
					output.write(0x31);
				}
				catch(IOExceptionex)
				{
					JOptionPane.showConfirmDialog(null,ex);
				}
			}	
		});
		jbsend.addActionListener(newActionListener()
		{
			publicvoidactionPerformed(ActionEvente)
			{
				if(jtf.getText()==null||jtf.getText().equals(""))
					return;
				if(jtf.getText().length()>=400)
				{
					JOptionPane.showConfirmDialog(null,"最大字數不能超過400");
					return;
				}
				try
				{
					Stringdestination=jcb.getSelectedItem().toString();
					Stringmessage=jtf.getText();
					if(socket==null)
						socket=newSocket(SERVER_IP,SERVER_PORT);
					byte[]temp=newbyte[3+destination.getBytes().length+message.getBytes().length];
					temp[0]=0x32;
					temp[1]=(byte)destination.getBytes().length;
					inti=2;
					for(intj=0;j<destination.getBytes().length;i++,j++)
						temp[i]=destination.getBytes()[j];
					temp[i++]=(byte)message.getBytes().length;
					for(intj=0;j<message.getBytes().length;i++,j++)
					{
						temp[i]=message.getBytes()[j];
						System.out.println();
					}
					output.write(temp);
					jta.append("me:
");
					jta.append(jtf.getText());
					jta.append("
");
					jtf.setText("");
				}
				catch(IOExceptionex)
				{
					System.err.println(ex);
				}
			}
		});
		try
		{
			jbrefresh.doClick();
			while(true)
			{
				byte[]tempBytes=newbyte[1000];
				input.read(tempBytes);
				intcommand=tempBytes[0]-0x30;
				//intreadLength=input.read();
				switch(command)
				{
					case1:
					{
						intreadLength=tempBytes[1];
						String[]temp=newString(tempBytes,2,readLength,"UTF-8").split(";");
						jcb.removeAllItems();
						if(temp.length==0&&temp[0].equals(""))
							return;
						for(inti=0;i<temp.length;i++)
						{
							jcb.addItem(temp[i]);
						}
						jcb.setSelectedIndex(0);
						break;
					}
					case2:
					{
						intreadLength1=tempBytes[1];
						jta.append(newString(tempBytes,2,readLength1,"UTF-8")+"
");
						intreadLength2=tempBytes[2+readLength1];
						jta.append(newString(tempBytes,3+readLength1,readLength2,"UTF-8")+"
");
						break;
					}
				}
			}
		}
		catch(IOExceptione)
		{
			System.err.println(e);
		}
	}
	publicstaticvoidmain(String[]args){
		testChatClientframe=newtestChatClient();
	}
	publicvoidinitComponents()
	{
		setLayout(newBorderLayout());
		JPaneljpNorth=newJPanel();
		jpNorth.setLayout(newBorderLayout());
		jpNorth.add(jcb,BorderLayout.CENTER);
		jpNorth.add(jbrefresh,BorderLayout.EAST);
		JPaneljpSouth=newJPanel();
		jpSouth.setLayout(newBorderLayout());
		jpSouth.add(jtf,BorderLayout.CENTER);
		jpSouth.add(jbsend,BorderLayout.EAST);
		add(jpNorth,BorderLayout.NORTH);
		add(jpSouth,BorderLayout.SOUTH);
		add(newJScrollPane(jta),BorderLayout.CENTER);
		this.getRootPane().setDefaultButton(jbsend);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setSize(300,600);
		setVisible(true);
	}
}

⑻ 用Java 的socket實現客戶端的功能

//服務端程序：
importjava.io.*;
importjava.net.*;

publicclassTCPServer{
publicstaticvoidmain(String[]args)throwsIOException{
newTCPServer().init();
}
@SuppressWarnings("static-access")
privatevoidinit()throwsIOException{
@SuppressWarnings("resource")
ServerSocketserver=newServerSocket(1000);
Socketclient=null;
while(true){
try{
client=server.accept();
BufferedInputStreambis=newBufferedInputStream(client.getInputStream());
byte[]b=newbyte[1024];
intlen=0;
Stringmessage="";
while((len=bis.read(b))!=-1){
message=newString(b,0,len);
System.out.print("客戶端："+client.getInetAddress().getLocalHost().getHostAddress()+"發來消息："+message);
if("byte".equals(message.trim()))
client.close();
PrintWriterpw=newPrintWriter(client.getOutputStream(),true);
pw.println(message);
}
}catch(Exceptione){
System.err.println("客戶端："+client.getInetAddress().getLocalHost().getHostAddress()+"已斷開連接！");
}
}
}
}

//客戶端程序：
importjava.io.*;
importjava.net.Socket;

{
publicstaticvoidmain(String[]args)throwsIOException{
newTCPClient().init();
}
privatevoidinit()throwsIOException{
@SuppressWarnings("resource")
finalSocketclient=newSocket("127.0.0.1",1000);
BufferedReaderin=newBufferedReader(newInputStreamReader(System.in));
Stringsend="";
while(true){
send=in.readLine();
PrintWriterout=newPrintWriter(client.getOutputStream(),true);
if(!"byte".equals(send.trim()))
out.println(send);
else{
out.println(send);
System.exit(0);
}
newThread(newTCPClient(){
@SuppressWarnings("static-access")
publicvoidrun(){
try{
BufferedInputStreambis=newBufferedInputStream(client.getInputStream());
byte[]b=newbyte[1024];
intlen=0;
while((len=bis.read(b))!=-1){
System.out.println("伺服器："+client.getInetAddress().getLocalHost().getHostAddress()+"發來消息："+newString(b,0,len).trim());
}
}catch(IOExceptione){
System.err.println("連接伺服器失敗!");
}
}
}).start();
}
}
publicvoidrun(){}
}

//伺服器測試結果：

客戶端：192.168.0.200發來消息：001 byte

客戶端：192.168.0.200發來消息：byte

客戶端：192.168.0.200 已斷開連接！

客戶端：192.168.0.200發來消息：adasd

客戶端：192.168.0.200 已斷開連接！

//客戶端測試結果：

---001號客戶端--

001byte

伺服器：192.168.0.200發來消息：001byte

byte //001禮貌說跟伺服器說byte

---002號客戶端--

adasd //002客戶端直接關閉程序

伺服器：192.168.0.200發來消息：adasd

⑼ 用JAVA寫一個SOCKET 接收TCP發來的消息

服務端監聽：ServerSocket server=new ServerSocket(port);//port：綁定的埠號
Socket client=server.accept()();//監聽埠，一旦取得連接則獲得客戶端的socket連接對象client

客戶端： Socket s=new Socket(ip,port);//要連接的伺服器的ip以及埠號

如果正常連接上之後，socket的對象可以獲得InputStream和OutputStreame，然後就可以進行通信了

完成通信之後，執行socket對象的close（）方法關閉連接，完成一次完整的socket連接