Introduction à Java RMI (avec exemples)

Java RMI fait référence à l'invocation de méthode à distance. Il s'agit d'un mécanisme qui permet à un objet d'une machine virtuelle Java d'appeler des méthodes sur un objet d'une autre machine virtuelle Java. Tout objet pouvant être appelé avec cette méthode doit implémenter l'interface distante. (Recommandé : Tutoriel vidéo Java)

Java RMI n'est pas une nouvelle technologie (elle était disponible à l'ère de Java 1.1), mais c'est une technologie sous-jacente très importante.

Les célèbres EJB sont tous construits sur rmi. Il existe également des composants d'appel à distance open source, et leur technologie sous-jacente est également rmi.

À l'ère de la promotion vigoureuse des services Web et de la SOA, chaque application devrait-elle être implémentée à l'aide de composants de services Web maladroits ? Après des tests comparatifs, RMI est le plus simple. Dans certaines petites applications, il est le plus approprié.

Ce qui suit utilise un exemple simple pour illustrer les principes et les applications de RMI. L'exemple suivant est un simple HelloWorld, mais il couvre les applications de base et les modèles de développement de RMI.

/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2008-8-7 21:50:02
* 定义一个远程接口，必须继承Remote接口，其中需要远程调用的方法必须抛出RemoteException异常
*/
public interface IHello extends Remote {

    /**
     * 简单的返回“Hello World！"字样
     * @return 返回“Hello World！"字样
     * @throws java.rmi.RemoteException
     */
    public String helloWorld() throws RemoteException;

    /**
     * 一个简单的业务方法，根据传入的人名返回相应的问候语
     * @param someBodyName  人名
     * @return 返回相应的问候语
     * @throws java.rmi.RemoteException
     */
    public String sayHelloToSomeBody(String someBodyName) throws RemoteException;
}

/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2008-8-7 21:56:47
* 远程的接口的实现
*/
public class HelloImpl extends UnicastRemoteObject implements IHello {
    /**
     * 因为UnicastRemoteObject的构造方法抛出了RemoteException异常，因此这里默认的构造方法必须写，必须声明抛出RemoteException异常
     *
     * @throws RemoteException
     */
    public HelloImpl() throws RemoteException {
    }

    /**
     * 简单的返回“Hello World！"字样
     *
     * @return 返回“Hello World！"字样
     * @throws java.rmi.RemoteException
     */
    public String helloWorld() throws RemoteException {
        return "Hello World!";
    }

    /**
     * 一个简单的业务方法，根据传入的人名返回相应的问候语
     *
     * @param someBodyName 人名
     * @return 返回相应的问候语
     * @throws java.rmi.RemoteException
     */
    public String sayHelloToSomeBody(String someBodyName) throws RemoteException {
        return "你好，" + someBodyName + "!";
    }
}

/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2008-8-7 22:03:35
* 创建RMI注册表，启动RMI服务，并将远程对象注册到RMI注册表中。
*/
public class HelloServer {
    public static void main(String args[]) {

        try {
            //创建一个远程对象
            IHello rhello = new HelloImpl();
            //本地主机上的远程对象注册表Registry的实例，并指定端口为8888，这一步必不可少（Java默认端口是1099），必不可缺的一步，缺少注册表创建，则无法绑定对象到远程注册表上
            LocateRegistry.createRegistry(8888);

            //把远程对象注册到RMI注册服务器上，并命名为RHello
            //绑定的URL标准格式为：rmi://host:port/name(其中协议名可以省略，下面两种写法都是正确的）
            Naming.bind("rmi://localhost:8888/RHello",rhello);
//            Naming.bind("//localhost:8888/RHello",rhello);

            System.out.println(">>>>>INFO:远程IHello对象绑定成功！");
        } catch (RemoteException e) {
            System.out.println("创建远程对象发生异常！");
            e.printStackTrace();
        } catch (AlreadyBoundException e) {
            System.out.println("发生重复绑定对象异常！");
            e.printStackTrace();
        } catch (MalformedURLException e) {
            System.out.println("发生URL畸形异常！");
            e.printStackTrace();
        }
    }
}

/**
* Created by IntelliJ IDEA.
* User: leizhimin
* Date: 2008-8-7 22:21:07
* 客户端测试，在客户端调用远程对象上的远程方法，并返回结果。
*/
public class HelloClient {
    public static void main(String args[]){
        try {
            //在RMI服务注册表中查找名称为RHello的对象，并调用其上的方法
            IHello rhello =(IHello) Naming.lookup("rmi://localhost:8888/RHello");
            System.out.println(rhello.helloWorld());
            System.out.println(rhello.sayHelloToSomeBody("熔岩"));
        } catch (NotBoundException e) {
            e.printStackTrace();
        } catch (MalformedURLException e) {
            e.printStackTrace();
        } catch (RemoteException e) {
            e.printStackTrace();  
        }
    }
}

Exécutez le programme serveur RMI :

Exécutez le programme client RMI :

Résumé :

D'après le processus ci-dessus, RMI dépend beaucoup de l'adresse IP et du port du serveur. Cependant, nous ne savons pas quelle sera l'adresse IP et le port du futur serveur pendant le développement, mais le programme client en dépend. sur cette IP et ce port.

C'est aussi une des limites du RMI. Il existe deux manières de résoudre ce problème : l'une consiste à le résoudre via DNS et l'autre consiste à exposer l'adresse IP en dehors du code du programme via l'encapsulation.

La deuxième limitation de RMI est que RMI est un appel à distance en langage Java. Le langage de programmation aux deux extrémités doit être implémenté en Java. Pour la communication entre différents langages, vous pouvez envisager d'utiliser un service Web ou une requête d'objet commun. Agence (CORBA) à réaliser.

Pour plus de connaissances sur Java, veuillez faire attention à la colonne Tutoriel de base Java.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!