Add suport for JsonValue annotation on Enums and JsonValue/JsonCreator otherwise.

Closes #1617.

Author: mikereiche

src/main/java/org/springframework/data/couchbase/config/AbstractCouchbaseConfiguration.java

@@ -402,6 +402,7 @@ public CustomConversions customConversions(CryptoManager cryptoManager) {
 			SimplePropertyValueConversions valueConversions = new SimplePropertyValueConversions();
 			valueConversions.setConverterFactory(new CouchbasePropertyValueConverterFactory(cryptoManager));
 			valueConversions.setValueConverterRegistry(new PropertyValueConverterRegistrar().buildRegistry());
+			valueConversions.afterPropertiesSet(); // wraps the CouchbasePropertyValueConverterFactory with CachingPVCFactory
 			configurationAdapter.setPropertyValueConversions(valueConversions);
 			configurationAdapter.registerConverters(newConverters);
 		});

src/main/java/org/springframework/data/couchbase/core/convert/AbstractCouchbaseConverter.java

@@ -117,10 +117,8 @@ public Object convertForWriteIfNeeded(CouchbasePersistentProperty prop, Converti
 			return null;
 		}
 		if (processValueConverter && conversions.hasValueConverter(prop)) {
-			CouchbaseDocument encrypted = (CouchbaseDocument) conversions.getPropertyValueConversions()
-					.getValueConverter(prop)
-					.write(value, new CouchbaseConversionContext(prop, (MappingCouchbaseConverter) this, accessor));
-			return encrypted;
+			return conversions.getPropertyValueConversions().getValueConverter(prop).write(value,
+					new CouchbaseConversionContext(prop, (MappingCouchbaseConverter) this, accessor));
 		}
 		Class<?> targetClass = this.conversions.getCustomWriteTarget(value.getClass()).orElse(null);
 

src/main/java/org/springframework/data/couchbase/core/convert/ConverterHasNoConversion.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright 2012-2022 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
+ *
+ *        https://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.couchbase.core.convert;
+
+/**
+ * PropertyValueConverter throws this when cannot convert the property. The caller should catch this and resort to other
+ * means for creating the value.
+ * 
+ * @author Michael Reiche
+ */
+public class ConverterHasNoConversion extends RuntimeException {}

src/main/java/org/springframework/data/couchbase/core/convert/CouchbaseCustomConversions.java

@@ -44,8 +44,6 @@
 import org.springframework.data.mapping.model.SimpleTypeHolder;
 import org.springframework.util.Assert;
 
-import com.couchbase.client.java.encryption.annotation.Encrypted;
-
 /**
  * Value object to capture custom conversion.
  * <p>
@@ -112,9 +110,6 @@ public static CouchbaseCustomConversions create(Consumer<CouchbaseConverterConfi
 
 	@Override
 	public boolean hasValueConverter(PersistentProperty<?> property) {
-		if (property.findAnnotation(Encrypted.class) != null) {
-			return true;
-		}
 		return super.hasValueConverter(property);
 	}
 

src/main/java/org/springframework/data/couchbase/core/convert/CouchbasePropertyValueConverterFactory.java

@@ -16,70 +16,175 @@
 
 package org.springframework.data.couchbase.core.convert;
 
+import java.lang.annotation.Annotation;
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
 
+import org.springframework.beans.BeanUtils;
 import org.springframework.data.convert.PropertyValueConverter;
 import org.springframework.data.convert.PropertyValueConverterFactory;
 import org.springframework.data.convert.ValueConversionContext;
 import org.springframework.data.mapping.PersistentProperty;
 
 import com.couchbase.client.core.encryption.CryptoManager;
 import com.couchbase.client.java.encryption.annotation.Encrypted;
+import com.fasterxml.jackson.annotation.JsonCreator;
+import com.fasterxml.jackson.annotation.JsonValue;
 
 /**
- * Accept the Couchbase @Encrypted annotation in addition to @ValueConverter
+ * Accept the Couchbase @Encrypted and @JsonValue annotations in addition to @ValueConverter annotation.<br>
+ * There can only be one propertyValueConverter for a property. Although there maybe be multiple annotations,
+ * getConverter(property) only returns one converter (a ChainedPropertyValueConverter might be useful). Note that
+ * valueConversions.afterPropertiesSet() encapsulates this in a CachingPropertyValueConverterFactory which caches by
+ * 'property'. Although CachingPropertyValueConverterFactory does have the functionality to cache by a type, it only
+ * caches by the type specified on an @ValueConverter annotation.To avoid having identical converter instances for each
+ * instance of a class containing an @JsonValue annotation, converterCacheForType is used.
  *
  * @author Michael Reiche
  */
 public class CouchbasePropertyValueConverterFactory implements PropertyValueConverterFactory {
 
-	CryptoManager cryptoManager;
-	Map<Class<? extends PropertyValueConverter<?, ?, ?>>, PropertyValueConverter<?, ?, ?>> converterCache = new HashMap<>();
-
+	final CryptoManager cryptoManager;
+	static protected final Map<Class<?>, Optional<PropertyValueConverter<?, ?, ?>>> converterCacheForType = new ConcurrentHashMap<>();
 	public CouchbasePropertyValueConverterFactory(CryptoManager cryptoManager) {
 		this.cryptoManager = cryptoManager;
 	}
 
+	/**
+	 * @param property must not be {@literal null}.
+	 * @return
+	 * @param <DV> destination value
+	 * @param <SV> source value
+	 * @param <P> context
+	 */
 	@Override
 	public <DV, SV, P extends ValueConversionContext<?>> PropertyValueConverter<DV, SV, P> getConverter(
 			PersistentProperty<?> property) {
 		PropertyValueConverter<DV, SV, P> valueConverter = PropertyValueConverterFactory.super.getConverter(property);
 		if (valueConverter != null) {
+			/* if using @ValueConverter, need process maybeTypePropertyConverter(property) for enum stuff
+			Optional<PropertyValueConverter<?, ?, ?>> cachedConverterForType = converterCacheForType
+				.get(property.getType());
+			if (cachedConverterForType != null) {
+				return valueConverter;
+			}
+			PropertyValueConverter<DV, SV, P> converterForType = maybeTypePropertyConverter(property);
+			converterCacheForType.put(property, Optional.ofNullable(converterForType));
+			 */
 			return valueConverter;
 		}
-		Encrypted encryptedAnn = property.findAnnotation(Encrypted.class);
-		if (encryptedAnn != null) {
-			Class cryptoConverterClass = CryptoConverter.class;
-			return getConverter((Class<PropertyValueConverter<DV, SV, P>>) cryptoConverterClass);
-		} else {
-			return null;
+
+		// this will return the converter for the first annotation that requires a PropertyValueConverter
+		for (Annotation ann : property.getField().getAnnotations()) {
+			Class<?> converterClass = converterFromFieldAnnotation(ann);
+			if (converterClass != null) {
+				return getConverter((Class<PropertyValueConverter<DV, SV, P>>) converterClass, property);
+			}
+		}
+		return (PropertyValueConverter<DV, SV, P> )converterCacheForType
+				.computeIfAbsent(property.getType(), p -> Optional.ofNullable((maybeTypePropertyConverter(property)))).orElse(null);
+	}
+
+	/**
+	 * lookup the converter class from the annotation. Analogous to getting the converter class from the value() attribute
+	 * of the @ValueProperty annotation
+	 * 
+	 * @param ann the annotation
+	 * @return the class of the converter
+	 */
+	private Class<?> converterFromFieldAnnotation(Annotation ann) {
+		if (ann instanceof Encrypted) {
+			return CryptoConverter.class;
 		}
+		return null;
+	}
+
+	<DV, SV, P extends ValueConversionContext<?>> PropertyValueConverter<DV, SV, P> maybeTypePropertyConverter(
+			PersistentProperty<?> property) {
+
+		Class<?> type = property.getType();
+
+		// since we need to find the annotated method to determine if a converter is required,
+		// we may as well cache it. And also create a value -> enum-object map for Enums.
+		Method jsonValueMethod = null;
+		for (Method m : type.getDeclaredMethods()) {
+			JsonValue jsonValueAnn = m.getAnnotation(JsonValue.class);
+			if (jsonValueAnn != null && jsonValueAnn.value()) {
+				jsonValueMethod = m;
+				jsonValueMethod.setAccessible(true);
+				JsonValueConverter.valueMethodCache.put(type, jsonValueMethod);
+				// for Enums, we can compute the conversion on read()
+				// otherwise, we rely on a constructor with an argument that is the output of the JsonValue method (inverse)
+				if (type.isEnum()) {
+					Map<Object, Enum<?>> enumConstants = new HashMap<>();
+					Class<Enum<?>> enumType = (Class<Enum<?>>) type;
+					for (Enum<?> e : enumType.getEnumConstants()) { // create a value -> enum-object map for Enums
+						try {
+							enumConstants.put(Optional.ofNullable(jsonValueMethod.invoke(e)), e);
+						} catch (IllegalAccessException | InvocationTargetException ex) {
+							throw new RuntimeException(ex);
+						}
+					}
+					enumConstants = Collections.unmodifiableMap(enumConstants);
+					JsonValueConverter.enumConstantsCache.put(type, enumConstants);
+				}
+			}
+		}
+
+		Constructor<?> jsonCreatorMethod = null;
+		for (Constructor<?> m : type.getConstructors()) {
+			JsonCreator jsonCreatorAnn = m.getAnnotation(JsonCreator.class);
+			if (jsonCreatorAnn != null && !jsonCreatorAnn.mode().equals(JsonCreator.Mode.DISABLED)) {
+				jsonCreatorMethod = m;
+				jsonCreatorMethod.setAccessible(true);
+				JsonValueConverter.creatorMethodCache.put(type, jsonCreatorMethod);
+				// hopefully the jsonValueConverter.read() will know what to do with this.
+			}
+		}
+		if (jsonValueMethod != null || jsonCreatorMethod != null) {
+			Class jsonValueConverterClass = JsonValueConverter.class;
+			return getConverter((Class<PropertyValueConverter<DV, SV, P>>) jsonValueConverterClass, property);
+		}
+		return null; // we didn't find a property value converter to use
 	}
 
 	@Override
 	public <DV, SV, P extends ValueConversionContext<?>> PropertyValueConverter<DV, SV, P> getConverter(
 			Class<? extends PropertyValueConverter<DV, SV, P>> converterType) {
+		return getConverter(converterType, null);
+	}
 
-		PropertyValueConverter<?, ?, ?> converter = converterCache.get(converterType);
-		if (converter != null) {
-			return (PropertyValueConverter<DV, SV, P>) converter;
-		}
+	/**
+	 * @param converterType
+	 * @param property
+	 * @return
+	 * @param <DV>
+	 * @param <SV>
+	 * @param <P>
+	 */
+	public <DV, SV, P extends ValueConversionContext<?>> PropertyValueConverter<DV, SV, P> getConverter(
+			Class<? extends PropertyValueConverter<DV, SV, P>> converterType, PersistentProperty<?> property) {
 
+		// CryptoConverter takes a cryptoManager argument
 		if (CryptoConverter.class.isAssignableFrom(converterType)) {
-			converter = new CryptoConverter(cryptoManager);
-		} else {
+			return (PropertyValueConverter<DV, SV, P>) new CryptoConverter(cryptoManager);
+		} else if (property != null) { // try constructor that takes PersistentProperty, fall-back to no-args constructor
 			try {
-				Constructor constructor = converterType.getConstructor();
-				converter = (PropertyValueConverter<?, ?, ?>) constructor.newInstance();
-			} catch (NoSuchMethodException | InstantiationException | IllegalAccessException | InvocationTargetException e) {
-				throw new RuntimeException(e);
-			}
+				Constructor<?> constructor = converterType.getConstructor(PersistentProperty.class);
+				try {
+					return (PropertyValueConverter<DV, SV, P>) constructor.newInstance(property);
+				} catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
+					throw new RuntimeException(e); // the constructor that takes a property failed
+				}
+			} catch (NoSuchMethodException e) {}
 		}
-		converterCache.put((Class<? extends PropertyValueConverter<DV, SV, P>>) converter.getClass(), converter);
-		return (PropertyValueConverter<DV, SV, P>) converter;
-
+		// there is no constructor that takes a property, fall-back to no-args constructor
+		return BeanUtils.instantiateClass(converterType);
 	}
 }

src/main/java/org/springframework/data/couchbase/core/convert/JsonValueConverter.java

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2022 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
+ *
+ *        https://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.couchbase.core.convert;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import org.springframework.data.convert.PropertyValueConverter;
+import org.springframework.data.convert.ValueConversionContext;
+import org.springframework.data.mapping.PersistentProperty;
+
+/**
+ * Enum properties annotated with JsonValue
+ * 
+ * @author Michael Reiche
+ */
+public class JsonValueConverter
+		implements PropertyValueConverter<Object, Object, ValueConversionContext<? extends PersistentProperty<?>>> {
+
+	static protected final Map<Class<?>, Method> valueMethodCache = new ConcurrentHashMap<>();
+	static protected final Map<Class<?>, Constructor<?>> creatorMethodCache = new ConcurrentHashMap<>();
+	static protected final Map<Class<?>, Map<Object, Enum<?>>> enumConstantsCache = new ConcurrentHashMap<>();
+	static private final ConverterHasNoConversion CONVERTER_HAS_NO_CONVERSION = new ConverterHasNoConversion();
+
+	@Override
+	public Object read(Object value, ValueConversionContext<? extends PersistentProperty<?>> context) {
+		Class<?> type = context.getProperty().getActualType();
+
+		// if there was a @JsonCreator method, use it
+		if (getJsonCreatorMethod(type) != null) {
+			try {
+				return getJsonCreatorMethod(type).newInstance(value);
+			} catch (IllegalAccessException | InvocationTargetException | InstantiationException e) {
+				throw new RuntimeException(e);
+			}
+		}
+
+		// for Enums, we can use the inverse mapping we made from the @JsonValue method
+		if (type.isEnum()) {
+			return getEnumConstant((Class<Enum<?>>) type, value);
+		}
+
+		// Otherwise fall-through in MappingCouchbaseConverter.readValue()
+		throw CONVERTER_HAS_NO_CONVERSION;
+	}
+
+	@Override
+	public Object write(Object value, ValueConversionContext<? extends PersistentProperty<?>> context) {
+		try {
+			Class<?> type = value.getClass();
+			return getJsonValueMethod(type).invoke(value);
+		} catch (IllegalAccessException | InvocationTargetException e) {
+			throw new RuntimeException(e);
+		}
+	}
+
+	private Enum<?> getEnumConstant(Class<Enum<?>> type, Object value) {
+		Map<Object, Enum<?>> enumConstants = enumConstantsCache.get(type);
+		return enumConstants.get(value);
+	}
+
+	private Method getJsonValueMethod(Class<?> type) {
+		return valueMethodCache.get(type);
+	}
+
+	private Constructor<?> getJsonCreatorMethod(Class<?> type) {
+		return creatorMethodCache.get(type);
+	}
+
+}