Java Serveur - Plusieurs ports?

Je suis sur le point de programmer un serveur mais je me demande si ce que j'ai à l'esprit est possible. Mon programme va être la sortie de plusieurs clients sur plusieurs ports - chaque port peut être accédé par plusieurs clients.

Normalement, je voudrais utiliser une tige filetée serveur socket, mais dans ce cas j'ai besoin de ce travail pour plusieurs ports. L'utilisation que j'ai en tête est dans une vague pseudo-code ci-dessous:

Démarrer le serveur
Écouter les connexions entrantes sur les ports de plusieurs
Identifier le port connecté à
- Si le port 1, démarrer un thread à l'écoute du client et de la sortie type de message x
- Si le port 2, démarrer un thread à l'écoute du client et de la sortie type de message y

J'espère que c'est un peu logique, et vous pouvez voir ce que je suis en train de faire. Il suffit de mettre: écouter une sélection de ports, de créer une tige de connexion de socket basé sur quel port est connecté.

Est-ce faisable à tous, ou vais-je finir le multi-threading raccord fileté g serveurs?

Edit: Changé le libellé afin de mieux tenir compte de la question.

Je sais que vous avez déjà choisi votre réponse, mais s'il vous plaît prendre un coup d'oeil à ma réponse et peut-être à reconsidérer.

OriginalL'auteur Myn | 2011-02-22

15

Je ne pense pas que c'est possible pour une seule instance de ServerSocket pour écouter plusieurs ports. Vous pouvez bien sûr avoir plusieurs ServerSockets. Cependant, comme vous le savez déjà, ServerSocket.accept blocs.

Ce que vous pouvez utiliser à la place est un ServerSocketChannel. Ils sont utilisés d'une manière similaire, mais ne bloquent pas.

Si il n'existe pas de connexions en attente lorsque ServerSocketChannel.accept est appelé alors elle retourne null.

Vous pouvez utiliser avec un Selector qui prend un ensemble de voies et de blocs jusqu'à ce que l'un au moins a une connexion en attente.

Je ne me souviens pas des détails sur la façon de les utiliser, mais cette semble être un décent exemple de code.

edit: Voici mon propre exemple (pseudo-ish)
```
Selector selector = Selector.open();

int[] ports = {4000,4001,6000};

for (int port : ports) {
   ServerSocketChannel server = ServerSocketChannel.open();
   server.configureBlocking(false);

   server.socket().bind(new InetSocketAddress(port));
//we are only interested when accept evens occur on this socket
   server.register(selector, SelectionKey.OP_ACCEPT); 
}

while (selector.isOpen()) {
   selector.select();
   Set readyKeys = selector.selectedKeys();
   Iterator iterator = readyKeys.iterator();
   while (iterator.hasNext()) {
      SelectionKey key = (SelectionKey) iterator.next();
      if (key.isAcceptable()) {
         SocketChannel client = server.accept();
         Socket socket = client.socket();
//create new thread to deal with connection (closing both socket and client when done)
      }
   }
}

//tidy up selector and channels
```
+1 C'est la meilleure réponse. J'étais sur le point d'écrire cela.
Intéressant.. Comme vous le dites, il bloque, ce qui est la raison principale que j'allais multi-thread filetée serveurs. Donnez-moi quelques minutes pour regarder cette...
Hm, certainement pas ce que j'avais à l'esprit; je visais pour être en mesure d'écouter un ensemble de ports (pas impérativement avec "ServerSocket"), mais cela semble comme une étape dans la bonne direction. Merci à tous, si je pouvais donner plus d'une meilleure réponse que je voudrais, en particulier pour Vance Maverick, mais je vous remercie de Dunes.
Pas sûr de ce que votre problème est. Vais écrire mon propre pseudo exemple, voir si cela efface les choses.
Je crois que je vois...si ma compréhension est correcte, le programme va commencer l'écoute d'un port, mais de continuer à courir à travers le programme, à l'écoute sur tous les ports spécifiés. Lorsqu'une connexion est détectée sur l'un de ces ports, le thread est créé pour gérer. C'est qu'une hypothèse juste? Merci encore Dunes.

OriginalL'auteur Dunes
8

Bonjour, alors laissez-moi obtenir ce droit. Ce que vous voulez faire est de créer un serveur, que vous pouvez écouter sur plusieurs ports et lorsque vous obtenez une nouvelle connexion, vous voulez être en mesure de dire qui port de connexion utilisé, est-ce correct? Eh bien, si c'est le cas, vous pouvez le faire très facilement avec l'utilisation de la java.nio paquet.

Nous allons utiliser un Sélecteur pour la préparation de la sélection et un ServerSocketChannel à écouter pour la réception des raccordements.

D'abord, nous devons déclarer notre Selector.
```
Selector selector = Selector.open();
```
Maintenant permet de créer une liste de ports à écouter et commencer à écouter.
```
int ports[] = new int[] { 1234, 4321 };

//loop through each port in our list and bind it to a ServerSocketChannel
for (int port : ports) {
    ServerSocketChannel serverChannel = ServerSocketChannel.open();
    serverChannel.configureBlocking(false);
    serverChannel.socket().bind(new InetSocketAddress(port));
    serverChannel.register(selector, SelectionKey.OP_ACCEPT);
}
```
Maintenant, pour la SelectionKey processus de traitement.
```
while (true) {
    selector.select();

    Iterator<SelectionKey> selectedKeys = selector.selectedKeys().iterator();
    while (selectedKeys.hasNext()) {
        SelectionKey selectedKey = selectedKeys.next();

        if (selectedKey.isAcceptable()) {
            SocketChannel socketChannel = ((ServerSocketChannel) selectedKey.channel()).accept();
            socketChannel.configureBlocking(false);
            switch (socketChannel.socket().getPort()) {
                case 1234:
                    //handle connection for the first port (1234)
                    break;
                case 4321:
                    //handle connection for the secon port (4321)
                    break;
            }
        } else if (selectedKey.isReadable()) {
            //yada yada yada
        }
    }
}
```
Peut-être une instruction switch n'est pas nécessaire pour une telle tâche simple, mais c'est pour la facilité de lecture et de compréhension.

Rappelez-vous, ce serveur est mis en place dans un non-bloquant asynchrone, de sorte que tous les appels d'e/S que vous effectuez ne va pas bloquer le thread courant. Donc NE PAS initier de nouvelles discussions dans la SelectionKey processus de traitement.

Aussi, je sais que ce n'est pas de répondre complètement à votre question (il pourrait, il pourrait ne pas) mais il sera en fait vous donner une compréhension sur la façon d'utiliser le java.nio package pour créer un non-bloquant asynchrone serveur, que vous pouvez écouter sur plusieurs ports.

Je suis en suivant ce code et d'obtenir un IllegalBlockingmodeException sur la ligne qui appelle la fonction registre sur le serverchannel.

OriginalL'auteur
1

Vous ne pouvez pas écouter tous ports, mais vous pouvez écouter un ensemble d'entre eux. Créer un ServerSocket ( http://download.oracle.com/javase/6/docs/api/java/net/ServerSocket.html#ServerSocket%28int%29 ) pour chaque port que vous souhaitez écouter et accepter les connexions sur chaque.

Ouais, c'est ce que je voulais dire par le multi-threading filetée serveurs - je pense que ce que j'ai sans doute voulu dire que je voulais un moyen plus efficace de l'écoute d'un ensemble de ports.

OriginalL'auteur Vance Maverick
0

Je ne pense pas que vous pouvez écouter à tous les ports, pas de. Qui serait très coûteux pour le système d'exploitation à mettre en œuvre, de sorte que c'est tout simplement pas la façon dont le port d'écoute d'œuvres.

Que si plusieurs demandes ont été simultanément à l'écoute de "tous" les ports, à la demande si le sous-système réseau de livrer les paquets entrants?

Mm c'est ce que je craignais...Et sans doute le moyen le plus efficace de l'écoute de quelques ports, disent si je savais que je n'aurais quelqu'un en reliant le port 4000, 4010, 4020, ou 4030, serait de multi-thread un raccord fileté g serveurs?
Multi-thread un raccord fileté g serveurs? Je ne le comprends pas.
"Multi-thread raccord fileté g de serveurs", qui devrait être, plutôt. Je veux dire, créer un raccord fileté g serveur écoute sur le port, par exemple, 4000, créer un raccord fileté g serveur écoute sur le port 4010, etc. et multi-thread ces d'avoir des serveurs qui exécutent simultanément.

OriginalL'auteur unwind
0

Cela devrait être possible avec NIO, cependant je ne vois pas une bonne raison pour éviter d'avoir un thread par l'auditeur, sauf si vous avez plus de 1K de port.

Avez-vous vraiment besoin de plusieurs ports d'écoute? Dans la plupart des cas, il devrait être possible pour un port soutenir toutes sortes de clients et le client dire le serveur (ou le serveur de déterminer quel type de connexion est nécessaire)

C'était mon sentiment, en distinguant les types de demande ne sont pas ce que les ports sont censés être utilisés pour. Demande chemins sont de la bonne façon. Quelle est la nature de la clientèle ici?
C'est principalement pour permettre des fonctionnalités supplémentaires à être construit à la suite. E. g. si un message du type z a été introduit pour le port 3000, elle n'aurait pas besoin de quelqu'un pour aller jouer avec le code serveur. Mes plans sont d'avoir un fichier de config où le serveur va lire quels types de message de sortie pour les ports. Quant à savoir si il nécessite la présence de plusieurs ports d'écoute, dans ce cas, il y a une exigence particulière, pour elle, un ingénieur senior.
Il semble que vous voulez avoir codé en dur d'abonnement à des groupes de messages par port. Ceci est habituellement fait avec la version d'un protocole ou d'un protocole de type envoyé par le client. (Mais j'ai un exemple de cela, avec deux ports sur mon serveur pour que je puisse voir les données avec un simple telnet sur le port, donc je ne suis pas contre)
Est-il possible d'exécuter plusieurs SocketChannel sur un seul port je.e même SocketAddress?
Un SocketChannel a deux IP:port de combinaisons, un à chaque à chaque. Ce doit être unique pour chaque connexion. Pour une IP:port vous pouvez vous connecter plusieurs fois à partir de IP différente:les ports.

OriginalL'auteur Peter Lawrey

Vous devez vous connecter pour publier un commentaire.