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
    

    
    
                
    
                
              
    • 
              
    
              
  • 

                相关阅读:
    
                
                  day7 面向对象 静态方法 类方法 属性方法 类的特殊成员方法 元类 反射 异常处理
                    
    day6 面向对象 封装 继承 多态 类与实例在内存中的关系 经典类和新式类
                    
    day5  time datetime random os sys shutil json pickle shelve xml configparser hashlib subprocess logging re正则 python计算器
                    
    kafka常用操作命令
                    
    linux基础
                    
    django学习1——初识web应用程序
                    
    mysql数据库(三）——pymysql模块
                    
    mysql数据库（二）——表的查询
                    
    mysql数据库（一）
                    
    Python常用模块——re模块
                    
                        
              
    • 
              
    
              
  • 
                原文地址：https://www.cnblogs.com/barrywxx/p/8546236.html
              
    • 

            

          



          
          

            

            

          

        

      

      



      

      

        

          Copyright © 2011-2022 走看看