javacsocket

1. 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();
}
}
}

2. 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應用程序、分布式系統和嵌入式系統應用程序等。

3. java socket發送字元串

java中socket是向某個特定地址的埠發送流（字元串通過getBytes方法轉換成流）。

publicstaticvoidmain(String[]args){
Sockets;
try{
s=newSocket("localhost",9091);

DataOutputStreamout=newDataOutputStream(s.getOutputStream());
out.write("aslkjlksjdsad".getBytes());
out.flush();
out.close();
}catch(UnknownHostExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}catch(IOExceptione){
//TODOAuto-generatedcatchblock
e.printStackTrace();
}
}

備註：有發送的話，就需要相應的地址和埠上做一個接收的，來實現交互。

4. 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();
}

}

5. Java的Socket編程

要通信首先要建立socket鏈接。
1 ab客戶端與服務端建立socket鏈接
2 a客戶端發送消息到服務端
3 服務端收到消息後，發送到指定的b客戶端
4 b客戶端處理來自服務端的消息

6. java多用戶socket通訊，數據返回給指定用戶

我覺得你是不是要了解下nio或者netty？
應該會有所幫助…服務端綁定埠監聽，每個客戶端去連接都是一個socket，服務端使用selector分發客戶端請求並處理。
基本使用netty就好了…

7. 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);
	}
}

8. java簡答題 如何創建socket連接的過程

java socket建立連接的過程如下：
socket

1、 首先調用Socket類的構造函數，以伺服器的指定的IP地址或指定的主機名和指定的埠號為參數，創建一個Socket流，在創建Socket流的過程中包含了向伺服器請求建立通訊連接的過程實現。
2、 建立了客戶端通訊Socket後。就可以使用Socket的方法getInputStream()和getOutputStream()來創建輸入/輸出流。這樣，使用Socket類後，網路輸入輸出也轉化為使用流對象的過程。
3、 使用輸入輸出流對象的相應方法讀寫位元組流數據，因為流連接著通訊所用的Socket，Socket又是和伺服器端建立連接的一個端點，因此數據將通過連接從伺服器得到或發向伺服器。這時我們就可以對位元組流數據按客戶端和伺服器之間的協議進行處理，完成雙方的通訊任務。
4、 待通訊任務完畢後，我們用流對象的close()方法來關閉用於網路通訊的輸入輸出流,在用Socket對象的close()方法來關閉Socket。

9. java 怎麼獲得socket流

java 獲得socket流

BufferedReader的readLine方法是一次讀一行的，這個方法是阻塞的，直到它讀到了一行數據為止程序才會繼續往下執行，那麼readLine什麼時候才會讀到一行呢？直到程序遇到了換行符或者是對應流的結束符readLine方法才會認為讀到了一行，才會結束其阻塞，讓程序繼續往下執行。所以我們在使用BufferedReader的readLine讀取數據的時候一定要記得在對應的輸出流裡面一定要寫入換行符（流結束之後會自動標記為結束，readLine可以識別），寫入換行符之後一定記得如果輸出流不是馬上關閉的情況下記得flush一下，這樣數據才會真正的從緩沖區裡面寫入。

10. 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());