zoukankan      html  css  js  c++  java

  • Dubbo+zookeeper构建高可用分布式集群（二）-集群部署

    在Dubbo+zookeeper构建高可用分布式集群（一）-单机部署中我们讲了如何单机部署。但没有将如何配置微服务。下面分别介绍单机与集群微服务如何配置注册中心。

    Zookeeper单机配置：
    方式一、

    <dubbo:registry
address="zookeeper://10.20.153.10:2181"/>

    方式二、

    <dubbo:registry
protocol="zookeeper"
address="10.20.153.10:2181"/>

    Zookeeper集群配置:

    方式一、

    <dubbo:registry address="zookeeper://10.20.153.10:2181?backup=10.20.153.11:2181,10.20.153.12:2181"/>

    方式二、

    <dubbo:registry 
protocol="zookeeper"
address="10.20.153.10:2181,10.20.153.11:2181,10.20.153.12/>

    集群配置方式一，特别适用于dubbo-admin 和dubbo-monitor

    Zookeeper是什么：

    Zookeeper,一种分布式应用的协作服务,是Google的Chubby一个开源的实现,是Hadoop的分布式协调服务,它包含一个简单的原语集,应用于分布式应用的协作服务,使得分布式应用可以基于这些接口实现诸如同步、配置维护和分集群或者命名的服务。

    zookeeper是一个由多个service组成的集群,一个leader,多个follower,每个server保存一份数据部分,全局数据一致,分布式读写,更新请求转发由leader实施.

    更新请求顺序进行,来自同一个client的更新请求按其发送顺序依次执行,数据更新原子性,一次数据更新要么成功,要么失败,全局唯一数据试图,client无论连接到哪个server,数据试图是一致的.

    为什么要用zookeeper

    大部分分布式应用需要一个主控、协调器或控制器来管理物理分布的子进程（如资源、任务分配等）,目前,大部分应用需要开发私有的协调程序,缺乏一个通用的机制.协调程序的反复编写浪费,且难以形成通用、伸缩性好的协调器,ZooKeeper：提供通用的分布式锁服务,用以协调分布式应用

    zookeeper工作原理

    zookeeper的核心是原子广播,这个机制保证了各个server之间的同步,实现这个机制的协议叫做Zab协议.Zab协议有两种模式,他们分别是恢复模式和广播模式.

    　 1.当服务启动或者在领导者崩溃后,Zab就进入了恢复模式,当领导着被选举出来,且大多数server都完成了和leader的状态同步后,恢复模式就结束了.状态同步保证了leader和server具有相同的系统状态.

    　 2.一旦leader已经和多数的follower进行了状态同步后,他就可以开始广播消息了,即进入广播状态.这时候当一个server加入zookeeper服务中,它会在恢复模式下启动,发下leader,并和leader进行状态同步,待到同步结束,它也参与广播消息.

    说明:

        广播模式需要保证proposal被按顺序处理,因此zk采用了递增的事务id号(zxid)来保证.所有的提议(proposal)都在被提出的时候加上了zxid.实现中zxid是一个64为的数字,它高32位是epoch用来标识leader关系是否改变,每次一个leader被选出来,它都会有一个新的epoch.低32位是个递增计数.

        当leader崩溃或者leader失去大多数的follower,这时候zk进入恢复模式,恢复模式需要重新选举出一个新的leader,让所有的server都恢复到一个正确的状态.

        zookeeper服务一致维持在Broadcast状态,直到leader崩溃了或者leader失去了大部分的followers支持.

        Broadcast模式极其类似于分布式事务中的2pc（two-phrase commit两阶段提交）：即leader提起一个决议,由followers进行投票,leader对投票结果进行计算决定是否通过该决议,如果通过执行该决议（事务）,否则什么也不做.

    Leader选举

    每个Server启动以后都询问其它的Server它要投票给谁,对于其他server的询问,server每次根据自己的状态都回复自己推荐的leader的id和上一次处理事务的zxid（系统启动时每个server都会推荐自己）,收到所有Server回复以后,就计算出zxid最大的哪个Server,并将这个Server相关信息设置成下一次要投票的Server.计算这过程中获得票数最多的的sever为获胜者,如果获胜者的票数超过半数,则改server被选为leader.否则,继续这个过程,直到leader被选举出来.leader就会开始等待server连接,Follower连接leader,将最大的zxid发送给leader,Leader根据follower的zxid确定同步点,完成同步后通知follower已经成为uptodate状态,Follower收到uptodate消息后,又可以重新接受client的请求进行服务了.

    zookeeper的数据模型

    层次化的目录结构,命名符合常规文件系统规范

    每个节点在zookeeper中叫做znode,并且其有一个唯一的路径标识

    节点Znode可以包含数据和子节点,但是EPHEMERAL类型的节点不能有子节点

    Znode中的数据可以有多个版本,比如某一个路径下存有多个数据版本,那么查询这个路径下的数据就需要带上版本

    客户端应用可以在节点上设置监视器,节点不支持部分读写,而是一次性完整读写

    Zoopkeeper 提供了一套很好的分布式集群管理的机制,就是它这种基于层次型的目录树的数据结构,并对树中的节点进行有效管理,从而可以设计出多种多样的分布式的数据管理模型

    Zookeeper的节点

    Znode有两种类型,短暂的（ephemeral）和持久的（persistent）

    Znode的类型在创建时确定并且之后不能再修改

    短暂znode的客户端会话结束时,zookeeper会将该短暂znode删除,短暂znode不可以有子节点

    持久znode不依赖于客户端会话,只有当客户端明确要删除该持久znode时才会被删除

    Znode有四种形式的目录节点,PERSISTENT、PERSISTENT_SEQUENTIAL、EPHEMERAL、EPHEMERAL_SEQUENTIAL.

    znode 可以被监控,包括这个目录节点中存储的数据的修改,子节点目录的变化等,一旦变化可以通知设置监控的客户端,这个功能是zookeeper对于应用最重要的特性,

    通过这个特性可以实现的功能包括配置的集中管理,集群管理,分布式锁等等.

    Zookeeper的角色

    领导者（leader）,负责进行投票的发起和决议,更新系统状态

    学习者（learner）,包括跟随者（follower）和观察者（observer）.

    follower用于接受客户端请求并想客户端返回结果,在选主过程中参与投票

    Observer可以接受客户端连接,将写请求转发给leader,但observer不参加投票过程,只同步leader的状态,observer的目的是为了扩展系统,提高读取速度

    客户端（client）,请求发起方

    Watcher

    Watcher 在 ZooKeeper是一个核心功能,Watcher可以监控目录节点的数据变化以及子目录的变化,一旦这些状态发生变化,服务器就会通知所有设置在这个目录节点上的Watcher,从而每个客户端都很快知道它所关注的目录节点的状态发生变化,而做出相应的反应

    可以设置观察的操作：exists,getChildren,getData

    可以触发观察的操作：create,delete,setData

    znode以某种方式发生变化时,“观察”（watch）机制可以让客户端得到通知.

    可以针对ZooKeeper服务的“操作”来设置观察,该服务的其他 操作可以触发观察.

    比如,客户端可以对某个客户端调用exists操作,同时在它上面设置一个观察,如果此时这个znode不存在,则exists返回false,如果一段时间之后,这个znode被其他客户端创建,则这个观察会被触发,之前的那个客户端就会得到通知.

    Zookeeper集群搭建

    Zookeeper 不仅可以单机提供服务,同时也支持多机组成集群来提供服务,实际上Zookeeper还支持另外一种伪集群的方式,也就是可以在一台物理机上运行多个Zookeeper实例.

    Zookeeper通过复制来实现高可用性,只要集合体中半数以上的机器处于可用状态,它就能够保证服务继续。

    集群容灾性:

    　3台机器只要有2台可用就可以选出leader并且对外提供服务(2n+1台机器,可以容n台机器挂掉)。

    Zookeeper伪分布式环境搭建:

    1、去Zookeeper官网下载最新版本的Zookeeper.

    [root@localhost zookeeper-cluster]# pwd

    /export/search/zookeeper-cluster

    [root@localhost zookeeper-cluster]# ls

    zookeeper-3.4.6.tar.gz

    [root@localhost zookeeper-cluster]#

    [root@localhost zookeeper-cluster]# tar -zxvf zookeeper-3.4.6.tar.gz

    #创建第一个集群节点

    [root@localhost zookeeper-cluster]# mv zookeeper-3.4.6 zookeeper-3.4.6-node1

    [root@localhost zookeeper-cluster]# cd zookeeper-3.4.6-node1

    [root@localhost zookeeper-3.4.6-node1]# pwd

    /export/search/zookeeper-cluster/zookeeper-3.4.6-node1

    #创建数据存放路径

    [root@localhost zookeeper-3.4.6-node1]# mkdir data

    [root@localhost zookeeper-3.4.6-node1]# cd ../

    #创建第二第三个集群节点

    [root@localhost zookeeper-cluster]# cp zookeeper-3.4.6-node1 zookeeper-3.4.6-node2 -R

    [root@localhost zookeeper-cluster]# cp zookeeper-3.4.6-node1 zookeeper-3.4.6-node3 -R

    [root@localhost zookeeper-cluster]# ls

    zookeeper-3.4.6-node1  zookeeper-3.4.6-node2  zookeeper-3.4.6-node3  zookeeper-3.4.6.tar.gz

    [root@localhost zookeeper-cluster]# cd zookeeper-3.4.6-node1/conf/

    [root@localhost conf]# ls

    configuration.xsl  log4j.properties  zoo_sample.cfg

    #创建zoo.cfg文件

    [root@localhost conf]# cp zoo_sample.cfg zoo.cfg

    2、配置zoo.cfg文件:

    #zookeeper-3.4.6-node1的配置

    tickTime=2000

    initLimit=10

    syncLimit=5

    clientPort=2181

    dataDir=/export/search/zookeeper-cluster/zookeeper-3.4.6-node1/data

    server.1=localhost:2887:3887

    server.2=localhost:2888:3888

    server.3=localhost:2889:3889

    #zookeeper-3.4.6-node2的配置

    tickTime=2000

    initLimit=10

    syncLimit=5

    clientPort=2182

    dataDir=/export/search/zookeeper-cluster/zookeeper-3.4.6-node2/data

    server.1=localhost:2887:3887

    server.2=localhost:2888:3888

    server.3=localhost:2889:3889

    #zookeeper-3.4.6-node3的配置

    tickTime=2000

    initLimit=10

    syncLimit=5

    clientPort=2183

    dataDir=/export/search/zookeeper-cluster/zookeeper-3.4.6-node3/data

    server.1=localhost:2887:3887

    server.2=localhost:2888:3888

    server.3=localhost:2889:3889

    参数说明:

    tickTime=2000:

    tickTime这个时间是作为Zookeeper服务器之间或客户端与服务器之间维持心跳的时间间隔,也就是每个tickTime时间就会发送一个心跳；

    initLimit=10:

    initLimit这个配置项是用来配置Zookeeper接受客户端（这里所说的客户端不是用户连接Zookeeper服务器的客户端,而是Zookeeper服务器集群中连接到Leader的Follower服务器）初始化连接时最长能忍受多少个心跳时间间隔数。

    当已经超过10个心跳的时间（也就是tickTime）长度后Zookeeper 服务器还没有收到客户端的返回信息,那么表明这个客户端连接失败。总的时间长度就是10*2000=20 秒；

    syncLimit=5:

    syncLimit这个配置项标识Leader与Follower之间发送消息,请求和应答时间长度,最长不能超过多少个tickTime的时间长度,总的时间长度就是5*2000=10秒；

    dataDir=/export/search/zookeeper-cluster/zookeeper-3.4.6-node1/data

    dataDir顾名思义就是Zookeeper保存数据的目录,默认情况下Zookeeper将写数据的日志文件也保存在这个目录里；

    clientPort=2181

    clientPort这个端口就是客户端连接Zookeeper服务器的端口,Zookeeper会监听这个端口接受客户端的访问请求；

    server.1=localhost:2887:3887

    server.2=localhost:2888:3888

    server.3=localhost:2889:3889

    server.A=B：C：D：

    A是一个数字,表示这个是第几号服务器,B是这个服务器的ip地址

    C第一个端口用来集群成员的信息交换,表示的是这个服务器与集群中的Leader服务器交换信息的端口

    D是在leader挂掉时专门用来进行选举leader所用

    3、创建ServerID标识

    除了修改zoo.cfg配置文件,集群模式下还要配置一个文件myid,这个文件在dataDir目录下,这个文件里面就有一个数据就是A的值,在上面配置文件中zoo.cfg中配置的dataDir路径中创建myid文件

    [root@localhost zookeeper-cluster]# cat /export/search/zookeeper-cluster/zookeeper-3.4.6-node1/data/myid

    1

    [root@localhost zookeeper-cluster]# cat /export/search/zookeeper-cluster/zookeeper-3.4.6-node2/data/myid

    2

    [root@localhost zookeeper-cluster]# cat /export/search/zookeeper-cluster/zookeeper-3.4.6-node3/data/myid

    3

    4、启动zookeeper

    [root@localhost zookeeper-cluster]# /export/search/zookeeper-cluster/zookeeper-3.4.6-node1/bin/zkServer.sh start

    JMX enabled by default

    Using config: /export/search/zookeeper-cluster/zookeeper-3.4.6-node1/bin/../conf/zoo.cfg

    Starting zookeeper ... STARTED

    [root@localhost zookeeper-cluster]# /export/search/zookeeper-cluster/zookeeper-3.4.6-node2/bin/zkServer.sh start

    JMX enabled by default

    Using config: /export/search/zookeeper-cluster/zookeeper-3.4.6-node2/bin/../conf/zoo.cfg

    Starting zookeeper ... STARTED

    [root@localhost zookeeper-cluster]# /export/search/zookeeper-cluster/zookeeper-3.4.6-node3/bin/zkServer.sh start

    JMX enabled by default

    Using config: /export/search/zookeeper-cluster/zookeeper-3.4.6-node3/bin/../conf/zoo.cfg

    Starting zookeeper ... STARTED

    5、检测集群是否启动

    [root@localhost zookeeper-cluster]# echo stat|nc localhost 2181

    [root@localhost zookeeper-cluster]# echo stat|nc localhost 2182

    [root@localhost zookeeper-cluster]# echo stat|nc localhost 2183

    #或者

    [root@localhost zookeeper-cluster]# /export/search/zookeeper-cluster/zookeeper-3.4.6-node1/bin/zkCli.sh

    [root@localhost zookeeper-cluster]# /export/search/zookeeper-cluster/zookeeper-3.4.6-node2/bin/zkCli.sh

    [root@localhost zookeeper-cluster]# /export/search/zookeeper-cluster/zookeeper-3.4.6-node3/bin/zkCli.sh

    伪集群部署注意事项:

    在一台机器上部署了3个server；需要注意的是clientPort这个端口，如果在1台机器上部署多个server,那么每个server都要有不同的clientPort.

    比如 server.1是2181,server.2是2182,server.3是2183

    最后几行唯一需要注意的地方就是

    server.X 这个数字就是对应 data/myid中的数字。你在3个server的myid文件中分别写入了1,2,3,那么每个server中的zoo.cfg都配server.1,server.2,server.3就OK了

    集成dubbo时的配置：

    提供者：

    <dubbo:registry protocol="zookeeper"  address="192.168.8.101:2181,192.168.8.101:2182,192.168.8.101:2183" />

    消费者：

    <dubbo:registry protocol="zookeeper"   address="192.168.8.101:2181,192.168.8.101:2182,192.168.8.101:2183" />

    具体详情可以参考：https://github.com/alibaba/dubbo

    第二步：下载，配置dubbo的管理项目
     
    2.1 下载 dubbo admin 项目 地址：http://dubbo.io/Download-zh.htm
     
    2.2 解压，取出war包。
    2.3 拷贝一个tomcat，改一下端口号（用默认容易和其他的tomcat端口冲突）
     
    2.4 删除 tomcat webapp 目录下面的文件，将dubbo admin 包解压内容放到root目录中，修改classpath 目录下的dubbo.properties， 将这个监测中心注册到zookeeper，即将dubbo.registry.address改成你安装zookeeper的机子IP+zookeeper配置的端口。我这里是一台机子演示，默认端口与zookeeper是一致的所以不用修改。用户名密码就没有改动的必要了。
     
     
    2.5 bin目录启动tomcat，输入这个tomat的访问网址 http://localhost:8180/ （端口号注意修改成你自己改的那个）,然后登陆密码都是就是上面配置文件中的，root  root登录
     
    这里可以看到，提供者为0，消费者为0
     

    第三步：创建提供者

    3.1：创建公用接口项目 service，创建两个provider （provider01，provider02）
     
     
    service包，公用接口，很简单，就是个maven基础java包，不需要加入任何依赖，也不需要加入任何配置文件
    [html] view plain copy
     
    1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
    2.   <modelVersion>4.0.0</modelVersion>  
    3.   <groupId>com.test</groupId>  
    4.   <artifactId>service</artifactId>  
    5.   <version>0.0.1-SNAPSHOT</version>  
    6. </project>  
     
     
    2个provider包引入service依赖，且需要引入dubbo，zookeeper，log4依赖，这里不需要引入Spring，dubbo自带依赖，不过版本很旧，也可以自己手动移除然后引入新版本Spring。下面给出其中一个的pom实例，copy请自行修改artifactId
    pom.xml：
    [html] view plain copy
     
    1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    2.     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">  
    3.     <modelVersion>4.0.0</modelVersion>  
    4.     <groupId>com.test</groupId>  
    5.     <artifactId>provider02</artifactId>  
    6.     <version>0.0.1-SNAPSHOT</version>  
    7.   
    8.     <dependencies>  
    9.         <dependency>  
    10.             <groupId>com.test</groupId>  
    11.             <artifactId>service</artifactId>  
    12.             <version>0.0.1-SNAPSHOT</version>  
    13.         </dependency>  
    14.         <dependency>  
    15.             <groupId>com.alibaba</groupId>  
    16.             <artifactId>dubbo</artifactId>  
    17.             <version>2.5.3</version>  
    18.         </dependency>  
    19.         <dependency>  
    20.             <groupId>org.apache.zookeeper</groupId>  
    21.             <artifactId>zookeeper</artifactId>  
    22.             <version>3.3.3</version>  
    23.         </dependency>  
    24.   
    25.         <!-- 日志相关 -->  
    26.         <dependency>  
    27.             <groupId>log4j</groupId>  
    28.             <artifactId>log4j</artifactId>  
    29.             <version>1.2.16</version>  
    30.         </dependency>  
    31.   
    32.         <dependency>  
    33.             <groupId>org.slf4j</groupId>  
    34.             <artifactId>slf4j-api</artifactId>  
    35.             <version>1.7.5</version>  
    36.         </dependency>  
    37.   
    38.         <!-- zookeeper client依赖，用于向zookeeper注册服务 -->  
    39.         <dependency>  
    40.             <groupId>com.github.sgroschupf</groupId>  
    41.             <artifactId>zkclient</artifactId>  
    42.             <version>0.1</version>  
    43.         </dependency>  
    44.   
    45.     </dependencies>  
    46.   
    47.     <build>  
    48.         <pluginManagement>  
    49.             <plugins>  
    50.                 <plugin>  
    51.                     <groupId>org.apache.maven.plugins</groupId>  
    52.                     <artifactId>maven-jar-plugin</artifactId>  
    53.                     <configuration>  
    54.                         <source>1.8</source>  
    55.                         <target>1.8</target>  
    56.                         <archive>  
    57.                             <manifest>  
    58.                                 <mainClass>com.test.provider.Provider</mainClass>  
    59.                                 <addClasspath>true</addClasspath>  
    60.                                 <classpathPrefix>lib/</classpathPrefix>  
    61.                             </manifest>  
    62.   
    63.                         </archive>  
    64.                         <classesDirectory>  
    65.                         </classesDirectory>  
    66.                     </configuration>  
    67.                 </plugin>  
    68.             </plugins>  
    69.         </pluginManagement>  
    70.     </build>  
    71.   
    72. </project>  


    3.2  在service公有服务接口包中新建接口TestService,内容很简单，就包含一个测试接口
    TestService.java：
    [java] view plain copy
     
    1. package com.test.service;  
    2.   
    3. /** 
    4.  * @author xianghui1 
    5.  * 
    6.  *test 
    7.  */  
    8. public interface TestService {  
    9.   
    10.     public String test();  
    11. }  


     
     
     
    3.3  provider 提供者需要实现这个公用接口以向消费者提供服务，两个provider基本是一样的，除了部分配置
    provider02 ：   TestServiceImpl.java实现公有接口 testService
    [java] view plain copy
     
    1. package com.test.service;  
    2.   
    3. import com.test.service.TestService;  
    4.   
    5. public class TestServiceImpl implements TestService {  
    6.   
    7.     public String test() {  
    8.         System.out.println("test success");  
    9.         return "provider02";  
    10.     }  
    11.   
    12. }  


    provider01 ：   TestServiceImpl.java实现公有接口 testService
    [java] view plain copy
     
    1. package com.test.service;  
    2.   
    3. import com.test.service.TestService;  
    4.   
    5. public class TestServiceImpl implements TestService {  
    6.   
    7.     public String test() {  
    8.         System.out.println("test success");  
    9.         return "provider01";  
    10.     }  
    11.   
    12. }  
     
    2个provider，随意实现，返回效果不同就行了，因为后面要测试集群负载均衡效果
     
    3.4 到这里提供者代码层面基本完了，该项目增加配置文件，在classpath目录下新建3个配置文件：applicationContext.xml（Spring配置文件），log4.properties，provider.xml（dubbo 提供者配置文件，重要）
     
     
    applicationContext.xml：（2个provider一模一样）
    [html] view plain copy
     
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2. <beans xmlns="http://www.springframework.org/schema/beans"  
    3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
    4.     xmlns:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop"  
    5.     xmlns:tx="http://www.springframework.org/schema/tx"  
    6.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd  
    7.     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd   
    8.     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd   
    9.     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">  
    10.       
    11.     <context:component-scan base-package="com.test" />  
    12.       
    13. </beans>  
    log4.properties:(2个provider一样）
    [html] view plain copy
     
    1. log4j.appender.mylog = org.apache.log4j.ConsoleAppender  
    2.   
    3. log4j.appender.mylog.target = System.out  
    4.   
    5. log4j.appender.mylog.layout= org.apache.log4j.PatternLayout  
    6.   
    7. log4j.appender.mylog.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n  
    8.   
    9. log4j.appender.my2log = org.apache.log4j.RollingFileAppender  
    10.   
    11. log4j.appender.my2log.File = D://Logger//mylog.log  
    12.   
    13. log4j.appender.my2log.MaxFileSize = 50KB  
    14.   
    15. log4j.appender.my2log.MaxBackupIndex = 1  
    16.   
    17. log4j.appender.my2log.layout= org.apache.log4j.PatternLayout  
    18.    
    19. log4j.appender.my2log.layout.ConversionPattern=%-d{yyyy-MM-dd HH:mm:ss} [%c]-[%p] %m%n  
    20.   
    21. log4j.rootLogger = info,mylog,my2log  


     
    provider01：    provider.xml
    [html] view plain copy
     
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2. <beans xmlns="http://www.springframework.org/schema/beans"  
    3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    4.     xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"  
    5.     xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd        http://code.alibabatech.com/schema/dubbo        http://code.alibabatech.com/schema/dubbo/dubbo.xsd">  
    6.    
    7.     <!-- 提供方应用信息，用于计算依赖关系 -->  
    8.     <dubbo:application name="provider"  />  
    9.    
    10.     <!-- 使用zookeeper广播注册中心暴露服务地址 -->  
    11.     <dubbo:registry address="zookeeper://127.0.0.1:2181"/>  
    12.    
    13.     <!-- 用dubbo协议在20880端口暴露服务 -->  
    14.     <dubbo:protocol name="dubbo" port="20881" />  
    15.   
    16.     <!-- 和本地bean一样实现服务 -->  
    17.     <bean id="testService" class="com.test.service.TestServiceImpl" />  
    18.       
    19.        
    20.     <!-- 声明需要暴露的服务接口 -->  
    21.     <dubbo:service interface="com.test.service.TestService" ref="testService" />  
    22.    
    23. </beans>  


     
    provider02：    provider.xml
    [html] view plain copy
     
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2. <beans xmlns="http://www.springframework.org/schema/beans"  
    3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"  
    4.     xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd        http://code.alibabatech.com/schema/dubbo        http://code.alibabatech.com/schema/dubbo/dubbo.xsd">  
    5.   
    6.     <!-- 提供方应用信息，用于计算依赖关系 -->  
    7.     <dubbo:application name="provider" />  
    8.   
    9.     <!-- 使用zookeeper广播注册中心暴露服务地址 -->  
    10.     <dubbo:registry address="zookeeper://10.120.106.35:2181" />  
    11.   
    12.     <!-- 用dubbo协议在20880端口暴露服务 -->  
    13.     <dubbo:protocol name="dubbo" port="20882" />  
    14.   
    15.     <!-- 和本地bean一样实现服务 -->  
    16.     <bean id="testService" class="com.test.service.TestServiceImpl" />  
    17.   
    18.   
    19.     <!-- 声明需要暴露的服务接口 -->  
    20.     <dubbo:service interface="com.test.service.TestService" ref="testService" />  
    21.   
    22. </beans>  


     
    这里需要注意，2个provider的应用名，一样，因为模拟集群负载均衡，所以对Dubbo来说是一个服务。2个provider的端口需不一样，因为是同一台机子模拟2个服务，如果是多台就无所谓了。dubbo：Service须保持一致，因为2个provider负载均衡是模拟一个服务，所以提供的服务外面看来须一样。
     
    3.5，业务代码以及配置文件都完成了，该启动2个provider了，新建provider类，并调用main启动，代码如下；
    Provider.java（2个provider一样即可）
    [html] view plain copy
     
    1. package com.test.provider;  
    2.   
    3. import org.apache.log4j.PropertyConfigurator;  
    4. import org.springframework.context.support.ClassPathXmlApplicationContext;  
    5.   
    6. public class Provider {  
    7.     // start provider  
    8.     static{  
    9.         PropertyConfigurator.configure("src/main/resources/log4.properties");  
    10.     }  
    11.     public static void main(String args[]) throws Exception {  
    12.         ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("classpath*:/*.xml");  
    13.         context.start();  
    14.         System.in.read();  
    15.     }  
    16. }  


     
     
    成功启动之后，显示注册到了zookeeper。
     
     
    这个时候我们刷新下dubbo.admin页面看看效果，显示提供者为1，说明一切正常
     
     
    然后启动第二个provider，至这里显示提供者为2，服务数为1，一切OK，下一步我们开始消费者端。
     

    第四步：创建消费者，这里创建2个Spring mvc web项目来充当消费的角色。

    2个消费者（dubbo-consumer01，dubbo-consumer02）也一样，基本一样，就是服务实现不一样来测试负载均衡，还有个消费者配置文件不一样。

    4.1 2个消费者POM.xml基本是一样的，标准的Spring mvc web项目,需要引入dubbo,zookeeper，公有服务service，Spring mvc系列，log4系列。这里需要注意的是，dubbo的Spring实在过于老旧了，对于web项目来说是不合适的，遇到了版本冲突，所以需要剔除dubbo中依赖的spring2.5

    pom.xml（copy请自行修改 groupId与artifactId）：
    [html] view plain copy
     
    1. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    2.   xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">  
    3.   <modelVersion>4.0.0</modelVersion>  
    4.   <groupId>com.test</groupId>  
    5.   <artifactId>dubbo-consumer02</artifactId>  
    6.   <packaging>war</packaging>  
    7.   <version>0.0.1-SNAPSHOT</version>  
    8.   <name>customer02 Maven Webapp</name>  
    9.   <url>http://maven.apache.org</url>  
    10.     <properties>  
    11.         <spring.version>4.3.8.RELEASE</spring.version>  
    12.     </properties>  
    13.   
    14.     <dependencies>  
    15.         <dependency>  
    16.             <groupId>junit</groupId>  
    17.             <artifactId>junit</artifactId>  
    18.             <version>3.8.1</version>  
    19.             <scope>test</scope>  
    20.         </dependency>  
    21.         <dependency>  
    22.             <groupId>com.test</groupId>  
    23.             <artifactId>service</artifactId>  
    24.             <version>0.0.1-SNAPSHOT</version>  
    25.         </dependency>  
    26.         <dependency>  
    27.             <groupId>com.alibaba</groupId>  
    28.             <artifactId>dubbo</artifactId>  
    29.             <version>2.5.3</version>  
    30.             <exclusions>  
    31.                 <exclusion>  
    32.                     <artifactId>spring</artifactId>  
    33.                     <groupId>org.springframework</groupId>  
    34.                 </exclusion>  
    35.             </exclusions>  
    36.         </dependency>  
    37.   
    38.         <!-- spring begin -->  
    39.         <dependency>  
    40.             <groupId>org.springframework</groupId>  
    41.             <artifactId>spring-webmvc</artifactId>  
    42.             <version>${spring.version}</version>  
    43.         </dependency>  
    44.   
    45.         <dependency>  
    46.             <groupId>org.springframework</groupId>  
    47.             <artifactId>spring-jdbc</artifactId>  
    48.             <version>${spring.version}</version>  
    49.         </dependency>  
    50.   
    51.         <dependency>  
    52.             <groupId>org.springframework</groupId>  
    53.             <artifactId>spring-context</artifactId>  
    54.             <version>${spring.version}</version>  
    55.         </dependency>  
    56.   
    57.         <dependency>  
    58.             <groupId>org.springframework</groupId>  
    59.             <artifactId>spring-aop</artifactId>  
    60.             <version>${spring.version}</version>  
    61.         </dependency>  
    62.   
    63.         <dependency>  
    64.             <groupId>org.springframework</groupId>  
    65.             <artifactId>spring-core</artifactId>  
    66.             <version>${spring.version}</version>  
    67.         </dependency>  
    68.   
    69.         <dependency>  
    70.             <groupId>org.springframework</groupId>  
    71.             <artifactId>spring-test</artifactId>  
    72.             <version>${spring.version}</version>  
    73.         </dependency>  
    74.                 <dependency>  
    75.             <groupId>org.springframework</groupId>  
    76.             <artifactId>spring-test</artifactId>  
    77.             <version>${spring.version}</version>  
    78.         </dependency>  
    79.         <!-- spring end -->  
    80.   
    81.         <!-- web jar -->  
    82.         <dependency>  
    83.             <groupId>javax.servlet</groupId>  
    84.             <artifactId>javax.servlet-api</artifactId>  
    85.             <version>3.0.1</version>  
    86.             <scope>provided</scope>  
    87.         </dependency>  
    88.         <dependency>  
    89.             <groupId>javax.servlet</groupId>  
    90.             <artifactId>jstl</artifactId>  
    91.             <version>1.1.2</version>  
    92.             <scope>provided</scope>  
    93.         </dependency>  
    94.         <dependency>  
    95.             <groupId>javax.servlet.jsp</groupId>  
    96.             <artifactId>javax.servlet.jsp-api</artifactId>  
    97.             <version>2.3.1</version>  
    98.             <scope>provided</scope>  
    99.         </dependency>  
    100.         <!-- jstl jar -->  
    101.         <dependency>  
    102.             <groupId>jstl</groupId>  
    103.             <artifactId>jstl</artifactId>  
    104.             <version>1.2</version>  
    105.         </dependency>  
    106.   
    107.         <dependency>  
    108.             <groupId>taglibs</groupId>  
    109.             <artifactId>standard</artifactId>  
    110.             <version>1.1.2</version>  
    111.         </dependency>  
    112.   
    113.         <!-- jackson jar -->  
    114.         <dependency>  
    115.             <groupId>org.codehaus.jackson</groupId>  
    116.             <artifactId>jackson-jaxrs</artifactId>  
    117.             <version>1.9.11</version>  
    118.         </dependency>  
    119.   
    120.         <!-- commons jar -->  
    121.         <dependency>  
    122.             <groupId>org.apache.commons</groupId>  
    123.             <artifactId>commons-lang3</artifactId>  
    124.             <version>3.3.2</version>  
    125.         </dependency>  
    126.         <dependency>  
    127.             <groupId>commons-io</groupId>  
    128.             <artifactId>commons-io</artifactId>  
    129.             <version>2.4</version>  
    130.         </dependency>  
    131.         <dependency>  
    132.             <groupId>org.apache.commons</groupId>  
    133.             <artifactId>commons-collections4</artifactId>  
    134.             <version>4.0</version>  
    135.         </dependency>  
    136.         <dependency>  
    137.             <groupId>commons-logging</groupId>  
    138.             <artifactId>commons-logging</artifactId>  
    139.             <version>1.1.3</version>  
    140.         </dependency>  
    141.         <dependency>  
    142.             <groupId>commons-codec</groupId>  
    143.             <artifactId>commons-codec</artifactId>  
    144.             <version>1.8</version>  
    145.         </dependency>  
    146.         <dependency>  
    147.             <groupId>commons-beanutils</groupId>  
    148.             <artifactId>commons-beanutils</artifactId>  
    149.             <version>1.8.3</version>  
    150.         </dependency>  
    151.         <dependency>  
    152.             <groupId>commons-chain</groupId>  
    153.             <artifactId>commons-chain</artifactId>  
    154.             <version>1.2</version>  
    155.         </dependency>  
    156.         <dependency>  
    157.             <groupId>commons-fileupload</groupId>  
    158.             <artifactId>commons-fileupload</artifactId>  
    159.             <version>1.3.1</version>  
    160.         </dependency>  
    161.         <dependency>  
    162.             <groupId>org.apache.commons</groupId>  
    163.             <artifactId>commons-math3</artifactId>  
    164.             <version>3.3</version>  
    165.         </dependency>  
    166.         <dependency>  
    167.             <groupId>org.apache.commons</groupId>  
    168.             <artifactId>commons-pool2</artifactId>  
    169.             <version>2.2</version>  
    170.         </dependency>  
    171.         <dependency>  
    172.             <groupId>org.apache.commons</groupId>  
    173.             <artifactId>commons-digester3</artifactId>  
    174.             <version>3.2</version>  
    175.         </dependency>  
    176.         <dependency>  
    177.             <groupId>commons-net</groupId>  
    178.             <artifactId>commons-net</artifactId>  
    179.             <version>3.3</version>  
    180.         </dependency>  
    181.         <dependency>  
    182.             <groupId>commons-dbutils</groupId>  
    183.             <artifactId>commons-dbutils</artifactId>  
    184.             <version>1.5</version>  
    185.         </dependency>  
    186.         <dependency>  
    187.             <groupId>org.apache.commons</groupId>  
    188.             <artifactId>commons-email</artifactId>  
    189.             <version>1.3.3</version>  
    190.         </dependency>  
    191.         <dependency>  
    192.             <groupId>commons-dbcp</groupId>  
    193.             <artifactId>commons-dbcp</artifactId>  
    194.             <version>1.4</version>  
    195.         </dependency>  
    196.   
    197.         <!-- 日志相关 -->  
    198.         <dependency>  
    199.             <groupId>log4j</groupId>  
    200.             <artifactId>log4j</artifactId>  
    201.             <version>1.2.16</version>  
    202.         </dependency>  
    203.   
    204.         <dependency>  
    205.             <groupId>org.slf4j</groupId>  
    206.             <artifactId>slf4j-api</artifactId>  
    207.             <version>1.7.5</version>  
    208.         </dependency>  
    209.         <!-- zookeeper client依赖，用于向zookeeper注册服务 -->  
    210.         <dependency>  
    211.             <groupId>com.github.sgroschupf</groupId>  
    212.             <artifactId>zkclient</artifactId>  
    213.             <version>0.1</version>  
    214.         </dependency>  
    215.     </dependencies>  
    216.     <build>  
    217.         <finalName>dubbo-customer02</finalName>  
    218.     </build>  
    219. </project>  


    4.2，两个web项目的主要配置文件，共5个：web.xml、applicationContext.xml、consumer.xml、log4.properties、springmvc-servlet.xml。
     
    web.xml ：基本一样这里只放出一个
    [html] view plain copy
     
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2. <web-app version="2.5" xmlns="http://java.sun.com/xml/ns/javaee"  
    3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    4.     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee   
    5.     http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">  
    6.   
    7.     <display-name>Archetype Created Web Application</display-name>  
    8.   
    9.   
    10.     <!-- 关键配置 contextListener -->  
    11.     <context-param>  
    12.         <param-name>contextConfigLocation</param-name>  
    13.         <param-value>classpath*:applicationContext.xml</param-value>  
    14.     </context-param>  
    15.   
    16.     <listener>  
    17.         <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
    18.     </listener>  
    19.   
    20.   
    21.     <!-- log4 -->  
    22.     <context-param>  
    23.         <param-name>log4jConfigLocation</param-name>  
    24.         <param-value>classpath:log4.properties</param-value>  
    25.     </context-param>  
    26.   
    27.     <context-param>  
    28.         <param-name>log4jRefreshInterval</param-name>  
    29.         <param-value>3000</param-value>  
    30.     </context-param>  
    31.   
    32.     <listener>  
    33.         <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>  
    34.     </listener>  
    35.       
    36.     <!-- 字符过滤器 -->  
    37.     <filter>  
    38.         <filter-name>encodingFilter</filter-name>  
    39.         <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>  
    40.         <init-param>  
    41.             <param-name>encoding</param-name>  
    42.             <param-value>UTF-8</param-value>  
    43.         </init-param>  
    44.     </filter>  
    45.     <filter-mapping>  
    46.         <filter-name>encodingFilter</filter-name>  
    47.         <url-pattern>/</url-pattern>  
    48.     </filter-mapping>  
    49.   
    50.   
    51.     <!-- 设置tomcat对静态资源默认拦截 -->  
    52.     <servlet-mapping>  
    53.         <servlet-name>default</servlet-name>  
    54.         <url-pattern>*.jpg</url-pattern>  
    55.     </servlet-mapping>  
    56.     <servlet-mapping>  
    57.         <servlet-name>default</servlet-name>  
    58.         <url-pattern>*.png</url-pattern>  
    59.     </servlet-mapping>  
    60.     <servlet-mapping>  
    61.         <servlet-name>default</servlet-name>  
    62.         <url-pattern>*.js</url-pattern>  
    63.     </servlet-mapping>  
    64.     <servlet-mapping>  
    65.         <servlet-name>default</servlet-name>  
    66.         <url-pattern>*.css</url-pattern>  
    67.     </servlet-mapping>  
    68.     <!-- 关键配置 dispatcherServlet -->  
    69.     <!-- 拦截所有的请求，包括静态资源 -->  
    70.     <servlet>  
    71.         <servlet-name>springmvc</servlet-name>  
    72.         <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
    73.         <init-param>  
    74.             <param-name>contextConfigLocation</param-name>  
    75.             <param-value>classpath*:springmvc-servlet.xml</param-value>  
    76.         </init-param>  
    77.         <load-on-startup>1</load-on-startup>  
    78.     </servlet>  
    79.   
    80.     <servlet-mapping>  
    81.         <servlet-name>springmvc</servlet-name>  
    82.         <url-pattern>/</url-pattern>  
    83.     </servlet-mapping>  
    84.   
    85.     <welcome-file-list>  
    86.         <welcome-file>index.jsp</welcome-file>  
    87.     </welcome-file-list>  
    88. </web-app>  


     
    applicationContext.xml    2个consumer一模一样，只是引入consumer消费者配置文件，很简单
     
    [html] view plain copy
     
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2. <beans xmlns="http://www.springframework.org/schema/beans"  
    3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"  
    4.     xmlns:p="http://www.springframework.org/schema/p" xmlns:aop="http://www.springframework.org/schema/aop"  
    5.     xmlns:tx="http://www.springframework.org/schema/tx"  
    6.     xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd  
    7.     http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd   
    8.     http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.3.xsd   
    9.     http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.3.xsd">  
    10.       
    11.     <import resource="classpath*:/consumer.xml" />  
    12.       
    13. </beans>  


    consumer.xml:    消费者配置文件，这个很重要，这里消费者应用名不能一样了，因为我模拟是2个消费者，然后需要向zookeeper中心注册，还有个很重要的就是引用提供者提供的远程服务
     
    consumer01:   consumer.xml
    [html] view plain copy
     
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2. <beans xmlns="http://www.springframework.org/schema/beans"  
    3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    4.     xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"  
    5.     xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd        http://code.alibabatech.com/schema/dubbo        http://code.alibabatech.com/schema/dubbo/dubbo.xsd">  
    6.    
    7.     <!-- 消费方应用名，用于计算依赖关系，不是匹配条件，不要与提供方一样 -->  
    8.     <dubbo:application name="consumer01"  />  
    9.    
    10.     <!-- 使用zookeeper广播注册中心暴露服务地址 -->  
    11.     <dubbo:registry address="zookeeper://127.0.0.1:2181"/>  
    12.    
    13.     <!-- 生成远程服务代理，可以和本地bean一样使用demoService -->  
    14.     <dubbo:reference id="testService" interface="com.test.service.TestService" />  
    15.    
    16. </beans>  
     
    consumer02:   consumer.xml
     
    [html] view plain copy
     
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2. <beans xmlns="http://www.springframework.org/schema/beans"  
    3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
    4.     xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"  
    5.     xsi:schemaLocation="http://www.springframework.org/schema/beans        http://www.springframework.org/schema/beans/spring-beans.xsd        http://code.alibabatech.com/schema/dubbo        http://code.alibabatech.com/schema/dubbo/dubbo.xsd">  
    6.    
    7.     <!-- 消费方应用名，用于计算依赖关系，不是匹配条件，不要与提供方一样 -->  
    8.     <dubbo:application name="consumer02"  />  
    9.    
    10.     <!-- 使用zookeeper广播注册中心暴露服务地址 -->  
    11.     <dubbo:registry address="zookeeper://127.0.0.1:2181"/>  
    12.    
    13.     <!-- 生成远程服务代理，可以和本地bean一样使用demoService -->  
    14.     <dubbo:reference id="testService" interface="com.test.service.TestService" />  
    15.    
    16. </beans>  



    log4配置文件，没什么好说的，同provider,这里不粘了
     
     
    springmvc-servlet.xml ：   配置文件，很简单，启用注解与controller扫描，没了。
     
    [html] view plain copy
     
    1. <?xml version="1.0" encoding="UTF-8"?>  
    2. <beans xmlns="http://www.springframework.org/schema/beans"  
    3.     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"  
    4.     xmlns:context="http://www.springframework.org/schema/context"  
    5.     xmlns:mvc="http://www.springframework.org/schema/mvc"  
    6.     xsi:schemaLocation="http://www.springframework.org/schema/beans    http://www.springframework.org/schema/beans/spring-beans-4.3.xsd      
    7. http://www.springframework.org/schema/context    http://www.springframework.org/schema/context/spring-context-4.3.xsd   
    8. http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.3.xsd"  
    9.     default-lazy-init="true">  
    10.   
    11.     <!-- 启用注解 -->  
    12.     <context:annotation-config />  
    13.   
    14.     <!-- 扫描Controller -->  
    15.     <context:component-scan base-package="com.test.controller" />  
    16.     <!-- 完成请求与注解的POJO映射 -->  
    17.     <bean  
    18.         class="org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter" />  
    19.     <bean  
    20.         class="org.springframework.web.servlet.mvc.annotation.DefaultAnnotationHandlerMapping" />  
    21.           
    22.           
    23.     <bean id="defaultViewResolver"  
    24.         class="org.springframework.web.servlet.view.InternalResourceViewResolver"  
    25.         p:order="3">  
    26.         <property name="viewClass"  
    27.             value="org.springframework.web.servlet.view.JstlView" />  
    28.         <property name="contentType" value="text/html" />  
    29.         <property name="prefix" value="/" />  
    30.         <property name="suffix" value=".jsp" />  
    31.     </bean>  
    32. </beans>  
     
    4.3   spring mvc web 项目配置已经完成了，这一步，可以直接启动项目，启动成功，且能进helloworld 页则说明你的配置没有出现细微错误，否则需要检查检查，保证项目是正常的，不然后面排错懵逼。
     
    现在我们新建个controller，很简单，就弄个接口，调用提供者的远程服务
    consumer01:     TestController：   
    [html] view plain copy
     
    1.   
    [java] view plain copy
     
    1. package com.test.controller;  
    2.   
    3.   
    4. import java.util.Map;  
    5.   
    6.   
    7. import javax.annotation.Resource;  
    8.   
    9.   
    10. import org.springframework.stereotype.Controller;  
    11. import org.springframework.web.bind.annotation.RequestMapping;  
    12. import org.springframework.web.bind.annotation.ResponseBody;  
    13.   
    14.   
    15. import com.test.service.TestService;  
    16.   
    17.   
    18.   
    19.   
    20. /** 
    21.  * @author xianghui1 
    22.  * 
    23.  *         测试controller 
    24.  */  
    25. @Controller  
    26. public class TestController {  
    27.   
    28.   
    29.     @Resource(name = "testService")  
    30.     TestService testInterface;  
    31.   
    32.   
    33.     @RequestMapping(value = { "/consumer/testMain" })  
    34.     @ResponseBody  
    35.     public String testDubbo() {  
    36.         return "consuemr01" + testInterface.test();  
    37.     }  
    38.   
    39.   
    40. }  

    

    

    

     
    

    consumer02    TestController: 
    

    

    

    

    [html] view plain copy

     
    

    

    

      

    1. package com.test.controller;  
      2. 

    2.   
      3. 

    3. import java.util.Map;  
      4. 

    4.   
      5. 

    5. import javax.annotation.Resource;  
      6. 

    6.   
      7. 

    7. import org.springframework.stereotype.Controller;  
      8. 

    8. import org.springframework.web.bind.annotation.RequestMapping;  
      9. 

    9. import org.springframework.web.bind.annotation.ResponseBody;  
      10. 

    10.   
      11. 

    11. import com.test.service.TestService;  
      12. 

    12.   
      13. 

    13.   
      14. 

    14. /**  
      15. 

    15.  * @author xianghui1  
      16. 

    16.  *  
      17. 

    17.  *测试controller  
      18. 

    18.  */  
      19. 

    19. @Controller  
      20. 

    20. public class TestController {  
      21. 

    21.   
      22. 

    22.     @Resource(name="testService")  
      23. 

    23.     TestService testInterface;  
      24. 

    24.       
      25. 

    25.     @RequestMapping(value={"/consumer/testMain"})  
      26. 

    26.     @ResponseBody  
      27. 

    27.     public String testDubbo(){  
      28. 

    28.         return "consuemr02"+testInterface.test();  
      29. 

    29.     }  
      30. 

    30.       
      31. 

    31. }  
      32. 

    


    

4.4,然后我们可以启动了，我们将2个consuemr分别放在两个tomcat中运行，2个tomcat端口要不一致的
    

     
    

    可以看出2个consumer，2个provider，一切正常，我们在浏览器中访问我们的接口，也是正常
    

    

     
    

    第五步：到这里我们的dubbo+zookeeper+Spring mvc 搭建完成了，下一步，加入nginx 实现http层面的负载均衡
    

     
    

    5.1   下载nginx，解压，并修改conf目录下的nginx.conf
    

     
    

    5.2我们新建个upstream 负载均衡，采取默认的nginx负载均衡策略，然后监听80端口，将80端口所有的请求代理转发到负载上面
    

    

     
    

    5.3 命令行启动nginx，然后在浏览器中输入接口网址即可发现会出现四种结果，consumer01provider01、consumer02provider01、consumer01provider02、consumer02provider02.   dubbo+zookeeper+spring mvc+nginx负载均衡测试完成
    


    --------------------------------------分割线 --------------------------------------
    

    Ubuntu 14.04安装分布式存储Sheepdog+ZooKeeper  http://www.linuxidc.com/Linux/2014-12/110352.htm
    

    CentOS 6安装sheepdog虚拟机分布式储存  http://www.linuxidc.com/Linux/2013-08/89109.htm
    

    ZooKeeper集群配置 http://www.linuxidc.com/Linux/2013-06/86348.htm
    

    使用ZooKeeper实现分布式共享锁http://www.linuxidc.com/Linux/2013-06/85550.htm
    

    分布式服务框架 ZooKeeper -- 管理分布式环境中的数据http://www.linuxidc.com/Linux/2013-06/85549.htm
    

    ZooKeeper集群环境搭建实践 http://www.linuxidc.com/Linux/2013-04/83562.htm
    

    ZooKeeper服务器集群环境配置实测 http://www.linuxidc.com/Linux/2013-04/83559.htm
    

    ZooKeeper集群安装 http://www.linuxidc.com/Linux/2012-10/72906.htm
    

    
    
                
    
                
              
    • 
              
    
              
  • 

                相关阅读:
    
                
                  django model：auto_now_add 和 auto_now
                    
    算法（2）：数据结构
                    
    Flask（2）：登陆验证
                    
    Flask（1）：基本示例、配置文件、路由、请求和响应、模板渲染
                    
    linux基础
                    
    算法（1）：查找&排序
                    
    利用dispatch_once创建单例
                    
    UIScrollView的属性总结
                    
    ios开发 UITableViewController
                    
    [深入浅出Cocoa]详解键值观察（KVO）及其实现机理
                    
                        
              
    • 
              
    
              
  • 
                原文地址：https://www.cnblogs.com/barrywxx/p/8546236.html
              
    • 

            

          



          
          

            

            

          

        

      

      



      

      

        

          Copyright © 2011-2022 走看看