Spring Boot integra Dubbo 3.X

Preste atenção em Wang Youzhi , um pescador de ouro mútuo que compartilha a tecnologia Java
hard - core

No artigo anterior conhecemos Dubbo e RPC juntos, hoje vamos aprender como usar Dubbo e integrar Dubbo em projetos Spring Boot. Vamos dar uma olhada nos softwares e versões a serem usados ​​hoje:

Programas	Versão	ilustrar
Java	11
bota de mola	2.7.13	A partir do Spring Boot 3.0, o suporte mínimo é Java 17
dublagem	3.2.2
Funcionário do zoológico	3.8.1	Como o centro de registro de Dubbo

Não há requisito obrigatório para a seleção do centro de registro, aqui tomamos o Zookeeper como exemplo para demonstrar.

DICAS : Hoje trataremos apenas da integração de Spring Boot, Dubbo e Zookeeper, e não envolveremos a integração de outros frameworks.

Implantar Zookeeper

Vamos implantar um Zookeeper primeiro. Aqui, forneço um tutorial de implantação para Windows e Linux. Se você o implantou com sucesso, pode pular esta parte.

A primeira é baixar o Zookeeper , aqui escolhemos a versão Zookeeper-3.8.1.

No Linux, você pode usar wgeto comando para baixar:

wget https://archive.apache.org/dist/zookeeper/zookeeper-3.8.1/apache-zookeeper-3.8.1-bin.tar.gz

Dicas : Nota, aqui baixamos o arquivo apache-zookeeper-3.8.1-bin.tar.gz .

Implantar o Zookeeper no Linux

Descompacte o Zookeeper:

tar -zxvf apache-zookeeper-3.8.1-bin.tar.gz

Arquivo de configuração do Zookeeper, o arquivo de configuração está localizado ../Zookeeper/confno diretório, copie o arquivo zoo_sample.cfg e nomeie-o como zoo.cfg:

cp zoo_sample.cfg zoo.cfg

No estudo do Dubbo, podemos usar a configuração padrão do Zookeeper, portanto não precisamos modificar o zoo.cfg aqui.

Modifique o arquivo de perfil:

vim /etc/profile

Adicione a configuração do Zookeeper ao arquivo de perfil:

export ZOOKEEPER_HOME=/opt/opt/apache-zookeeper-3.8.1-bin
export PATH=$ZOOKEEPER_HOME/bin:$PATH
export PATH

Atualize o arquivo de perfil:

source profile

Iniciar Zookeeper:

zkServer.sh start

Em circunstâncias normais, o log será gerado:

ZooKeeper JMX enabled by default
Using config: /opt/apache-zookeeper-3.8.1-bin/bin/../conf/zoo.cfg
Starting zookeeper ... STARTED

Você pode usar o comando para visualizar o status do Zookeeper:

zkServer.sh status

O status autônomo gera os seguintes logs:

ZooKeeper JMX enabled by default
Using config: /opt/apache-zookeeper-3.8.1-bin/bin/../conf/zoo.cfg
Client port found: 2181. Client address: localhost. Client SSL: false.
Mode: standalone

Até agora, implantamos com sucesso uma versão autônoma simples e utilizável do Zookeeper no servidor Linux.

Zookeeper de implantação do Windows

Consulte as etapas de implantação do Zookeeper no Linux para modificar o arquivo de configuração. No Windows, precisamos modificar o caminho de dataDir e adicionar o caminho de dataLogDir:

tickTime=2000
initLimit=10
syncLimit=5
dataDir=D:\\Apache\\Apache Zookeeper 3.8.1\\data
dataLogDir=D:\\Apache\\Apache Zookeeper 3.8.1\\logs
clientPort=2181

Caso a variável de ambiente JAVA_HOME não esteja configurada no sistema, precisamos modificar a configuração JAVA_HOME no zkEnv.cmd, que está localizado no diretório ../Apache Zookeeper/bin:

@echo off
REM Licensed to the Apache Software Foundation (ASF) under one or more
REM contributor license agreements.  See the NOTICE file distributed with
REM this work for additional information regarding copyright ownership.
REM The ASF licenses this file to You under the Apache License, Version 2.0
REM (the "License"); you may not use this file except in compliance with
REM the License.  You may obtain a copy of the License at
REM
REM     http://www.apache.org/licenses/LICENSE-2.0
REM
REM Unless required by applicable law or agreed to in writing, software
REM distributed under the License is distributed on an "AS IS" BASIS,
REM WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
REM See the License for the specific language governing permissions and
REM limitations under the License.

set ZOOCFGDIR=%~dp0%..\conf
set ZOO_LOG_DIR=%~dp0%..\logs

REM for sanity sake assume Java 1.6
REM see: http://java.sun.com/javase/6/docs/technotes/tools/windows/java.html

REM add the zoocfg dir to classpath
set CLASSPATH=%ZOOCFGDIR%

REM make it work in the release
SET CLASSPATH=%~dp0..\*;%~dp0..\lib\*;%CLASSPATH%

REM make it work for developers
SET CLASSPATH=%~dp0..\build\classes;%~dp0..\build\lib\*;%CLASSPATH%

set ZOOCFG=%ZOOCFGDIR%\zoo.cfg

@REM setup java environment variables

if not defined JAVA_HOME (
  echo Error: JAVA_HOME is not set.
  goto :eof
)

set JAVA_HOME=%JAVA_HOME%

if not exist "%JAVA_HOME%"\bin\java.exe (
  echo Error: JAVA_HOME is incorrectly set: %JAVA_HOME%
  echo Expected to find java.exe here: %JAVA_HOME%\bin\java.exe
  goto :eof
)

REM strip off trailing \ from JAVA_HOME or java does not start
if "%JAVA_HOME:~-1%" EQU "\" set "JAVA_HOME=%JAVA_HOME:~0,-1%"
 
set JAVA="%JAVA_HOME%"\bin\java

Avançamos da linha 41 set JAVA_HOME=%JAVA_HOME%para a linha 36, ​​configuramos antes de julgar se JAVA_HOME existe na variável de ambiente e usamos um caminho completo, como: set JAVA_HOME=D:\Java\jdk11.0.18.

Após a conclusão da modificação do conteúdo acima, clique duas vezes diretamente para executar zkServer.cmd para iniciar o Zookeeper. Observe que pode haver vários erros ao iniciar no Windows, os mais comuns são flashbacks de inicialização. Neste momento, você pode iniciar o zkServer.cmd no PowerShell para visualizar o log para resolver o problema:

cd D:
PS D:\> cd '.\Apache\Apache Zookeeper 3.8.1\bin\'
PS D:\Apache\Apache Zookeeper 3.8.1\bin> .\zkServer.cmd

Ok, aqui você deve ter concluído a implantação do Zookeeper e, em seguida, integraremos o Dubbo no aplicativo Spring Boot.

Integração de formulário XML do Dubbo

Primeiramente, preparamos dois projetos, DubboProviderXML e DubboConsumerXML, para imitar o provedor de serviço e o consumidor de serviço, e pulamos a parte de criar o projeto diretamente, acredito que todos não terão problemas nesta etapa.

Além disso, o Dubbo fornece oficialmente o andaime do projeto Dubbo Initializer , que é conveniente para todos criarem projetos Dubbo rapidamente:

O uso é semelhante ao Spring Initializr :

Dicas :

• Claro, você também pode simular o provedor e o consumidor no mesmo projeto;

• Spring Initializr é estritamente um erro de digitação, mas todos aceitaram essa abordagem e há uma discussão sobre o nome no V2EX .

Projeto DubboProviderXML

Criou dois subprojetos no projeto DubboProviderXML:

• provedor-api, declara a interface RPC

• provedor de serviço, a implementação da lógica de negócios principal

Neste momento, a estrutura do projeto é a seguinte:

Agora modifique o arquivo POM do projeto DubboProviderXML:

<modelVersion>4.0.0</modelVersion>
<groupId>com.wyz</groupId>
<artifactId>DubboProviderXML</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>pom</packaging>
<name>DubboProviderXML</name>
<description>DubboProviderXML</description>

<properties>
    <maven.compiler.source>11</maven.compiler.source>
    <maven.compiler.target>11</maven.compiler.target>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>

<modules>
    <module>provider-api</module>
    <module>provider-service</module>
</modules>

Normalmente adicionarei dependências que todos os subprojetos usarão no projeto DubboProviderXML, como: lombok, commons-lang3, etc. Ignoramos esta parte aqui.

Configurar a API do provedor

Em seguida, processe o arquivo POM no provedor-api do subprojeto:

<modelVersion>4.0.0</modelVersion>
<parent>
    <groupId>com.wyz</groupId>
    <artifactId>DubboProviderXML</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</parent>
<artifactId>provider-api</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>provider-api</name>
<packaging>jar</packaging>
<description>provider-api</description>

Em seguida, declare a interface RPC em provider-api:

package com.wyz.api;

/**
 * @author wyz
 * @version 1.0
 * @date 2023/6/28
 */
public interface DubboDemoXMLService {
    String say(String message);
}

Dessa forma, a configuração da API do provedor é concluída e o DubboProviderXML tem uma entrada para fornecer serviços RPC para o mundo externo.

Dicas : Provider-api precisa ser empacotado em um jar para DubboConsumerXML usar.

Configurar provedor-serviço

Em seguida, configuramos o arquivo POM do provedor-serviço do subprojeto:

<modelVersion>4.0.0</modelVersion>
<parent>
    <groupId>com.wyz</groupId>
    <artifactId>DubboProviderXML</artifactId>
    <version>0.0.1-SNAPSHOT</version>
</parent>
<artifactId>provider-service</artifactId>
<version>0.0.1-SNAPSHOT</version>
<name>provider-service</name>
<description>provider-service</description>

<properties>
    <spring.boot.version>2.7.13</spring.boot.version>
    <dubbo.version>3.2.2</dubbo.version>
    <zookeeper.version>3.8.1</zookeeper.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
        <version>${spring.boot.version}</version>
    </dependency>
  
    <!-- dubbo-spring-boot-starter引入了dubbo -->
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-spring-boot-starter</artifactId>
        <version>${dubbo.version}</version>
    </dependency>
  
    <!-- DUbbo与Zookeeper的连接器 -->
    <!-- curator5自身引入了Zookeeper的依赖，因此无需额外引入 -->
    <dependency>
        <groupId>org.apache.dubbo</groupId>
        <artifactId>dubbo-dependencies-zookeeper-curator5</artifactId>
        <version>${dubbo.version}</version>
        <type>pom</type>
    </dependency>
    
    <dependency>
        <groupId>com.wyz</groupId>
        <artifactId>provider-api</artifactId>
        <version>0.0.1-SNAPSHOT</version>
    </dependency>
</dependencies>

Em seguida, implementamos esta interface em provider-service:

package com.wyz.service.impl;

import com.wyz.DubboDemoXMLService;

/**
 * @author wyz
 * @version 1.0
 * @date 2023/7/3
 */
public class DubboDemoXMLServiceImpl implements DubboDemoXMLService {

    @Override
    public String say(String message) {
        return "XML Provider say : " + message;
    }
}

Agora temos a interface e a implementação da interface, só precisamos configurar como um serviço Dubbo, e adicionar o arquivo dubbo-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://dubbo.apache.org/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://dubbo.apache.org/schema/dubbo
        http://dubbo.apache.org/schema/dubbo/dubbo.xsd">

    <!-- Dubbo的基本配置-->
    <dubbo:application name="DubboProviderXML" qos-port="2222"/>
    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
    <dubbo:protocol name="dubbo"/>

    <!-- 配置提供的服务dubboDemoXMLServiceImpl -->
    <bean id="dubboDemoXMLServiceImpl" class="com.wyz.service.impl.DubboDemoXMLServiceImpl"/>
    <dubbo:service interface="com.wyz.api.DubboDemoXMLService" ref="dubboDemoXMLServiceImpl"/>
</beans>

Depois de concluídas todas as configurações, importamos o arquivo dubbo-provider.xml:

package com.wyz.service;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ImportResource;

/**
 * @author wyz
 * @version 1.0
 * @date 2023/7/3
 */
@SpringBootApplication
@ImportResource(locations = "classpath:dubbo-provider.xml")
public class ProviderServiceApplication {

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

Neste ponto nosso projeto DubboProviderXML está configurado, neste momento a estrutura do projeto é a seguinte:

Projeto DubboConsumerXML

Continuamos a configurar o projeto DubboConsumerXML do consumidor do serviço, o processo geral é basicamente o mesmo da configuração do DubboProviderXML, avançamos diretamente para a parte de configuração no serviço do consumidor.

Deploymentconsumer-service

O arquivo POM do serviço ao consumidor é exatamente o mesmo que o serviço de provedor do subprojeto do projeto DubboProviderXML, portanto, pulamos esta parte diretamente.

Em seguida, implemente a chamada para DubboDemoXMLService#say:

package com.wyz.service.impl;

import com.wyz.DubboDemoXMLService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

/**
 * @author wyz
 * @version 1.0
 * @date 2023/7/3
 */
@Component
public class DubboConsumerXMLService implements CommandLineRunner {

    @Autowired
    DubboDemoXMLService dubboDemoXMLServiceImpl;

    @Override
    public void run(String... args) {
        String message = dubboDemoXMLServiceImpl.say("wyz");
        System.out.println(message);
    }
}

Em seguida adicionamos um novo arquivo dubbo-consumer.xml para configurar o serviço a ser chamado pelo consumidor:

<?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://dubbo.apache.org/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://dubbo.apache.org/schema/dubbo
        http://dubbo.apache.org/schema/dubbo/dubbo.xsd">

    <!-- Dubbo的基本配置-->
    <dubbo:application name="DubboConsumerXML" qos-port="2223"/>
    <dubbo:registry address="zookeeper://106.75.33.232:2181"/>
    <dubbo:protocol name="dubbo"/>
  
    <!-- 配置需要调用的服务 -->
    <dubbo:reference id="DubboDemoXMLService" interface="com.wyz.api.DubboDemoXMLService"/>
</beans>

Da mesma forma, importamos o arquivo dubbo-consumer.xml:

package com.wyz.service;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.ImportResource;

/**
 * @author wyz
 * @version 1.0
 * @date 2023/7/3
 */
@SpringBootApplication
@ImportResource(locations = "classpath:dubbo-consumer.xml")
public class ConsumerServiceApplication {

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

Por fim, iniciamos o programa, o console deve gerar o seguinte log:

Neste momento, a estrutura do projeto DubboConsumerXML é a seguinte:

Integração do formulário de anotação do Dubbo

Além de usar XML, também podemos usar anotações para configurar o Dubbo (afinal muita gente não gosta de XML). Da mesma forma, precisamos criar dois projetos DubboProviderAnnotation e DubboConsumerAnnotation primeiro.

Projeto DubboProviderAnnotation

As etapas de configuração do projeto DubboProviderAnnotation são basicamente as mesmas do DubboProviderXML. Vamos avançar rapidamente para a parte de implementação da interface. Desta vez, precisamos usar anotações @DubboServicepara declarar que este é um serviço Dubbo:

package com.wyz.service.impl;

import com.wyz.api.DubboProviderAnnotationService;
import org.apache.dubbo.config.annotation.DubboService;

/**
 * @author wyz
 * @version 1.0
 * @date 2023/7/3
 */
@DubboService
public class DubboProviderAnnotationServiceImpl implements DubboProviderAnnotationService {

    @Override
    public String say(String message) {
        return "DubboProviderAnnotationService say : " + message;
    }
}

Com a interface e a implementação, vamos configurar o conteúdo relevante do Dubbo. Desta vez, usamos a configuração YAML:

dubbo:
  application:
    name: DubboProviderAnnotation
    qos-port: 2222
  protocol:
    name: dubbo
  registry:
    address: zookeeper://${zookeeper.address:127.0.0.1}:2181

Em seguida, adicionamos anotações à classe de inicialização @EnableDubbopara habilitar a injeção automática de Dubbo:

package com.wyz.service;

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

/**
 * @author wyz
 * @version 1.0
 * @date 2023/7/3
 */
@SpringBootApplication
@EnableDubbo
public class ProviderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProviderServiceApplication.class, args);
    }
}

Neste momento, a estrutura de DubboProviderAnnotation é a seguinte:

Por fim, podemos iniciar o projeto DubboProviderAnnotation normalmente.

Projeto DubboConsumerAnnotation

Com a base anterior, acredito que você possa pensar em como configurar o DubboConsumerAnnotation. Vamos escrever a DubboDemoAnnotationService#saylógica da chamada primeiro e depois @DubboReferenceinjetar a interface:

package com.wyz.service.impl;

import com.wyz.api.DubboProviderAnnotationService;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.boot.CommandLineRunner;
import org.springframework.stereotype.Component;

/**
 * @author wyz
 * @version 1.0
 * @date 2023/7/3
 */
@Component
public class DubboConsumerAnnotationService implements CommandLineRunner {

    @DubboReference
    DubboProviderAnnotationService dubboProviderAnnotationService;

    @Override
    public void run(String... args) {
        String message = dubboProviderAnnotationService.say("wyz");
        System.out.println(message);
    }
}

Em seguida, configure o arquivo YAML:

dubbo:
  application:
    name: DubboConsumerAnnotation
    qos-port: 2223
  protocol:
    name: dubbo
  registry:
    address: zookeeper://${zookeeper.address:127.0.0.1}:2181

Da mesma forma, precisamos adicionar @EnableDubboanotações no lado do consumidor do serviço para habilitar a injeção automática do Dubbo:

package com.wyz.service;

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

/**
 * @author wyz
 * @version 1.0
 * @date 2023/7/3
 */
@SpringBootApplication
@EnableDubbo
public class ConsumerServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConsumerServiceApplication.class, args);
    }
}

Neste momento, a estrutura de DubboConsumerAnnotation é a seguinte:

Por fim, podemos iniciar o projeto DubboConsumerAnnotation normalmente.

epílogo

Até agora, concluímos duas formas de integração do Dubbo 3.X no Spring Boot. De um modo geral, optarei por usar XML para configurar os serviços fornecidos pelo Dubbo, mas optarei por configurar as informações básicas do Dubbo, como: tipo de protocolo, endereço do centro de registro etc., no arquivo YAML, que é para gerenciamento unificado de serviços fornecidos externamente E os serviços usados, você pode ver rapidamente quais recursos o projeto oferece e de quais interfaces externas ele depende.

Bem, isso é tudo por hoje. Se este artigo for útil para você, dê um joinha . Por fim, dê as boas-vindas a todos para prestar atenção em Wang Youzhi, um pescador , e até a próxima!