Java를 사용하여 Java 객체를 MongoDB 컬렉션에 삽입
자바를 사용하여 전체 자바 객체를 MongoDB Collection에 삽입하려고 합니다.다음 오류가 발생합니다.
오류:
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)
엠플리오이.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);
}
}
이 오류가 발생하는 이유를 설명할 수 있는 사람이 있습니까?
애초에 왜 이것이 효과가 있을 거라고 생각하시는지 저는 조금 혼란스럽습니다.가장 먼저 알아야 할 것은 POJO를 MongoDB 문서에 매핑하는 방법입니다.현재 시스템(코드)에 이 작업을 수행하는 방법을 알려주지 않습니다.
이에 대한 매핑 라이브러리(Morphia가 떠오름)를 사용하거나 ReflectionDBObject를 사용할 수 있습니다.두 솔루션 모두 POJO를 MongoDB 문서에 매핑하거나 MongoDB 문서를 POJO에 매핑할 수 있습니다(전자 방식이 후자보다 훨씬 더 좋습니다).
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();
}
}
저는 양방향으로 변환하는 코드를 게시하는 것이 유용할 것이라고 생각했습니다.
직원 개체 저장
직원 개체 찾기 및 다시 만들기
이것이 유용하기를 바랍니다.
프로
당신은 당신이 원하는 대로 강력한 유형의 물체를 계속 사용합니다.
콘트라
어떤 사람들은 정말 싫어합니다 : 확장.
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);
}
}
package foo;
import java.net.UnknownHostException;
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("yeahMongo");
Employee employee = new Employee();
employee.setNo(1L);
employee.setName("yogesh");
DBCollection employeeCollection = null ;
employeeCollection = db.getCollection(Employee.COLLECTION_NAME);
employeeCollection.save(employee);
System.err.println(employeeCollection.findOne());
}
}
morphia 외에도 jongo를 살펴봐야 합니다: http://jongo.org/ jongo는 jsmongo 엔진과 동일한 형태의 구문을 사용하며, 초보자에게 좋은 포인트를 발견했습니다.당신은 mongojs와 java 사이에서 당신의 마인드 맵을 바꿀 필요가 없습니다.당신은 약간의 변화 없이 js 샘플을 사용할 수 있습니다.
gson 라이브러리를 사용하여 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);
이 질문을 한 이후로 몇 가지 변경 사항이 있습니다.사용.test.java질문에서, 여기 구글의 제품을 사용하는 데 도움이 된 것이 있습니다.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);
MongoDB를 사용하면 Java bean을 DB에 삽입할 수 없지만 MongoDB Object에 다시 매핑해야 합니다.
귀하의 경우 다음을 수행해야 합니다.
BasicDBObject basicDBObject = new BasicDBObject();
basicDBObject.put("no", employee.getNo());
basicDBObject.put("name", employee.getName());
이것이 당신에게 효과가 있기를 바라며 당신은 그것으로부터 도움을 받을 수 있습니다.데이터베이스 작업(insert, delete, update, get, getall)을 수행하고 데모 목적으로 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;
}
}
}
- 모델 클래스
인물.자바
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;
}
- 메인클래스
시험을 보다
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));
}
}
Java 객체를 MongoDB 문서에 매핑하거나 MongoDB 문서에서 매핑할 수 있는 괜찮은 라이브러리인 MongoJack을 적극 추천합니다.
코드는 다음과 같습니다.
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을 사용하고 있습니다.)
BasicDB Object Builder를 사용하여 POJO를 DB Collection이 저장할 수 있는 DBObject 인스턴스로 변환합니다.
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();
}
}
저장하려면, 그냥 전화하세요.toDBObject()POJO 인스턴스에서 수집에 제공합니다.
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에 대한 종속성만 있습니다.
Java BasicDB Object를 MongoDb Collection에 삽입하려고 할 때 동일한 오류가 발생합니다.
내 객체는 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의 빈 태그로 인해 발생합니다. 모든 빈 태그를 제거한 후 해결했습니다.
저장이 아니라 "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));
아무도 언급하지 않았기 때문에 - bson4jackson을 사용하여 해결책이 있을 수 있다고 생각합니다.이것은 자체적으로 빠른 인코더로 청구됩니다.
언급URL : https://stackoverflow.com/questions/10170506/inserting-java-object-to-mongodb-collection-using-java
'programing' 카테고리의 다른 글
| Firebase FCM 사용 제한 (0) | 2023.06.26 |
|---|---|
| 셸 스크립트에서 sqlplus를 실행하는 동안 오류 처리 관리 (0) | 2023.06.26 |
| 워크북을 전역 변수로 선언 (0) | 2023.06.26 |
| UI이미지를 NSData로 변환 (0) | 2023.06.26 |
| Postgresql에서 "대소문자를 구분하지 않는" 쿼리를 만드는 방법은 무엇입니까? (0) | 2023.06.26 |