聊天应用程序使用套接字无法通过Internet在Java中工作

我目前正在开发通过Internet工作的聊天应用程序。目前我的应用程序在局域网上正常工作但不能在Internet上工作。我也使用了端口转发。我已经在调制解调器中设置并将端口转发到私有IP地址但仍然是没有工作。我收到了找不到服务器的错误。请告诉我我要做的事情告诉我，我是否在调制解调器中完成了正确的设置？

I am currently developing chat application working over Internet.currently my application working fine over LAN but not working over Internet.I have also used port forwarding.I have done setting in modem and forward the port to private IP address but still it's not working.I got the error that "server isn't found".Please suggest me what I have to do and tell,Am I done the correct setting in modem or not??

下面是我的服务器代码......

Below is my server code...

Server.java

import java.util.*;
import java.net.*;
import java.io.*;

class Server implements ChatConstants
{
  private static Vector list;
  private ServerSocket ssocket ;
  private Service service;
  private static Socket socket;
  private boolean done=false;
  private static Hashtable userTable = new Hashtable();
  private static Hashtable _userList = new Hashtable();
  private static Hashtable _conflist = new Hashtable();


public Server() throws UnknownHostException
{
    System.out.println("Initializing...");
    list=new Vector(BACKLOG);
    try {
        ssocket= new ServerSocket(SERVER_PORT,BACKLOG);
    }
    catch(Exception e) {
                    e.printStackTrace();
                    System.out.println("Inside constructor"+e);
    }
    start();
}



public void start() throws UnknownHostException
{

    byte[] data;
    int header;
    Socket _socket = null;
    String hostname = null;
    System.out.println("Server successfully started at "
            +InetAddress.getLocalHost().toString()
            +" port "+SERVER_PORT);

     while(!done) {
                try 
                   {
                   _socket=ssocket.accept();

                    if(_socket != null) {
                     synchronized(list) {
                     list.addElement(_socket);
                }

                DataInputStream dis=new DataInputStream(_socket.getInputStream());
                data = new byte[MAX_MESSAGE_SIZE];
                dis.read(data);
                Message message = ((Message)ChatUtils.bytesToObject(data));
                System.out.println("Joined client "
                            +message._username+" at "+message._host+"...");
                synchronized(userTable) {
                    userTable.put(message._username,_socket);
                }
                addUser(message);
                sendUserList(message);
                writeToClients(message);
                service = new Service(_socket,hostname,message._user);
            }
        }

        catch(Exception e) {
            e.printStackTrace();
            System.out.println("Thread exception"+e);
            try {
                _socket.close();
            }
            catch(Exception ex) {
                ex.printStackTrace();
                System.out.println("ERROR CLOSING SOCKET");
            }
        }
    }//END WHILE
}


private void addUser(Message message)
{
    synchronized(_userList) {
        _userList.put(message._user.toString(),message._user);
    }
}

public static void updateUser(User user)
{
    User myuser;
    synchronized(_userList) {
        _userList.put(user.toString(),user);
    }
}

public static synchronized void writeToClients(Message message)
{
    byte[] data;
    DataOutputStream dos;
        for(int count=0;count<list.size();count++) {
        try {
             dos=new 
                     DataOutputStream(((Socket)list.elementAt(count)).getOutputStream());
            data=ChatUtils.objectToBytes(message);
            dos.write(data,0,data.length);
        }
        catch(Exception e) {
            e.printStackTrace();
            System.out.println("Output exception");
        }
    }//END FOR
}

public static void writeToClient(Message message)
{
    Socket socket;
    byte[] data;
    DataOutputStream dos;
    synchronized(userTable) {
        try {
            socket = (Socket)userTable.get(message._destination);
            dos=new DataOutputStream(socket.getOutputStream());
            data=ChatUtils.objectToBytes(message);
            dos.write(data,0,data.length);
        }
        catch(Exception e) {
            e.printStackTrace();
            System.out.println("SEND EXCEPTION"+e);
        }
    }
}


public static void sendConferenceListToClient(Message message)
{
    Socket socket;
    byte[] data;
    DataOutputStream dos;
    synchronized(userTable) {
        try {
            Message mymessage= new Message(CONFERENCE_LIST);
            Vector vector = (Vector)
                _conflist.get(message._destination);

            mymessage._username = message._username;
            mymessage._destination = message._destination;
            mymessage.userlist = vector;

            socket = (Socket)userTable.get(message._username);

            if(socket!=null) {
                dos=new DataOutputStream(socket.getOutputStream());
                data=ChatUtils.objectToBytes(mymessage);
                dos.write(data,0,data.length);
            }
        }
        catch(Exception e) {
            e.printStackTrace();
            System.out.println("CONFERENCE LIST EXCEPTION"+e);
        }
    }
}


public static void writeToPublicChat(Message message)
{
    Socket socket;
    byte[] data;
    DataOutputStream dos;
    synchronized(_conflist) {
        try {
            Vector svector = (Vector)_conflist.get(message._destination);
            for(int cnt=0;cnt<svector.size();cnt++) {
                synchronized(userTable) {
                    try {
                        socket = (Socket)userTable.get((svector.get(cnt).toString()));
                        if(socket!=null) {
                            dos=new DataOutputStream(socket.getOutputStream());
                            data=ChatUtils.objectToBytes(message);
                            dos.write(data,0,data.length);
                        }
                    }
                    catch(Exception e) {
                        e.printStackTrace();
                        System.out.println("PUBLIC CHAT EXCEPTION"+e);
                    }
                }
            }
        } catch(Exception e){
            e.printStackTrace();
            System.out.println("PUBLIC EXCEPTION"+e);
        }
    }
}


public static void inviteToPublicChat(Vector svector,Message message)
{
    Socket socket;
    byte[] data;
    DataOutputStream dos;
    synchronized(_conflist) {
        for(int cnt=0;cnt<svector.size();cnt++) {
            synchronized(userTable) {
                try {
                    socket = (Socket)userTable.get((svector.get(cnt).toString()));
                    if(socket != null) {
                        dos=new DataOutputStream(socket.getOutputStream());
                        data=ChatUtils.objectToBytes(message);
                        dos.write(data,0,data.length);
                    }
                }
                catch(Exception e) {
                    e.printStackTrace();
                    System.out.println("PUBLIC INVITE EXCEPTION"+e);
                }
            }
        }
    }
}

private void sendUserList(Message message)
{
    int header=0;
    String destination;

    header=message._header;
    destination = message._destination;

    message._header = USERS_LIST;
    message._destination = message._username;

    message.userlist = new Vector(_userList.values());
    writeToClient(message);

    //Restore the headers
    message._destination = destination;
    message._header = header;

}

public static synchronized void removeUser(User user)
{
    try {
        Socket socket = (Socket)userTable.get(user.toString());
        list.removeElement(socket);
        _userList.remove(user.toString());
        userTable.remove(user.toString());
    }
    catch(Exception e) {
        e.printStackTrace();
        System.out.println("ERROR REMOVING SOCKET "+e);
    }
}


public static synchronized void processClientMessage(Message message)
{
    switch(message._header) {

        case CHANGE_STATUS:
            updateUser(message._user);
            writeToClients(message);
            break;

        case CLIENT_LOGOUT:
            removeUser(message._user);
            writeToClients(message);
            break;

        case CONFERENCE_CREATE:
            Vector myvector = new Vector();
            myvector.add(message._username);
            _conflist.put(message._user.toString(),myvector);
        case CONFERENCE_INVITE:
            inviteToPublicChat(message.userlist,message);
        break;

        case CONFERENCE_JOIN:
            Vector vector=null;
            vector = (Vector)
                _conflist.get(message._destination.toString());
            vector.add(message._username);
            _conflist.put(message._destination.toString(),vector);
            writeToPublicChat(message);
        break;

        case CONFERENCE_DENY:
            //_conflist.remove(message._user.toString(),message.userlist);
            writeToPublicChat(message);
        break;

        case CONFERENCE_LEAVE:
            Vector vectors =(Vector)
                _conflist.get(message._destination.toString());
            for(int count=0;count<vectors.size();count++) {
                if(message._username.equals((vectors.elementAt(count).toString())))
                    vectors.remove(count);
            }
            if(vectors.size() != 0)
                _conflist.put(message._user.toString(),vectors);
            else//IF THERE ARE NO MORE USERS
                _conflist.remove(message._user.toString());//DONE CONFERENCE
            writeToPublicChat(message);
        break;

        case PUBLIC_CHAT:
            writeToPublicChat(message);
        break;

        case CONFERENCE_LIST:
            sendConferenceListToClient(message);
        break;

        default:
            writeToClient(message);
    }
}


public static void main(String args[]) throws Exception
{
    Server chatserver=new Server();
}
  }


 //
 // Service: Service class for each clients connected to server.
 //


  class Service implements Runnable, ChatConstants
  {
private DataInputStream dis;
private Socket socket;
private boolean done=false;
private Thread thread;
private String hostname;
private User user;

public Service(Socket _socket,String _hostname,User user)
{
    try {
        this.socket = _socket;
        this.hostname=_hostname;
        this.user = user;
        dis=new DataInputStream(socket.getInputStream());
        thread=new Thread(this,"SERVICE");
        thread.start();
    }
    catch(Exception e){
        e.printStackTrace();
        System.out.println("service constructor"+e);
    }
}

public void run()
{
    byte[] data;
    while(!done)
    {
        try {
            data = new byte[MAX_MESSAGE_SIZE];
            dis.read(data);
            Message message = ((Message)ChatUtils.bytesToObject(data));
            Server.processClientMessage(message);
        }
        catch(Exception e) {
            e.printStackTrace();
            done = true;
            Server.removeUser(user);
            Message message = new Message(CLIENT_LOGOUT);
            user.isOnline = OFFLINE;
            message._user = user;
            Server.writeToClients(message);
            try {
                socket.close();
            } catch(Exception se) {
                se.printStackTrace();
                System.out.println("ERROR CLOSING SOCKET "+se);
            }
            //System.out.println("SERVICE THREAD EXCEPTION"+e);
        }
    }//END WHILE
}
  }

提前致谢。