JAVA-984: Allow non-void setters in object mapping.

Alexandre Dutra · olim7t · commit f87f0573d2e1 · 2016-07-22T09:47:09.000-07:00
diff --git a/changelog/README.md b/changelog/README.md
@@ -12,6 +12,7 @@
 - [improvement] JAVA-1192: Make EventDebouncer settings updatable at runtime.
 - [new feature] JAVA-541: Add polymorphism support to object mapper.
 - [new feature] JAVA-636: Allow @Column annotations on getters/setters as well as fields.
+- [new feature] JAVA-984: Allow non-void setters in object mapping.
 
 Merged from 3.0.x branch:
 
diff --git a/driver-mapping/src/main/java/com/datastax/driver/mapping/AnnotationParser.java b/driver-mapping/src/main/java/com/datastax/driver/mapping/AnnotationParser.java
@@ -114,7 +114,7 @@ static <T> EntityMapper<T> parseEntity(final Class<T> entityClass, MappingManage
                     ? "col" + columnCounter.incrementAndGet()
                     : null;
 
-            PropertyMapper propertyMapper = new PropertyMapper(propertyName, alias, field, property);
+            PropertyMapper propertyMapper = new PropertyMapper(entityClass, propertyName, alias, field, property);
 
             if (mappingManager.isCassandraV1 && propertyMapper.isComputed())
                 throw new UnsupportedOperationException("Computed properties are not supported with native protocol v1");
@@ -180,7 +180,7 @@ static <T> MappedUDTCodec<T> parseUDT(Class<T> udtClass, MappingManager mappingM
             java.lang.reflect.Field field = (java.lang.reflect.Field) entry.getValue()[0];
             PropertyDescriptor property = (PropertyDescriptor) entry.getValue()[1];
 
-            PropertyMapper propertyMapper = new PropertyMapper(propertyName, null, field, property);
+            PropertyMapper propertyMapper = new PropertyMapper(udtClass, propertyName, null, field, property);
 
             AnnotationChecks.validateAnnotations(propertyMapper, VALID_FIELD_ANNOTATIONS);
 
diff --git a/driver-mapping/src/main/java/com/datastax/driver/mapping/PropertyMapper.java b/driver-mapping/src/main/java/com/datastax/driver/mapping/PropertyMapper.java
@@ -51,12 +51,12 @@ class PropertyMapper {
     private final Method setter;
     private final Map<Class<? extends Annotation>, Annotation> annotations;
 
-    PropertyMapper(String propertyName, String alias, Field field, PropertyDescriptor property) {
+    PropertyMapper(Class<?> baseClass, String propertyName, String alias, Field field, PropertyDescriptor property) {
         this.propertyName = propertyName;
         this.alias = alias;
         this.field = field;
         getter = ReflectionUtils.findGetter(property);
-        setter = ReflectionUtils.findSetter(property);
+        setter = ReflectionUtils.findSetter(baseClass, property);
         annotations = ReflectionUtils.scanPropertyAnnotations(field, property);
         if (field != null)
             ReflectionUtils.tryMakeAccessible(field);
diff --git a/driver-mapping/src/main/java/com/datastax/driver/mapping/ReflectionUtils.java b/driver-mapping/src/main/java/com/datastax/driver/mapping/ReflectionUtils.java
@@ -75,7 +75,7 @@ private static <T> Map<String, Field> scanFields(Class<T> baseClass) {
         HashMap<String, Field> fields = new HashMap<String, Field>();
         for (Class<?> clazz = baseClass; !clazz.equals(Object.class); clazz = clazz.getSuperclass()) {
             for (Field field : clazz.getDeclaredFields()) {
-                if (field.getName().equals("class") || field.isSynthetic() || (field.getModifiers() & Modifier.STATIC) == Modifier.STATIC)
+                if (field.getName().equals("class") || field.isSynthetic() || Modifier.isStatic(field.getModifiers()))
                     continue;
                 // never override a more specific field masking another one declared in a superclass
                 if (!fields.containsKey(field.getName()))
@@ -160,13 +160,24 @@ static Method findGetter(PropertyDescriptor property) {
         return getter;
     }
 
-    static Method findSetter(PropertyDescriptor property) {
+    static Method findSetter(Class<?> baseClass, PropertyDescriptor property) {
         if (property == null)
             return null;
         Method setter = property.getWriteMethod();
-        if (setter == null)
-            return null;
-        return setter;
+        if (setter != null)
+            return setter;
+        String propertyName = property.getName();
+        String setterName = "set" + propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
+        // JAVA-984: look for a "relaxed" setter, ie. a setter whose return type may be anything
+        try {
+            setter = baseClass.getMethod(setterName, property.getPropertyType());
+            if (!Modifier.isStatic(setter.getModifiers())) {
+                return setter;
+            }
+        } catch (NoSuchMethodException e) {
+            // ok
+        }
+        return null;
     }
 
     static void tryMakeAccessible(AccessibleObject object) {
diff --git a/driver-mapping/src/test/java/com/datastax/driver/mapping/MapperPolymorphismTest.java b/driver-mapping/src/test/java/com/datastax/driver/mapping/MapperPolymorphismTest.java
@@ -243,8 +243,11 @@ public double getRadius() {
             return _radius;
         }
 
-        public void setRadius(double radius) {
+        // builder-style setter; because the field isn't named in a standard way,
+        // if this setter is not detected the test would fail
+        public Circle setRadius(double radius) {
             this._radius = radius;
+            return this;
         }
 
         @Override
@@ -430,6 +433,13 @@ public void setCenter(Point3D center) {
             this.center = center;
         }
 
+        // overridden builder-style setter
+        @Override
+        public Sphere setRadius(double radius) {
+            super.setRadius(radius);
+            return this;
+        }
+
         @Override
         public boolean equals(Object o) {
             if (this == o) return true;
diff --git a/manual/object_mapper/creating/README.md b/manual/object_mapper/creating/README.md
@@ -119,6 +119,36 @@ A mapped field is thus allowed to be non-public if:
 1. Reads and writes are done through its public getters and setters; or
 2. The security manager, if any, grants the mapper access to it via [reflection][set-accessible].
 
+Note that, according to the [Java Beans specification][java-beans], a setter
+must have a `void` return type; the driver, however, will consider as a setter any public method
+having a matching signature (i.e., name and parameter types match those expected),
+but having a different return type. This allows the usage of "fluent" setters that can
+be chained together in a builder-pattern style:
+
+```java
+@Table(name = "users")
+public static class User {
+
+    // fluent setters
+    
+    public User setId(UUID id) {
+        this.id = id;
+        return this;
+    }
+
+    public User setName(String name) {
+        this.name = name;
+        return this;
+    }
+
+}
+
+// chained calls
+User user = new User()
+    .setId(UUIDs.random())
+    .setName("John Doe");
+```
+
 [table]:http://docs.datastax.com/en/drivers/java/3.0/com/datastax/driver/mapping/annotations/Table.html
 [case-sensitive]:http://docs.datastax.com/en/cql/3.3/cql/cql_reference/ucase-lcase_r.html
 [consistency level]:http://docs.datastax.com/en/drivers/java/3.0/com/datastax/driver/core/ConsistencyLevel.html
