Question

我正在尝试使用Java将整个Java对象插入到MongoDB集合中。我收到了以下错误：

错误：

Exception in thread "main" java.lang.IllegalArgumentException: can't serialize class net.yogesh.test.Employee
    at org.bson.BSONEncoder._putObjectField(BSONEncoder.java:185)
    at org.bson.BSONEncoder.putObject(BSONEncoder.java:119)
    at org.bson.BSONEncoder.putObject(BSONEncoder.java:65)
    at com.mongodb.DBApiLayer$MyCollection.insert(DBApiLayer.java:176)
    at com.mongodb.DBApiLayer$MyCollection.insert(DBApiLayer.java:134)
    at com.mongodb.DBApiLayer$MyCollection.insert(DBApiLayer.java:129)
    at com.mongodb.DBCollection.save(DBCollection.java:418)
    at net.yogesh.test.test.main(test.java:31)

Emplyoee.java（POJO）

package net.yogesh.test;

import java.io.Serializable;

public class Employee implements Serializable {

    private static final long serialVersionUID = 1L;
    private long no;
    private String name;

    public Employee() {
    }

    public long getNo() {
        return no;
    }

    public void setNo(long no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

}

主要方法类（test.java）

package net.yogesh.test;

import java.net.UnknownHostException;

import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.Mongo;
import com.mongodb.MongoException;

public class test {

    public static void main(String[] args) throws UnknownHostException,
            MongoException {

        Mongo mongo = new Mongo("localhost", 27017);
        DB db = mongo.getDB("test");

        Employee employee = new Employee();
        employee.setNo(1L);
        employee.setName("yogesh");


        BasicDBObject basicDBObject = new BasicDBObject("Name", employee);

        DBCollection dbCollection = db.getCollection("NameColl");

        dbCollection.save(basicDBObject);   

    }

}

有人可以解释我收到此错误的原因吗？

Answer 1

我有点困惑，为什么你认为这首先起作用。有些东西需要知道如何将POJO映射到MongoDB文档。目前你没有告诉系统的任何部分如何做到这一点。

您可以使用映射库（Morphia浮现）或使用ReflectionDBObject。两种解决方案（前者比后者更好）允许您将POJO映射到MongoDB文档并返回。

Answer 2

亲你可以继续使用强类型对象

魂斗罗
有些人真的不喜欢：延伸


package foo;
import com.mongodb.BasicDBObject;

public class Employee extends BasicDBObject {

private static final long serialVersionUID = 2105061907470199595L;
//should be something shorter as "name" like "n" 
//here just use name to conform your  sample
public static final String NAME = "name";
public static final String NO = "no";
public static final String COLLECTION_NAME = "employee";

public Long getNo() {
    return getLong(NO);
}

public void setNo(long no) {
    put(NO, no);
}

public String getName() {
    return getString(NAME);
}

public void setName(String name) {
    put(NAME, name);
}


}

private static final long serialVersionUID = 2105061907470199595L;
//should be something shorter as "name" like "n" 
//here just use name to conform your  sample
public static final String NAME = "name";
public static final String NO = "no";
public static final String COLLECTION_NAME = "employee";

public Long getNo() {
    return getLong(NO);
}

public void setNo(long no) {
    put(NO, no);
}

public String getName() {
    return getString(NAME);
}

public void setName(String name) {
    put(NAME, name);
}

除了吗啡，你应该看看 jongo： http://jongo.org/ jongo使用与js mongo引擎相同的表单语法，我发现它对初学者来说很有意义。您不必在mongojs和java之间切换思维导图。你可以使用js样本，几乎没有变化。

Answer 3

DB db = mongoClient.getDB( "mydb" );

coll = db.getCollection("testCollection");

Employee emp = new Employee();
emp.setId("1001");
emp.setName("John Doe");

//Converting a custom Class(Employee) to BasicDBObject
Gson gson = new Gson();
BasicDBObject obj = (BasicDBObject)JSON.parse(gson.toJson(emp));
coll.insert(obj);
findEmployee(new BasicDBObject("id","1001"));


public static void findEmployee(BasicDBObject query){

    DBCursor cursor = coll.find(query);

    try {
       while(cursor.hasNext()) {
          DBObject dbobj = cursor.next();
        //Converting BasicDBObject to a custom Class(Employee)
          Employee emp = (new Gson()).fromJson(dbobj.toString(), Employee.class);
          System.out.println(emp.getName());
       }
    } finally {
       cursor.close();
    }

}

我认为发布双向转换的代码会很有用存储员工对象
查找并重新创建员工对象
希望这很有用..

Answer 4

您可以使用gson library将java对象转换为json字符串，然后将其插入mongodb。

例如：

Gson gson = new Gson();
String json = gson.toJson(Employee);    
BasicDBObject basicDBObject = new BasicDBObject("Name", json );          
DBCollection dbCollection = db.getCollection("NameColl");          
dbCollection.save(basicDBObject);

Answer 5

使用MongoDB，您无法在数据库中插入Java bean，但必须将它们重新映射到MongoDB对象。

在你的情况下你必须这样做：

BasicDBObject basicDBObject = new BasicDBObject();
basicDBObject.put("no", employee.getNo());
basicDBObject.put("name", employee.getName());

Answer 6

自提出此问题以来，已经有一些变化。在问题中使用test.java，以下是使用Google Gson对我有用的内容：

import com.google.gson.Gson;
import com.mongodb.Block;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;

public class test {
  public static void main(String[] args) {
    MongoClient mongoClient = new MongoClient(); // Connect with default settings i.e. localhost:27017
    MongoDatabase db = mongoClient.getDatabase("test"); // Get database "test". Creates one if it doesn't exist
    Employee employee = new Employee(); // Create java object
    employee.setNo(1L);
    employee.setName("yogesh");
    // Deserialize object to json string
    Gson gson = new Gson();
    String json = gson.toJson(employee);
    // Parse to bson document and insert
    Document doc = Document.parse(json);
    db.getCollection("NameColl").insertOne(doc);

    // Retrieve to ensure object was inserted
    FindIterable<Document> iterable = db.getCollection("NameColl").find();
    iterable.forEach(new Block<Document>() {
      @Override
      public void apply(final Document document) {
        System.out.println(document); // See below to convert document back to Employee
      }
    });

  }
}

您还可以使用Gson将检索到的bson文档转换回Java对象：

Gson gson = new Gson();
Employee emp = gson.fromJson(document.toJson(), Employee.class);

Answer 7

强烈推荐MongoJack，一个将Java对象映射到MongoDB文档/从MongoDB文档映射的合适库。

代码如下所示：

import java.util.Arrays;
import org.mongojack.JacksonDBCollection;
import com.mongodb.DB;
import com.mongodb.MongoClient;
import com.mongodb.ServerAddress;

public class Test {

    public static void main(String[] args) {

        MongoClient mongoClient = new MongoClient(Arrays.asList(new ServerAddress("localhost", 27017)));
        DB db = mongoClient.getDB("test");

        Employee employee = new Employee();
        employee.setNo(1L);
        employee.setName("yogesh");

        JacksonDBCollection<Employee, String> collectionData = JacksonDBCollection.wrap(db.getCollection("NameColl"), Employee.class, String.class);
        collectionData.save(employee);
        mongoClient.close();
    }

}

（PS：目前我使用的是mongo-java-driver v3.2.2和mongojack v2.6.1）

Answer 8

使用BasicDBObjectBuilder将您的POJO转换为DBObject可以保存的DBCollection个实例：

import com.mongodb.BasicDBObjectBuilder;
import com.mongodb.DBObject;

public class Employee {
    private long no;
    private String name;

    // Getters and Setters

    public DBObject toDBObject() {
        BasicDBObjectBuilder builder = BasicDBObjectBuilder
                .start("no", no)
                .append("name", name);
        return builder.get();
    }
}

为了保存，只需在POJO实例上调用toDBObject()并将其提供给集合：

public class test {

    public static void main(String[] args) throws UnknownHostException,
            MongoException {
        ...
        DBCollection dbCollection = db.getCollection("NameColl");

        Employee employee = new Employee();
        employee.setNo(1L);
        employee.setName("yogesh");

        dbCollection.save(employee.toDBObject());
    }
}

使用这种方法：

您无需每次都手动创建DBObject
你不需要通过扩展Mongo类来搞乱你的POJO（如果你的POJO已经扩展了一个类怎么办？）
您不需要Json映射器[及其在POJO字段上的注释]
你只依赖于java-mongo-driver jar

Answer 9

希望这对您有用，您可以从中获得帮助。我执行了数据库操作（插入，删除，更新，获取，getall），并使用Person对象在带有Java的MongoDB中进行了演示。

数据库连接类

Connection.java

package test;
import org.bson.codecs.configuration.CodecRegistry;
import org.bson.codecs.pojo.PojoCodecProvider;
import static org.bson.codecs.configuration.CodecRegistries.fromProviders;
import static org.bson.codecs.configuration.CodecRegistries.fromRegistries;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.client.MongoDatabase;

public class Connection {
    public MongoClient mongo;
    private String db;
    public MongoDatabase database;
    private static Connection instance;

    private Connection() {
        db = "chatsystem";
        CodecRegistry pojoCodecRegistry = fromRegistries(MongoClient.getDefaultCodecRegistry(),
                fromProviders(PojoCodecProvider.builder().automatic(true).build()));
        mongo = new MongoClient("localhost", MongoClientOptions.builder().codecRegistry(pojoCodecRegistry).build());
        database = mongo.getDatabase(db);

    }

    public static Connection getInstance() {
        if (instance == null) {
            instance = new Connection();
            return instance;
        } else {
            return instance;
        }
    }

}

模型类

Person.java

package test;

import org.bson.types.ObjectId;

public class Person {

    public Person() {
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getEmail() {
        return email;
    }

    public void setEmail(String email) {
        this.email = email;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public String getFname() {
        return fname;
    }

    public void setFname(String fname) {
        this.fname = fname;
    }

    public String getLname() {
        return lname;
    }

    public void setLname(String lname) {
        this.lname = lname;
    }

    private ObjectId id;

    public Person(String username, String email, String password, String fname, String lname) {
        super();
        this.username = username;
        this.email = email;
        this.password = password;
        this.fname = fname;
        this.lname = lname;
    }

    public ObjectId getId() {
        return id;
    }

    public void setId(ObjectId id) {
        this.id = id;
    }

    private String username;
    private String email;
    private String password;
    private String fname;
    private String lname;
}

主班

test.java

package test;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import static com.mongodb.client.model.Filters.*;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;

public class test {
    private MongoCollection<Person> person;
    Connection conn;
    public void getCollection() {
        conn = Connection.getInstance();
        person = conn.database.getCollection("person", Person.class);
    }
    public static void main(String[] args) throws Exception {
        test t = new test();
        t.getCollection();
        Person p = new Person();
        p.setEmail("test@test.com");
        p.setFname("ftest");
        p.setLname("ltest");
        p.setPassword("testtest");
        p.setUsername("test123");


        // insert person type objects in database
        t.insertPerson(p);


        // get all persons from database
        List<Person> pp = t.getAllPersons();
        Person pt = pp.get(0);
        System.out.println(pt.getEmail());
        System.out.println(pt.getId());


        // get one person from database by username filter

                 // pass username of person in method argument
        Person ph = t.getOnePerson("test123");
        System.out.println(ph.getEmail());
        System.out.println(ph.getId());


        // update/edit person by username filter
                // pass username of person in method argument
        t.updatePerson("test123");


        // delete person by username filter
               // pass username of person in method argument
        t.removePerson("updatetest123");

    }

    public void insertPerson(Person p) {

        person.insertOne(p);
    }

    public List<Person> getAllPersons() {
        FindIterable<Person> iterable = person.find();
        Iterator it = iterable.iterator();
        List<Person> allPersons = new ArrayList<>();
        while (it.hasNext()) {
            Person per = (Person) it.next();
            allPersons.add(per);
        }
        return allPersons;
    }

    public Person getOnePerson(String username) {
        return person.find(eq("username", username)).first();
    }

    public void updatePerson(String username) {
        Person p = new Person();
        p.setEmail("update@test.com");
        p.setFname("updateftest");
        p.setLname("updateltest");
        p.setPassword("updatetesttest");
        p.setUsername("updatetest123");
        person.replaceOne(eq("username", username), p);

    }

    public void removePerson(String username) {
        person.deleteOne(eq("username", username));
    }



}

Answer 10

当我尝试将java BasicDBObject插入MongoDb集合时，我遇到了同样的错误。

我的对象是从转换为Json的Xml创建的。

java.lang.IllegalArgumentException: can't serialize class net.sf.json.JSONNull
    at org.bson.BasicBSONEncoder._putObjectField(BasicBSONEncoder.java:299)
    at org.bson.BasicBSONEncoder.putMap(BasicBSONEncoder.java:339)
    at org.bson.BasicBSONEncoder._putObjectField(BasicBSONEncoder.java:261)

此错误是由Xml中的空标记引起的;当我删除所有空标签时，我解决了它。

Answer 11

仅使用“ insertOne”方法，而不保存。

    MongoCollection collection;
    String collectionName = "somename";
    String jsonObject = "{}";

    if (!mongoTemplate.collectionExists(collectionName)) {
        collection = mongoTemplate.createCollection(collectionName);
        logger.info("Collection %s was successfully created", collectionName);
    } else {
        collection = mongoTemplate.getCollection(collectionName);
    }

    collection.insertOne(Document.parse(jsonObject));

Answer 12

因为没有人提到它 - 我认为使用 bson4jackson 可能有一个解决方案。这自称为快速编码器。

使用Java将Java对象插入MongoDB集合

12 个答案: