A custom Codec or PojoCodec may need to be explicitly configured and registered to handle this type - spring

Question

UserProfileModel has two embedded models. I am giving here concisely:
#Document(collection = "USER_PROFILE")
public class UserProfileModel extends BaseModel<UserModel> {
public static final String FIELD_USER_ID = "userId";
public static final String FIELD_BASIC_INFO = "basicInfo";
public static final String FIELD_CONTACT_INFO = "contactInfo";
private String userId;
private BasicInfo basicInfo;
private ContactInfo contactInfo;
}
public class BasicInfo {
private String gender;
private LocalDate birthDate;
private String[] langs;
private String religiousView;
private String politicalView;
}
public class ContactInfo {
private String[] mobilePhones;
private Address address;
private SocialLink[] socialLinks;
private String[] websites;
private String[] emails;
}
Writing converter class of UserProfileModel:
#Component
#WritingConverter
public class UserProfileModelConverter implements Converter<UserProfileModel, Document> {
#Override
public Document convert(UserProfileModel s) {
Document doc = new Document();
if (null != s.getUserId())
doc.put(UserProfileModel.FIELD_USER_ID, s.getUserId());
if (null != s.getBasicInfo())
doc.put(UserProfileModel.FIELD_BASIC_INFO, s.getBasicInfo());
if (null != s.getContactInfo())
doc.put(UserProfileModel.FIELD_CONTACT_INFO, s.getContactInfo());
}
}
Trying to save an object of UserProfileModel like this:
#Autowired
private UserProfileRepository repo;
UserProfileModel profileModel = generateUserProfileModel();
repo.save(profileModel);
Exception:
org.bson.codecs.configuration.CodecConfigurationException: An exception occurred when encoding using the AutomaticPojoCodec.
Encoding a BasicInfo: 'BasicInfo(gender=Male, birthDate=2020-05-05, langs=[Lang 1, Lang 2], religiousView=Islam (Sunni), politicalView=N/A)' failed with the following exception:
Failed to encode 'BasicInfo'. Encoding 'langs' errored with: Can't find a codec for class [Ljava.lang.String;.
A custom Codec or PojoCodec may need to be explicitly configured and registered to handle this type.
at org.bson.codecs.pojo.AutomaticPojoCodec.encode(AutomaticPojoCodec.java:53)
at org.bson.codecs.EncoderContext.encodeWithChildContext(EncoderContext.java:91)
at org.bson.codecs.DocumentCodec.writeValue(DocumentCodec.java:185)
at org.bson.codecs.DocumentCodec.writeMap(DocumentCodec.java:199)
at org.bson.codecs.DocumentCodec.encode(DocumentCodec.java:141)
at org.bson.codecs.DocumentCodec.encode(DocumentCodec.java:45)
at org.bson.codecs.BsonDocumentWrapperCodec.encode(BsonDocumentWrapperCodec.java:63)
at org.bson.codecs.BsonDocumentWrapperCodec.encode(BsonDocumentWrapperCodec.java:29)
If I don't use converter for UserProfileModel by adding in Mongo Config, then this exception doesn't appear and everything works well.
But I am trying to use the Converter class for some reason.
So is it something wrong or modification needed in converter class?

Answer 1

A Jira ticket already raised on this issue here.
Can't find a codec for class [Ljava.lang.String;
And their reply
The Document class currently supports only List, not native Java
array, so just replace with:
List codes = Arrays.asList("1112233", "2223344");
So, String array is not supported. Use List<String> instead of String[] in models.

Answer 2

Two ways to solve this issue:
Either change String[] to List<String> as mentioned here
Write your custom codec (if you do not have control over a class)
Following is solution 2:
Create a custom Code StringArrayCodec
Register it along with the existing codec
Start/restart application which uses mongo-java driver
Following is Kotlin code but can be converted to java as well.
StringArrayCodec.kt
import java.util.*
import org.bson.BsonReader
import org.bson.BsonType
import org.bson.BsonWriter
import org.bson.codecs.Codec
import org.bson.codecs.DecoderContext
import org.bson.codecs.EncoderContext
class StringArrayCodec : Codec<Array<String>> {
/**
* Encode an instance of the type parameter `T` into a BSON value.
* #param writer the BSON writer to encode into
* #param value the value to encode
* #param encoderContext the encoder context
*/
override fun encode(writer: BsonWriter?, value: Array<String>?, encoderContext: EncoderContext?) {
writer?.writeStartArray()
val isNonNull = value != null
if (isNonNull) {
writer?.writeBoolean(isNonNull)
value?.size?.let { writer?.writeInt32(it) }
for (i in value!!) {
writeValue(writer, i, encoderContext)
}
} else {
writer?.writeBoolean(!isNonNull)
}
writer?.writeEndArray()
}
private fun writeValue(writer: BsonWriter?, s: String, encoderContext: EncoderContext?) {
if (s == null) {
writer?.writeNull()
} else {
writer?.writeString(s)
}
}
/**
* Returns the Class instance that this encodes. This is necessary because Java does not reify generic types.
*
* #return the Class instance that this encodes.
*/
override fun getEncoderClass(): Class<Array<String>>? {
return Array<String>::class.java
}
/**
* Decodes a BSON value from the given reader into an instance of the type parameter `T`.
*
* #param reader the BSON reader
* #param decoderContext the decoder context
* #return an instance of the type parameter `T`.
*/
override fun decode(reader: BsonReader?, decoderContext: DecoderContext?): Array<String>? {
reader?.readStartArray()
val isNonNull = reader?.readBoolean()
val tempArray: Array<String?>?
if (isNonNull == true) {
val size = reader.readInt32()
tempArray = arrayOfNulls(size)
for (i in 0 until size) {
tempArray[i] = readValue(reader, decoderContext)
}
} else {
tempArray = null
}
val array: Array<String>? = if (isNonNull == true) {
Arrays.stream(tempArray)
.filter { s ->
s != null
}
.toArray() as Array<String>
} else {
null
}
reader?.readEndArray()
return array
}
private fun readValue(reader: BsonReader, decoderContext: DecoderContext?): String? {
val bsonType: BsonType = reader.currentBsonType
return if (bsonType == BsonType.NULL) {
reader.readNull()
null
} else {
reader.readString()
}
}
}
Register custom codec as CodecRegistries.fromCodecs(StringArrayCodec())
MongodbConfig.kt
import com.mongodb.ConnectionString
import com.mongodb.MongoClientSettings
import com.mongodb.client.MongoClient
import com.mongodb.client.MongoClients
import com.mongodb.client.MongoCollection
import com.mongodb.client.MongoDatabase
import org.bson.Document
import org.bson.codecs.configuration.CodecRegistries
import org.bson.codecs.configuration.CodecRegistries.fromProviders
import org.bson.codecs.configuration.CodecRegistries.fromRegistries
import org.bson.codecs.configuration.CodecRegistry
import org.bson.codecs.pojo.PojoCodecProvider
import org.springframework.beans.factory.annotation.Value
import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty
import org.springframework.boot.context.properties.ConfigurationProperties
import org.springframework.boot.context.properties.EnableConfigurationProperties
import org.springframework.context.annotation.Bean
import org.springframework.stereotype.Component
#EnableConfigurationProperties
#ConfigurationProperties(prefix = "mongodb")
#ConditionalOnProperty(name = ["mongodb.enable"], havingValue = "true", matchIfMissing = false)
#Component
class MongodbConfig
(
#Value("\${mongodb.uri}")
val connectionUri: String,
#Value("\${mongodb.database}")
val database: String,
#Value("\${mongodb.collection-name}")
val collectionName: String
) {
#Bean
fun mongoClient(): MongoClient {
return MongoClients.create(mongodbSettings())
}
#Bean
fun mongoDatabase(mongoClient: MongoClient): MongoDatabase {
return mongoClient.getDatabase(database)
}
#Bean
fun mongodbCollection(mongoDatabase: MongoDatabase): MongoCollection<Document> {
return mongoDatabase.getCollection(collectionName)
}
fun mongodbSettings(): MongoClientSettings {
val pojoCodecRegistry: CodecRegistry = fromRegistries(
CodecRegistries.fromCodecs(StringArrayCodec()), // <---- this is the custom codec
MongoClientSettings.getDefaultCodecRegistry(),
fromProviders(PojoCodecProvider.builder().automatic(true).build())
)
val connectionString = ConnectionString(connectionUri)
return MongoClientSettings.builder()
.codecRegistry(pojoCodecRegistry)
.applyConnectionString(connectionString)
.build()
}
}
Dependency and driver version
implementation("org.mongodb:mongodb-driver-sync:4.2.0") {
because("To connect mongodb instance")
}

Answer 3

The answer from dkb re StringArrayCodec was helpful to me.
If you wish to avoid kotlin and use java instead then here is a non-kotlin-spam-java version:
import org.bson.BsonReader;
import org.bson.BsonWriter;
import org.bson.codecs.Codec;
import org.bson.codecs.DecoderContext;
import org.bson.codecs.EncoderContext;
public final class MongoCodecStringArray implements Codec {
public void encode(BsonWriter writer, String[] value, EncoderContext encoderContext) {
if (writer == null)
return;
writer.writeStartArray();
boolean isNonNull = value != null;
writer.writeBoolean(isNonNull);
if (isNonNull) {
writer.writeInt32(value.length);
for (int i = 0; i < value.length; ++i) {
writer.writeString(value[i]);
}
}
writer.writeEndArray();
}
public void encode(BsonWriter var1, Object var2, EncoderContext var3) {
this.encode(var1, (String[]) var2, var3);
}
public Class getEncoderClass() {
return String[].class;
}
public String[] decodeImpl(BsonReader reader, DecoderContext decoderContext) {
if (reader == null)
return null;
reader.readStartArray();
Boolean isNonNull = reader.readBoolean();
String[] ret = null;
if (isNonNull) {
int size = reader.readInt32();
ret = new String[size];
for (int i = 0; i < size; ++i) {
ret[i] = reader.readString();
}
}
reader.readEndArray();
return ret;
}
public Object decode(BsonReader var1, DecoderContext var2) {
return decodeImpl(var1, var2);
}
}
.