Java多商户新零售系统源码：全渠道融合的智能商业解决方案

新零售数字化转型的核心引擎

在数字经济时代，多商户新零售系统成为传统零售业转型升级的关键技术支撑。基于Java的多商户新零售外卖超市系统源码，通过小程序、APP、公众号和H5的全渠道覆盖，为商户提供了一站式的数字化解决方案。该系统集商品管理、订单处理、配送调度、营销推广于一体，助力企业实现线上线下深度融合，提升运营效率和用户体验。

系统架构：稳定可靠的技术基石

该多商户新零售系统采用成熟的SpringBoot+MybatisPlus+MySQL后端技术栈，结合Uniapp前端框架和Vue+ElementUI管理后台，构建了高可用、易扩展的分布式架构。

// 多商户系统主配置类
@SpringBootApplication
@MapperScan("com.multimerchant.retail.mapper")
@EnableCaching
@EnableAsync
public class MultiMerchantRetailApplication {
    public static void main(String[] args) {
        SpringApplication.run(MultiMerchantRetailApplication.class, args);
    }
    
    @Bean
    @ConfigurationProperties(prefix = "spring.datasource")
    public DataSource dataSource() {
        return DataSourceBuilder.create().build();
    }
    
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        template.setConnectionFactory(factory);
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new GenericJackson2JsonRedisSerializer());
        return template;
    }
}

核心功能模块深度解析

1. 多商户入驻与权限管理体系

系统支持多级商户管理，每个商户拥有独立的后台管理权限，实现数据隔离和个性化配置。

// 商户服务实现类
@Service
@Transactional
public class MerchantServiceImpl extends ServiceImpl<MerchantMapper, Merchant> 
    implements MerchantService {
    
    @Autowired
    private MerchantAuthService authService;
    
    @Autowired
    private MerchantConfigService configService;
    
    /**
     * 商户入驻申请
     */
    @Override
    public MerchantRegisterResult registerMerchant(MerchantRegisterDTO registerDTO) {
        // 验证商户信息
        validateMerchantInfo(registerDTO);
        
        // 创建商户基础信息
        Merchant merchant = new Merchant();
        BeanUtils.copyProperties(registerDTO, merchant);
        merchant.setStatus(MerchantStatus.PENDING);
        merchant.setCreateTime(new Date());
        baseMapper.insert(merchant);
        
        // 创建商户管理员账号
        authService.createMerchantAdmin(merchant.getId(), registerDTO.getAdminInfo());
        
        // 初始化商户配置
        configService.initMerchantConfig(merchant.getId());
        
        return new MerchantRegisterResult(merchant.getId(), "入驻申请提交成功，等待审核");
    }
    
    /**
     * 审核商户入驻
     */
    @Override
    public boolean auditMerchant(Long merchantId, AuditStatus status, String remark) {
        Merchant merchant = baseMapper.selectById(merchantId);
        if (merchant == null) {
            throw new BusinessException("商户不存在");
        }
        
        merchant.setStatus(status);
        merchant.setAuditTime(new Date());
        merchant.setAuditRemark(remark);
        baseMapper.updateById(merchant);
        
        // 发送审核结果通知
        notifyMerchantAuditResult(merchant, status);
        
        return true;
    }
}

2. 智能商品管理与分类系统

支持多维度商品分类、库存管理、价格策略和商品推荐，满足复杂零售场景需求。

// 商品服务实现
@Service
public class ProductServiceImpl extends ServiceImpl<ProductMapper, Product> 
    implements ProductService {
    
    @Autowired
    private ProductSkuService skuService;
    
    @Autowired
    private ProductCategoryService categoryService;
    
    /**
     * 添加商品（支持多规格）
     */
    @Override
    @Transactional
    public Product addProduct(ProductDTO productDTO) {
        // 验证分类信息
        ProductCategory category = categoryService.getById(productDTO.getCategoryId());
        if (category == null) {
            throw new BusinessException("商品分类不存在");
        }
        
        // 保存商品基本信息
        Product product = new Product();
        BeanUtils.copyProperties(productDTO, product);
        product.setStatus(ProductStatus.ON_SALE);
        product.setCreateTime(new Date());
        product.setUpdateTime(new Date());
        baseMapper.insert(product);
        
        // 保存商品规格信息
        if (productDTO.getSkus() != null && !productDTO.getSkus().isEmpty()) {
            List<ProductSku> skus = productDTO.getSkus().stream()
                .map(skuDTO -> {
                    ProductSku sku = new ProductSku();
                    BeanUtils.copyProperties(skuDTO, sku);
                    sku.setProductId(product.getId());
                    sku.setMerchantId(product.getMerchantId());
                    return sku;
                })
                .collect(Collectors.toList());
            
            skuService.saveBatch(skus);
        }
        
        // 更新商品库存
        updateProductStock(product.getId());
        
        return product;
    }
    
    /**
     * 商品搜索（支持多条件筛选）
     */
    @Override
    public Page<ProductVO> searchProducts(ProductQuery query, Page<Product> page) {
        return baseMapper.selectProductPage(page, query);
    }
}

3. 智能订单处理与履约系统

集成多种订单类型（立即配送、预约、到店自提），实现自动化订单分配和状态跟踪。

// 订单服务核心实现
@Service
public class OrderServiceImpl extends ServiceImpl<OrderMapper, Order> 
    implements OrderService {
    
    @Autowired
    private OrderItemService orderItemService;
    
    @Autowired
    private DeliveryService deliveryService;
    
    @Autowired
    private InventoryService inventoryService;
    
    /**
     * 创建订单
     */
    @Override
    @Transactional
    public Order createOrder(OrderCreateDTO orderDTO) {
        // 验证商品库存
        checkInventory(orderDTO.getItems());
        
        // 创建订单主信息
        Order order = new Order();
        order.setOrderNo(generateOrderNo());
        order.setMerchantId(orderDTO.getMerchantId());
        order.setUserId(orderDTO.getUserId());
        order.setTotalAmount(calculateTotalAmount(orderDTO.getItems()));
        order.setStatus(OrderStatus.WAITING_PAYMENT);
        order.setCreateTime(new Date());
        baseMapper.insert(order);
        
        // 保存订单商品项
        List<OrderItem> orderItems = orderDTO.getItems().stream()
            .map(item -> {
                OrderItem orderItem = new OrderItem();
                BeanUtils.copyProperties(item, orderItem);
                orderItem.setOrderId(order.getId());
                return orderItem;
            })
            .collect(Collectors.toList());
        
        orderItemService.saveBatch(orderItems);
        
        // 扣减库存
        inventoryService.deductInventory(orderItems);
        
        return order;
    }
    
    /**
     * 订单支付成功处理
     */
    @Override
    @Transactional
    public boolean processPaymentSuccess(Long orderId, String paymentNo) {
        Order order = baseMapper.selectById(orderId);
        if (order == null) {
            throw new BusinessException("订单不存在");
        }
        
        // 更新订单状态
        order.setStatus(OrderStatus.WAITING_MERCHANT_CONFIRM);
        order.setPaymentTime(new Date());
        order.setPaymentNo(paymentNo);
        baseMapper.updateById(order);
        
        // 通知商户接单
        notifyMerchantNewOrder(order);
        
        // 如果支持自动接单，直接分配骑手
        if (autoAcceptOrderEnabled(order.getMerchantId())) {
            acceptOrder(orderId);
        }
        
        return true;
    }
    
    /**
     * 商户接单
     */
    @Override
    public boolean acceptOrder(Long orderId) {
        Order order = baseMapper.selectById(orderId);
        order.setStatus(OrderStatus.PREPARING);
        order.setAcceptTime(new Date());
        baseMapper.updateById(order);
        
        // 分配骑手进行配送
        if (order.getDeliveryType() == DeliveryType.EXPRESS) {
            deliveryService.assignRider(order);
        }
        
        return true;
    }
}

4. 实时库存管理与预警系统

采用分布式锁保证库存数据一致性，实现库存预警和自动补货提醒。

// 库存服务实现
@Service
public class InventoryServiceImpl extends ServiceImpl<InventoryMapper, Inventory> 
    implements InventoryService {
    
    @Autowired
    private RedissonClient redissonClient;
    
    /**
     * 扣减库存（分布式锁保证原子性）
     */
    @Override
    public boolean deductInventory(List<OrderItem> orderItems) {
        // 按商品ID分组，逐个处理
        Map<Long, List<OrderItem>> itemsByProduct = orderItems.stream()
            .collect(Collectors.groupingBy(OrderItem::getProductId));
        
        for (Map.Entry<Long, List<OrderItem>> entry : itemsByProduct.entrySet()) {
            Long productId = entry.getKey();
            int totalQuantity = entry.getValue().stream()
                .mapToInt(OrderItem::getQuantity)
                .sum();
            
            // 使用分布式锁
            RLock lock = redissonClient.getLock("inventory_lock:" + productId);
            try {
                lock.lock();
                
                Inventory inventory = baseMapper.selectById(productId);
                if (inventory == null) {
                    throw new BusinessException("商品库存不存在");
                }
                
                if (inventory.getAvailableStock() < totalQuantity) {
                    throw new BusinessException("商品库存不足");
                }
                
                // 扣减可用库存
                inventory.setAvailableStock(inventory.getAvailableStock() - totalQuantity);
                inventory.setLockedStock(inventory.getLockedStock() + totalQuantity);
                baseMapper.updateById(inventory);
                
            } finally {
                lock.unlock();
            }
        }
        
        return true;
    }
    
    /**
     * 库存预警检查
     */
    @Scheduled(cron = "0 0 6 * * ?") // 每天6点执行
    public void checkInventoryWarning() {
        List<Inventory> lowStockInventories = baseMapper.selectLowStockInventory();
        
        for (Inventory inventory : lowStockInventories) {
            // 发送库存预警通知
            sendInventoryWarning(inventory);
        }
    }
}

5. 智能营销与会员管理系统

集成优惠券、满减、会员折扣等多种营销工具，提升用户粘性和复购率。

// 营销服务实现
@Service
public class PromotionServiceImpl implements PromotionService {
    
    @Autowired
    private CouponService couponService;
    
    @Autowired
    private MemberService memberService;
    
    /**
     * 计算订单优惠
     */
    @Override
    public OrderPrice calculateOrderPrice(OrderPrice price, Long userId, Long couponId) {
        // 会员折扣
        MemberLevel memberLevel = memberService.getUserMemberLevel(userId);
        if (memberLevel != null && memberLevel.getDiscount() < 1.0) {
            double discountAmount = price.getProductAmount() * (1 - memberLevel.getDiscount());
            price.setMemberDiscount(discountAmount);
            price.setDiscountAmount(price.getDiscountAmount() + discountAmount);
        }
        
        // 优惠券折扣
        if (couponId != null) {
            CouponDiscount couponDiscount = couponService.applyCoupon(price, couponId, userId);
            price.setCouponDiscount(couponDiscount.getDiscountAmount());
            price.setDiscountAmount(price.getDiscountAmount() + couponDiscount.getDiscountAmount());
        }
        
        // 满减活动
        FullReductionDiscount fullReduction = calculateFullReduction(price.getProductAmount());
        if (fullReduction != null) {
            price.setFullReductionDiscount(fullReduction.getDiscountAmount());
            price.setDiscountAmount(price.getDiscountAmount() + fullReduction.getDiscountAmount());
        }
        
        // 最终价格
        price.setFinalAmount(price.getTotalAmount() - price.getDiscountAmount());
        
        return price;
    }
}

技术优势与创新亮点

1. 多租户数据隔离架构

采用先进的多租户设计，确保不同商户数据完全隔离，同时保持系统高性能。

// 多租户数据过滤器
@Component
public class TenantFilter implements Filter {
    
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
        throws IOException, ServletException {
        
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        String tenantId = httpRequest.getHeader("X-Tenant-ID");
        
        if (StringUtils.isNotBlank(tenantId)) {
            try {
                // 设置当前线程的租户上下文
                TenantContext.setCurrentTenant(tenantId);
                chain.doFilter(request, response);
            } finally {
                // 清除租户上下文
                TenantContext.clear();
            }
        } else {
            chain.doFilter(request, response);
        }
    }
}

// MybatisPlus多租户配置
@Configuration
public class MybatisPlusConfig {
    
    @Bean
    public MybatisPlusInterceptor mybatisPlusInterceptor() {
        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
        
        // 多租户插件
        TenantLineInnerInterceptor tenantInterceptor = new TenantLineInnerInterceptor();
        tenantInterceptor.setTenantLineHandler(new TenantLineHandler() {
            @Override
            public Expression getTenantId() {
                return new StringValue(TenantContext.getCurrentTenant());
            }
            
            @Override
            public String getTenantIdColumn() {
                return "merchant_id";
            }
            
            @Override
            public boolean ignoreTable(String tableName) {
                // 系统表不进行租户过滤
                return tableName.startsWith("sys_");
            }
        });
        
        interceptor.addInnerInterceptor(tenantInterceptor);
        return interceptor;
    }
}

2. 高性能商品搜索方案

基于Elasticsearch实现商品全文检索，支持多字段、多条件复杂查询。

// 商品搜索服务
@Service
public class ProductSearchService {
    
    @Autowired
    private ElasticsearchRestTemplate elasticsearchTemplate;
    
    /**
     * 商品搜索建议
     */
    public List<String> suggestProducts(String keyword, Long merchantId) {
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        
        queryBuilder.withQuery(QueryBuilders.boolQuery()
            .must(QueryBuilders.matchQuery("name", keyword))
            .filter(QueryBuilders.termQuery("merchantId", merchantId))
            .filter(QueryBuilders.termQuery("status", ProductStatus.ON_SALE.getValue())));
        
        queryBuilder.withPageable(PageRequest.of(0, 10));
        
        SearchHits<ProductES> searchHits = elasticsearchTemplate.search(
            queryBuilder.build(), ProductES.class);
        
        return searchHits.getSearchHits().stream()
            .map(hit -> hit.getContent().getName())
            .collect(Collectors.toList());
    }
    
    /**
     * 复杂商品搜索
     */
    public Page<ProductVO> advancedSearch(ProductSearchDTO searchDTO, Pageable pageable) {
        NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
        
        BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
        
        // 关键词搜索
        if (StringUtils.isNotBlank(searchDTO.getKeyword())) {
            boolQuery.must(QueryBuilders.multiMatchQuery(searchDTO.getKeyword(), 
                "name", "description", "tags"));
        }
        
        // 分类过滤
        if (searchDTO.getCategoryId() != null) {
            boolQuery.filter(QueryBuilders.termQuery("categoryId", searchDTO.getCategoryId()));
        }
        
        // 价格区间
        if (searchDTO.getMinPrice() != null || searchDTO.getMaxPrice() != null) {
            RangeQueryBuilder priceRange = QueryBuilders.rangeQuery("price");
            if (searchDTO.getMinPrice() != null) {
                priceRange.gte(searchDTO.getMinPrice());
            }
            if (searchDTO.getMaxPrice() != null) {
                priceRange.lte(searchDTO.getMaxPrice());
            }
            boolQuery.filter(priceRange);
        }
        
        queryBuilder.withQuery(boolQuery);
        queryBuilder.withPageable(pageable);
        
        // 排序
        if (StringUtils.isNotBlank(searchDTO.getSortBy())) {
            queryBuilder.withSort(SortBuilders.fieldSort(searchDTO.getSortBy())
                .order(SortOrder.fromString(searchDTO.getSortOrder())));
        }
        
        SearchHits<ProductES> searchHits = elasticsearchTemplate.search(
            queryBuilder.build(), ProductES.class);
        
        return convertToPage(searchHits, pageable);
    }
}

新零售时代的智能化解决方案

Java多商户新零售系统通过先进的技术架构和丰富的功能模块，为零售企业提供了完整的数字化转型方案。系统支持多商户管理、智能商品运营、全渠道订单处理和精准营销推广，具备高可用、易扩展、安全可靠的特点。

该系统的技术优势体现在多个层面：基于SpringBoot的微服务架构确保了系统稳定性；MybatisPlus优化了数据访问效率；多租户设计实现了数据隔离；Elasticsearch提供了高效的搜索能力。这些技术特性使系统能够支撑高并发访问，处理复杂的业务逻辑。

对于零售企业而言，这一系统提供了线上线下融合的技术基础，帮助实现库存同步、会员互通、营销统一的全渠道经营。对于平台运营商，系统提供了完善的商户管理工具，支持快速扩展业务规模。

随着新零售技术的不断发展，这一基于Java的解决方案将持续演进，集成更多人工智能、大数据和物联网技术，为零售行业创新提供持续的技术动力，助力企业在数字化竞争中保持领先地位。