SpringBoot+Vue3在线家具商城架构设计与实现

1. 项目概述：在线家具商城的技术架构与核心价值

这个基于Java SpringBoot+Vue3+MyBatis的在线家具商城系统，采用了当前主流的前后端分离架构，是典型的B2C电商平台实现方案。我在实际开发中发现，家具类电商相比普通商品电商有几个显著特点：商品SKU属性复杂（尺寸、材质、颜色等组合多样）、展示需要3D效果或全景图、物流配送需要考虑大件物品的特殊性。这套技术栈的组合正好能完美应对这些需求痛点。

SpringBoot作为后端框架提供了快速构建RESTful API的能力，Vue3的前端响应式特性特别适合商品筛选交互，MyBatis的灵活SQL编写能力可以高效处理家具产品多维度查询。MySQL作为关系型数据库，既能保证事务一致性，又能通过合理的分表策略应对商品数据的存储需求。整套系统源码已经过生产环境验证，包含完整的权限管理、支付对接和物流跟踪模块。

2. 技术栈选型与架构设计

2.1 后端技术栈深度解析

SpringBoot 2.7.x版本作为基础框架，这是经过多个项目验证的稳定选择。特别配置了：

java复制spring:
  datasource:
    url: jdbc:mysql://localhost:3306/furniture_mall?useSSL=false&serverTimezone=Asia/Shanghai
    hikari:
      maximum-pool-size: 20  # 根据家具商城查询密集特性调整
  jackson:
    default-property-inclusion: non_null  # 避免null值影响前端展示

选择MyBatis而非JPA的主要考虑是家具商城的复杂查询场景。比如需要动态构建如下查询：

xml复制<select id="searchFurniture" resultType="FurnitureVO">
  SELECT * FROM product 
  <where>
    <if test="material != null">
      AND material = #{material}
    </if>
    <if test="priceRange != null">
      AND price BETWEEN #{priceRange[0]} AND #{priceRange[1]}
    </if>
    <!-- 其他动态条件 -->
  </where>
  ORDER BY 
  <choose>
    <when test="sortType == 'price_asc'">price ASC</when>
    <when test="sortType == 'sales'">sales_count DESC</when>
    <otherwise>create_time DESC</otherwise>
  </choose>
</select>

2.2 前端技术方案设计

Vue3的组合式API特别适合电商场景开发，主要优势在于：

1. Composition API让商品展示逻辑更好封装
2. Vite构建速度远超Webpack，加快开发迭代
3. Pinia状态管理处理跨组件数据流（如购物车）

典型商品卡片组件实现：

vue复制<script setup>
const props = defineProps({
  item: Object,
  show3DView: Boolean
})

const router = useRouter()
const cartStore = useCartStore()

const handleQuickView = () => {
  if(props.show3DView) {
    show3DModel(props.item.modelUrl)
  } else {
    router.push(`/detail/${props.item.id}`)
  }
}
</script>

2.3 数据库设计要点

家具商城的MySQL设计有几个特殊考虑：

1. 商品表需要支持多维度属性

sql复制CREATE TABLE `product` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `name` varchar(100) NOT NULL COMMENT '商品名称',
  `category_id` int NOT NULL COMMENT '分类ID',
  `material` enum('实木','板材','金属','玻璃','布艺') NOT NULL,
  `style` enum('现代','中式','欧式','美式','日式') NOT NULL,
  `price` decimal(10,2) NOT NULL,
  `stock` int NOT NULL DEFAULT '0',
  `weight` decimal(8,2) COMMENT '重量(kg)',
  `package_size` varchar(50) COMMENT '包装尺寸',
  `3d_model_url` varchar(255) COMMENT '3D模型地址',
  PRIMARY KEY (`id`),
  KEY `idx_category` (`category_id`),
  KEY `idx_material` (`material`),
  KEY `idx_style` (`style`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

2. 特别注意大件家具的物流信息存储设计

sql复制CREATE TABLE `logistics` (
  `id` bigint NOT NULL AUTO_INCREMENT,
  `order_id` bigint NOT NULL,
  `logistics_type` enum('普通快递','专线物流','安装服务') NOT NULL,
  `estimated_days` int COMMENT '预计天数',
  `delivery_fee` decimal(10,2) NOT NULL,
  `floor_charge` decimal(10,2) DEFAULT 0 COMMENT '上楼费',
  `assembly_charge` decimal(10,2) DEFAULT 0 COMMENT '安装费',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

3. 核心功能模块实现

3.1 商品三维展示方案

家具商城区别于普通电商的核心功能是3D展示。我们采用两种方案：

1. 轻量级方案：Three.js实现Web端3D预览

javascript复制import { GLTFLoader } from 'three/examples/jsm/loaders/GLTFLoader'

const loader = new GLTFLoader()
loader.load(
  '/models/sofa.glb',
  (gltf) => {
    scene.add(gltf.scene)
    // 添加旋转交互控制
    controls = new OrbitControls(camera, renderer.domElement)
  },
  undefined,
  (error) => {
    console.error('模型加载失败:', error)
  }
)

2. 专业方案：对接酷家乐等专业家居3D平台API

3.2 组合购买与定制功能

家具常需要成套购买，我们设计了组合销售功能：

java复制@PostMapping("/combine")
public Result<CombinationVO> createCombination(
    @RequestBody @Valid CombinationDTO dto) {
    
    // 验证组合中各商品是否存在且可组合
    List<Product> products = productService.listByIds(dto.getProductIds());
    if(products.size() != dto.getProductIds().size()) {
        throw new BusinessException("包含无效商品");
    }
    
    // 计算组合总价（可配置折扣策略）
    BigDecimal total = products.stream()
        .map(Product::getPrice)
        .reduce(BigDecimal.ZERO, BigDecimal::add);
    
    BigDecimal finalPrice = discountStrategy.applyDiscount(total);
    
    return Result.success(new CombinationVO(products, finalPrice));
}

3.3 大件物流特殊处理

在订单服务中特别处理物流逻辑：

java复制public class LogisticsService {
    
    @Transactional
    public LogisticsInfo calculateLogistics(Long orderId, String address) {
        Order order = orderRepository.findById(orderId)
            .orElseThrow(() -> new BusinessException("订单不存在"));
        
        // 根据商品总重量和体积计算基础运费
        LogisticsCalculation calculation = logisticsCalculator
            .calculate(order.getItems(), address);
        
        // 特殊处理上楼费
        if(address.contains("无电梯") && calculation.getTotalWeight() > 50) {
            calculation.setFloorFee(new BigDecimal("200"));
        }
        
        // 保存物流信息
        Logistics logistics = new Logistics();
        logistics.setOrderId(orderId);
        logistics.setDeliveryFee(calculation.getBaseFee());
        logistics.setFloorCharge(calculation.getFloorFee());
        logisticsRepository.save(logistics);
        
        return mapper.toInfo(logistics);
    }
}

4. 安全与性能优化实践

4.1 解决SQL注入问题

针对MyBatis使用中的安全风险，我们采取以下措施：

1. 严格使用#{}替代${}

xml复制<!-- 错误示范 -->
<select id="findByCondition" resultType="Product">
  SELECT * FROM product 
  ORDER BY ${sortField} ${sortOrder}
</select>

<!-- 正确做法 -->
<select id="findByCondition" resultType="Product">
  SELECT * FROM product 
  ORDER BY 
  <choose>
    <when test="sortField == 'price'">price</when>
    <when test="sortField == 'sales'">sales_count</when>
    <otherwise>create_time</otherwise>
  </choose>
  <choose>
    <when test="sortOrder == 'asc'">ASC</when>
    <otherwise>DESC</otherwise>
  </choose>
</select>

2. 添加全局过滤器防止XSS

java复制@Configuration
public class WebSecurityConfig extends WebSecurityConfigurerAdapter {
    
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .addFilterBefore(new XssFilter(), UsernamePasswordAuthenticationFilter.class)
            // 其他配置...
    }
}

public class XssFilter extends OncePerRequestFilter {
    @Override
    protected void doFilterInternal(HttpServletRequest request, 
            HttpServletResponse response, FilterChain chain) {
        chain.doFilter(new XssRequestWrapper(request), response);
    }
}

4.2 高并发场景优化

针对秒杀等场景的优化方案：

1. Redis缓存商品库存

java复制public class ProductStockService {
    
    private final String STOCK_KEY = "product:stock:%s";
    
    public boolean reduceStock(Long productId, int num) {
        String key = String.format(STOCK_KEY, productId);
        Long value = redisTemplate.opsForValue().decrement(key, num);
        if(value != null && value >= 0) {
            // 异步更新数据库
            stockUpdateQueue.add(new StockUpdateTask(productId, num));
            return true;
        } else {
            // 库存不足，回滚
            redisTemplate.opsForValue().increment(key, num);
            return false;
        }
    }
}

2. 数据库分库分表策略

yaml复制# application-sharding.yml
spring:
  shardingsphere:
    datasource:
      names: ds0,ds1
    sharding:
      tables:
        product:
          actual-data-nodes: ds$->{0..1}.product_$->{0..15}
          table-strategy:
            inline:
              sharding-column: id
              algorithm-expression: product_$->{id % 16}
          database-strategy:
            inline:
              sharding-column: category_id
              algorithm-expression: ds$->{category_id % 2}

5. 部署与运维实践

5.1 容器化部署方案

使用Docker Compose编排服务：

dockerfile复制# backend/Dockerfile
FROM openjdk:11-jre
COPY target/furniture-mall.jar /app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

yaml复制# docker-compose.yml
version: '3'
services:
  backend:
    build: ./backend
    ports:
      - "8080:8080"
    depends_on:
      - mysql
      - redis
  frontend:
    build: 
      context: ./frontend
      dockerfile: Dockerfile
    ports:
      - "80:80"
  mysql:
    image: mysql:8.0
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: furniture_mall
    volumes:
      - mysql_data:/var/lib/mysql
volumes:
  mysql_data:

5.2 监控与日志方案

1. SpringBoot Actuator健康检查配置

java复制@Configuration
public class ActuatorConfig {
    
    @Bean
    public MeterRegistryCustomizer<PrometheusMeterRegistry> metricsCommonTags() {
        return registry -> registry.config().commonTags(
            "application", "furniture-mall",
            "region", System.getenv("REGION")
        );
    }
}

2. 前端性能监控

javascript复制// main.js
import * as Sentry from '@sentry/vue'

Sentry.init({
  app,
  dsn: 'your-dsn',
  integrations: [
    new Sentry.BrowserTracing({
      routingInstrumentation: Sentry.vueRouterInstrumentation(router)
    }),
    new Sentry.Replay()
  ],
  tracesSampleRate: 0.2,
  replaysSessionSampleRate: 0.1,
  replaysOnErrorSampleRate: 1.0
})

6. 开发中的典型问题与解决方案

6.1 跨域问题深度处理

前后端分离常见跨域问题，我们的解决方案：

java复制@Configuration
public class CorsConfig implements WebMvcConfigurer {
    
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**")
            .allowedOrigins("*")
            .allowedMethods("GET", "POST", "PUT", "DELETE")
            .allowedHeaders("*")
            .exposedHeaders("Authorization")
            .allowCredentials(true)
            .maxAge(3600);
    }
    
    // 针对WebSocket的特殊配置
    @Bean
    public ServletServerContainerFactoryBean createWebSocketContainer() {
        ServletServerContainerFactoryBean container = new ServletServerContainerFactoryBean();
        container.setMaxSessionIdleTimeout(600000L);
        container.setAsyncSendTimeout(5000L);
        return container;
    }
}

6.2 文件上传优化

家具商城需要处理大量高清图片上传：

1. 前端分片上传实现

javascript复制const uploadFile = async (file) => {
  const chunkSize = 5 * 1024 * 1024 // 5MB
  const chunks = Math.ceil(file.size / chunkSize)
  const fileMd5 = await calculateMd5(file)
  
  for(let i = 0; i < chunks; i++) {
    const chunk = file.slice(i * chunkSize, (i + 1) * chunkSize)
    const formData = new FormData()
    formData.append('file', chunk)
    formData.append('chunkNumber', i)
    formData.append('totalChunks', chunks)
    formData.append('identifier', fileMd5)
    
    await axios.post('/api/upload', formData, {
      headers: { 'Content-Type': 'multipart/form-data' }
    })
  }
  
  // 通知合并
  await axios.post('/api/merge', {
    filename: file.name,
    identifier: fileMd5,
    totalChunks: chunks
  })
}

2. 后端接收处理

java复制@PostMapping("/upload")
public Result uploadChunk(
    @RequestParam("file") MultipartFile file,
    @RequestParam Integer chunkNumber,
    @RequestParam Integer totalChunks,
    @RequestParam String identifier) {
    
    String tempDir = uploadProperties.getTempPath() + identifier + "/";
    File dir = new File(tempDir);
    if(!dir.exists()) dir.mkdirs();
    
    String chunkFilename = chunkNumber + ".part";
    file.transferTo(new File(tempDir + chunkFilename));
    
    return Result.success();
}

@PostMapping("/merge")
public Result mergeChunks(
    @RequestBody MergeRequest request) {
    
    String tempDir = uploadProperties.getTempPath() + request.getIdentifier() + "/";
    File outputFile = new File(uploadProperties.getPath() + request.getFilename());
    
    try (FileOutputStream fos = new FileOutputStream(outputFile);
         FileChannel outChannel = fos.getChannel()) {
        
        for(int i = 0; i < request.getTotalChunks(); i++) {
            File chunkFile = new File(tempDir + i + ".part");
            try (FileInputStream fis = new FileInputStream(chunkFile);
                 FileChannel inChannel = fis.getChannel()) {
                outChannel.transferFrom(inChannel, outChannel.size(), inChannel.size());
            }
            chunkFile.delete();
        }
        
        new File(tempDir).delete();
        return Result.success(outputFile.getAbsolutePath());
    }
}

6.3 支付模块集成

对接多种支付方式的实现策略：

java复制public interface PaymentStrategy {
    PaymentResult pay(PaymentRequest request);
    PaymentResult query(String paymentNo);
    PaymentResult refund(RefundRequest request);
}

@Service
public class PaymentService {
    
    private final Map<PaymentType, PaymentStrategy> strategies;
    
    public PaymentService(List<PaymentStrategy> strategyList) {
        this.strategies = strategyList.stream()
            .collect(Collectors.toMap(
                PaymentStrategy::getType,
                Function.identity()
            ));
    }
    
    public PaymentResult pay(PaymentType type, PaymentRequest request) {
        PaymentStrategy strategy = strategies.get(type);
        if(strategy == null) {
            throw new BusinessException("不支持的支付方式");
        }
        return strategy.pay(request);
    }
}

// 支付宝实现示例
@Service
public class AlipayStrategy implements PaymentStrategy {
    
    @Override
    public PaymentResult pay(PaymentRequest request) {
        AlipayClient client = new DefaultAlipayClient(
            "https://openapi.alipay.com/gateway.do",
            appId,
            privateKey,
            "json",
            "UTF-8",
            alipayPublicKey,
            "RSA2");
        
        AlipayTradePagePayRequest payRequest = new AlipayTradePagePayRequest();
        payRequest.setReturnUrl(request.getReturnUrl());
        payRequest.setNotifyUrl(request.getNotifyUrl());
        
        JSONObject bizContent = new JSONObject();
        bizContent.put("out_trade_no", request.getOrderNo());
        bizContent.put("total_amount", request.getAmount());
        bizContent.put("subject", request.getSubject());
        bizContent.put("product_code", "FAST_INSTANT_TRADE_PAY");
        
        payRequest.setBizContent(bizContent.toString());
        
        try {
            String form = client.pageExecute(payRequest).getBody();
            return PaymentResult.success(form);
        } catch (AlipayApiException e) {
            throw new BusinessException("支付宝支付异常", e);
        }
    }
}

7. 项目扩展与进阶方向

7.1 微服务化改造

当系统规模扩大时，可考虑拆分为以下服务：

1. 商品服务
2. 订单服务
3. 用户服务
4. 物流服务
5. 支付服务

使用Spring Cloud Alibaba实现方案：

java复制// 商品服务Feign客户端
@FeignClient(name = "product-service", path = "/product")
public interface ProductFeignClient {
    
    @GetMapping("/{id}")
    Result<ProductDTO> getById(@PathVariable Long id);
    
    @PostMapping("/reduce-stock")
    Result<Boolean> reduceStock(@RequestBody ReduceStockDTO dto);
}

// 订单服务调用示例
@Service
@RequiredArgsConstructor
public class OrderService {
    
    private final ProductFeignClient productClient;
    
    @Transactional
    public OrderDTO createOrder(OrderCreateDTO dto) {
        // 验证商品
        Result<ProductDTO> productResult = productClient.getById(dto.getProductId());
        if(!productResult.isSuccess() || productResult.getData() == null) {
            throw new BusinessException("商品不存在");
        }
        
        // 扣减库存
        ReduceStockDTO stockDTO = new ReduceStockDTO(dto.getProductId(), dto.getQuantity());
        Result<Boolean> stockResult = productClient.reduceStock(stockDTO);
        if(!stockResult.isSuccess() || !stockResult.getData()) {
            throw new BusinessException("库存不足");
        }
        
        // 创建订单逻辑...
    }
}

7.2 多端适配方案

1. 小程序适配方案

vue复制<!-- 条件渲染不同平台组件 -->
<template>
  <div>
    <template v-if="isWeixin">
      <weixin-pay-button @click="handlePay" />
    </template>
    <template v-else-if="isAlipay">
      <alipay-button @click="handlePay" />
    </template>
    <template v-else>
      <button @click="handlePay">立即支付</button>
    </template>
  </div>
</template>

<script>
export default {
  computed: {
    isWeixin() {
      return /MicroMessenger/i.test(navigator.userAgent)
    },
    isAlipay() {
      return /AlipayClient/i.test(navigator.userAgent)
    }
  }
}
</script>

2. 响应式布局优化

scss复制.product-grid {
  display: grid;
  grid-template-columns: repeat(auto-fill, minmax(250px, 1fr));
  gap: 20px;
  
  @media (max-width: 768px) {
    grid-template-columns: repeat(auto-fill, minmax(150px, 1fr));
    gap: 10px;
  }
  
  @media (max-width: 480px) {
    grid-template-columns: 1fr;
  }
}

.product-card {
  .product-image {
    height: 0;
    padding-bottom: 100%;
    position: relative;
    
    img {
      position: absolute;
      top: 0;
      left: 0;
      width: 100%;
      height: 100%;
      object-fit: cover;
    }
  }
}

7.3 数据分析与推荐系统

基于用户行为的商品推荐实现：

java复制public class RecommendService {
    
    private final UserBehaviorRepository behaviorRepo;
    private final ProductRepository productRepo;
    
    public List<Product> recommendForUser(Long userId) {
        // 获取用户最近浏览记录
        List<UserBehavior> behaviors = behaviorRepo
            .findTop10ByUserIdAndBehaviorTypeOrderByCreateTimeDesc(
                userId, BehaviorType.BROWSE);
        
        if(behaviors.isEmpty()) {
            return recommendHotProducts();
        }
        
        // 提取商品特征向量
        Map<Long, double[]> productFeatures = loadProductFeatures();
        double[] userVector = new double[FEATURE_DIM];
        
        // 计算用户兴趣向量（加权平均）
        for(UserBehavior behavior : behaviors) {
            double[] feature = productFeatures.get(behavior.getProductId());
            if(feature != null) {
                double weight = calculateWeight(behavior);
                for(int i = 0; i < FEATURE_DIM; i++) {
                    userVector[i] += feature[i] * weight;
                }
            }
        }
        
        // 归一化
        normalizeVector(userVector);
        
        // 计算相似商品
        return productRepo.findAll().stream()
            .filter(p -> !behaviors.stream()
                .anyMatch(b -> b.getProductId().equals(p.getId())))
            .sorted(Comparator.comparingDouble(p -> 
                cosineSimilarity(userVector, productFeatures.get(p.getId()))))
            .limit(10)
            .collect(Collectors.toList());
    }
    
    private double cosineSimilarity(double[] v1, double[] v2) {
        double dotProduct = 0.0;
        double norm1 = 0.0;
        double norm2 = 0.0;
        
        for(int i = 0; i < v1.length; i++) {
            dotProduct += v1[i] * v2[i];
            norm1 += Math.pow(v1[i], 2);
            norm2 += Math.pow(v2[i], 2);
        }
        
        return dotProduct / (Math.sqrt(norm1) * Math.sqrt(norm2));
    }
}

8. 项目部署与持续集成

8.1 Jenkins流水线配置

完整的CI/CD流水线示例：

groovy复制pipeline {
    agent any
    
    environment {
        DOCKER_REGISTRY = 'registry.example.com'
        PROJECT_NAME = 'furniture-mall'
        VERSION = "${env.BUILD_NUMBER}"
    }
    
    stages {
        stage('Checkout') {
            steps {
                git branch: 'main', 
                    url: 'https://github.com/yourrepo/furniture-mall.git'
            }
        }
        
        stage('Backend Build') {
            steps {
                dir('backend') {
                    sh 'mvn clean package -DskipTests'
                }
            }
        }
        
        stage('Frontend Build') {
            steps {
                dir('frontend') {
                    sh 'npm install'
                    sh 'npm run build'
                }
            }
        }
        
        stage('Docker Build') {
            steps {
                script {
                    docker.build("${DOCKER_REGISTRY}/${PROJECT_NAME}/backend:${VERSION}", './backend')
                    docker.build("${DOCKER_REGISTRY}/${PROJECT_NAME}/frontend:${VERSION}", './frontend')
                }
            }
        }
        
        stage('Deploy to Test') {
            steps {
                sshPublisher(
                    publishers: [
                        sshPublisherDesc(
                            configName: 'test-server',
                            transfers: [
                                sshTransfer(
                                    sourceFiles: 'docker-compose.yml',
                                    removePrefix: '',
                                    remoteDirectory: PROJECT_NAME,
                                    execCommand: """
                                    cd ${PROJECT_NAME} && \
                                    docker-compose down && \
                                    docker-compose pull && \
                                    docker-compose up -d
                                    """
                                )
                            ]
                        )
                    ]
                )
            }
        }
    }
}

8.2 生产环境部署策略

采用蓝绿部署确保零停机：

bash复制#!/bin/bash

# 新版本部署
docker-compose -p furniture-mall-green up -d --build

# 等待新版本就绪
while ! curl -s http://localhost:8080/actuator/health | grep -q 'UP'; do
  sleep 5
done

# 切换流量
nginx -s reload

# 下线旧版本
docker-compose -p furniture-mall-blue down

对应的Nginx配置：

nginx复制upstream backend {
    server furniture-mall-blue:8080;
    server furniture-mall-green:8080 backup;
}

server {
    listen 80;
    
    location / {
        proxy_pass http://frontend;
    }
    
    location /api {
        proxy_pass http://backend;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header Host $host;
    }
    
    # 动态切换蓝绿部署
    location = /switch {
        proxy_pass http://127.0.0.1:8081;
    }
}

9. 项目经验与最佳实践

9.1 开发规范与协作流程

1. Git分支策略：

   • main：生产环境代码，必须通过PR合并
   • release/*：预发布分支
   • feature/*：功能开发分支
   • hotfix/*：紧急修复分支

2. 代码提交规范：

   • feat: 新功能
   • fix: bug修复
   • docs: 文档变更
   • style: 代码格式
   • refactor: 代码重构
   • test: 测试相关
   • chore: 构建或辅助工具变更

3. API设计原则：

   • RESTful风格
   • 版本控制：/api/v1/resource
   • 统一响应格式：

   json复制{
     "code": 200,
     "message": "success",
     "data": {},
     "timestamp": 1630000000000
   }
   

9.2 性能调优经验

1. 前端性能优化：

   • 图片懒加载

   vue复制<img v-lazy="product.image" alt="product name">
   

   • 路由懒加载

   javascript复制const ProductDetail = () => import('./views/ProductDetail.vue')
   

   • Webpack分包优化

   javascript复制configureWebpack: {
     optimization: {
       splitChunks: {
         chunks: 'all',
         maxSize: 244 * 1024 // 244KB
       }
     }
   }
   

2. 后端缓存策略：

   java复制@Cacheable(value = "products", key = "#id", unless = "#result == null")
   public Product getById(Long id) {
       return productMapper.selectById(id);
   }
   
   @Caching(evict = {
       @CacheEvict(value = "products", key = "#product.id"),
       @CacheEvict(value = "product_list", allEntries = true)
   })
   public void updateProduct(Product product) {
       productMapper.updateById(product);
   }
   

9.3 安全防护措施

1. 密码安全处理：

   java复制public class PasswordEncoder {
       
       private static final int ITERATIONS = 10000;
       private static final int KEY_LENGTH = 256;
       
       public static String encode(String rawPassword, String salt) {
           PBEKeySpec spec = new PBEKeySpec(
               rawPassword.toCharArray(),
               salt.getBytes(),
               ITERATIONS,
               KEY_LENGTH);
           
           try {
               SecretKeyFactory skf = SecretKeyFactory.getInstance("PBKDF2WithHmacSHA256");
               byte[] hash = skf.generateSecret(spec).getEncoded();
               return Base64.getEncoder().encodeToString(hash);
           } catch (Exception e) {
               throw new RuntimeException(e);
           } finally {
               spec.clearPassword();
           }
       }
   }
   

2. 接口防刷策略：

   java复制@Aspect
   @Component
   public class RateLimitAspect {
       
       private final Cache<String, Integer> requestCounts = Caffeine.newBuilder()
           .expireAfterWrite(1, TimeUnit.MINUTES)
           .maximumSize(10000)
           .build();
       
       @Around("@annotation(rateLimit)")
       public Object around(ProceedingJoinPoint joinPoint, RateLimit rateLimit) throws Throwable {
           String key = getRequestKey(joinPoint);
           Integer count = requestCounts.getIfPresent(key);
           
           if(count != null && count >= rateLimit.value()) {
               throw new BusinessException("请求过于频繁，请稍后再试");
           }
           
           requestCounts.put(key, count == null ? 1 : count + 1);
           return joinPoint.proceed();
       }
       
       private String getRequestKey(ProceedingJoinPoint joinPoint) {
           HttpServletRequest request = ((ServletRequestAttributes) 
               RequestContextHolder.currentRequestAttributes()).getRequest();
           return request.getRemoteAddr() + ":" + 
               joinPoint.getSignature().toShortString();
       }
   }
   

10. 项目演进与未来规划

10.1 技术债务清理计划

1. 代码重构重点：

   • 将通用组件抽离为独立模块
   • 统一异常处理机制
   • 标准化DTO转换逻辑

2. 测试覆盖率提升：

   xml复制<plugin>
     <groupId>org.jacoco</groupId>
     <artifactId>jacoco-maven-plugin</artifactId>
     <version>0.8.7</version>
     <executions>
       <execution>
         <goals>
           <goal>prepare-agent</goal>
         </goals>
       </execution>
       <execution>
         <id>report</id>
         <phase>test</phase>
         <goals>
           <goal>report</goal>
         </goals>
       </execution>
     </executions>
     <configuration>
       <excludes>
         <exclude>**/config/**</exclude>
         <exclude>**/dto/**</exclude>
       </excludes>
     </configuration>
   </plugin>
   

10.2 智能化升级方向

1. 智能客服集成：

   java复制public class ChatbotService {
       
       private final NlpService nlpService;
       private final ProductRepository productRepo;
       
       public ChatResponse handleMessage(ChatRequest request) {
           // 意图识别
           Intent intent = nlpService.detectIntent(request.getMessage());
           
           switch(intent.getType()) {
               case PRODUCT_QUERY:
                   List<Product> products = productRepo.search(intent.getKeywords());
                   return buildProductResponse(products);
               case ORDER_QUERY:
                   return buildOrderResponse(queryOrder(request.getUserId()));
               default:
                   return buildFallbackResponse();
           }
       }
   }
   

2. AR虚拟摆放功能：

   javascript复制// 使用ARKit/ARCore实现
   async function setupARView() {
     const scene = new THREE.Scene()
     const camera = new THREE.PerspectiveCamera()
     const renderer = new THREE.WebGLRenderer({ antialias: true })
     
     // 检测平面
     const session = await navigator.xr.requestSession('immersive-ar')
     const refSpace = await session.requestReferenceSpace('local')
     
     // 加载家具模型
     const loader = new GLTFLoader()
     const sofa = await loader.loadAsync('/models/sofa.glb')
     
     // 放置交互逻辑
     let placed = false
     window.addEventListener('click', () => {
       if(!placed) {
         scene.add(sofa.scene)
         placed = true
       }
     })
     
     // 渲染循环
     function render() {
       renderer.render(scene, camera)
       session.requestAnimationFrame(render)
     }
     render()
   }
   

10.3 多商户支持改造

1. 多租户数据库设计：

java复制public class TenantContext {
    
    private static final ThreadLocal<String> currentTenant = new ThreadLocal<>();
    
    public static void setTenant(String tenant) {
        currentTenant.set(tenant);
    }
    
    public static String getTenant() {
        return currentTenant.get();
    }
    
    public static void clear() {
        currentTenant.remove();
    }
}

@Configuration
public class DataSourceConfig {
    
    @Bean
    public AbstractRoutingDataSource routingDataSource(
            @Qualifier("masterDataSource") DataSource master,
            @Value("${tenants}") List<String> tenants) {
        
        Map<Object, Object> targetDataSources = new HashMap<>();
        tenants.forEach(tenant -> {
            DataSource ds = buildDataSourceForTenant(tenant);
            targetDataSources.put(tenant, ds);
        });
        
        AbstractRoutingDataSource routing = new AbstractRoutingDataSource() {
            @Override
            protected Object determineCurrentLookupKey() {
                return TenantContext.getTenant();
            }
        };
        
        routing.setDefaultTargetDataSource(master);
        routing.setTargetDataSources(targetDataSources);
        return routing;
    }
}

2. 商户管理后台功能：

vue复制<template>
  <div>
    <h2>商户管理</h2>
    <el-table :data="tenants">
      <el-table-column prop="name" label="商户名称"></el-table-column>
      <el-table-column prop="status" label="状态">
        <template #default="{row}">
          <el-tag :type="row.status === 'active' ? 'success' : 'danger'">
            {{ row.status === 'active' ? '已激活' : '已禁用' }}
          </el-tag>
        </template>
      </el-table-column>
      <el-table-column label="操作">
        <template #default="{row}">
          <el-button @click="editTenant(row)">编辑</el-button>
          <el-button 
            @click="toggleStatus(row)"
            :type="row.status === 'active' ? 'danger' : 'success'">
            {{ row.status === 'active' ? '禁用' : '激活' }}
          </el-button>
        </template>
      </el-table-column>
    </el-table>
  </div>
</template>

<script>
export default {
  data() {
    return {
      tenants: []
    }
  },
  async created() {
    const res = await this.$api.get('/admin/tenants')
    this.tenants = res.data
  },
  methods: {
    editTenant(tenant) {
      this.$router.push(`/tenant/edit/${tenant.id}`)
    },
    async toggleStatus(tenant) {
      const newStatus = tenant.status === 'active' ? 'inactive' : 'active'
      await this.$api.patch(`/admin/tenants/${tenant.id}/status`, { status: newStatus })
      tenant.status = newStatus
    }
  }
}
</script>