手把手教你Dubbo与SpringBoot常用两种方式整合

一、Dubbo整合SpringBoot的方式(1)


1)直奔主题，方式一：

　　pom.xml中引入dubbo-starter依赖，在application.properties配置属性，使用@Service【暴露服务】使用@Reference【引用服务】，选取的是application.properties+部分注解的方式来完成。

2)创建ego_interface接口模块,被提供者和消费者所使用

此模块目录结构如下：

1、实体类UserAddress

package com.sxt.domain;
import java.io.Serializable;

//实体类 必须实现序列化
public class UserAddress implements Serializable {

    private Integer id;
    private String address;
    private String userId;

    public UserAddress() {
    }
    public UserAddress(Integer id, String address, String userId) {
        this.id = id;
        this.address = address;
        this.userId = userId;
    }

    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public String getUserId() {
        return userId;
    }
    public void setUserId(String userId) {
        this.userId = userId;
    }
}

2、提供者接口UserService

package com.sxt.service;
import com.sxt.domain.UserAddress;
import java.util.List;
//提供者接口
public interface UserService {

    //根据用户id查询用户地址
    public List<UserAddress> getUserAddressByUserId(String userId);
}

3、消费者接口OrderService

package com.sxt.service;
import com.sxt.domain.UserAddress;
import java.util.List;
//消费者接口
public interface OrderService{

    //初始化订单
    public List<UserAddress> initOrder(String userId);
}

3)创建boot-ego-user-service-provider提供者模块

此模块目录结构如下(config是第二种方式用的,此处请先忽略)：

4)修改pom.xml加入依赖

添部分关键依赖(其余自动生成)：

    <!--加入对ego_interface依赖-->　　<!--这个是上面第二步创建的你所要使用的接口类的依赖-->
<dependency>
    <groupId>com.sxt</groupId>
    <artifactId>ego_interface</artifactId>
    <version>1.0-SNAPSHOT</version>
</dependency>
        <!-- Dubbo Spring Boot Starter -->
<dependency>
     <groupId>org.apache.dubbo</groupId>
     <artifactId>dubbo-spring-boot-starter</artifactId>
     <version>${dubbo.version}</version>
</dependency>
        <!-- 使用zk 做注册中心，Dubbo 需要的依赖 -->
<dependency>
      <groupId>org.apache.dubbo</groupId>
      <artifactId>dubbo-dependencies-zookeeper</artifactId>
      <version>${dubbo.version}</version>
      <type>pom</type>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
</dependency>

1、编写UserServiceImpl

package com.sxt.service.impl;

import com.sxt.domain.UserAddress;
import com.sxt.service.UserService;
import org.apache.dubbo.config.annotation.Service;
import java.util.ArrayList;
import java.util.List;

//此处service是apache.dubbo的 代替了创建和暴露对象
@Service
public class UserServiceImpl implements UserService {

    public static List<UserAddress> address=new ArrayList<>();

    static {
        address.add(new UserAddress(1, "天安门广场", "bj"));
        address.add(new UserAddress(2, "上海迪士尼", "sh"));
    }

    @Override
    public List<UserAddress> getUserAddressByUserId(String userId) {
        return address;
    }
}

2、修改application.properties

#application-name 本模块名字
dubbo.application.name=boot-ego-user-service-provider
#registry 指定注册中心地址(www.lcbxiuxiu.tech是我阿里云地址 请换成你自己的服务器地址)
dubbo.registry.address=zookeeper://www.lcbxiuxiu.tech:2181
#dubbo protocol 指定dubbo协议 将服务暴露在20880端口
dubbo.protocol.name=dubbo
dubbo.protocol.port=20880

3、修改启动类并启动

@SpringBootApplication
//此注解为了自动开启dubbo
@EnableDubbo
public class BootEgoUserServiceProviderApplication {
  public static void main(String[] args) {
        SpringApplication.run(BootEgoUserServiceProviderApplication.class, args);
    }
}

4、启动成功后画面在远程dubbo访问

5)创建boot-ego-order-service-comsumer消费者模块

此模块目录结构如下(config是第二种方式用的,此处请先忽略)：

1、修改pom.xml

<?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.2.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.sxt</groupId>
    <artifactId>boot-ego-order-service-comsumer</artifactId>
    <version>1.0</version>
    <name>boot-ego-order-service-comsumer</name>
    <description>springboot集成dubbo的消费者</description>

    <properties>
        <java.version>1.8</java.version>
        <dubbo.version>2.7.3</dubbo.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-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </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>
        <!--加入对ego_interface依赖-->
        <dependency>
            <groupId>com.sxt</groupId>
            <artifactId>ego_interface</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>

        <!-- Dubbo Spring Boot Starter -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>${dubbo.version}</version>
        </dependency>
        <!-- 使用zk 做注册中心，Dubbo 需要的依赖 -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo-dependencies-zookeeper</artifactId>
            <version>${dubbo.version}</version>
            <type>pom</type>
            <exclusions>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

    </dependencies>

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

</project>

2、创建OrderServiceImpl

package com.sxt.service.impl;

import com.sxt.domain.UserAddress;
import com.sxt.service.OrderService;
import com.sxt.service.UserService;
import org.springframework.stereotype.Service;
import org.apache.dubbo.config.annotation.Reference;

import java.util.List;

@Service  //此处是spring的 帮你自动创建对象与注入
public class OrderServiceImpl implements OrderService {

    @Reference //此处是apache.dubbo 代替引入远程对象
    private UserService userService;

    public void setUserService(UserService userService) {
        this.userService = userService;
    }

    @Override
    public List<UserAddress> initOrder(String userId) {
        return this.userService.getUserAddressByUserId(userId);
    }

}

3、修改启动类并启动

package com.sxt;

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

@SpringBootApplication
@EnableDubbo
public class BootEgoOrderServiceComsumerApplication {

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

4、在测试类中测试

package com.sxt;

import com.sxt.domain.UserAddress;
import com.sxt.service.OrderService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.io.IOException;
import java.util.List;

@SpringBootTest
class BootEgoOrderServiceComsumerApplicationTests {

    @Autowired
    OrderService orderService;

    @Test
        void contextLoads() throws IOException {
        List<UserAddress> userAddresses = orderService.initOrder("sxt");
        for (UserAddress userAddress : userAddresses) {
            System.out.println(userAddress.getId()+" "+userAddress.getAddress());
        }
        //想在dubbo首页显示消费者 阻止程序停止
        System.in.read();
    }

}

5、修改application.properties后启动上面的测试类即可

#application.name
dubbo.application.name=boot-ego-order-service-comsumer
#address
dubbo.registry.address=zookeeper://自己的服务器地址:2181

小结第一种方式：

　　1.提供者只需要在application.properties中声明：模块名字，注册中心地址，连接规则(使用什么协议，暴露什么端口)。其余的由service实现类中的@service(apache.dubbo)注解帮忙创建和暴露了对象

　　2.消费者只需要在application.properties中声明：模块名字，注册中心地址。其余由service实现类中的@service(spring的)注解帮忙创建和注入对象，@Reference(apache.dubbo)帮忙引入远程服务，在测试类中就可以使用@Autowired装配对象使用其方法

原文地址：https://www.cnblogs.com/lcbxiuxiu/p/12202627.html

时间： 2024-10-08 23:15:06

手把手教你Dubbo与SpringBoot常用两种方式整合的相关文章

搭建pytorch神经网络的常用两种方式

'''本节说明搭建pytorch神经网络的常用两种方式 相比快速搭建法 第一种可以个性化设置网络结构''' import torch import torch.nn.functional as F #方式1 用 class 继承了一个 torch 中的神经网络结构, 然后对其进行了修改 class Net(torch.nn.Module): def __init__(self, n_feature, n_hidden, n_output): super(Net, self).__init__()

SpringBoot集成Mybatis实现多表查询的两种方式(基于xml)

 下面将在用户和账户进行一对一查询的基础上进行介绍SpringBoot集成Mybatis实现多表查询的基于xml的两种方式.   首先我们先创建两个数据库表,分别是user用户表和account账户表     user表:  account表:  然后创建实体类        **第一种通过创建子类的方式查询                             需求:查询所有的用户基础信息以及其所属的账户中的金额     1.创建想要得到多表查询数据的实体类(子类)            

【REACT NATIVE 系列教程之十三】利用LISTVIEW与TEXTINPUT制作聊天/对话框&&获取组件实例常用的两种方式

本站文章均为 李华明Himi 原创,转载务必在明显处注明: 转载自[黑米GameDev街区] 原文链接: http://www.himigame.com/react-native/2346.html 本篇Himi来利用ListView和TextInput这两种组件实现对话.聊天框. 首先需要准备的有几点:(组件的学习就不赘述了,简单且官方有文档) 1. 学习下 ListView: 官方示例:http://reactnative.cn/docs/0.27/tutorial.html#content

android/IOS常用图片上传的两种方式

android/IOS常用图片上传的两种方式: 1.上传到服务器的文件服务器(FileServer) 原理:上传到文件服务器的方式是先在服务器端搭建文件服务器,配置好路径(url),该路径是我们待会上传图片的路径,配置成功后便通过http+post的模式上传到文件服务器,同时文件服务器将返回一个图片ID,这个ID就是图片的唯一标识,并将该ID写入数据库保存,当需要下载该图片时只需要将此ID带上即可. 两个核心问题: (1)服务端:配置FileServer,并写处理响应上传图片的代码,这个值得去网

企业宣传片在拍摄时常用的两种方式

企业宣传片在拍摄时常用的两种方式北京企业宣传片制作公司:企业宣传片在拍摄时常用的两种方式.固定拍摄:固定拍摄是将摄影机和支架固定在确定的地方,以固定的角度和方向进行拍摄.其特点是:画面稳定.清晰,不会出现抖动的现象.观众的视线在画面上停留.游动的相对时间长,有利看清画面的内容.容易产生单调.呆板的感觉.固定拍摄可以从拍摄方向.位置.角度上进行变化.既可正拍也可反拍,既可有近景也可有中景.特写等,可以在机位或镜头内部运动等方面变化.运动拍摄:是指不断地变动摄影机在拍摄过程中的方向.位置.角度.其特

springboot 注册服务注册中心(zk)的两种方式

在使用springboot进行开发的过程中,我们经常需要处理这样的场景:在服务启动的时候,需要向服务注册中心(例如zk)注册服务状态,以便当服务状态改变的时候,可以故障摘除和负载均衡. 我遇到过两种注册的途径: 1.在Spring的webapplication启动完成后,直接进行注册: 2.在servlet容器启动完成后,通过listener进行注册. 本文通过一个demo讲述一下这两种注册方式,使用的是传统的向zk注册的方案. 1.Spring webapplication启动完成后注册 先上

基于Maven的SpringBoot项目实现热部署的两种方式

下面我将介绍使用maven构建的SpringBoot项目中实现热部署的两种方式,使得部署变得异常简单,同时两种方式也非常的简单. 热部署 devtools Pom.xml中直接添加依赖即可: <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-devtools</artifactId> <scope>provided</

springboot项目启动成功后执行一段代码的两种方式

springboot项目启动成功后执行一段代码的两种方式 实现ApplicationRunner接口 package com.lnjecit.lifecycle; import org.springframework.boot.ApplicationArguments; import org.springframework.boot.ApplicationRunner; import org.springframework.core.annotation.Order; import org.sp

创建安卓模拟器的两种方式及常用Android命令介绍

创建安卓模拟器有以下两种方式: 1>通过图形界面创建,在Eclipse中单击Windows->Android Virtual Device Manager启动图形界面窗口 2>如果用的不是Eclipse,则可以切换到~/tools/文件夹,在终端执行"android avd",单击Create 按钮,则可以创建一个新的模拟器. 2.使用镜像功能加快模拟器的启动速度. 也许你在启动Android模拟器重新启动的速度很慢,因此新增了一个保存和恢复模拟器状态的镜像功能,用以