javasocketclient

Ⅰ 用java socket實現client與server通信，客戶端向服務端發送字元串, 服務端再返回,把返回的變成大寫。

import java.io.*;
import java.util.*;
import java.net.*;
public class Client { //客戶端
public static void main(String args[])throws Exception
{
String clientMessage;//來自用戶輸入的的信息
String serverMessage; //伺服器端的信息
Socket ClientSocket=new Socket("127.0.0.0",5557);//參數是本機地址和埠,客戶端套接字，發起TCP連接
BufferedReader fromUser=new BufferedReader(new InputStreamReader(System.in));//字元讀取流，獲取從鍵盤輸入的字元
BufferedReader fromServer=new BufferedReader(new InputStreamReader(ClientSocket.getInputStream()));//獲取從伺服器端的流，建立套接字輸入流
DataOutputStream toServer=new DataOutputStream(ClientSocket.getOutputStream());//建立套接字輸出流
clientMessage=fromUser.readLine();//讀取從用戶的輸入
toServer.writeBytes(clientMessage);//寫到伺服器端
serverMessage=fromServer.readLine();//從伺服器端讀取
ClientSocket.close();//關閉套接字連接
}

}
import java.io.*;
import java.net.*; //伺服器端
public class Server {
public static void main(String args[])throws Exception
{
String ClientMessage;
String ServerMessage;
ServerSocket serversocket=new ServerSocket(5557);//埠要和客戶端對應
System.out.println("正在監聽5555埠");//
while(true)
{
Socket collection=serversocket.accept();//調用accept()函數，建立TCP連接
DataInputStream fromClient=new DataInputStream(collection.getInputStream());
DataOutputStream toClient=new DataOutputStream(collection.getOutputStream());
ClientMessage=fromClient.readUTF();//接收來自客戶端的信息
ServerMessage=ClientMessage.toUpperCase();//轉換為大寫
toClient.writeBytes(ServerMessage);//寫到伺服器端
System.out.println("成功建立TCP連接");
}
}

}

Ⅱ 使用java socket怎麼能夠實現將一個客戶端發送到服務端的消息轉發到另一個客戶端

用一個集合記住所有客戶的Socket，收到數據包，就根據收發要求，轉發

Ⅲ Java Socket編程，server端如何返回值，client端如何進行處理

鏈接是否正常是由通訊底層必須做的，也就是通常所說的三次握手，socket才能進行數據包的傳輸。
socket編程用的是客戶端的對象進行傳輸。
多搜搜例子就好了。
不是很麻煩。

Ⅳ java socket 客戶端能 多次 隨時 向客戶端發送會話嗎要怎麼實現，能舉個例子嗎 在線等，謝謝再次謝謝

可以做的到，但這個是有前提的，就好像QQ一樣，必須對方在線，他才能收到你的會話。
比如說多次，你可以採用循環輸入，等到滿足一個條件時，退出！
比如說發送方代碼如下：
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.Scanner;

class practise12{
public static void main(String[] args) throws SocketException, UnknownHostException, IOException{
DatagramSocket ds=new DatagramSocket(3000);
DatagramPacket dp=null;
String str="";
do{
System.out.println("請輸入：");
Scanner input=new Scanner(System.in);
str=input.next();
dp=new DatagramPacket(str.getBytes(),str.length(),InetAddress.getByName("localhost"),8000);
ds.send(dp);
}while(str.compareTo("exit")!=0);
ds.close();
}
}

這樣你就可以多次發送會話，當發送方輸入「exit」時，程序就會退出。
接收方也是同樣道理：當接收到「exit」時，程序退出。

一點灼見，希望對你有用！

Ⅳ 用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 client 專門建立一個接收和發送信息的方法，接收不到參數如果不用建立的方法，

建議用NIO

Ⅶ clientSocket = serverSocket.accept();在Java中是什麼意思

ServerSocket:Java中一個專門用來建立Socket伺服器的類,可以用伺服器需要使用的埠號作為參數來創建伺服器對象。model:ServerSocket serverSocket=new ServerSocket(port);
socket=serverSocket.accept();// 監聽,等待連接,一旦有client端連接便創建socket實例.
然後通過socket交互數據.
serverSocket.accept();//serverSocket.accept();的這一方法可以說是阻塞式的,沒有client端連接就一直監聽著,等待連接.直到有client端連接進來才通過socket實例與client端進行交互,一個server端可以被多個client端連接,每連接一次都會創建一個socket實例,派發服務線程.
如果把監聽寫進while()循環里便可實現不斷的監聽.
可以參照網路socket.

Ⅷ java socketioclient 怎麼獲取數據

php有可用的websocket庫，不需要php-fpm。
目前比較成熟的有swoole（swoole.com），和workman（workman.net）
swoole是c寫的php擴展， 效率比nodejs還要高，workman是純php實現，兩者都號稱可以實現並發百萬TCP連接。
給你個例子：
這個要通過cmd運行的 具體帶的參數有點忘記了
<?php
error_reporting(E_ALL);
set_time_limit(0);
ob_implicit_flush();

//創建一個socket連接 設置參數 綁定 監聽 並且返回
$master = WebSocket("localhost",12345);

//標示是否已經進行過握手了
$is_shaked = false;

//是否已經關閉
$is_closed = true;

//將socket變為一個可用的socket

while(true){
//如果是關閉狀態並且是沒有握手的話 則創建一個可用的socket（貌似第二個條件可以去除）
if($is_closed && !$is_shaked){
if(($sock = socket_accept($master)) < 0){
echo "socket_accept() failed: reason: " . socket_strerror($sock) . "\n";
}

//將關閉狀態修改為false
$is_closed = false;
}

//開始進行數據處理
process($sock);
}

//處理請求的函數
function process($socket){
//先從獲取到全局變數
global $is_closed, $is_shaked;

//從socket中獲取數據
$buffer = socket_read($socket,2048);

//如果buffer返回值為false並且已經握手的話 則斷開連接
if(!$buffer && $is_shaked){
disconnect($socket);
}else{
//如果沒有握手的話則握手 並且修改握手狀態
if($is_shaked == false){
$return_str = dohandshake($buffer);
$is_shaked = true;
}else{
//如果已經握手的話則送入deal函數中進行相應處理
$data_str = decode($buffer); //解析出來的從前端送來的內容
console($data_str);
$return_str = encode(deal($socket, $data_str));
//$return_str = encode($data_str);
}

//將應該返回的字元串寫入socket返回
socket_write($socket,$return_str,strlen($return_str));
}
}

function deal($socket, $msgObj){
$obj = json_decode($msgObj);
foreach($obj as $key=>$value){
if($key == 'close'){
disconnect($socket);
console('close success');
return 'close success';
}else if($key == 'msg'){
console($value."\n");
return $value;
}
}
}

Ⅸ java socket編程中sever和client互相傳送數字

importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.InputStreamReader;
importjava.io.OutputStream;
importjava.io.PrintStream;
importjava.net.InetAddress;
importjava.net.Socket;
importjava.net.UnknownHostException;

/**
*測試客戶端類
*/
publicclassASCIIClient
{
	Stringstr=null;

	SocketClientsc=null;

	BufferedReaderbr=null;

	publicASCIIClient()
	{
		sc=newSocketClient("localhost",8080);
		br=newBufferedReader(newInputStreamReader(System.in));
		while(true)
		{
			try
			{
				str=br.readLine();
				if(!str.matches("^([0-9]|[1-9]\d|1[01]\d|12[0-7]|-1)$"))
				{
					System.out.println("Pleaseinput-1~127");
				}
				elseif("-1".equals(str))
				{
					sc.sendRequest(str);
					System.out.println("
closing...");
					sc.destroy();
					System.exit(0);
					break;
				}
				else
				{
					sc.sendRequest(str);
					sc.getResponse();
				}
			}
			catch(Exceptione)
			{
				System.err.println(e.toString());
				sc.destroy();
				System.exit(-1);
			}
		}
	}

	publicstaticvoidmain(Stringargs[])
	{
		newASCIIClient();
	}
}

classSocketClient
{
	Socketsocket=null;

	PrintStreamps=null;

	BufferedReaderbr=null;

	OutputStreamos=null;

	InputStreamis=null;

	publicSocketClient(Stringip,intport)
	{
		try
		{
			socket=newSocket(ip,port);
			InetAddressaddr=socket.getLocalAddress();
			System.out.println("addr="+addr.getHostName()+"/"+addr.getHostAddress());
			System.out.println("socket="+socket);
			os=socket.getOutputStream();
			is=socket.getInputStream();
			ps=newPrintStream(os);
			br=newBufferedReader(newInputStreamReader(is));
		}
		catch(UnknownHostExceptione)
		{
			System.err.println("未知伺服器地址..."+e.toString());
			destroy();
			System.exit(-1);
		}
		catch(IOExceptione)
		{
			System.err.println("連接伺服器失敗..."+e.toString());
			destroy();
			System.exit(-1);
		}
	}

	publicvoidsendRequest(Stringrequest)
	{
		ps.println(request);
		System.out.print("Sent:"+request);
	}

	publicStringgetResponse()
	{
		Stringresponse=null;
		try
		{
			response=br.readLine();
			System.out.println("Received:"+response);
		}
		catch(IOExceptione)
		{
			System.err.println("獲取響應失敗..."+e.toString());
			System.exit(-1);
		}
		returnresponse;
	}

	publicvoiddestroy()
	{
		try
		{
			if(null!=br)
			{
				br.close();
			}
			if(null!=is)
			{
				is.close();
			}
			if(null!=ps)
			{
				ps.close();
			}
			if(null!=os)
			{
				os.close();
			}
			if(null!=socket)
			{
				socket.close();
			}
		}
		catch(IOExceptionignore)
		{}
	}
}


///////////////////////////////////////////////////////////////


importjava.io.BufferedReader;
importjava.io.IOException;
importjava.io.InputStream;
importjava.io.InputStreamReader;
importjava.io.OutputStream;
importjava.io.PrintStream;
importjava.net.ServerSocket;
importjava.net.Socket;

/**
*測試伺服器類
*/
publicclassASCIIServer
{
	SocketServerss=null;

	BufferedReaderbr=null;

	Stringrequest="";

	publicASCIIServer()
	{
		ss=newSocketServer("localhost",8080);
		br=newBufferedReader(newInputStreamReader(System.in));
		try
		{
			while(true)
			{
				request=ss.getRequest();
				if("-1".equals(request))
				{
					System.out.println("
closing...");
					ss.destroy();
					System.exit(0);
					break;
				}
				else
				{
					charc=(char)(Integer.parseInt(request));
					ss.sendResponse(c+"");
				}
			}
		}
		catch(Exceptione)
		{
			System.err.println(e.toString());
			ss.destroy();
			System.exit(-1);
		}
	}

	publicstaticvoidmain(Stringargs[])
	{
		newASCIIServer();
	}
}

classSocketServer
{
	ServerSocketserverSocket=null;

	SocketclientSocket=null;

	PrintStreamps=null;

	OutputStreamos=null;

	InputStreamis=null;

	BufferedReaderbr=null;

	publicSocketServer(Stringip,intport)
	{
		try
		{
			serverSocket=newServerSocket(port);
			System.out.println("ServerStarted:"+serverSocket);
			clientSocket=serverSocket.accept();
			System.out.println("Connectionaccepted:"+clientSocket);
			os=clientSocket.getOutputStream();
			is=clientSocket.getInputStream();
			ps=newPrintStream(os);
			br=newBufferedReader(newInputStreamReader(is));
		}
		catch(Exceptione)
		{
			System.err.println(e.toString());
			destroy();
			System.exit(-1);
		}
	}

	publicStringgetRequest()
	{
		Stringrequest=null;
		try
		{
			request=br.readLine();
			System.out.print("Received:"+request);
		}
		catch(IOExceptione)
		{
			System.err.println("無法讀取埠..."+e.toString());
			System.exit(-1);
		}
		returnrequest;
	}

	publicvoidsendResponse(Stringresponse)
	{
		try
		{
			ps.println(response);
			System.out.println("Sent:"+response);
		}
		catch(Exceptione)
		{
			System.err.println("寫入埠失敗..."+e.toString());
			System.exit(-1);
		}
	}

	publicvoiddestroy()
	{
		try
		{
			if(null!=br)
			{
				br.close();
			}
			if(null!=is)
			{
				is.close();
			}
			if(null!=ps)
			{
				ps.close();
			}
			if(null!=os)
			{
				os.close();
			}
			if(null!=clientSocket)
			{
				clientSocket.close();
			}
			if(null!=serverSocket)
			{
				serverSocket.close();
			}
		}
		catch(IOExceptionignore)
		{}
	}
}

Ⅹ 如何使用 java websocketclient

client.htm

<!DOCTYPE html>
<html>
<body>
<h1>WebSocket</h1>
<script src="client.js"></script>
</body>
</html>
client.js
var ws = new WebSocket("ws://127.0.0.1:8080/");

ws.onopen = function() {
alert("Opened");
ws.send("I'm client");
};

ws.onmessage = function (evt) {
alert(evt.data);
};

ws.onclose = function() {
alert("Closed");
};

ws.onerror = function(err) {
alert("Error: " + err);
};
服務端可以用各種語言去實現，Java可以用Jetty，C#可以用SuperSocket，這里我舉例用Node.js，創建server.js：

var WebSocketServer = require('ws').Server
, wss = new WebSocketServer({port: 8080});
wss.on('connection', function(ws) {
ws.on('message', function(message) {
console.log('received: %s', message);
});
ws.send('something');
});
運行方式：

npm install ws
node server.js