Spring Boot整合Dubbo2.x,解决其中遇到的坑

2020/01/08 13:34
阅读数 135

 

Dubbo了解

a high-performance, java based open source RPC framework.

Dubbo官网 源码 文档

快速知道用法

本地服务 Spring 配置

local.xml:

<bean id=“xxxService” class=“com.xxx.XxxServiceImpl” />
<bean id=“xxxAction” class=“com.xxx.XxxAction”>
    <property name=“xxxService” ref=“xxxService” />
</bean>

远程服务 Spring 配置

在本地服务的基础上,只需做简单配置,即可完成远程化:

  • 将上面的 local.xml 配置拆分成两份,将服务定义部分放在服务提供方 remote-provider.xml,将服务引用部分放在服务消费方 remote-consumer.xml
  • 并在提供方增加暴露服务配置 <dubbo:service>,在消费方增加引用服务配置 <dubbo:reference>

remote-provider.xml:

<!-- 和本地服务一样实现远程服务 -->
<bean id=“xxxService” class=“com.xxx.XxxServiceImpl” /> 
<!-- 增加暴露远程服务配置 -->
<dubbo:service interface=“com.xxx.XxxService” ref=“xxxService” /> 

remote-consumer.xml:

<!-- 增加引用远程服务配置 -->
<dubbo:reference id=“xxxService” interface=“com.xxx.XxxService” />
<!-- 和本地服务一样使用远程服务 -->
<bean id=“xxxAction” class=“com.xxx.XxxAction”> 
    <property name=“xxxService” ref=“xxxService” />
</bean>

Spring Boot中使用Dubbo

阿里官方demo

dubbo-spring-boot-project

Dubbo Spring Boot (v0.1.0) : https://github.com/dubbo/dubbo-spring-boot-project
Dubbo (v2.0.1) : https://github.com/alibaba/dubbo
Google group : http://groups.google.com/group/dubbo

下面就给出一个完整整合案例,适合入门级别

官方给出的一些案例:dubbo-spring-boot-samples

项目模块

1.配置服务提供者

将服务提供者注册到注册中心
1. 引入dubbo和zkclient组件依赖
2. 配置dubbo的扫描包和注册中心的地址
3. 使用@Service发布服务

  1. pom.xml文件中添加需要的依赖
<!-- springboot整合dubbo的start包 -->
        <dependency>
            <groupId>com.alibaba.spring.boot</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>
        <!-- zookeeper相关的包  -->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.12</version>
        </dependency>
        <!-- 客户端连接zookeeper所需的包 引入ZooKeeper客户端工具 -->
        <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.9</version>
        </dependency>

 

  1. 公共接口,及其实现类

TicketService 接口

package com.gqz.ticket.service;

/** * @ClassName: TicketService * @author: ganquanzhong * @date: 2019/10/30 9:40 */
public interface TicketService {

    /** dubbo中的公共api * 获取票 */
    public String getTicket(String name);
}

TicketServiceImpl实现类

package com.gqz.ticket.service;

import com.alibaba.dubbo.config.annotation.Service;
import org.springframework.stereotype.Component;

/** * @ClassName: TicketServiceImpl * @author: ganquanzhong * @date: 2019/10/30 9:43 */


@Component
@Service(version = "1.0.0")  //Dubbo的注解,将服务发布出去
public class TicketServiceImpl implements TicketService {

    @Override
    public String getTicket(String name) {
        return name+"成功订购《银河补习班》电影票";
    }
}

  1. Spring Boot应用启动类

ProviderTicketApplication

package com.gqz.ticket;

import com.alibaba.dubbo.config.spring.context.annotation.DubboComponentScan;
import com.alibaba.dubbo.config.spring.context.annotation.EnableDubbo;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

/** * 1、 将服务提供者注册到注册中心 * 1.引入dubbo和zkclient组件依赖 * 2.配置dubbo的扫描包和注册中心的地址 * 3.使用@Service发布服务 */

@EnableDubbo()
@DubboComponentScan()
@SpringBootApplication
public class ProviderTicketApplication {

    public static void main(String[] args) {
        SpringApplication.run(ProviderTicketApplication.class, args);
    }

}

  1. application.properties 配置
    主要配置PRC框架和注册中心
#dubbo服务名称
dubbo.application.name =provider-ticket
# Base packages to scan Dubbo Component: @org.apache.dubbo.config.annotation.Service
dubbo.scan.base-packages = com.gqz.ticket.service

# Dubbo Application
## The default value of dubbo.application.name is ${spring.application.name}
## dubbo.application.name=${spring.application.name}

# Dubbo Protocol
# 通讯规则dubbo,hession...
dubbo.protocol.name=dubbo
#dubbo服务端口,我们无需知道dubbo服务运行在哪个端口,故也将其设为随机端口
dubbo.protocol.port=12345

## Dubbo Registry
#注册中心地址, 如果搭建是集群,所以用逗号分开 192.168.1.112:2181,192.168.1.112:2182,192.168.1.112:2183
dubbo.registry.protocol=zookeeper
dubbo.registry.address=192.168.1.112:2181

到这里,服务提供者就配置完成了,可以启动应用将服务发布到注册中

2.配置服务调用者

调用注册中的服务,完成自己的业务
1.引入依赖Dubbo和zkClient
2.配置dubbo的注册中心地址
3.引用服务

  1. pom.xml文件中添加需要的依赖
<!-- springboot整合dubbo的start包 -->
        <dependency>
            <groupId>com.alibaba.spring.boot</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>2.0.0</version>
        </dependency>
        <!-- zookeeper相关的包 -->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.12</version>
        </dependency>
        <!-- 客户端连接zookeeper所需的包 引入ZooKeeper客户端工具 -->
        <dependency>
            <groupId>com.101tec</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.9</version>
        </dependency>
  1. 公共接口(需要和服务提供者的路径相同),自身的业务
    在这里插入图片描述

TicketService公共接口

package com.gqz.ticket.service;

/** * @ClassName: TicketService * @author: ganquanzhong * @date: 2019/10/30 9:40 */
public interface TicketService {

    /** dubbo中的公共api * 获取票 */
    public String getTicket(String name);
}

UserService自身的业务,调用远程ticketService服务

package com.gqz.user.service;

import com.alibaba.dubbo.config.annotation.Reference;
import com.gqz.ticket.service.TicketService;
import org.springframework.stereotype.Service;

/** * 调用远程RPC Remote Procedure Call * 调用com.gqz.ticket.service.TicketService中的服务 * * @ClassName: UserService * @author: ganquanzhong * @date: 2019/10/30 9:48 */

@Service
public class UserService {

    /** * @Reference注解 通过 @Reference 注入TicketService * 是通过全类名引用 */
    @Reference(version = "1.0.0", url = "dubbo://127.0.0.1:12345")
    TicketService ticketService;

    //调用远程接口的服务
    public void orderTicket(String name){
        System.out.println(ticketService.getTicket(name));
    }

}

  1. properties配置
# 配置Dubbo
#dubbo服务名称
dubbo.application.name =consumer-user

#通讯规则
dubbo.protocol.name=dubbo

#注册中心地址
dubbo.registry.protocol=zookeeper
dubbo.registry.address=192.168.1.112:2181
  1. 测试Test

ConsumerUserApplicationTests测试

package com.gqz.user;

import com.gqz.user.service.UserService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

@SpringBootTest
class ConsumerUserApplicationTests {

    @Autowired
    UserService userService;

    @Test
    void testRPC() {
        System.out.println("调用RPC provider中的订票业务");
        userService.orderTicket("甘全中-陈蓉");
    }

}

运行成功!!
success

issue&空指针

在这里插入图片描述
服务者必须运行,提供服务

其中经常遇到空指针异常,不能调用远程的服务主要是Dubbo配置、注解、版本等问题。严格参照官方的demo,不同版本可能出现一些架构方面的变更。

Dubbo Spring Boot 工程

Dubbo Apache Dubbo™ 是一款高性能Java RPC框架。
Spring Boot 应用场景的开发。同时也整合了 Spring Boot 特性:

Apache Dubbo |ˈdʌbəʊ| 是一款高性能、轻量级的开源Java RPC框架,它提供了三大核心能力:面向接口的远程方法调用,智能容错和负载均衡,以及服务自动注册和发现。

English README

已发行版本

您可以为您的工程引入最新 dubbo-spring-boot-starter 的发布,增加以下依赖到工程的 pom.xml 文件中:

<properties>
    <spring-boot.version>2.1.1.RELEASE</spring-boot.version>
    <dubbo.version>2.7.3</dubbo.version>
</properties>
    
<dependencyManagement>
    <dependencies>
        <!-- Spring Boot -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>${spring-boot.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>

        <!-- Apache Dubbo -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-dependencies-bom</artifactId>
            <version>${dubbo.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>

        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo</artifactId>
            <version>${dubbo.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>org.springframework</groupId>
                    <artifactId>spring</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>javax.servlet</groupId>
                    <artifactId>servlet-api</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>log4j</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <!-- Dubbo Spring Boot Starter -->
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-spring-boot-starter</artifactId>
        <version>2.7.3</version>
    </dependency>
    
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo</artifactId>
    </dependency>
</dependencies>

如果您的工程遇到了依赖问题, 请尝试添加如下 Maven 参考到工程的 pom.xml 文件中:

<repositories>
    <repository>
        <id>apache.snapshots.https</id>
        <name>Apache Development Snapshot Repository</name>
        <url>https://repository.apache.org/content/repositories/snapshots</url>
        <releases>
            <enabled>false</enabled>
        </releases>
        <snapshots>
            <enabled>true</enabled>
        </snapshots>
    </repository>
</repositories>

历史版本

如果您现在使用的Dubbo版本低于2.7.0,请使用如下对应版本的Dubbo Spring Boot:

Dubbo Spring Boot Dubbo Spring Boot
0.2.1.RELEASE 2.6.5+ 2.x
0.1.2.RELEASE 2.6.5+ 1.x

源代码构建

如果您需要尝试最新 dubbo-spring-boot-project 的特性,您可将当前工程手动 Maven install 到本地 Maven 仓库:

  1. Maven install 当前工程

Maven install = mvn install

快速开始

如果您对 Dubbo 不是非常了解,耽误您几分钟访问 http://dubbo.apache.org/ 。了解后,如果您期望更深入的探讨,可以移步用户手册

通常情况 , Dubbo 应用有两种使用场景 , 其一为 Dubbo 服务提供方 , 另外一个是 Dubbo 服务消费方,当然也允许两者混合,下面我们一起快速开始!

首先,我们假设存在一个 Dubbo RPC API ,由服务提供方为服务消费方暴露接口 :

public interface DemoService {

    String sayHello(String name);

}

实现 Dubbo 服务提供方

  1. 实现 DemoService 接口

    @Service(version = "1.0.0")
    public class DefaultDemoService implements DemoService {
    
        /** * The default value of ${dubbo.application.name} is ${spring.application.name} */
        @Value("${dubbo.application.name}")
        private String serviceName;
    
        public String sayHello(String name) {
            return String.format("[%s] : Hello, %s", serviceName, name);
        }
    }
    
  2. 编写 Spring Boot 引导程序

    @EnableAutoConfiguration
    public class DubboProviderDemo {
    
        public static void main(String[] args) {
            SpringApplication.run(DubboProviderDemo.class,args);
        }
    }
    
  3. 配置 application.properties :

    # Spring boot application
    spring.application.name=dubbo-auto-configuration-provider-demo
    # Base packages to scan Dubbo Component: @org.apache.dubbo.config.annotation.Service
    dubbo.scan.base-packages=org.apache.dubbo.spring.boot.demo.provider.service
    
    # Dubbo Application
    ## The default value of dubbo.application.name is ${spring.application.name}
    ## dubbo.application.name=${spring.application.name}
    
    # Dubbo Protocol
    dubbo.protocol.name=dubbo
    dubbo.protocol.port=12345
    
    ## Dubbo Registry
    dubbo.registry.address=N/A
    

实现 Dubbo 服务消费方

  1. 通过 @Reference 注入 DemoService :

    @EnableAutoConfiguration
    public class DubboAutoConfigurationConsumerBootstrap {
    
        private final Logger logger = LoggerFactory.getLogger(getClass());
    
        @Reference(version = "1.0.0", url = "dubbo://127.0.0.1:12345")
        private DemoService demoService;
    
        public static void main(String[] args) {
            SpringApplication.run(DubboAutoConfigurationConsumerBootstrap.class).close();
        }
    
        @Bean
        public ApplicationRunner runner() {
            return args -> {
                logger.info(demoService.sayHello("mercyblitz"));
            };
        }
    }
    
  2. 配置 application.yml :

    spring:
      application:
        name: dubbo-auto-configure-consumer-sample
    

请确保 Dubbo 服务提供方服务可用, DubboProviderDemo 运行方可正常。

更多的实现细节,请参考 Dubbo 示例

社区交流

如果您在使用 Dubbo Spring Boot 中遇到任何问题或者有什么建议? 我们非常需要您的支持!

  • 如果您需要升级版本,请提前阅读发布公告,了解最新的特性和问题修复。
  • 如果您遇到任何问题 ,您可以订阅 Dubbo 用户邮件列表
  • 问题反馈,您可以在 issues 提出您遇到的使用问题。

模块工程

Dubbo Spring Boot 采用多 Maven 模块工程 , 模块如下:

dubbo-spring-boot-parent

dubbo-spring-boot-parent 模块主要管理 Dubbo Spring Boot 工程的 Maven 依赖

dubbo-spring-boot-autoconfigure

dubbo-spring-boot-autoconfigure 模块提供 Spring Boot’s @EnableAutoConfiguration 的实现 - DubboAutoConfiguration
它简化了 Dubbo 核心组件的装配。

dubbo-spring-boot-actuator

dubbo-spring-boot-actuator 提供 Production-Ready 特性:

dubbo-spring-boot-starter

dubbo-spring-boot-starter 模块为标准的 Spring Boot Starter ,
当您将它引入到工程后,dubbo-spring-boot-autoconfigure 模块会一同被间接依赖。

dubbo-spring-boot-samples

Dubbo Spring Boot 示例工程包括:

 

展开阅读全文
打赏
0
0 收藏
分享
加载中
更多评论
打赏
0 评论
0 收藏
0
分享
返回顶部
顶部