Exception while creating index - Spring Data MongoDB

Turns out this isn't as easy as I thought but can be done with a few extra classes.

First you will need to override the class that creates the indexes and overwrite the method that creates the indexes, trapping the exceptions that match and only logging them.

Unfortunately it is package protected so you will need to create a class in the same package as the class we're extending.

package org.springframework.data.mongodb.core.index;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.mongodb.MongoDbFactory;
import org.springframework.data.mongodb.core.mapping.MongoMappingContext;

public class ExceptionIgnoringIndexCreator extends MongoPersistentEntityIndexCreator {

    //assuming SLF4J as your logger otherwise, put your logger here
    private static final Logger LOG = LoggerFactory.getLogger(ExceptionIgnoringIndexCreator.class);

    public ExceptionIgnoringIndexCreator(MongoMappingContext mappingContext, MongoDbFactory mongoDbFactory) {
        super(mappingContext, mongoDbFactory);
    }

    @Override
    void createIndex(MongoPersistentEntityIndexResolver.IndexDefinitionHolder indexDefinition) {
        try {
            super.createIndex(indexDefinition);
        } catch (final RuntimeException exp) {
            final RuntimeException trans = translate(exp);
            if (trans != null) {
                throw trans;
            } else {
                LOG.warn("Exception while creating index", exp);
            }
        }
    }

    protected RuntimeException translate(final RuntimeException exp) {
        if (exp == null || exp.getMessage().contains("Cannot create index")) {
            return null;
        }
        return exp;
    }
}

The index creation is triggered by an event published by the MongoMappingContext using the ApplicationEventPublisherInterface. We need a class that we can lazily set another ApplicationEventPublisher as a delegate that the two methods of the interface will delegate their calls to.

public class DelegatingPublisher implements ApplicationEventPublisher {

        private ApplicationEventPublisher delegate;

        @Override
        public void publishEvent(ApplicationEvent event) {
            delegate.publishEvent(event);
        }

        @Override
        public void publishEvent(Object event) {
            delegate.publishEvent(event);
        }

        public void setDelegate(ApplicationEventPublisher delegate) {
            this.delegate = delegate;
        }

}

Normally you configure spring data mongoDB using a class that extends AbstractMongoConfig and overrides the "mongo()" method.

The component responsible for publishing the message that initializes the indexes is the one returned from "mongoMappingContext()" so you'll need to override that method and extend the default MongoMappingContext overriding the method that sets the event publisher and passing our new delegate publisher in its place.

@Configuration
@EnableMongoRepositories("com.my.company")
public class MyMongoConfig extends AbstractMongoConfiguration {
...
    @Override
    @Bean
    public MongoMappingContext mongoMappingContext() throws ClassNotFoundException {
        final DelegatingPublisher dep = new DelegatingPublisher();
        final MongoMappingContext mappingContext = new MongoMappingContext() {
            @Override
            public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
                super.setApplicationEventPublisher(dep);
            }
        };
        mappingContext.setInitialEntitySet(getInitialEntitySet());
        mappingContext.setSimpleTypeHolder(customConversions().getSimpleTypeHolder());
        mappingContext.setFieldNamingStrategy(fieldNamingStrategy());

        try {
            final MongoPersistentEntityIndexCreator indexCreator = new ExceptionIgnoringIndexCreator(mappingContext, mongoDbFactory());
            dep.setDelegate(new MongoMappingEventPublisher(indexCreator));
            return mappingContext;
        } catch (Exception exp) {
            throw new RuntimeException(exp);
        }
    }
...
}

If you use XML based configuration, you'll need one more class and the specified configuration

public class EventDelegatingMongoMappingContext extends MongoMappingContext {

    private ApplicationEventPublisher publisher;

    public EventDelegatingMongoMappingContext(ApplicationEventPublisher publisher) {
        this.publisher = publisher;    
    }

    @Override
    public void setApplicationEventPublisher(ApplicationEventPublisher applicationEventPublisher) {
        super.setApplicationEventPublisher(publisher);
    }
}

<mongo:db-factory id="mongoDbFactory"
                  host="localhost"
                  port="27017"
                  dbname="database"
                  username="mycompany"
                  password="secret"/>

<bean id="delegatingPublisher" class="com.my.company.DelegatingPublisher">
    <property name="delegate" ref="mappingEventPublisher" />
</bean>

<!-- Must be named 'mongoMappingContext' to be recognized up -->
<bean id="mongoMappingContext" class="com.my.company.EventDelegatingMongoMappingContext">
    <constructor-arg>
        <bean ref="delegatingPublisher" />
    </constructor-arg>
</bean>

<bean id="mongoIndexCreator" class="org.springframework.data.mongodb.core.index.ExceptionIgnoringIndexCreator">
    <constructor-arg>
        <bean ref="mongoMappingContext"/>
    </constructor-arg>
    <constructor-arg>
        <bean ref="mongoDbFactory"/>
    </constructor-arg>
</bean>

<bean id="mappingEventPublisher" class="org.springframework.data.mongodb.core.index.MongoMappingEventPublisher">
    <constructor-arg>
        <bean ref="mongoIndexCreator"/>
    </constructor-arg>
</bean>