Spring Data MongoDB中基于复合索引更新文档的异常排查

这个问题我之前也碰到过，核心矛盾就是Spring Data MongoDB默认的save()逻辑和你用复合索引做主键的需求不匹配——默认情况下save()靠EntityInformation.isNew()判断是插入还是更新，逻辑通常是检查_id是否有值，但你的主键是复合索引，这就导致本该执行更新的时候，系统误判为新实体执行插入，触发复合索引的唯一性约束抛出异常。

下面给你几个可行的解决方案，按推荐程度排序：

方案1：使用MongoTemplate的upsert操作（最直接） #

绕过MongoRepository.save()的默认逻辑，直接用MongoTemplate的原生upsert功能——它会根据你指定的查询条件自动判断：如果存在匹配文档就更新，不存在就插入，完美契合你的需求。

举个例子，假设你的实体类是User，复合索引字段是username和email：

// 实体类定义复合索引
@Document(collection = "users")
@CompoundIndex(def = "{'username': 1, 'email': 1}", unique = true)
public class User {
    private String username;
    private String email;
    private String nickname;
    // 其他字段、getter/setter省略
}

然后用MongoTemplate执行upsert：

@Autowired
private MongoTemplate mongoTemplate;

public User upsertUser(User user) {
    // 构造复合索引匹配的查询条件
    Query query = new Query(Criteria.where("username").is(user.getUsername())
                                    .and("email").is(user.getEmail()));
    // 构造要更新的字段，支持插入时才设置特定字段
    Update update = new Update()
        .set("nickname", user.getNickname())
        .setOnInsert("createTime", new Date()); // 仅插入时生效的字段

    // 执行upsert并返回更新后的实体
    return mongoTemplate.findAndModify(query, update, 
        new FindAndModifyOptions().upsert(true).returnNew(true), 
        User.class);
}

这个方法完全贴合MongoDB原生逻辑，不需要修改Spring Data的默认配置，是最推荐的方案。

方案2：自定义EntityInformation，重写isNew()逻辑 #

如果你想继续使用MongoRepository.save()方法，可以自定义EntityInformation，让它根据你的复合索引字段来判断是否为新实体。

步骤如下：

1. 自定义EntityInformation实现类：

public class CustomUserEntityInformation extends MappingMongoEntityInformation<User, String> {

    private final MongoTemplate mongoTemplate;

    public CustomUserEntityInformation(MongoPersistentEntity<User> entity, MongoTemplate mongoTemplate) {
        super(entity);
        this.mongoTemplate = mongoTemplate;
    }

    @Override
    public boolean isNew(User user) {
        // 自定义判断逻辑：复合索引字段都非空时，查询数据库是否存在
        if (user.getUsername() == null || user.getEmail() == null) {
            return true;
        }
        Query query = new Query(Criteria.where("username").is(user.getUsername())
                                        .and("email").is(user.getEmail()));
        return mongoTemplate.count(query, User.class) == 0;
    }

    // 重写getId方法，返回复合索引的组合值作为逻辑主键
    @Override
    public String getId(User user) {
        return user.getUsername() + "_" + user.getEmail();
    }
}

2. 自定义MongoRepositoryFactoryBean替换默认逻辑：

public class CustomMongoRepositoryFactoryBean<T extends Repository<S, ID>, S, ID> 
    extends MongoRepositoryFactoryBean<T, S, ID> {

    private MongoTemplate mongoTemplate;

    public CustomMongoRepositoryFactoryBean(Class<? extends T> repositoryInterface) {
        super(repositoryInterface);
    }

    @Autowired
    @Override
    public void setMongoOperations(MongoOperations mongoOperations) {
        super.setMongoOperations(mongoOperations);
        this.mongoTemplate = (MongoTemplate) mongoOperations;
    }

    @Override
    protected RepositoryFactorySupport createRepositoryFactory(MongoOperations operations) {
        return new MongoRepositoryFactory(operations) {
            @Override
            protected <S, ID> EntityInformation<S, ID> getEntityInformation(Class<S> domainClass) {
                if (domainClass == User.class) {
                    MongoPersistentEntity<S> entity = getMongoConverter()
                        .getMappingContext().getRequiredPersistentEntity(domainClass);
                    return (EntityInformation<S, ID>) new CustomUserEntityInformation(
                        (MongoPersistentEntity<User>) entity, mongoTemplate
                    );
                }
                return super.getEntityInformation(domainClass);
            }
        };
    }
}

3. 在启动类指定自定义的RepositoryFactoryBean：

@EnableMongoRepositories(basePackages = "com.yourpackage.repository",
    repositoryFactoryBeanClass = CustomMongoRepositoryFactoryBean.class)
@SpringBootApplication
public class YourApplication {
    public static void main(String[] args) {
        SpringApplication.run(YourApplication.class, args);
    }
}

这个方案能让你继续用MongoRepository.save()，但配置稍复杂，适合不想改动太多业务代码的场景。

方案3：自定义Repository方法，手动判断插入/更新 #

你也可以在Repository接口中自定义方法，手动实现存在性判断：

public interface UserRepository extends MongoRepository<User, String> {

    @Query("{'username': ?0, 'email': ?1}")
    User findByUsernameAndEmail(String username, String email);

    default User saveWithCompoundKey(User user) {
        User existing = findByUsernameAndEmail(user.getUsername(), user.getEmail());
        if (existing != null) {
            // 更新已有实体的字段
            existing.setNickname(user.getNickname());
            // 其他字段更新逻辑
            return save(existing);
        } else {
            return save(user);
        }
    }
}

这个方法简单直观，但要注意并发问题——如果多个线程同时操作同一个复合索引的实体，可能会出现重复插入的情况，建议配合MongoDB事务或upsert逻辑优化。

总结 #

• 优先选方案1（MongoTemplate upsert）：简单直接，贴合需求，避免Spring Data默认逻辑的限制；
• 想保留MongoRepository.save()用方案2：配置稍繁琐，但能复用原有Repository接口；
• 临时快速解决用方案3：注意并发场景的风险。

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