第一部分：微服务架构完整大纲

1. 锁定技术栈（无兼容冲突，生产级版本）

分类	技术选型	版本	核心作用
基础框架	SpringBoot3 + JDK17	3.3.4 / 17	微服务基础开发
微服务 RPC / 注册中心	Dubbo3 + Nacos2	3.3.0 / 2.3.0	服务远程调用、服务注册发现
关系型数据库	MySQL8.0（主从复制）	8.0.39	结构化数据存储、读写分离
非关系型数据库	MongoDB7.0 + Redis7.2 + Memcached	7.0 / 7.2 /1.6	非结构化数据 / 分布式缓存 / 轻量缓存
持久层框架	MyBatis-Plus3.5.x	3.5.7	数据库操作增强
消息 / 搜索	RabbitMQ3.13 + Elasticsearch8.13	3.13 /8.13	异步解耦、全文检索、数据同步
部署 / 运维	Docker + DockerCompose + Jenkins	最新版	容器化、自动化 CICD 部署

2. 标准架构分层（自上而下）

3. 项目模块划分（Maven 多模块）

• micro-cloud-parent：父工程（统一依赖版本、Maven 管理）
• micro-cloud-common：公共模块（实体类、接口、工具类、全局配置）
• micro-cloud-provider：服务提供者（写操作：MySQL 主库、Dubbo 服务暴露）
• micro-cloud-consumer：服务消费者（读操作：MySQL 从库、Dubbo 服务调用）
• micro-cloud-infra：基础设施（Redis/Memcached、RabbitMQ、ES、MongoDB）

4. 核心解决方案（重点需求）

（1）MySQL 主从复制 + 读写分离

• 主库（master）：仅执行增删改
• 从库（slave）：仅执行查询
• 实现：dynamic-datasource 多数据源路由 + @DS 注解切换
• 主从同步：MySQL 原生复制，保证数据最终一致

（2）数据一致性保障（核心）

1. 数据库层：主从异步复制，自动同步写库数据到读库
2. 缓存层：双删策略（写前删 + 写后删），避免缓存脏数据
3. 消息层：RabbitMQ 最终一致性消息，同步数据到 ES/MongoDB
4. 业务层：无强事务，用最终一致性提升分布式性能

（3）双缓存架构

• Redis：分布式锁、热点数据、复杂数据结构
• Memcached：静态数据、轻量级 KV 缓存、高并发读

（4）消息 + 搜索兼容

• RabbitMQ：异步解耦、流量削峰、数据同步
• Elasticsearch：RabbitMQ 消费消息，实现 DB 与 ES 数据一致

（5）容器化 + CICD

• Docker：所有服务 / 中间件打包为镜像
• Docker Compose：一键启动所有中间件
• Jenkins：自动化 拉取代码→编译→构建镜像→部署

第二部分：示例

核心功能

Nacos注册 → Dubbo调用 → MySQL读写分离 → 双缓存 → 数据一致性

一、环境准备

1. JDK17、Maven3.8+
2. Docker + Docker Compose
3. IDEA（开发工具）

二、项目结构

三、核心代码实现

1. 父工程：micro-cloud-parent pom.xml

统一管理所有依赖版本，解决 SpringBoot3 兼容问题

<?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/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>com.micro</groupId>
    <artifactId>micro-cloud-parent</artifactId>
    <version>1.0.0</version>
    <packaging>pom</packaging>
    <modules>
        <module>micro-cloud-common</module>
        <module>micro-cloud-provider</module>
        <module>micro-cloud-consumer</module>
    </modules>

    <!-- 版本锁定 -->
    <properties>
        <java.version>17</java.version>
        <spring.boot.version>3.3.4</spring.boot.version>
        <dubbo.version>3.3.0</dubbo.version>
        <mybatis.plus.version>3.5.7</mybatis.plus.version>
    </properties>

    <dependencyManagement>
        <dependencies>
            <!-- SpringBoot3 -->
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-dependencies</artifactId>
                <version>${spring.boot.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
            <!-- Dubbo3 + Nacos -->
            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-spring-boot-starter</artifactId>
                <version>${dubbo.version}</version>
            </dependency>
            <dependency>
                <groupId>org.apache.dubbo</groupId>
                <artifactId>dubbo-registry-nacos</artifactId>
                <version>${dubbo.version}</version>
            </dependency>
            <!-- MyBatis-Plus + 多数据源（读写分离） -->
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>${mybatis.plus.version}</version>
            </dependency>
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
                <version>4.3.0</version>
            </dependency>
        </dependencies>
    </dependencyManagement>
</project>

2. 公共模块：micro-cloud-common

2.1 实体类（User.java）

package com.micro.common.entity;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;
import java.io.Serializable;

@Data
@TableName("t_user")
public class User implements Serializable {
    @TableId(type = IdType.AUTO)
    private Long id;
    private String username;
}

2.2 Dubbo 服务接口（UserService.java）

package com.micro.common.service;
import com.micro.common.entity.User;
public interface UserService {
    // 写接口：主库
    User saveUser(User user);
    // 读接口：从库
    User getUser(Long id);
}

3. 服务提供者：micro-cloud-provider（写服务 → MySQL 主库）

3.1 application.yml（Nacos + 主库 + Dubbo 配置）

spring:
  application:
    name: user-provider
  # 读写分离：主库（写）
  datasource:
    dynamic:
      primary: master
      datasource:
        master:
          url: jdbc:mysql://localhost:3306/micro_db?useSSL=false&allowPublicKeyRetrieval=true
          username: root
          password: root
          driver-class-name: com.mysql.cj.jdbc.Driver
  # Redis缓存
  data:
    redis:
      host: localhost
      port: 6379

# Dubbo3配置
dubbo:
  application:
    name: user-provider
  registry:
    address: nacos://localhost:8848
  protocol:
    name: dubbo
    port: 20880
  scan:
    base-packages: com.micro.provider.service.impl

3.2 服务实现（写操作 + 缓存删除 + 数据一致性）

package com.micro.provider.service.impl;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.micro.common.entity.User;
import com.micro.common.service.UserService;
import com.micro.provider.mapper.UserMapper;
import org.apache.dubbo.config.annotation.DubboService;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.transaction.annotation.Transactional;
import jakarta.annotation.Resource;

@DubboService // 暴露Dubbo服务
public class UserServiceImpl implements UserService {

    @Resource
    private UserMapper userMapper;

    // 写主库 + 事务 + 删除缓存（保证一致性）
    @DS("master")
    @Transactional(rollbackFor = Exception.class)
    @CacheEvict(value = "user", key = "#user.id") // 写操作删除缓存
    @Override
    public User saveUser(User user) {
        userMapper.insert(user);
        return user;
    }

    @Override
    public User getUser(Long id) {
        return null;
    }
}

4. 服务消费者：micro-cloud-consumer（读服务 → MySQL 从库）

4.1 application.yml（从库 + Dubbo 配置）

spring:
  application:
    name: user-consumer
  # 读写分离：从库（读）
  datasource:
    dynamic:
      primary: slave
      datasource:
        slave:
          url: jdbc:mysql://localhost:3307/micro_db?useSSL=false&allowPublicKeyRetrieval=true
          username: root
          password: root
          driver-class-name: com.mysql.cj.jdbc.Driver
  data:
    redis:
      host: localhost
      port: 6379

# Dubbo
dubbo:
  application:
    name: user-consumer
  registry:
    address: nacos://localhost:8848

4.2 服务实现（读操作 + 缓存加载）

package com.micro.consumer.service.impl;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.micro.common.entity.User;
import com.micro.common.service.UserService;
import com.micro.consumer.mapper.UserMapper;
import org.apache.dubbo.config.annotation.DubboReference;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import jakarta.annotation.Resource;

@Service
public class UserConsumerService {

    @DubboReference // 远程调用Dubbo写服务
    private UserService userService;

    @Resource
    private UserMapper userMapper;

    // 读从库 + 缓存查询
    @DS("slave")
    @Cacheable(value = "user", key = "#id")
    public User getUser(Long id) {
        return userMapper.selectById(id);
    }

    // 调用提供者写入主库
    public User saveUser(User user) {
        return userService.saveUser(user);
    }
}

四、Docker 容器化配置（一键启动所有中间件）

docker-compose.yml（Nacos+MySQL 主从 + Redis+Memcached+RabbitMQ+ES）

version: '3.8'
services:
  # 注册中心
  nacos:
    image: nacos/nacos-server:v2.3.0
    ports:
      - "8848:8848"
    environment:
      - MODE=standalone

  # MySQL主库（写）
  mysql-master:
    image: mysql:8.0
    ports:
      - "3306:3306"
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: micro_db

  # MySQL从库（读）
  mysql-slave:
    image: mysql:8.0
    ports:
      - "3307:3306"
    environment:
      MYSQL_ROOT_PASSWORD: root

  # 缓存
  redis:
    image: redis:7.2
    ports:
      - "6379:6379"
  memcached:
    image: memcached:1.6
    ports:
      - "11211:11211"

  # 消息+搜索
  rabbitmq:
    image: rabbitmq:3.13-management
    ports:
      - "5672:5672"
      - "15672:15672"
  elasticsearch:
    image: elasticsearch:8.13
    ports:
      - "9200:9200"
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=false

五、Jenkins CICD 自动化流水线（Jenkinsfile）

pipeline {
    agent any
    stages {
        stage('拉取代码') { steps { git 'https://gitee.com/your/micro-cloud.git' } }
        stage('编译打包') { steps { sh 'mvn clean package -DskipTests' } }
        stage('构建Docker镜像') { steps { sh 'docker build -t user-provider:1.0 .' } }
        stage('部署服务') { steps { sh 'docker-compose up -d user-provider' } }
    }
}

本文章仅供参考！