dubbo基础

最新推荐文章于 2024-07-15 15:40:07 发布

Java硬件工程师

最新推荐文章于 2024-07-15 15:40:07 发布

阅读量181

点赞数

分类专栏： dubbo Java 文章标签： java dubbo

本文链接：https://blog.csdn.net/qq_39736597/article/details/119064497

版权

Java 同时被 2 个专栏收录

211 篇文章 12 订阅

订阅专栏

dubbo

5 篇文章 0 订阅

订阅专栏

1、分布式基础理论

1.1、什么是分布式系统？

《分布式系统原理与范型》定义：
“分布式系统是若干独立计算机的集合，这些计算机对于用户来说就像单个相关系统”
分布式系统（distributed system）是建立在网络之上的软件系统。

随着互联网的发展，网站应用的规模不断扩大，常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行，亟需一个治理系统确保架构有条不紊的演进。

1.2.发展演变

在这里插入图片描述

单一应用架构

当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时，用于简化增删改查工作量的数据访问框架(ORM)是关键。
在这里插入图片描述
适用于小型网站，小型管理系统，将所有功能都部署到一个功能里，简单易用。
缺点：
1、性能扩展比较难（一个功能就会导致整个系统都要重新部署）
2、协同开发问题
3、不利于升级维护

垂直应用架构

当访问量逐渐增大，单一应用增加机器带来的加速度越来越小，将应用拆成互不相干的几个应用，以提升效率。此时，用于加速前端页面开发的Web框架(MVC)是关键。
在这里插入图片描述

通过切分业务来实现各个模块独立部署，降低了维护和部署的难度，团队各司其职更易管理，性能扩展也更方便，更有针对性。
缺点：公用模块无法重复利用，开发性的浪费

分布式服务架构

当垂直应用越来越多，应用之间交互不可避免，将核心业务抽取出来，作为独立的服务，逐渐形成稳定的服务中心，使前端应用能更快速的响应多变的市场需求。此时，用于提高业务复用及整合的分布式服务框架(RPC)是关键。

在这里插入图片描述

流动计算架构

当服务越来越多，容量的评估，小服务资源的浪费等问题逐渐显现，此时需增加一个调度中心基于访问压力实时管理集群容量，提高集群利用率。此时，用于提高机器利用率的资源调度和治理中心(SOA)[ Service Oriented Architecture]是关键。
在这里插入图片描述

1.3.RPC

什么叫RPC

RPC【Remote Procedure Call】是指远程过程调用，是一种进程间通信方式(例如A服务器上的代码想调用B服务器上的应用)，他是一种技术的思想，而不是规范。它允许程序调用另一个地址空间（通常是共享网络的另一台机器上）的过程或函数，而不用程序员显式编码这个远程调用的细节。即程序员无论是调用本地的还是远程的函数，本质上编写的调用代码基本相同。

在这里插入图片描述

RPC两个核心模块：通讯，序列化。

2、dubbo核心概念

2.1.简介

Apache Dubbo (incubating) |ˈdʌbəʊ| 是一款高性能、轻量级的开源Java RPC框架，它提供了三大核心能力：面向接口的远程方法调用，智能容错和负载均衡，以及服务自动注册和发现。
在这里插入图片描述

官网：

http://dubbo.apache.org/

2.2.基本概念

在这里插入图片描述
服务提供者（Provider）：暴露服务的服务提供方，服务提供者在启动时，向注册中心注册自己提供的服务。
服务消费者（Consumer）: 调用远程服务的服务消费方，服务消费者在启动时，向注册中心订阅自己所需的服务，服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。
注册中心（Registry）：注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者
监控中心（Monitor）：服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心
调用关系说明

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

3.dubbo环境搭建

ZooKeeper注册中心

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

Dubbo官方文档: http://dubbo.apache.org/en-us/docs/user/quick-start.html

在zookeeper官网下载zookeeper
http://mirror.bit.edu.cn/apache/zookeeper/zookeeper-3.4.14/
在这里插入图片描述
在bin文件下，启动zkServer.cmd会有报错，处理需要在condif文件中将zoo_sample.cfg文件复制一份，将名字改为zoo.cfg。

在zookeeper的文件夹下创建data文件夹，打开zoo.cfg，修改datadir，将dataDir数据保存为我们自定义的文件中(此步骤可省略)
在这里插入图片描述
配置完毕后，我们再次在conf下启动zkServer.cmd，这次可以成功启动

继续运行zkCli.cmd，可以连接到zookeeper的服务器。

此时，我们zookeeper的注册中心及环境以及搭建完毕。

查看结点创建结点
在这里插入图片描述

监控中心的配置

1.下载dubbo-admin

dubbo-admin下载地址：https://github.com/apache/dubbo-admin/tree/master

在这里插入图片描述
2.解压后进入目录修改指定zookeeper地址
进入如下地址：dubbo-admin-master\dubbo-admin\src\main\resources\application.properties"
将zookeeper的监控中心的地址配置为本地端口

#注册中心的地址
dubbo.registry.address=zookeeper://127.0.0.1:2181

在这里插入图片描述
配置完毕后，我们在dubo-zookeeper\dubbo-admin-master\dubbo-admin文件夹下cmd打包测试下。

mvn clean package

在这里插入图片描述
cmd命令 java -jar dubbo-admin-0.0.1-SNAPSHOT.jar运行打包好的jar包
启动成功后，可以看到一个7001的端口

此时我们的zookeeper的服务都为启动状态，在浏览器中访问 localhost:7001，访问到注册中心，输入账号密码root。
在这里插入图片描述

此时，我们zookeeper监控中心的配置完成。注意，要访问到监控中心，一定要启动zookeeper注册中心的启动类,即一定要提前启动zk

4.dubbo-helloworld

4.1.提出需求

某个电商系统，订单服务需要调用用户服务获取某个用户的所有地址；
我们现在需要创建两个服务模块进行测试

模块	功能
订单服务web模块	创建订单等
用户服务service模块	查询用户地址等

测试预期结果：
订单服务web模块在A服务器，用户服务模块在B服务器，A可以远程调用B的功能。
在这里插入图片描述

4.2.工程架构

根据 dubbo《服务化最佳实践》
1、分包
建议将服务接口，服务模型，服务异常等均放在 API 包中，因为服务模型及异常也是 API 的一部分，同时，这样做也符合分包原则：重用发布等价原则(REP)，共同重用原则(CRP)。
如果需要，也可以考虑在 API 包中放置一份 spring 的引用配置，这样使用方，只需在 spring 加载过程中引用此配置即可，配置建议放在模块的包目录下，以免冲突，如：com/alibaba/china/xxx/dubbo-reference.xml。
2、粒度
服务接口尽可能大粒度，每个服务方法应代表一个功能，而不是某功能的一个步骤，否则将面临分布式事务问题，Dubbo 暂未提供分布式事务支持。
服务接口建议以业务场景为单位划分，并对相近业务做抽象，防止接口数量爆炸。
不建议使用过于抽象的通用接口，如：Map query(Map)，这样的接口没有明确语义，会给后期维护带来不便。

4.3.Dubbo服务提供消费者接口搭建

在这里插入图片描述

引入javabean文件

/**
 * 用户地址
 * @author lfy
 *
 */
public class UserAddress implements Serializable {
	
	private Integer id;
    private String userAddress; //用户地址
    private String userId; //用户id
    private String consignee; //收货人
    private String phoneNum; //电话号码
    private String isDefault; //是否为默认地址    Y-是     N-否
    
    public UserAddress() {
		super();
		// TODO Auto-generated constructor stub
	}
    
	public UserAddress(Integer id, String userAddress, String userId, String consignee, String phoneNum,
			String isDefault) {
		super();
		this.id = id;
		this.userAddress = userAddress;
		this.userId = userId;
		this.consignee = consignee;
		this.phoneNum = phoneNum;
		this.isDefault = isDefault;
	}
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getUserAddress() {
		return userAddress;
	}
	public void setUserAddress(String userAddress) {
		this.userAddress = userAddress;
	}
	public String getUserId() {
		return userId;
	}
	public void setUserId(String userId) {
		this.userId = userId;
	}
	public String getConsignee() {
		return consignee;
	}
	public void setConsignee(String consignee) {
		this.consignee = consignee;
	}
	public String getPhoneNum() {
		return phoneNum;
	}
	public void setPhoneNum(String phoneNum) {
		this.phoneNum = phoneNum;
	}
	public String getIsDefault() {
		return isDefault;
	}
	public void setIsDefault(String isDefault) {
		this.isDefault = isDefault;
	}
	
}

用户服务接口

/**
 * 用户服务
 * @author lfy
 *
 */
public interface UserService {
	
	/**
	 * 按照用户id返回所有的收货地址
	 * @param userId
	 * @return
	 */
	public List<UserAddress> getUserAddressList(String userId);

}

实现类

public class UserServiceImpl implements UserService {

    @Override
    public List<UserAddress> getUserAddressList(String userId) {
        UserAddress address1=new UserAddress(1,"中国科学技术大学思贤楼","1","张老师","1351111111","Y");
        UserAddress address2=new UserAddress(2,"中国科学技术大学明德楼","2","郭老师","1481111111","Y");
        return Arrays.asList(address1,address2);
    }
}

消费者
在这里插入图片描述
OrderService

public interface OrderService {
    /*
    * 初始化订单
    * */
    public void initOrder(String userId);
}

OrderServiceImpl

public class OrderServiceImpl implements OrderService {
    UserService userService;
    @Override
    public void initOrder(String userId) {
        //1.查询用户的收货地址
        List<UserAddress> addressList=userService.getUserAddressList(userId);
        System.out.println(addressList);

    }
}

此时我们调用userservice肯定是要报错的。这种面向接口的方式，我们这里只是调到了接口，而接口实际是在另外一个项目中，如果我们两个项目工程都创建共同的实体类，太过于麻烦了，我们可以将服务接口，服务模型等单独放在一个项目中，更为方便调用。
创建Maven项目=> gmail-interface 用于存放共同的服务接口
在这里插入图片描述
将提供者和消费者项目中的所有实体类复制到当前相关的文件包下，删除原有的实体类包及service包，也就是将实体类及service放在了当前公共的项目中。

把服务提供者和消费者项目中引入以下依赖，引入后项目不在报错.

<dependencies>
    <dependency>
        <groupId>org.example</groupId>
        <artifactId>gmail-interface</artifactId>
        <version>1.0-SNAPSHOT</version>
    </dependency>
</dependencies>

4.4.服务提供者配置及测试

在 user-service-provider 服务提供者项目中引入依赖

 <!--dubbo-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>dubbo</artifactId>
    <version>2.6.2</version>
</dependency>
<!--注册中心是 zookeeper，引入zookeeper客户端-->
<dependency>
    <groupId>org.apache.curator</groupId>
    <artifactId>curator-framework</artifactId>
    <version>2.12.0</version>
</dependency>

在resource文件中创建provider.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"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.3.xsd http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd">

    <!--1、指定当前服务/应用的名字(同样的服务名字相同，不要和别的服务同名)-->
    <dubbo:application name="user-service-provider"></dubbo:application>
    <!--2、指定注册中心的位置-->
    <!--<dubbo:registry address="zookeeper://127.0.0.1:2181"></dubbo:registry>-->
    <dubbo:registry protocol="zookeeper" address="127.0.0.1:2181"></dubbo:registry>
    <!--3、指定通信规则（通信协议? 服务端口）-->
    <dubbo:protocol name="dubbo" port="20880"></dubbo:protocol>

    <!--4、暴露服务 让别人调用 ref指向服务的真正实现对象-->
    <dubbo:service interface="com.yujie.service.UserService" ref="userServiceImpl"></dubbo:service>

    <!--服务的实现-->
    <bean id="userServiceImpl" class="com.yujie.service.impl.UserServiceImpl"></bean>
</beans>

编写一个ProviderApplication启动类程序，运行测试配置

public class MailApplication {
    public static void main(String[] args) throws IOException {
        ClassPathXmlApplicationContext applicationContext= new ClassPathXmlApplicationContext("provider.xml");
        applicationContext.start();
        System.in.read();
    }
}

在这里插入图片描述
zookeeper注册中心的的zkServer.cmd、和zkCli.cmd服务
在dubbo-admin target中cmd运行 java -jar dubbo-admin-0.0.1-SNAPSHOT.jar
再次启动项目，我们可以看到在zookeeper中已经发现服务提供者。

服务消费者配置及测试

在 order-service-consumer 服务消费者项目中引入依赖

 <!--dubbo-->
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>dubbo</artifactId>
            <version>2.6.2</version>
        </dependency>
        <!--注册中心是 zookeeper，引入zookeeper客户端-->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-framework</artifactId>
            <version>2.12.0</version>
        </dependency>

创建consumer.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://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.3.xsd
		http://dubbo.apache.org/schema/dubbo http://dubbo.apache.org/schema/dubbo/dubbo.xsd
		http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
        <!--包扫描-->
        <context:component-scan base-package="com.yujie.service.impl"/>

        <!--指定当前服务/应用的名字(同样的服务名字相同，不要和别的服务同名)-->
        <dubbo:application name="order-service-consumer"></dubbo:application>
        <!--指定注册中心的位置-->
        <dubbo:registry address="zookeeper://127.0.0.1:2181"></dubbo:registry>

        <!--调用远程暴露的服务，生成远程服务代理-->
        <dubbo:reference interface="com.yujie.service.UserService" id="userService"></dubbo:reference>
</beans>

把当前OrderServiceImpl实现类中加上注解

@Service
public class OrderServiceImpl implements OrderService {
    @Autowired
    public UserService userService;
    public void initOrder(String userID) {
        //查询用户的收货地址
        List<UserAddress> userAddressList = userService.getUserAddressList(userID);
        
        //为了直观的看到得到的数据，以下内容也可不写
        System.out.println("当前接收到的userId=> "+userID);
        System.out.println("**********");
        System.out.println("查询到的所有地址为：");
        for (UserAddress userAddress : userAddressList) {
            //打印远程服务地址的信息
            System.out.println(userAddress.getUserAddress());
        }
        
    }
}

编写一个ConsumerApplication启动类程序，运行测试配置

public class ConsumerApplication {
    public static void main(String[] args) {
        ClassPathXmlApplicationContext applicationContext = new ClassPathXmlApplicationContext("consumer.xml");
        OrderService orderService = applicationContext.getBean(OrderService.class);

        //调用方法查询出数据
        orderService.initOrder("1");
        System.out.println("调用完成...");
	    System.in.read();
    }
}

5.dubbo-monitor-simple简易监控中心

进入dubbo-monitor-simple文件，执行cmd命令，mvn package打包成jar包
在这里插入图片描述

将 dubbo-monitor-simple-2.0.0-assembly.tar.gz 压缩包解压至当前文件夹，解压后config文件查看properties的配置是否是本地的zookeeper。
打开解压后的 assembly.bin 文件，start.bat 启动dubbo-monitor-simple监控中心

在浏览器 localhost:8080 ，可以看到一个监控中心。
在服务提供者和消费者的xml中配置以下内容，再次启动服务提供和消费者启动类。

<!--dubbo-monitor-simple监控中心发现的配置-->
<dubbo:monitor protocol="registry"></dubbo:monitor>
<!--<dubbo:monitor address="127.0.0.1:7070"></dubbo:monitor>-->

在这里插入图片描述
可以看到，这个监控中心也捕获到了服务提供和消费者信息

6.Dubbo与SpringBoot整合

在这里插入图片描述

boot-user-service-provider 服务提供者

引入以下依赖

<dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </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>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>gmail-interface</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba.boot</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>0.2.0</version>
        </dependency>

    </dependencies>

把 user-service-provider 中的service拿到此项目中。
注意，以此方法为返回的需要更改 interface包中的void为 List

//这是dubboe的@Service注解
@Service        //暴露服务
@Component
public class UserServiceImpl implements UserService {

    @Override
    public List<UserAddress> getUserAddressList(String userId) {
        UserAddress address1=new UserAddress(1,"中国科学技术大学思贤楼","1","张老师","1351111111","Y");
        UserAddress address2=new UserAddress(2,"中国科学技术大学明德楼","2","郭老师","1481111111","Y");
        return Arrays.asList(address1,address2);
    }
}

配置 application.properties

dubbo.application.name=boot-user-service-provider
dubbo.registry.address=127.0.0.1:2181
dubbo.registry.protocol=zookeeper

dubbo.protocol.name=dubbo
dubbo.protocol.port=20880

#连接监控中心
dubbo.monitor.protocol=registry

BootProviderApplication 启动类配置

@EnableDubbo        //开启基于注解的dubbo功能
@SpringBootApplication
public class BootUserServiceProviderApplication {

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

}

启动注册中心，启动当前服务提供者，可以在浏览器看到一个服务提供者。

boot-order-service-consumer 服务消费者

创建Maven项目 boot-order-service-consumer 服务消费者，注意消费者我们创建的是web工程来测试

导入以下依赖

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.example</groupId>
            <artifactId>gmail-interface</artifactId>
            <version>1.0-SNAPSHOT</version>
            <scope>compile</scope>
        </dependency>

        <dependency>
            <groupId>com.alibaba.boot</groupId>
            <artifactId>dubbo-spring-boot-starter</artifactId>
            <version>0.2.0</version>
        </dependency>

把order-service-consumer项目中的service复制到当前项目。

@Service
public class OrderServiceImpl implements OrderService {
    @Reference  //远程引用userService的服务，会自动发现
    UserService userService;
    @Override
    public List<UserAddress> initOrder(String userID) {
        //查询用户的收货地址
        List<UserAddress> userAddressList = userService.getUserAddressList(userID);
        return userAddressList;

    }
}

创建 OrderController 控制器

@Controller
public class OrderController {
    @Autowired
    OrderService orderService;
    @ResponseBody
    @RequestMapping("/initOrder")
    public List<UserAddress> initOrder(@RequestParam("id") String userId){
        return orderService.initOrder(userId);
    }
}

创建application.properties 配置

# 应用名称
spring.application.name=boot-order-service-consumer
# 应用服务 WEB 访问端口
# 因为8080已经被监控中心使用
server.port=8081

dubbo.application.name=boot-order-service-consumer
dubbo.registry.address=zookeeper://127.0.0.1:2181
dubbo.monitor.protocol=registry

BootConsumerApplication 启动类创建

@EnableDubbo
@SpringBootApplication
public class BootOrderServiceConsumerApplication {

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

}

配置完毕，此时启动zookeeper注册中心及监控。
启动springboot配置的服务提供者和消费者
在浏览器输入 localhost:7001 查看结果

在这里插入图片描述
查询到地址信息

duboo的springboot整合配置完成。

注意：SpringBoot整合Dubbo遇到的几个坑

一、Bean没有注入到容器中报错

 [DUBBO] No Spring Bean annotating Dubbo's
1

2019-03-27 09:01:57.601  INFO 9276 --- [           main] b.f.a.ServiceAnnotationBeanPostProcessor :  [DUBBO] BeanNameGenerator bean can't be found in BeanFactory with name [org.springframework.context.annotation.internalConfigurationBeanNameGenerator], dubbo version: 2.6.2, current host: 192.168.1.114
2019-03-27 09:01:57.601  INFO 9276 --- [           main] b.f.a.ServiceAnnotationBeanPostProcessor :  [DUBBO] BeanNameGenerator will be a instance of org.springframework.context.annotation.AnnotationBeanNameGenerator , it maybe a potential problem on bean name generation., dubbo version: 2.6.2, current host: 192.168.1.114
2019-03-27 09:01:57.602  WARN 9276 --- [           main] b.f.a.ServiceAnnotationBeanPostProcessor :  [DUBBO] No Spring Bean annotating Dubbo's @Service was found under package[com.caohuimin.service.bootuserserviceproductor], dubbo version: 2.6.2, current host: 192.168.1.114

原因：分析错误可以看到是容器中没有要暴露的服务，也就是相应的服务没有加入到容器中

要暴露的服务上没有加@Bean，@Component或者别的能加入到容器中的注解没有使用
检查包的层级，springboot只会自动扫描与MainApplication(主类)相同包层级及以下层级的类，注意包的层级不要弄错了

Java硬件工程师

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
dubbo基础

1、分布式基础理论1.1、什么是分布式系统？《分布式系统原理与范型》定义：“分布式系统是若干独立计算机的集合，这些计算机对于用户来说就像单个相关系统”分布式系统（distributed system）是建立在网络之上的软件系统。随着互联网的发展，网站应用的规模不断扩大，常规的垂直应用架构已无法应对，分布式服务架构以及流动计算架构势在必行，亟需一个治理系统确保架构有条不紊的演进。1.2.发展演变单一应用架构当网站流量很小时，只需一个应用，将所有功能都部署在一起，以减少部署节点和成本。此时，用
复制链接

扫一扫