SpringBoot+Vue医疗电商系统架构与实现

1. 医疗用品销售网站项目概述

作为一名有10年全栈开发经验的工程师，我最近完成了一个基于SpringBoot+Vue的医疗用品销售网站项目。这个项目不仅包含了完整的电商功能模块，还针对医疗行业的特殊需求做了定制化开发。从技术架构到业务逻辑实现，整个项目采用了我多年积累的最佳实践方案。

医疗电商平台相比普通电商有着更高的合规性要求和更复杂的业务流程。在开发过程中，我特别注重了以下几个关键点：

• 严格的权限控制和数据安全机制
• 符合医疗行业规范的订单处理流程
• 完善的药品信息管理系统
• 响应式设计适配多终端访问

这个项目采用了前后端分离架构，后端使用SpringBoot+MyBatisPlus，前端使用Vue.js+ElementUI，数据库选用MySQL 8.0。整套系统经过严格测试，性能稳定，完全满足毕业设计或商业项目的要求。

2. 系统架构设计

2.1 技术栈选型解析

选择合适的技术栈是项目成功的基础。经过多方比较，我最终确定了以下技术组合：

后端技术栈：

• Spring Boot 2.7：简化配置，内置Tomcat，快速构建RESTful API
• MyBatis-Plus 3.5：增强的ORM框架，减少90%的SQL编写
• Shiro 1.10：完善的认证授权框架，保障系统安全
• Redis 6.2：缓存热点数据，提升系统响应速度
• RabbitMQ 3.9：异步处理高延迟操作如邮件发送

前端技术栈：

• Vue 3.2：响应式前端框架，组件化开发
• Element Plus 2.2：丰富的UI组件库
• Axios 1.2：处理HTTP请求
• Vue Router 4.1：前端路由管理
• Pinia 2.0：状态管理库

数据库：

• MySQL 8.0：关系型数据库，存储业务数据
• MongoDB 5.0：存储非结构化数据如用户行为日志

这个技术组合的优势在于：

1. 成熟稳定：所有技术都有大量生产环境验证
2. 社区支持：遇到问题可以快速找到解决方案
3. 性能优异：能够支撑高并发访问
4. 易于扩展：各组件松耦合，方便功能扩展

2.2 系统架构设计

系统采用经典的三层架构，但针对电商特点做了优化：

code复制┌───────────────────────────────────────┐
│               客户端层                │
│  ┌─────────┐  ┌─────────┐  ┌───────┐ │
│  │   Web   │  │  Mobile │  │ Admin │ │
│  └─────────┘  └─────────┘  └───────┘ │
└───────────────────┬───────────────────┘
                    │ HTTP/HTTPS
┌───────────────────▼───────────────────┐
│               应用服务层               │
│  ┌─────────┐  ┌─────────┐  ┌───────┐ │
│  │  API网关 │  │ 业务服务 │  │ 消息队列│ │
│  └─────────┘  └─────────┘  └───────┘ │
└───────────────────┬───────────────────┘
                    │ JDBC/NoSQL
┌───────────────────▼───────────────────┐
│               数据存储层               │
│  ┌─────────┐  ┌─────────┐  ┌───────┐ │
│  │  MySQL  │  │ MongoDB │  │ Redis │ │
│  └─────────┘  └─────────┘  └───────┘ │
└───────────────────────────────────────┘

关键设计决策：

1. API网关：统一处理认证、限流、日志等横切关注点
2. 服务拆分：按业务域划分微服务（用户服务、商品服务、订单服务等）
3. 缓存策略：多级缓存（Redis→本地缓存→数据库）
4. 异步处理：耗时操作通过消息队列异步化

2.3 数据库设计

数据库设计遵循第三范式，但针对查询性能做了适当反范式化。主要表结构如下：

用户相关表：

sql复制CREATE TABLE `user` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `username` varchar(50) NOT NULL COMMENT '登录名',
  `password` varchar(100) NOT NULL COMMENT '密码',
  `real_name` varchar(50) DEFAULT NULL COMMENT '真实姓名',
  `phone` varchar(20) DEFAULT NULL COMMENT '手机号',
  `email` varchar(100) DEFAULT NULL COMMENT '邮箱',
  `avatar` varchar(255) DEFAULT NULL COMMENT '头像',
  `status` tinyint DEFAULT '1' COMMENT '状态 0-禁用 1-正常',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`),
  UNIQUE KEY `idx_username` (`username`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户表';

药品信息表：

sql复制CREATE TABLE `medicine` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `name` varchar(100) NOT NULL COMMENT '药品名称',
  `code` varchar(50) NOT NULL COMMENT '药品编码',
  `spec` varchar(100) DEFAULT NULL COMMENT '规格',
  `manufacturer` varchar(200) DEFAULT NULL COMMENT '生产厂家',
  `category_id` bigint DEFAULT NULL COMMENT '分类ID',
  `price` decimal(10,2) DEFAULT NULL COMMENT '售价',
  `cost` decimal(10,2) DEFAULT NULL COMMENT '成本价',
  `stock` int DEFAULT '0' COMMENT '库存',
  `image` varchar(255) DEFAULT NULL COMMENT '主图',
  `description` text COMMENT '描述',
  `status` tinyint DEFAULT '1' COMMENT '状态 0-下架 1-上架',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`),
  UNIQUE KEY `idx_code` (`code`),
  KEY `idx_category` (`category_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='药品信息表';

订单表：

sql复制CREATE TABLE `order` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `order_no` varchar(50) NOT NULL COMMENT '订单编号',
  `user_id` bigint NOT NULL COMMENT '用户ID',
  `total_amount` decimal(10,2) NOT NULL COMMENT '订单总金额',
  `payment_amount` decimal(10,2) NOT NULL COMMENT '实付金额',
  `shipping_fee` decimal(10,2) DEFAULT '0.00' COMMENT '运费',
  `payment_type` tinyint DEFAULT NULL COMMENT '支付方式 1-支付宝 2-微信',
  `status` tinyint DEFAULT '0' COMMENT '状态 0-待支付 1-已支付 2-已发货 3-已完成 4-已取消',
  `shipping_address` varchar(500) DEFAULT NULL COMMENT '收货地址',
  `receiver_name` varchar(50) DEFAULT NULL COMMENT '收货人',
  `receiver_phone` varchar(20) DEFAULT NULL COMMENT '收货电话',
  `note` varchar(500) DEFAULT NULL COMMENT '订单备注',
  `create_time` datetime DEFAULT CURRENT_TIMESTAMP,
  `update_time` datetime DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
  PRIMARY KEY (`id`),
  UNIQUE KEY `idx_order_no` (`order_no`),
  KEY `idx_user_id` (`user_id`),
  KEY `idx_create_time` (`create_time`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='订单表';

数据库设计时特别注意了以下几点：

1. 所有表都包含create_time和update_time字段
2. 金额字段使用decimal类型避免精度问题
3. 建立合适的索引提升查询性能
4. 字段注释完整，便于维护

3. 核心功能实现

3.1 用户认证与授权

医疗电商系统对安全性要求极高，我采用Shiro+JWT实现认证授权：

java复制// JWT工具类
public class JwtUtil {
    private static final String SECRET_KEY = "medical-secret-key";
    private static final long EXPIRATION = 86400000; // 24小时
    
    public static String generateToken(User user) {
        Map<String, Object> claims = new HashMap<>();
        claims.put("userId", user.getId());
        claims.put("username", user.getUsername());
        claims.put("roles", user.getRoles());
        
        return Jwts.builder()
                .setClaims(claims)
                .setSubject(user.getUsername())
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + EXPIRATION))
                .signWith(SignatureAlgorithm.HS256, SECRET_KEY)
                .compact();
    }
    
    public static Claims parseToken(String token) {
        return Jwts.parser()
                .setSigningKey(SECRET_KEY)
                .parseClaimsJws(token)
                .getBody();
    }
}

// Shiro配置
@Configuration
public class ShiroConfig {
    @Bean
    public ShiroFilterFactoryBean shiroFilter(SecurityManager securityManager) {
        ShiroFilterFactoryBean factoryBean = new ShiroFilterFactoryBean();
        factoryBean.setSecurityManager(securityManager);
        
        Map<String, String> filterMap = new LinkedHashMap<>();
        filterMap.put("/api/login", "anon");
        filterMap.put("/api/register", "anon");
        filterMap.put("/api/**", "jwt");
        
        factoryBean.setFilterChainDefinitionMap(filterMap);
        return factoryBean;
    }
    
    @Bean
    public DefaultWebSecurityManager securityManager(Realm realm) {
        DefaultWebSecurityManager securityManager = new DefaultWebSecurityManager();
        securityManager.setRealm(realm);
        return securityManager;
    }
    
    @Bean
    public Realm realm() {
        return new JwtRealm();
    }
}

安全设计要点：

1. 密码存储使用BCrypt加密
2. JWT设置合理过期时间
3. 接口按角色进行权限控制
4. 敏感操作记录日志
5. 防XSS、CSRF攻击

3.2 药品管理模块

药品管理是核心功能，包含以下子模块：

• 药品分类管理
• 药品信息CRUD
• 库存管理
• 价格管理

药品添加接口实现：

java复制@RestController
@RequestMapping("/api/medicine")
public class MedicineController {
    
    @Autowired
    private MedicineService medicineService;
    
    @PostMapping
    @RequiresRoles("admin")
    public Result addMedicine(@Valid @RequestBody MedicineDTO dto) {
        // 检查药品编码是否已存在
        if (medicineService.existsByCode(dto.getCode())) {
            return Result.fail("药品编码已存在");
        }
        
        Medicine medicine = new Medicine();
        BeanUtils.copyProperties(dto, medicine);
        
        // 处理药品图片上传
        if (dto.getImageFile() != null) {
            String imageUrl = fileService.upload(dto.getImageFile());
            medicine.setImage(imageUrl);
        }
        
        medicineService.save(medicine);
        return Result.success();
    }
    
    @GetMapping("/{id}")
    public Result getMedicine(@PathVariable Long id) {
        Medicine medicine = medicineService.getById(id);
        if (medicine == null) {
            return Result.fail("药品不存在");
        }
        return Result.success(medicine);
    }
}

药品搜索实现：

java复制@Service
public class MedicineServiceImpl extends ServiceImpl<MedicineMapper, Medicine> implements MedicineService {
    
    @Override
    public Page<MedicineVO> search(MedicineQuery query) {
        return lambdaQuery()
            .like(StringUtils.isNotBlank(query.getKeyword()), Medicine::getName, query.getKeyword())
            .or()
            .like(StringUtils.isNotBlank(query.getKeyword()), Medicine::getCode, query.getKeyword())
            .eq(query.getCategoryId() != null, Medicine::getCategoryId, query.getCategoryId())
            .eq(Medicine::getStatus, 1)
            .page(query.toPage())
            .convert(this::toVO);
    }
    
    private MedicineVO toVO(Medicine medicine) {
        MedicineVO vo = new MedicineVO();
        BeanUtils.copyProperties(medicine, vo);
        // 补充分类名称等额外信息
        if (medicine.getCategoryId() != null) {
            Category category = categoryService.getById(medicine.getCategoryId());
            if (category != null) {
                vo.setCategoryName(category.getName());
            }
        }
        return vo;
    }
}

3.3 购物车与订单系统

购物车和订单是电商系统的核心，我设计了以下流程：

1. 购物车设计：

java复制@Service
public class CartServiceImpl implements CartService {
    
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
    
    private String getCartKey(Long userId) {
        return "cart:" + userId;
    }
    
    @Override
    public void addItem(Long userId, CartItem item) {
        String key = getCartKey(userId);
        // 检查药品是否存在且库存充足
        Medicine medicine = medicineService.getById(item.getMedicineId());
        if (medicine == null || medicine.getStatus() != 1) {
            throw new BusinessException("药品不存在或已下架");
        }
        if (medicine.getStock() < item.getQuantity()) {
            throw new BusinessException("库存不足");
        }
        
        // 使用Hash存储购物车商品
        redisTemplate.opsForHash().put(key, 
            item.getMedicineId().toString(), 
            item);
        
        // 设置购物车过期时间
        redisTemplate.expire(key, 30, TimeUnit.DAYS);
    }
    
    @Override
    public List<CartItem> getCart(Long userId) {
        String key = getCartKey(userId);
        List<Object> values = redisTemplate.opsForHash().values(key);
        return values.stream()
            .map(obj -> (CartItem) obj)
            .collect(Collectors.toList());
    }
}

2. 下单流程：

java复制@Service
@Transactional
public class OrderServiceImpl implements OrderService {
    
    @Override
    public Order createOrder(Long userId, OrderCreateDTO dto) {
        // 1. 验证用户
        User user = userService.getById(userId);
        if (user == null) {
            throw new BusinessException("用户不存在");
        }
        
        // 2. 获取购物车商品
        List<CartItem> cartItems = cartService.getCart(userId);
        if (cartItems.isEmpty()) {
            throw new BusinessException("购物车为空");
        }
        
        // 3. 检查库存并计算总价
        List<Long> medicineIds = cartItems.stream()
            .map(CartItem::getMedicineId)
            .collect(Collectors.toList());
        
        Map<Long, Medicine> medicineMap = medicineService.listByIds(medicineIds)
            .stream()
            .collect(Collectors.toMap(Medicine::getId, m -> m));
        
        BigDecimal totalAmount = BigDecimal.ZERO;
        List<OrderItem> orderItems = new ArrayList<>();
        
        for (CartItem item : cartItems) {
            Medicine medicine = medicineMap.get(item.getMedicineId());
            if (medicine == null || medicine.getStatus() != 1) {
                throw new BusinessException("药品" + medicine.getName() + "已下架");
            }
            if (medicine.getStock() < item.getQuantity()) {
                throw new BusinessException("药品" + medicine.getName() + "库存不足");
            }
            
            BigDecimal itemTotal = medicine.getPrice().multiply(
                new BigDecimal(item.getQuantity()));
            
            OrderItem orderItem = new OrderItem();
            orderItem.setMedicineId(medicine.getId());
            orderItem.setMedicineName(medicine.getName());
            orderItem.setMedicineImage(medicine.getImage());
            orderItem.setPrice(medicine.getPrice());
            orderItem.setQuantity(item.getQuantity());
            orderItem.setTotalAmount(itemTotal);
            
            orderItems.add(orderItem);
            totalAmount = totalAmount.add(itemTotal);
        }
        
        // 4. 创建订单
        Order order = new Order();
        order.setOrderNo(generateOrderNo());
        order.setUserId(userId);
        order.setTotalAmount(totalAmount);
        order.setPaymentAmount(totalAmount); // 暂不考虑优惠
        order.setStatus(OrderStatus.UNPAID.getCode());
        order.setShippingAddress(dto.getAddress());
        order.setReceiverName(dto.getReceiverName());
        order.setReceiverPhone(dto.getReceiverPhone());
        order.setNote(dto.getNote());
        
        orderMapper.insert(order);
        
        // 5. 保存订单明细
        orderItems.forEach(item -> {
            item.setOrderId(order.getId());
            orderItemMapper.insert(item);
            
            // 扣减库存
            medicineMapper.deductStock(
                item.getMedicineId(), 
                item.getQuantity());
        });
        
        // 6. 清空购物车
        cartService.clearCart(userId);
        
        // 7. 发送订单创建通知
        rabbitTemplate.convertAndSend(
            "order.event.exchange",
            "order.created",
            order.getId());
            
        return order;
    }
    
    private String generateOrderNo() {
        // 时间戳+随机数生成订单号
        return "M" + System.currentTimeMillis() + 
            ThreadLocalRandom.current().nextInt(1000, 9999);
    }
}

4. 系统部署与优化

4.1 部署架构

生产环境推荐使用Docker Compose部署，架构如下：

yaml复制version: '3.8'

services:
  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: ${DB_ROOT_PASSWORD}
      MYSQL_DATABASE: medical
      MYSQL_USER: medical
      MYSQL_PASSWORD: ${DB_PASSWORD}
    volumes:
      - mysql_data:/var/lib/mysql
    ports:
      - "3306:3306"
    networks:
      - medical-net

  redis:
    image: redis:6.2
    ports:
      - "6379:6379"
    volumes:
      - redis_data:/data
    networks:
      - medical-net

  rabbitmq:
    image: rabbitmq:3.9-management
    ports:
      - "5672:5672"
      - "15672:15672"
    volumes:
      - rabbitmq_data:/var/lib/rabbitmq
    networks:
      - medical-net

  backend:
    build: ./backend
    ports:
      - "8080:8080"
    environment:
      - SPRING_PROFILES_ACTIVE=prod
      - DB_URL=jdbc:mysql://mysql:3306/medical
      - DB_USERNAME=medical
      - DB_PASSWORD=${DB_PASSWORD}
      - REDIS_HOST=redis
      - RABBITMQ_HOST=rabbitmq
    depends_on:
      - mysql
      - redis
      - rabbitmq
    networks:
      - medical-net

  frontend:
    build: ./frontend
    ports:
      - "80:80"
    networks:
      - medical-net

volumes:
  mysql_data:
  redis_data:
  rabbitmq_data:

networks:
  medical-net:
    driver: bridge

4.2 性能优化措施

1. 数据库优化：

   • 合理设计索引，避免全表扫描
   • 使用连接池控制连接数
   • 读写分离，查询走从库
   • 大表分库分表

2. 缓存策略：

   • 多级缓存：Redis → Caffeine → 数据库
   • 热点数据预加载
   • 缓存雪崩/穿透/击穿防护

3. 接口优化：

   • 合并细粒度接口
   • 数据懒加载
   • 分页查询优化

4. 前端优化：

   • 组件懒加载
   • 路由懒加载
   • 图片懒加载+CDN
   • 接口请求合并

4.3 监控与日志

完善的监控是系统稳定的保障：

1. Spring Boot Actuator：暴露健康检查端点
2. Prometheus + Grafana：系统指标监控
3. ELK：日志收集与分析
4. Sentry：错误追踪

yaml复制# application-monitor.yml
management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,prometheus
  metrics:
    export:
      prometheus:
        enabled: true
    tags:
      application: medical-system

5. 项目总结与经验分享

在开发这个医疗用品销售网站的过程中，我积累了一些宝贵的经验：

1. 医疗行业特殊性：

   • 药品信息必须准确无误
   • 处方药需要特殊流程验证
   • 价格变动需要记录审计日志
   • 订单取消需要特殊处理流程

2. 技术选型心得：

   • Spring Boot + Vue的组合非常适合中小型电商项目
   • MyBatis-Plus极大提高了开发效率
   • 合理使用Redis可以显著提升系统性能

3. 开发建议：

   • 前期做好领域模型设计
   • 接口设计考虑扩展性
   • 编写完整的单元测试
   • 文档与代码同步更新

4. 常见问题解决：

   • 分布式事务使用最终一致性方案
   • 库存超卖问题使用乐观锁
   • 高并发下单使用队列削峰

这个项目从技术架构到业务实现都经过精心设计，代码规范清晰，文档完整，非常适合作为毕业设计参考，也可以作为商业项目的基础进行二次开发。