Java UDP多客户端
目前我有一个Java UDP服务器在Android上工作，服务器在端口上有一个datagramSocket，它首先监听客户端连接，客户端将在同一端口上创建一个新datagramSocket，并通过请求连接发送一个数据包，一旦服务器接收到这个数据包，它将使用IP发送消息，然后只发送一个带有块位置的消息包，而客户端也发送回它自己的块位置 信息，该应用程序允许多个用户连接到一个主机，该主机将接收客户端的所有位置，然后将它们广播出去，还有其他方法可以做到这一点，但我想这样做是为了研究 但不管怎么说，我的应用程序有望处理8个用户，因为这个应用程序适用于wifihotspot。如何允许多个客户端连接、发送数据和接收数据？我已经有了允许一个客户机连接的代码，主机将向该客户机发送数据，但是如果我尝试连接另一个客户机，我会收到一个错误，这是我的服务器和客户机代码 另外，可能有一些调试代码在那里，因为我需要清除它 服务器代码Java UDP多客户端,java,android,networking,udp,wifi,Java,Android,Networking,Udp,Wifi,目前我有一个Java UDP服务器在Android上工作，服务器在端口上有一个datagramSocket，它首先监听客户端连接，客户端将在同一端口上创建一个新datagramSocket，并通过请求连接发送一个数据包，一旦服务器接收到这个数据包，它将使用IP发送消息，然后只发送一个带有块位置的消息包，而客户端也发送回它自己的块位置 信息，该应用程序允许多个用户连接到一个主机，该主机将接收客户端的所有位置，然后将它们广播出去，还有其他方法可以做到这一点，但我想这样做是为了研究 但不管怎么说，我的
package com.example.gelorph_v1;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.MulticastSocket;
import java.net.NetworkInterface;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Enumeration;
import org.apache.http.conn.util.InetAddressUtils;
import android.content.Context;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.util.Log;
public class gameServer extends Thread {
/**
* Sets up a server for Android applciation
*/
private static final String TAG = "GameServer";
private DatagramSocket socket;
private int port = 50000;
private int players = 0;
private ArrayList<gameObject> assets = new ArrayList();
private ArrayList<InetAddress> address = new ArrayList();
private boolean wait = false;
private Context contextHolder = null;
//Make an array, this array will hold all the positions
//the clients sent to it,
//using the ID number, it will store it in a array block
//and the "host" can just return it and use that
public gameServer( Context context ) throws IOException
{
contextHolder = context;
socket = new DatagramSocket( port );
Log.d(TAG, "Server was setup");
}
public DatagramSocket rtnSocket(){ return socket; }
private String getLocalIPAddress()
{
try
{
for (Enumeration<NetworkInterface> nis = NetworkInterface.getNetworkInterfaces(); nis.hasMoreElements();)
{
NetworkInterface ni = nis.nextElement();
Log.v(TAG, "NetworkInterface = " + ni.getDisplayName());
for (Enumeration<InetAddress> ips = ni.getInetAddresses(); ips.hasMoreElements();)
{
InetAddress ip = ips.nextElement();
String s = ip.getHostAddress();
Log.v(TAG, "InetAddress = " + s);
if (!ip.isLoopbackAddress())
{
if(InetAddressUtils.isIPv4Address(s)) return s;
}
}
}
}
catch (SocketException e)
{
Log.e(TAG,"getLocalIPAddress()", e);
}
return null;
}
public void passClient( gameObject clientTemp )
{
assets.add( clientTemp );
}
protected void doInBackground()
{
}
@Override
public void run() {
InetAddress client = null;
boolean run = true;
String data = "";
DatagramPacket packet = null;
while( run )
{
if( data.equalsIgnoreCase( "" ) )
{
/*Log.d(TAG, "waiting for clients");
String msg = "waiting";
int msgLength = msg.length();
byte[] message = msg.getBytes();
DatagramPacket p = new DatagramPacket( message, msgLength, client, port );
try
{
socket.send( p );
}
catch (IOException e2)
{
Log.d(TAG, "Error with sending");
e2.printStackTrace();
}*/
}
//Send some data
if( data.equalsIgnoreCase( "connect" ) && wait == true )
{
Log.d(TAG, "ID send :" + packet.getAddress());
address.add( packet.getAddress() );
players += 1;
String msg = String.valueOf( players );
int msgLength = msg.length();
byte[] message = msg.getBytes();
DatagramPacket p = new DatagramPacket( message, msgLength, packet.getAddress(), port );
try
{
socket.send( p );
wait = false;
}
catch (IOException e2)
{
Log.d(TAG, "Error with sending");
e2.printStackTrace();
data = "";
}
}
//if( /*data.equalsIgnoreCase( "position" )*/ address.size() > 0 )
//{
//Create for loop to create the string
String msg = "";
msg = players + "#";
for(int i = 0; i < players; i++)
{
msg += + i + ":" + assets.get(i).returnPosX() + ":" + assets.get(i).returnPosY() + ":";
}
//msg = String.valueOf(
// players + ":" +
// "1:" + assets.get(0).returnPosX() + ":" + assets.get(0).returnPosY() );
int msgLength = msg.length();
byte[] message = msg.getBytes();
for(int i = 0; i < address.size() ; i++)
{
DatagramPacket p = new DatagramPacket( message, msgLength, address.get(i), port );
try
{
socket.send( p );
}
catch (IOException e2)
{
Log.d(TAG, "Error with sending");
e2.printStackTrace();
}
}
//Log.d(TAG, "Data sent is:" + msg);
//}
data = " ";
//Receive some data
if( wait == false )
{
byte[] buf = new byte[256];
packet = new DatagramPacket( buf, buf.length );
try
{
socket.receive( packet );
wait = true;
}
catch (IOException e)
{
Log.d(TAG, "Error with receiving data");
e.printStackTrace();
}
data = new String( buf, 0, packet.getLength() );
Log.d(TAG, "Data received from :" + packet.getAddress() + ", holds this value: " + data);
//Upset each asset with the data sent
}
//Log.d(TAG, "Data received was :" + data);
try
{
this.sleep( 25 );
}
catch (InterruptedException e)
{
// TODO Auto-generated catch block
Log.d(TAG, "Error with trying to sleep");
e.printStackTrace();
}
}
Log.d(TAG, "Error with while run value");
}
public int returnPlayers(){ return players; }
}
package com.example.gelorph_v1;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.MulticastSocket;
import java.net.Socket;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.util.ArrayList;
import android.content.Context;
import android.graphics.BitmapFactory;
import android.net.DhcpInfo;
import android.net.wifi.WifiManager;
import android.os.AsyncTask;
import android.util.Log;
public class gameClient extends Thread {
private static final String TAG = "gameClient";
private gameServer server;
private boolean rdyForPlay = false;
private gameObject[] assets = new gameObject[8];
private int ID = 0;
private int port = 50000;
private InetAddress address;
private maths cal = new maths();
private Context contextHolder;
private boolean host = false;
private DatagramSocket socket = null;
private int totalPlayers = 0;
public gameClient( boolean serverTag, Context context )
{
if( serverTag == true)
{
host = true;
try
{
contextHolder = context;
server = new gameServer( contextHolder );
this.start();
}
catch (IOException e)
{
Log.d(TAG, "Could not start server");
e.printStackTrace();
}
}
else
{
contextHolder = context;
connectToServer();
this.start();
}
}
public void connectToServer()
{
//Send a connect message to the server
try {
socket = new DatagramSocket( port );
byte[] bufer = new byte[256];
String msg = "connect";
int msgLength = msg.length();
bufer = msg.getBytes();
InetAddress address;
address = InetAddress.getByName("192.168.1.59");
DatagramPacket p = new DatagramPacket( bufer, bufer.length , address, port );
socket.send( p );
} catch (UnknownHostException e2) {
// TODO Auto-generated catch block
e2.printStackTrace();
} catch (SocketException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
//Receive the message back
byte[] buf = new byte[256];
DatagramPacket packet = new DatagramPacket( buf, buf.length );
try
{
socket.receive( packet );
}
catch (IOException e)
{
Log.d(TAG, "Error with receiving data");
e.printStackTrace();
}
String data = new String( buf, 0, packet.getLength() );
ID = Integer.parseInt( data );
setUpClient();
Log.d(TAG, "Data received was :" + ID);
}
public void setUpClient()
{
gameObject temp = new gameObject(BitmapFactory.decodeResource(contextHolder.getResources(), R.drawable.player), 250, 300);
assets[ID] = temp;
if( host == true )
{
server.passClient( temp );
}
}
public void sendTouchEvent(float xSet, float ySet)
{
assets[ID].setPosition( xSet, ySet );
}
@Override
public void run()
{
if( host == true ) { setUpClient(); server.start(); }
rdyForPlay = true;
boolean run = true;
boolean setupPlayer = false;
while( run )
{
//Tell the server to give position of players
//if( setupPlayer == true )
//{
// setUpClient();
// setupPlayer = false;
//}
if( host == false )
{
try {
if(socket == null)
{
socket = new DatagramSocket( port );
}
byte[] bufer = new byte[256];
//String msg = "position";
String msg = ID +":"+ assets[ID].returnPosX() +":"+ assets[ID].returnPosY();
int msgLength = msg.length();
bufer = msg.getBytes();
InetAddress address;
address = InetAddress.getByName("192.168.1.59");
DatagramPacket p = new DatagramPacket( bufer, bufer.length , address, port );
socket.send( p );
} catch (UnknownHostException e2) {
// TODO Auto-generated catch block
Log.d(TAG, "Error with unknown host");
e2.printStackTrace();
} catch (SocketException e) {
// TODO Auto-generated catch block
Log.d(TAG, "Error with socket");
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
Log.d(TAG, "Error with sending/receiving data");
e.printStackTrace();
}
byte[] buf = new byte[256];
DatagramPacket packet = new DatagramPacket( buf, buf.length );
try
{
socket.receive( packet );
}
catch (IOException e)
{
Log.d(TAG, "Error with receiving data");
e.printStackTrace();
}
String data = new String( buf, 0, packet.getLength() );
//Split the string up
String[] dataArray = data.split("#");
int newTotalPlayers = Integer.parseInt( dataArray[0] );
if( newTotalPlayers != totalPlayers )
{
Log.d(TAG," what is total amount of players:" + newTotalPlayers);
if( newTotalPlayers == 1 )
{
newPlayer( 0 );
totalPlayers = newTotalPlayers;
}
else
{
newPlayer( newTotalPlayers );
totalPlayers = newTotalPlayers;
}
//if( ID == 0 && host == false)
//{
// ID = newTotalPlayers;
// setupPlayer = true;
//}
}
//Do a for loop to go through dataArray
for( int i = 0; i < totalPlayers; i++)
{
String[] pos = dataArray[(i + 1)].split(":");
if( Integer.parseInt( pos[(i*3)] ) == ID )
{
Log.d(TAG, "Do nothing please");
}
else
{
assets[i].setPosition( Integer.parseInt( pos[(i*3) + 1] ), Integer.parseInt( pos[(i*3) + 2] ) );
}
}
}
//host
if( host == true )
{
/*if( server.returnPlayers() != totalPlayers )
{
Log.d(TAG," what is total amount of players:" + server.returnPlayers());
newPlayer( server.returnPlayers() );
totalPlayers = server.returnPlayers();
//if( ID == 0 && host == false)
//{
// ID = newTotalPlayers;
// setupPlayer = true;
//}
}*/
}
}
Log.d(TAG, "Error with run value");
}
private void newPlayer( int idOfNewPlayer )
{
gameObject temp = new gameObject(BitmapFactory.decodeResource(contextHolder.getResources(), R.drawable.new_player), 250, 300);
assets[ idOfNewPlayer ] = temp;
}
private void updateAssets()
{
}
public gameObject[] rtnAssets(){ return assets; }
public int rtnID(){ return ID; }
public boolean rtnRdy(){ return rdyForPlay; }
public gameServer rtnServer(){ return server; }
public boolean rtnHost(){ return host; }
public void stopServers()
{
socket.close();
server.rtnSocket().close();
}
}
package com.example.gelorph_v1；
导入java.io.IOException；
导入java.net.DatagramPacket；
导入java.net.DatagramSocket；
导入java.net.InetAddress；
导入java.net.MulticastSocket；
导入java.net.NetworkInterface；
导入java.net.ServerSocket；
导入java.net.Socket；
导入java.net.SocketException；
导入java.net.UnknownHostException；
导入java.util.ArrayList；
导入java.util.Enumeration；
导入org.apache.http.conn.util.InetAddressUtils；
导入android.content.Context；
导入android.graphics.BitmapFactory；
导入android.os.AsyncTask；
导入android.util.Log；
公共类gameServer扩展线程{
/**
*为Android应用程序设置服务器
*/
私有静态最终字符串TAG=“GameServer”；
专用DatagramSocket套接字；
专用int端口=50000；
私人整数玩家=0；
私有ArrayList资产=新ArrayList（）；
私有ArrayList地址=新ArrayList（）；
私有布尔等待=false；
私有上下文contextHolder=null；
//制作一个数组，此数组将保留所有位置
//发送给它的客户，
//使用ID号，它将其存储在数组块中
//而“主机”只需返回它并使用它
公共游戏服务器（上下文）引发IOException
{
contextHolder=上下文；
套接字=新的DatagramSocket（端口）；
Log.d（标记“服务器已设置”）；
}
公共DatagramSocket rtnSocket（）{return socket；}
私有字符串getLocalIPAddress（）
{
尝试
{
对于（枚举nis=NetworkInterface.getNetworkInterfaces（）；nis.hasMoreElements（）；）
{
NetworkInterface ni=nis.nextElement（）；
Log.v（标记“NetworkInterface=“+ni.getDisplayName（））；
对于（枚举ips=ni.getInetAddresses（）；ips.hasMoreElements（）；）
{
InetAddress ip=ips.nextElement（）；
字符串s=ip.getHostAddress（）；
Log.v（标签，“InetAddress=“+s”）；
如果（！ip.isLoopbackAddress（））
{
if（InetAddressUtils.isIPv4Address）返回s；
}
}
}
}
捕获（SocketException e）
{
Log.e（标记“getLocalIPAddress（）”，e）；
}
返回null；
}
public void passClient（gameObject clientTemp）
{
资产。添加（clientTemp）；
}
受保护的void doInBackground（）
{
}
@凌驾
公开募捐{
InetAddress客户端=null；
布尔运行=真；
字符串数据=”；
DatagramPacket数据包=null；
while（运行）
{
if（data.equalsIgnoreCase（“”）
{
/*Log.d（标签“等待客户”）；
字符串msg=“等待”；
int msgLength=msg.length（）；
byte[]message=msg.getBytes（）；
DatagramPacket p=新的DatagramPacket（消息、msgLength、客户端、端口）；
尝试
{
socket.send（p）；
}
捕获（IOE2异常）
{
Log.d（标记“发送错误”）；
e2.printStackTrace（）；
}*/
}
//发送一些数据
if（data.equalsIgnoreCase（“connect”）和&wait==true）
{
Log.d（标记“ID send:+packet.getAddress（））；
add（packet.getAddress（））；
玩家+=1；
String msg=String.valueOf（玩家）；
int msgLength=msg.length（）；
byte[]message=msg.getBytes（）；
DatagramPacket p=新的DatagramPacket（消息，msgLength，packet.getAddress（），端口）；
尝试
{
socket.send（p）；
等待=错误；
}
捕获（IOE2异常）
{
Log.d（标记“发送错误”）；
e2.printStackTrace（）；
数据=”；
}
}
//if（/*data.equalsIgnoreCase（“位置”）*/address.size（）>0）
//{
//创建for循环以创建字符串
字符串msg=“”；
msg=玩家+“#”；
对于（int i=0；i