Dubbo在项目中的应用

最新推荐文章于 2025-06-17 19:42:40 发布
最新推荐文章于 2025-06-17 19:42:40 发布
阅读量2.8k 收藏 4
点赞数 1
分类专栏： JAVA基础知识 分布式知识

关于dubbo的使用，我们举个简单例子：

存在2个系统，A系统和B系统，A系统调用B系统的接口获取数据，用于查询用户列表。

在上一篇博文介绍了dubbo的创建，zookeeper的创建完成后，我们可以来使用dubbo和zookeeper了？

再回顾下dubbo的架构：

所以通过此图，我们看到就是服务的提供者将服务注册到注册中心，服务的消费者从注册中心获取服务，monitor监控服务的调用。

所谓框架无非就是配置文件+java代码，所以dubbo也同理：

（1）首先看下B服务的提供者的配置文件和代码：

搭建b系统：

建立一个maven的war工程，导入依赖

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<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>cn.itcast.dubbo</groupId>
    <artifactId>dubbo-b</artifactId>
    <version>1.0.0-SNAPSHOT</version>
    <packaging>war</packaging>
 
    <dependencies>
        <!-- dubbo采用spring配置方式，所以需要导入spring容器依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.6.4</version>
        </dependency><br data-filtered="filtered">//zookeeper的依赖需要导入，因为需要使用zkclient

<dependency>

        <groupId>org.apache.zookeeper</groupId>

        <artifactId>zookeeper</artifactId>

        <version>3.3.3</version>

      </dependency>

 

      <dependency>

        <groupId>com.github.sgroschupf</groupId>

        <artifactId>zkclient</artifactId>

        <version>0.1</version>

      </dependency>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
         
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.5.3</version>
            <exclusions>
                <exclusion>
                    <!-- 排除传递spring依赖 -->
                    <artifactId>spring</artifactId>
                    <groupId>org.springframework</groupId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>
        <build>
        <plugins>
            <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>
</project>

　　第二步：创建user对象：注意这里一定要实现序列化，并获取序列化的序号：

1
//关于这个的获取，直接点击小黄色图标，既可以自动生成

 

1
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
package cn.itcast.dubbo.pojo;
 
// 使用dubbo要求传输的对象必须实现序列化接口
public class User implements java.io.Serializable {
 
    private static final long serialVersionUID = -2668999087589887337L;<br data-filtered="filtered">//关于这个的获取，直接点击小黄色图标，既可以自动生成
 
    private Long id;
 
    private String username;
 
    private String password;
 
    private Integer age;
 
    public Long getId() {
        return id;
    }
 
    public void setId(Long id) {
        this.id = id;
    }
 
    public String getUsername() {
        return username;
    }
 
    public void setUsername(String username) {
        this.username = username;
    }
 
    public String getPassword() {
        return password;
    }
 
    public void setPassword(String password) {
        this.password = password;
    }
 
    public Integer getAge() {
        return age;
    }
 
    public void setAge(Integer age) {
        this.age = age;
    }
 
}

　　创建服务接口和服务接口的实现类：

接口为了暴露服务的：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
5.3.5.  创建UserService（接口）提供查询服务
package cn.itcast.dubbo.service;
 
import java.util.List;
 
import cn.itcast.dubbo.pojo.User;
 
public interface UserService {
 
    /**
     * 查询所有的用户数据
     *
     * @return
     */
    public List<User> queryAll();
 
}
5.3.6.  创建UserServiceImpl实现类
package cn.itcast.dubbo.service.impl;
 
import java.util.ArrayList;
import java.util.List;
 
import cn.itcast.dubbo.pojo.User;
import cn.itcast.dubbo.service.UserService;
 
public class UserServiceImpl implements UserService {
 
    /**
     * 实现查询，这里做模拟实现，不做具体的数据库查询
     */
    public List<User> queryAll() {
        List<User> list = new ArrayList<User>();
        for (int i = 0; i < 10; i++) {
            User user = new User();
            user.setAge(10 + i);
            user.setId(Long.valueOf(i + 1));
            user.setPassword("123456");
            user.setUsername("username_" + i);
            list.add(user);
        }
        return list;
    }
 
}

　　下面就是dubbo的服务提供者的配置文件了：

实际项目中，相当于服务的提供者的第一步：编写配置文件

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
    http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
 
    <!-- 提供方应用信息，用于计算依赖关系 -->
    <dubbo:application name="dubbo-b-server" />
 
    <!-- 这里使用的注册中心是zookeeper -->
    <dubbo:registry address="zookeeper://127.0.0.1:2181" client="zkclient"/>
 
    <!-- 用dubbo协议在20880端口暴露服务 -->
    <dubbo:protocol name="dubbo" port="20880" />
 
    <!-- 将该接口暴露到dubbo中 -->
    <dubbo:service interface="cn.itcast.dubbo.service.UserService" ref="userServiceImpl" />
 
    <!-- 将具体的实现类加入到Spring容器中 -->
    <bean id="userServiceImpl" class="cn.itcast.dubbo.service.impl.UserServiceImpl" /><br data-filtered="filtered">//监控的配置<br data-filtered="filtered">                    <dubbo:monitor protocol="registry"></dubbo:monitor>
 
  
</beans>

　　这里spring与dubbo进行了无缝整合，所以这里进行了spring与dubbo的整合：

第二步：读取配置文件

我们需要在web.xml中将配置文件引入：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
<?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" id="WebApp_ID" version="2.5">
     
    <display-name>dubbo-b</display-name>
     
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:dubbo/dubbo-*.xml</param-value>
    </context-param>
     
    <!--Spring的ApplicationContext 载入 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>
     
    <welcome-file-list>
        <welcome-file>index.jsp</welcome-file>
    </welcome-file-list>
 
</web-app>

　　第三步：配置服务消费者：

这里我们建立a的系统：

建立一个maven的jar工程：

导入依赖：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
<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>cn.itcast.dubbo</groupId>
    <artifactId>dubbo-a</artifactId>
    <version>0.0.1-SNAPSHOT</version>
 
    <dependencies>
        <!-- dubbo采用spring配置方式，所以需要导入spring容器依赖 -->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.1.3.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.6.4</version>
        </dependency>
 
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.5.3</version>
            <exclusions>
                <exclusion>
                    <!-- 排除传递spring依赖 -->
                    <artifactId>spring</artifactId>
                    <groupId>org.springframework</groupId>
                </exclusion>
            </exclusions>
        </dependency>
 
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.3.3</version>
        </dependency>
 
        <dependency>
            <groupId>com.github.sgroschupf</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.1</version>
        </dependency>
    </dependencies>
</project>

　　从b系统拷贝：

1.1.1.   从b系统中拷贝User对象、UserService接口道a系统

服务的消费者配置：

dubbo-consumer.xml

：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
dubbo-consumer.xml：
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:context="http://www.springframework.org/schema/context" xmlns:p="http://www.springframework.org/schema/p"
    xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
    xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
    http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
    http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-4.0.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-4.0.xsd
    http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
 
    <!-- 提供方应用信息，用于计算依赖关系 -->
    <dubbo:application name="dubbo-a-consumer" />
 
    <!-- 这里使用的注册中心是zookeeper -->
    <dubbo:registry address="zookeeper://127.0.0.1:2181" client="zkclient"/>
     
    <!-- 从注册中心中查找服务 -->
    <dubbo:reference id="userService" interface="cn.itcast.dubbo.service.UserService"/>
  
</beans>

　　编写测试：代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
package cn.itcast.dubbo.service;
 
import static org.junit.Assert.*;
 
import java.util.List;
 
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
 
import cn.itcast.dubbo.pojo.User;
 
public class UserServiceTest {
 
    private UserService userService;//从这里我们可以看出，使用了dubbo后感觉调用服务是在自己的工程一样，但是其实我们是调用的b系统，因为b将服务接口暴露出来了，我们通过访问注册中心的服务接口来获取服务的实现。
 
    @Before
    public void setUp() throws Exception {
        ApplicationContext applicationContext = new ClassPathXmlApplicationContext(
                "classpath:dubbo/*.xml");
        this.userService = applicationContext.getBean(UserService.class);
    }
 
    @Test
    public void testQueryAll() {
        List<User> users = this.userService.queryAll();
        for (User user : users) {
            System.out.println(user);
        }
    }
 
}

　　这个是dubbo的简单入门程序，具体在项目中也是同样的道理。

不过上面代码有重复，我们可以家里一个公共的maven来存放pojo和服务接口，然后ab工程添加依赖即可。

在我们的项目中，一般步骤如下；

（1）导入dubbo、zookeeper依赖

（2）在服务提供者端，编写服务接口，服务接口的实现类，编写配置文件

（3）修改web.xml读取配置文件

（4）在服务消费者，即客户端，调用服务接口，调用服务实现类，编写配置文件

这样系统间就可以互相通信，从而感觉像在本地使用一样。

使用dubbo不像httpclient一样json的转换，因为dubbo都自动进行了。

什么是Dubbo？Dubbo在项目中是怎么用的？
技术专家
09-07 1010
什么是Dubbo？ 黑马程序员Dubbo快速入门，Java分布式框架必会的教程 Dubbo 是阿里开源的远程服务调用（RPC）的分布式框架，提供了 SOA 服务治理方案；它的架构主要有五个角色/核心组件，分为是 Container（容器）、Provider（服务的提供方）、Registry（注册中心）、Consumer（服务的消费方）、Monitor（监控中心）。 容器主要负责启动、加载、运行服务提供者； 同时服务提供者在启动时，向注册中心注册自己提供的服务； 消费者向注册中心订阅自己的服务； 注册中心返
什么是Dubbo？Dubbo在项目中怎么使用？
Aa112233aA1的博客
07-26 756
提供了SOA服务治理方案;它的架构主要有五个角色/核心组件，分为是Container(容器)、Provider(服务的提供方)、Registry(注册中心)、Consumer(服务的消费方)、Monitor(监控中心)。容器主要负责启动、加载、运行服务提供者;同时服务提供者在启动时，向注册中心注册自己提供的服务;消费者向注册中心订阅自己的服务;注册中心返回服务提供者列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者;...
Dubbo使用
李章勇的博客
04-25 567
Dubbo使用 　　【注：本文参考《Dubbo入门---搭建一个最简单的Demo框架》，感谢原创作者的知识探索与奉献】 　　一.Dubbo背景和简介　　Dubbo开始于电商系统，因此在这里先从电商系统的演变讲起。    　1.单一应用框架(ORM)   　 当网站流量很小时，只需一个应用，将所有功能（如下单支付等）都部署在一起，以减少部署节点和成本...
两小时学会使用dubbo(直接API、spring、注解、springboot)
最新发布
weixin_62421895的博客
06-17 1027
Dubbo是一个分布式、高性能、透明化的RPC服务框架，提供服务自动注册、自动发现等高效服务治理方案，可以和Spring框架无缝集成。Dubbo最常用的应用就是远程调用。：配置当前应用信息：配置提供服务的协议信息：配置注册相关信息：配置暴露的服务信息：配置当前应用信息：配置引用的服务信息。
dubbo在项目中的使用
yujian111111的博客
10-15 498
1. 安装zookeeper（见笔记“zookeeper安装及启动”），zookeeper是Dubbo的注册中心。 2. 编写java代码：创建Maven项目，构建Dubbo+Zookeeper+Spring实现的简单Demo； 3. 安装Dubbo-admin（见笔记“Dubbo的管理控制台dubbo-admin安装启动”），实现监控 注意：我启动了一个服务提供者和两个消费者后，可...
基于dubbo的项目开发
qq_35911118的博客
03-09 425
dubbo是什么: dubbo是一个阿里巴巴开发的开源分布式服务框架，致力于提供高性能和透明化的RPC远程服务调用方案，是阿里巴巴集团的各成员站点的核心框架，每天为2,000+个服务提供3,000,000,000+次访问量支持。dubbo是对一个系统中应用层上的优化,后面我会在对系统中数据库层面的优化进行分享,这里我们只针对dubbo进行学习 dubbo能解决什么问题: 当网站变大后，不可避免的需...
使用dubbo 分布式框架开发项目
程序员闪充宝
03-15 134
点击上面　　免费订阅本账号！本公众号主要推送javaweb开发相关技术，基础知识点，同时会深入剖析复杂的问题，分享一些优秀的框架，大型项目经验，当今最流行的Javaweb技术，热点科技新...
dubbo项目源码
04-11
在IT行业中，分布式架构已经成为大型互联网应用的基石，而Dubbo作为阿里巴巴开源的一款高性能、轻量级的服务治理框架，备受业界关注。本篇文章将详细探讨一个名为"淘淘商城"的项目，该商城系统采用SSM（Spring、...
Dubbo在SSM项目中的使用
11-05
在SSM项目中，需要在Spring配置文件中添加Dubbo的相关配置，如服务提供者的应用信息、协议、端口、服务接口等。同时，为服务消费者配置服务引用和消费策略。完成配置后，通过Spring的ApplicationContext加载这些...
dubboDemo项目
03-06
通过这个项目，开发者可以学习到如何利用Dubbo搭建分布式服务，理解服务提供者和消费者的角色，以及如何借助Zookeeper进行服务发现，同时还能熟悉SpringMVC在微服务架构中的应用。这对于提升开发者在分布式系统设计...
dubbo使用
少健终望成，波中取千金----张少波
09-01 280
dubbo 使用
Dubbo的使用
lnh1998的博客
05-15 880
一般超时时间使用默认的超时时间即可，如果超时时间设置过短，当网络出现波动时，请求就会失败，当然dubbo的重试机制会尽量避免这个问题(失败后dubbo会通过重试机制进行两次重试)，如果此时进行的是添加操作，出现网络波动，从而进行重试会导致添加三条记录。可以替换Feign，提升高并发压力，Dubbo是RPC协议，而RPC协议是属于TCP协议的一种。根据消费者的权重进行循环分配，1,2分配到提供者1中，3,4,5分配到提供者2中，6,7,8,9,10分配到提供者3中，1-10依次轮询，然后再循环。
dubbo的使用
丢了风筝的线的博客
05-19 306
dubbo的使用 一、使用dubbo所用的解决的问题 1、rpc调用需要定制，额外的增加工作量 2、rpc的复杂调用，依赖严重 3、rpc不能处理负载测略 4、动态的扩展服务节点 **二、dubbo是什么？**问什么要是用dubbo？ 一种分布式、高性能、透明化的rpc框架 项目需求的不断扩展，使的业务之间的相互嵌套调用越来越复杂，耦合度越来越高，由此 就由原来的单体式架构发展出了面向服务的分布式架构，dubbo就是用处理分布式项目的 远程服务调用的框架。 三、结构和功能 [外链图片转存失败,源站可能有防盗
Apache Dubbo在Spring Boot项目中的应用
通过上述配置，我们可以快速在Spring Boot项目中集成Dubbo来构建分布式应用。对于开发基于微服务的应用程序来说，Dubbo无疑提供了一个强大且灵活的RPC解决方案。它能够帮助开发人员在保证服务调用性能的同时，还能够...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值