DATACMNS-534 - Add support to mark a persistent property as read only.

This commit introduces @ReadOnlyProperty to mark properties as not to be persisted. That trait is exposed via the newly added PersistentProperty.isWritable() which supersedes shallBePersisted(). Currently all non-transient property that are not annotated with @ReadOnlyProperty are considered writable.

Original pull request: #88.

src/main/java/org/springframework/data/annotation/ReadOnlyProperty.java

@@ -0,0 +1,33 @@
+/*
+ * Copyright 2014 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.annotation;
+
+import static java.lang.annotation.ElementType.*;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Marks a field to be {@literal read-only} for the mapping framework and therefore will not be persisted.
+ * 
+ * @author Christoph Strobl
+ * @since 1.9
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(value = { FIELD, METHOD, ANNOTATION_TYPE })
+public @interface ReadOnlyProperty {
+}

src/main/java/org/springframework/data/mapping/PersistentProperty.java

@@ -147,8 +147,21 @@ public interface PersistentProperty<P extends PersistentProperty<P>> {
 	 */
 	boolean isTransient();
 
+	/**
+	 * @return
+	 * @deprecated use {@link #isWritable()} instead, will be removed in 1.9 RC1.
+	 */
+	@Deprecated
 	boolean shallBePersisted();
 
+	/**
+	 * Returns whether the current property is writable, i.e. if the value held for it shall be written to the data store.
+	 * 
+	 * @return
+	 * @since 1.9
+	 */
+	boolean isWritable();
+
 	/**
 	 * Returns whether the property is an {@link Association}.
 	 * 

src/main/java/org/springframework/data/mapping/model/AbstractPersistentProperty.java

@@ -36,6 +36,7 @@ import org.springframework.util.ReflectionUtils;
  * 
  * @author Jon Brisbin
  * @author Oliver Gierke
+ * @author Christoph Strobl
  */
 public abstract class AbstractPersistentProperty<P extends PersistentProperty<P>> implements PersistentProperty<P> {
 
@@ -203,7 +204,17 @@ public abstract class AbstractPersistentProperty<P extends PersistentProperty<P>
 	 * (non-Javadoc)
 	 * @see org.springframework.data.mapping.PersistentProperty#shallBePersisted()
 	 */
+	@Override
 	public boolean shallBePersisted() {
+		return isWritable();
+	}
+
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mapping.PersistentProperty#isWritable()
+	 */
+	@Override
+	public boolean isWritable() {
 		return !isTransient();
 	}
 
@@ -215,6 +226,10 @@ public abstract class AbstractPersistentProperty<P extends PersistentProperty<P>
 		return field == null ? false : AnnotationUtils.getAnnotation(field, Reference.class) != null;
 	}
 
+	/*
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mapping.PersistentProperty#getAssociation()
+	 */
 	public Association<P> getAssociation() {
 		return association;
 	}

src/main/java/org/springframework/data/mapping/model/AnnotationBasedPersistentProperty.java

@@ -29,6 +29,7 @@ import org.springframework.core.annotation.AnnotationUtils;
 import org.springframework.data.annotation.AccessType;
 import org.springframework.data.annotation.AccessType.Type;
 import org.springframework.data.annotation.Id;
+import org.springframework.data.annotation.ReadOnlyProperty;
 import org.springframework.data.annotation.Reference;
 import org.springframework.data.annotation.Transient;
 import org.springframework.data.annotation.Version;
@@ -41,6 +42,7 @@ import org.springframework.util.Assert;
  * Special {@link PersistentProperty} that takes annotations at a property into account.
  * 
  * @author Oliver Gierke
+ * @author Christoph Strobl
  */
 public abstract class AnnotationBasedPersistentProperty<P extends PersistentProperty<P>> extends
 		AbstractPersistentProperty<P> {
@@ -169,6 +171,15 @@ public abstract class AnnotationBasedPersistentProperty<P extends PersistentProp
 		return !isTransient() && isAnnotationPresent(Reference.class);
 	}
 
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mapping.model.AbstractPersistentProperty#isWritable()
+	 */
+	@Override
+	public boolean isWritable() {
+		return !isTransient() && !isAnnotationPresent(ReadOnlyProperty.class);
+	}
+
 	/**
 	 * Returns the annotation found for the current {@link AnnotationBasedPersistentProperty}. Will prefer field
 	 * annotations over ones found at getters or setters.

src/test/java/org/springframework/data/mapping/model/AnnotationBasedPersistentPropertyUnitTests.java

@@ -30,6 +30,8 @@ import org.junit.Test;
 import org.springframework.data.annotation.AccessType;
 import org.springframework.data.annotation.AccessType.Type;
 import org.springframework.data.annotation.Id;
+import org.springframework.data.annotation.ReadOnlyProperty;
+import org.springframework.data.annotation.Transient;
 import org.springframework.data.mapping.context.SampleMappingContext;
 import org.springframework.data.mapping.context.SamplePersistentProperty;
 import org.springframework.test.util.ReflectionTestUtils;
@@ -38,6 +40,7 @@ import org.springframework.test.util.ReflectionTestUtils;
  * Unit tests for {@link AnnotationBasedPersistentProperty}.
  * 
  * @author Oliver Gierke
+ * @author Christoph Strobl
  */
 public class AnnotationBasedPersistentPropertyUnitTests<P extends AnnotationBasedPersistentProperty<P>> {
 
@@ -158,6 +161,38 @@ public class AnnotationBasedPersistentPropertyUnitTests<P extends AnnotationBase
 		context.getPersistentEntity(AnotherInvalidSample.class);
 	}
 
+	/**
+	 * @see DATACMNS-534
+	 */
+	@Test
+	public void treatsNoAnnotationCorrectly() {
+		assertThat(getProperty(ClassWithReadOnlyProperties.class, "noAnnotations").isWritable(), is(true));
+	}
+
+	/**
+	 * @see DATACMNS-534
+	 */
+	@Test
+	public void treatsTransientAsNotExisting() {
+		assertThat(getProperty(ClassWithReadOnlyProperties.class, "transientProperty"), nullValue());
+	}
+
+	/**
+	 * @see DATACMNS-534
+	 */
+	@Test
+	public void treatsReadOnlyAsNonWritable() {
+		assertThat(getProperty(ClassWithReadOnlyProperties.class, "readOnlyProperty").isWritable(), is(false));
+	}
+
+	/**
+	 * @see DATACMNS-534
+	 */
+	@Test
+	public void considersPropertyWithReadOnlyMetaAnnotationReadOnly() {
+		assertThat(getProperty(ClassWithReadOnlyProperties.class, "customReadOnlyProperty").isWritable(), is(false));
+	}
+
 	@SuppressWarnings("unchecked")
 	private Map<Class<? extends Annotation>, Annotation> getAnnotationCache(SamplePersistentProperty property) {
 		return (Map<Class<? extends Annotation>, Annotation>) ReflectionTestUtils.getField(property, "annotationCache");
@@ -270,4 +305,22 @@ public class AnnotationBasedPersistentPropertyUnitTests<P extends AnnotationBase
 			return lastname;
 		}
 	}
+
+	static class ClassWithReadOnlyProperties {
+
+		String noAnnotations;
+
+		@Transient String transientProperty;
+
+		@ReadOnlyProperty String readOnlyProperty;
+
+		@CustomReadOnly String customReadOnlyProperty;
+	}
+
+	@ReadOnlyProperty
+	@Retention(RetentionPolicy.RUNTIME)
+	@Target(FIELD)
+	static @interface CustomReadOnly {
+
+	}
 }