How to be avoid duplicates entries at insert to MongoDB

Question

I just want to be shure when inputting new DBObject to DB that it is really unique and Collection doesn't contain key field duplicates .

Here is how it looks now:

public abstract class AbstractMongoDAO<ID, MODEL> implements GenericDAO<ID, MODEL> {

    protected Mongo client;

    protected Class<MODEL> model;

    protected DBCollection dbCollection;

    /**
     * Contains model data : unique key name and name of get method
     */
    protected KeyField keyField;

    @SuppressWarnings("unchecked")
    protected AbstractMongoDAO() {
        ParameterizedType genericSuperclass = (ParameterizedType) this.getClass().getGenericSuperclass();
        model = (Class<MODEL>) genericSuperclass.getActualTypeArguments()[1];
        getKeyField();
    }

    public void connect() throws UnknownHostException {
        client = new MongoClient(Config.getMongoHost(), Integer.parseInt(Config.getMongoPort()));
        DB clientDB = client.getDB(Config.getMongoDb());
        clientDB.authenticate(Config.getMongoDbUser(), Config.getMongoDbPass().toCharArray());
        dbCollection = clientDB.getCollection(getCollectionName(model));
    }

    public void disconnect() {
        if (client != null) {
            client.close();
        }
    }

    @Override
    public void create(MODEL model) {
        Object keyValue = get(model);
        try {
            ObjectMapper mapper = new ObjectMapper();
            String requestAsString = mapper.writerWithDefaultPrettyPrinter().writeValueAsString(model);
            // check if not presented
            BasicDBObject dbObject = new BasicDBObject((String) keyValue, requestAsString);
            dbCollection.ensureIndex(dbObject, new BasicDBObject("unique", true));
            dbCollection.insert(new BasicDBObject((String) keyValue, requestAsString));
        } catch (Throwable e) {
            throw new RuntimeException(String.format("Duplicate parameters '%s' : '%s'", keyField.id(), keyValue));
        }
    }

private Object get(MODEL model) {
    Object result = null;
    try {
        Method m = this.model.getMethod(this.keyField.get());
        result = m.invoke(model);
    } catch (Exception e) {
        throw new RuntimeException(String.format("Couldn't find method by name '%s' at class '%s'", this.keyField.get(), this.model.getName()));
    }
    return result;
}

/**
 * Extract the name of collection that is specified at '@Entity' annotation.
 *
 * @param clazz is model class object.
 * @return the name of collection that is specified.
 */
private String getCollectionName(Class<MODEL> clazz) {
    Entity entity = clazz.getAnnotation(Entity.class);
    String tableName = entity.value();
    if (tableName.equals(Mapper.IGNORED_FIELDNAME)) {
        // think about usual logger
        tableName = clazz.getName();
    }
    return tableName;
}

private void getKeyField() {
    for (Field field : this.model.getDeclaredFields()) {
        if (field.isAnnotationPresent(KeyField.class)) {
            keyField = field.getAnnotation(KeyField.class);
            break;
        }
    }
    if (keyField == null) {
        throw new RuntimeException(String.format("Couldn't find key field at class : '%s'", model.getName()));
    }
}

KeyFeld is custom annotation:

@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface KeyField {

    String id();

    String get();

    String statusProp() default "ALL";

But I'm not shure that this solution really prove this. I'm newly at Mongo.

Any suggestions?

Answer 1

A uniqueness can be maintained in MonboDb using _id field. If we will not provide the value of this field, MongoDB automatically creates a unique id for that particuler collection.

So, in your case just create a property called _id in java & assign your unique field value here. If duplicated, it will throw an exception.

Answer 2

With Spring Data MongoDB (the question was tagged with spring-data , that's why I suggest it), all you need is that:

 // Your types

 class YourType {

    BigInteger id;
    @Indexed(unique = true) String emailAddress;
    …
 }

 interface YourTypeRepository extends CrudRepository<YourType, BigInteger> { }

 // Infrastructure setup, if you use Spring as container prefer @EnableMongoRepositories

 MongoOperations operations = new MongoTemplate(new MongoClient(), "myDatabase");
 MongoRepositoryFactory factory = new MongoRepositoryFactory(operations);
 YourTypeRepository repository = factory.getRepository(YourTypeRepository.class);

 // Now use it…

 YourType first = …; // set email address
 YourType second = …; // set same email address

 repository.save(first);
 repository.save(second); // will throw an exception

The crucial part that's most related to your original question is @Indexed as this will cause the required unique index created when you create the repository.

What you get beyond that is:

• no need to manually implement any repository (deleted code does not contain bugs \\o/)
• automatic object-to-document conversion
• automatic index creation
• powerful repository abstraction to easily query data by declaring query methods

For more details, check out the reference documentation .