是否可以将小程序用作Java服务器？

我刚刚开始接触网络，我对如何使用服务器托管公司的服务器进行游戏感到困惑。目前，该程序允许用户从他们的计算机托管服务器，并且在一定程度上起作用。唯一的问题是，当我的朋友从其他州连接到游戏时，他们的ping非常高，而且他们的延迟非常严重

我现在正在使用一个提供免费网络托管空间的网站。我相信我已经跳过了使用套接字所需的大部分权限限制，小程序的工作方式与在我的计算机上运行时的工作方式相同

下面是游戏课的摘录。如果我使用InetAddress.getLocalHost（）.getHostAddress（）获取IP，它将从使用客户端的用户那里获取IP，并使他们成为服务器主机。这是可行的，但不能解决我的滞后问题

    Game.java

    public synchronized void start() {
    running = true;

    thread = new Thread(this, NAME + "_main");
    thread.start();

    if (JOptionPane.showConfirmDialog(this, "Do you want to run the server") == 0) {
        socketServer = new GameServer(this);
        socketServer.start();
    }


    this.ipAddress = "31.170.163.198";
    //this.ipAddress = InetAddress.getByName(ipAddress).toString();

    System.out.println("IP: " + this.ipAddress);
    socketClient = new GameClient(this, this.ipAddress);//Inet4Address.getLocalHost().getHostAddress());    

    try {
        Player.setIp(Inet4Address.getLocalHost().getHostAddress());
    } catch (UnknownHostException e) {
        e.printStackTrace();
    }
    socketClient.start();
}

我希望包含jar的服务器托管服务器。我们都会相互ping测试，而且大多数情况下都会超时，然而，当我们ping服务器的ip时，我们都会得到不错的ping。当我手动输入服务器的IP（我在控制面板中找到此信息）时，服务器/客户端无法建立连接。我已经尝试使用提供的网站IP和服务器IP。我还尝试使用applet.getCodeBase（）.getHost（）从服务器检索IP，但该IP也无法发送/接收数据

我想做的事可能吗？服务器是否阻止我以这种方式使用它？我需要重写整个程序并研究java servlet来实现我的目标吗

如果这个问题很愚蠢，我道歉。在过去的3-4天里，我一直在研究这个问题，但进展甚微。我已经搜索了一些关于以这种方式使用服务器的信息，但在这个主题上我发现很少

下面是其他相关代码的一些摘录

GameClient.java

package fraccas.java2dgame.net;


public class GameClient extends Thread {

private InetAddress ipAddress;
private DatagramSocket socket;
private Game game;
public long lastPing = 0;
public static int ping = 0;

public GameClient(Game game, String ipAddress) {
    this.game = game;
    try {
        this.socket = new DatagramSocket();
        this.ipAddress = InetAddress.getByName(ipAddress);
        System.out.println("IP: " + InetAddress.getByName(ipAddress));
    } catch (SocketException e) {
        e.printStackTrace();
    } catch (UnknownHostException e) {
        e.printStackTrace();
    }
}

public void run() {
    while (true) {
        byte[] data = new byte[1024];
        DatagramPacket packet = new DatagramPacket(data, data.length);
        try {
            socket.receive(packet);
            if (packet != null)
            {
                long current = System.currentTimeMillis();
                ping = (int) (current - lastPing);
                lastPing = current;
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        this.parsePacket(packet.getData(), packet.getAddress(), packet.getPort());
    }
}

private void parsePacket(byte[] data, InetAddress address, int port) {
    String message = new String(data).trim();
    PacketTypes type = Packet.lookupPacket(message.substring(0, 2));
    Packet packet = null;
    switch (type) {
    default:
    case INVALID:
        break;
    case LOGIN:
        packet = new Packet00Login(data);
        handleLogin((Packet00Login) packet, address, port);
        break;
    case DISCONNECT:
        packet = new Packet01Disconnect(data);
        System.out.println("[" + address.getHostAddress() + ":" + port + "] "
                + ((Packet01Disconnect) packet).getUsername() + " has left the world...");
        game.level.removePlayerMP(((Packet01Disconnect) packet).getUsername());
        break;
    case MOVE:
        packet = new Packet02Move(data);
        handleMove((Packet02Move) packet);
    }
}

public void sendData(byte[] data) {
    //if (!game.isApplet) {
        DatagramPacket packet = new DatagramPacket(data, data.length, ipAddress, 3333);
        try {
            socket.send(packet);
        } catch (IOException e) {
            e.printStackTrace();
        }
   //}
}

private void handleLogin(Packet00Login packet, InetAddress address, int port) {
    System.out.println("[" + address.getHostAddress() + ":" + port + "] " + packet.getUsername()
            + " has joined the game...");
    PlayerMP player = new PlayerMP(game.level, packet.getX(), packet.getY(), packet.getUsername(), address, port);
    game.level.addEntity(player);
}

private void handleMove(Packet02Move packet) {
    this.game.level.movePlayer(packet.getUsername(), packet.getX(), packet.getY(), packet.getNumSteps(),
            packet.isMoving(), packet.getMovingDir());
}

}

GameServer.java
包fraccas.java2dgame.net；
公共类GameServer扩展线程{
专用DatagramSocket套接字；
私人游戏；
private List connectedPlayers=new ArrayList（）；
公共游戏服务器（游戏）{
这个游戏=游戏；
试一试{
this.socket=新的DatagramSocket（3333）；
}捕获（SocketException e）{
e、 printStackTrace（）；
}
}
公开募捐{
while（true）{
字节[]数据=新字节[1024]；
DatagramPacket数据包=新的DatagramPacket（数据，数据.长度）；
试一试{
套接字接收（数据包）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
this.parsePacket（packet.getData（），packet.getAddress（），packet.getPort（））；
}
}
专用无效数据包（字节[]数据，InetAddress地址，int端口）{
字符串消息=新字符串（数据）.trim（）；
PacketTypes类型=Packet.lookupPacket（message.substring（0,2））；
数据包=空；
开关（类型）{
违约：
案例无效：
打破
案例登录：
数据包=新数据包00登录（数据）；
System.out.println（“[”+地址.getHostAddress（）+”：“+端口+”）
+（（Packet00Login）packet.getUsername（）+“已连接…”）；
PlayerMP player=新的PlayerMP（game.level，100100，（（Packet00Login）数据包）.getUsername（），地址，端口）；
这个.addConnection（player，（Packet00Login）包）；
打破
外壳断开：
数据包=新数据包01断开连接（数据）；
System.out.println（“[”+地址.getHostAddress（）+”：“+端口+”）
+（（Packet01Disconnect）packet.getUsername（）+“已离开…”）；
此.removeConnection（（Packet01Disconnect）数据包）；
打破
案件动议：
数据包=新数据包02移动（数据）；
此.handleMove（（（Packet02Move）packet））；
}
}
public void addConnection（PlayerMP播放器，packet00登录包）{
布尔值alreadyConnected=false；
对于（PlayerMP:this.connectedPlayers）{
if（player.getUsername（）.equalsIgnoreCase（p.getUsername（）））{
if（p.ipAddress==null）{
p、 ipAddress=player.ipAddress；
}
如果（p.port==-1）{
p、 port=player.port；
}
alreadyConnected=true；
}否则{
//中继到当前连接的播放机，以确认有新的播放机
//玩家
sendData（packet.getData（），p.ipAddress，p.port）；
//中继到当前连接的播放机的新播放机
//存在
//packet=newpacket00login（p.getUsername（），p.x，p.y）；
Packet00Login packetNew=新的Packet00Login（p.getUsername（），p.x，p.y）；
sendData（packetNew.getData（），player.ipAddress，player.port）；
}
}
如果（！已连接）{
this.connectedPlayers.add（player）；
}
}
public void removeConnection（packet01断开数据包）{
this.connectedPlayers.remove（getPlayerMPIndex（packet.getUsername（））；
packet.writeData（本）；
}
public PlayerMP getPlayerMP（字符串用户名）{
for（PlayerMP播放器：这个.连接的播放器）{
if（player.getUsername（）.equals（username））{
返回球员；
}
}
返回null；
}
public int getPlayerMPIndex（字符串用户名）{
int指数=0；
for（PlayerMP播放器：这个.连接的播放器）{
if（player.getUsername（）.equals（username））{
打破
}
索引++；
}
收益指数；
}
public void sendData（字节[]数据，InetAddress ipAddress，int端口）{
//如果（！game.isApplet）{
DatagramPacket数据包=新的DatagramPacket（数据、数据.length、IP地址、端口）；
试一试{
这个.socket.send（包）；
}捕获（IOE异常）{
e、 printStackTrace（）；
}
//}
}
public void向所有客户端发送数据（字节[]数据）{
for（PlayerMP:connectedPlayers）{
sendData（数据，p.ipAddress，p.port）；
}
}
私有无效句柄移动（Packet02Move packet）{
if（getPlayerMP（packet.getUsername（））！=null）{
GameServer.java

package fraccas.java2dgame.net;


public class GameServer extends Thread {

private DatagramSocket socket;
private Game game;
private List<PlayerMP> connectedPlayers = new ArrayList<PlayerMP>();

public GameServer(Game game) {
    this.game = game;
    try {
        this.socket = new DatagramSocket(3333);
    } catch (SocketException e) {
        e.printStackTrace();
    }
}

public void run() {
    while (true) {
        byte[] data = new byte[1024];
        DatagramPacket packet = new DatagramPacket(data, data.length);
        try {
            socket.receive(packet);
        } catch (IOException e) {
            e.printStackTrace();
        }
        this.parsePacket(packet.getData(), packet.getAddress(), packet.getPort());
    }
}

private void parsePacket(byte[] data, InetAddress address, int port) {
    String message = new String(data).trim();
    PacketTypes type = Packet.lookupPacket(message.substring(0, 2));
    Packet packet = null;
    switch (type) {
    default:
    case INVALID:
        break;
    case LOGIN:
        packet = new Packet00Login(data);
        System.out.println("[" + address.getHostAddress() + ":" + port + "] "
                + ((Packet00Login) packet).getUsername() + " has connected...");
        PlayerMP player = new PlayerMP(game.level, 100, 100, ((Packet00Login) packet).getUsername(), address, port);
        this.addConnection(player, (Packet00Login) packet);
        break;
    case DISCONNECT:
        packet = new Packet01Disconnect(data);
        System.out.println("[" + address.getHostAddress() + ":" + port + "] "
                + ((Packet01Disconnect) packet).getUsername() + " has left...");
        this.removeConnection((Packet01Disconnect) packet);
        break;
    case MOVE:
        packet = new Packet02Move(data);
        this.handleMove(((Packet02Move) packet));
    }
}

public void addConnection(PlayerMP player, Packet00Login packet) {
    boolean alreadyConnected = false;
    for (PlayerMP p : this.connectedPlayers) {
        if (player.getUsername().equalsIgnoreCase(p.getUsername())) {
            if (p.ipAddress == null) {
                p.ipAddress = player.ipAddress;
            }
            if (p.port == -1) {
                p.port = player.port;
            }
            alreadyConnected = true;
        } else {
            // relay to the current connected player that there is a new
            // player
            sendData(packet.getData(), p.ipAddress, p.port);

            // relay to the new player that the currently connect player
            // exists
            //packet = new Packet00Login(p.getUsername(), p.x, p.y);
            Packet00Login packetNew = new Packet00Login(p.getUsername(), p.x, p.y);
            sendData(packetNew.getData(), player.ipAddress, player.port);
        }
    }
    if (!alreadyConnected) {
        this.connectedPlayers.add(player);
    }
}

public void removeConnection(Packet01Disconnect packet) {
    this.connectedPlayers.remove(getPlayerMPIndex(packet.getUsername()));
    packet.writeData(this);
}

public PlayerMP getPlayerMP(String username) {
    for (PlayerMP player : this.connectedPlayers) {
        if (player.getUsername().equals(username)) {
            return player;
        }
    }
    return null;
}

public int getPlayerMPIndex(String username) {
    int index = 0;
    for (PlayerMP player : this.connectedPlayers) {
        if (player.getUsername().equals(username)) {
            break;
        }
        index++;
    }
    return index;
}

public void sendData(byte[] data, InetAddress ipAddress, int port) {
    //if (!game.isApplet) {

        DatagramPacket packet = new DatagramPacket(data, data.length, ipAddress, port);
        try {
            this.socket.send(packet);
        } catch (IOException e) {
            e.printStackTrace();
        }
    //}
}

public void sendDataToAllClients(byte[] data) {
    for (PlayerMP p : connectedPlayers) {
        sendData(data, p.ipAddress, p.port);
    }
}

private void handleMove(Packet02Move packet) {
    if (getPlayerMP(packet.getUsername()) != null) {
        int index = getPlayerMPIndex(packet.getUsername());
        PlayerMP player = this.connectedPlayers.get(index);
        player.x = packet.getX();
        player.y = packet.getY();
        player.setMoving(packet.isMoving());
        player.setMovingDir(packet.getMovingDir());
        player.setNumSteps(packet.getNumSteps());
        packet.writeData(this);
    }
}