Comment puis-je m'assurer que le RMI utilise uniquement un ensemble de ports?

Vous pouvez le faire avec un RMI Prise en Usine.

La prise des usines de créer des sockets RMI pour utiliser à la fois du client et du serveur donc si vous écrivez votre propre, vous avez le plein contrôle sur les ports utilisés. Le client usines sont créées sur le serveur, Sérialisé puis envoyé au client qui est assez propre.

Voici un guide au Soleil vous dire comment le faire.

OriginalL'auteur Dave Webb

Résumé de la longue réponse ci-dessous: pour résoudre le problème que j'avais (restriction de serveur et de rappel des ports à chaque extrémité du RMI de connexion), j'avais besoin de créer deux paires de client et de serveur de socket usines.

Réponds plus s'ensuit:

Notre solution pour le rappel problème avait essentiellement trois parties. La première a été l'objet d'habillage qui avait besoin de la possibilité de spécifier qu'il était utilisé par un client pour le serveur de connexion et être utilisé pour un serveur de client de rappel. À l'aide d'une extension de UnicastRemoteObject nous a donné la possibilité de spécifier le client et le serveur de socket usines que nous voulions utiliser. Cependant, le meilleur endroit pour verrouiller la prise des usines est dans le constructeur de l'objet distant.

public class RemoteObjectWrapped extends UnicastRemoteObject {
//....
private RemoteObjectWrapped(final boolean callback) throws RemoteException {
  super((callback ? RemoteConnectionParameters.getCallbackPort() : RemoteConnectionParameters.getServerSidePort()),
        (callback ? CALLBACK_CLIENT_SOCKET_FACTORY : CLIENT_SOCKET_FACTORY),
        (callback ? CALLBACK_SERVER_SOCKET_FACTORY : SERVER_SOCKET_FACTORY));
}
//....
}

Donc, le premier argument spécifie la partie sur laquelle l'objet est attend demandes, alors que les deuxième et troisième spécifier la prise des usines qui sera utilisée à chaque extrémité de la connexion de la conduite de cet objet distant.

Depuis que nous avons voulu limiter les ports utilisé par la connexion, nous avons besoin d'étendre le RMI prise d'usines et de verrouiller les ports. Voici quelques croquis de notre serveur et client usines:

public class SpecifiedServerSocketFactory implements RMIServerSocketFactory {
/** Always use this port when specified. */
private int serverPort;
/**
 * @param ignoredPort This port is ignored.  
 * @return a {@link ServerSocket} if we managed to create one on the correct port.
 * @throws java.io.IOException
 */
@Override
public ServerSocket createServerSocket(final int ignoredPort) throws IOException {
    try {
        final ServerSocket serverSocket = new ServerSocket(this.serverPort);
        return serverSocket;
    } catch (IOException ioe) {
        throw new IOException("Failed to open server socket on port " + serverPort, ioe);
    }
}
//....
}

Noter que le serveur de socket usine ci-dessus garantit que seul le port que vous avez spécifié précédemment ne sera jamais utilisé par cette usine. Le socket client en usine doit être couplé avec la prise appropriée de l'usine (ou vous ne serez jamais à se connecter).

public class SpecifiedClientSocketFactory implements RMIClientSocketFactory, Serializable {
/** Serialization hint */
public static final long serialVersionUID = 1L;
/** This is the remote port to which we will always connect. */
private int remotePort;
/** Storing the host just for reference. */
private String remoteHost = "HOST NOT YET SET";
//....
/**
 * @param host The host to which we are trying to connect
 * @param ignoredPort This port is ignored.  
 * @return A new Socket if we managed to create one to the host.
 * @throws java.io.IOException
 */
@Override
public Socket createSocket(final String host, final int ignoredPort) throws IOException {
    try {
        final Socket socket = new Socket(host, remotePort);
        this.remoteHost = host;
        return socket;
    } catch (IOException ioe) {
        throw new IOException("Failed to open a socket back to host " + host + " on port " + remotePort, ioe);
    }
}
//....
}

Alors, la seule chose restant à la force de votre connexion bidirectionnelle pour rester sur le même ensemble de ports est une logique de reconnaître que vous êtes de retour d'appel pour le côté client. Dans cette situation, assurez-vous que votre méthode de fabrique de l'objet distant appelle la RemoteObjectWrapper constructeur jusqu'en haut avec le rappel paramètre est défini sur true.

OriginalL'auteur Bob Cross