<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>简单之美 &#187; Category &#187; Dubbo/Akka/Thrift</title>
	<atom:link href="http://shiyanjun.cn/archives/category/opensource/dubbo-akka-thrift/feed" rel="self" type="application/rss+xml" />
	<link>http://shiyanjun.cn</link>
	<description>简单之美，难得简单，享受简单的唯美。</description>
	<lastBuildDate>Wed, 04 Mar 2026 07:04:53 +0000</lastBuildDate>
	<language>zh-CN</language>
		<sy:updatePeriod>hourly</sy:updatePeriod>
		<sy:updateFrequency>1</sy:updateFrequency>
	<generator>http://wordpress.org/?v=3.9.2</generator>
	<item>
		<title>Akka Cluster原理与应用</title>
		<link>http://shiyanjun.cn/archives/1186.html</link>
		<comments>http://shiyanjun.cn/archives/1186.html#comments</comments>
		<pubDate>Wed, 26 Aug 2015 09:16:42 +0000</pubDate>
		<dc:creator><![CDATA[Yanjun]]></dc:creator>
				<category><![CDATA[Dubbo/Akka/Thrift]]></category>
		<category><![CDATA[开源技术]]></category>
		<category><![CDATA[Akka]]></category>

		<guid isPermaLink="false">http://shiyanjun.cn/?p=1186</guid>
		<description><![CDATA[<p>Akka集群原理
Akka集群支持去中心化的基于P2P的集群服务，没有单点故障（SPOF）问题，它主要是通过Gossip协议来实现。对于集群成员的状态，Akka提供了一种故障检测机制，能够自动发现出现故障而离开集群的成员节点，通过事件驱动的方式，将状态传播到整个集群的其它成员节点。

状态转移与故障检测

Akka内部为集群成员定义了一组有限状态（6种状态），并给出了一个状态转移矩阵，代码如下所示：
Akka集群中的每个成员节点，都有可能处于上面的一种状态，在发生某些事件以后，会发生状态转移。需要注意的是，除了Down和Removed状态以外，节点处于其它任何一个状态时都有可能变成Down状态，即节点故障而无法提供服务，而在变成Down状态之前有一个虚拟的Unreachable状态，因为在Gossip收敛过程中，是无法到达或者经由Unreachable状态的节点，这个状态是由Akka实现的故障探测器（Failure Detector）来检测到的。处于Down状态的节点如果想要再次加入Akka集群，需要重新启动，并进入Joining状态，然后才能进行后续状态的转移变化。Akka集群成员节点状态及其转移情况，如下</p>]]></description>
	<p>Akka集群原理
Akka集群支持去中心化的基于P2P的集群服务，没有单点故障（SPOF）问题，它主要是通过Gossip协议来实现。对于集群成员的状态，Akka提供了一种故障检测机制，能够自动发现出现故障而离开集群的成员节点，通过事件驱动的方式，将状态传播到整个集群的其它成员节点。

状态转移与故障检测

Akka内部为集群成员定义了一组有限状态（6种状态），并给出了一个状态转移矩阵，代码如下所示：

  private[cluster] val allowedTransitions: Map[MemberStatus, Set[MemberStatus]] =
    Map(
      Joining -&gt; Set(Up, Down, Removed),
      Up -&gt; Set(Leaving, Down, Removed),
      Leaving -&gt; Set(Exiting, Down, Removed),
      Down -&gt; Set(Removed),
      Exiting -&gt; Set(Removed, Down),
      Removed -&gt; Set.empty[MemberStatus])
}

Akka集群中的每个成员节点，都有可能处于上面的一种状态，在发生某些事件以后，会发生状态转移。需要注意的是，除了Down和Removed状态以外，节点处于其它任何一个状态时都有可能变成Do</p>			<content:encoded><![CDATA[<p>Akka集群原理
Akka集群支持去中心化的基于P2P的集群服务，没有单点故障（SPOF）问题，它主要是通过Gossip协议来实现。对于集群成员的状态，Akka提供了一种故障检测机制，能够自动发现出现故障而离开集群的成员节点，通过事件驱动的方式，将状态传播到整个集群的其它成员节点。

状态转移与故障检测

Akka内部为集群成员定义了一组有限状态（6种状态），并给出了一个状态转移矩阵，代码如下所示：
Akka集群中的每个成员节点，都有可能处于上面的一种状态，在发生某些事件以后，会发生状态转移。需要注意的是，除了Down和Removed状态以外，节点处于其它任何一个状态时都有可能变成Down状态，即节点故障而无法提供服务，而在变成Down状态之前有一个虚拟的Unreachable状态，因为在Gossip收敛过程中，是无法到达或者经由Unreachable状态的节点，这个状态是由Akka实现的故障探测器（Failure Detector）来检测到的。处于Down状态的节点如果想要再次加入Akka集群，需要重新启动，并进入Joining状态，然后才能进行后续状态的转移变化。Akka集群成员节点状态及其转移情况，如下</p>]]></content:encoded>
			<wfw:commentRss>http://shiyanjun.cn/archives/1186.html/feed</wfw:commentRss>
		<slash:comments>4</slash:comments>
		</item>
		<item>
		<title>Akka入门编程实践</title>
		<link>http://shiyanjun.cn/archives/1178.html</link>
		<comments>http://shiyanjun.cn/archives/1178.html#comments</comments>
		<pubDate>Thu, 20 Aug 2015 06:34:28 +0000</pubDate>
		<dc:creator><![CDATA[Yanjun]]></dc:creator>
				<category><![CDATA[Dubbo/Akka/Thrift]]></category>
		<category><![CDATA[开源技术]]></category>
		<category><![CDATA[Akka]]></category>

		<guid isPermaLink="false">http://shiyanjun.cn/?p=1178</guid>
		<description><![CDATA[<p>Akka是使用Scala语言开发一个编程库，基于事件驱动的架构实现异步处理，它能够简化编写分布式应用程序。Akka中最核心的概念是Actor模型，它为编写分布式/并行计算应用程序提供了高层次抽象，在实际编程实践中，开发人员可以从对复杂网络通信细节的处理、多线程应用场景下对锁的管理中解脱出来。
Akka能够给应用程序带来的几个重要的特性是：

容错性
可伸缩性
异步性
事件驱动架构（EDA）
远程透明性

Actor是Akka中最核心的组件，以至于我们在编写基于Akka的应用程序时，大部分时间都会和Actor打交道，那么Actor到底是怎样的一种抽象呢？一个Actor对象封装了状态和行为，但是它不和外界其它的Actor共享状态，如果一个Actor想要和另一个Actor交互，能且只能通过发送消息来达到信息交换的目的。可见，一个Actor能够很好地保护其内部状态的安全。
与本地Actor通信
下面，我们从最简单的Actor编程来体验Akka的功能。首先，先定义几种类型的消息，后面会基于这些消息来进行通信，代码如下所示：
要实现一个Actor，需要继承自特质akka.actor.Actor，然后需要实现Actor特质</p>]]></description>
	<p>Akka是使用Scala语言开发一个编程库，基于事件驱动的架构实现异步处理，它能够简化编写分布式应用程序。Akka中最核心的概念是Actor模型，它为编写分布式/并行计算应用程序提供了高层次抽象，在实际编程实践中，开发人员可以从对复杂网络通信细节的处理、多线程应用场景下对锁的管理中解脱出来。
Akka能够给应用程序带来的几个重要的特性是：

容错性
可伸缩性
异步性
事件驱动架构（EDA）
远程透明性

Actor是Akka中最核心的组件，以至于我们在编写基于Akka的应用程序时，大部分时间都会和Actor打交道，那么Actor到底是怎样的一种抽象呢？一个Actor对象封装了状态和行为，但是它不和外界其它的Actor共享状态，如果一个Actor想要和另一个Actor交互，能且只能通过发送消息来达到信息交换的目的。可见，一个Actor能够很好地保护其内部状态的安全。
与本地Actor通信
下面，我们从最简单的Actor编程来体验Akka的功能。首先，先定义几种类型的消息，后面会基于这些消息来进行通信，代码如下所示：

package org.shirdrn.scala.akka

object Start extends Serializable</p>			<content:encoded><![CDATA[<p>Akka是使用Scala语言开发一个编程库，基于事件驱动的架构实现异步处理，它能够简化编写分布式应用程序。Akka中最核心的概念是Actor模型，它为编写分布式/并行计算应用程序提供了高层次抽象，在实际编程实践中，开发人员可以从对复杂网络通信细节的处理、多线程应用场景下对锁的管理中解脱出来。
Akka能够给应用程序带来的几个重要的特性是：

容错性
可伸缩性
异步性
事件驱动架构（EDA）
远程透明性

Actor是Akka中最核心的组件，以至于我们在编写基于Akka的应用程序时，大部分时间都会和Actor打交道，那么Actor到底是怎样的一种抽象呢？一个Actor对象封装了状态和行为，但是它不和外界其它的Actor共享状态，如果一个Actor想要和另一个Actor交互，能且只能通过发送消息来达到信息交换的目的。可见，一个Actor能够很好地保护其内部状态的安全。
与本地Actor通信
下面，我们从最简单的Actor编程来体验Akka的功能。首先，先定义几种类型的消息，后面会基于这些消息来进行通信，代码如下所示：
要实现一个Actor，需要继承自特质akka.actor.Actor，然后需要实现Actor特质</p>]]></content:encoded>
			<wfw:commentRss>http://shiyanjun.cn/archives/1178.html/feed</wfw:commentRss>
		<slash:comments>2</slash:comments>
		</item>
		<item>
		<title>Akka框架基本要点介绍</title>
		<link>http://shiyanjun.cn/archives/1168.html</link>
		<comments>http://shiyanjun.cn/archives/1168.html#comments</comments>
		<pubDate>Wed, 12 Aug 2015 15:43:38 +0000</pubDate>
		<dc:creator><![CDATA[Yanjun]]></dc:creator>
				<category><![CDATA[Dubbo/Akka/Thrift]]></category>
		<category><![CDATA[开源技术]]></category>
		<category><![CDATA[Akka]]></category>

		<guid isPermaLink="false">http://shiyanjun.cn/?p=1168</guid>
		<description><![CDATA[<p>Akka基于Actor模型，提供了一个用于构建可扩展的（Scalable）、弹性的（Resilient）、快速响应的（Responsive）应用程序的平台。本文基本上是基于Akka的官方文档（版本是2.3.12），通过自己的理解，来阐述Akka提供的一些组件或概念，另外总结了Akka的一些使用场景。
Actor
维基百科这样定义Actor模型：

在计算科学领域，Actor模型是一个并行计算（Concurrent Computation）模型，它把actor作为并行计算的基本元素来对待：为响应一个接收到的消息，一个actor能够自己做出一些决策，如创建更多的actor，或发送更多的消息，或者确定如何去响应接收到的下一个消息。

Actor是Akka中最核心的概念，它是一个封装了状态和行为的对象，Actor之间可以通过交换消息的方式进行通信，每个Actor都有自己的收件箱（Mailbox）。
通过Actor能够简化锁及线程管理，可以非常容易地开发出正确地并发程序和并行系统，Actor具有如下特性：

提供了一种高级抽象，能够简化在并发（Concurrency）/并行（Parallelism）应用场景下的编程开发
提供了异步非阻塞的、高性能的事件驱动编程模型
超</p>]]></description>
	<p>Akka基于Actor模型，提供了一个用于构建可扩展的（Scalable）、弹性的（Resilient）、快速响应的（Responsive）应用程序的平台。本文基本上是基于Akka的官方文档（版本是2.3.12），通过自己的理解，来阐述Akka提供的一些组件或概念，另外总结了Akka的一些使用场景。
Actor
维基百科这样定义Actor模型：

在计算科学领域，Actor模型是一个并行计算（Concurrent Computation）模型，它把actor作为并行计算的基本元素来对待：为响应一个接收到的消息，一个actor能够自己做出一些决策，如创建更多的actor，或发送更多的消息，或者确定如何去响应接收到的下一个消息。

Actor是Akka中最核心的概念，它是一个封装了状态和行为的对象，Actor之间可以通过交换消息的方式进行通信，每个Actor都有自己的收件箱（Mailbox）。
通过Actor能够简化锁及线程管理，可以非常容易地开发出正确地并发程序和并行系统，Actor具有如下特性：

提供了一种高级抽象，能够简化在并发（Concurrency）/并行（Parallelism）应用场景下的编程开发
提供了异步非阻塞的、高性能的事件驱动编程模型
超</p>			<content:encoded><![CDATA[<p>Akka基于Actor模型，提供了一个用于构建可扩展的（Scalable）、弹性的（Resilient）、快速响应的（Responsive）应用程序的平台。本文基本上是基于Akka的官方文档（版本是2.3.12），通过自己的理解，来阐述Akka提供的一些组件或概念，另外总结了Akka的一些使用场景。
Actor
维基百科这样定义Actor模型：

在计算科学领域，Actor模型是一个并行计算（Concurrent Computation）模型，它把actor作为并行计算的基本元素来对待：为响应一个接收到的消息，一个actor能够自己做出一些决策，如创建更多的actor，或发送更多的消息，或者确定如何去响应接收到的下一个消息。

Actor是Akka中最核心的概念，它是一个封装了状态和行为的对象，Actor之间可以通过交换消息的方式进行通信，每个Actor都有自己的收件箱（Mailbox）。
通过Actor能够简化锁及线程管理，可以非常容易地开发出正确地并发程序和并行系统，Actor具有如下特性：

提供了一种高级抽象，能够简化在并发（Concurrency）/并行（Parallelism）应用场景下的编程开发
提供了异步非阻塞的、高性能的事件驱动编程模型
超</p>]]></content:encoded>
			<wfw:commentRss>http://shiyanjun.cn/archives/1168.html/feed</wfw:commentRss>
		<slash:comments>3</slash:comments>
		</item>
		<item>
		<title>基于Dubbo框架构建分布式服务</title>
		<link>http://shiyanjun.cn/archives/1075.html</link>
		<comments>http://shiyanjun.cn/archives/1075.html#comments</comments>
		<pubDate>Tue, 31 Mar 2015 14:30:45 +0000</pubDate>
		<dc:creator><![CDATA[Yanjun]]></dc:creator>
				<category><![CDATA[Dubbo/Akka/Thrift]]></category>
		<category><![CDATA[开源技术]]></category>

		<guid isPermaLink="false">http://shiyanjun.cn/?p=1075</guid>
		<description><![CDATA[<p>Dubbo是Alibaba开源的分布式服务框架，我们可以非常容易地通过Dubbo来构建分布式服务，并根据自己实际业务应用场景来选择合适的集群容错模式，这个对于很多应用都是迫切希望的，只需要通过简单的配置就能够实现分布式服务调用，也就是说服务提供方（Provider）发布的服务可以天然就是集群服务，比如，在实时性要求很高的应用场景下，可能希望来自消费方（Consumer）的调用响应时间最短，只需要选择Dubbo的Forking Cluster模式配置，就可以对一个调用请求并行发送到多台对等的提供方（Provider）服务所在的节点上，只选择最快一个返回响应的，然后将调用结果返回给服务消费方（Consumer），显然这种方式是以冗余服务为基础的，需要消耗更多的资源，但是能够满足高实时应用的需求。
有关Dubbo服务框架的简单使用，可以参考我的其他两篇文章（《基于Dubbo的Hessian协议实现远程调用》，《Dubbo实现RPC调用使用入门》，后面参考链接中已给出链接），这里主要围绕Dubbo分布式服务相关配置的使用来说明与实践。
Dubbo服务集群容错
假设我们使用的是单机模式的Dubbo服务，如</p>]]></description>
	<p>Dubbo是Alibaba开源的分布式服务框架，我们可以非常容易地通过Dubbo来构建分布式服务，并根据自己实际业务应用场景来选择合适的集群容错模式，这个对于很多应用都是迫切希望的，只需要通过简单的配置就能够实现分布式服务调用，也就是说服务提供方（Provider）发布的服务可以天然就是集群服务，比如，在实时性要求很高的应用场景下，可能希望来自消费方（Consumer）的调用响应时间最短，只需要选择Dubbo的Forking Cluster模式配置，就可以对一个调用请求并行发送到多台对等的提供方（Provider）服务所在的节点上，只选择最快一个返回响应的，然后将调用结果返回给服务消费方（Consumer），显然这种方式是以冗余服务为基础的，需要消耗更多的资源，但是能够满足高实时应用的需求。
有关Dubbo服务框架的简单使用，可以参考我的其他两篇文章（《基于Dubbo的Hessian协议实现远程调用》，《Dubbo实现RPC调用使用入门》，后面参考链接中已给出链接），这里主要围绕Dubbo分布式服务相关配置的使用来说明与实践。
Dubbo服务集群容错
假设我们使用的是单机模式的Dubbo服务，如</p>			<content:encoded><![CDATA[<p>Dubbo是Alibaba开源的分布式服务框架，我们可以非常容易地通过Dubbo来构建分布式服务，并根据自己实际业务应用场景来选择合适的集群容错模式，这个对于很多应用都是迫切希望的，只需要通过简单的配置就能够实现分布式服务调用，也就是说服务提供方（Provider）发布的服务可以天然就是集群服务，比如，在实时性要求很高的应用场景下，可能希望来自消费方（Consumer）的调用响应时间最短，只需要选择Dubbo的Forking Cluster模式配置，就可以对一个调用请求并行发送到多台对等的提供方（Provider）服务所在的节点上，只选择最快一个返回响应的，然后将调用结果返回给服务消费方（Consumer），显然这种方式是以冗余服务为基础的，需要消耗更多的资源，但是能够满足高实时应用的需求。
有关Dubbo服务框架的简单使用，可以参考我的其他两篇文章（《基于Dubbo的Hessian协议实现远程调用》，《Dubbo实现RPC调用使用入门》，后面参考链接中已给出链接），这里主要围绕Dubbo分布式服务相关配置的使用来说明与实践。
Dubbo服务集群容错
假设我们使用的是单机模式的Dubbo服务，如</p>]]></content:encoded>
			<wfw:commentRss>http://shiyanjun.cn/archives/1075.html/feed</wfw:commentRss>
		<slash:comments>28</slash:comments>
		</item>
		<item>
		<title>基于Thrift实现跨语言服务</title>
		<link>http://shiyanjun.cn/archives/456.html</link>
		<comments>http://shiyanjun.cn/archives/456.html#comments</comments>
		<pubDate>Fri, 18 Oct 2013 09:26:21 +0000</pubDate>
		<dc:creator><![CDATA[Yanjun]]></dc:creator>
				<category><![CDATA[Dubbo/Akka/Thrift]]></category>
		<category><![CDATA[开源技术]]></category>
		<category><![CDATA[Thrift]]></category>

		<guid isPermaLink="false">http://shiyanjun.cn/?p=456</guid>
		<description><![CDATA[<p>假设，现在我们有这样一个需求：
要通过一个代理平台，将查询请求转发到后端服务器进行查询。后端存在多种查询服务器，查询方式也不同，比如，有基于SQL的关系数据库查询，也有基于搜索引擎Solr的查询。通过代理平台，将
服务暴露给具有任何编程语言技能的开发人员进行调用。
我们可以选择Thrift来定义语言中性的服务接口，然后通过Thrift编译器将定义生成多种编程语言的客户端代码框架，服务器端使用指定语言进行开发，如Java，最后通过连接Thrift服务器来进行查
询调用。
根据我们的需求，后端服务使用Java实现，而外部使用C#进行调用返回结果，再执行进一步的处理。
Thrift服务定义
首先，看一下，我们给出的示例服务定义，文件命名为queryproxy.thrift，内容如下所示：
上面定义的内容的含义如下所示：

QueryType 指定查询类型，包括两种类型：查询Solr服务器，或SQL查询
QueryParams 用来设置请求参数
QueryResult 是返回结果对象，封装了查询结果列表，我们将查询结果以JSON列表形式返回
QueryFailureException 如果查询失败，返回该异常
QueryProxyService </p>]]></description>
	<p>假设，现在我们有这样一个需求：
要通过一个代理平台，将查询请求转发到后端服务器进行查询。后端存在多种查询服务器，查询方式也不同，比如，有基于SQL的关系数据库查询，也有基于搜索引擎Solr的查询。通过代理平台，将
服务暴露给具有任何编程语言技能的开发人员进行调用。
我们可以选择Thrift来定义语言中性的服务接口，然后通过Thrift编译器将定义生成多种编程语言的客户端代码框架，服务器端使用指定语言进行开发，如Java，最后通过连接Thrift服务器来进行查
询调用。
根据我们的需求，后端服务使用Java实现，而外部使用C#进行调用返回结果，再执行进一步的处理。
Thrift服务定义
首先，看一下，我们给出的示例服务定义，文件命名为queryproxy.thrift，内容如下所示：

namespace java org.shirdrn.queryproxy.thrift.protocol
namespace csharp Query.Proxy.Thrift.Protocol
namespace py queryproxy.thrift.protocol

typedef i16 short
typedef i32 int
typedef i64 long

enum QueryType {
     SOLR = 1,
     SQL = 2
}

struct QueryPara</p>			<content:encoded><![CDATA[<p>假设，现在我们有这样一个需求：
要通过一个代理平台，将查询请求转发到后端服务器进行查询。后端存在多种查询服务器，查询方式也不同，比如，有基于SQL的关系数据库查询，也有基于搜索引擎Solr的查询。通过代理平台，将
服务暴露给具有任何编程语言技能的开发人员进行调用。
我们可以选择Thrift来定义语言中性的服务接口，然后通过Thrift编译器将定义生成多种编程语言的客户端代码框架，服务器端使用指定语言进行开发，如Java，最后通过连接Thrift服务器来进行查
询调用。
根据我们的需求，后端服务使用Java实现，而外部使用C#进行调用返回结果，再执行进一步的处理。
Thrift服务定义
首先，看一下，我们给出的示例服务定义，文件命名为queryproxy.thrift，内容如下所示：
上面定义的内容的含义如下所示：

QueryType 指定查询类型，包括两种类型：查询Solr服务器，或SQL查询
QueryParams 用来设置请求参数
QueryResult 是返回结果对象，封装了查询结果列表，我们将查询结果以JSON列表形式返回
QueryFailureException 如果查询失败，返回该异常
QueryProxyService </p>]]></content:encoded>
			<wfw:commentRss>http://shiyanjun.cn/archives/456.html/feed</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>基于Dubbo的Hessian协议实现远程调用</title>
		<link>http://shiyanjun.cn/archives/349.html</link>
		<comments>http://shiyanjun.cn/archives/349.html#comments</comments>
		<pubDate>Thu, 05 Sep 2013 12:03:16 +0000</pubDate>
		<dc:creator><![CDATA[Yanjun]]></dc:creator>
				<category><![CDATA[Dubbo/Akka/Thrift]]></category>
		<category><![CDATA[开源技术]]></category>
		<category><![CDATA[Hessian]]></category>

		<guid isPermaLink="false">http://shiyanjun.cn/?p=349</guid>
		<description><![CDATA[<p>Dubbo基于Hessian实现了自己Hessian协议，可以直接通过配置的Dubbo内置的其他协议，在服务消费方进行远程调用，也就是说，服务调用方需要使用Java语言来基于Dubbo调用提供方服务，限制了服务调用方。同时，使用Dubbo的Hessian协议实现提供方服务，而调用方可以使用标准的Hessian接口来调用，原生的Hessian协议已经支持多语言客户端调用，支持语言如下所示：

Java：http://hessian.caucho.com/#Java
Flash/Flex：http://hessian.caucho.com/#FlashFlex
Python：http://hessian.caucho.com/#Python
C++：http://hessian.caucho.com/#C
C#：http://hessian.caucho.com/#NETC
D：http://hessian.caucho.com/#D
Erlang：http://hessian.caucho.com/#Erlang
PHP：http://hessian.caucho.com/#PHP
Ruby：http://hessian.caucho.com/#Ruby
Objective-C：http://hessian.caucho.com/#ObjectiveC

下面，我们的思路是，先基于Dubbo封装的Hessian协议，实现提供方服务和消费方调用服务，双方必须都使用Dubbo来开发；然后，基于Dubbo封装的Hessian协议实现提供方服务，然后服务</p>]]></description>
	<p>Dubbo基于Hessian实现了自己Hessian协议，可以直接通过配置的Dubbo内置的其他协议，在服务消费方进行远程调用，也就是说，服务调用方需要使用Java语言来基于Dubbo调用提供方服务，限制了服务调用方。同时，使用Dubbo的Hessian协议实现提供方服务，而调用方可以使用标准的Hessian接口来调用，原生的Hessian协议已经支持多语言客户端调用，支持语言如下所示：

Java：http://hessian.caucho.com/#Java
Flash/Flex：http://hessian.caucho.com/#FlashFlex
Python：http://hessian.caucho.com/#Python
C++：http://hessian.caucho.com/#C
C#：http://hessian.caucho.com/#NETC
D：http://hessian.caucho.com/#D
Erlang：http://hessian.caucho.com/#Erlang
PHP：http://hessian.caucho.com/#PHP
Ruby：http://hessian.caucho.com/#Ruby
Objective-C：http://hessian.caucho.com/#ObjectiveC

下面，我们的思路是，先基于Dubbo封装的Hessian协议，实现提供方服务和消费方调用服务，双方必须都使用Dubbo来开发；然后，基于Dubbo封装的Hessian协议实现提供方服务，然后服务</p>			<content:encoded><![CDATA[<p>Dubbo基于Hessian实现了自己Hessian协议，可以直接通过配置的Dubbo内置的其他协议，在服务消费方进行远程调用，也就是说，服务调用方需要使用Java语言来基于Dubbo调用提供方服务，限制了服务调用方。同时，使用Dubbo的Hessian协议实现提供方服务，而调用方可以使用标准的Hessian接口来调用，原生的Hessian协议已经支持多语言客户端调用，支持语言如下所示：

Java：http://hessian.caucho.com/#Java
Flash/Flex：http://hessian.caucho.com/#FlashFlex
Python：http://hessian.caucho.com/#Python
C++：http://hessian.caucho.com/#C
C#：http://hessian.caucho.com/#NETC
D：http://hessian.caucho.com/#D
Erlang：http://hessian.caucho.com/#Erlang
PHP：http://hessian.caucho.com/#PHP
Ruby：http://hessian.caucho.com/#Ruby
Objective-C：http://hessian.caucho.com/#ObjectiveC

下面，我们的思路是，先基于Dubbo封装的Hessian协议，实现提供方服务和消费方调用服务，双方必须都使用Dubbo来开发；然后，基于Dubbo封装的Hessian协议实现提供方服务，然后服务</p>]]></content:encoded>
			<wfw:commentRss>http://shiyanjun.cn/archives/349.html/feed</wfw:commentRss>
		<slash:comments>25</slash:comments>
		</item>
		<item>
		<title>Dubbo实现RPC调用使用入门</title>
		<link>http://shiyanjun.cn/archives/341.html</link>
		<comments>http://shiyanjun.cn/archives/341.html#comments</comments>
		<pubDate>Thu, 05 Sep 2013 07:48:51 +0000</pubDate>
		<dc:creator><![CDATA[Yanjun]]></dc:creator>
				<category><![CDATA[Dubbo/Akka/Thrift]]></category>
		<category><![CDATA[开源技术]]></category>

		<guid isPermaLink="false">http://shiyanjun.cn/?p=341</guid>
		<description><![CDATA[<p>使用Dubbo进行远程调用实现服务交互，它支持多种协议，如Hessian、HTTP、RMI、Memcached、Redis、Thrift等等。由于Dubbo将这些协议的实现进行了封装了，无论是服务端（开发服务）还是客户端（调用服务），都不需要关心协议的细节，只需要在配置中指定使用的协议即可，从而保证了服务提供方与服务消费方之间的透明。
另外，如果我们使用Dubbo的服务注册中心组件，这样服务提供方将服务发布到注册的中心，只是将服务的名称暴露给外部，而服务消费方只需要知道注册中心和服务提供方提供的服务名称，就能够透明地调用服务，后面我们会看到具体提供服务和消费服务的配置内容，使得双方之间交互的透明化。
示例场景
我们给出一个示例的应用场景：
服务方提供一个搜索服务，对服务方来说，它基于SolrCloud构建了搜索服务，包含两个集群，ZooKeeper集群和Solr集群，然后在前端通过Nginx来进行反向代理，达到负载均衡的目的。
服务消费方就是调用服务进行查询，给出查询条件（满足Solr的REST-like接口）。
应用设计
基于上面的示例场景，我们打算使用ZooKeeper集群作为服务注</p>]]></description>
	<p>使用Dubbo进行远程调用实现服务交互，它支持多种协议，如Hessian、HTTP、RMI、Memcached、Redis、Thrift等等。由于Dubbo将这些协议的实现进行了封装了，无论是服务端（开发服务）还是客户端（调用服务），都不需要关心协议的细节，只需要在配置中指定使用的协议即可，从而保证了服务提供方与服务消费方之间的透明。
另外，如果我们使用Dubbo的服务注册中心组件，这样服务提供方将服务发布到注册的中心，只是将服务的名称暴露给外部，而服务消费方只需要知道注册中心和服务提供方提供的服务名称，就能够透明地调用服务，后面我们会看到具体提供服务和消费服务的配置内容，使得双方之间交互的透明化。
示例场景
我们给出一个示例的应用场景：
服务方提供一个搜索服务，对服务方来说，它基于SolrCloud构建了搜索服务，包含两个集群，ZooKeeper集群和Solr集群，然后在前端通过Nginx来进行反向代理，达到负载均衡的目的。
服务消费方就是调用服务进行查询，给出查询条件（满足Solr的REST-like接口）。
应用设计
基于上面的示例场景，我们打算使用ZooKeeper集群作为服务注</p>			<content:encoded><![CDATA[<p>使用Dubbo进行远程调用实现服务交互，它支持多种协议，如Hessian、HTTP、RMI、Memcached、Redis、Thrift等等。由于Dubbo将这些协议的实现进行了封装了，无论是服务端（开发服务）还是客户端（调用服务），都不需要关心协议的细节，只需要在配置中指定使用的协议即可，从而保证了服务提供方与服务消费方之间的透明。
另外，如果我们使用Dubbo的服务注册中心组件，这样服务提供方将服务发布到注册的中心，只是将服务的名称暴露给外部，而服务消费方只需要知道注册中心和服务提供方提供的服务名称，就能够透明地调用服务，后面我们会看到具体提供服务和消费服务的配置内容，使得双方之间交互的透明化。
示例场景
我们给出一个示例的应用场景：
服务方提供一个搜索服务，对服务方来说，它基于SolrCloud构建了搜索服务，包含两个集群，ZooKeeper集群和Solr集群，然后在前端通过Nginx来进行反向代理，达到负载均衡的目的。
服务消费方就是调用服务进行查询，给出查询条件（满足Solr的REST-like接口）。
应用设计
基于上面的示例场景，我们打算使用ZooKeeper集群作为服务注</p>]]></content:encoded>
			<wfw:commentRss>http://shiyanjun.cn/archives/341.html/feed</wfw:commentRss>
		<slash:comments>22</slash:comments>
		</item>
		<item>
		<title>Dubbo架构设计详解</title>
		<link>http://shiyanjun.cn/archives/325.html</link>
		<comments>http://shiyanjun.cn/archives/325.html#comments</comments>
		<pubDate>Tue, 03 Sep 2013 13:26:59 +0000</pubDate>
		<dc:creator><![CDATA[Yanjun]]></dc:creator>
				<category><![CDATA[Dubbo/Akka/Thrift]]></category>
		<category><![CDATA[开源技术]]></category>

		<guid isPermaLink="false">http://shiyanjun.cn/?p=325</guid>
		<description><![CDATA[<p>Dubbo是Alibaba开源的分布式服务框架，它最大的特点是按照分层的方式来架构，使用这种方式可以使各个层之间解耦合（或者最大限度地松耦合）。从服务模型的角度来看，Dubbo采用的是一种非常简单的模型，要么是提供方提供服务，要么是消费方消费服务，所以基于这一点可以抽象出服务提供方（Provider）和服务消费方（Consumer）两个角色。关于注册中心、协议支持、服务监控等内容，详见后面描述。
总体架构
Dubbo的总体架构，如图所示：

Dubbo框架设计一共划分了10个层，而最上面的Service层是留给实际想要使用Dubbo开发分布式服务的开发者实现业务逻辑的接口层。图中左边淡蓝背景的为服务消费方使用的接口，右边淡绿色背景的为服务提供方使用的接口， 位于中轴线上的为双方都用到的接口。
下面，结合Dubbo官方文档，我们分别理解一下框架分层架构中，各个层次的设计要点：

服务接口层（Service）：该层是与实际业务逻辑相关的，根据服务提供方和服务消费方的业务设计对应的接口和实现。
配置层（Config）：对外配置接口，以ServiceConfig和ReferenceConfig为中心，可</p>]]></description>
	<p>Dubbo是Alibaba开源的分布式服务框架，它最大的特点是按照分层的方式来架构，使用这种方式可以使各个层之间解耦合（或者最大限度地松耦合）。从服务模型的角度来看，Dubbo采用的是一种非常简单的模型，要么是提供方提供服务，要么是消费方消费服务，所以基于这一点可以抽象出服务提供方（Provider）和服务消费方（Consumer）两个角色。关于注册中心、协议支持、服务监控等内容，详见后面描述。
总体架构
Dubbo的总体架构，如图所示：

Dubbo框架设计一共划分了10个层，而最上面的Service层是留给实际想要使用Dubbo开发分布式服务的开发者实现业务逻辑的接口层。图中左边淡蓝背景的为服务消费方使用的接口，右边淡绿色背景的为服务提供方使用的接口， 位于中轴线上的为双方都用到的接口。
下面，结合Dubbo官方文档，我们分别理解一下框架分层架构中，各个层次的设计要点：

服务接口层（Service）：该层是与实际业务逻辑相关的，根据服务提供方和服务消费方的业务设计对应的接口和实现。
配置层（Config）：对外配置接口，以ServiceConfig和ReferenceConfig为中心，可</p>			<content:encoded><![CDATA[<p>Dubbo是Alibaba开源的分布式服务框架，它最大的特点是按照分层的方式来架构，使用这种方式可以使各个层之间解耦合（或者最大限度地松耦合）。从服务模型的角度来看，Dubbo采用的是一种非常简单的模型，要么是提供方提供服务，要么是消费方消费服务，所以基于这一点可以抽象出服务提供方（Provider）和服务消费方（Consumer）两个角色。关于注册中心、协议支持、服务监控等内容，详见后面描述。
总体架构
Dubbo的总体架构，如图所示：

Dubbo框架设计一共划分了10个层，而最上面的Service层是留给实际想要使用Dubbo开发分布式服务的开发者实现业务逻辑的接口层。图中左边淡蓝背景的为服务消费方使用的接口，右边淡绿色背景的为服务提供方使用的接口， 位于中轴线上的为双方都用到的接口。
下面，结合Dubbo官方文档，我们分别理解一下框架分层架构中，各个层次的设计要点：

服务接口层（Service）：该层是与实际业务逻辑相关的，根据服务提供方和服务消费方的业务设计对应的接口和实现。
配置层（Config）：对外配置接口，以ServiceConfig和ReferenceConfig为中心，可</p>]]></content:encoded>
			<wfw:commentRss>http://shiyanjun.cn/archives/325.html/feed</wfw:commentRss>
		<slash:comments>36</slash:comments>
		</item>
		<item>
		<title>CentOS安装和使用Thrift</title>
		<link>http://shiyanjun.cn/archives/107.html</link>
		<comments>http://shiyanjun.cn/archives/107.html#comments</comments>
		<pubDate>Thu, 22 Aug 2013 15:08:23 +0000</pubDate>
		<dc:creator><![CDATA[Yanjun]]></dc:creator>
				<category><![CDATA[Dubbo/Akka/Thrift]]></category>
		<category><![CDATA[开源技术]]></category>
		<category><![CDATA[Thrift]]></category>

		<guid isPermaLink="false">http://shirdrn.org/?p=107</guid>
		<description><![CDATA[<p>Thrift是Apache的一个开源的跨语言服务开发框架，它提供了一个代码生成引擎来构建服务，支持C++，Java，Python，PHP，Ruby，Erlang，Perl，Haskell，C#，Cocoa，JavaScript，Node.js，Smalltalk，OCaml，Delphi等多种编程语言。
一般来说，使用Thrift来开发应用程序，主要建立在两种场景下：

第一，在我们开发过程中，一个比较大的项目需要多个团队进行协作，而每个团队的成员在编程技术方面的技能可能不一定相同，为了实现这种跨语言的开发氛围，使用Thrift来构建服务
第二，企业之间合作，在业务上不可避免出现跨语言的编程环境，使用Thrift可以达到类似Web Services的跨平台的特性

安装配置Thrift
Thrift的编译器使用C++编写的，在安装编译器之前，首先应该保证操作系统基本环境支持C++的编译，安装相关依赖的软件包，如下所示
下载Thrift的软件包，并解压缩：
配置、编译、安装Thrift，如下所示：
如果在配置的时候总是报如下错误：
如果需要的话，可以运行测试用例：
安装成功以后，可以输入如下命令行进行验证：
使用Thrift
我们直接使用Thrift官网提供的简</p>]]></description>
	<p>Thrift是Apache的一个开源的跨语言服务开发框架，它提供了一个代码生成引擎来构建服务，支持C++，Java，Python，PHP，Ruby，Erlang，Perl，Haskell，C#，Cocoa，JavaScript，Node.js，Smalltalk，OCaml，Delphi等多种编程语言。
一般来说，使用Thrift来开发应用程序，主要建立在两种场景下：

第一，在我们开发过程中，一个比较大的项目需要多个团队进行协作，而每个团队的成员在编程技术方面的技能可能不一定相同，为了实现这种跨语言的开发氛围，使用Thrift来构建服务
第二，企业之间合作，在业务上不可避免出现跨语言的编程环境，使用Thrift可以达到类似Web Services的跨平台的特性

安装配置Thrift
Thrift的编译器使用C++编写的，在安装编译器之前，首先应该保证操作系统基本环境支持C++的编译，安装相关依赖的软件包，如下所示

sudo yum install automake libtool flex bison pkgconfig gcc-c++ boost-devel libevent-devel zlib-devel python-devel ruby-devel openssl-devel

下载Thrift的软件包，并解压缩：

wget http://mirrors.cnnic.cn/apache/thri</p>			<content:encoded><![CDATA[<p>Thrift是Apache的一个开源的跨语言服务开发框架，它提供了一个代码生成引擎来构建服务，支持C++，Java，Python，PHP，Ruby，Erlang，Perl，Haskell，C#，Cocoa，JavaScript，Node.js，Smalltalk，OCaml，Delphi等多种编程语言。
一般来说，使用Thrift来开发应用程序，主要建立在两种场景下：

第一，在我们开发过程中，一个比较大的项目需要多个团队进行协作，而每个团队的成员在编程技术方面的技能可能不一定相同，为了实现这种跨语言的开发氛围，使用Thrift来构建服务
第二，企业之间合作，在业务上不可避免出现跨语言的编程环境，使用Thrift可以达到类似Web Services的跨平台的特性

安装配置Thrift
Thrift的编译器使用C++编写的，在安装编译器之前，首先应该保证操作系统基本环境支持C++的编译，安装相关依赖的软件包，如下所示
下载Thrift的软件包，并解压缩：
配置、编译、安装Thrift，如下所示：
如果在配置的时候总是报如下错误：
如果需要的话，可以运行测试用例：
安装成功以后，可以输入如下命令行进行验证：
使用Thrift
我们直接使用Thrift官网提供的简</p>]]></content:encoded>
			<wfw:commentRss>http://shiyanjun.cn/archives/107.html/feed</wfw:commentRss>
		<slash:comments>4</slash:comments>
		</item>
	</channel>
</rss>
