Dubbo教程

最新推荐文章于 2023-05-15 12:41:35 发布

KevinAdam

最新推荐文章于 2023-05-15 12:41:35 发布

阅读量305

点赞数 1

分类专栏： Dubbo 文章标签： dubbo provider consumer zookeeper

本文链接：https://blog.csdn.net/Zhang_Pengcheng/article/details/82870819

版权

Dubbo 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

1. Dubbo是什么？

Dubbo是一个分布式服务框架，致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。简单的说，dubbo就是个服务框架，如果没有分布式的需求，其实是不需要用的，只有在分布式的时候，才有dubbo这样的分布式服务框架的需求，并且本质上是个服务调用的东东，说白了就是个远程服务调用的分布式框架。

其核心部分包含:

1. 远程通讯: 提供对多种基于长连接的NIO框架抽象封装，包括多种线程模型，序列化，以及“请求-响应”模式的信息交换方式。

2. 集群容错: 提供基于接口方法的透明远程过程调用，包括多协议支持，以及软负载均衡，失败容错，地址路由，动态配置等集群支持。

3. 自动发现: 基于注册中心目录服务，使服务消费方能动态的查找服务提供方，使地址透明，使服务提供方可以平滑增加或减少机器。

2. Dubbo能做什么？

1.透明化的远程方法调用，就像调用本地方法一样调用远程方法，只需简单配置，没有任何API侵入。

2.软负载均衡及容错机制，可在内网替代F5等硬件负载均衡器，降低成本，减少单点。

3. 服务自动注册与发现，不再需要写死服务提供方地址，注册中心基于接口名查询服务提供者的IP地址，并且能够平滑添加或删除服务提供者。

Dubbo采用全spring配置方式，透明化接入应用，对应用没有任何API侵入，只需用Spring加载Dubbo的配置即可，Dubbo基于Spring的Schema扩展进行加载。

3. Dubbo架构

3.1 背景

3.2 需求

3.3 dubbo架构

节点角色说明：

Provider: 暴露服务的服务提供方。

Consumer: 调用远程服务的服务消费方。

Registry: 服务注册与发现的注册中心。

Monitor: 统计服务的调用次调和调用时间的监控中心。

Container: 服务运行容器。

调用关系说明：

0. 服务容器负责启动，加载，运行服务提供者。

1. 服务提供者在启动时，向注册中心注册自己提供的服务。

2. 服务消费者在启动时，向注册中心订阅自己所需的服务。

3. 注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。

4. 服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。

5. 服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

4. dubbo使用方法

需求：假设现在需要开发2个独立的业务系统，B系统和A系统。A系统调用B系统暴露的接口获取数据，比如查询用户列表。

4.1 安装zookeeper

要运行dubbo，首先需要搭建一个注册中心，比如使用zk作为服务注册中心

zk安装包解压如下：

修改配置文件conf/zoo.cfg：设置data目录，该目录必须存在。

双击zkServer启动zookeeper服务（cmd文件是windows脚本，sh文件是linux下的脚本）：

4.2 搭建B系统

新建一个maven项目(这边可以不用选骨架了)

新建dubbo-b系统

导入依赖

b系统的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/maven-v4_0_0.xsd">
    <parent>
        <artifactId>dubbo-demo</artifactId>
        <groupId>com.cherry.consumer</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <packaging>war</packaging>
    <name>dubbo-b</name>
    <artifactId>dubbo-b</artifactId>
    <dependencies>
        <!-- 单元测试 -->
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <!--lombok-->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <version>1.16.20</version>
        </dependency>
        <!-- 采用spring配置方式使用dubbo，所以需要导入spring容器依赖-->
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>4.3.14.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.7</version>
            <!-- 排除传递spring依赖-->
            <exclusions>
                <exclusion>
                    <artifactId>spring</artifactId>
                    <groupId>org.springframework</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>spring-web</artifactId>
                    <groupId>org.springframework</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>spring-beans</artifactId>
                    <groupId>org.springframework</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>spring-context</artifactId>
                    <groupId>org.springframework</groupId>
                </exclusion>
            </exclusions>
        </dependency>
        <!--导入zookeeper依赖-->
        <dependency>
            <groupId>org.apache.zookeeper</groupId>
            <artifactId>zookeeper</artifactId>
            <version>3.4.8</version>
        </dependency>
        <dependency>
            <groupId>com.github.sgroschupf</groupId>
            <artifactId>zkclient</artifactId>
            <version>0.1</version>
        </dependency>
    </dependencies>
    <build>
        <plugins>
            <plugin>
                <groupId>org.mortbay.jetty</groupId>
                <artifactId>maven-jetty-plugin</artifactId>
                <version>6.1.7</version>
                <configuration>
                    <connectors>
                        <connector implementation="org.mortbay.jetty.nio.SelectChannelConnector">
                            <port>8888</port>
                            <maxIdleTime>30000</maxIdleTime>
                        </connector>
                    </connectors>
                    <webAppSourceDirectory>${project.build.directory}/${pom.artifactId}-${pom.version}
                    </webAppSourceDirectory>
                    <contextPath>/</contextPath>
                </configuration>
            </plugin>
            <!--为了使用maven插件启动该项目-->
            <plugin>
                <groupId>org.apache.tomcat.maven</groupId>
                <artifactId>tomcat7-maven-plugin</artifactId>
                <version>2.2</version>
                <configuration>
                    <path>/</path>
                    <port>8082</port>
                </configuration>
            </plugin>
        </plugins>
    </build>

</project>

配置log4j文件

#输出源是console以及stdout
log4j.rootLogger=debug,console,stdout
#输出源console的配置
# 定义输出源console的输出位置是控制台
log4j.appender.console=org.apache.log4j.ConsoleAppender
# 定义输出日志的布局采用的类
log4j.appender.console.layout=org.apache.log4j.PatternLayout
# 定义日志输出布局
log4j.appender.console.layout.ConversionPattern=%d %p [%c] - %m%n
#输出源stdout的配置
log4j.appender.stdout = org.apache.log4j.FileAppender
log4j.appender.stdout.layout = org.apache.log4j.PatternLayout
log4j.appender.stdout.layout.ConversionPattern = [%-5p][%-22d{yyyy/MM/dd HH:mm:ss S}][%l]%n%m%n
log4j.appender.stdout.Threshold = DEBUG
log4j.appender.stdout.ImmediateFlush = TRUE
log4j.appender.stdout.Append = TRUE
log4j.appender.stdout.File = ${log4jDir}/logd/log4j.log
#spring中的配置配置，需要在web.xml中配置listener
#log4j.appender.stdout.File = ${webApp.root}/WEB-INF/logs/app.log
log4j.appender.stdout.Encoding = UTF-8

创建User对象

package com.cherry.consumer.user.model;
import lombok.Getter;
import lombok.Setter;
import java.io.Serializable;

@Getter
@Setter
public class User implements Serializable {
    private static final long serialVersionUID = 666534008757750297L;
    private Integer id;
    private String  name;
    private String sex;
}

创建IUserService（接口）并提供查询服务

package com.cherry.consumer.user.service;
import com.cherry.consumer.user.model.User;
import java.util.List;
public interface IUserService {
    List<User> queryAllUser();
}

创建UserServiceImpl实现类

package com.cherry.consumer.user.service.impl;
import com.cherry.consumer.user.model.User;
import com.cherry.consumer.user.service.IUserService;
import org.springframework.stereotype.Service;
import java.util.ArrayList;
import java.util.List;
@Service
public class UserServiceImpl implements IUserService {
    public List<User> queryAllUser() {
        List<User> list = new ArrayList<User>();
        for (int i = 0; i < 10; i++) {
            User user = new User();
            user.setId(20 + i);
            user.setSex("M");
            user.setName("username_" + i);
            list.add(user);
        }
        return list;
    }
}

编写dubbo配置文件

<?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://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
      http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd"
       default-lazy-init="false" default-autowire="byName">
    <!-- 提供方应用信息，用于计算依赖关系 -->
    <dubbo:application name = "dubbo-b-provider"/>
    <!-- 使用zookeeper注册中心暴露服务地址 -->
    <dubbo:registry address = "zookeeper://127.0.0.1:2181" client="zkclient"/>
    <!-- 用dubbo协议在20880端口暴露服务 -->
    <dubbo:protocol name="dubbo" port="20880"/>
    <!-- 将该接口暴露到dubbo中 -->
    <dubbo:service interface="com.cherry.consumer.user.service.IUserService" ref="userServiceImpl"/>
    <!-- 将具体的实现类加入到Spring容器中 -->
    <bean id="userServiceImpl" class="com.cherry.consumer.user.service.impl.UserServiceImpl"/>
</beans>

导入zookeeper依赖（在pom.xml中都有了）

编写Web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.4"
         xmlns="http://java.sun.com/xml/ns/j2ee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd">
    <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>

使用maven插件启动服务器：启动tomcat

启动tomcat查看日志

可以看到，已经将UserService服务注册到zookeeper注册中心，协议采用的是dubbo。

Zookeeper控制台显示收到连接：

最终系统a的项目结构

新建dubbo-a系统(和a系统步骤一致，重复的就不写出来了)

注意一点：包名需要一致

编写A系统的dubbo配置文件

<?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://code.alibabatech.com/schema/dubbo"
       xsi:schemaLocation="http://www.springframework.org/schema/beans  http://www.springframework.org/schema/beans/spring-beans-3.2.xsd
      http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd"
       default-lazy-init="false" default-autowire="byName">
    <!-- 提供方应用信息，用于计算依赖关系 -->
    <dubbo:application name = "dubbo-a-consumer"/>
    <!-- 使用zookeeper注册中心暴露服务地址 -->
    <dubbo:registry address = "zookeeper://127.0.0.1:2181" client="zkclient"/>
    <!-- 从注册中心中查找服务 -->
    <dubbo:reference id="userService" interface="com.cherry.consumer.user.service.IUserService"/>
</beans>

编写UserService测试用例

package com.cherry.consumer.user.service;

import com.cherry.consumer.user.model.User;
import org.junit.Before;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import java.util.List;

public class UserServiceTest {
    private IUserService userService;
    @Before
    public void setUp()throws Exception{
        ApplicationContext applicationContext =new ClassPathXmlApplicationContext(
                "classpath:dubbo/*.xml");
        this.userService= applicationContext.getBean(IUserService.class);
    }

    @Test
    public void testQueryAll() {
        List<User> users =this.userService.queryAllUser();
        for(User user :users) {
            System.out.println(user);
        }
    }
}

查看效果(重写了User的toString方法！)

可以看到，已经查询到10条数据，那么，也就是说A系统通过B系统提供的服务获取到了数据。

最终系统b的项目结构

5.解决代码重复问题

上述的两个系统中，其中User对象和UserService在A系统和B系统中都使用，那么，我们是否应该将该代码复用，而不用硬拷贝？答案是肯定的。

在使用dubbo时，provider需要将提供服务所需要的java代码（bean、interface等）单独打包成jar提供给consumer使用。

这个我们在下一篇文章中说。

KevinAdam

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Dubbo教程

1. Dubbo是什么？Dubbo是一个分布式服务框架，致力于提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理方案。简单的说，dubbo就是个服务框架，如果没有分布式的需求，其实是不需要用的，只有在分布式的时候，才有dubbo这样的分布式服务框架的需求，并且本质上是个服务调用的东东，说白了就是个远程服务调用的分布式框架。其核心部分包含:1. 远程通讯: 提供对多种基于长连...
复制链接

扫一扫