一文入坑分布式框架Dubbo + Zookeeper【纯代码实例篇】

Dubbo是一款非常优秀的RPC框架，Zookeeper主要是作为服务发现与注册中心的组件

1、首先我们需要在本地安装zookeeper，由于官方网站下载的速度很慢，这里我直接提供压缩包。大家只需要解压后修改一下config目录下的 zoo.cfg <zoo_sample.cfg改名而来> 的data、log目录即可。（详情参考网上zookeeper安装教程）

链接：https://pan.baidu.com/s/1faoS6t2CUCEOQNuDRhaHQA 提取码：llhm

2、安装成功之后我们需要点击zkServer.cmd文件，然后再点击zkCli.cmd文件验证是否开启成功，至此，zookeeper安装完毕。

本文主要介绍xml、注解的方式来进行配置开发

一、通过xml配置的方式整合zookeeper进行开发（官方推荐）

文件目录

1、通过xml的方式整合zookeeper进行开发，先在META-INF.spring目录下创建一个provider注册服务的配置文件，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:application name="provider" owner="yangshiwen">
        <dubbo:parameter key="qos.enable" value="true"/>
        <dubbo:parameter key="qos.accept.foreign.ip" value="false"/>
        <dubbo:parameter key="qos.port" value="55555"/>
    </dubbo:application>

    <dubbo:monitor protocol="registry"/>

    <!--dubbo这个服务所要暴露的服务地址所对应的注册中心-->
    <!--<dubbo:registry address="N/A" />-->
    <!--整合zookeeper的方式-->
    <dubbo:registry address="zookeeper://localhost:2181" check="false"/>

    <!--只订阅[只注册服务]，但不支持服务的发现-->
    <!--<dubbo:registry register="false" protocol="zookeeper" address="localhost:2181" check="false"></dubbo:registry>-->

    <!--当前服务发布所依赖的协议；webserovice、Thrift、Hessain、http-->
    <dubbo:protocol name="dubbo" port="20880"/>

    <!--服务发布的配置，需要暴露的服务接口，集群容错机制采用[failover]，如果失败则最多限制重启2次-->
    <dubbo:service cluster="failover" retries="2"
            interface="com.xml.example.dubbo.service.ProviderService"
            ref="providerService"/>

    <!--Bean bean定义-->
    <bean id="providerService" class="com.xml.example.dubbo.service.ProviderServiceImpl"/>

</beans>

2、同时在resource目录下创建一个consumer.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:application name="consumer" owner="yangshiwen"/>

    <!--dubbo这个服务所要暴露的服务地址所对应的注册中心-->
    <!--1、点对点的方式-->
    <!--<dubbo:registry address="N/A" />-->

    <!-- 2、zookeeper配置 -->
    <dubbo:registry protocol="zookeeper" address="localhost:2181" check="false"/>

    <!-- 3、只注册，不订阅 -->
    <!--<dubbo:registry subscribe="false" address="zookeeper://192.168.101.139:2181" check="false"/>-->

    <!--生成一个远程服务的调用代理-->
    <!--1、点对点方式-->
    <dubbo:reference id="providerService"
                     interface="com.xml.example.dubbo.service.ProviderService"
                     url="dubbo://192.168.101.139:20880/com.xml.example.dubbo.service.ProviderService"/>

    <!--2、消费者直连provider-->
    <!--<dubbo:reference id="providerService" cluster="failover" retries="2"-->
    <!--                 interface="com.xml.example.dubbo.service.ProviderService"-->
    <!--                 url="dubbo://192.168.101.139:20880/com.xml.example.dubbo.service.ProviderService"/>-->

    <!--3、集群容错采用[failover]的方式来进行，如果失败的话则最多限制失败2次 -->
    <!--<dubbo:reference cluster="failover" retries="2" check="false" id="providerService"-->
    <!--                 interface="com.xml.example.dubbo.service.ProviderService"-->
    <!--                 url="dubbo://192.168.101.139:20880/com.xml.example.dubbo.service.ProviderService"-->

</beans>

3、提供一个我们即将注册的接口出去

package com.xml.example.dubbo.service;

/**
 * 服务提供者接口 - xml方式
 *
 * @author shiwen
 * @date 2020/9/23
 */
public interface ProviderService {

    String SayHello(String keyword);

}

4、再提供这个接口对应的实现类

package com.xml.example.dubbo.service;


/**
 * 服务提供实现类 - xml方式
 *
 * @author shiwen
 * @date 2020/9/23
 */
public class ProviderServiceImpl implements ProviderService {

    @Override
    public String SayHello(String keyword) {
        return keyword;
    }

}

5、注册服务到zookeeper服务注册与发现中心

package com.xml.example.dubbo.register;

import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;

/**
 * 发布接口 - 服务注册
 *
 * @author shiwen
 * @date 2020/9/23
 */
public class RegisterInterface {

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

        // 这里我们需要拿到我们配置的xml文件 zookeeperProvider
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("META-INF/spring/provider.xml");
        // 发起调用
        context.start();
        //System.out.println(context + "==================");
        // 按任意键退出
        System.in.read();

    }

}

6、通过消费者调用我们注册的服务

package com.xml.example.dubbo.register;

import com.xml.example.dubbo.service.ProviderService;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.io.IOException;

/**
 * 服务发现
 *
 * @author shiwen
 * @date 2020/9/23
 */
public class FindInterface {

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

        // zookeeperConsumer
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("consumer.xml");
        context.start();
        ProviderService providerService = (ProviderService) context.getBean("providerService");
        String str = providerService.SayHello("调用dubbo服务");
        System.out.println(str);
        System.in.read();

    }

}

最后，调用成功，我们的控制台就会直接输出以下文案。

---

2、通过注解的方式整合zookeeper进行开发

首先看下文件目录，其实无非就是分接口层、配置层、服务 [注册 / 发现] 层，这里我们不需要使用xml配置文件了，我们只需要使用dubbo自带的注解的方式来进行整合

1、首先我们来定义服务提供者的接口和实现类，先来看接口

package com.anno.provider.service.annotation;

/**
 * @author shiwen
 * @date 2020/9/24
 */
public interface ProviderServiceAnnotation {

    String sayHello(String key);

    int sumTotal(int paramA, int paramB);

}

2、再来看服务提供者的接口实现类

package com.anno.provider.service.annotation;

import com.alibaba.dubbo.config.annotation.Service;

/**
 * 注解方式的实现类
 * PS：这里是Dubbo提供的service注解
 *
 * @author shiwen
 * @date 2020/9/24
 */

@Service(timeout = 5000)
public class ProviderServiceImplAnnotation implements ProviderServiceAnnotation {

    @Override
    public String sayHello(String key) {
        return key;
    }

    @Override
    public int sumTotal(int paramA, int paramB) {
        int total = paramA + paramB;
        return total;
    }

}

3、服务提供者的配置文件（其实这里也是参考着xml来弄的，相当于把xml转为了java文件）

package com.anno.provider.configuration;

import com.alibaba.dubbo.config.ApplicationConfig;
import com.alibaba.dubbo.config.ProtocolConfig;
import com.alibaba.dubbo.config.ProviderConfig;
import com.alibaba.dubbo.config.RegistryConfig;
import com.alibaba.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * 组装服务提供方。
 * 通过 Spring 中 Java Config 的技术（@Configuration）和 annotation 扫描（@EnableDubbo）来发现、组装、并向外提供 Dubbo 的服务。
 *
 * @author shiwen
 * @date 2020/9/24
 */

@Configuration
@EnableDubbo(scanBasePackages = "com.anno.provider.service.annotation")
public class DubboConfiguration {

    @Bean   // #1 服务提供者信息配置
    public ProviderConfig providerConfig() {
        ProviderConfig providerConfig = new ProviderConfig();
        providerConfig.setTimeout(1000);
        return providerConfig;
    }

    @Bean   // #2 分布式应用信息配置
    public ApplicationConfig applicationConfig() {
        ApplicationConfig applicationConfig = new ApplicationConfig();
        applicationConfig.setName("dubbo-annotation-provider");
        return applicationConfig;
    }

    @Bean   // #3 注册中心信息配置
    public RegistryConfig registryConfig() {
        RegistryConfig registryConfig = new RegistryConfig();
        registryConfig.setProtocol("zookeeper");
        registryConfig.setAddress("localhost");
        registryConfig.setPort(2181);
        return registryConfig;
    }

    @Bean   // #4 使用协议配置，这里使用dubbo
    public ProtocolConfig protocolConfig() {
        ProtocolConfig protocolConfig = new ProtocolConfig();
        protocolConfig.setName("dubbo");
        protocolConfig.setPort(20880);
        return protocolConfig;
    }

}

4、注册服务，服务注册完成

package com.anno.provider;

import com.anno.provider.configuration.DubboConfiguration;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.io.IOException;

/**
 * @author shiwen
 * @date 2020/9/24
 */
public class AppAnnotation {

    public static void main(String[] args) throws IOException {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(DubboConfiguration.class);
        context.start();
        System.in.read();
    }

}

5、消费者端接口调用类

package com.anno.consumer.annotation;

import com.alibaba.dubbo.config.annotation.Reference;
import com.anno.provider.service.annotation.ProviderServiceAnnotation;
import org.springframework.stereotype.Component;

/**
 * 注解方式的service
 *
 * @author shiwen
 * @date 2020/9/24
 */

@Component("annotatedConsumer")
public class ConsumerAnnotationService {

    @Reference
    private ProviderServiceAnnotation providerServiceAnnotation;

    public String doSayHello(String key) {
        return providerServiceAnnotation.sayHello(key);
    }

    public int sumTotal(int paramA, int paramB) {
        return providerServiceAnnotation.sumTotal(paramA, paramB);
    }

}

6、消费者端配置文件（相当于把consumer.xml文件配置转为java文件）

package com.anno.consumer.configuration;

/**
 * @author shiwen
 * @date 2020/9/24
 */
import com.alibaba.dubbo.config.ApplicationConfig;
import com.alibaba.dubbo.config.ConsumerConfig;
import com.alibaba.dubbo.config.RegistryConfig;
import com.alibaba.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;
import java.util.Map;

/**
 * 注解配置类
 */
@Configuration
@EnableDubbo(scanBasePackages = "com.anno.consumer.annotation")
@ComponentScan(value = {"com.anno.consumer.annotation"})
public class ConsumerConfiguration {

    @Bean // 应用配置
    public ApplicationConfig applicationConfig() {
        ApplicationConfig applicationConfig = new ApplicationConfig();
        applicationConfig.setName("dubbo-annotation-consumer");
        Map<String, String> stringStringMap = new HashMap<String, String>();
        stringStringMap.put("qos.enable","true");
        stringStringMap.put("qos.accept.foreign.ip","false");
        stringStringMap.put("qos.port","33333");
        applicationConfig.setParameters(stringStringMap);
        return applicationConfig;
    }

    @Bean // 服务消费者配置
    public ConsumerConfig consumerConfig() {
        ConsumerConfig consumerConfig = new ConsumerConfig();
        consumerConfig.setTimeout(3000);
        return consumerConfig;
    }

    @Bean // 配置注册中心
    public RegistryConfig registryConfig() {
        RegistryConfig registryConfig = new RegistryConfig();
        registryConfig.setProtocol("zookeeper");
        registryConfig.setAddress("localhost");
        registryConfig.setPort(2181);
        return registryConfig;
    }

}

7、消费者调用已经注册的服务

package com.anno.consumer;

import com.anno.consumer.annotation.ConsumerAnnotationService;
import com.anno.consumer.configuration.ConsumerConfiguration;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

import java.io.IOException;

/**
 * @author shiwen
 * @date 2020/9/24
 */
public class AppAnnotation {

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

        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(ConsumerConfiguration.class);
        context.start(); // 启动
        ConsumerAnnotationService consumerAnnotationService = context.getBean(ConsumerAnnotationService.class);
        String hello = consumerAnnotationService.doSayHello("AAAAAAAAAAAAAAAAAAAAAA"); // 调用方法
        int total = consumerAnnotationService.sumTotal(10, 20);   // 调用方法
        System.out.println("======================== result: " + hello + "   total：" + total); // 输出结果

    }

}

最终控制台输出调用输出结果