# cat-taxi

**Repository Path**: AYueBlog/cat-taxi

## Basic Information

- **Project Name**: cat-taxi
- **Description**: 基于华夏代驾的软改出来的猫咪打车
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 0
- **Forks**: 5
- **Created**: 2024-11-25
- **Last Updated**: 2024-11-25

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

<h1 align="center">猫咪打车</h1> 

# 0X0 项目已死，根本无法复现华夏打车项目

多端全栈项目实战，大型商业级代驾业务全流程落地 --by 华夏打车

# 0X1 关于作者的碎碎念

​	5天！！！愤怒脸！你知道我5天是怎么过来的吗？花费无数精力去按照文档与视频搭建项目，中途的坑让我一一道来。

# 0X2 我所见到恶心坑

##  首先第一坑

在使用docker安装各种各样的服务中间件的时候不会给你版本号，那么没有版本号视频是怎么安装的呢？ 疑惑脸？好好好，这算是问到点子上了，视频怎么做的，他狗日是直接本地导入镜像的，说白了就是直接吧镜像打包好然后用docker的load命令直接加载。草（草本植物的一种代称）！！！你这样根本不知道他用了什么版本，兼容性问题会让你在后面埋下一颗大雷。

​	

##  第二坑

在安装**ShardingSphere**这个玩意的时候我是真的有点想停止复现的想法了，首先这个没有版本号，我在前面提过了。然后，视频里面提到说是用的5.0版本，TNND，我安装的时候各种报错，jdk下了又下11-17版本都下了个遍，最离谱的还是 ShardingSphere这个中间件，我从5.0版本硬是下到了5.5版本中间的每个版本都挨个测试了一遍。好不容易解决兼容问题，这个项目作者还是会藏的啊，这个ShardingSphere中间件是打包好，里面的配置文件写的明明白白。而我还闷在鼓里，一遍遍跑，然后提示没有配置文件，报错！

​	最后去网上查才知道少了配置文件，然后文档的配置文件让我想死的心都有了，残缺不堪，每段只截取一部分，我花了一天的时间，我只记得凌晨4点我才睡的觉。万幸的是我把配置文件还原了出来，你可以看看那 2.4章节的配置文件有多长。但是我知道，有的核心部分我是真的复现不出来，后期肯定会暴雷！

​	

## 第三坑

当我把所有的项目中间件都搭建完了，自豪脸！！我刚准备写代码的时候，视频给我迎头重击，视频说项目代码环境已经全部都写好了，你们可以直接套那个初始化代码模板就行了，然后就直接开始写Serve层代码了，每个项目工程都不介绍的，草！！！我翻遍**全网**也没有（你知道我能搭建私有docker仓库，我就有这个能力）初始化模板代码！无奈只能copy别人写好的代码，还copy几份不同的，然后拼接把项目跑出来了。

​	![image-20240704012444784](assets/image-20240704012444784.png)

![image-20240704012504069](assets/image-20240704012504069.png)



## 最后一坑直接放弃了，这也是我直接弃坑的主要原因

​	在跑前端环境的时候根本就跑不起来，微信小程序的插件我除了ocr，我一个都用不了，这意味着我的地图的导航，路线规划，乃至我最基本的地图都使用不了。

​	最可恨的是，我想查询某些接口的时候，我无意间翻到了一个配置文件里面居然调用了支付接口（为什么知道，原来我做过支付模块所以对这个熟悉的很）它哪怕不写注释我也知道这个是支付模块。支付模块不可怕，可怕的是微信支付模块，众所周知微信的支付模块是需要你去真的开个公司的。我哪里有这个条件哦，小程序的那些插件查了一下，也是需要开通企业级的资质，第二次呐喊，我哪里有那个条件哦。最后想了一下，跑一下vue前端的管理页面吧，好好好，直接雷击，压根无法运行，大片飘红，报错信息更是毫无逻辑，翻了一下网上的解决方案，就是没有解决方案。到此结束。最后放上一张解脱画面。

![image-20240704013838740](assets/image-20240704013838740.png)

# 1 系统环境部署

## 1.1 虚拟机与Centos配置

​	首先Linux的安装不再赘述，版本Centos7-2009版本。

​	PS：现在是2024年7月1日编写的文档，而CentOS官方宣布了停止维护CentOS的计划，CentOS 6已于2020年11月30日停止维护，CentOS 7已于2024年06月30日停止维护。但是对项目当前来讲系统停止维护没有任何影响。

​			但是考虑到后面的几年yum等安装方法可能受到大幅度的影响，如果可以进行平替的话，建议对系统进行平替。

​	唯一要注意的是采用VMware虚拟机系统安装的配置，流畅运行配置如下，当然，这里面采用最小化这里可以酌情精简配置：

![image-20240701155142083](assets/image-20240701155142083.png)

​	**这里使用双网卡，一个是桥接网卡，另一个是net网卡，一个用于对外网络通信，一个用于局域网内部访问。**

​	举个栗子：	

| 网卡     | 模式   | 地址/网关                     |
| -------- | ------ | ----------------------------- |
| 桥接网卡 | static | 192.168.8.12 / 192.168.8.1    |
| net网卡  | static | 192.168.10.100 / 192.168.10.2 |

当然这里面还涉及到了系统的端口映射，就放到docker容器部署里面讲了。



# 2 docker容器部署

VMware中nat端口转发必要性：因为项目需要对外暴露，也就是说让别人的电脑也可以连上这台虚拟机。这时候使用nat模式的话是无法将虚拟机给其他的电脑进行连接，只能本机进行访问。这就意味，ssh远程访问，MySQL，redis等服务无法给其他的电脑进行连接，这里就需要引入VMware的端口转发功能，将你需要的功能进行转发。

端口转发如图：

| 服务           | 本机端口（宿主机）  | docker服务器端口（子主机） | 服务源端口          |
| -------------- | ------------------- | -------------------------- | ------------------- |
| SSH远程服务    | 5022                | 22                         | 22                  |
| MySQL-1        | 3311                | 3311                       | 3306                |
| MySQL-2        | 3312                | 3312                       | 3306                |
| MySQL-3        | 3313                | 3313                       | 3306                |
| MySQL-4        | 3314                | 3314                       | 3306                |
| MySQL-5        | 3315                | 3315                       | 3306                |
| ShardingSphere | 3307                | 3307                       | 3307                |
| MongoDB        | 27017               | 27017                      | 27017               |
| redis          | 6379                | 6379                       | 6379                |
| Minio          | 9001 UI端口 / 9000  | 9001 / 9000                | 9001 / 9000         |
| RabbitMQ       | 15672 UI端口 / 5672 | 15672 UI端口 / 5672        | 15672 UI端口 / 5672 |
| Nacos          | 8848                | 8848                       | 8848                |
| Sentinel       | 8719 / 8858 UI端口  | 8719 / 8858 UI端口         | 8719 / 8858 UI端口  |



## 2.1 MySQL集群

​	在docker中，我们需要为项目创建一个独立的docker网段，这样可以使项目之间的容器，与原本的容器不受干扰。

```
docker network create --subnet=10.0.0.0/24 cat
```

​	网段可以改自己喜欢的，"cat"最后的名字可以随便起

```
docker run -it 
--restart=always \
-d --name mysql_1 -p 3311:3306 \
--net cat --ip 10.0.0.2 \
-m 400m \
-v /opt/data/mysql/mysql_1/data:/var/lib/mysql \
-v /opt/data/mysql/mysql_1/config:/etc/mysql/conf.d \
-e MYSQL_ROOT_PASSWORD=root \
-e TZ=Asia/Shanghai --privileged=true \
mysql:8.0.23 \
--lower_case_table_names=1
--skip-name-resolve
```

-p 端口映射

--net  设置刚才的网段

--ip 分配ip地址，需要注意的是，10.0.0.1是网关的 IP ( 不可用 )

-m 限制容器内存大小

-v 将docker容器的路径挂载到宿主机上

-e 设置参数

mysql:8.0.23  选择创建的镜像

--lower_case_table_names=1 MySQL的设置，不区分数据表的大小写。

--skip-name-resolve解决MySQL端口映射访问速度慢的问题。

```
echo "skip-name-resolve" >> /etc/mysql/my.cnf
```

改一下名字网段，连续创建剩下的MySQL容器。



## 2.2 ShardingSphere 安装

​	Apache ShardingSphere 是一款分布式 SQL 事务和查询引擎，可通过数据分片、弹性伸缩、加密等能力对任意数据库进行增强。

​	经过多次测试5.0-5.5版本的全版本，最后选择了5.1.2版本，这个版本是唯一最贴近5.0.0版本的使用版本。

![image-20240702165837059](assets/image-20240702165837059.png)

​	注意，使用ShardingSphere 需要安装Java环境，但是经过测试，正常在centos7安装Java11-15版本都不行，**会报"Could not create the Java Virtual Machine."错误。**因为没有人在安装ShardingSphere 能解决这种错误的，这种错误在全网都是几乎无解的。

​	所以必须使用docker进行安装Java环境。jdk的镜像版本如下：

![image-20240702170450241](assets/image-20240702170450241.png)

​	注意你在任何地方都找不到我这个版本的镜像，因为这个是我自己使用自建仓库拉取下来的，而原始版本是：

![image-20240702170734248](assets/image-20240702170734248.png)

​	如果有能力可以直接下载。

​	然后就是配置文件了，这个几乎是我最头疼的。因为这个几乎我花了一个通宵根据原始的一点提示而补全出来的，我估计大部分的人都会止步于这一步了。话不多说，这里面一共就两个文件：server.yaml与config-sharding.yaml这两个文件。

​	都在**/opt/module/shardingsphere/conf**这个目录里面了，注意我是安装到/opt/module这个目录里面了，按照自己的安装位置进行一一对应。

​	首先是server.yaml配置文件：

```yaml
#
# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#

######################################################################################################
# 
# If you want to configure governance, authorization and proxy properties, please refer to this file.
# 
######################################################################################################

#mode:
#  type: Cluster
#  repository:
#    type: ZooKeeper
#    props:
#      namespace: governance_ds
#      server-lists: localhost:2181
#      retryIntervalMilliseconds: 500
#      timeToLiveSeconds: 60
#      maxRetries: 3
#      operationTimeoutMilliseconds: 500
#  overwrite: false
#
rules:
 - !AUTHORITY
   users:
     - root@%:root
     - sharding@:root
   provider:
     type: ALL_PRIVILEGES_PERMITTED
 - !TRANSACTION
   defaultType: XA
   providerType: Atomikos
#  - !SQL_PARSER
#    sqlCommentParseEnabled: true
#    sqlStatementCache:
#      initialCapacity: 2000
#      maximumSize: 65535
#      concurrencyLevel: 4
#    parseTreeCache:
#      initialCapacity: 128
#      maximumSize: 1024
#      concurrencyLevel: 4

#props:
#  max-connections-size-per-query: 1
#  kernel-executor-size: 16  # Infinite by default.
#  proxy-frontend-flush-threshold: 128  # The default value is 128.
#  proxy-opentracing-enabled: false
#  proxy-hint-enabled: false
#  sql-show: false
#  check-table-metadata-enabled: false
#  show-process-list-enabled: false
#    # Proxy backend query fetch size. A larger value may increase the memory usage of ShardingSphere Proxy.
#    # The default value is -1, which means set the minimum value for different JDBC drivers.
#  proxy-backend-query-fetch-size: -1
#  check-duplicate-table-enabled: false
#  proxy-frontend-executor-size: 0 # Proxy frontend executor size. The default value is 0, which means let Netty decide.
#    # Available options of proxy backend executor suitable: OLAP(default), OLTP. The OLTP option may reduce time cost of writing packets to client, but it may increase the latency of SQL execution
#    # and block other clients if client connections are more than `proxy-frontend-executor-size`, especially executing slow SQL.
#  proxy-backend-executor-suitable: OLAP
#  proxy-frontend-max-connections: 0 # Less than or equal to 0 means no limitation.
#  sql-federation-enabled: false
#    # Available proxy backend driver type: JDBC (default), ExperimentalVertx
#  proxy-backend-driver-type: JDBC

```

其实就是设置了一下数据库远程登录的账号与数据库的隔离性。

然后就是大头config-sharding.yaml文件：

```yaml
schemaName: cat-taxi

dataSources:
 rep_s1_mis:
   url: jdbc:mysql://10.0.0.2:3306/hxds_mis?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true&allowPublicKeyRetrieval=true
   username: root
   password: root
   connectionTimeoutMilliseconds: 30000
   idleTimeoutMilliseconds: 60000
   maxLifetimeMilliseconds: 1800000
   maxPoolSize: 50
   minPoolSize: 1

 rep_s1_cst:
   url: jdbc:mysql://10.0.0.2:3306/hxds_cst?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true&allowPublicKeyRetrieval=true
   username: root
   password: root
   connectionTimeoutMilliseconds: 30000
   idleTimeoutMilliseconds: 60000
   maxLifetimeMilliseconds: 1800000
   maxPoolSize: 50
   minPoolSize: 1
 rep_s2_cst:
   url: jdbc:mysql://10.0.0.3:3306/hxds_cst?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true&allowPublicKeyRetrieval=true
   username: root
   password: root
   connectionTimeoutMilliseconds: 30000
   idleTimeoutMilliseconds: 60000
   maxLifetimeMilliseconds: 1800000
   maxPoolSize: 50
   minPoolSize: 1
   
 rep_s1_dr: 
   url: jdbc:mysql://10.0.0.2:3306/hxds_dr?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true&allowPublicKeyRetrieval=true
   username: root
   password: root
   connectionTimeoutMilliseconds: 30000
   idleTimeoutMilliseconds: 60000
   maxLifetimeMilliseconds: 1800000
   maxPoolSize: 50
   minPoolSize: 1
 rep_s2_dr: 
   url: jdbc:mysql://10.0.0.3:3306/hxds_dr?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true&allowPublicKeyRetrieval=true
   username: root
   password: root
   connectionTimeoutMilliseconds: 30000
   idleTimeoutMilliseconds: 60000
   maxLifetimeMilliseconds: 1800000
   maxPoolSize: 50
   minPoolSize: 1
   
 rep_s1_rule: 
   url: jdbc:mysql://10.0.0.2:3306/hxds_rule?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true&allowPublicKeyRetrieval=true
   username: root
   password: root
   connectionTimeoutMilliseconds: 30000
   idleTimeoutMilliseconds: 60000
   maxLifetimeMilliseconds: 1800000
   maxPoolSize: 50
   minPoolSize: 1  
 rep_s2_rule: 
   url: jdbc:mysql://10.0.0.3:3306/hxds_rule?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true&allowPublicKeyRetrieval=true
   username: root
   password: root
   connectionTimeoutMilliseconds: 30000
   idleTimeoutMilliseconds: 60000
   maxLifetimeMilliseconds: 1800000
   maxPoolSize: 50
   minPoolSize: 1

 rep_s3_odr:
   url: jdbc:mysql://10.0.0.4:3306/hxds_odr?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true&allowPublicKeyRetrieval=true
   username: root
   password: root
   connectionTimeoutMilliseconds: 30000
   idleTimeoutMilliseconds: 60000
   maxLifetimeMilliseconds: 1800000
   maxPoolSize: 50
   minPoolSize: 1    
 rep_s4_odr:
   url: jdbc:mysql://10.0.0.5:3306/hxds_odr?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true&allowPublicKeyRetrieval=true
   username: root
   password: root
   connectionTimeoutMilliseconds: 30000
   idleTimeoutMilliseconds: 60000
   maxLifetimeMilliseconds: 1800000
   maxPoolSize: 50
   minPoolSize: 1  

 rep_s3_vhr:
   url: jdbc:mysql://10.0.0.4:3306/hxds_vhr?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true&allowPublicKeyRetrieval=true
   username: root
   password: root
   connectionTimeoutMilliseconds: 30000
   idleTimeoutMilliseconds: 60000
   maxLifetimeMilliseconds: 1800000
   maxPoolSize: 50
   minPoolSize: 1 
 rep_s4_vhr:
   url: jdbc:mysql://10.0.0.5:3306/hxds_vhr?useUnicode=true&characterEncoding=UTF-8&serverTimezone=Asia/Shanghai&nullCatalogMeansCurrent=true&allowPublicKeyRetrieval=true
   username: root
   password: root
   connectionTimeoutMilliseconds: 30000
   idleTimeoutMilliseconds: 60000
   maxLifetimeMilliseconds: 1800000
   maxPoolSize: 50
   minPoolSize: 1 
   

rules:
- !SHARDING
  tables:
    tb_action: 
      actualDataNodes: rep_s1_mis.tb_action
    tb_dept: 
      actualDataNodes: rep_s1_mis.tb_dept
    tb_feedback: 
      actualDataNodes: rep_s1_mis.tb_feedback
    tb_module: 
      actualDataNodes: rep_s1_mis.tb_module
    tb_permission: 
      actualDataNodes: rep_s1_mis.tb_permission
    tb_role: 
      actualDataNodes: rep_s1_mis.tb_role
    tb_user: 
      actualDataNodes: rep_s1_mis.tb_user

    tb_customer:
       actualDataNodes: rep_s${1..2}_cst.tb_customer
       databaseStrategy:
        standard:
          shardingColumn: id
          shardingAlgorithmName: cst-inline
       keyGenerateStrategy:
        column: id
        keyGeneratorName: snowflake

    tb_customer_fine:
       actualDataNodes: rep_s${1..2}_cst.tb_customer_fine
       databaseStrategy:
         standard:
           shardingColumn: customer_id
           shardingAlgorithmName: cst-children-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake

    tb_customer_car:
       actualDataNodes: rep_s${1..2}_cst.tb_customer_car
       tableStrategy:
         standard:
           shardingColumn: customer_id
           shardingAlgorithmName: cst-children-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake
  
    tb_driver:
       actualDataNodes: rep_s${1..2}_dr.tb_driver
       tableStrategy:
         standard:
           shardingColumn: id
           shardingAlgorithmName: dr-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake
      
    tb_driver_fine:
       actualDataNodes: rep_s${1..2}_dr.tb_driver_fine
       tableStrategy:
         standard:
           shardingColumn: id
           shardingAlgorithmName: dr-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake'
    
    tb_driver_lockdown:
       actualDataNodes: rep_s${1..2}_dr.tb_driver_lockdown
       tableStrategy:
         standard:
           shardingColumn: id
           shardingAlgorithmName: dr-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake
   
    tb_driver_recognition:
       actualDataNodes: rep_s${1..2}_dr.tb_driver_recognition
       tableStrategy:
         standard:
           shardingColumn: id
           shardingAlgorithmName: dr-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake

    tb_driver_settings:
       actualDataNodes: rep_s${1..2}_dr.tb_driver_settings
       tableStrategy:
         standard:
           shardingColumn: id
           shardingAlgorithmName: dr-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake
   
    tb_wallet:
       actualDataNodes: rep_s${1..2}_dr.tb_wallet
       tableStrategy:
         standard:
           shardingColumn: id
           shardingAlgorithmName: dr-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake 
 
    tb_wallet_income:
       actualDataNodes: rep_s${1..2}_dr.tb_wallet_income
       tableStrategy:
         standard:
           shardingColumn: id
           shardingAlgorithmName: dr-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake 
 
    tb_wallet_payment:
       actualDataNodes: rep_s${1..2}_dr.tb_wallet_payment
       tableStrategy:
         standard:
           shardingColumn: id
           shardingAlgorithmName: dr-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake 
  
    tb_award_rule:
       actualDataNodes: rep_s${1..2}_rule.tb_award_rule
       tableStrategy:
         standard:
           shardingColumn: id
           shardingAlgorithmName: rule-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake 

    tb_cancel_rule:
       actualDataNodes: rep_s${1..2}_rule.tb_cancel_rule
       tableStrategy:
         standard:
           shardingColumn: id
           shardingAlgorithmName: rule-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake     

    tb_charge_rule:
       actualDataNodes: rep_s${1..2}_rule.tb_charge_rule
       tableStrategy:
         standard:
           shardingColumn: id
           shardingAlgorithmName: rule-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake 

    tb_profitsharing_rule:
       actualDataNodes: rep_s${1..2}_rule.tb_profitsharing_rule
       tableStrategy:
         standard:
           shardingColumn: id
           shardingAlgorithmName: rule-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake 

    tb_order:
       actualDataNodes: rep_s${3..4}_odr.tb_order
       tableStrategy:
         standard:
           shardingColumn: customer_id
           shardingAlgorithmName: ord-children-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake 

    tb_order_appeal:
       actualDataNodes: rep_s${3..4}_odr.tb_order_appeal
       tableStrategy:
         standard:
           shardingColumn: order_id
           shardingAlgorithmName: ord-order-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake 

    tb_order_bill:
       actualDataNodes: rep_s${3..4}_odr.tb_order_bill
       tableStrategy:
         standard:
           shardingColumn: order_id
           shardingAlgorithmName: ord-order-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake 

    tb_order_call:
       actualDataNodes: rep_s${3..4}_odr.tb_order_call
       tableStrategy:
         standard:
           shardingColumn: order_id
           shardingAlgorithmName: ord-order-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake 

    tb_order_comment:
       actualDataNodes: rep_s${3..4}_odr.tb_order_comment
       tableStrategy:
         standard:
           shardingColumn: order_id
           shardingAlgorithmName: ord-order-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake 

    tb_order_monitoring:
       actualDataNodes: rep_s${3..4}_odr.tb_order_monitoring
       tableStrategy:
         standard:
           shardingColumn: order_id
           shardingAlgorithmName: ord-order-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake 
  
    tb_order_profitsharing:
       actualDataNodes: rep_s${3..4}_odr.tb_order_profitsharing
       tableStrategy:
         standard:
           shardingColumn: order_id
           shardingAlgorithmName: ord-order-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake 
  
    tb_order_violation:
       actualDataNodes: rep_s${3..4}_odr.tb_order_violation
       tableStrategy:
         standard:
           shardingColumn: order_id
           shardingAlgorithmName: ord-order-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake 

    tb_voucher:
       actualDataNodes: rep_s${3..4}_vhr.tb_voucher
       tableStrategy:
         standard:
           shardingColumn: id
           shardingAlgorithmName: vhr-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake    
    
    tb_voucher_customer:
       actualDataNodes: rep_s${3..4}_vhr.tb_voucher_customer
       tableStrategy:
         standard:
           shardingColumn: customer_id
           shardingAlgorithmName: vhr-children-inline
       keyGenerateStrategy:
         column: id
         keyGeneratorName: snowflake

  bindingTables:
  - tb_voucher
  - tb_voucher_customer
  - tb_order
  - tb_order_appeal
  - tb_order_bill
  - tb_order_call
  - tb_order_comment
  - tb_order_monitoring
  - tb_order_profitsharing
  - tb_order_violation
  - tb_award_rule
  - tb_cancel_rule
  - tb_charge_rule
  - tb_profitsharing_rule
  - tb_driver
  - tb_driver_fine
  - tb_driver_lockdown
  - tb_driver_recognition
  - tb_driver_settings
  - tb_wallet
  - tb_wallet_income
  - tb_wallet_payment
  - tb_customer
  - tb_customer_car
  - tb_customer_fine
  
  shardingAlgorithms:
    cst-inline:
     type: INLINE
     props:
       algorithm-expression: rep_s${(id % 2)+1}_cst
    cst-children-inline: 
     type: INLINE
     props:
       algorithm-expression: rep_s${(customer_id % 2)+1}_cst
       
    dr-inline:
     type: INLINE
     props:
       algorithm-expression: rep_s${(id % 2)+1}_dr

    rule-inline:
     type: INLINE
     props:
       algorithm-expression: rep_s${(id % 2)+1}_rule

    ord-children-inline: 
     type: INLINE
     props:
       algorithm-expression: rep_s${(customer_id % 2)+1}_ord
    ord-order-inline: 
     type: INLINE
     props:
       algorithm-expression: rep_s${(order_id % 2)+1}_ord

    vhr-inline:
     type: INLINE
     props:
       algorithm-expression: rep_s${(id % 2)+1}_vhr
    vhr-children-inline: 
     type: INLINE
     props:
       algorithm-expression: rep_s${(customer_id % 2)+1}_vhr

  keyGenerators:
    snowflake:
     type: SNOWFLAKE
```

​	这个我不想去解释里面的内容了，太痛苦了。

​	给shardingsphere/bin目录下的脚本给运行权限：进入shardingsphere的bin目录下然后执行

```bash
chmod 777 -R ./*
```



​	然后就是jdk的环境创建，不然无法配合使用。

```bash
docker run -it -d --name jdk -p 3307:3307 \
--net cat --ip 10.0.0.7 \
-m 700m -v /opt/module/shardingsphere:/opt/module/shardingsphere \
-e TZ=Asia/Shanghai --privileged=true \
registry.cn-hangzhou.aliyuncs.com/my-base-env/jdk:15.0.2 bash
```

​	端口这里要提一嘴，shardingsphere的暴露端口是3307，大概就是映射shardingsphere文件夹到容器里面，然后去运行bin目录里面的start.sh脚本就行了。

​	运行后去shardingsphere的logs文件夹看一下日志文件，没有报错就是运行成功了。

​	然后就是去连一下shardingsphere的数据库，账号密码你看server.yaml文件设置的。

![image-20240702172435936](assets/image-20240702172435936.png)



## 2.3 安装MongoDB

​	这里简单的概述一下要做的事情，拉取镜像，然后就是写安装MongoDB的配置文件。写启动脚本最后运行。

​	镜像版本为当前最新版本：latest

![image-20240702173636215](assets/image-20240702173636215.png)

​	在你想安装的地方创建mongoDB创建配置文件：

​	创建 /opt/data/mongoDB/mongod.conf 文件，然后在文件中添加如下内容：

```yaml
storage:
  dbPath: "/data/db"
security:
  authorization: enabled
net:
  port: 27017
  bindIp: "0.0.0.0"
```

​	启动 MongoDB 容器

```shell
docker run -it -d --name mongo \
-p 27017:27017 \
--net cat --ip 10.0.0.8 \
-v /opt/data/mongoDB:/etc/mongo \
-v /opt/data/mongoDB/data/db:/data/db \
-m 400m --privileged=true \
-e MONGO_INITDB_ROOT_USERNAME=admin \
-e MONGO_INITDB_ROOT_PASSWORD=admin \
-e TZ=Asia/Shanghai \
--restart=always \
registry.cn-hangzhou.aliyuncs.com/my-base-env/mongo \
--config /etc/mongo/mongod.conf
```

​	然后使用工具连接就行了

![image-20240702181116866](assets/image-20240702181116866.png)

## 2.4 redis安装

​	拉取镜像redis镜像，这里还是选择6.0.10版本：

![image-20240702185048807](assets/image-20240702185048807.png)

​	编写配置文件：redis.conf

​	创建 /opt/data/redis/conf/redis.conf 文件，然后在文件中添加如下内容：

```shell
# 指定 redis 只接收来自于该IP地址的请求，如果不进行设置，那么将处理所有请求
# bind 127.0.0.1
bind 0.0.0.0

# 是否开启保护模式，默认开启。要是配置里没有指定bind和密码。开启该参数后，redis只会本地进行访问，拒绝外部访问。
protected-mode no

# redis监听的端口号。
port 6379

# 此参数确定了TCP连接中已完成队列(完成三次握手之后)的长度， 当然此值必须不大于Linux系统定义的/proc/sys/net/core/somaxconn值，默认是511，而Linux的默认参数值是128。当系统并发量大并且客户端速度缓慢的时候，可以将这二个参数一起参考设定。该内核参数默认值一般是128，对于负载很大的服务程序来说大大的不够。一般会将它修改为2048或者更大。在/etc/sysctl.conf中添加:net.core.somaxconn = 2048，然后在终端中执行sysctl -p。
tcp-backlog 511

# 此参数为设置客户端空闲超过timeout，服务端会断开连接，为0则服务端不会主动断开连接，不能小于0。
timeout 0

# tcp keepalive参数。如果设置不为0，就使用配置tcp的SO_KEEPALIVE值，使用keepalive有两个好处:检测挂掉的对端。降低中间设备出问题而导致网络看似连接却已经与对端端口的问题。在Linux内核中，设置了keepalive，redis会定时给对端发送ack。检测到对端关闭需要两倍的设置值。
tcp-keepalive 0

# 指定了服务端日志的级别。级别包括：debug（很多信息，方便开发、测试），verbose（许多有用的信息，但是没有debug级别信息多），notice（适当的日志级别，适合生产环境），warn（只有非常重要的信息）
loglevel notice

# 指定了记录日志的文件。空字符串的话，日志会打印到标准输出设备。后台运行的redis标准输出是/dev/null。
logfile ""

# 数据库的数量，默认使用的数据库是DB 0。可以通过SELECT命令选择一个db
databases 12

# redis是基于内存的数据库，可以通过设置该值定期写入磁盘。
# 注释掉“save”这一行配置项就可以让保存数据库功能失效
# 900秒（15分钟）内至少1个key值改变（则进行数据库保存--持久化） 
# 300秒（5分钟）内至少10个key值改变（则进行数据库保存--持久化） 
# 60秒（1分钟）内至少10000个key值改变（则进行数据库保存--持久化）
save 900 1
save 300 10
save 60 10000

# 当RDB持久化出现错误后，是否依然进行继续进行工作，yes：不能进行工作，no：可以继续进行工作，可以通过info中的rdb_last_bgsave_status了解RDB持久化是否有错误
stop-writes-on-bgsave-error yes

# 使用压缩rdb文件，rdb文件压缩使用LZF压缩算法，yes：压缩，但是需要一些cpu的消耗。no：不压缩，需要更多的磁盘空间
rdbcompression yes

# 是否校验rdb文件。从rdb格式的第五个版本开始，在rdb文件的末尾会带上CRC64的校验和。这跟有利于文件的容错性，但是在保存rdb文件的时候，会有大概10%的性能损耗，所以如果你追求高性能，可以关闭该配置。
rdbchecksum yes

# rdb文件的名称
dbfilename dump.rdb

# 数据目录，数据库的写入会在这个目录。rdb、aof文件也会写在这个目录
dir ./

# requirepass配置可以让用户使用AUTH命令来认证密码，才能使用其他命令。这让redis可以使用在不受信任的网络中。为了保持向后的兼容性，可以注释该命令，因为大部分用户也不需要认证。使用requirepass的时候需要注意，因为redis太快了，每秒可以认证15w次密码，简单的密码很容易被攻破，所以最好使用一个更复杂的密码。注意只有密码没有用户名。
#requirepass admin
```

​	跟原来的配置文件修改了一点东西，关闭了严格服务模式，删除了密码验证。

​	docker启动redis脚本：

```shell
docker run -it -d --name redis -m 200m \
-p 6379:6379 --privileged=true \
--net cat --ip 10.0.0.9 \
-v /opt/data/redis/conf/:/usr/local/etc/redis \
-e TZ=Asia/Shanghai \
--restart=always \
registry.cn-hangzhou.aliyuncs.com/my-base-env/redis:6.0.10 \
redis-server /usr/local/etc/redis/redis.conf
```

​	连接一下看一下是否成功

![image-20240702211309306](assets/image-20240702211309306.png)



## 2.5 安装Minio

​	老三样了，拉镜像写配置起运行脚本。这里还要多一步，就是配置存放文件路径的权限。

​	镜像选择最新的latest版本。

![image-20240702213217884](assets/image-20240702213217884.png)

​	创建 Minio 文件存储路径

```shell
mkdir -p /opt/data/minio/data # 创建文件夹
chmod -R 777 /opt/data/minio/data # 给其设置权限，否则Minio无法使用该文件夹保存文件
```

​	写启动 Minio 脚本：其中 9000 是上传文件端口，9001 是 Minio 自带的 Web 端管理系统的端口，这里提一嘴，官网在账号与密码设置了限制，账号不得小于5为字符，密码不得小于8位字符

```shell
docker run -it -d --name minio -m 400m \
-p 9000:9000 -p 9001:9001 \
--net cat --ip 10.0.0.10 \
-v /opt/data/minio/data:/data \
-e TZ=Asia/Shanghai --privileged=true \
--env MINIO_ROOT_USER="admin" \
--env MINIO_ROOT_PASSWORD="ljcvip8888" \
--restart=always \
registry.cn-hangzhou.aliyuncs.com/my-base-env/minio
```

​	安装成功后验证一下web界面是否能打开

![image-20240702230544541](assets/image-20240702230544541.png)



## 2.6 安装RabbitMQ

拉取 RabbitMQ 镜像文件

![image-20240702230653601](assets/image-20240702230653601.png)

直接运行docker脚本

```shell
docker run -it -d --name mq \
--net cat --ip 10.0.0.11 \
-p 15672:15672 -p 5672:5672 -m 500m \
-e TZ=Asia/Shanghai --privileged=true \
--restart=always \
registry.cn-hangzhou.aliyuncs.com/my-base-env/rabbitmq:latest
```

3. 进入容器内部后，执行`rabbitmq-plugins enable rabbitmq_management`，即可进入[RabbitMQ后台系统](http://host_ip:15672/#/)

​		用户名/密码：guest/guest

![image-20240702232810283](assets/image-20240702232810283.png)

3. 执行`rabbitmq-plugins enable rabbitmq_tracing`、`rabbitmqctl trace_on`和`rabbitmqctl trace_on -p myhost`，开启消息追踪

## 2.7 安装Nacos

拉取 Nacos 镜像文件2.0.4版本

![image-20240702235846627](assets/image-20240702235846627.png)

编写docker运行脚本

```shell
docker run -it -d -p 8848:8848 --env MODE=standalone \
--net cat --ip 10.0.0.12 -e TZ=Asia/Shanghai \
--name nacos \
--restart=always \
registry.cn-hangzhou.aliyuncs.com/my-base-env/nacos-server:v2.0.4
```

登陆 Nacos [控制台](http://192.168.10.100:8848/nacos)，账密都是：nacos，进入即可查看具体状况

![image-20240703005728533](assets/image-20240703005728533.png)

## 2.8 安装Sentinel

拉取镜像文件1.8.7版本

![image-20240703005816996](assets/image-20240703005816996.png)

编写运行docker脚本

````shell
docker run -it -d --name sentinel \
-p 8719:8719 -p 8858:8858 \
--net cat --ip 10.0.0.13 \
-e TZ=Asia/Shanghai -m 400m \
--restart=always \
registry.cn-hangzhou.aliyuncs.com/my-base-env/sentinel-dashboard:1.8.7
````

打开webUI界面检查是否安装成功

登陆 Sentinel [控制台](http://host_ip:8858/#/dashboard)，账密都是：sentinel，进入即可查看具体状况

![image-20240703010459038](assets/image-20240703010459038.png)



# 3 代码实现

微服务端口预览

## 服务总览

子系统总览

| 序号 |    子系统    |   端口号   |      具体用途      |
| :--: | :----------: | :--------: | :----------------: |
|  1   |    cat-tm    | 7970和8070 | 分布式事务管理节点 |
|  2   |    cat-dr    |    8001    |     司机子系统     |
|  3   |   cat-odr    |    8002    |     订单子系统     |
|  4   |   cat-snm    |    8003    |   消息通知子系统   |
|  5   |   cat-mps    |    8004    |     地图子系统     |
|  6   |   cat-oes    |    8005    |   订单执行子系统   |
|  7   |   cat-rule   |    8006    |     规则子系统     |
|  8   |   cat-cst    |    8007    |     客户子系统     |
|  9   |   cat-vhr    |    8008    |    代金券子系统    |
|  10  |  cat-nebula  |    8009    |    大数据子系统    |
|  11  | cat-mis-api  |    8010    |     MIS子系统      |
|  12  | cat-workflow |    8011    |    工作流子系统    |
|  13  |  bff-driver  |    8101    |   司机bff子系统    |
|  14  | bff-customer |    8102    |   客户bff子系统    |
|  15  |   gateway    |    8080    |     网关子系统     |