Dubbo分布式框架学习(1)

发布于：2025-04-02 ⋅ 阅读:(24) ⋅ 点赞:(0)

学习链接

Dubbo官网文档 apache

黑马程序员Dubbo快速入门，Java分布式框架dubbo教程 - B站视频

千锋教育Dubbo教程

尚硅谷Dubbo教程(dubbo经典之作) - B站视频

Dubbo从0到1——万字完整学习笔记
Zookeeper【Curator客户端Java版】从0到1——万字学习笔记

Dubbo入门介绍及学习笔记总结

文章目录

分布式系统中的相关概念

大型互联网项目架构目标

互联网项目特点：

  • 用户多流量大，

  • 并发高

  • 海量数据

  • 易受攻击

  • 功能繁琐

  • 变更快

衡量网站的性能指标：

  • 响应时间：指执行一个请求从开始到最后收到响应数据所花费的总体时间。
  • 并发数：指系统同时能处理的请求数量。
    • 并发连接数：指的是客户端向服务器发起请求，并建立了TCP连接。每秒钟服务器连接的总TCP数量
    • 请求数：也称为QPS(Query Per Second) 指每秒多少请求.
    • 并发用户数：单位时间内有多少用户
  • 吞吐量：指单位时间内系统能处理的请求数量。
    • QPS：Query Per Second 每秒查询数。
    • TPS：Transactions Per Second 每秒事务数。
    • 一个事务是指一个客户机向服务器发送请求然后服务器做出反应的过程。客户机在发送请求时开始计时，收到服务器响应后结束计时，以此来计算使用的时间和完成的事务个数。
    • 一个页面的一次访问，只会形成一个TPS；但一次页面请求，可能产生多次对服务器的请求，就会有多个QPS

架构目标

  • 高性能：提供快速的访问体验。

  • 高可用：网站服务一直可以正常访问。

  • 可伸缩：通过硬件增加/减少，提高/降低处理能力。

  • 高可扩展：系统间耦合低，方便的通过新增/移除方式，增加/减少新的功能/模块。

  • 安全性：提供网站安全访问和数据加密，安全存储等策略。

  • 敏捷性：随需应变，快速响应。

集群和分布式

集群：很多“人”一起 ，干一样的事。一个业务模块，部署在多台服务器上。

分布式：很多“人”一起，干不一样的事。这些不一样的事，合起来是一件大事。一个大的业务系统，拆分为小的业务模块，分别部署在不同的机器上。。

image-20250329092750050

image-20250329092810880

image-20250329092823698

架构演进

image-20250329114242579

单体架构

image-20250329093251503

垂直架构

image-20250329093322557

分布式架构

image-20250329093739565

SOA架构

image-20250329094016768

微服务架构

image-20250329094039901

Dubbo 概述

Dubbo概念

Dubbo是阿里巴巴公司开源的一个高性能、轻量级的 Java RPC 框架。

致力于提供高性能和透明化的 RPC 远程服务调用方案，以及 SOA 服务治理方案。

官网：http://dubbo.apache.org

Dubbo架构

image-20250329130631999

Dubbo 快速入门

Zookeeper安装

Dubbo官方推荐使用Zookeeper作为注册中心

下载安装

1、环境准备

ZooKeeper服务器是用Java创建的，它运行在JVM之上。需要安装JDK 7或更高版本。

2、上传

将下载的ZooKeeper放到/opt/ZooKeeper目录下

#上传zookeeper alt+p
put f:/setup/apache-zookeeper-3.5.6-bin.tar.gz
#打开 opt目录
cd /opt
#创建zooKeeper目录
mkdir  zooKeeper
#将zookeeper安装包移动到 /opt/zooKeeper
mv apache-zookeeper-3.5.6-bin.tar.gz /opt/zookeeper/

3、解压

将tar包解压到/opt/zookeeper目录下

tar -zxvf apache-ZooKeeper-3.5.6-bin.tar.gz
配置启动

1、配置zoo.cfg

进入到conf目录拷贝一个zoo_sample.cfg并完成配置

#进入到conf目录
cd /opt/zooKeeper/apache-zooKeeper-3.5.6-bin/conf/
#拷贝
cp  zoo_sample.cfg  zoo.cfg

修改zoo.cfg

#打开目录
cd /opt/zooKeeper/
#创建zooKeeper存储目录
mkdir  zkdata
#修改zoo.cfg
vim /opt/zooKeeper/apache-zooKeeper-3.5.6-bin/conf/zoo.cfg

1577548250377

修改存储目录：dataDir=/opt/zookeeper/zkdata

（可以修改日志存储位置：dataLogDir=/opt/zookeeper/logs）

（注意zookeeper启动默认会占用8080端口，可以通过该配置修改此端口号，admin.serverPort=6088）

2、启动ZooKeeper

cd /opt/zooKeeper/apache-zooKeeper-3.5.6-bin/bin/
#启动（关闭的命令是 ./zkServer.sh stop）
./zkServer.sh  start

# （如果是windows环境，直接输出 zkServer.cmd，后面不需要加start）

1577548052037

看到上图表示ZooKeeper成功启动

3、查看ZooKeeper状态

# zk的默认启动端口是2181
./zkServer.sh status

zookeeper启动成功。standalone代表zk没有搭建集群，现在是单节点

1577548175232

zookeeper没有启动

1577548112773

spring和springmvc整合

dubbo-service

image-20250329155443775

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 
                             http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.itheima</groupId>
    <artifactId>dubbo-service</artifactId>
    <version>1.0-SNAPSHOT</version>



    <properties>
        <spring.version>5.1.9.RELEASE</spring.version>
        <dubbo.version>2.7.4.1</dubbo.version>
        <zookeeper.version>4.0.0</zookeeper.version>

    </properties>

    <dependencies>
        <!-- servlet3.0规范的坐标 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!--spring的坐标-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--springmvc的坐标-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--日志-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.21</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.21</version>
        </dependency>



        <!--Dubbo的起步依赖，版本2.7之后统一为rg.apache.dubbo -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo</artifactId>
            <version>${dubbo.version}</version>
        </dependency>
        <!--ZooKeeper客户端实现 -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>${zookeeper.version}</version>
        </dependency>
        <!--ZooKeeper客户端实现 -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>${zookeeper.version}</version>
        </dependency>



    </dependencies>

</project>
log4j.properties
# DEBUG < INFO < WARN < ERROR < FATAL
# Global logging configuration
log4j.rootLogger=info, stdout,file
# My logging configuration...
#log4j.logger.com.tocersoft.school=DEBUG
#log4j.logger.net.sf.hibernate.cache=debug
## Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p %d %C: %m%n

log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=../logs/iask.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss}  %l  %m%n
applicationContext.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" 
       xmlns:context="http://www.springframework.org/schema/context"
	   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 
                           http://www.springframework.org/schema/context 
                           https://www.springframework.org/schema/context/spring-context.xsd">


	<context:component-scan base-package="com.itheima.service" />

</beans>
UserService
public interface UserService {
    public String sayHello();
}
UserServiceImpl
import com.itheima.service.UserService;
import org.springframework.stereotype.Service;


@Service
public class UserServiceImpl implements UserService {

    public String sayHello() {
        return "hello dubbo!~";
    }
}
dubbo-web

image-20250329155806527

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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.itheima</groupId>
    <artifactId>dubbo-web</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>


    <properties>
        <spring.version>5.1.9.RELEASE</spring.version>
        <dubbo.version>2.7.4.1</dubbo.version>
        <zookeeper.version>4.0.0</zookeeper.version>

    </properties>

    <dependencies>
        <!-- servlet3.0规范的坐标 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!--spring的坐标-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--springmvc的坐标-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--日志-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.21</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.21</version>
        </dependency>



        <!--Dubbo的起步依赖，版本2.7之后统一为rg.apache.dubb -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo</artifactId>
            <version>${dubbo.version}</version>
        </dependency>
        <!--ZooKeeper客户端实现 -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>${zookeeper.version}</version>
        </dependency>
        <!--ZooKeeper客户端实现 -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>${zookeeper.version}</version>
        </dependency>



        <!--依赖service模块-->
        <dependency>
            <groupId>com.itheima</groupId>
            <artifactId>dubbo-service</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

    </dependencies>


    <build>
        <plugins>
            <!--tomcat插件-->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.1</version>
                <configuration>
                    <port>8000</port>
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>


</project>
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         version="2.5">

		 
	<!-- spring -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath*:spring/applicationContext*.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
		 
	<!-- Springmvc -->	 
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 指定加载的配置文件 ，通过参数contextConfigLocation加载-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring/springmvc.xml</param-value>
        </init-param>
    </servlet>

    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>


</web-app>
log4j.properties
# DEBUG < INFO < WARN < ERROR < FATAL
# Global logging configuration
log4j.rootLogger=info, stdout,file
# My logging configuration...
#log4j.logger.com.tocersoft.school=DEBUG
#log4j.logger.net.sf.hibernate.cache=debug
## Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p %d %C: %m%n

log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=../logs/iask.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss}  %l  %m%n
springmvc.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"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       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://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">



    <mvc:annotation-driven/>
    <context:component-scan base-package="com.itheima.controller"/>
</beans>
UserController
import com.itheima.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/user")
public class UserController {

    //注入Service
    @Autowired
    private UserService userService;


    @RequestMapping("/sayHello")
    public String sayHello(){
        return userService.sayHello();
    }

}
启动
安装dubbo-service

image-20250329160119429

配置tomcat

image-20250329160151464image-20250329160204410

访问

image-20250329160508527

dubbo快速入门

dubbo-interface

image-20250329220904295

UserService
public interface UserService {
    public String sayHello();
}
dubbo-service

image-20250329221245471

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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.itheima</groupId>
    <artifactId>dubbo-service</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>



    <properties>
        <spring.version>5.1.9.RELEASE</spring.version>
        <dubbo.version>2.7.4.1</dubbo.version>
        <zookeeper.version>4.0.0</zookeeper.version>

    </properties>

    <dependencies>
        <!-- servlet3.0规范的坐标 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!--spring的坐标-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--springmvc的坐标-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--日志-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.21</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.21</version>
        </dependency>



        <!--Dubbo的起步依赖，版本2.7之后统一为rg.apache.dubb -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo</artifactId>
            <version>${dubbo.version}</version>
        </dependency>
        <!--ZooKeeper客户端实现 -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>${zookeeper.version}</version>
        </dependency>
        <!--ZooKeeper客户端实现 -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>${zookeeper.version}</version>
        </dependency>


        <!--依赖公共的接口模块-->
        <dependency>
            <groupId>com.itheima</groupId>
            <artifactId>dubbo-interface</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>

    </dependencies>




    <build>
        <plugins>
            <!--tomcat插件-->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.1</version>
                <configuration>
                    <port>9000</port>
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project>
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
                             http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         version="2.5">

		 
	<!-- spring -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath*:spring/applicationContext*.xml</param-value>
    </context-param>
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>


</web-app>
log4j.properties
# DEBUG < INFO < WARN < ERROR < FATAL
# Global logging configuration
log4j.rootLogger=info, stdout,file
# My logging configuration...
#log4j.logger.com.tocersoft.school=DEBUG
#log4j.logger.net.sf.hibernate.cache=debug
## Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p %d %C: %m%n

log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=../logs/iask.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss}  %l  %m%n
applicationContext.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" xmlns:context="http://www.springframework.org/schema/context"
	   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 http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">


	<!--<context:component-scan base-package="com.itheima.service" />-->

	<!--dubbo的配置-->
	<!--1.配置项目的名称,唯一-->
	<dubbo:application name="dubbo-service"/>
	<!--2.配置注册中心的地址-->
	<dubbo:registry address="zookeeper://127.0.0.1:2181"/>
	<!--3.配置dubbo包扫描-->
	<dubbo:annotation package="com.itheima.service.impl" />

</beans>
UserServiceImpl
import com.itheima.service.UserService;
import org.apache.dubbo.config.annotation.Service;


//@Service//将该类的对象创建出来，放到Spring的IOC容器中  bean定义

@Service//将这个类提供的方法（服务）对外发布。将访问的地址 ip，端口，路径注册到注册中心中
public class UserServiceImpl implements UserService {

    public String sayHello() {
        return "hello dubbo hello!~";
    }
}
dubbo-web

image-20250329221315132

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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.itheima</groupId>
    <artifactId>dubbo-web</artifactId>
    <version>1.0-SNAPSHOT</version>
    <packaging>war</packaging>


    <properties>
        <spring.version>5.1.9.RELEASE</spring.version>
        <dubbo.version>2.7.4.1</dubbo.version>
        <zookeeper.version>4.0.0</zookeeper.version>

    </properties>

    <dependencies>
        <!-- servlet3.0规范的坐标 -->
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.1.0</version>
            <scope>provided</scope>
        </dependency>
        <!--spring的坐标-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-context</artifactId>
            <version>${spring.version}</version>
        </dependency>
        <!--springmvc的坐标-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>${spring.version}</version>
        </dependency>

        <!--日志-->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.21</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.21</version>
        </dependency>



        <!--Dubbo的起步依赖，版本2.7之后统一为rg.apache.dubb -->
        <dependency>
            <groupId>org.apache.dubbo</groupId>
            <artifactId>dubbo</artifactId>
            <version>${dubbo.version}</version>
        </dependency>
        <!--ZooKeeper客户端实现 -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>${zookeeper.version}</version>
        </dependency>
        <!--ZooKeeper客户端实现 -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>${zookeeper.version}</version>
        </dependency>

        <!--依赖公共的接口模块-->
        <dependency>
            <groupId>com.itheima</groupId>
            <artifactId>dubbo-interface</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>


        <!--依赖service模块-->
       <!-- <dependency>
            <groupId>com.itheima</groupId>
            <artifactId>dubbo-service</artifactId>
            <version>1.0-SNAPSHOT</version>
        </dependency>-->

    </dependencies>


    <build>
        <plugins>
            <!--tomcat插件-->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.1</version>
                <configuration>
                    <port>8000</port>
                    <path>/</path>
                </configuration>
            </plugin>
        </plugins>
    </build>


</project>
web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xmlns="http://java.sun.com/xml/ns/javaee"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         version="2.5">


		 
	<!-- Springmvc -->	 
    <servlet>
        <servlet-name>springmvc</servlet-name>
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 指定加载的配置文件 ，通过参数contextConfigLocation加载-->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring/springmvc.xml</param-value>
        </init-param>
    </servlet>

    <servlet-mapping>
        <servlet-name>springmvc</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>


</web-app>
log4j.properties
# DEBUG < INFO < WARN < ERROR < FATAL
# Global logging configuration
log4j.rootLogger=info, stdout,file
# My logging configuration...
#log4j.logger.com.tocersoft.school=DEBUG
#log4j.logger.net.sf.hibernate.cache=debug
## Console output...
log4j.appender.stdout=org.apache.log4j.ConsoleAppender
log4j.appender.stdout.layout=org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern=%5p %d %C: %m%n

log4j.appender.file=org.apache.log4j.FileAppender
log4j.appender.file.File=../logs/iask.log
log4j.appender.file.layout=org.apache.log4j.PatternLayout
log4j.appender.file.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss}  %l  %m%n
springmvc.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"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xmlns:context="http://www.springframework.org/schema/context"
       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://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd http://www.springframework.org/schema/context https://www.springframework.org/schema/context/spring-context.xsd">



    <mvc:annotation-driven/>
    <context:component-scan base-package="com.itheima.controller"/>


    <!--dubbo的配置-->
    <!--1.配置项目的名称,唯一-->
    <dubbo:application name="dubbo-web" >
        <!-- 因为当前 dubbo-service 和 dubbo-web 都部署在本地，qos默认占用的是22222端口，所以这里修改dubbo-web的qos端口-->
        <dubbo:parameter key="qos.port" value="33333"/>
    </dubbo:application>
    <!--2.配置注册中心的地址-->
    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
    <!--3.配置dubbo包扫描-->
    <dubbo:annotation package="com.itheima.controller" />



</beans>
UserController
import com.itheima.service.UserService;
import org.apache.dubbo.config.annotation.Reference;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/user")
public class UserController {

    //注入Service
    //@Autowired//本地注入

    /*
        1. 从zookeeper注册中心获取userService的访问url
        2. 进行远程调用RPC
        3. 将结果封装为一个代理对象。给变量赋值
     */

    @Reference//远程注入
    private UserService userService;


    @RequestMapping("/sayHello")
    public String sayHello(){
        return userService.sayHello();
    }

}
访问

image-20250329221710876image-20250329221720289

image-20250329221741898

访问路径：http://localhost:9091/dubbo_web/user/sayHello

Dubbo 高级特性

dubbo-admin管理平台

  • dubbo-admin 管理平台，是图形化的服务管理页面

  • 从注册中心中获取到所有的提供者 / 消费者进行配置管理

  • 路由规则、动态配置、服务降级、访问控制、权重调整、负载均衡等管理功能

  • dubbo-admin 是一个前后端分离的项目。前端使用vue，后端使用springboot

  • 安装 dubbo-admin 其实就是部署该项目

dubbo-admin安装

1、环境准备

dubbo-admin 是一个前后端分离的项目。前端使用vue，后端使用springboot，安装 dubbo-admin 其实就是部署该项目。我们将dubbo-admin安装到开发环境上。要保证开发环境有jdk，maven，nodejs

安装node**(如果当前机器已经安装请忽略)**

因为前端工程是用vue开发的，所以需要安装node.js，node.js中自带了npm，后面我们会通过npm启动

下载地址

https://nodejs.org/en/

1578298201398

2、下载 Dubbo-Admin

进入github，搜索dubbo-admin

https://github.com/apache/dubbo-admin

下载：

1578297063167

3、把下载的zip包解压到指定文件夹(解压到那个文件夹随意)

1578297477356

4、修改配置文件

解压后我们进入…\dubbo-admin-develop\dubbo-admin-server\src\main\resources目录，找到 application.properties 配置文件 进行配置修改

1578297603008

修改zookeeper地址

1578297758655

# centers in dubbo2.7
admin.registry.address=zookeeper://192.168.149.135:2181
admin.config-center=zookeeper://192.168.149.135:2181
admin.metadata-report.address=zookeeper://192.168.149.135:2181
  • admin.registry.address注册中心
  • admin.config-center 配置中心
  • admin.metadata-report.address元数据中心

5、打包项目

在 dubbo-admin-develop 目录执行打包命令

mvn  clean package

1578300464726

6、启动后端

切换到目录

dubbo-Admin-develop\dubbo-admin-distribution\target>

执行下面的命令启动 dubbo-admin，dubbo-admin后台由SpringBoot构建。

java -jar .\dubbo-admin-0.1.jar

7、前台后端

dubbo-admin-ui 目录下执行命令

npm run dev

1578300677041

8、访问

浏览器输入。用户名密码都是root

http://localhost:8081/

1578300774258

dubbo-admin简单使用

image-20250329223158959

注意:Dubbo Admin【服务Mock】【服务统计】将在后续版本发布…

在上面的步骤中，我们已经进入了Dubbo-Admin的主界面，在【快速入门】章节中，我们定义了服务生产者、和服务消费者，下面我们从Dubbo-Admin管理界面找到这个两个服务

1、点击服务查询

image-20250329223542042

2、查询结果

1578301528363

A:输入的查询条件com.itheima.service.UserService

B:搜索类型，主要分为【按服务名】【按IP地址】【按应用】三种类型查询

C:搜索结果

3.1.4 dubo-admin查看详情

我们查看com.itheima.service.UserService （服务提供者）的具体详细信息，包含【元数据信息】

1）点击详情

image-20250329223616534

（可以看到生产者使用的dubbo端口是20880，可以使用<dubbo:protocol port="20880"/>来修改生产者的这个默认的端口）

从【详情】界面查看，主要分为3个区域

A区域：主要包含服务端 基础信息比如服务名称、应用名称等

B区域：主要包含了生产者、消费者一些基本信息

C区域：是元数据信息，注意看上面的图,元数据信息是空的

我们需要打开我们的生产者配置文件加入下面配置

<!-- 元数据配置 -->
<dubbo:metadata-report address="zookeeper://192.168.149.135:2181" />

重新启动生产者，再次打开Dubbo-Admin

这样我们的元数据信息就出来了

image-20250329225439064

测试dubbo-admin

1、在windows平台上，先修改zoo.cfg配置文件（手动创建dataDir和dataLogDir对应的目录），然后启动zookeeper

image-20250330165415172

zkServer.cmd

image-20250330160215128

2、按照《dubbo-admin管理平台》的安装使用步骤，修改zookeeper的地址，然后打包成dubbo-admin-0.1.jar，使用java -jar dubbo-admin-0.1.jar启动该jar包

image-20250330160800727

3、启动dubbo-admin-ui这个vue项目

image-20250330160834362

4、使用《dubbo快速入门》中的示例，启动dubbo-web和dubbo-service这2个项目。然后使用root/root登录dubbo-admin的管理界面。

image-20250330161836144

image-20250330163149664

查看消费者

image-20250330165603529

5、点击测试，可以测试生产者服务，看到下面已经有结果了

image-20250330163526203

image-20250330163604174

image-20250330163621814

dubbo 常用高级配置

序列化

image-20250330165512762

测试

1、新增1个dubbo-pojo项目，并创建User类，让dubbo-interface引入dubbo-pojo。

image-20250330171738078

User类如下：

@Data
@AllArgsConstructor
@NoArgsConstructor
public class User {

    private Integer id;

    private String name;

    private String password;

}

UserService接口添加方法

public interface UserService {
    ...

    public User getUser(Integer id);
}

UserServiceImpl实现方法

import com.itheima.pojo.User;
import com.itheima.service.UserService;
import org.apache.dubbo.config.annotation.Service;


// 将该类的对象创建出来，放到Spring的IOC容器中  bean定义
@Service//将这个类提供的方法（服务）对外发布。将访问的地址 ip，端口，路径注册到注册中心中
public class UserServiceImpl implements UserService {

    ...

    @Override
    public User getUser(Integer id) {
        return new User(id, "zhangsan", "123456");
    }

}

2、将dubbo-pojo和dubbo-interface使用mvn:install安装到本地仓库，然后启动dubbo-web和dubbo-service

（这里就不使用tomcat来启动了，而使用maven的tomcat7插件来启动。双击Maven面板下的tomcat7:run即可启动对应的项目），然后访问：http://localhost:9091/user/find（由于User类未实现Serilizable接口，所以有如下报错）

image-20250330172236546

3、修改User类，实现Serilizable接口，将dubbo-pojo和dubbo-interface使用mvn:install安装到本地仓库，然后再次启动dubbo-web和dubbo-service，此时访问正常

image-20250330172604908

地址缓存

注册中心挂了，服务是否可以正常访问？

可以，因为dubbo服务消费者在第一次调用时，会将服务提供方地址缓存到本地，以后在调用则不会访问注册中心。当服务提供者地址发生变化时，注册中心会通知服务消费者。

image-20250330190908249

测试

关闭zk，查看是否能访问成功，发现访问仍然能够成功。

image-20250330191055261

超时与重试
超时

image-20250330200218736

  • 服务消费者在调用服务提供者的时候发生了阻塞、等待的情形，这个时候，服务消费者会一直等待下去。

  • 在某个峰值时刻，大量的请求都在同时请求服务消费者，会造成线程的大量堆积，势必会造成雪崩。

  • dubbo 利用超时机制来解决这个问题，设置一个超时时间，在这个时间段内，无法完成服务访问，则自动断开连接。

  • 使用timeout属性配置超时时间，默认值1000，单位毫秒。

重试

  • 设置了超时时间，在这个时间段内，无法完成服务访问，则自动断开连接。

  • 如果出现网络抖动，则这一次请求就会失败。

  • Dubbo 提供重试机制来避免类似问题的发生。

  • 通过 retries 属性来设置重试次数。默认为 2 次。

测试1

消费者（dubbo-web）

@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {

    //注入Service
    //@Autowired//本地注入

    @Reference//远程注入
    private UserService userService;


    @RequestMapping("/find")
    public User find(Integer id){
        log.info("dubbo-web find 被调用");
        try {
            return userService.getUser(id);
        } catch (Exception e) {
            log.info("dubbo-web find 发生异常");
            throw new RuntimeException(e.getMessage());
        } finally {
            log.info("dubbo-web find finally");
        }
    }

}

提供者（dubbo-service）

//@Service//将该类的对象创建出来，放到Spring的IOC容器中  bean定义
@Slf4j
@Service//将这个类提供的方法（服务）对外发布。将访问的地址 ip，端口，路径注册到注册中心中
public class UserServiceImpl implements UserService {

    public String sayHello() {
        return "hello dubbo hello!~";
    }

    @Override
    public User getUser(Integer id) {
        log.info("dubbo-service getUser sleep start...");
        try {
            TimeUnit.MILLISECONDS.sleep(Math.abs(id));
            if (id < 0) {
                throw new RuntimeException("id不能为负数");
            }
            log.info("dubbo-service getUser sleep end...");
            return new User(id, "zhangsan", "123456");
        } catch (Exception e) {
            log.info("dubbo-service getUser 发生异常, e:{}", e);
            throw new RuntimeException(e);
        } finally {
            log.info("dubbo-service getUser finally...");
        }
    }

}

http://localhost:9091/user/find?id=500访问500ms，正常返回

image-20250330194759404

http://localhost:9091/user/find?id=1000访问1000ms，正常返回

image-20250330194900800

http://localhost:9091/user/find?id=1050访问1050ms，会报错。

image-20250330195330922

（并且从dubbo-web和dubbo-service的日志来看，dubbo-web会先发起1次请求，然后dubbo-service会睡1s多，然后就超时了，但是dubbo-service睡完1s多后后续代码仍会继续执行，此时dubbo-web检测到超时，发起请求重试，然后dubbo-service睡完1s多，然后dubbo-web又检测到超时，然后又发起请求重试，然后又检测到超时，此时不再重试，最终抛出超时异常。这也就是说，在默认情况下，消费方会最多发起2次请求重试，一共3次请求）

测试2

给UserServiceImpl的@Service注解加上timeout = 1000，其它代码保持不变，效果与测试1中的结果完全一致。

测试3

给UserServiceImpl的@Service注解加上timeout = 2000，其它代码保持不变。

访问：http://localhost:9091/user/find?id=1500，正常得到结果

image-20250330201811551

访问：http://localhost:9091/user/find?id=2050，会报错

image-20250330201933010

（并且从dubbo-web和dubbo-service的日志来看，dubbo-web会先发起1次请求，然后dubbo-service会睡2s多，然后就超时了，但是dubbo-service睡完2s多后后续代码仍会继续执行，此时dubbo-web检测到超时，发起请求重试，然后dubbo-service睡完2s多，然后dubbo-web又检测到超时，然后又发起请求重试，然后又检测到超时，此时不再重试，最终抛出超时异常。这也就是说，在默认情况下，消费方会最多发起2次请求重试，一共3次请求）

测试4

给UserServiceImpl的@Service注解加上timeout = 2000, retries = 3，其它代码保持不变。

访问：http://localhost:9091/user/find?id=2050

发现服务消费方会重试3次，因为提供者这边被调用了4次（1初次请求 + 3次重试请求）

测试5

给服务消费方的UserController的@Reference注解加上timeout = 1000, retries = 1

给UserServiceImpl的@Service注解加上timeout = 2000, retries = 3

访问：http://localhost:9091/user/find?id=1050

发现服务消费方会重试1次，因为提供者这边被调用了2次（1初次请求 + 1次重试请求），这说明服务的消费方设置的timeout和retries将会覆盖掉服务提供方的timeout和retries，最终重试是由服务的消费方发起的重试。

多版本

image-20250330203414220

  • 灰度发布：当出现新功能时，会让一部分用户先使用新功能，用户反馈没问题时，再将所有用户迁移到新功能。

  • dubbo 中使用version 属性来设置和调用同一个接口的不同版本

测试

在服务的消费者的@Reference指定对应的版本，在服务的提供者提供v1.0和2.0的实现，即可实现调用不同的版本。当服务的消费方使用v1.0，调用的将是v1.0的实现。当服务的消费方使用v2.0，调用的将是v2.0的实现。

服务的消费者

@Slf4j
@RestController
@RequestMapping("/user")
public class UserController {
    
    @Reference(version = "v2.0")//远程注入
    private UserService userService;
    
    @RequestMapping("/find")
    public User find(Integer id){
        log.info("dubbo-web find 被调用");
        try {
            return userService.getUser(id);
        } catch (Exception e) {
            log.info("dubbo-web find 发生异常, e:{}", e);
            throw new RuntimeException(e.getMessage());
        } finally {
            log.info("dubbo-web find finally");
        }
    }

}

服务的提供者

@Slf4j
@Service(version = "v1.0")//将这个类提供的方法（服务）对外发布。将访问的地址 ip，端口，路径注册到注册中心中
public class UserServiceImpl implements UserService {

    public String sayHello() {
        return "hello dubbo hello!~";
    }

    @Override
    public User getUser(Integer id) {
        log.info("dubbo-service getUser sleep start...");
        try {
            TimeUnit.MILLISECONDS.sleep(Math.abs(id));
            if (id < 0) {
                throw new RuntimeException("id不能为负数");
            }
            log.info("dubbo-service getUser sleep end...");
            return new User(id, "zhangsan", "123456");
        } catch (Exception e) {
            log.info("dubbo-service getUser 发生异常, e:{}", e);
            throw new RuntimeException(e);
        } finally {
            log.info("dubbo-service getUser finally...");
        }
    }

}


//@Service//将该类的对象创建出来，放到Spring的IOC容器中  bean定义
@Slf4j
@Service(version = "v2.0")//将这个类提供的方法（服务）对外发布。将访问的地址 ip，端口，路径注册到注册中心中
public class UserServiceImpl2 implements UserService {

    public String sayHello() {
        return "hello dubbo hello!~";
    }

    @Override
    public User getUser(Integer id) {
        log.info("dubbo-service getUser sleep start v2.0...");
        try {
            TimeUnit.MILLISECONDS.sleep(Math.abs(id));
            if (id < 0) {
                throw new RuntimeException("id不能为负数");
            }
            log.info("dubbo-service getUser sleep end v2.0...");
            return new User(id, "zhangsan", "123456");
        } catch (Exception e) {
            log.info("dubbo-service getUser v2.0 发生异常, e:{}", e);
            throw new RuntimeException(e);
        } finally {
            log.info("dubbo-service getUser finally v2.0...");
        }
    }

}
负载均衡

负载均衡的实现查看AbstractLoadBalance的实现类即可。

Random&RoundRobin

image-20250330204345090

leastActive&ConsitentHash

image-20250330205241629

测试

将dubbo-service启动3个；dubbo-web启动1个，并且使用@Reference注解指定负载均衡策略为roundrobin，以测试负载均衡的效果。

dubbo-service修改如下

1、pom.xml中的tomcat7插件的端口修改8091、8092、8093

2、applicationContext.xml中分别修改为20881、20882、20883 和 44441、44442、44443

<?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" 
       xmlns:context="http://www.springframework.org/schema/context"
	   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 
                           http://www.springframework.org/schema/context 
                           https://www.springframework.org/schema/context/spring-context.xsd">


	<!--<context:component-scan base-package="com.itheima.service" />-->

	<!-- 设置生产者的dubbo使用的端口 -->
	<dubbo:protocol port="20883" />

	<!-- 元数据配置 -->
	<dubbo:metadata-report address="zookeeper://127.0.0.1:2181" />

	<!--dubbo的配置-->
	<!--1.配置项目的名称,唯一-->
	<dubbo:application name="dubbo-service" >
		<dubbo:parameter key="qos.port" value="44443"/>
	</dubbo:application>
	<!--2.配置注册中心的地址-->
	<dubbo:registry address="zookeeper://127.0.0.1:2181"/>
	<!--3.配置dubbo包扫描-->
	<dubbo:annotation package="com.itheima.service.impl" />

</beans>

3、UserServiceImpl的sayHello中加上对应的端口号

dubbo-web的UserController中的@Reference注解的loadBalance属性使用roundrobin

访问测试

GIF 2025-3-30 21-25-09

dubbo-admin查看

image-20250330212555205

集群容错

image-20250330212648240

dubbo-web的UserController中的@Reference注解的cluster属性使用failfast

服务降级

image-20250330214405474

dubbo-web的UserController中的@Reference注解的mock属性使用force:return null，将不再调用userService的服务，而直接返回null

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布