spring整合RMI实现Java远程方法调用

最新推荐文章于 2018-12-17 15:54:01 发布
最新推荐文章于 2018-12-17 15:54:01 发布
阅读量450 收藏 1
点赞数
分类专栏： JAVA_learning
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/achiberx/article/details/78395845
版权

使用Spring对RMI的支持，可以非常容易地构建你的分布式应用。
在服务端，可以通过Spring的org.springframework.remoting.rmi.RmiServiceExporter可以暴露你的服务；
在客户端，通过org.springframework.remoting.rmi.RmiProxyFactoryBean可以使用服务端暴露的服务，非常方便。
这种C/S模型的访问方式，可以屏蔽掉RMI本身的复杂性，如服务端Skeleton和客户端Stub等的处理细节，这些对于服务开发和服务使用的人员来说，都是透明的，无需过度关注，而集中精力开发你的商业逻辑。
下面通过一个例子，说明如何通过Spring集成RMI。

1.服务端接口：

接口1

/**
 * server端接口 
 * @author wwh
 *
 */
public interface HelloRMIService {
    public int getAdd(int a, int b);
    public User getUser();
}

接口2

/**
 * Server端接口
 * @author wwh
 */
public interface ICalculateRMIService {
    public int mul(int a, int b);
    public int get();
    public void setAvalue(int avalue);
    public void setBvalue(int bvalue);
}

2.服务端接口实现：

实现接口1

public class HelloRMIServiceImpl implements HelloRMIService {
    @Override
    public int getAdd(int a, int b) {
        return a + b;
    }
    @Override
    public User getUser() {
        User user = new User();
        user.setAge(18);
        user.setEmail("achiberx@gmail.com");
        user.setName("xiaohuihui");
        return user;
    }
}

实现接口2

public class CalculateRMIServiceImpl implements ICalculateRMIService {

    private int avalue = 0, bvalue = 0;
    @Override
    public int mul(int a, int b) {
        return a * b;
    }
    public int get() {
        return avalue*bvalue;
    }
    public int getAvalue() {
        return avalue;
    }
    public void setAvalue(int avalue) {
        this.avalue = avalue;
    }
    public int getBvalue() {
        return bvalue;
    }
    public void setBvalue(int bvalue) {
        this.bvalue = bvalue;
    }
}

3.服务端配置文件 rmiServer.xml

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jee="http://www.springframework.org/schema/jee" 
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd   
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd   
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd   
       http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd   
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">

    <bean id="helloRMIServiceImpl" class="com.rmi.test.spring.HelloRMIServiceImpl"> </bean>
    <!-- 将一个类发布为一个RMI服务 -->
    <bean id="myRMIServer"  class="org.springframework.remoting.rmi.RmiServiceExporter">
     <!-- 服务名， 在client端serviceUrl中 -->
      <property name="serviceName" value="helloRMI"></property>
       <!-- 被暴露的服务类 -->
      <property name="service" ref="helloRMIServiceImpl"></property>
       <!-- 服务的接口, 在client端也有 -->
      <property name="serviceInterface" value="com.rmi.test.spring.HelloRMIService"></property>
       <!-- 服务的端口 -->
      <property name="registryPort" value="9999"></property>
    </bean>


    <bean id="calculateRMIServiceImpl" class="com.rmi.test.spring.CalculateRMIServiceImpl"> </bean>
     <!-- 将一个类发布为一个RMI服务 -->
    <bean id="ICalculateRMIService"  class="org.springframework.remoting.rmi.RmiServiceExporter">
       <!-- 被暴露的服务类 -->
      <property name="service" ref="calculateRMIServiceImpl"></property>
      <!-- 服务名， 在client端serviceUrl中 -->
      <property name="serviceName" value="calculate"></property>
      <!-- 服务的接口, 在client端也有 -->
      <property name="serviceInterface" value="com.rmi.test.spring.ICalculateRMIService"></property>
      <!-- 服务的端口 -->
      <property name="registryPort" value="9999"></property>
      <!-- 其他的属性自己查看  RmiServiceExporter类-->
    </bean>

</beans>

4.服务端发布服务：RMIServiceTest.java

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

/**
 * 服务端发布服务功能， 供远程调用
 * @author Administrator
 */
public class RMIServiceTest {
    public static void main(String[] args) {
        ApplicationContext applicationContext =  new ClassPathXmlApplicationContext("rmiServer.xml");
        ICalculateRMIService iCalculateRMIService = applicationContext.getBean("calculateRMIServiceImpl", ICalculateRMIService.class);
        iCalculateRMIService.setAvalue(4);
        iCalculateRMIService.setBvalue(5);
        System.out.println(iCalculateRMIService.get());
        System.out.println("server发布服务成功！");
    }
}

5.客户端接口：（和服务端一样）

接口1

/**
 * server端接口 
 * @author wwh
 *
 */
public interface HelloRMIService {
    public int getAdd(int a, int b);
    public User getUser();
}

接口2

/**
 * Server端接口
 * @author wwh
 */
public interface ICalculateRMIService {
    public int mul(int a, int b);
    public int get();
    public void setAvalue(int avalue);
    public void setBvalue(int bvalue);
}

6.客户端配置文件：rmiClient.xml

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:jee="http://www.springframework.org/schema/jee" 
       xmlns:tx="http://www.springframework.org/schema/tx"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.0.xsd   
       http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd   
       http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd   
       http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.0.xsd   
       http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd">

    <!-- 客户端 -->
    <bean id="myRMIClient"  class="org.springframework.remoting.rmi.RmiProxyFactoryBean">
          <property name="serviceInterface" value="com.rmi.test.spring.HelloRMIService"></property>
          <property name="serviceUrl" value="rmi://127.0.0.1:9999/helloRMI"></property>
    </bean>

      <bean id="calculate"  class="org.springframework.remoting.rmi.RmiProxyFactoryBean">
          <property name="serviceInterface" value="com.rmi.test.spring.ICalculateRMIService"></property>
          <property name="serviceUrl" value="rmi://127.0.0.1:9999/calculate"></property>
      </bean>
</beans>

7.客户端测试程序：RMIClient.java

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
/**
 * 远程client测试接口
 * @author wwh
 */
public class RMIClient {
    public static void main(String[] args) {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext("rmiClient.xml");
        HelloRMIService helloRMIService = applicationContext.getBean("myRMIClient", HelloRMIService.class);
        System.out.println("client:");
        System.out.println("加法接口:        " + helloRMIService.getAdd(3, 5));
        System.out.println("输出User接口:  " + helloRMIService.getUser());

        System.out.println("测试ICalculateRMIService接口:   ");
        ICalculateRMIService calculateRMIService = applicationContext.getBean("calculate", ICalculateRMIService.class);
        System.out.println("调用乘法接口：" + calculateRMIService.mul(5, 5));
        System.out.println("get接口：       " + calculateRMIService.get());
    }
}

RMI Without Spring

定义IHello 接口

import java.rmi.Remote;
import java.rmi.RemoteException;

public interface IHello extends Remote{
    public String sayHello(String name) throws RemoteException;
    public int sum(int a, int b) throws RemoteException;
}

实现IHello接口

import java.rmi.RemoteException;
import java.rmi.server.UnicastRemoteObject;

public class HelloImpl extends UnicastRemoteObject implements IHello{
    protected HelloImpl() throws RemoteException {
        super();
    }
    private static final long serialVersionUID = 1L;

    @Override
    public String sayHello(String name) {
        return "Hello, " + name;
    }
    @Override
    public int sum(int a, int b) {
        return a+b;
    }
}

服务端开启服务

import java.net.MalformedURLException;
import java.rmi.AlreadyBoundException;
import java.rmi.Naming;
import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;

public class HelloServer {
    public static void main(String[] args) {
        try {
            IHello rhello = new HelloImpl();
            LocateRegistry.createRegistry(8888);
            Naming.bind("rmi://127.0.0.1:8888/RHello", rhello);
            System.out.println(">>INFO:远程IHello对象绑定成功！");
        } catch (RemoteException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (MalformedURLException e) {
            System.out.println("发生URL异常");
            e.printStackTrace();
        } catch (AlreadyBoundException e) {
            System.out.println("发生重复绑定对象异常！");
            e.printStackTrace();
        }
    }
}

客户端远程访问

import java.net.MalformedURLException;
import java.rmi.Naming;
import java.rmi.NotBoundException;
import java.rmi.RemoteException;

public class HelloClient {
    public static void main(String[] args) {
        try {
            IHello rhello = (IHello) Naming.lookup("rmi://127.0.0.1:8888/RHello");
            System.out.println(rhello.sayHello("world"));
            System.out.println(rhello.sum(12, 120));
        } catch (MalformedURLException | RemoteException | NotBoundException e) {
            e.printStackTrace();
        }
    }
}

参考链接1
参考链接2

acceptedwwh
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java spring+rmi 的远程调用例子
10-31
一个基于Spring的rmi实现，测试成功，可以远程调用。
Java 远程调用 RMI 与Spring的整合实例
xwh9004的博客
08-06 3528
spring 与java rmi整合
Java RMI和Spring RMI的实现
ibigboy
12-17 2789
初学RMI时，在网上搜java RMI的使用方法，很容易就搜到了，也很简单，整个过程也就是以下几个步骤： Java RMI的简单实现案例 1、创建自定义服务接口并继承java.rmi.Remote接口 package cn.com.rimtest; import java.rmi.Remote; import java.rmi.RemoteException; public interfa...
spring rmi 改造
01-16
基于spring rmi的一些小改造，在原基础上加入了线程池控制线程数。
Spring RMI注意问题
ZERO
11-17 4042
转载自： http://yangwencan2002.iteye.com/blog/284249 RMI问题1： 用 ./shutdown.sh 关闭 rmi 服务器的 tomcat ，然后 ./startup.sh 启动，客户端连接总是会导致如下错误： org.springframework.remoting.RemoteLookupFailureException: Lookup o
Spring 实现远程访问详解——rmi
04-18
通过使用 RmiProxyFactoryBean 和 RmiServiceExporter，并且，Spring支持两个传统的RMI（使用 java.rmi.Remote接口和java.rmi.RemoteException）和通过RMI调用器实现的暴露远程调用（支持任何Java接口）。...
Spring-Reference_zh_CN（Spring中文参考手册）
06-06
12.2.4. 不使用回调的基于Spring的DAO实现 12.2.5. 基于Hibernate3的原生API实现DAO 12.2.6. 编程式的事务划分 12.2.7. 声明式的事务划分 12.2.8. 事务管理策略 12.2.9. 容器资源 vs 本地资源 12.2.10. 在应用服务器...
Spring攻略(第二版 中文高清版).part1
03-16
2.2　调用一个实例工厂方法创建Bean　58 2.2.1　问题　58 2.2.2　解决方案　59 2.2.3　工作原理　59 2.3　从静态字段中声明Bean　60 2.3.1　问题　60 2.3.2　解决方案　60 2.3.3　工作原理　61 2.4　从对象属性中...
搞定J2EE：STRUTS+SPRING+HIBERNATE整合详解与典型案例 (1)
09-04
1.4.8 RMI（远程方法调用） 1.4.9 JMS（Java消息服务） 1.4.10 JMX（Java分布式管理） 1.4.11 JACC（Java容器授权合同） 1.4.12 JCA（Java连接器体系） 1.5 小结 第二章 MVC模式介绍 2.1 MVC模式概述 2.1.1 MVC模式...
Spring攻略(第二版 中文高清版).part2
03-16
2.2　调用一个实例工厂方法创建Bean　58 2.2.1　问题　58 2.2.2　解决方案　59 2.2.3　工作原理　59 2.3　从静态字段中声明Bean　60 2.3.1　问题　60 2.3.2　解决方案　60 2.3.3　工作原理　61 2.4　从对象属性中...
java项目使用spring rmi所涉及到的包
12-07
java项目使用spring rmi所涉及到的包
Java RMI实现以及Spring封装RMI实现小结
零度的博客专栏
08-05 1万+
最近应用到了Java RMI技术，所以总结一下RMI的使用，另外EJB的实现也是以Java RMI为基础核心的。RMI远程方法调用，可以跨机器通过网络调用，不过Java RMI只支持两边都是Java程序，如果要实现完全两边异构，那么就要用到传说中的Web Service了。为了看好效果，都要建立两个或两个以上工程，当然，如果你有两个机器并通过局域网相连更好，如果能同有互联网的条件就更好了，以下是同
分布式(一)基于spring-rmi
Sunny_Zhang0110的博客
11-07 250
rpc--实现--》spring封装rmi（java） 1、spring的rmi封装 a）对应的库：spring context环境自带rmi封装 b）使用方式：不需要写java代码=只需要配置即可 2、spring=封装rpc--rmi服务端的配置： 把【对应的接口】【对应的实现类的对象】暴露为远程服务 配置：spring-rmi-server.xml &lt;!-- RMI服...
Spring实现RMI远程方法调用
U2的博客
09-10 389
RMI（Remote Method Invocation，远程方法调用）它是一种机制，能够让在某个 Java 虚拟机上的对象调用另一个 Java 虚拟机中的对象上的方法。JVM 可以位于相同或不同计算机上，在多个 JVM 中，一个 JVM 可以调用存储在其它 JVM 的对象的方法。 实现RMI有两种方式，即通过Java和Spring，相比使用Java实现RMI远程方法调用，使用 Spring实现...
spring_webservice_rmi配置示例
Java_lilin的专栏
10-07 682
服务器端：  Userinfo.java  package com.lilin.entity; import java.io.Serializable; public class Userinfo implements Serializable { private String name; public String getName() { r
Spring整合 RMI
热门推荐
arkblue的专栏
03-10 2万+
Spring整合RMI的原理客户端的核心是RmiProxyFactoryBean，包含serviceURL属性和serviceInterface属性。服务端暴露远程服务RmiServiceExporter把任何Spring管理的Bean输出成一个RMI服务。通过把Bean包装在一个适配器类中工作。适配器类被绑定到RMI注册表中，并且将请求代理给服务类。服务端程序：1 IHelloWorld.java POJO的接口public interface IHelloWorld { public String
spring rmi客户端原理-RmiProxyFactoryBean
ChinFeng的专栏
10-19 2974
spring中rmi客户端引入使用org.springframework.remoting.rmi.RmiProxyFactoryBean进行rmi代理 如 @Bean private RmiProxyFactoryBean login() { RmiProxyFactoryBean rmiProxyFactory = new RmiProxyFactoryBean(); rmiPro...
RMI简单实例与Spring集成RMI
undergrowth的专栏
05-03 4586
rmi远程方法调用，用于服务器端和kehuduan
spring zuul网关过滤和spring远程方法调用
最新发布
04-26
Spring远程方法调用可以通过RMI、Hessian、Burlap、HTTP等协议来实现，通过Spring框架提供的远程调用模块可以方便地实现远程方法调用。其中最常用的是HTTP协议调用RESTful API，实现微服务之间的相互调用。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值