Dubbo+Zookeeper+Spring 搭建

2019年6月9日 187次阅读 来源: 普度众生的面瘫青年

本文采用Dubbo与Zookeeper、Spring框架的整合。

主要是以下几个步骤：

  1. 安装Zookeeper,启动；
  2. 创建MAVEN项目，构建Dubbo+Zookeeper+Spring实现的简单Demo；
  3. 安装Dubbo-admin，实现监控。

项目已经上传到了github，地址是 https://github.com/cafeUncle/dubbo-demo

安装Zookeeper

没有zk环境的可以参考：zookeeper简介及搭建

创建项目

首先看一下项目结构

《Dubbo+Zookeeper+Spring 搭建》

  • dubbo-api是服务发布的接口
  • dubbo-customer和dubbo-customer2是服务调用方，分别为xml配置bean和注解配置bean，这点后面会提到。
  • dubbo-provider和dubbo-provider2是服务提供方，区别于customer相同。
1. 总pom
<?xml version="1.0" encoding="UTF-8"?>
<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">
    <modelVersion>4.0.0</modelVersion>
    <groupId>groupId</groupId>
    <artifactId>dubboDemo</artifactId>
    <packaging>pom</packaging>
    <version>1.0-SNAPSHOT</version>
    <modules>
        <module>dubbo-api</module>
        <module>dubbo-provider</module>
        <module>dubbo-customer</module>
        <module>dubbo-customer2</module>
        <module>dubbo-provider2</module>
    </modules>
    <properties>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
        <spring.version>4.2.5.RELEASE</spring.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-core</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.9</version>
        </dependency>
        <!-- dubbo -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.5.3</version>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- zkclient 客户端 -->
        <dependency>
            <groupId>com.github.sgroschupf</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.1</version>
        </dependency>
    </dependencies>

</project>

zkclient是Datameer开源的一个Zookeeper客户端实现，开源比较早，参见：https://github.com/sgroschupf/zkclient。dubbo在2.2.0之后默认使用zkclient，2.3.0之后提供可选配置Curator,而没有使用zookeeper本身的客户端与zookeeper进行交互，原因如下(采集自网络)：

  1. ZooKeeper的Watcher是一次性的，用过了需要再注册；
  2. session的超时后没有自动重连，生产环境中如果网络出现不稳定情况，那么这种情况出现的更加明显；
  3. 没有领导选举机制，集群情况下可能需要实现stand by，一个服务挂了，另一个需要接替的效果；
  4. 客户端只提供了存储byte数组的接口，而项目中一般都会使用对象。
  5. 客户端接口需要处理的异常太多，并且通常，我们也不知道如何处理这些异常。
2. dubbo-api

《Dubbo+Zookeeper+Spring 搭建》

一般会打出一个jar包，维护服务接口定义、RPC参数类型、RPC返回类型、接口异常、及接口用到的常量。该jar包中不处理任何业务逻辑，由提供方通过引用该jar包实现接口并暴露服务，由调用方引用该jar包并注入接口的代理实例。

3. dubbo-customer

结构：
《Dubbo+Zookeeper+Spring 搭建》

  • spring-customer.xml:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       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">

    <!-- 配置应用名、注册中心,并配置客户端reference bean -->

    <!--定义了提供方应用信息，用于计算依赖关系；在 dubbo-admin 或 dubbo-monitor 会显示这个名字，方便辨识-->
    <dubbo:application name="dubbo-consumer" owner="programmer" organization="dubbox"/>

    <!--向 zookeeper 订阅 provider 的地址，由 zookeeper 定时推送-->
    <dubbo:registry address="zookeeper://192.168.0.200:2181"/>
 
    <!--客户端跟服务端不同的是客户端这边没有实现类，配置的dubbo:reference实际会生成一个spring bean实例, -->
    <!--使用 dubbo 协议调用定义好的接口,由该实例代理处理Dubbo请求，然后其他要调用处直接使用spring bean的方式使用这个实例即可-->
    <!--id即为spring bean的id,之后无论是在spring配置中使用ref="demoService"还是通过@Autowired注解都可以-->
    <dubbo:reference id="demoService" interface="dubboApi.DemoService" version="1.0"/>
</beans>
  • 另外开发、测试环境可通过指定Url方式绕过注册中心直连指定的服务地址，避免注册中心中服务过多，启动建立连接时间过长，如：
    <dubbo:reference id="demoService" interface="dubboApi.DemoService"  
        version="1.0" url="dubbo://127.0.0.1:20880/"></dubbo:reference>
  • Customer.java
public static void main(String[] args) {

        ClassPathXmlApplicationContext context =
                new ClassPathXmlApplicationContext("spring-customer.xml");

        DemoService demoService = context.getBean(DemoService.class);

        System.out.println("get demoService");

        System.out.println(demoService.getLists(666));

}

4. dubbo-provider

结构:
《Dubbo+Zookeeper+Spring 搭建》

spring-provider.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       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">

    <!-- 定义了提供方应用信息，用于计算依赖关系；在 dubbo-admin 或 dubbo-monitor 会显示这个名字，方便辨识-->
    <dubbo:application name="dubbo-provider" owner="programmer" organization="dubbox"/>

    <!-- 使用 zookeeper 注册中心暴露服务，注意要先开启 zookeeper-->
    <dubbo:registry address="zookeeper://192.168.0.200:2181"/>

    <!-- 用dubbo协议在20880端口暴露服务 -->
    <!-- 使用Dubbo协议的服务会在初始化时建立长连接-->
    <dubbo:protocol name="dubbo" port="20880"/>

    <!-- 使用 dubbo 协议实现定义好的 dubboApi.DemoService 接口-->
    <dubbo:service interface="dubboApi.DemoService" ref="demoService" protocol="dubbo" version="1.0"/>

    <!-- 实现该接口的 bean-->
    <bean id="demoService" class="dubboProvider.DemoServiceImpl"/>
</beans>
  • DemoServiceImpl.java
public class DemoServiceImpl implements DemoService {
    public List<String> getLists(Integer id) {
        List<String> strList = new ArrayList<String>();
        strList.add("id:" + (id + 1));
        strList.add("id:" + id);
        strList.add("id:" + --id);

        System.out.println(strList);

        return strList;
    }
}
  • Provider.java
public class Provider {
    public static void main(String[] args) throws IOException {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("spring-provider.xml");
        System.out.println(context.getDisplayName() + ": here");
        context.start(); // 显式调用getBean方法时可以不手动start容器
        System.out.println("服务已经启动...");
        System.in.read();  // 为保证服务一直开着，利用输入流的阻塞来模拟
    }
}

测试

  1. 启动zookeeper
  2. 运行Provider.java

  3. 运行Custom.java

    《Dubbo+Zookeeper+Spring 搭建》

    调用成功！

那为什么还有 dubbo-customer2和dubbo-provider2？
因为除了声明式配置外，还可以用@Service注解的方式来发布，@Reference注入的方式来调用

5. dubbo-customer2

结构相似：
《Dubbo+Zookeeper+Spring 搭建》

  • spring-customer2.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       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">
    <!--定义了提供方应用信息，用于计算依赖关系；在 dubbo-admin 或 dubbo-monitor 会显示这个名字，方便辨识-->
    <dubbo:application name="dubbo-customer2" owner="programmer" organization="dubbox"/>
    <!--使用 zookeeper 注册中心暴露服务，注意要先开启 zookeeper-->
    <dubbo:registry address="zookeeper://192.168.0.200:2181"/>
    <!-- 注解方式装配 -->
    <dubbo:annotation package="dubboCustom2"/>
</beans>

可以看出由<dubbo:reference/>标签声明的服务，用<dubbo:annotation/>注解扫描器代替了。
在配置文件中加上<dubbo:annotation>，它会扫描所有注册bean的java类，发现带@Reference标签的属性，它会去寻找发布的provider是否有匹配的接口，有就自动注入。

  • Customer2.java
@Component
public class Customer2 {

    // 因为Spring的注入是对于对象属性的注入，而static是类属性，不是对象属性。
    // dubbo的@Reference注解可以注入static属性，而Spring的'@Autowired'、'@Resource'不可以
    @Reference(version = "1.0")
    private static DemoService demoService;

    public static void main(String[] args) {

        ClassPathXmlApplicationContext classPathXmlApplicationContext =
                new ClassPathXmlApplicationContext("spring-customer2.xml");
        classPathXmlApplicationContext.start(); // 显式调用getBean方法时可以不手动start容器

        List<String> lists = demoService.getLists(555);

        System.out.println(lists);
    }
}

此时可以启用Provider.java和Customer2.java进行测试

《Dubbo+Zookeeper+Spring 搭建》

6. dubbo-provider2

结构：
《Dubbo+Zookeeper+Spring 搭建》

  • spring-provider2.xml
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
       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">

    <!--定义了提供方应用信息，用于计算依赖关系；在 dubbo-admin 或 dubbo-monitor 会显示这个名字，方便辨识-->
    <dubbo:application name="dubbo-provider2" owner="programmer" organization="dubbox"/>

    <!--使用 zookeeper 注册中心暴露服务，注意要先开启 zookeeper-->
    <!-- 可以通过group指定注册中心分组，可通过register配置是否注册到该注册中心以及subscribe配置是否从该注册中心订阅 -->
    <dubbo:registry address="zookeeper://192.168.0.200:2181"/>

    <!-- 用dubbo协议在20881端口暴露服务，同时启动两种provider时端口不能冲突，换一个端口 -->
    <!-- 使用Dubbo协议的服务会在初始化时建立长连接-->
    <dubbo:protocol name="dubbo" port="20881"/>

    <!-- 注解方式装配, 不指定包名的话会在spring bean中查找配置了dubbo注解的对应实例的类 -->
    <dubbo:annotation package="dubboProvider2"/>

</beans>

可以看出，原本的声明服务依赖关系被<dubbo:annotation/>注解替代了。

  • DemoServiceImpl.java
@Service(version = "1.0")
public class DemoServiceImpl implements DemoService {
    @Override
    public List<String> getLists(Integer id) {
        List<String> strings = new ArrayList<>();

        strings.add("aaa");
        strings.add("bbb");
        strings.add("ccc");

        System.out.println(strings);

        return strings;
    }
}

这里改动不大，只是加了@Service注解。这里需要十分注意的是，Service注解的包一定要导com.alibaba.dubbo.config.annotation.Service，我在第一次搭建时以为导入spring下的注解包就可以，结果花掉了整整半天的时间来debug这个问题。

  • Provider2.java相比于Provider.java没有什么改动。
    然后可以再做一次测试。这次我们启动Customer2.java和Provider2。

    《Dubbo+Zookeeper+Spring 搭建》

dubbo-admin

直接使用了github上dubbo项目中的admin模块
https://github.com/apache/incubator-dubbo
git clone https://github.com/apache/incubator-dubbo

《Dubbo+Zookeeper+Spring 搭建》

  1. 打开下图中的路径，修改参数，并启动dubbo-admin项目

    《Dubbo+Zookeeper+Spring 搭建》

  2. 打开locahost:8080，用刚才配置的用户名密码登录

    《Dubbo+Zookeeper+Spring 搭建》

  3. 首页可以搜索刚才配置的地址上注册的服务

    《Dubbo+Zookeeper+Spring 搭建》
    《Dubbo+Zookeeper+Spring 搭建》

  4. governance中可以查看注册的服务提供方和调用方等信息

    《Dubbo+Zookeeper+Spring 搭建》

  5. 通过governance中的route配置路由规则，调整客户端调用策略，IP地址支持结尾为匹配所有，如10.0.0.或者10.0.*等
    《Dubbo+Zookeeper+Spring 搭建》
  6. 通过governance中的loadbalance配置负载均衡，dubbo提供4种负载均衡方式:
  • Random，随机，按权重配置随机概率，调用量越大分布越均匀，默认是这种方式
  • RoundRobin，轮询，按权重设置轮询比例，如果存在比较慢的机器容易在这台机器的请求阻塞较多
  • LeastActive，最少活跃调用数，不支持权重，只能根据自动识别的活跃数分配，不能灵活调配
  • ConsistentHash，一致性hash，对相同参数的请求路由到一个服务提供者上，如果有类似灰度发布需求可采用
    dubbo的负载均衡机制是在客户端调用时通过内存中的服务方信息及配置的负责均衡策略选择，如果对自己系统没有一个全面认知，可以先采用默认的random方式。

《Dubbo+Zookeeper+Spring 搭建》

踩坑经验：

  • provider在注解装配时，实现类上的@Service注解要使用dubbo的
  • @Reference只能在spring bean实例对应的当前类中使用，暂时无法在父类使用；如果确实要在父类声明一个引用，可通过配置文件配置dubbo:reference，然后在需要引用的地方@AutoWired

以上均为自学经验，目前工作中没有dubbo和zk的使用环境，待以后有生产环境使用经验后，再来完善。感谢阅读本文。

    原文作者：普度众生的面瘫青年
    原文地址: https://www.jianshu.com/p/9cbfb8679e1d
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞