分布式RPC框架Apache Dubbo

最新推荐文章于 2022-04-19 13:54:48 发布
最新推荐文章于 2022-04-19 13:54:48 发布
阅读量235 收藏
点赞数
文章标签： java big data 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/haozhzhzh/article/details/121481108
版权
本文详细介绍了软件架构从单体到微服务的演进过程，并重点讲解了Apache Dubbo，一个高性能的Java RPC框架。文章阐述了Dubbo的核心功能、服务注册中心Zookeeper的安装与使用，以及如何进行Dubbo的快速入门，包括服务提供者和消费者的应用开发。此外，还讨论了Dubbo管理控制台的安装和使用，以及解决Dubbo在处理事务代理服务时遇到的问题和解决方案。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、 软件架构的演进过程

软件架构的发展经历了由单体架构、垂直架构、SOA架构到微服务架构的演进过程，下面我们分别了解 一下这几个架构

1.1 单体架构

架构说明： 全部功能集中在一个项目内（All in one）。

架构优点： 架构简单，前期开发成本低、开发周期短，适合小型项目。

架构缺点： 全部功能集成在一个工程中，对于大型项目不易开发、扩展和维护。 技术栈受限，只能使用一种语言开发。 系统性能扩展只能通过扩展集群节点，成本高。

1.2 垂直架构

架构说明： 按照业务进行切割，形成小的单体项目。

架构优点： 技术栈可扩展（不同的系统可以用不同的编程语言编写）。

架构缺点： 功能集中在一个项目中，不利于开发、扩展、维护。 系统扩张只能通过集群的方式。 项目之间功能冗余、数据冗余、耦合性强

1.3 SOA架构

SOA全称为Service-Oriented Architecture，即面向服务的架构。它可以根据需求通过网络对松散耦合 的粗粒度应用组件(服务)进行分布式部署、组合和使用。一个服务通常以独立的形式存在于操作系统进 程中。

站在功能的角度，把业务逻辑抽象成可复用的服务，通过服务的编排实现业务的快速再生，目的：把原 先固有的业务功能转变为通用的业务服务，实现业务逻辑的快速复用。

架构说明： 将重复功能或模块抽取成组件的形式，对外提供服务，在项目与服务之间使用ESB（企业服务总线）的 形式作为通信的桥梁。

架构优点： 重复功能或模块抽取为服务，提高开发效率。 可重用性高。 可维护性高。

架构缺点： 各系统之间业务不同，很难确认功能或模块是重复的。 抽取服务的粒度大。 系统和服务之间耦合度高。

1.4 微服务架构

架构说明： 将系统服务层完全独立出来，抽取为一个一个的微服务。 抽取的粒度更细，遵循单一原则。 采用轻量级框架协议传输

架构优点： 服务拆分粒度更细，有利于提高开发效率 可以针对不同服务指定对应的优化方案 适用于互联网时代，产品迭代周期更短

架构缺点： 粒度太细导致服务太多，维护成本高 分布式系统开发的技术成本高，对团队的挑战大

二、 Apache Dubbo 概述

2.1 Dubbo简介

Apache Dubbo是一款高性能的 Java RPC框架。其前身是阿里巴巴公司开源的、轻量级的开源 Java RPC框架，可以和Spring框架无缝集成，2018年阿里巴巴把这个框架捐献给了apache基金会

什么是RPC？

RPC全称为remote procedure call，即 远程过程调用。比如两台服务器A和B，A服务器上部署一个应用，B服务器上部署一个应用，A服务器上的应用想调用B服务器上的应用提供的方法，由于两个应用不再一个内存空间，不能直接调用，所以需要通过网络来表达调用的语义和传达调用的数据。

需要注意的是，RPC并不是一个具体的技术，而是指整个网络远程调用的过程

RPC是一个泛化的概念，严格来说一切远程过程调用手段都属于RPC范畴。各种开发语言都有自己的RPC框架。Java中的RPC框架比较多，广泛使用的有RMI、Hessian、Dubbo等。

Dubbo官网地址：https://dubbo.apache.org/zh/

Dubbo提供了三大核心能力： ​ 面向接口的远程方法调用 ​ 智能容错和负载均衡 ​ 以及服务自动注册和发现

2.2 Dubbo架构

 

节点角色名称
Provider暴露服务的服务提供方
Consumer调用远程服务的服务消费方
Registry服务注册与发现的注册中心
Monitor统计服务的嗲用次数和调用时间的监控中心
Container服务运行容器

虚线都是异步访问，实线都是同步访问，蓝色虚线：在启动时完成的功能 红色虚线( 实线 )都是程序运行过程中执行的功能

调用关系说明： 0：服务容器负责启动，加载，运行服务提供者 1：服务提供者在启动时，向注册中心注册自己提供的服务 2：服务消费者在启动时，向注册中心订阅自己所需要的服务 3：注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者 4：服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一 台调用 5：服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

三、 服务注册中心Zookeeper

通过前面的Dubbo架构图可以看到，Registry( 服务注册中心 )在其中起着至关重要的作用。Dubbo官方推荐使用Zookeeper作为服务注册中心

3.1 Zookeeper介绍

Zookeeper 是 Apache Hadoop 的子项目，是一个树形的目录服务，支持变更推送，支持作为Dubbo服务的注册中心，工业强度较高，可用于生产环境，并推荐使用

为了便于理解Zookeeper的属性目录服务，我们先来看一下我们电脑的文件( 也是一个树形目录结构 )

我的电脑可以分为多个盘符（例如C、D、E等），每个盘符下可以创建多个目录，每个目录下面可以创 建文件，也可以创建子目录，最终构成了一个树型结构。通过这种树型结构的目录，我们可以将文件分 门别类的进行存放，方便我们后期查找。而且磁盘上的每个文件都有一个唯一的访问路径，例如： C:\Windows\kkb\hello.txt。

Zookeeper的属性目录服务：

 

流程说明

  • 服务提供者( Provider )启动时：向 /dubbo/com.foo.BarService/providers 目录下写入自己的URL地址

  • 服务消费者( Consumer )启动时：订阅 /dubbo/com.foo.BarService/providers 目录下的提供者URL地址。并向 /dubbo/com.foo.BarService/consumers 目录下写入自己的URL地址

  • 监控中心( Monitor )启动时：订阅 /dubbo/com.foo.BarService 目录下的所有提供者和消费者URL地址

3.2 安装Zookeeper

下载地址：Index of /dist/zookeeper

安装步骤： 第一步：安装 jdk（略） 第二步：把 zookeeper 的压缩包（zookeeper-3.4.6.tar.gz）上传到 linux 系 统 第三步：解压缩压缩包 tar -zxvf zookeeper-3.4.6.tar.gz -C /usr 第四步：进入zookeeper-3.4.6目 录，创建data目录 mkdir data 第五步：进入conf目录 ，把zoo_sample.cfg 改名为zoo.cfg cd conf mv zoo_sample.cfg zoo.cfg 第六步：打开zoo.cfg文件, 修改data属性：dataDir=/usr/zookeeper-3.4.6/data

3.3 启动、停止Zookeeper

进入Zookeeper的bin目录，启动服务命令 ./zkServer.sh start 停止服务命令 ./zkServer.sh stop 查看服务状态： ./zkServer.sh status 客户端连接 ./zkCli.sh

四、Dubbo快速入门

Dubbo作为一个RPC框架，其最核心的功能就是要实现跨网络的远程调用。本小节就是要创建两个应用，一个座位服务的提供方，一个作为服务的消费方。通过Dubbo来实现服务消费方远程调用服务提供方的方法

4.1 服务提供方开发

  1. 创建maven工程（打包方式为war）dubbodemo_provider

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <spring.version>5.0.5.RELEASE</spring.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-beans</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-aspects</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jms</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context-support</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!-- dubbo相关 -->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.6.0</version>
        </dependency>
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.7</version>
        </dependency>
        <dependency>
            <groupId>com.github.sgroschupf</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.1</version>
        </dependency>
        <dependency>
            <groupId>javassist</groupId>
            <artifactId>javassist</artifactId>
            <version>3.12.1.GA</version>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>2.3.2</version>
                <configuration>
                    <source>1.8</source>
                    <target>1.8</target>
                </configuration>
            </plugin>
            <!-- 设置tomcat插件 -->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <!-- 指定端口 -->
                    <port>8081</port>
                    <!-- 请求路径 -->
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>

  2. 配置文件 web.xml

    <?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
​
​
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext*.xml</param-value>
    </context-param>
​
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
​
</web-app>

  3. 创建服务接口

    package szh.service;
​
public interface HelloService {
​
    public String sayHello(String name);
​
}

  4. 创建服务实现类

    package szh.service.impl;
​
import com.alibaba.dubbo.config.annotation.Service;
import szh.service.HelloService;
​
@Service
public class HelloServiceImpl implements HelloService {
    @Override
    public String sayHello(String name) {
        return "hello:"+name;
    }
}

    注意：服务实现类上的Service注解是 Dubbo提供的，用于对外发布服务

  5. 在src/main/resources下创建applicationContext-service.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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
        xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
        xmlns:mvc="http://www.springframework.org/schema/mvc"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://code.alibabatech.com/schema/dubbo
        http://code.alibabatech.com/schema/dubbo/dubbo.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
​
    <!-- 当前应用名称，用于注册中心计算应用间依赖关系，注意：消费者和提供者应用名不要一样 -->
    <dubbo:application name="dubbodemo_provider"></dubbo:application>
​
    <!-- 连接服务注册中心zookeeper ip为zookeeper所在服务器的ip地址-->
    <dubbo:registry address="zookeeper://192.168.227.128:2181"></dubbo:registry>
​
    <!-- 注册 协议和port -->
    <dubbo:protocol name="dubbo" port="20881"></dubbo:protocol>
​
    <!-- 扫描指定包，加入@Service注解的类会被发布为服务 -->
    <dubbo:annotation package="szh.service.impl" />
​
​
</beans>

  6. 启动服务

4.2 服务消费方开发

  1. 创建maven工程（打包方式为war）dubbodemo_consumer，pom.xml配置和上面服务提供者 相同，只需要将Tomcat插件的端口号改为8082即可

  2. 配置 web.xml 文件

    <?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0">
​
​
    <servlet>
        <servlet-name>dispatcherServlet</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:applicationContext-web.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>dispatcherServlet</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
​
</web-app>

  3. 将服务提供者工程中的HelloService接口复制到当前工程

  4. 编写Controller

    package szh.controller;
​
import com.alibaba.dubbo.config.annotation.Reference;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import szh.service.HelloService;
​
@RestController
@RequestMapping("/demo")
public class HelloController {
​
    @Reference
    private HelloService helloService;
​
    @RequestMapping("/hello")
    public String getName(String name){
        String hello = helloService.sayHello(name);
        return  hello;
​
    }
}

    注意：Controller中注入HelloService使用的是Dubbo提供的@Reference注解

  5. 在src/main/resources下创建applicationContext-web.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:p="http://www.springframework.org/schema/p"
       xmlns:context="http://www.springframework.org/schema/context"
        xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
        xmlns:mvc="http://www.springframework.org/schema/mvc"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/mvc
        http://www.springframework.org/schema/mvc/spring-mvc.xsd
        http://code.alibabatech.com/schema/dubbo
        http://code.alibabatech.com/schema/dubbo/dubbo.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
​
    <!-- 当前应用名称，用于注册中心计算应用间依赖关系，注意：消费者和提供者应用名不要一样 -->
    <dubbo:application name="dubbodemo_consumer"></dubbo:application>
​
    <!-- 连接服务注册中心zookeeper ip为zookeeper所在服务器的ip地址-->
    <dubbo:registry address="zookeeper://192.168.227.128:2181"></dubbo:registry>
​
    <!-- 扫描指定包，加入@Service注解的类会被发布为服务 -->
    <dubbo:annotation package="szh.controller" />
​
​
</beans>

  6. 运行测试

    在浏览器输入http://localhost:8082/demo/hello.do?name=Jack，查看浏览器输出结果

思考一： 上面的Dubbo入门案例中我们是将HelloService接口从服务提供者工程(dubbodemo_provider)复制到服务消费者工程(dubbodemo_consumer)中，这种做法是否合适？还有 没有更好的方式？ 答：这种做法显然是不好的，同一个接口被复制了两份，不利于后期维护。更好的方式是单独创建一个maven工程，将此接口创建在这个maven工程中。需要依赖此接口的工程只需要在自己工程的pom.xml文件中引入maven坐标即可

思考二： 在服务消费者工程(dubbodemo_consumer)中只是引用了HelloService接口，并没有提供实现 类，Dubbo是如何做到远程调用的？ 答： Dubbo底层是基于代理技术为HelloService接口创建代理对象，远程调用是通过此代理对象完成的。可以通过开发工具的debug功能查看此代理对象的内部结构。另外，Dubbo实现网络传输时基于Netty框架完成的。

思考三： 上面的Dubbo入门案例中我们使用Zookeeper作为服务注册中心，服务提供者需要将自己的服务信息注册到Zookeeper，服务消费者需要从Zookeeper订阅自己所需要的服务，此时Zookeeper服务就变得非常重要了，那如何防止Zookeeper单点故障呢？ 答： Zookeeper其实是支持集群模式的，可以配置Zookeeper集群来达到Zookeeper服务的高可用，防止出现单点故障

五、 Dubbo管理控制台

我们在开发时，需要知道Zookeeper注册中心都注册了哪些服务，有哪些消费者来消费这些服务。我们可以通过部署一个管理中心来实现。其实管理中心的是一个web应用，部署到tomcat即可。

5.1 安装

安装步骤

  1. 将资料中的dubbo-admin-2.6.0.war文件复制到tomcat的webapps目录下

  2. 启动tomcat，此war文件会自动解压

  3. 修改WEB-INF下的dubbo.properties文件，注意dubbo.registry.address对应的值需要对应当前 使用的Zookeeper的ip地址和端口号 dubbo.registry.address=zookeeper://192.168.134.129:2181 dubbo.admin.root.password=rootdubbo.admin.guest.password=guest

  4. 重启tomcat

5.2 使用

操作步骤

  1. 访问http://localhost:8080/dubbo-admin-2.6.0/，输入用户名(root)和密码(root)

     

  2. 启动服务提供者工程和服务消费者工程，可以在查看到对应的信息  

     

     

六、Dubbo相关配置说明

6.1 包扫描

<dubbo:annotation package="com.lxs.service" />

服务提供者和服务消费者都需要配置，表示包扫描，作用是扫描指定包(包括子包)下的类。

如果不使用包扫描，也可以通过如下配置的方式来发布服务：

<bean id="helloService" class="com.lxs.service.impl.HelloServiceImpl" />
<dubbo:service interface="com.lxs.api.HelloService" ref="helloService" />

作为服务消费者，可以通过如下配置来引用服务：

<!-- 生成远程服务代理，可以和本地bean一样使用helloService -->
<dubbo:reference id="helloService" interface="com.lxs.api.HelloService" />

上面这种方式发布和引用服务，一个配置项(dubbo:service、dubbo:reference)只能发布或者引用一个 服务，如果有多个服务，这种方式就比较繁琐了。推荐使用包扫描方式。

6.2 协议

<dubbo:protocol name="dubbo" port="20880"/>

一般在服务提供者一方配置，可以指定使用的协议名和端口号。

其中Dubbo支持的协议有：dubbo、rmi、hessian、http、webservice、rest、redis等。

推荐使用的是dubbo协议

dubbo协议采用单一长连接和NIO异步通讯，适合于小数据量大并发的服务调用，以及服务消费者机器数远大于服务提供者机器数的情况。不适合传送大数据量的服务，比如传文件，传视频等，除非请求量很低

也可以在同一个工程中配置多个协议，不同服务可以使用不同的协议

<!-- 多协议配置 -->
<dubbo:protocol name="dubbo" port="20880" />
<dubbo:protocol name="rmi" port="1099" />
<!-- 使用dubbo协议暴露服务 -->
<dubbo:service interface="com.lxs.api.HelloService" ref="helloService" protocol="dubbo" />
<!-- 使用rmi协议暴露服务 -->
<dubbo:service interface="com.lxs.api.DemoService" ref="demoService" protocol="rmi" />

6.3 负载均衡

负载均衡（Load Balance）：其实就是将请求分摊到多个操作单元上进行执行，从而共同完成工作任务。

在集群负载均衡时，Dubbo 提供了多种均衡策略（包括随机、轮询、最少活跃调用数、一致性 Hash），缺省为random随机调用。

配置负载均衡策略，既可以在服务提供者一方配置，也可以在服务消费者一方配置，如下：

@Controller
@RequestMapping("/demo")
public class HelloController {
    //在服务消费者一方配置负载均衡策略
    @Reference(check = false,loadbalance = "random")
    private HelloService helloService;
    
    @RequestMapping("/hello")
    @ResponseBody
    public String getName(String name){
        //远程调用
        String result = helloService.sayHello(name);
        System.out.println(result);
        return result;
    }
}
​
//在服务提供者一方配置负载均衡
@Service(loadbalance = "random")
    public class HelloServiceImpl implements HelloService {
    public String sayHello(String name) {
        return "hello " + name;
    }
}
​

可以通过启动多个服务提供者来观察Dubbo负载均衡效果

注意：现在因为是在一台机器上启动多个服务提供者，所以需要修改tomcat的端口号和Dubbo服务的端口号来防止端口冲突

在实际生产环境中，多个服务提供者是分别部署在不同的机器上，所以不存在端口冲突问题

七、 解决Dubbo无法发布被事务代理的Service问题

前面我们已经完成了Dubbo的入门案例，通过入门案例我们可以看到通过Dubbo提供的标签配置就可以进行包扫描，扫描到@Service注解的类就可以被发布为服务

但是我们如果在服务提供者类上加入@Transactional事务控制注解后，服务就发布不成功了。原因是事务控制的底层原理是为服务提供者创建代理对象，而默认情况下Spring是基于JDK动态代理方式创建代理对象，而此代理对象的完整类名为com.sun.proxy.$Proxy42（最后两位数字不是固定的），导致Dubbo在发布服务前进行包匹配时无法完成匹配，进而没有进行服务的发布

7.1 问题展示

在入门案例的服务提供者dubbodemo_provider工程基础上进行展示

操作步骤

  1. 在pom.xml文件中增加maven坐标

    <dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.47</version>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid</artifactId>
    <version>1.1.6</version>
</dependency>
<dependency>
    <groupId>org.mybatis</groupId>
    <artifactId>mybatis-spring</artifactId>
    <version>1.3.2</version>
</dependency>

  2. 在applicationContext-service.xml配置文件中加入数据源、事务管理器、开启事务注解的相关配 置

    <!--数据源-->
<bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy•method="close">
    <property name="username" value="root" />
    <property name="password" value="root" />
    <property name="driverClassName" value="com.mysql.jdbc.Driver" />
    <property name="url" value="jdbc:mysql://localhost:3306/test" />
</bean>
<!-- 事务管理器 -->
<bean id="transactionManager"
    class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"/>
</bean>
<!--开启事务控制的注解支持-->
<tx:annotation-driven transaction-manager="transactionManager"/>

    上面链接的数据库可以自行创建

  3. 在HelloServiceImpl类上加入@Transactional注解

  4. 启动服务提供者和服务消费者，并访问

     

    上面的错误为没有可用的服务提供者

    查看dubbo管理控制台发现服务并没有发布，如下： 可以通过断点调试的方式查看Dubbo执行过程，Dubbo通过AnnotationBean的 postProcessAfterInitialization方法进行处理 ​​​​​​​

     

     

     

7.2 解决方案

通过上面的断点调试可以看到，在HelloServiceImpl类上加上事务注释后，Spring会为此类基于JDK动态代理技术创建代理对象，创建的代理对象完整类名为com.sun.proxy.$Proxy35，导致Dubbo在进行 包匹配时没有成功（因为我们在发布服务时扫描的包为com.lxs.service），所以后面真正发布服务的代 码没有执行。

解决方案操作步骤：

  1. 修改applicationContext-service.xml配置文件，开启事务控制注解支持时指定proxy-target-class 属性，值为true。其作用是使用cglib代理方式为Service类创建代理对象

    <!--开启事务控制的注解支持-->
<tx:annotation-driven transaction-manager="transactionManager" proxy-target-class="true"/>

     

  2. 修改HelloServiceImpl类，在Service注解中加入interfaceClass属性，值为HelloService.class， 作用是指定服务的接口类型

    @Service(interfaceClass = HelloService.class)
@Transactional
public class HelloServiceImpl implements HelloService {
    public String sayHello(String name) {
        return "hello " + name;
    }
}

    此处也是必须要修改的，否则会导致发布的服务接口为SpringProxy，而不是HelloService接口，如 下：

     

八、 小bug

原本写法：

<!-- 连接服务注册中心zookeeper ip为zookeeper所在服务器的ip地址-->
<dubbo:registry address="192.168.227.128:2181"></dubbo:registry>

问题： 可能会导致注册不了服务

解决方案：

<!-- 连接服务注册中心zookeeper ip为zookeeper所在服务器的ip地址-->
<dubbo:registry address="zookeeper://192.168.227.128:2181"></dubbo:registry>

war包使用的jdk版本要和war包部署的tomcat的系统jdk版本匹配

haozhzhzh
关注
分布式RPC框架Apache Dubbo概述及入门
9.冄2.7.號的博客
07-04 329
1. 软件架构的演进过程 软件架构的发展经历了由单体架构、垂直架构、SOA架构到微服务架构的演进过程，下面我们分别了解一下这几个架构。 1.1 单体架构 架构说明： 全部功能集中在一个项目内（All in one）。 架构优点： 架构简单，前期开发成本低、开发周期短，适合小型项目。 架构缺点： 全部功能集成在一个工程中，对于大型项目不易开发、扩展和维护。 技术栈受限，只能使用一种语言开发。 系统性能扩展只能通过扩展集群节点，成本高。 1.2 垂直架构 架构说明： 按照业务进行切
Apache Dubbo
Yitouxiufa的博客
10-25 262
分布式RPC框架Apache Dubbo 1. 软件架构的演进过程 软件架构的发展经历了由单体架构、垂直架构、SOA架构到微服务架构的演进过程，下面我们分别了解一下这几个架构。 1.1 单体架构 架构说明： ​ 全部功能集中在一个项目内（All in one）。 架构优点： ​ 架构简单，前期开发成本低、开发周期短，适合小型项目。 架构缺点： ​ 全部功能集成在一...
"分布式RPC框架Apache Dubbo演进过程与软件架构
总的来说，Dubbo是一个非常强大的分布式RPC框架，它能够很好地支持多种架构，并提供丰富的功能和强大的服务治理能力。通过与Zookeeper的集成，Dubbo能够帮助用户更加轻松地构建和管理复杂的分布式系统，让用户能够...
分布式RPC系统框架-Dubbo(2.7)教程(4.31G)
04-11
分布式RPC系统框架-Dubbo(2.7)教程涵盖了在现代软件开发中至关重要的技术领域，主要涉及分布式系统、远程过程调用（RPC）以及相关的中间件和服务治理。Dubbo是阿里巴巴开源的一款高性能、轻量级的RPC框架，它极大地...
分布式RPC框架Apache Dubbo（浅习）
weixin_38817361的博客
04-19 230
1、软件架构的演进过程 软件架构的发展经历了单体架构、垂直架构、SOA架构到微服务架构的演进过程。 1.1 单体架构 架构说明：全部功能集中在一个项目内（All in one）。 架构优点：架构简单，前期开发成本低，开发周期短，适合小型项目。 架构缺点：全部功能集成在一个工程中，对于大型项目不易开发、扩展和维护；技术栈受限，只能使用一种语言开发；系统性能扩展只能通过扩展集群节点，成本高。 1.2 垂直架构 架构说明：按照业务进行切割，形成小的单体项目。 架构优点：技术栈可...
高性能RPC框架--Apache Dubbo
u014379055的博客
10-31 223
Dubbo是一款高性能、轻量级的开源Java RPC框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。 1 Dubbo 处理流程 节点说明： 节点 角色名称 Provider 暴露服务的服务提供方 Consumer 调用远程服务的服务消费方 Registry 服务注册与发现的注册中心 Monitor 统计服务的调用次数和调用时间的监控中心 Container 服务运行容器 负责启动 加载 运行服务提供者 调用关系说明: 虚线
Apache dubbo RPC框架 中文文档
宇宙浪子的专栏
07-04 426
阿里在2017年重启dubbo框架的开发，2018年初合并当当网的dubbox分支，然后进入Apache基金会孵化， 2019年5月20日宣布孵化完成。 Apachedubbo RPC框架 中文文档：http://dubbo.apache.org/zh-cn/docs/user/quick-start.html ...
分布式-RPC
weixin_43612949的博客
04-05 832
一、什么是RPC RPC（Remote Procedure Call Protocol）远程过程调用协议，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。简言之，RPC使得程序能够像访问本地系统资源一样，去访问远端系统资源。比较关键的一些方面包括：通讯协议、序列化、接口描述、服务框架、性能等。 简单的说，RPC就是从一台机器(客户端)上通过参数传递的方式调用另一台机器...
深入理解 RPC 之集群篇
架构师小秘圈
03-04 630
上一篇文章分析了服务的注册与发现，这一篇文章着重分析下 RPC 框架都会用到的集群的相关知识。集群(Cluster)本身并不具备太多知识点，在分布式系统中，集群一般涵盖了负载均衡（Load...
【学习总结】分布式系统理论、分布式、集群、微服务的区别、远程过程调用（RPC）
Zhou_LC的博客
07-14 542
文章目录1 分布式系统理论1.1 什么是分布式系统1.2 分布式与集群的区别1.3 分布式系统的目标1.4 需要注意的问题1.5 具体应用2 远程过程调用（RPC）2.1 什么是RPC2.2 基本原理 1 分布式系统理论 1.1 什么是分布式系统 在《分布式系统概念与设计》一书中，对分布式系统做了如下定义：分布式系统是一个硬件或软件组件分布在不同的网络计算机上，彼此之间仅仅通过消息传递进行通信和协调的系统。简单来说就是一群独立计算机集合共同对外提供服务，但是对于系统的用户来说，就像是一台计算机在提供服务一样
RPC框架与Dubbo完整使用
热门推荐
「有且仅有」
06-21 5万+
这并不是原理性的解释文章。只是快速入门，还有一个完整的Java例子。 一篇我觉得不错的文章推荐：深入浅出 RPC - 浅出篇 一、RPC 什么是RPC？RPC（Remote Procedure Call）远程过程调用。见名知意 - 从远程主机调用一个过程/函数。RPC的目标是：使得程序调用其它远程主机上的函数，好像调用本程序内的函数一样简单。并且屏蔽编程语言的差异性。要实现上述目标，首先的是设计一
【Dubbo】深入理解Apache Dubbo（一）：带你走近高性能RPC通信框架
少侠露飞的学习笔记
01-30 3万+
1. 简介 从本篇开始，笔者将会带你进入Apache顶级项目——Dubbo的学习。本篇侧重介绍Dubbo的来龙去脉，会从架构的演进过程说明Dubbo的重要性和意义。 2. 应用架构的演进过程 2.1 单体应用 1. JEE时期 特征 优点 缺点 JEE是早期提供了企业级应用开发环境的工具，整体上分为展示层、业务逻辑层和数据存储层。各层的组件都被聚合在一起运行在统一的服务器上（如To...
Apache Dubbo——基于Java的高性能开源RPC框架
开发猫
11-02 1551
Apache Dubbo（孵化）项目 Apache Dubbo是一种基于Java的高性能开源RPC框架。请访问官方网站以获取快速入门和文档，   架构 特征 基于透明接口的RPC 智能负载均衡 自动服务注册和发现 可扩展性高 运行时流量路由 可视化的服务治理 入门 以下代码段来自Dubbo Samples。您可以dubbo-samples-api在继续阅读之前克隆示例项目...
分布式RPC框架Apache Dubbo详细使用以及服务器部署
落日的博客
04-06 1452
分布式RPC框架Apache Dubbo 1. 软件架构的演进过程 软件架构的发展经历了由单体架构、垂直架构、SOA架构到微服务架构的演进过程，下面我们分别了解一下这几个架构。 1.1 单体架构 架构说明： ​ 全部功能集中在一个项目内（All in one）。 架构优点： ​ 架构简单，前期开发成本低、开发周期短，适合小型项目。 架构缺点： ​ 全部功能集成在一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值