diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/MongoOperations.java b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/MongoOperations.java index a018faff4..fa878b31a 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/MongoOperations.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/MongoOperations.java @@ -223,6 +223,81 @@ public interface MongoOperations { */ void ensureIndex(String collectionName, IndexSpecification indexSpecification); + /** + * Map the results of an ad-hoc query on the default MongoDB collection to a single instance of an object + * of the specified type. + * + * The object is converted from the MongoDB native representation using an instance of + * {@see MongoConverter}. Unless configured otherwise, an + * instance of SimpleMongoConverter will be used. + * + * The query is specified as a {@link Query} which can be created either using the {@link BasicQuery} or the more + * feature rich {@link Query}. + * + * @param query the query class that specifies the criteria used to find a record and also an optional fields specification + * @param targetClass the parameterized type of the returned list. + * @return the converted object + */ + T findOne(Query query, Class targetClass); + + /** + * Map the results of an ad-hoc query on the default MongoDB collection to a single instance of an object + * of the specified type. + * + * The object is converted from the MongoDB native representation using an instance of + * {@see MongoConverter}. Unless configured otherwise, an + * instance of SimpleMongoConverter will be used. + * + * The query is specified as a {@link Query} which can be created either using the {@link BasicQuery} or the more + * feature rich {@link Query}. + * + * @param query the query class that specifies the criteria used to find a record and also an optional fields specification + * @param targetClass the parameterized type of the returned list. + * @param reader the MongoReader to convert from DBObject to an object. + * @return the converted object + */ + T findOne(Query query, Class targetClass, + MongoReader reader); + + /** + * Map the results of an ad-hoc query on the specified collection to a single instance of an object + * of the specified type. + * + * The object is converted from the MongoDB native representation using an instance of + * {@see MongoConverter}. Unless configured otherwise, an + * instance of SimpleMongoConverter will be used. + * + * The query is specified as a {@link Query} which can be created either using the {@link BasicQuery} or the more + * feature rich {@link Query}. + * + * @param collectionName name of the collection to retrieve the objects from + * @param query the query class that specifies the criteria used to find a record and also an optional fields specification + * @param targetClass the parameterized type of the returned list. + * @return the converted object + */ + T findOne(String collectionName, Query query, + Class targetClass); + + /** + * Map the results of an ad-hoc query on the specified collection to a single instance of an object + * of the specified type. + * + * The object is converted from the MongoDB native representation using an instance of + * {@see MongoConverter}. Unless configured otherwise, an + * instance of SimpleMongoConverter will be used. + * + * The query is specified as a {@link Query} which can be created either using the {@link BasicQuery} or the more + * feature rich {@link Query}. + * + * @param collectionName name of the collection to retrieve the objects from + * @param query the query class that specifies the criteria used to find a record and also an optional fields specification + * @param targetClass the parameterized type of the returned list. + * @param reader the MongoReader to convert from DBObject to an object. + * @return the converted object + */ + T findOne(String collectionName, Query query, + Class targetClass, MongoReader reader); + /** * Map the results of an ad-hoc query on the default MongoDB collection to a List of the specified type. * @@ -258,7 +333,7 @@ public interface MongoOperations { MongoReader reader); /** - * Map the results of an ad-hoc query on the default MongoDB collection to a List of the specified type. + * Map the results of an ad-hoc query on the specified collection to a List of the specified type. * * The object is converted from the MongoDB native representation using an instance of * {@see MongoConverter}. Unless configured otherwise, an @@ -276,7 +351,7 @@ public interface MongoOperations { Class targetClass); /** - * Map the results of an ad-hoc query on the default MongoDB collection to a List of the specified type. + * Map the results of an ad-hoc query on the specified collection to a List of the specified type. * * The object is converted from the MongoDB native representation using an instance of * {@see MongoConverter}. Unless configured otherwise, an @@ -296,7 +371,7 @@ public interface MongoOperations { /** - * Map the results of an ad-hoc query on the default MongoDB collection to a List of the specified type. + * Map the results of an ad-hoc query on the specified collection to a List of the specified type. * * The object is converted from the MongoDB native representation using an instance of * {@see MongoConverter}. Unless configured otherwise, an diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/MongoPropertyDescriptors.java b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/MongoPropertyDescriptors.java index 436b46c8b..94105721e 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/MongoPropertyDescriptors.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/MongoPropertyDescriptors.java @@ -120,7 +120,7 @@ public class MongoPropertyDescriptors implements Iterable
  • Execute the given {@link ConnectionCallback} for a + * {@link DBObject}.
  • Apply the given + * {@link DbObjectCallback} to each of the {@link DBObject}s to obtain the result.
      • + * + * @param + * @param collectionCallback the callback to retrieve the {@link DBObject} with + * @param objectCallback the {@link DbObjectCallback} to transform {@link DBObject}s into the actual domain type + * @param collectionName the collection to be queried + * @return + */ + private T execute(CollectionCallback collectionCallback, + DbObjectCallback objectCallback, String collectionName) { + + try { + T result = objectCallback.doWith(collectionCallback.doInCollection(getCollection(collectionName))); + return result; + } catch (MongoException e) { + throw potentiallyConvertRuntimeException(e); + } + } + /** * Central callback executing method to do queries against the datastore that requires reading a collection of * objects. It will take the following steps
      1. Execute the given {@link ConnectionCallback} for a @@ -428,10 +454,31 @@ public class MongoTemplate implements InitializingBean, MongoOperations { }, collectionName); } - // Find methods that take a Query to express the query. + // Find methods that take a Query to express the query and that return a single object. + + public T findOne(Query query, Class targetClass) { + return findOne(getDefaultCollectionName(), query, targetClass); + } + + public T findOne(Query query, Class targetClass, + MongoReader reader) { + return findOne(getDefaultCollectionName(), query, targetClass, reader); + } + + public T findOne(String collectionName, Query query, + Class targetClass) { + return findOne(collectionName, query, targetClass, null); + } + + public T findOne(String collectionName, Query query, + Class targetClass, MongoReader reader) { + return doFindOne(collectionName, query.getQueryObject(), query.getFieldsObject(), targetClass, reader); + } + + // Find methods that take a Query to express the query and that return a List of objects. public List find(Query query, Class targetClass) { - return find(getDefaultCollectionName(), query, targetClass); // + return find(getDefaultCollectionName(), query, targetClass); } public List find(Query query, Class targetClass, MongoReader reader) { @@ -494,7 +541,7 @@ public class MongoTemplate implements InitializingBean, MongoOperations { public void insert(String collectionName, T objectToSave, MongoWriter writer) { BasicDBObject dbDoc = new BasicDBObject(); writer.write(objectToSave, dbDoc); - ObjectId id = insertDBObject(collectionName, dbDoc); + Object id = insertDBObject(collectionName, dbDoc); populateIdIfNecessary(objectToSave, id); } @@ -558,21 +605,21 @@ public class MongoTemplate implements InitializingBean, MongoOperations { } - protected ObjectId insertDBObject(String collectionName, final DBObject dbDoc) { + protected Object insertDBObject(String collectionName, final DBObject dbDoc) { if (dbDoc.keySet().isEmpty()) { return null; } - return execute(new CollectionCallback() { - public ObjectId doInCollection(DBCollection collection) throws MongoException, DataAccessException { + return execute(new CollectionCallback() { + public Object doInCollection(DBCollection collection) throws MongoException, DataAccessException { if (writeConcern == null) { collection.insert(dbDoc); } else { collection.insert(dbDoc, writeConcern); } - return (ObjectId) dbDoc.get(ID); + return dbDoc.get(ID); } }, collectionName); } @@ -740,6 +787,27 @@ public class MongoTemplate implements InitializingBean, MongoOperations { return MongoDbUtils.getDB(mongo, databaseName, username, password == null ? null : password.toCharArray()); } + /** + * Map the results of an ad-hoc query on the default MongoDB collection to an object using the provided MongoReader + * + * The query document is specified as a standard DBObject and so is the fields specification. + * + * @param collectionName name of the collection to retrieve the objects from + * @param query the query document that specifies the criteria used to find a record + * @param fields the document that specifies the fields to be returned + * @param targetClass the parameterized type of the returned list. + * @param reader the MongoReader to convert from DBObject to an object. + * @return the List of converted objects. + */ + protected T doFindOne(String collectionName, DBObject query, DBObject fields, Class targetClass, MongoReader reader) { + MongoReader readerToUse = reader; + if (readerToUse == null) { + readerToUse = this.mongoConverter; + } + substituteMappedIdIfNecessary(query, targetClass, readerToUse); + return execute(new FindOneCallback(query, fields), new ReadDbObjectCallback(readerToUse, targetClass), + collectionName); + } /** * Map the results of an ad-hoc query on the default MongoDB collection to a List of the specified type. @@ -761,6 +829,7 @@ public class MongoTemplate implements InitializingBean, MongoOperations { * @return the List of converted objects. */ protected List doFind(String collectionName, DBObject query, DBObject fields, Class targetClass, CursorPreparer preparer) { + substituteMappedIdIfNecessary(query, targetClass, mongoConverter); return executeEach(new FindCallback(query, fields), preparer, new ReadDbObjectCallback(mongoConverter, targetClass), collectionName); } @@ -778,6 +847,7 @@ public class MongoTemplate implements InitializingBean, MongoOperations { * @return the List of converted objects. */ protected List doFind(String collectionName, DBObject query, DBObject fields, Class targetClass, MongoReader reader) { + substituteMappedIdIfNecessary(query, targetClass, reader); return executeEach(new FindCallback(query, fields), null, new ReadDbObjectCallback(reader, targetClass), collectionName); } @@ -804,7 +874,7 @@ public class MongoTemplate implements InitializingBean, MongoOperations { * @param savedObject * @param id */ - protected void populateIdIfNecessary(Object savedObject, ObjectId id) { + protected void populateIdIfNecessary(Object savedObject, Object id) { if (id == null) { return; @@ -818,11 +888,72 @@ public class MongoTemplate implements InitializingBean, MongoOperations { } if (bw.getPropertyValue(idDescriptor.getName()) == null) { - Object target = this.mongoConverter.convertObjectId(id, idDescriptor.getPropertyType()); + Object target = null; + if (id instanceof ObjectId) { + target = this.mongoConverter.convertObjectId((ObjectId)id, idDescriptor.getPropertyType()); + } + else { + target = id; + } bw.setPropertyValue(idDescriptor.getName(), target); } } + /** + * Substitutes the id key if it is found in he query. Any 'id' keys will be replaced with '_id' and the value converted + * to an ObjectId if possible. This conversion should match the way that the id fields are converted during read + * operations. + * + * @param query + * @param targetClass + * @param reader + */ + protected void substituteMappedIdIfNecessary(DBObject query, Class targetClass, MongoReader reader) { + MongoConverter converter = null; + if (reader instanceof SimpleMongoConverter) { + converter = (MongoConverter) reader; + } + else { + return; + } + String idKey = null; + if (query.containsField("id")) { + idKey = "id"; + } + if (query.containsField("_id")) { + idKey = "_id"; + } + if (idKey == null) { + // no ids in this query + return; + } + final MongoPropertyDescriptor descriptor; + try { + descriptor = new MongoPropertyDescriptor(new PropertyDescriptor(idKey, targetClass)); + } catch (IntrospectionException e) { + // no property descriptor for this key + return; + } + if (descriptor.isIdProperty() && descriptor.isOfIdType()) { + Object value = query.get(idKey); + ObjectId newValue = null; + try { + if (value instanceof String && ObjectId.isValid((String)value)) { + newValue = converter.convertObjectId(value); + } + } catch (ConversionFailedException iae) { + LOGGER.warn("Unable to convert the String " + value + " to an ObjectId"); + } + query.removeField(idKey); + if (newValue != null) { + query.put(MongoPropertyDescriptor.ID_KEY, newValue); + } + else { + query.put(MongoPropertyDescriptor.ID_KEY, value); + } + } + } + private String getRequiredDefaultCollectionName() { String name = getDefaultCollectionName(); @@ -894,6 +1025,34 @@ public class MongoTemplate implements InitializingBean, MongoOperations { } + /** + * Simple {@link CollectionCallback} that takes a query {@link DBObject} plus an optional fields specification + * {@link DBObject} and executes that against the {@link DBCollection}. + * + * @author Oliver Gierke + * @author Thomas Risberg + */ + private static class FindOneCallback implements CollectionCallback { + + private final DBObject query; + + private final DBObject fields; + + public FindOneCallback(DBObject query, DBObject fields) { + this.query = query; + this.fields = fields; + } + + public DBObject doInCollection(DBCollection collection) throws MongoException, DataAccessException { + if (fields == null) { + return collection.findOne(query); + } + else { + return collection.findOne(query, fields); + } + } + } + /** * Simple {@link CollectionCallback} that takes a query {@link DBObject} plus an optional fields specification * {@link DBObject} and executes that against the {@link DBCollection}. diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/SimpleMongoConverter.java b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/SimpleMongoConverter.java index 2fe089e5e..c8a03f7d4 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/SimpleMongoConverter.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/SimpleMongoConverter.java @@ -45,6 +45,7 @@ import org.springframework.core.convert.ConversionService; import org.springframework.core.convert.converter.Converter; import org.springframework.core.convert.support.ConversionServiceFactory; import org.springframework.core.convert.support.GenericConversionService; +import org.springframework.dao.InvalidDataAccessApiUsageException; import org.springframework.data.document.mongodb.MongoPropertyDescriptors.MongoPropertyDescriptor; import org.springframework.util.Assert; import org.springframework.util.comparator.CompoundComparator; @@ -162,7 +163,7 @@ public class SimpleMongoConverter implements MongoConverter { @SuppressWarnings("rawtypes") public void write(Object obj, DBObject dbo) { - MongoBeanWrapper beanWrapper = createWraper(obj, false); + MongoBeanWrapper beanWrapper = createWrapper(obj, false); for (MongoPropertyDescriptor descriptor : beanWrapper.getDescriptors()) { if (descriptor.isMappable()) { Object value = beanWrapper.getValue(descriptor); @@ -176,13 +177,18 @@ public class SimpleMongoConverter implements MongoConverter { if (descriptor.isEnum()) { writeValue(dbo, keyToUse, ((Enum) value).name()); } else if (descriptor.isIdProperty() && descriptor.isOfIdType()) { - + if (value instanceof String && ObjectId.isValid((String)value)) { try { writeValue(dbo, keyToUse, conversionService.convert(value, ObjectId.class)); } catch (ConversionFailedException iae) { - LOG.debug("Unable to convert the String " + value + " to an ObjectId"); + LOG.warn("Unable to convert the String " + value + " to an ObjectId"); writeValue(dbo, keyToUse, value); } + } + else { + // we can't convert this id - use as is + writeValue(dbo, keyToUse, value); + } } else { writeValue(dbo, keyToUse, value); } @@ -307,6 +313,10 @@ public class SimpleMongoConverter implements MongoConverter { * @see org.springframework.data.document.mongodb.MongoReader#read(java.lang.Class, com.mongodb.DBObject) */ public S read(Class clazz, DBObject source) { + + if (source == null) { + return null; + } Assert.notNull(clazz, "Mapped class was not specified"); S target = BeanUtils.instantiateClass(clazz); @@ -446,7 +456,7 @@ public class SimpleMongoConverter implements MongoConverter { * @param fieldAccess whether to use field access or property access * @return */ - protected MongoBeanWrapper createWraper(Object target, boolean fieldAccess) { + protected MongoBeanWrapper createWrapper(Object target, boolean fieldAccess) { return new MongoBeanWrapper(target, conversionService, fieldAccess); } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/MongoTemplateTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/MongoTemplateTests.java index ce9dd41da..b96033a6c 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/MongoTemplateTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/MongoTemplateTests.java @@ -17,6 +17,7 @@ package org.springframework.data.document.mongodb; import static org.hamcrest.Matchers.hasItem; import static org.hamcrest.Matchers.is; +import static org.hamcrest.Matchers.notNullValue; import static org.hamcrest.Matchers.endsWith; import static org.junit.Assert.assertThat; @@ -24,6 +25,7 @@ import static org.springframework.data.document.mongodb.query.Criteria.where; import java.util.List; +import org.bson.types.ObjectId; import org.junit.Before; import org.junit.Rule; import org.junit.Test; @@ -117,7 +119,6 @@ public class MongoTemplateTests { boolean unique = false; boolean dropDupes = false; for (DBObject ix : indexInfo) { - System.out.println(ix); if ("age_-1".equals(ix.get("name"))) { indexKey = ix.get("key").toString(); unique = (Boolean) ix.get("unique"); @@ -130,8 +131,82 @@ public class MongoTemplateTests { } @Test - public void simpleQuery() throws Exception { - new Query(where("name").is("Mary")).and(where("age").lt(33).gt(22)).skip(22).limit(20); - // TODO: more tests + public void testProperHandlingOfDifferentIdTypes() throws Exception { + PersonWithIdPropertyOfTypeString p1 = new PersonWithIdPropertyOfTypeString(); + p1.setFirstName("Sven_1"); + p1.setAge(22); + template.insert(p1); + assertThat(p1.getId(), notNullValue()); + PersonWithIdPropertyOfTypeString p1q = template.findOne(new Query(where("id").is(p1.getId())), PersonWithIdPropertyOfTypeString.class); + assertThat(p1q, notNullValue()); + assertThat(p1q.getId(), is(p1.getId())); + + PersonWithIdPropertyOfTypeString p2 = new PersonWithIdPropertyOfTypeString(); + p2.setFirstName("Sven_2"); + p2.setAge(22); + p2.setId("TWO"); + template.insert(p2); + assertThat(p2.getId(), notNullValue()); + PersonWithIdPropertyOfTypeString p2q = template.findOne(new Query(where("id").is(p2.getId())), PersonWithIdPropertyOfTypeString.class); + assertThat(p2q, notNullValue()); + assertThat(p2q.getId(), is(p2.getId())); + + PersonWith_idPropertyOfTypeString p3 = new PersonWith_idPropertyOfTypeString(); + p3.setFirstName("Sven_3"); + p3.setAge(22); + template.insert(p3); + assertThat(p3.get_id(), notNullValue()); + PersonWith_idPropertyOfTypeString p3q = template.findOne(new Query(where("_id").is(p3.get_id())), PersonWith_idPropertyOfTypeString.class); + assertThat(p3q, notNullValue()); + assertThat(p3q.get_id(), is(p3.get_id())); + + PersonWith_idPropertyOfTypeString p4 = new PersonWith_idPropertyOfTypeString(); + p4.setFirstName("Sven_4"); + p4.setAge(22); + p4.set_id("FOUR"); + template.insert(p4); + assertThat(p4.get_id(), notNullValue()); + PersonWith_idPropertyOfTypeString p4q = template.findOne(new Query(where("_id").is(p4.get_id())), PersonWith_idPropertyOfTypeString.class); + assertThat(p4q, notNullValue()); + assertThat(p4q.get_id(), is(p4.get_id())); + + PersonWithIdPropertyOfTypeObjectId p5 = new PersonWithIdPropertyOfTypeObjectId(); + p5.setFirstName("Sven_5"); + p5.setAge(22); + template.insert(p5); + assertThat(p5.getId(), notNullValue()); + PersonWithIdPropertyOfTypeObjectId p5q = template.findOne(new Query(where("id").is(p5.getId())), PersonWithIdPropertyOfTypeObjectId.class); + assertThat(p5q, notNullValue()); + assertThat(p5q.getId(), is(p5.getId())); + + PersonWithIdPropertyOfTypeObjectId p6 = new PersonWithIdPropertyOfTypeObjectId(); + p6.setFirstName("Sven_6"); + p6.setAge(22); + p6.setId(new ObjectId()); + template.insert(p6); + assertThat(p6.getId(), notNullValue()); + PersonWithIdPropertyOfTypeObjectId p6q = template.findOne(new Query(where("id").is(p6.getId())), PersonWithIdPropertyOfTypeObjectId.class); + assertThat(p6q, notNullValue()); + assertThat(p6q.getId(), is(p6.getId())); + + PersonWith_idPropertyOfTypeObjectId p7 = new PersonWith_idPropertyOfTypeObjectId(); + p7.setFirstName("Sven_7"); + p7.setAge(22); + template.insert(p7); + assertThat(p7.get_id(), notNullValue()); + PersonWith_idPropertyOfTypeObjectId p7q = template.findOne(new Query(where("_id").is(p7.get_id())), PersonWith_idPropertyOfTypeObjectId.class); + assertThat(p7q, notNullValue()); + assertThat(p7q.get_id(), is(p7.get_id())); + + PersonWith_idPropertyOfTypeObjectId p8 = new PersonWith_idPropertyOfTypeObjectId(); + p8.setFirstName("Sven_8"); + p8.setAge(22); + p8.set_id(new ObjectId()); + template.insert(p8); + assertThat(p8.get_id(), notNullValue()); + PersonWith_idPropertyOfTypeObjectId p8q = template.findOne(new Query(where("_id").is(p8.get_id())), PersonWith_idPropertyOfTypeObjectId.class); + assertThat(p8q, notNullValue()); + assertThat(p8q.get_id(), is(p8.get_id())); } + } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/PersonWithIdPropertyOfTypeObjectId.java b/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/PersonWithIdPropertyOfTypeObjectId.java new file mode 100644 index 000000000..90b7b85bd --- /dev/null +++ b/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/PersonWithIdPropertyOfTypeObjectId.java @@ -0,0 +1,52 @@ +/* + * Copyright 2010-2011 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.data.document.mongodb; + +import org.bson.types.ObjectId; + +public class PersonWithIdPropertyOfTypeObjectId { + + private ObjectId id; + + private String firstName; + + private int age; + + public ObjectId getId() { + return id; + } + + public void setId(ObjectId id) { + this.id = id; + } + + public String getFirstName() { + return firstName; + } + + public void setFirstName(String firstName) { + this.firstName = firstName; + } + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + +} diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/PersonWithIdPropertyOfTypeString.java b/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/PersonWithIdPropertyOfTypeString.java new file mode 100644 index 000000000..f69db5aed --- /dev/null +++ b/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/PersonWithIdPropertyOfTypeString.java @@ -0,0 +1,51 @@ +/* + * Copyright 2010-2011 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.data.document.mongodb; + + +public class PersonWithIdPropertyOfTypeString { + + private String id; + + private String firstName; + + private int age; + + public String getId() { + return id; + } + + public void setId(String id) { + this.id = id; + } + + public String getFirstName() { + return firstName; + } + + public void setFirstName(String firstName) { + this.firstName = firstName; + } + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + +} diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/PersonWith_idPropertyOfTypeObjectId.java b/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/PersonWith_idPropertyOfTypeObjectId.java new file mode 100644 index 000000000..c8d9d2db6 --- /dev/null +++ b/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/PersonWith_idPropertyOfTypeObjectId.java @@ -0,0 +1,52 @@ +/* + * Copyright 2010-2011 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.data.document.mongodb; + +import org.bson.types.ObjectId; + +public class PersonWith_idPropertyOfTypeObjectId { + + private ObjectId _id; + + private String firstName; + + private int age; + + public ObjectId get_id() { + return _id; + } + + public void set_id(ObjectId _id) { + this._id = _id; + } + + public String getFirstName() { + return firstName; + } + + public void setFirstName(String firstName) { + this.firstName = firstName; + } + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + +} diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/PersonWith_idPropertyOfTypeString.java b/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/PersonWith_idPropertyOfTypeString.java new file mode 100644 index 000000000..b5ab8c8ff --- /dev/null +++ b/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/PersonWith_idPropertyOfTypeString.java @@ -0,0 +1,51 @@ +/* + * Copyright 2010-2011 the original author or authors. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package org.springframework.data.document.mongodb; + + +public class PersonWith_idPropertyOfTypeString { + + private String _id; + + private String firstName; + + private int age; + + public String get_id() { + return _id; + } + + public void set_id(String _id) { + this._id = _id; + } + + public String getFirstName() { + return firstName; + } + + public void setFirstName(String firstName) { + this.firstName = firstName; + } + + public int getAge() { + return age; + } + + public void setAge(int age) { + this.age = age; + } + +}