分布式-dubbo的入门

提供一个简单的例子：完成下订单，减库存的功能

一、提供服务暴漏的接口，代码如下：

1. package com.rm.dubbo.service.api;
   
2. 
   
3. 
   
4. import com.rm.dubbo.service.pojo.Orders;
   
5. 
   
6. public interface OrdersService {
   
7. 
   
8.    /**
   
9.     * @Description: 根据订单id查询订单
   
10.     */
    
11.    public Orders getOrder(String orderId);
    
12. 
    
13.    /**
    
14.     * @Description: 下订单
    
15.     */
    
16.    public boolean createOrder(String itemId);
    
17. 
    
18. }
    

用的Mybatis的逆向工程，所以这里生成Orders类和Oreders的条件的类，和对应的mapper.xml的文件，工程如下：

有一个这个api是需要给对应的实现类来引用的。而且在分布式中式服务化的，所以把订单服务放一个子模块，工程的结构如下：

二、加入相应的依赖：

①、由于dubbo2.5.3是阿里维护的最后的一个版本，用的人是最多的。dubbo启动的时候是依赖spring的版本的，dubbo的默认的版本是2.5.6的版本是非常的低的，所以要排除掉。

②、order-service是依赖order-api的，所以也要把order-api的版本控制给引入order-service中。

1. <dependencies>
   
2.        <dependency>
   
3.            <groupId>com.rm.dubbo</groupId>
   
4.            <artifactId>rm-order-api</artifactId>
   
5.        </dependency>
   
6. 
   
7.        <!-- Mybatis -->
   
8.        <dependency>
   
9.            <groupId>org.mybatis</groupId>
   
10.            <artifactId>mybatis</artifactId>
    
11.        </dependency>
    
12.        <dependency>
    
13.            <groupId>org.mybatis</groupId>
    
14.            <artifactId>mybatis-spring</artifactId>
    
15.        </dependency>
    
16.        <dependency>
    
17.            <groupId>com.github.miemiedev</groupId>
    
18.            <artifactId>mybatis-paginator</artifactId>
    
19.        </dependency>
    
20.        <dependency>
    
21.            <groupId>com.github.pagehelper</groupId>
    
22.            <artifactId>pagehelper</artifactId>
    
23.        </dependency>
    
24.        <!-- MySql -->
    
25.        <dependency>
    
26.            <groupId>mysql</groupId>
    
27.            <artifactId>mysql-connector-java</artifactId>
    
28.        </dependency>
    
29.        <!-- 连接池 -->
    
30.        <dependency>
    
31.            <groupId>com.alibaba</groupId>
    
32.            <artifactId>druid</artifactId>
    
33.        </dependency>
    
34. 
    
35.        <!-- Spring -->
    
36.        <dependency>
    
37.            <groupId>org.springframework</groupId>
    
38.            <artifactId>spring-context</artifactId>
    
39.        </dependency>
    
40.        <dependency>
    
41.            <groupId>org.springframework</groupId>
    
42.            <artifactId>spring-beans</artifactId>
    
43.        </dependency>
    
44.        <dependency>
    
45.            <groupId>org.springframework</groupId>
    
46.            <artifactId>spring-webmvc</artifactId>
    
47.        </dependency>
    
48.        <dependency>
    
49.            <groupId>org.springframework</groupId>
    
50.            <artifactId>spring-jdbc</artifactId>
    
51.        </dependency>
    
52.        <dependency>
    
53.            <groupId>org.springframework</groupId>
    
54.            <artifactId>spring-aspects</artifactId>
    
55.        </dependency>
    
56. 
    
57.        <!-- 引入dubbo -->
    
58.        <dependency>
    
59.            <groupId>com.alibaba</groupId>
    
60.            <artifactId>dubbo</artifactId>
    
61.            <exclusions>
    
62.                <exclusion>
    
63.                    <artifactId>spring</artifactId>
    
64.                    <groupId>org.springframework</groupId>
    
65.                </exclusion>
    
66.            </exclusions>
    
67.        </dependency>
    
68.        <dependency>
    
69.            <groupId>org.apache.zookeeper</groupId>
    
70.            <artifactId>zookeeper</artifactId>
    
71.        </dependency>
    
72.        <dependency>
    
73.            <groupId>com.github.sgroschupf</groupId>
    
74.            <artifactId>zkclient</artifactId>
    
75.        </dependency>
    
76. 
    
77.        <!-- zk 客户端依赖 -->
    
78.        <dependency>
    
79.            <groupId>org.apache.curator</groupId>
    
80.            <artifactId>curator-framework</artifactId>
    
81.        </dependency>
    
82.        <dependency>
    
83.            <groupId>org.apache.curator</groupId>
    
84.            <artifactId>curator-recipes</artifactId>
    
85.        </dependency>
    
86. 
    
87.        <dependency>
    
88.            <groupId>junit</groupId>
    
89.            <artifactId>junit</artifactId>
    
90.            <version>4.11</version>
    
91.            <scope>test</scope>
    
92.        </dependency>
    
93.    </dependencies>
    

写对应的实现类，代码如下：

1. package com.rm.dubbo.service.impl;
   
2. 
   
3. import com.rm.dubbo.mapper.OrdersMapper;
   
4. import com.rm.dubbo.service.api.OrdersService;
   
5. import com.rm.dubbo.service.pojo.Orders;
   
6. import org.slf4j.Logger;
   
7. import org.slf4j.LoggerFactory;
   
8. import org.springframework.beans.factory.annotation.Autowired;
   
9. import org.springframework.stereotype.Service;
   
10. 
    
11. import java.util.UUID;
    
12. 
    
13. @Service("ordersService")
    
14. public class OrdersServiceImpl implements OrdersService {
    
15. 
    
16.    final static Logger log = LoggerFactory.getLogger(OrdersServiceImpl.class);
    
17. 
    
18.    @Autowired
    
19.    private OrdersMapper ordersMapper;
    
20. 
    
21.    @Override
    
22.    public Orders getOrder(String orderId) {
    
23.        return ordersMapper.selectByPrimaryKey(orderId);
    
24.    }
    
25. 
    
26.    @Override
    
27.    public boolean createOrder(String itemId) {
    
28. 
    
29.        // 创建订单
    
30.        String oid = UUID.randomUUID().toString().replaceAll("-", "");
    
31.        Orders o = new Orders();
    
32.        o.setId(oid);
    
33.        o.setOrderNum(oid);
    
34.        o.setItemId(itemId);
    
35.        ordersMapper.insert(o);
    
36.        log.info("订单创建成功");
    
37.        return true;
    
38.    }
    
39. 
    
40. }
    

三、由于需要把这个服务的接口注册到zk上，参考dubbo的官网，需要一个关于dubbo的配置文件，代码如下：

1. <?xml version="1.0" encoding="UTF-8"?>
   
2. <beans xmlns="http://www.springframework.org/schema/beans"
   
3.       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   
4.       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
   
5.       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
   
6.       http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
   
7. 
   
8.    <!-- 服务提供者的名称，唯一标识 -->
   
9.    <dubbo:application name="order-provider"/>
   
10.    <!-- 注册中心 -->
    
11.    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
    
12.    <!-- 指定暴露的服务端，默认的协议是dubbo-->
    
13.    <dubbo:protocol name="dubbo" port="20881"/>
    
14.    <!-- 定义暴露的服务接口，ref指的是对应的实现类 -->
    
15.    <dubbo:service interface="com.rm.dubbo.service.api.OrdersService" ref="ordersService"/>
    
16. </beans>
    

对应整个项目的结构如下：

然后测试下，启动这个服务，然后启动zk，控制台的信息打印如下：

其中注册打印的信息如下：dubbo默认的协议的是dubbo，用的是dubbo的统一的标准。

1. Register: dubbo://169.254.18.74:20881/com.rm.dubbo.service.api.OrdersService?anyhost=true&application=order-provider&dubbo=2.5.3&interface=com.rm.dubbo.service.api.OrdersService&methods=createOrder,getOrder&pid=14544&revision=1.0-SNAPSHOT&side=provider&timestamp=1580444734532, dubbo version: 2.5.3, current host: 127.0.0.1
   

20881:是dubbo的端口号，169.254.18.74:本机的ip地址。com.rm.dubbo.service.api.OrderService:暴漏出接口的全路径。anyhost:true,代表任何机器都可以访问，没有权限。application=orderprovider:代表这个服务定义的名称。dubbo=2.5.3，dubbo的版本用的是2.5.3的版本。interface=com.rm.dubbo.service.api.OrderService&methods=createOrder,getOrder:这个告诉哪一个接口里的哪一个方法。pid:是当前进程的id。revision=1.0-SNAPSHOT:当前项目的版本。sid=provider代表是一种提供服务的角色。timestamp:毫秒值。后面的是dubbo的版本和主机。

然后查看下zk上的注册信息：

configurations节点:配置会话的 providers:配置服务提供者的，数组的原因是一个接口当中会有很多的实例，这样就可以做成负载均衡。 而在providers节点中的内容和控制台打印的内容是一样的，只不过是做了转义。这就是注册生成协议的信息。

同样也提供商品服务，工程结构如下：

提供暴漏出接口中的方法：

1. package com.rm.dubbo.service.api;
   
2. 
   
3. import com.rm.dubbo.service.pojo.Items;
   
4. 
   
5. public interface ItemsService {
   
6. 
   
7.    /**
   
8.     * @Description: 根据商品id获取商品
   
9.     */
   
10.    public Items getItem(String itemId);
    
11. 
    
12.    /**
    
13.     * @Description: 查询商品库存
    
14.     */
    
15.    public int getItemCounts(String itemId);
    
16. 
    
17.    /**
    
18.     * @Description: 购买商品成功后减少库存
    
19.     */
    
20.    public void displayReduceCounts(String itemId, int buyCounts);
    
21. 
    
22. }
    

同样也需要把这个服务注册到zk上。

然后提供相应的消费端，工程结构如下:

在接口BuyService接口中，提供相应的买商品的方法，代码如下：

1. package com.rm.web.service;
   
2. 
   
3. public interface BuyService {
   
4. 
   
5.    /**
   
6.     * @Description: 购买商品
   
7.     */
   
8.    public void doBuyItem(String itemId);
   
9. 
   
10.    public boolean displayBuy(String itemId);
    
11. }
    

对应的实现类如下：

1. package com.rm.web.service.impl;
   
2. 
   
3. import com.rm.dubbo.service.api.ItemsService;
   
4. import com.rm.dubbo.service.api.OrdersService;
   
5. import com.rm.web.service.BuyService;
   
6. import org.slf4j.Logger;
   
7. import org.slf4j.LoggerFactory;
   
8. import org.springframework.stereotype.Service;
   
9. 
   
10. import javax.annotation.Resource;
    
11. 
    
12. @Service("buyService")
    
13. public class BuyServiceImpl implements BuyService {
    
14. 
    
15.    final static Logger log = LoggerFactory.getLogger(BuyServiceImpl.class);
    
16. 
    
17.    @Resource
    
18.    private ItemsService itemService;
    
19. 
    
20.    @Resource
    
21.    private OrdersService ordersService;
    
22. 
    
23.    @Override
    
24.    public void doBuyItem(String itemId) {
    
25.        // 减少库存
    
26.        itemService.displayReduceCounts(itemId, 1);
    
27. 
    
28.        // 创建订单
    
29.        ordersService.createOrder(itemId);
    
30.    }
    
31. 
    
32.    @Override
    
33.    public boolean displayBuy(String itemId) {
    
34. 
    
35.        int buyCounts = 5;
    
36. 
    
37.        // 1. 判断库存
    
38.        int stockCounts = itemService.getItemCounts(itemId);
    
39.        if (stockCounts < buyCounts) {
    
40.            log.info("库存剩余{}件，用户需求量{}件，库存不足，订单创建失败...",
    
41.                    stockCounts, buyCounts);
    
42.            return false;
    
43.        }
    
44. 
    
45.        // 2. 创建订单
    
46.        boolean isOrderCreated = ordersService.createOrder(itemId);
    
47. 
    
48.        // 3. 创建订单成功后，扣除库存
    
49.        if (isOrderCreated) {
    
50.            log.info("订单创建成功...");
    
51.            itemService.displayReduceCounts(itemId, buyCounts);
    
52.        } else {
    
53.            log.info("订单创建失败...");
    
54.            return false;
    
55.        }
    
56.        return true;
    
57.    }
    
58. 
    
59. }
    

然后消费端也需要把自己注册到zk上，也需要订阅上面的两个服务。所以dubbo的配置信息如下：

1. <?xml version="1.0" encoding="UTF-8"?>
   
2. <beans xmlns="http://www.springframework.org/schema/beans"
   
3.       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   
4.       xmlns:dubbo="http://code.alibabatech.com/schema/dubbo"
   
5.       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
   
6.       http://code.alibabatech.com/schema/dubbo http://code.alibabatech.com/schema/dubbo/dubbo.xsd">
   
7. 
   
8.    <dubbo:application name="web-consumer"/>
   
9.    <!-- 注册中心 -->
   
10.    <dubbo:registry address="zookeeper://127.0.0.1:2181"/>
    
11.    <!-- 引用暴露的服务ordersService和itemService如果和属性的名称相同，则按照名称来装配，否则按照类型装配。
    
12.    interface的值指向接口的全路径,这样做之后把接口的实现类完全放到spring容器中去管理了-->
    
13.    <dubbo:reference id="ordersService"  interface="com.rm.dubbo.service.api.OrdersService"/>
    
14.    <dubbo:reference id="itemService" interface="com.rm.dubbo.service.api.ItemsService" />
    
15. </beans>
    

然后启动消费端：返回的结果是200，代表购买成功。

由于是分布式的项目，数据库做成垂直的拆分。所以分成两个数据库。

这时刷新下数据库。

上面的过程就是dubbo的通过在tomcat容器中启动。一个简单的入门。晚上分享如何去写一个简单的rpc框架。