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