Spring + Hessian 实现轻量级分布式远程调用【包含rmi方式重构】

最新推荐文章于 2022-04-03 15:18:16 发布
最新推荐文章于 2022-04-03 15:18:16 发布
阅读量1.2k 收藏
点赞数
分类专栏： JAVA 文章标签： java spring hessian rmi
最近一期的《programmer》里几乎从头至尾在讲关于“J2EE without EJB”的事情，可怜的ejb啊，居然被描述成了遗产系统的重要组成部分。。。

其实有上面的结论，无外乎现在java里面的新技术已经几乎能完全取代ejb的优点，而克服ejb的缺点，entity bean和有状态的session bean已经机乎被视为垃圾，hibernate和spring大行其到，看看最进n期《programmer》中篇幅的比重就知道了。本来我个人的感觉是hibernate取代了entity bean，spring取代了session bean，但是ejb的远程调用用hibernate和spring的架构还取代不了，可是在最近的一期《programmer》中我发现了Hessian！更爽的是，发现了spring原来可以和Hessian结合使用！看来真的可以say byebye to ejb了。

看到这么振奋人心的消息，怎么能不亲自试验一下呢，于是上http://www.caucho.com/以迅雷不及掩耳盗铃之势下载了Hessian的src jar和bin jar。create一个工程，把这些相关的jar统统扔进去，配置和coding就可以开始了。首先，开了如下几个包：



whao.test.hessian.server
放远程服务的接口

whao.test.hessian.server.impl
放远程服务的实现类

whao.test.hessian.client
放客户端应用



1． whao.test.hessian.server中写一个MyService接口：
Java代码 复制代码  收藏代码
  1. /*  
  2.  
  3.  * Created on 2005-7-25  
  4.  
  5.  *  
  6.  
  7.  */  
  8.   
  9. package whao.test.hessian.server;   
  10.   
  11.     
  12.   
  13. /**  
  14.  
  15.  * @author Hao Wei  
  16.  
  17.  *  
  18.  
  19.  */  
  20.   
  21. public interface MyService {   
  22.   
  23.     public String doSomething(String s);;   
  24.   
  25. }  
/*

 * Created on 2005-7-25

 *

 */

package whao.test.hessian.server;

 

/**

 * @author Hao Wei

 *

 */

public interface MyService {

    public String doSomething(String s);;

}



2． whao.test.hessian.server.impl中写一个实现类

Java代码 复制代码  收藏代码
  1. /*  
  2.  
  3.  * Created on 2005-7-25  
  4.  
  5.  *  
  6.  
  7.  */  
  8.   
  9. package whao.test.hessian.server.impl;   
  10.   
  11.     
  12.   
  13. import whao.test.hessian.server.MyService;   
  14.   
  15.     
  16.   
  17. /**  
  18.  
  19.  * @author Hao Wei  
  20.  
  21.  *  
  22.  
  23.  */  
  24.   
  25. public class MyServiceImpl implements MyService {   
  26.   
  27.     
  28.   
  29.     /* (non-Javadoc);  
  30.  
  31.      * @see whao.test.hessian.server.MyService#doSomething(java.lang.String);  
  32.  
  33.      */  
  34.   
  35.     public String doSomething(String s); {   
  36.   
  37.         return "HAHAHA: " + s;   
  38.   
  39.     }   
  40.   
  41. }   
  42.   
  43.    
/*

 * Created on 2005-7-25

 *

 */

package whao.test.hessian.server.impl;

 

import whao.test.hessian.server.MyService;

 

/**

 * @author Hao Wei

 *

 */

public class MyServiceImpl implements MyService {

 

    /* (non-Javadoc);

     * @see whao.test.hessian.server.MyService#doSomething(java.lang.String);

     */

    public String doSomething(String s); {

        return "HAHAHA: " + s;

    }

}


3. 配置远程服务

         Hessian的远程服务要配置成servlet，配置如下：
Java代码 复制代码  收藏代码
  1. <servlet>   
  2.   
  3.    <servlet-name>myservice</servlet-name>   
  4.   
  5.    <servlet-class>com.caucho.hessian.server.HessianServlet</servlet-class>   
  6.   
  7.    <load-on-startup>1</load-on-startup>   
  8.   
  9.    <init-param>   
  10.   
  11.        <param-name>service-class</param-name>   
  12.   
  13.        <param-value>whao.test.hessian.server.impl.MyServiceImpl</param-value>   
  14.   
  15.    </init-param>   
  16.   
  17. </servlet>   
  18.   
  19. <servlet-mapping>   
  20.   
  21.    <servlet-name>myservice</servlet-name>   
  22.   
  23.    <url-pattern>/myservice</url-pattern>   
  24.   
  25. </servlet-mapping>   
    <servlet>

       <servlet-name>myservice</servlet-name>

       <servlet-class>com.caucho.hessian.server.HessianServlet</servlet-class>

       <load-on-startup>1</load-on-startup>

       <init-param>

           <param-name>service-class</param-name>

           <param-value>whao.test.hessian.server.impl.MyServiceImpl</param-value>

       </init-param>

    </servlet>

    <servlet-mapping>

       <servlet-name>myservice</servlet-name>

       <url-pattern>/myservice</url-pattern>

    </servlet-mapping>


这样，当启动了这个web应用，这个远程服务就以url http://localhost:8080/test_web/myservice 的形式发布了。然后就是开发客户端来调用这个远程服务。

Java代码 复制代码  收藏代码
  1. /*  
  2.  
  3.  * Created on 2005-7-25  
  4.  
  5.  *  
  6.  
  7.  */  
  8.   
  9. package whao.test.hessian.client;   
  10.   
  11.     
  12.   
  13. import whao.test.hessian.server.MyService;   
  14.   
  15.     
  16.   
  17. import com.caucho.hessian.client.HessianProxyFactory;   
  18.   
  19.     
  20.   
  21. /**  
  22.  
  23.  * @author Hao Wei  
  24.  
  25.  *    
  26.  
  27.  */  
  28.   
  29. public class TestMain {   
  30.   
  31.     public static void main(String[] args); throws Exception {   
  32.   
  33.         HessianProxyFactory proxyFactory = new HessianProxyFactory();;   
  34.   
  35.         MyService service = (MyService); proxyFactory.create(MyService.class,   
  36.   
  37.                 "http://localhost:8080/test_web/myservice");;   
  38.   
  39.         System.out.println(service.doSomething("xixixixi"););;   
  40.   
  41.         System.out.println("ok!");;   
  42.   
  43.     }   
  44.   
  45. }   
  46.   
  47.    
/*

 * Created on 2005-7-25

 *

 */

package whao.test.hessian.client;

 

import whao.test.hessian.server.MyService;

 

import com.caucho.hessian.client.HessianProxyFactory;

 

/**

 * @author Hao Wei

 *  

 */

public class TestMain {

    public static void main(String[] args); throws Exception {

        HessianProxyFactory proxyFactory = new HessianProxyFactory();;

        MyService service = (MyService); proxyFactory.create(MyService.class,

                "http://localhost:8080/test_web/myservice");;

        System.out.println(service.doSomething("xixixixi"););;

        System.out.println("ok!");;

    }

}


运行一把，显示

HAHAHA:xixixi

ok!

不错不错，纯Hessian的远程调用就这样搞定了。继续研究《programmer》看到上面介绍用spring的远程访问解决方案来访问ejb的远程服务。什么？spring还有远程解决方案？没听说过嘛，看了《programmer》上的介绍，发现是真的。那么既然spring能访问ejb的远程服务，那么能访问Hessian的远程服务么？打开spring.jar看看，居然发现了名曰org.springframework.remoting.caucho.HessianProxyFactoryBean的类！夏昕真不厚道啊，再他的spring中文教程中居然匿掉了spring里这么好的东西！于是打开sping英文版reference，终于找到了用spring配置Hessian客户端的方法：
Java代码 复制代码  收藏代码
  1. <bean id="myService" class="org.springframework.remoting.caucho.HessianProxyFactoryBean">   
  2.   
  3.    <property name="serviceUrl">   
  4.   
  5.        <value>   
  6.   
  7.        http://localhost:8080/test_web/myservice   
  8.   
  9.        </value>   
  10.   
  11.    </property>   
  12.   
  13.    <property name="serviceInterface">   
  14.   
  15.        <value>whao.test.hessian.server.MyService</value>   
  16.   
  17.    </property>   
  18.   
  19. </bean>   
    <bean id="myService" class="org.springframework.remoting.caucho.HessianProxyFactoryBean">

       <property name="serviceUrl">

           <value>

           http://localhost:8080/test_web/myservice

           </value>

       </property>

       <property name="serviceInterface">

           <value>whao.test.hessian.server.MyService</value>

       </property>

    </bean>

然后客户端就可以这么玩啦：

Java代码 复制代码  收藏代码
  1. /*  
  2.  
  3.  * Created on 2005-7-25  
  4.  
  5.  *  
  6.  
  7.  */  
  8.   
  9. package whao.test.hessian.client;   
  10.   
  11.     
  12.   
  13. import whao.test.hessian.server.MyService;   
  14.   
  15. import whao.util.spirng.SpringBeanFactory;   
  16.   
  17.     
  18.   
  19. import com.caucho.hessian.client.HessianProxyFactory;   
  20.   
  21.     
  22.   
  23. /**  
  24.  
  25.  * @author Hao Wei  
  26.  
  27.  *    
  28.  
  29.  */  
  30.   
  31. public class TestMain {   
  32.   
  33.     
  34.   
  35.     public static void main(String[] args); throws Exception {   
  36.   
  37.         testWithSpring();;   
  38.   
  39.     }   
  40.   
  41.     public static void testWithSpring();{   
  42.   
  43.         MyService service = (MyService);SpringBeanFactory.getBean("myService");;   
  44.   
  45.         System.out.println(service.doSomething("lllllllll"););;   
  46.   
  47.         System.out.println("ok!");;   
  48.   
  49.     }   
  50.   
  51.     public static void testWithoutSpring(); throws Exception {   
  52.   
  53.         HessianProxyFactory proxyFactory = new HessianProxyFactory();;   
  54.   
  55.         MyService service = (MyService); proxyFactory.create(MyService.class,   
  56.   
  57.                 "http://localhost:8080/test_web/myservice");;   
  58.   
  59.         System.out.println(service.doSomething("xixixixi"););;   
  60.   
  61.         System.out.println("ok!");;   
  62.   
  63.     }   
  64.   
  65. }   
  66.   
  67.    
/*

 * Created on 2005-7-25

 *

 */

package whao.test.hessian.client;

 

import whao.test.hessian.server.MyService;

import whao.util.spirng.SpringBeanFactory;

 

import com.caucho.hessian.client.HessianProxyFactory;

 

/**

 * @author Hao Wei

 *  

 */

public class TestMain {

 

    public static void main(String[] args); throws Exception {

        testWithSpring();;

    }

    public static void testWithSpring();{

        MyService service = (MyService);SpringBeanFactory.getBean("myService");;

        System.out.println(service.doSomething("lllllllll"););;

        System.out.println("ok!");;

    }

    public static void testWithoutSpring(); throws Exception {

        HessianProxyFactory proxyFactory = new HessianProxyFactory();;

        MyService service = (MyService); proxyFactory.create(MyService.class,

                "http://localhost:8080/test_web/myservice");;

        System.out.println(service.doSomething("xixixixi"););;

        System.out.println("ok!");;

    }

}


执行一下，输出是：

HAHAHA:lllllllll

ok!

spring真是个好东东，呵呵，其中的SpringBeanFactory是这样实现的：
Java代码 复制代码  收藏代码
  1.   
  2. /*  
  3.  
  4.  * Created on 2005-7-25  
  5.  
  6.  *  
  7.  
  8.  */  
  9.   
  10. package whao.util.spirng;   
  11.   
  12.     
  13.   
  14. import javax.servlet.ServletContext;   
  15.   
  16.     
  17.   
  18. import org.apache.commons.logging.Log;   
  19.   
  20. import org.apache.commons.logging.LogFactory;   
  21.   
  22. import org.springframework.context.ApplicationContext;   
  23.   
  24. import org.springframework.context.support.FileSystemXmlApplicationContext;   
  25.   
  26. import org.springframework.web.context.support.WebApplicationContextUtils;   
  27.   
  28.     
  29.   
  30. /**  
  31.  
  32.  * @author Hao Wei  
  33.  
  34.  *  
  35.  
  36.  */  
  37.   
  38. public class SpringBeanFactory {   
  39.   
  40.     private static final Log log = LogFactory.getLog(SpringBeanFactory.class);;   
  41.   
  42.          private static ApplicationContext ctx = null;   
  43.   
  44.     
  45.   
  46.     public static Object getBean(ServletContext context, String beanID); {   
  47.   
  48.         log.info("beanID=" + beanID);;   
  49.   
  50.         ApplicationContext ac = WebApplicationContextUtils   
  51.   
  52.                 .getWebApplicationContext(context);;   
  53.   
  54.         return ac.getBean(beanID);;   
  55.   
  56.     }   
  57.   
  58.        
  59.   
  60.     public static Object getBean(String beanID);{   
  61.   
  62.                    if(ctx == null);{   
  63.   
  64.                             ctx = new FileSystemXmlApplicationContext(   
  65.   
  66.                             "D:\\whao-work\\src\\test_web\\test_web\\WEB-INF\\applicationContext.xml");;   
  67.   
  68.                    }   
  69.   
  70.                    return ctx.getBean(beanID);;   
  71.   
  72.     }   
  73.   
  74. }   
  75.   
  76.    
/*

 * Created on 2005-7-25

 *

 */

package whao.util.spirng;

 

import javax.servlet.ServletContext;

 

import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.FileSystemXmlApplicationContext;

import org.springframework.web.context.support.WebApplicationContextUtils;

 

/**

 * @author Hao Wei

 *

 */

public class SpringBeanFactory {

    private static final Log log = LogFactory.getLog(SpringBeanFactory.class);;

         private static ApplicationContext ctx = null;

 

    public static Object getBean(ServletContext context, String beanID); {

        log.info("beanID=" + beanID);;

        ApplicationContext ac = WebApplicationContextUtils

                .getWebApplicationContext(context);;

        return ac.getBean(beanID);;

    }

    

    public static Object getBean(String beanID);{

                   if(ctx == null);{

                            ctx = new FileSystemXmlApplicationContext(

                            "D:\\whao-work\\src\\test_web\\test_web\\WEB-INF\\applicationContext.xml");;

                   }

                   return ctx.getBean(beanID);;

    }

}


看到sping.jar的包org.springframework.remoting.caucho中还有另外两个类叫HessianClientInterceptor和HessianServiceExporter，看来貌似hessian服务端也可以和spring结合，还有客户端的Interceptor估计可以实现对远程服务的AOP，要继续研究一下了，待续吧
返回顶楼
         
 
  • benber
  • 等级: 二星会员
  • 性别:
  • 文章: 23
  • 积分: 185
  • 来自: 上海
   发表时间：2005-07-31  
在成功的将hessian server端也和spring结合后，从整个分布式应用的架构可以看出，无论是服务端与客户端共有的业务接口，还是服务端业务实现类，以及客户端访问远程服务的应用代码里，已经没有一行关于远程操作的代码了。也就是spring让我们的分布式业务开发完全无关于远程访问协议了，这样我们就可以埋头开发服务端和客户端的业务接口、实现、应用等等，二不必关心远程调用究竟要怎么实现。很明显，这也是AOP（面向方面的编程）的一个比较完美的应用，它使远程访问接口和业务逻辑完全无耦合的分开了。设想一下，如果某天我们有需要，远程访问的接口要从rmi、jax-rpc、hessian、httpinvoker之间做切换，也只要改下配置文件就ok了，一行代码都不用改，真的非常exciting。

接着前面那篇日志，先把spring和hessian在服务端的结合帖上来：

接口，还是那个接口~；实现，还是那个实现~~；配置却不是了那个配置呀~~~

首先，servlet变成了：
Java代码 复制代码  收藏代码
  1. <servlet>   
  2.   
  3.    <servlet-name>remote</servlet-name>   
  4.   
  5.    <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>   
  6.   
  7.    <load-on-startup>1</load-on-startup>   
  8.   
  9. </servlet>   
  10.   
  11. <servlet-mapping>   
  12.   
  13.    <servlet-name>remote</servlet-name>   
  14.   
  15.    <url-pattern>/remote/*</url-pattern>   
  16.   
  17. </servlet-mapping>  
    <servlet>

       <servlet-name>remote</servlet-name>

       <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

       <load-on-startup>1</load-on-startup>

    </servlet>

    <servlet-mapping>

       <servlet-name>remote</servlet-name>

       <url-pattern>/remote/*</url-pattern>

    </servlet-mapping>

其次，applicationContext.xml没有必要了，但是要有个remote-servlet.xml，内容如下：

Java代码 复制代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>   
  2.   
  3. <!-- edited with XMLSPY v5 rel. 4 U (http://www.xmlspy.com); by whao (mdc); -->   
  4.   
  5. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">   
  6.   
  7. <beans>   
  8.   
  9.     <description>server properties</description>   
  10.   
  11.     <bean id="_myService_server" class="whao.test.hessian.server.impl.MyServiceImpl">   
  12.   
  13.     </bean>   
  14.   
  15.     <bean name="/myService_server" class="org.springframework.remoting.caucho.HessianServiceExporter">   
  16.   
  17.        <property name="service">   
  18.   
  19.            <ref bean="_myService_server"/>   
  20.   
  21.        </property>   
  22.   
  23.        <property name="serviceInterface">   
  24.   
  25.            <value>whao.test.hessian.server.MyService</value>   
  26.   
  27.        </property>   
  28.   
  29.     </bean>       
  30.   
  31. </beans>   
  32.   
  33.    
<?xml version="1.0" encoding="UTF-8"?>

<!-- edited with XMLSPY v5 rel. 4 U (http://www.xmlspy.com); by whao (mdc); -->

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

    <description>server properties</description>

    <bean id="_myService_server" class="whao.test.hessian.server.impl.MyServiceImpl">

    </bean>

    <bean name="/myService_server" class="org.springframework.remoting.caucho.HessianServiceExporter">

       <property name="service">

           <ref bean="_myService_server"/>

       </property>

       <property name="serviceInterface">

           <value>whao.test.hessian.server.MyService</value>

       </property>

    </bean>    

</beans>


这样一来这个hessian服务的发布地址就变成了 http://localhost:8080/test_web/remote/myService_server

客户端的配置改成：
Java代码 复制代码  收藏代码
  1. <bean id="myServiceClient" class="org.springframework.remoting.caucho.HessianProxyFactoryBean">   
  2.   
  3.    <property name="serviceUrl">   
  4.   
  5.        <value>http://localhost:8080/test_web/remote/myService_server</value>   
  6.   
  7.    </property>   
  8.   
  9.    <property name="serviceInterface">   
  10.   
  11.        <value>whao.test.hessian.server.MyService</value>   
  12.   
  13.    </property>   
  14.   
  15. </bean>  
    <bean id="myServiceClient" class="org.springframework.remoting.caucho.HessianProxyFactoryBean">

       <property name="serviceUrl">

           <value>http://localhost:8080/test_web/remote/myService_server</value>

       </property>

       <property name="serviceInterface">

           <value>whao.test.hessian.server.MyService</value>

       </property>

    </bean>



客户端的代码依然是：
Java代码 复制代码  收藏代码
  1. MyService service = (MyService);SpringBeanFactory.getBean("myServiceClient");;   
  2.   
  3. System.out.println(service.doSomething("mmmmmmmmm"););;   
        MyService service = (MyService);SpringBeanFactory.getBean("myServiceClient");;

        System.out.println(service.doSomething("mmmmmmmmm"););;


运行一下，输出：

HAHAHA: mmmmmmmmm

ok!



嗯，真是不错，下面尝试着不改一行代码，我们把远程协议由hessian改成rmi。

由于rmi server不用servlet，也就不用web server，所以可以由自己的进程之接启动，我们就把remote-servlet.xml改成beans.xml内容如下：

Java代码 复制代码  收藏代码
  1. <?xml version="1.0" encoding="UTF-8"?>   
  2.   
  3. <!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">   
  4.   
  5. <beans>   
  6.   
  7.     <bean id="_myService_server" class="whao.test.hessian.server.impl.MyServiceImpl">   
  8.   
  9.     </bean>   
  10.   
  11.     <bean id="myService_server" class="org.springframework.remoting.rmi.RmiServiceExporter">   
  12.   
  13.        <property name="serviceName"><value>myService_server</value></property>   
  14.   
  15.        <property name="service"><ref bean="_myService_server"/></property>   
  16.   
  17.        <property name="serviceInterface"><value>whao.test.hessian.server.MyService</value></property>   
  18.   
  19.     </bean>   
  20.   
  21. </beans>   
  22.   
  23.    
<?xml version="1.0" encoding="UTF-8"?>

<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>

    <bean id="_myService_server" class="whao.test.hessian.server.impl.MyServiceImpl">

    </bean>

    <bean id="myService_server" class="org.springframework.remoting.rmi.RmiServiceExporter">

       <property name="serviceName"><value>myService_server</value></property>

       <property name="service"><ref bean="_myService_server"/></property>

       <property name="serviceInterface"><value>whao.test.hessian.server.MyService</value></property>

    </bean>

</beans>


然后随便写个main程序启动服务，就不用启动web server了：

Java代码 复制代码  收藏代码
  1. /*  
  2.  
  3.  * Created on 2005-7-31  
  4.  
  5.  *  
  6.  
  7.  */  
  8.   
  9. package whao.test.rmi;   
  10.   
  11.     
  12.   
  13. import org.springframework.context.ApplicationContext;   
  14.   
  15. import org.springframework.context.support.FileSystemXmlApplicationContext;   
  16.   
  17.     
  18.   
  19. /**  
  20.  
  21.  * @author Hao Wei  
  22.  
  23.  *  
  24.  
  25.  */  
  26.   
  27. public class Server {   
  28.   
  29.          public static void main(String[] args); throws Exception{   
  30.   
  31.              ApplicationContext ctx = new FileSystemXmlApplicationContext("D:\\whao-work\\src\\test_web\\src_server\\beans.xml");;   
  32.   
  33.              ctx.getBean("myService_server");;   
  34.   
  35.                    System.out.println("Server started");;   
  36.   
  37.          }   
  38.   
  39. }  
/*

 * Created on 2005-7-31

 *

 */

package whao.test.rmi;

 

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.FileSystemXmlApplicationContext;

 

/**

 * @author Hao Wei

 *

 */

public class Server {

         public static void main(String[] args); throws Exception{

             ApplicationContext ctx = new FileSystemXmlApplicationContext("D:\\whao-work\\src\\test_web\\src_server\\beans.xml");;

             ctx.getBean("myService_server");;

                   System.out.println("Server started");;

         }

}



这样，我们的服务接口和实现类的代码一行不用动，而变成rmi协议的服务已经以rmi://localhost/myService_server 的url启动了。

然后在把客户端的配置略微调整一下：
Java代码 复制代码  收藏代码
  1. <bean id="myServiceClient" class="org.springframework.remoting.rmi.RmiProxyFactoryBean">   
  2.   
  3.    <property name="serviceUrl">   
  4.   
  5.        <value>rmi://localhost/myService_server</value>   
  6.   
  7.    </property>   
  8.   
  9.    <property name="serviceInterface">   
  10.   
  11.        <value>whao.test.hessian.server.MyService</value>   
  12.   
  13.    </property>   
  14.   
  15. </bean>   
    <bean id="myServiceClient" class="org.springframework.remoting.rmi.RmiProxyFactoryBean">

       <property name="serviceUrl">

           <value>rmi://localhost/myService_server</value>

       </property>

       <property name="serviceInterface">

           <value>whao.test.hessian.server.MyService</value>

       </property>

    </bean>

客户端的代码也一行不动，在执行下，输出依然是：

HAHAHA: mmmmmmmmm

ok!

然而，我们的remoting其实已经由基于http的hessian改成了rmi。果然不错啊，除了hessian,rmi之外，现在spring支持的remoting协议还包括jax-rpc，burlap，httpinvoker，也就是说我们的remoting操作协议在这些中间切换时，利用spring remoting框架，都可以不用改一行代码，已经非常强大了，只是现在还没有corba的支持。
aWangz
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
分布式通信之远程调用
m0_38043550的博客
06-03 818
前言 分布式的本质就是多进程协作，共同完成任务。要协作，自然免不了通信。从今天开始就来介绍多个进程之间通信的相关内容，那么首先先介绍分布式通信中的远程调用。 什么是远程调用？ 以电商购物平台为例，每一笔交易都涉及订单系统、支付系统及库存系统，假设三个系统分别部署在三台机器 A、B、C 中独立运行，订单交易流程如下所示： 用户下单时，调用本地（机器 A）的订单系统进行下单； 下单完成后，会远程调用机器 B 上的支付系统进行支付，待支付完成后返回结果，之后在本地更新订单状态； 在本地远程调用机器 C 上的仓库
分布式通信：远程调用
热门推荐
海陆云的博客
12-25 3万+
分布式通信：远程调用前言什么是远程调用？远程调用的原理及应用RPC 的原理及应用RMI 的原理及应用RPC 与 RMI 对比分析知识扩展：远程过程调用存在同步和异步吗？总结 前言 分布式的本质就是多进程协作，共同完成任务。要协作自然免不了通信。分布式通信技术模块中分布式通信中的远程调用。 什么是远程调用？ 以电商购物平台为例，每一笔交易都涉及订单系统、支付系统及库存系统，假设三个系统分别部署在三台机器 A、B、C 中独立运行，订单交易流程如下所示： 用户下单时，调用本地（机器 A）的订单系统进行下单；
分布式系统阅读笔记（五）-----远程调用
走在前往架构师的路上
12-24 2823
介绍） 这篇笔记主要讲的是远程调用的主要2种形式，RPC(远程过程调用)，RMI(远程方法调用)，这2种方法作为远程调用的实现形式，对于我们理解他们的过程非常有用。 请求回复协议） 在远程调用中，一个很重要的概念是啊请求回复协议，由客户端发送Request到服务端，服务端执行好操作之后，把结果在回传到客户端上，就完成了一个基本的调用过程。这里有几点比较重要的概念： 1.消息标识别。这里指的
用spring和hessian构建分布式应用（远程接口）的方法
yangf1275的专栏
03-27 1644
最近一期的《programmer》里几乎从头至尾在讲关于“J2EE without EJB”的事情，可怜的ejb啊，居然被描述成了遗产系统的重要组成部分。。。 其实有上面的结论，无外乎现在java里面的新技术已经几乎能完全取代ejb的优点，而克服ejb的缺点，entity bean和有状态的session bean已经机乎被视为垃圾，hibernate和spring大行其到，看看最进n期《prog
分布式系统如何实现远程调用
weixin_47723535的博客
11-02 837
在分布式系统中，各个服务可能处于不同主机，但是服务之间不可避免的需要相互调用，这个称为远程调用。 之前我们在项目的开发过程中，只需要创建一个工程，将所有功能放入一个项目进行开发，管理，变异，测试，打包。 所以以前的项目都被称为单体架构 。 但由于单体架构存在明显的缺陷，这时我们需要用到分布式系统。 远程过程调用(RPC):RPC是由Sun发明的远程过程调用协议，是第一种真正的分布式应用模型。 RPC远程调用框架： （1）RMI实现 （2）Hessian （3）thrift （4）SpringCloud （5
Spring+Hibernate+Xfire实现远程分布式调用
05-26
本主题将深入探讨如何使用Spring、Hibernate和Xfire来实现远程分布式调用。这些技术都是Java开发中的重要工具，Spring作为全面的框架提供了服务管理和依赖注入，Hibernate则是流行的ORM（对象关系映射）解决方案，而...
java+hessian 远程调用
01-31
Java Hessian远程调用是一种高效的、轻量级的RPC（Remote Procedure Call）解决方案，它允许Java应用程序通过网络进行跨语言的通信。Hessian是BEA Systems开发的一种二进制Web服务协议，它提供了序列化和远程方法...
spring+hessian+maven整合.zip
最新发布
03-10
【标题】：“Spring + Hessian + Maven 整合”是一个基于Java的分布式服务开发实践，它结合了Spring框架的强大功能，Hessian的轻量级RPC（远程过程调用）协议，以及Maven作为项目构建和依赖管理工具。这个压缩包包含...
Spring + Hessian + Spring MVC(包括Server和Client).zip
06-21
1.名称:Spring + Hessian + Spring MVC(包括Server和Client).zip 2.来源：自己实现 3.备注：项目有两个系统，包括Server端和Client端，项目已经跑通，可以实现。 4.注意：client中pom.xml里最后的一个jar包，需要...
springboot+dubbo+zookeeper构建的分布式调用服务框架
11-26
Dubbo 是阿里巴巴开源的一个高性能、轻量级的Java RPC框架，它提供了服务注册与发现、负载均衡、容错、监控等能力，旨在提高服务之间的通信效率和稳定性。Dubbo 支持多种协议，如Dubbo、HTTP、Hessian等，并且可以...
分布式(一)基于spring-rmi
Sunny_Zhang0110的博客
11-07 256
rpc--实现--》spring封装rmi（java） 1、spring的rmi封装 a）对应的库：spring context环境自带rmi封装 b）使用方式：不需要写java代码=只需要配置即可 2、spring=封装rpc--rmi服务端的配置： 把【对应的接口】【对应的实现类的对象】暴露为远程服务 配置：spring-rmi-server.xml &lt;!-- RMI服...
分布式对象和远程调用
weixin_33994429的博客
05-11 228
一.引言 1.1 分布式对象技术要解决的基本问题 　　分布式对象技术是在面向对象技术的基础上发展起来的，它要解决的主要问题是位于不同进程中的对象之间的调用问题。 支持访问异地对象，支持访问异构对象（java平台调用C、vb，C++）。 1.2 中间件 　　参考http://kb.cnblogs.com/page/196448/  　　1.中间件是一种软件，它提供基本的通信模块和其他一些...
分布式系统漫谈【伍】_远程调用
xinzun的专栏
03-03 855
上篇文章：分布式系统漫谈【肆】_负载层技术：CDN 当我们的系统由单体应用拆分成多个子应用分布式部署后，就要去考虑各个应用之前的调用问题了。因为之前单体应用的时候，各个接口的调用只是本地调用，是在一个JVM中完成的；而我们要跨应用(JVM)调用的时候，这就使用到了远程调用。 远程调用 什么是远程调用？先了解一下RPC(Remote Procedure Call Pro...
分布式系统基础-远程过程调用（RPC）
Ron.Zheng
10-10 4287
RPC（Remote Procedure Call，远程过程调用）是建立在Socket之上的一种多进程间的通信机制。不同于复杂的Socket通信方式，RPC的初心是设计一套远程通信的通用框架，这个框架能够自动处理通信协议、对象序列化、网络传输等复杂细节，并且希望开发者使用这个框架以后，调用一个远程机器上的接口代码与以本地方法调用的代码“看起来没什么区别”，从而大大减小分布式的开发难度，
分布式之远程调用
weixin_46822085的博客
11-03 482
一、Spring cloud中使用Http+Resful+Json进行调用 1. restful是什么：用于设计web服务(controller @ResponseMapping("/list"))的规范。 之前：http协议 （罗伊*菲尔丁） http://127.0.0.1:8080/getStudent 不符合restful 增加学生，可能是：/addNewStudent 更新学生，可能是：/updateStudent 删除学生，可能是：/deleteStudent?id=xx 删除所有学生
分布式系统学习(四)——远程调用
DadaBlog
07-28 636
远程调用 请求-应答协议 在TCP协议之上，通过数据报API中发送和接收操作来描述。请求-应答协议基于三个通信原语：doOperation、getRequest、sendReply，该协议可将服务器的应答消息作为客户端请求消息的确认。 请求-应答协议消息结构 messageType int(0 请求 1 应答） requestId。 int 消息唯一标识符 由整数序列 发送进程IP 端口号 组成...
分布式系统架构的远程调用（RESTFul、RPC）和CAP原理
IT-CRUD
04-03 3397
分布式系统的远程调用 在微服务架构中，通常存在多个服务之间的远程调用的需求。远程调用通常包含两个部分：序列化和通信协议。常见的序列化协议包括json、xml、hession、protobuf、thrift、text、bytes等，目前主流的远程调用技术有基于HTTP的RESTful接口以及基于TCP的RPC协议。 RestFul接口 REST，即Representational State Transfer的缩写，如果一个架构符合REST原则，就称它为RESTful架构。 资源（Resource）：所谓"
分布式系统的那些事儿（三） - 系统与系统之间的调用
weixin_34021089的博客
06-08 319
系统与系统之间的调用通俗来讲，分为本地同一台服务器上的服务相互调用与远程服务调用，这个都可以称之为RPC通信。浅白点讲，客户访问服务器A，此时服务器要完成某个动作必须访问服务器B，服务器A与B互相通信，相互调用，A访问B的时候，A挂起，等待B的响应，B响应返回相应的数据个A，A再返回给用户，这就是一个很简单的栗子。 举个常见栗子，用户上传图片，用户上传图片首先会经过自身的服务器，然后再对图片进行处...
java的分布式远程调用
joshuacty的博客
06-04 433
RPC 是 远程过程调用机制 思想 框架 1，rmi，客户端与服务器完全基于java，是RPC在java中的具体体现 rmi是1.0的时候出现的 2 webService 微软 客戶機和服務器都必須可以是多種語言 性能較低 ...
计算机外文翻译-Spring的web-MVC-构架模式.pdf
10-28
当应用需要升级或扩展时，Spring提供了选择特定技术路径的能力，比如使用JtaTransactionManager处理分布式事务或通过DataSourceTransactionManager或HibernateTransactionManager实现事务管理。 Spring的web MVC...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值