Dubbo配置的三种基本使用

勿以浮沙筑高台

---

公共提前准备

1.新建项目

新建三个项目，接口提供者SDK，数据生产方Provider，数据消费方consumer

2.引入maven依赖

在生产者和消费者中引入maven依赖

 <!-- 升级 apache dubbo -->
    <dependency>
      <groupId>org.apache.dubbo</groupId>
      <artifactId>dubbo</artifactId>
      <version>2.7.3</version>
    </dependency>
    <!-- Zookeeper -->
    <dependency>
      <groupId>org.apache.zookeeper</groupId>
      <artifactId>zookeeper</artifactId>
      <version>3.5.3-beta</version>
    </dependency>
    <dependency>
      <groupId>org.apache.curator</groupId>
      <artifactId>curator-framework</artifactId>
      <version>4.2.0</version>
    </dependency>
    <dependency>
      <groupId>org.apache.curator</groupId>
      <artifactId>curator-recipes</artifactId>
      <version>4.2.0</version>
    </dependency>

3.类文件编写

sdk接口编写：

package com.dobbu.sdk.services;

public interface ServiceProvider {
    String sayHello(String name);
}

provider类实现编写：

package com.dobbu.servicesimpl;

import com.dobbu.sdk.services.ServiceProvider;

public class ServiceProvideImpl implements ServiceProvider {
    @Override
    public String sayHello(String name) {
        return name+"hello  world";
    }
}

XML方式配置Dobbu

4.配置xml文件

在resource文件夹中配置xml文件
其中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="gerry" logger="log4j">
        <!--运维使用qos-->
        <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"/>-->
    <!--N/A代码没有注册中心-->
    <!--<dubbo:registry address="zookeeper://localhost:2181/"/>-->
    <!--zookeeper代表用的zookeeper注册中心，后面更的是zookeeper地址，倘若是集群又，逗号分隔，eg:192.16831.107:2181，192.16831.108:2181-->
    <!--<dubbo:registry address="zookeeper://localhost:2181/"/>-->
    <dubbo:registry address="zookeeper://localhost:2181/"/>

    <!--当前服务发布所依赖的协议；dubbo，webservice、Thrift、Hession、http-->
    <!--port:为启动的端口号-->
    <dubbo:protocol name="dubbo" port="20880"/>

    <!--服务发布的配置，需要暴露的服务接口类路径-->
    <dubbo:service
            interface="com.dobbu.sdk.services.ServiceProvider"
            ref="providerService"/>

    <!--Bean bean定义 暴露的服务接口对应实现类类路径-->
    <bean id="providerService" class="com.dobbu.servicesimpl.ServiceProvideImpl"/>
</beans>

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="fuchasheng" logger="log4j">
        <!--运维使用qos-->
        <dubbo:parameter key="qos.enable" value="true"/>
        <dubbo:parameter key="qos.accept.foreign.ip" value="false"/>
        <dubbo:parameter key="qos.port" value="55556"/>
    </dubbo:application>

    <!--监视-->
    <dubbo:monitor protocol="registry"/>

    <!--dubbo这个服务所要暴露的服务地址所对应的注册中心-->
    <!--<dubbo:registry address="N/A"/>-->
    
    <!--N/A代码没有注册中心-->
    <!--zookeeper代表用的zookeeper注册中心，后面更的是zookeeper地址，倘若是集群又，逗号分隔，eg:192.16831.107:2181，192.16831.108:2181-->
    <!--<dubbo:registry address="zookeeper://localhost:2181/"/>-->
    <dubbo:registry address="zookeeper://localhost:2181/"/>

    <!--调用方接口类路径-->
   <dubbo:reference id="serviceProvider" interface="com.dobbu.sdk.services.ServiceProvider"/>
</beans>

5.方法调用

provider:

public class App 
{
    public static void main(String[] args) throws IOException {
    //dubbo基于Spring
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("provider.xml");
        context.start();
        //等待输入避免程序退出
        System.in.read();
    }
}

consumer:

public class App 
{
    public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext("conusmer.xml");
        ServiceProvider serviceProvide = context.getBean(ServiceProvider.class);
        String result = serviceProvide.sayHello("负差生");
        System.out.println(result);
    }
}

6.测试结果

最先启动zookeeper，先启动提供方provider，再启动消费方，it’s OK

API方式配置Dobbu

4. 配置api

provider:直接调用时候配置api

package com.dobbu;

import com.dobbu.sdk.services.ServiceProvider;
import com.dobbu.servicesimpl.ServiceProvideImpl;
import org.apache.dubbo.config.ApplicationConfig;
import org.apache.dubbo.config.ProtocolConfig;
import org.apache.dubbo.config.RegistryConfig;
import org.apache.dubbo.config.ServiceConfig;

import java.io.IOException;

public class ApiAPP {
    public static void main(String[] args) throws IOException {
        // 需要Application
        ApplicationConfig appCfg = new ApplicationConfig();
        appCfg.setQosEnable(false);
        appCfg.setName("user-provider");
        appCfg.setOwner("fuchasheng");
        appCfg.setLogger("log4j");

        // 配置注册中心
        RegistryConfig registryConfig = new RegistryConfig();
        //设置注册中心协议和地址
        registryConfig.setAddress("zookeeper://localhost:2181");

        // 配置协议
        ProtocolConfig protocolConfig = new ProtocolConfig();
        protocolConfig.setName("dubbo");
        //端口号
        protocolConfig.setPort(20888);

        ServiceConfig<ServiceProvider> serviceConfig = new ServiceConfig();
        serviceConfig.setApplication(appCfg);
        serviceConfig.setRegistry(registryConfig);
        serviceConfig.setProtocol(protocolConfig);
        serviceConfig.setInterface(ServiceProvider.class);
        //写入实现
        serviceConfig.setRef(new ServiceProvideImpl());
        //设置新老接口版本
        serviceConfig.setVersion("1.0.0");
        //启动
        serviceConfig.export();
        System.in.read();
    }
}

consumer配置实现:

      // <dubbo:application name="consumer" owner="fuchasheng">
        //        <dubbo:parameter key="qos.enable" value="false"/>
        //    </dubbo:application>
        ApplicationConfig appCfg = new ApplicationConfig();

        appCfg.setQosEnable(false);
        appCfg.setLogger("log4j");
        appCfg.setOwner("fuchasheng");
        appCfg.setName("user-consumer");
        // <dubbo:registry address="zookeeper://localhost:2181" />
        RegistryConfig registryConfig = new RegistryConfig();
        registryConfig.setAddress("zookeeper://localhost:2181");

        // <dubbo:reference id="userService"
        //             interface="com.zhaoxi.dubbo.user.sdk.service.UserService"
        //             version="2.0.0"/>
        ReferenceConfig<ServiceProvider> referenceConfig = new ReferenceConfig<>();
        referenceConfig.setApplication(appCfg);
        referenceConfig.setRegistry(registryConfig);
        referenceConfig.setVersion("1.0.0");
        referenceConfig.setInterface(ServiceProvider.class);

        ServiceProvider userService = referenceConfig.get();
        String result = userService.sayHello("负差生");
        System.out.println(result);

5. 测试结果

注解方法配置Dubbo

4. 配置config配置类

provider的config类配置编写：

@Configuration // 标记配置类
@EnableDubbo(scanBasePackages = {"com.dobbu.servicesimpl"})//类实现的类路径
public class DubboProviderConfig {
    @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");
        applicationConfig.setQosEnable(false);
        applicationConfig.setOwner("fuchasheng");
        return applicationConfig;
    }

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


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

consumer的config配置编写：

package com.config;

import org.apache.dubbo.config.ApplicationConfig;
import org.apache.dubbo.config.RegistryConfig;
import org.apache.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;


@Configuration
@EnableDubbo(scanBasePackages = "com.annotation")  //dobbu调用包装类类路径
@ComponentScan("com.annotation")   //spring扫描包装为Bean对象
public class ConsumerConfig {
    @Bean // #1 服务消费方信息配置
    public org.apache.dubbo.config.ConsumerConfig consumerConfig() {
        org.apache.dubbo.config.ConsumerConfig consumerConfig = new org.apache.dubbo.config.ConsumerConfig();
        consumerConfig.setTimeout(1000);
        return consumerConfig;
    }

    @Bean // #2 分布式应用信息配置
    public ApplicationConfig applicationConfig() {
        ApplicationConfig applicationConfig = new ApplicationConfig();
        applicationConfig.setName("dubbo-annotation-consumer");
        applicationConfig.setQosEnable(false);
        applicationConfig.setOwner("fuchasheng");
        applicationConfig.setLogger("log4j");
        return applicationConfig;
    }

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

配置consumer映射版本实例类：

@Component
public class AnnotationConsumer {
    @DubboReference(version = "1.0.0")
    private UserService userService;

    public String addUser(User user) {
        return userService.addUser(user);
    }
}

在接口实现类上标注**@DubboService**注解

@DubboService(version = "1.0.0",timeout = 3000)
public class ServiceProvideImpl implements ServiceProvider {
    @Override
    public String sayHello(String name) {
        return name+"hello  world";
    }
}

5. 调用代码编写

provider调用编写：

       AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(DubboProviderConfig.class);
        context.start();
        System.in.read();

consumer调用编写：

    AnnotationConfigApplicationContext context =
                new AnnotationConfigApplicationContext(AnnocationConsumerConfig.class);
        ServiceProvider bean = context.getBean(ServiceProvider.class);
        System.out.println(bean.sayHello("负差生"));

6. 调用代码编写

It’s OK