Tutorial popular de Dubbo (2): Integração de Dubbo e Spring Boot

Pronto

Antes de tudo, precisamos construir o ambiente do zookeeper do centro de registro do Dubbo e da plataforma dubbo-admin do Dubbo. Como esse não é o foco deste artigo, vou ignorá-lo aqui.Os leitores que precisam conhecer os detalhes podem consultar as informações relevantes.

Construa o projeto

Criamos um projeto Spring Boot chamado dubbo-test e, em seguida, criamos três novos módulos no projeto, da seguinte maneira:

1. api: camada de interface, armazene a interface chamada pelo provedor e pelo consumidor
2. produtor: provedor, usado para fornecer implementação de interface aos consumidores
3. consumidor: consumidor, chame a implementação de interface fornecida pelo provedor remotamente

O diretório do projeto é o seguinte:

Implementação do módulo API

Definimos uma interface no módulo api, que é usado para modificar o nome.

package edu.szu.api.service;

/**
 * 修改名称的接口
 */
public interface NameService {
    String updateName(String name);
}

implementação do módulo produtor

Primeiro, precisamos apresentar a dependência relevante dubbo-spring-boot-starter e o módulo api implementado acima no módulo produtor.O arquivo pom é implementado da seguinte maneira:

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>edu.szu</groupId>
    <artifactId>producer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>producer</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- 引入api模块 -->
        <dependency>
            <groupId>edu.szu</groupId>
            <artifactId>api</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <!-- 引入dubbo环境 -->
        <dependency>
            <groupId>com.alibaba.boot</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>0.2.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Em seguida, precisamos escrever a implementação da interface NameService definida pelo módulo api. Note-se que precisamos adicionar a anotação @ com.alibaba.dubbo.config.annotation.Service na classe de implementação.

package edu.szu.producer.serviceImpl;

import com.alibaba.dubbo.config.annotation.Service;
import edu.szu.api.service.NameService;
import org.springframework.stereotype.Component;

@Component
@Service
public class NameServiceImpl implements NameService {

    @Override
    public String updateName(String name) {
        return "修改后的名称:" + name;
    }
}

Em seguida, adicione a anotação @EnableDubbo na classe de inicialização para iniciar o serviço Dubbo

package edu.szu.producer;

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

@SpringBootApplication
@EnableDubbo
public class ProducerApplication {

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

}

Por fim, modifique o arquivo de configuração.De fato, os comentários do arquivo de configuração já são muito detalhados.

server.port=8080
#提供方应用信息，用于计算依赖关系
dubbo.application.name=producer
#注册中心地址
dubbo.registry.address=127.0.0.1:2181
#使用zookeeper作为注册中心
dubbo.registry.protocol=zookeeper
#使用dubbo协议
dubbo.protocol.name=dubbo
#使用dubbo协议在20880端口暴露服务
dubbo.protocol.port=20880

implementação do módulo consumidor

Primeiro, introduza a dependência relevante dubbo-spring-boot-starter e o módulo api, o arquivo pom é o seguinte:

<?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 https://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.6.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>edu.szu</groupId>
    <artifactId>consumer</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>consumer</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <!-- 引入api模块 -->
        <dependency>
            <groupId>edu.szu</groupId>
            <artifactId>api</artifactId>
            <version>0.0.1-SNAPSHOT</version>
        </dependency>
        <!-- 引入dubbo环境 -->
        <dependency>
            <groupId>com.alibaba.boot</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>0.2.0</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

Em seguida, definimos a interface relevante implementada no consumidor

package edu.szu.consumer.service;

public interface ChangeService {
    String change(String name);
}

Em seguida, forneça uma implementação da interface.Aqui chamamos o serviço remoto nameService.Note-se que precisamos adicionar uma anotação @Reference à chamada interface de serviço remoto.

package edu.szu.consumer.serviceImpl;

import com.alibaba.dubbo.config.annotation.Reference;
import edu.szu.api.service.NameService;
import edu.szu.consumer.service.ChangeService;
import org.springframework.stereotype.Component;

@Component
public class ChangeServiceImpl implements ChangeService {

    @Reference
    NameService nameService;

    @Override
    public String change(String name) {
        return nameService.updateName(name);
    }
}

Em seguida, simplesmente implementamos a camada de controle

package edu.szu.consumer.controller;

import edu.szu.consumer.service.ChangeService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class ChangeController {

    @Autowired
    private ChangeService changeService;

    @RequestMapping("/change/{name}")
    public String change(@PathVariable("name") String name) {
        return changeService.change(name);
    }

}

Em seguida, adicione a anotação @EnableDubbo na classe de inicialização para iniciar o serviço Dubbo

package edu.szu.consumer;

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

@SpringBootApplication
@EnableDubbo
public class ConsumerApplication {

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

}

Por fim, modifique o arquivo de configuração

server.port=8081
#提供方应用信息，用于计算依赖关系
dubbo.application.name=consumer
#注册中心地址
dubbo.registry.address=127.0.0.1:2181
#使用zookeeper作为注册中心
dubbo.registry.protocol=zookeeper

Teste

Abrimos o tratador do centro de registro do Dubbo e, em seguida, iniciamos o produtor e o consumidor, respectivamente, digite http: // localhost: 8081 / change / HelloDubbo no navegador e descobrimos que a exibição é a seguinte:

mostra que o consumidor chamou com êxito o serviço fornecido pelo provedor remotamente .

Em seguida, iniciamos o dubbo-admin, que é exibido da seguinte forma: o

dubbo-admin monitorou com êxito nossos fornecedores e consumidores e, ao mesmo tempo, afirmou que nossa integração ao Dubbo e Spring Boot foi bem-sucedida.