嘿，刚好在Hybris项目里处理过好几次重复产品的清理需求，你问的两种方法（Impex脚本、业务代码修改）都完全可行，我给你详细拆解下：

这种方法适合一次性清理，不需要开发代码，直接通过Hybris的Impex工具执行就行。核心思路是先定位重复产品，再批量删除。

步骤1：先查询重复产品（用Flexible Search） #

首先你得明确“重复”的判断标准——通常是产品code（因为业务上code应该是唯一标识），也可以是EAN、SKU这类字段。用Flexible Search查询重复项：

SELECT {p.pk}, {p.code} 
FROM {Product AS p} 
GROUP BY {p.code} 
HAVING COUNT({p.pk}) > 1

执行这个查询后，你会得到所有重复产品的PK和对应的code。

步骤2：编写删除Impex脚本 #

方式A：手动导出PK后批量删除

把查询到的重复产品PK（除了你想保留的那个）列出来，用REMOVE语句删除：

REMOVE Product[batchmode=true];pk[unique=true]
;8796093054986  // 替换成实际的重复产品PK
;8796093055012

batchmode=true会提升批量删除的性能，避免逐个处理的开销。

方式B：用Groovy脚本自动清理（更智能）

如果重复项太多，手动列PK太麻烦，可以在Impex里嵌入Groovy脚本，自动按code分组，保留第一个产品、删除其余重复项：

#%groovy
// 获取Hybris核心服务
def flexibleSearchService = spring.getBean("flexibleSearchService")
def modelService = spring.getBean("modelService")

// 查询所有重复产品
def query = "SELECT {p.pk}, {p.code} FROM {Product AS p} GROUP BY {p.code} HAVING COUNT({p.pk}) > 1"
def searchResult = flexibleSearchService.search(query)
def duplicateProducts = searchResult.result

// 按code分组，保留第一个，删除其余
def productsByCode = duplicateProducts.groupBy { it.code }
productsByCode.each { code, productsList ->
    if (productsList.size() > 1) {
        // 跳过第一个产品，删除剩下的重复项
        productsList.drop(1).each { product ->
            modelService.remove(product)
        }
    }
}

// 提交修改
modelService.saveAll()

如果需要定期自动清理重复产品，或者要做更复杂的业务逻辑判断（比如结合创建时间保留最新/最早的产品），就适合写业务代码实现。

步骤1：编写清理服务类 #

创建一个服务类，注入Hybris的flexibleSearchService和modelService，实现重复产品的检测与删除逻辑：

import de.hybris.platform.core.model.product.ProductModel;
import de.hybris.platform.servicelayer.search.FlexibleSearchService;
import de.hybris.platform.servicelayer.search.SearchResult;
import de.hybris.platform.servicelayer.model.ModelService;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Service
public class ProductDuplicateCleanupService {

    private final FlexibleSearchService flexibleSearchService;
    private final ModelService modelService;

    // 构造方法注入服务
    public ProductDuplicateCleanupService(FlexibleSearchService flexibleSearchService, ModelService modelService) {
        this.flexibleSearchService = flexibleSearchService;
        this.modelService = modelService;
    }

    public void cleanDuplicateProducts() {
        // 自定义重复判断逻辑：这里按code分组，你可以改成EAN/SKU等
        String query = "SELECT {p.pk}, {p.code} FROM {Product AS p} GROUP BY {p.code} HAVING COUNT({p.pk}) > 1";
        SearchResult<ProductModel> searchResult = flexibleSearchService.search(query);
        List<ProductModel> duplicateProducts = searchResult.getResult();

        // 按code分组，保留创建时间最早的产品（或你需要的规则）
        Map<String, List<ProductModel>> productsByCode = duplicateProducts.stream()
                .collect(Collectors.groupingBy(ProductModel::getCode));

        productsByCode.forEach((code, productsList) -> {
            if (productsList.size() > 1) {
                // 按创建时间排序，保留第一个，删除其余
                productsList.sort((p1, p2) -> p1.getCreationtime().compareTo(p2.getCreationtime()));
                productsList.subList(1, productsList.size()).forEach(modelService::remove);
            }
        });

        // 提交所有删除操作
        modelService.saveAll();
    }
}

步骤2：配置定时任务（可选） #

如果要定期执行清理，可以创建一个Cron Job：

1. 在items.xml里定义Job类型：

<itemtype code="ProductDuplicateCleanupJob" extends="ServicelayerJob" autocreate="true" generate="true">
    <attributes>
        <attribute qualifier="cleanupService" type="ProductDuplicateCleanupService">
            <modifiers read="true" write="true" optional="false"/>
            <persistence type="property"/>
        </attribute>
    </attributes>
</itemtype>

2. 编写Job执行类：

import de.hybris.platform.cronjob.enums.CronJobResult;
import de.hybris.platform.cronjob.enums.CronJobStatus;
import de.hybris.platform.servicelayer.cronjob.AbstractJobPerformable;
import de.hybris.platform.servicelayer.cronjob.PerformResult;

public class ProductDuplicateCleanupJobPerformable extends AbstractJobPerformable<ProductDuplicateCleanupJobModel> {

    @Override
    public PerformResult perform(ProductDuplicateCleanupJobModel job) {
        try {
            job.getCleanupService().cleanDuplicateProducts();
            return new PerformResult(CronJobResult.SUCCESS, CronJobStatus.FINISHED);
        } catch (Exception e) {
            LOG.error("Failed to clean duplicate products", e);
            return new PerformResult(CronJobResult.FAILURE, CronJobStatus.ABORTED);
        }
    }
}

3. 最后在Backoffice里配置这个Cron Job，设置执行周期（比如每周日凌晨执行），就可以自动清理了。

重要提醒 #

• 一定要先备份数据！ 不管用哪种方法，先在测试环境验证逻辑，确认没问题再到生产环境执行，删除操作不可逆。
• 灵活调整重复判断规则：根据你的业务需求，修改Flexible Search的查询条件，比如结合多个字段（code+category）判断重复。
• 性能优化：如果产品量很大，记得用分页查询（Flexible Search加LIMIT和OFFSET），避免一次性加载太多数据导致内存溢出。
• 关联数据处理：删除产品前，确认是否需要处理关联数据（比如购物车中的产品、历史订单、库存记录），Hybris的modelService.remove()会自动处理部分关联，但特殊业务场景可能需要额外处理。

内容的提问来源于stack exchange，提问作者rosp