基于 Spring Boot 3.x 的企业级系统架构设计与实践

场景：某电商系统，初期单体架构
问题：
- 代码耦合严重，牵一发而动全身
- 新人上手成本高，培养周期 3 个月
- 扩展困难，每次新功能都要改动大量代码

后果：
- 开发效率低下，一周只能上线 1-2 个功能
- bug 频发，线上事故不断
- 团队士气低落，人员流动大

解决：重构为模块化架构
效果：
- 开发效率提升 300%
- bug 率下降 80%
- 新人 1 周即可上手

高内聚：相关功能聚集在同一模块
  - 用户管理都在 system 模块
  - 定时任务都在 quartz 模块
  - 代码生成都在 generator 模块

低耦合：模块间通过接口通信
  - Controller → Service → Mapper
  - 依赖抽象接口，不依赖实现类
  - 使用 Maven 管理模块依赖

易扩展：符合开闭原则
  - 新增功能不修改现有代码
  - 通过扩展类和接口实现
  - 支持插件化开发

<!-- 核心技术栈 -->
<properties>
    <java.version>17</java.version>
    <spring-boot.version>3.5.8</spring-boot.version>
    <mybatis.version>3.0.5</mybatis.version>
    <druid.version>1.2.27</druid.version>
    <redis.version>7.x</redis.version>
</properties>

<dependencies>
    <!-- Spring Boot 核心 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>

    <!-- Spring Security 6 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>

    <!-- MyBatis 持久层 -->
    <dependency>
        <groupId>org.mybatis.spring.boot</groupId>
        <artifactId>mybatis-spring-boot-starter</artifactId>
    </dependency>

    <!-- Druid 连接池 -->
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid-spring-boot-starter</artifactId>
    </dependency>

    <!-- Redis缓存 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>

    <!-- JWT 认证 -->
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-api</artifactId>
        <version>0.12.0</version>
    </dependency>
</dependencies>

// package.json
{
  "dependencies": {
    "vue": "2.6.12",
    "element-ui": "2.15.1",
    "vuex": "3.6.0",
    "vue-router": "3.4.9",
    "axios": "0.21.1",
    "echarts": "5.0.2"
  }
}

<!-- feiyu-admin (主启动模块) -->
<dependencies>
    <dependency>
        <groupId>com.ant.cluster</groupId>
        <artifactId>feiyu-framework</artifactId>
    </dependency>
    <dependency>
        <groupId>com.ant.cluster</groupId>
        <artifactId>feiyu-system</artifactId>
    </dependency>
    <dependency>
        <groupId>com.ant.cluster</groupId>
        <artifactId>feiyu-quartz</artifactId>
    </dependency>
    <dependency>
        <groupId>com.ant.cluster</groupId>
        <artifactId>feiyu-generator</artifactId>
    </dependency>
</dependencies>

<!-- feiyu-framework (框架层) -->
<dependencies>
    <dependency>
        <groupId>com.ant.cluster</groupId>
        <artifactId>feiyu-common</artifactId>
    </dependency>
    <!-- Spring Security, AOP, 切面等 -->
</dependencies>

<!-- feiyu-system (业务层) -->
<dependencies>
    <dependency>
        <groupId>com.ant.cluster</groupId>
        <artifactId>feiyu-common</artifactId>
    </dependency>
    <!-- 用户、角色、权限等业务逻辑 -->
</dependencies>

<!-- feiyu-common (公共模块) -->
<dependencies>
    <!-- 工具类、常量、异常、注解等 -->
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-lang3</artifactId>
    </dependency>
    <dependency>
        <groupId>cn.hutool</groupId>
        <artifactId>hutool-all</artifactId>
    </dependency>
</dependencies>

com.ant.cluster.common/
├── annotation/          # 自定义注解
│   ├── DataScope.java  # 数据权限注解
│   ├── DataSource.java # 多数据源注解
│   ├── NoToken.java    # 免 Token 注解
│   └── RateLimiter.java# 限流注解
├── config/             # 配置类
├── constant/           # 常量定义
├── core/               # 核心类
│   ├── controller/     # 基础 Controller
│   ├── domain/         # 基础实体
│   ├── page/           # 分页封装
│   └── redis/          # Redis 封装
├── enums/              # 枚举类
├── exception/          # 异常定义
├── utils/              # 工具类
│   ├── RedisUtil.java
│   ├── StringUtils.java
│   └── DateUtils.java
└── xss/                # XSS 防护

com.ant.cluster.framework/
├── aspect/             # AOP 切面
│   ├── LogAspect.java      # 日志切面
│   ├── DataScopeAspect.java# 数据权限切面
│   └── RateLimiterAspect.java# 限流切面
├── config/             # 框架配置
│   ├── CorsConfig.java     # CORS 配置
│   └── ResourcesConfig.java# 资源配置
├── interceptor/        # 拦截器
├── manager/            # 管理器
└── security/           # Security 配置
    ├── filter/         # 过滤器
    └── handle/         # 处理器

com.ant.cluster.system/
├── domain/             # 业务实体
│   ├── SysUser.java       # 用户实体
│   ├── SysRole.java       # 角色实体
│   └── SysDept.java       # 部门实体
├── mapper/             # 数据访问层
│   ├── SysUserMapper.java
│   └── SysRoleMapper.java
├── service/            # 业务逻辑层
│   ├── ISysUserService.java
│   └── impl/SysUserServiceImpl.java
└── web/controller/     # 控制器层
    ├── SysUserController.java
    └── SysRoleController.java

/**
 * 基础 Mapper 接口
 */
public interface BaseMapper<T> extends Mapper<T> {

    /**
     * 根据 ID 查询
     */
    T selectById(Long id);

    /**
     * 查询列表
     */
    List<T> selectList(T entity);

    /**
     * 分页查询
     */
    TableDataInfo selectPage(T entity, PageParams page);

    /**
     * 插入
     */
    int insert(T entity);

    /**
     * 更新
     */
    int update(T entity);

    /**
     * 删除
     */
    int deleteByIds(Long[] ids);
}

/**
 * 基础 Service 接口
 */
public interface BaseService<T> {

    /**
     * 根据 ID 查询
     */
    T getById(Long id);

    /**
     * 查询列表
     */
    List<T> getList(T entity);

    /**
     * 分页查询
     */
    TableDataInfo getPage(T entity, PageParams page);

    /**
     * 新增
     */
    int add(T entity);

    /**
     * 修改
     */
    int edit(T entity);

    /**
     * 删除
     */
    int remove(Long[] ids);
}

/**
 * 基础 Service 实现
 */
@Slf4j
public abstract class BaseServiceImpl<M extends BaseMapper<T>, T> 
    implements BaseService<T> {

    @Autowired
    protected M mapper;

    @Override
    public T getById(Long id) {
        return mapper.selectById(id);
    }

    @Override
    public List<T> getList(T entity) {
        return mapper.selectList(entity);
    }

    @Override
    public TableDataInfo getPage(T entity, PageParams page) {
        PageHelper.startPage(page.getPageNum(), page.getPageSize());
        List<T> list = mapper.selectList(entity);
        return new TableDataInfo(list);
    }

    @Override
    public int add(T entity) {
        entity.setCreateTime(LocalDateTime.now());
        return mapper.insert(entity);
    }

    @Override
    public int edit(T entity) {
        entity.setUpdateTime(LocalDateTime.now());
        return mapper.updateById(entity);
    }

    @Override
    public int remove(Long[] ids) {
        return mapper.deleteByIds(ids);
    }
}

// 定义 Mapper
public interface SysUserMapper extends BaseMapper<SysUser> {
}

// 定义 Service 接口
public interface ISysUserService extends BaseService<SysUser> {
}

// 实现 Service
@Service
public class SysUserServiceImpl 
    extends BaseServiceImpl<SysUserMapper, SysUser> 
    implements ISysUserService {

    // 可以添加自定义方法
    @Override
    public SysUser getByUserName(String userName) {
        return mapper.selectByUserName(userName);
    }
}

/**
 * 统一返回结果
 */
@Data
public class R<T> {

    /**
     * 状态码 (200=成功)
     */
    private Integer code;

    /**
     * 提示信息
     */
    private String msg;

    /**
     * 返回数据
     */
    private T data;

    /**
     * 成功返回
     */
    public static <T> R<T> success() {
        R<T> r = new R<>();
        r.setCode(HttpStatus.SUCCESS.getCode());
        r.setMsg("操作成功");
        return r;
    }

    public static <T> R<T> success(T data) {
        R<T> r = success();
        r.setData(data);
        return r;
    }

    /**
     * 失败返回
     */
    public static <T> R<T> fail(String msg) {
        R<T> r = new R<>();
        r.setCode(HttpStatus.ERROR.getCode());
        r.setMsg(msg);
        return r;
    }

    public static <T> R<T> fail(Integer code, String msg) {
        R<T> r = new R<>();
        r.setCode(code);
        r.setMsg(msg);
        return r;
    }
}

@RestController
@RequestMapping("/system/user")
public class SysUserController {

    @Autowired
    private ISysUserService userService;

    @GetMapping("/list")
    public R<TableDataInfo> list(SysUser user) {
        startPage();
        List<SysUser> list = userService.getList(user);
        return R.success(getDataTable(list));
    }

    @PostMapping
    public R<Void> add(@RequestBody SysUser user) {
        return toAjax(userService.add(user));
    }

    @PutMapping
    public R<Void> edit(@RequestBody SysUser user) {
        return toAjax(userService.edit(user));
    }

    @DeleteMapping("/{userIds}")
    public R<Void> remove(@PathVariable Long[] userIds) {
        return toAjax(userService.remove(userIds));
    }

    /**
     * 转换为 Ajax 返回
     */
    private R<Void> toAjax(int result) {
        return result > 0 ? R.success() : R.fail();
    }
}

/**
 * Redis 工具类封装
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class RedisUtil {

    private final RedisTemplate<String, Object> redisTemplate;

    /**
     * 设置缓存
     */
    public void set(String key, Object value) {
        redisTemplate.opsForValue().set(key, value);
    }

    /**
     * 设置缓存 (带过期时间)
     */
    public void set(String key, Object value, long timeout, TimeUnit unit) {
        redisTemplate.opsForValue().set(key, value, timeout, unit);
    }

    /**
     * 获取缓存
     */
    public Object get(String key) {
        return redisTemplate.opsForValue().get(key);
    }

    /**
     * 获取缓存 (指定类型)
     */
    @SuppressWarnings("unchecked")
    public <T> T get(String key, Class<T> clazz) {
        return (T) redisTemplate.opsForValue().get(key);
    }

    /**
     * 删除缓存
     */
    public boolean delete(String key) {
        return Boolean.TRUE.equals(redisTemplate.delete(key));
    }

    /**
     * 判断是否存在
     */
    public boolean hasKey(String key) {
        return Boolean.TRUE.equals(redisTemplate.hasKey(key));
    }

    /**
     * 自增
     */
    public Long increment(String key) {
        return redisTemplate.opsForValue().increment(key);
    }

    /**
     * 自减
     */
    public Long decrement(String key) {
        return redisTemplate.opsForValue().decrement(key);
    }
}

@Service
public class UserService {

    @Autowired
    private RedisUtil redisUtil;

    public SysUser getUserById(Long userId) {
        String cacheKey = "user:" + userId;

        // 先从缓存获取
        if (redisUtil.hasKey(cacheKey)) {
            return redisUtil.get(cacheKey, SysUser.class);
        }

        // 缓存未命中，查询数据库
        SysUser user = userMapper.selectById(userId);

        // 写入缓存 (30 分钟过期)
        if (user != null) {
            redisUtil.set(cacheKey, user, 30, TimeUnit.MINUTES);
        }

        return user;
    }

    public void updateUser(SysUser user) {
        // 更新数据库
        userMapper.updateById(user);

        // 删除缓存
        String cacheKey = "user:" + user.getUserId();
        redisUtil.delete(cacheKey);
    }
}

Controller 层 (Web 层)
  ↓ 职责：接收请求，参数校验，调用 Service
  ↓ 特点：无业务逻辑，只做转发

Service 层 (业务层)
  ↓ 职责：业务逻辑处理，事务控制
  ↓ 特点：核心业务，可复用

Mapper 层 (持久层)
  ↓ 职责：数据库 CRUD
  ↓ 特点：专注数据访问

// 命名约定
SysUser          // 实体类：大驼峰
sysUser          // 变量名：小驼峰
sys_user         // 表名：下划线
user_id          // 字段名：下划线
selectUserList   // 方法名：动词 + 名词

// 包结构约定
controller/      // 控制器
service/         // 业务接口
service/impl/    // 业务实现
mapper/          // 数据访问
domain/          // 实体类
dto/             // 数据传输对象
vo/              // 视图对象

// 定义策略接口
public interface PaymentStrategy {
    void pay(Order order);
}

// 多种支付实现
@Component("alipay")
public class AlipayStrategy implements PaymentStrategy {
    public void pay(Order order) {
        // 支付宝支付逻辑
    }
}

@Component("wechat")
public class WechatPayStrategy implements PaymentStrategy {
    public void pay(Order order) {
        // 微信支付逻辑
    }
}

// 上下文类
@Component
public class PaymentContext {

    @Autowired
    private Map<String, PaymentStrategy> strategyMap;

    public void processPayment(Order order, String type) {
        PaymentStrategy strategy = strategyMap.get(type);
        if (strategy == null) {
            throw new IllegalArgumentException("不支持的支付方式");
        }
        strategy.pay(order);
    }
}

// 新增支付方式只需实现接口
@Component("unionpay")
public class UnionPayStrategy implements PaymentStrategy {
    public void pay(Order order) {
        // 银联支付逻辑
    }
}

// 无需修改现有代码

当前：模块化单体 (feiyu-system)
  ↓ 当业务复杂度达到临界点
  ↓ 部分模块独立部署

阶段一：服务化改造
  - 用户服务独立
  - 订单服务独立
  - 支付服务独立

阶段二：微服务架构
  - 完整的服务治理
  - 服务注册发现
  - 链路追踪监控

阶段三：云原生架构
  - 容器化部署
  - 自动弹性伸缩
  - Serverless 化

## 能力提升建议

### 技术深度
- ✅ 精通至少一门编程语言
- ✅ 深入理解常用框架原理
- ✅ 掌握系统设计方法论

### 技术广度
- ✅ 了解前沿技术趋势
- ✅ 熟悉不同架构风格
- ✅ 跨领域知识储备

### 软技能
- ✅ 沟通协调能力
- ✅ 决策和权衡能力
- ✅ 团队建设能力
- ✅ 业务理解能力

### 实践经验
- ✅ 主导过大型项目架构
- ✅ 处理过高并发场景
- ✅ 解决过复杂技术问题
- ✅ 持续学习和总结