Java 如何正确扩展Mongo'；什么是文档类？

我创建了一个类

User

，它扩展了

文档

User

只是在一些字符串和int周围有一些简单的构造函数和getter/setter。但是，当我尝试将用户类插入Mongo时，会出现以下错误：

Exception in thread "main" org.bson.codecs.configuration.CodecConfigurationException: Can't find a codec for class com.foo.User.
    at org.bson.codecs.configuration.CodecCache.getOrThrow(CodecCache.java:46)
    at org.bson.codecs.configuration.ProvidersCodecRegistry.get(ProvidersCodecRegistry.java:63)
    at org.bson.codecs.configuration.ProvidersCodecRegistry.get(ProvidersCodecRegistry.java:37)
    at org.bson.BsonDocumentWrapper.asBsonDocument(BsonDocumentWrapper.java:62)
    at com.mongodb.MongoCollectionImpl.documentToBsonDocument(MongoCollectionImpl.java:507)
    at com.mongodb.MongoCollectionImpl.insertMany(MongoCollectionImpl.java:292)
    at com.mongodb.MongoCollectionImpl.insertMany(MongoCollectionImpl.java:282)
    at com.foo.bar.main(bar.java:27)

听起来我需要使用一些Mongo编解码器的东西，但我对它不熟悉，一些快速的谷歌搜索会返回一些看起来相当先进的结果

如何正确编写

User

类以在Mongo中使用？以下是我的课堂参考：

public class User extends Document {
    User(String user, List<Document > history, boolean isActive, String location){
        this.append("_id", user)
                .append("history", history)
                .append("isActive", isActive)
                .append("location", location);
    }

    public List<Document > getHistory(){
        return this.get("history", ArrayList.class);
    }

    public void addToHistory(Document event){
       List<Document> history = this.getHistory();
        history.add(event);
        this.append("history", history);
    }

    public boolean hasMet(User otherUser){
        List<String> usersIveMet = this.getUsersMet(),
                     usersTheyMet = otherUser.getUsersMet();
        return !Collections.disjoint(usersIveMet, usersTheyMet);
    }

    public List<String> getUsersMet() {
        List<Document> usersHistory = this.getHistory();
        List<String> usersMet = usersHistory.stream()
                .map(doc -> Arrays.asList(doc.getString("user1"), doc.getString("user1")))
                .filter(u -> !u.equals(this.getUser()))
                .flatMap(u -> u.stream())
                .collect(Collectors.toList());
        return usersMet;
    }

    public String getUser(){
        return this.getString("_id");
    }
}

公共类用户扩展文档{
用户（字符串用户、列表历史记录、布尔值isActive、字符串位置）{
此。追加（“\u id”，用户）
.append（“历史”，历史）
.append（“isActive”，isActive）
.附加（“位置”，位置）；
}
公共列表getHistory（）{
返回这个.get（“history”，ArrayList.class）；
}
公共作废addToHistory（文档事件）{
List history=this.getHistory（）；
添加（事件）；
本附录（“历史”，历史）；
}
公共布尔值hasMet（用户otherUser）{
List usersIveMet=this.getUsersMet（），
usersThemet=otherUser.getUsersMet（）；
return！Collections.disjoint（usersIveMet，userthemet）；
}
公共列表getUsersMet（）{
List usersHistory=this.getHistory（）；
List usersMet=usersHistory.stream（）
.map（doc->Arrays.asList（doc.getString（“user1”）、doc.getString（“user1”））
.filter（u->！u.equals（this.getUser（）））
.flatMap（u->u.stream（））
.collect（Collectors.toList（））；
返回usersMet；
}
公共字符串getUser（）{
返回这个.getString（“_id”）；
}
}

由于您试图创建新对象（即使您从文档扩展），Mongo无法识别它，因此您需要提供编码/解码，以便让Mongo了解您的对象（至少我看不到除此之外的其他方式）

我和你的用户类玩了一会儿，然后让它工作起来。 下面是我如何定义用户类的：

public class User {

    private List<Document> history;
    private String id;
    private Boolean isActive;
    private String location;

    // Getters and setters. Omitted for brevity..
}

public class UserCodec implements Codec<User> {

    private CodecRegistry codecRegistry;

    public UserCodec(CodecRegistry codecRegistry) {
        this.codecRegistry = codecRegistry;
    }

    @Override
    public User decode(BsonReader reader, DecoderContext decoderContext) {
        reader.readStartDocument();
        String id = reader.readString("id");
        Boolean isActive = reader.readBoolean("isActive");
        String location = reader.readString("location");

        Codec<Document> historyCodec = codecRegistry.get(Document.class);
        List<Document> history = new ArrayList<>();
        reader.readStartArray();
        while (reader.readBsonType() != BsonType.END_OF_DOCUMENT) {
            history.add(historyCodec.decode(reader, decoderContext));
        }
        reader.readEndArray();
        reader.readEndDocument();

        User user = new User();
        user.setId(id);
        user.setIsActive(isActive);
        user.setLocation(location);
        user.setHistory(history);
        return user;
    }

    @Override
    public void encode(BsonWriter writer, User user, EncoderContext encoderContext) {
        writer.writeStartDocument();
        writer.writeName("id");
        writer.writeString(user.getId());
        writer.writeName("isActive");
        writer.writeBoolean(user.getIsActive());
        writer.writeName("location");
        writer.writeString(user.getLocation());

        writer.writeStartArray("history");
        for (Document document : user.getHistory()) {
            Codec<Document> documentCodec = codecRegistry.get(Document.class);
            encoderContext.encodeWithChildContext(documentCodec, writer, document);
        }
        writer.writeEndArray();
        writer.writeEndDocument();
    }

    @Override
    public Class<User> getEncoderClass() {
        return User.class;
    }
}

公共类用户{
私人名单历史；
私有字符串id；
私有布尔非活动；
私有字符串位置；
//getter和setter。为简洁起见省略。。
}

然后，您需要为您的用户类提供编码/解码逻辑：

public class User {

    private List<Document> history;
    private String id;
    private Boolean isActive;
    private String location;

    // Getters and setters. Omitted for brevity..
}

public class UserCodec implements Codec<User> {

    private CodecRegistry codecRegistry;

    public UserCodec(CodecRegistry codecRegistry) {
        this.codecRegistry = codecRegistry;
    }

    @Override
    public User decode(BsonReader reader, DecoderContext decoderContext) {
        reader.readStartDocument();
        String id = reader.readString("id");
        Boolean isActive = reader.readBoolean("isActive");
        String location = reader.readString("location");

        Codec<Document> historyCodec = codecRegistry.get(Document.class);
        List<Document> history = new ArrayList<>();
        reader.readStartArray();
        while (reader.readBsonType() != BsonType.END_OF_DOCUMENT) {
            history.add(historyCodec.decode(reader, decoderContext));
        }
        reader.readEndArray();
        reader.readEndDocument();

        User user = new User();
        user.setId(id);
        user.setIsActive(isActive);
        user.setLocation(location);
        user.setHistory(history);
        return user;
    }

    @Override
    public void encode(BsonWriter writer, User user, EncoderContext encoderContext) {
        writer.writeStartDocument();
        writer.writeName("id");
        writer.writeString(user.getId());
        writer.writeName("isActive");
        writer.writeBoolean(user.getIsActive());
        writer.writeName("location");
        writer.writeString(user.getLocation());

        writer.writeStartArray("history");
        for (Document document : user.getHistory()) {
            Codec<Document> documentCodec = codecRegistry.get(Document.class);
            encoderContext.encodeWithChildContext(documentCodec, writer, document);
        }
        writer.writeEndArray();
        writer.writeEndDocument();
    }

    @Override
    public Class<User> getEncoderClass() {
        return User.class;
    }
}

public类UserCodec实现编解码器{
私人编码中心注册中心；
公共用户编解码器（编解码器注册表编解码器注册表）{
this.codecRegistry=codecRegistry；
}
@凌驾
公共用户解码（BsonReader阅读器，DecoderContext DecoderContext）{
reader.readStartDocument（）；
String id=reader.readString（“id”）；
Boolean isActive=reader.readBoolean（“isActive”）；
字符串位置=reader.readString（“位置”）；
Codec historyCodec=codecRegistry.get（Document.class）；
列表历史记录=新建ArrayList（）；
reader.readStartArray（）；
while（reader.readBsonType（）！=BsonType.END\u文档）{
添加（historyCodec.decode（reader，decoderContext））；
}
reader.readEndArray（）；
reader.readEndDocument（）；
用户=新用户（）；
user.setId（id）；
user.setIsActive（isActive）；
user.setLocation（位置）；
user.setHistory（历史记录）；
返回用户；
}
@凌驾
公共无效编码（BsonWriter编写器、用户用户、EncoderContext EncoderContext）{
writer.writeStartDocument（）；
writer.writeName（“id”）；
writer.writeString（user.getId（））；
writer.writeName（“isActive”）；
writebolean（user.getIsActive（））；
writer.writeName（“位置”）；
writer.writeString（user.getLocation（））；
作者：WriteStartaray（“历史”）；
对于（文档：user.getHistory（））{
Codec documentCodec=codecRegistry.get（Document.class）；
encoderContext.encodeWithChildContext（documentCodec、writer、document）；
}
writer.writeEndArray（）；
writer.writeEndDocument（）；
}
@凌驾
公共类getEncoderClass（）{
返回User.class；
}
}

然后，在开始序列化/反序列化之前，需要提供用于类型检查的编解码器

public class UserCodecProvider implements CodecProvider {

    @Override
    @SuppressWarnings("unchecked")
    public <T> Codec<T> get(Class<T> clazz, CodecRegistry registry) {
        if (clazz == User.class) {
            return (Codec<T>) new UserCodec(registry);
        }
        return null;
    }
}

public类UserCodecProvider实现CodecProvider{
@凌驾
@抑制警告（“未选中”）
公共编解码器获取（类clazz，编解码器注册表）{
if（clazz==User.class）{
返回（编解码器）新用户编解码器（注册表）；
}
返回null；
}
}

最后，您需要将提供商注册到您的MongoClient，仅此而已

public class MongoDb {

    private MongoDatabase db;

    public MongoDb() {
        CodecRegistry codecRegistry = CodecRegistries.fromRegistries(
                CodecRegistries.fromProviders(new UserCodecProvider()),
                MongoClient.getDefaultCodecRegistry());
        MongoClientOptions options = MongoClientOptions.builder()
                .codecRegistry(codecRegistry).build();
        MongoClient mongoClient = new MongoClient(new ServerAddress(), options);
        db = mongoClient.getDatabase("test");
    }

    public void addUser(User user) {
        MongoCollection<User> collection = db.getCollection("user").withDocumentClass(User.class);
        collection.insertOne(user);
    }

    public static void main(String[] args) {
        MongoDb mongoDb = new MongoDb();

        Document history1 = new Document();
        history1.append("field1", "value1");
        history1.append("field2", "value2");
        history1.append("field3", "value3");

        List<Document> history = new ArrayList<>();
        history.add(history1);

        User user = new User();
        user.setId("someId1");
        user.setIsActive(true);
        user.setLocation("someLocation");
        user.setHistory(history);
        mongoDb.addUser(user);
    }
}

公共类MongoDb{
私有MongoDatabase数据库；
公共MongoDb（）{
CodecRegistry CodecRegistry=CodecRegistries.fromRegistries(
CodeRegistries.fromProviders（新的UserCodecProvider（）），
MongoClient.getDefaultCodecRegistry（））；
MongoClientOptions=MongoClientOptions.builder（）
.codecRegistry（codecRegistry）.build（）；
MongoClient MongoClient=新的MongoClient（新服务器地址（），选项）；
db=mongoClient.getDatabase（“测试”）；
}
public void addUser（用户）{
MongoCollection collection=db.getCollection（“用户”）.withDocumentClass（user.class）；
collection.insertOne（用户）；
}
公共静态void main（字符串[]args）{
MongoDb MongoDb=新的MongoDb（）；
文档历史1=新文档（）；
历史1.附加（“字段1”、“值1”）；
历史1.附加（“字段2”、“值2”）；
历史1.附加（“字段3”、“值3”）；
列表历史记录=新建ArrayList（）；
历史。添加（历史1）；
用户=新用户（）；
user.setId（“someId1”）；
user.setIsActive（true）；
user.setLocation（“someLocation”）；
user.setHistory（历史记录