1.新增功能。
2.删除username为cang的人
3.删除age大于8小于25的人
4.修改username为chen的age为8
5.给喜爱东京的人也爱好小电影2和小电影3
- db.users.updateOne({“username”:“lison”,},
{
“$push”: {
“comments”: {
$each: [
{
“author” : “james”,
“content” : “lison是个好老师!”,
“commentTime” : ISODate(“2018-01-06T04:26:18.354Z”)
}
],
KaTeX parse error: Expected 'EOF', got '}' at position 33: …me":-1} }̲ } …sort运算符进行排序,插入评论后,再按照评论时间降序排序;
7.查看人员时加载最新的三条评论;
db.users.find({“username”:“lison”},{“comments”:{"$slice":[0,3]}}).pretty()
8.点击评论的下一页按钮,新加载三条评论
db.users.find({“username”:“lison”},{“comments”:{“KaTeX parse error: Expected 'EOF', got '}' at position 13: slice":[3,3]}̲,"id”:1}).pretty();
9.查询总共有多少数据
10.查询喜好城市为东莞和东京的人
11.查询username中含有“s”,country为“English”或"USA"
12.db.users.find({“username”:“lison”},{“comments”:{“KaTeX parse error: Expected 'EOF', got '}' at position 13: slice":[0,3]}̲,"id”:1}).pretty();
13.db.users.aggregate([{“KaTeX parse error: Expected 'EOF', got '}' at position 28: …rname":"lison"}}̲, …unwind”:“KaTeX parse error: Expected 'EOF', got '}' at position 10: comments"}̲, …sort:{“comments.commentTime”:-1}},
{“KaTeX parse error: Expected 'EOF', got '}' at position 24: …:{"comments":1}}̲, …skip”:6},
{”$limit":3}])
如果有多种排序需求怎么处理?使用聚合
14.DbRef查询
15.db.users.update({"":""},{“username”:“leilei”},{“upsert”:true})
16.db.users.updateMany({“username”:“lison”},{“KaTeX parse error: Expected 'EOF', got '}' at position 31: …y":"","age":""}}̲) 17.db.users.u…rename”:{“country”:“guojia”,“age”:“nianling”}})
18.db.users.updateMany({ “username” : “jack”}, { “KaTeX parse error: Expected '}', got 'EOF' at end of input: …s.movies" : { "each” : [ “小电影2 " , “小电影3”]}}})
19.db.users.updateMany({ “username” : “jack”}, { “KaTeX parse error: Expected 'EOF', got '}' at position 55: …影2 " , "小电影3"]}}̲) 20.db.users.u…push”:{“comments”:{“author”:“lison23”,“content”:“ydddyyytttt”}}})
21.db.users.updateOne({“username”:“jack”},
{“KaTeX parse error: Expected '}', got 'EOF' at end of input: … {"each”:[{“author”:“lison22”,“content”:“yyyytttt”},
{“author”:“lison23”,“content”:“ydddyyytttt”}]}}})
22.db.users.updateOne({“username”:“jack”},
{“KaTeX parse error: Expected '}', got 'EOF' at end of input: … {"each”:[ {“author”:“lison22”,“content”:“yyyytttt”},
{“author”:“lison23”,“content”:“ydddyyytttt”} ],
KaTeX parse error: Expected 'EOF', got '}' at position 20: …: {"author":1} }̲ } }) 23.db.use…pull”:{“comments”:{“author”:“lison22”}}})
24.db.users.update({“username”:“lison”},
{“KaTeX parse error: Expected 'EOF', got '}' at position 131: …ison是苍老师的小迷弟"}}}̲) 25.db.users.u…set”:{“comments.
.
c
o
n
t
e
n
t
"
:
"
x
x
o
o
"
,
"
c
o
m
m
e
n
t
s
.
.content":"xxoo", "comments.
.content":"xxoo","comments..author”:“lison10” }})
注意:本文用的数据脚本和详细代码在git仓库上:https://github.com/shidebin/mongodb/tree/master/java-pojo
doc形式:
package com.shidebin.mongodb.java_pojo;
import static com.mongodb.client.model.Filters.eq;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.bson.Document;
import org.bson.conversions.Bson;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.mongodb.core.query.Update;
import com.mongodb.Block;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.ServerAddress;
import com.mongodb.WriteConcern;
import com.mongodb.client.AggregateIterable;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Aggregates;
import com.mongodb.client.model.Filters;
import com.mongodb.client.model.FindOneAndUpdateOptions;
import com.mongodb.client.model.Projections;
import com.mongodb.client.model.PushOptions;
import com.mongodb.client.model.ReturnDocument;
import com.mongodb.client.model.Sorts;
import com.mongodb.client.model.UpdateOptions;
import com.mongodb.client.model.Updates;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import com.mongodb.operation.UpdateOperation;
public class JavaDocTest {
private static final Logger logger = LoggerFactory.getLogger(JavaDocTest.class);
private MongoClient client;
private MongoDatabase database;
private MongoCollection<Document> collection;
@Before
public void init() {
// MongoClientOptions mco = MongoClientOptions.builder()
// .writeConcern(WriteConcern.ACKNOWLEDGED)
// .connectionsPerHost(100)
// .threadsAllowedToBlockForConnectionMultiplier(5)
// .maxWaitTime(120000).connectTimeout(10000).build();
// client = new MongoClient(new ServerAddress("192.168.126.128",27022),mco);
client = new MongoClient("192.168.126.128",27022);
database = client.getDatabase("lison");
collection = database.getCollection("users");
}
@Test
public void insert() {
Document doc1 = new Document();
doc1.append("username", "cang");
doc1.append("country", "USA");
doc1.append("age", 20);
doc1.append("lenght", 1.77f);
doc1.append("salary", new BigDecimal("6565.22"));
Map<String, String> address1 = new HashMap<String, String>();
address1.put("aCode", "0000");
address1.put("add", "xxx000");
doc1.append("address", address1);
Map<String, Object> favorites1 = new HashMap<String, Object>();
favorites1.put("movies", Arrays.asList("aa","bb"));
favorites1.put("cites", Arrays.asList("东莞","东京"));
doc1.append("favorites", favorites1);
Document doc2 = new Document();
doc2.append("username", "chen");
doc2.append("country", "China");
doc2.append("age", 30);
doc2.append("lenght", 1.77f);
doc2.append("salary", new BigDecimal("8888.22"));
Map<String, String> address2 = new HashMap<String, String>();
address2.put("aCode", "411000");
address2.put("add", "我的地址2");
doc1.append("address", address2);
Map<String, Object> favorites2 = new HashMap<String, Object>();
favorites2.put("movies", Arrays.asList("东游记","一路向东"));
favorites2.put("cites", Arrays.asList("珠海","东京"));
doc2.append("favorites", favorites2);
collection.insertMany(Arrays.asList(doc1,doc2));
}
@Test
public void delete() {
//删除username为cang的人
DeleteResult result = collection.deleteMany(Filters.eq("username", "cang"));
logger.info("删除的数量:"+result.getDeletedCount());
//删除age大于8小于25的人
long count = collection.count(Filters.and(Filters.lt("age", 25),Filters.gt("age", 8)));
logger.info("age大于8小于25的人:"+count);
DeleteResult result2 = collection.deleteMany(Filters.and(Filters.gt("age", 8),Filters.lt("age", 25)));
logger.info("删除的数量2:"+result2.getDeletedCount());
}
@Test
public void update() {
//修改username为chen的age为8
UpdateResult result = collection.updateMany(Filters.eq("username", "chen"), Updates.set("age", 8));
logger.info("修改的数量:"+result.getModifiedCount());
//给喜爱东京的人也爱好小电影2和小电影3
UpdateResult result2 = collection.updateMany(Filters.eq("favorites.cites", "东京"),
Updates.addEachToSet("favorites.movies", Arrays.asList("小电影2","小电影3")));
logger.info("修改的数量2:"+result2.getModifiedCount());
}
/**
* db.users.updateOne({"username":"lison",},
{
"$push": {
"comments": {
$each: [
{
"author" : "james",
"content" : "lison是个好老师!",
"commentTime" : ISODate("2018-01-06T04:26:18.354Z")
}
],
$sort: {"commentTime":-1}
}
}
}
);
新增评论时,使用$sort运算符进行排序,插入评论后,再按照评论时间降序排序;
*/
@Test
public void update1() {
Document doc = new Document().append("author", "james").append("content", "lison是个好老师!").
append("commentTime", new Date());
PushOptions sortDocument = new PushOptions().sortDocument(new Document().append("commentTime", -1));
Bson pushEach = Updates.pushEach("comments", Arrays.asList(doc), sortDocument);
UpdateResult updateOne = collection.updateOne(Filters.eq("username", "lison"),pushEach);
System.out.println("++++++++++"+updateOne.getModifiedCount());
}
@Test
/**
* db.users.update({"":""},{"username":"leilei"},{"upsert":true})
*/
public void update3() {
UpdateOptions upsert = new UpdateOptions().upsert(true);
UpdateResult updateOne = collection.updateOne(Filters.eq("username", ""),Updates.setOnInsert("username", "leilei"),upsert);
System.out.println("++++++++++"+updateOne.getModifiedCount());
}
/**
* db.users.updateMany({"username":"lison"},{"$unset":{"country":"","age":""}})
*/
@Test
public void update4() {
UpdateResult updateMany = collection.updateMany(Filters.eq("username", "lison"),
Updates.combine(Updates.unset("country"),Updates.unset("age")));
System.out.println("++++++++++"+updateMany.getModifiedCount());
}
/**
* db.users.updateMany({"username":"jack"},{"$rename":{"country":"guojia","age":"nianling"}})
*/
@Test
public void update5() {
UpdateResult updateMany = collection.updateMany(Filters.eq("username", "jack"),
Updates.combine(Updates.rename("country", "guojia"),Updates.rename("age", "nianling")));
System.out.println("++++++++++"+updateMany.getModifiedCount());
}
/**
* db.users.updateMany({ "username" : "jack"}, { "$addToSet" : { "favorites.movies" : { "$each" : [ "小电影2 " , "小电影3"]}}})
*/
@Test
public void updat6() {
UpdateResult updateMany = collection.updateMany(Filters.eq("username", "jack"),
Updates.addEachToSet("favorites.movies", Arrays.asList("小电影2 " , "小电影3")));
System.out.println("++++++++++"+updateMany.getModifiedCount());
}
/**
* db.users.updateMany({ "username" : "jack"}, { "$pull" : { "favorites.movies" : [ "小电影2 " , "小电影3"]}})
*/
@Test
public void update7() {
UpdateResult updateMany = collection.updateMany(Filters.eq("username", "jack"),
Updates.pullAll("favorites.movies", Arrays.asList("小电影2 " , "小电影3")));
System.out.println("++++++++++"+updateMany.getModifiedCount());
}
/**
* db.users.updateOne({"username":"jack"},
* {"$push":{"comments":{"author":"lison23","content":"ydddyyytttt"}}})
*/
@Test
public void update8() {
Document document = new Document();
document.append("author", "lison23");
document.append("content", "ydddyyytttt");
UpdateResult updateOne = collection.updateOne(Filters.eq("username", "jack"), Updates.push("comments", document));
System.out.println("++++++++++"+updateOne.getModifiedCount());
}
/**
* db.users.updateOne({"username":"jack"},
{"$push":{"comments":
{"$each":[{"author":"lison21","content":"yyyytttt"},
{"author":"lison22","content":"ydddyyytttt"}]}}})
*/
@Test
public void update9() {
Document document = new Document();
document.append("author", "lison21");
document.append("content", "ydddyyytttt");
Document document2 = new Document();
document2.append("author", "lison22");
document2.append("content", "ydddyyytttt");
UpdateResult updateOne = collection.updateOne(Filters.eq("username", "jack"),
Updates.pushEach("comments", Arrays.asList(document,document2)));
System.out.println("++++++++++"+updateOne.getModifiedCount());
}
/**
* db.users.updateOne({"username":"jack"},
{"$push": {"comments":
{"$each":[ {"author":"lison24","content":"yyyytttt"},
{"author":"lison25","content":"ydddyyytttt"} ],
$sort: {"author":1} } } })
*/
@Test
public void update10() {
Document document = new Document();
document.append("author", "lison24");
document.append("content", "ydddyyytttt");
Document document2 = new Document();
document2.append("author", "lison25");
document2.append("content", "ydddyyytttt");
PushOptions sortDocument = new PushOptions().sortDocument(Sorts.ascending("author"));
UpdateResult updateOne = collection.updateOne(Filters.eq("username", "jack"),
Updates.pushEach("comments", Arrays.asList(document,document2),sortDocument));
System.out.println("++++++++++"+updateOne.getModifiedCount());
}
/**
* db.users.update({"username":"jack"},
{"$pull":{"comments":{"author":"lison22"}}})
*/
@Test
public void update11() {
Document document = new Document();
document.append("author", "lison22");
UpdateResult updateMany = collection.updateMany(Filters.eq("username", "jack"),
Updates.pull("comments",document));
System.out.println("++++++++++"+updateMany.getModifiedCount());
}
/**
* db.users.update({"username":"lison"},
{"$pull":{"comments":{"author":"lison5",
"content":"lison是苍老师的小迷弟"}}})
*/
@Test
public void update12() {
Document doc = new Document();
doc.append("author", "lison5");
doc.append("content", "lison是苍老师的小迷弟");
UpdateResult updateOne = collection.updateOne(Filters.eq("username", "lison"),
Updates.pull("comments", doc));
System.out.println("++++++++++"+updateOne.getModifiedCount());
}
/**
* db.users.updateMany({"username":"jack","comments.author":"lison1"},
{"$set":{"comments.$.content":"xxoo",
"comments.$.author":"lison10" }})
*/
@Test
public void update13() {
UpdateResult updateMany = collection.updateMany(Filters.and(Filters.eq("username", "jack"),Filters.eq("comments.author", "lison16")),
Updates.combine(Updates.set("comments.$.content", "xxoo"),
Updates.set("comments.$.author", "lison10")));
// Document doc = new Document();
// doc.append("content","xxoo");
// doc.append("author", "lison10");
// UpdateResult updateMany = collection.updateMany(Filters.and(Filters.eq("username", "jack"),Filters.eq("comments.author", "lison16")),
// Updates.set("comments", doc));
System.out.println("++++++++++"+updateMany.getModifiedCount());
}
/**
* db.users.findAndModify({{"username":"json","comments.author":"lison1"},
{"$set":{"comments.$.content":"xxoo",
"comments.$.author":"lison10" }},"new":true})
*/
@Test
public void update14() {
Document findOneAndUpdate = collection.findOneAndUpdate(Filters.and(Filters.eq("username", "lison"),Filters.eq("comments.author", "lison2")),
Updates.combine(Updates.set("comments.$.content", "xxoo2"),
Updates.set("comments.$.author", "lison12")),new FindOneAndUpdateOptions().returnDocument(ReturnDocument.AFTER));
System.out.println("++++++++++"+findOneAndUpdate.toJson());
}
/**
* 查看人员时加载最新的三条评论;
db.users.find({"username":"lison"},{"comments":{"$slice":[0,3]}}).pretty()
*/
@Test
public void query2() {
FindIterable<Document> projection = collection.find(Filters.eq("username", "lison")).
projection(Projections.slice("comments", 0, 3));
Block<Document> block = getBlock();
forEach(projection,block);
}
/**
* 点击评论的下一页按钮,新加载三条评论
db.users.find({"username":"lison"},{"comments":{"$slice":[3,3]},"$id":1}).pretty();
*/
@Test
public void query3() {
Bson slice = Projections.slice("comments", 3, 3);
Bson include = Projections.include("$id");
FindIterable<Document> projection = collection.find(Filters.eq("username", "lison")).
projection(Projections.fields(slice,include));
Block<Document> block = getBlock();
forEach(projection,block);
}
@Test
public void query() {
//查询总共有多少数据
logger.info("总共有多少数据:"+collection.count());
//查询喜好城市为东莞和东京的人
/*FindIterable<Document> result = collection.find(Filters.and(Filters.eq("favorites.cites","东莞"),
Filters.eq("favorites.cites","东京")));*/
FindIterable<Document> result = collection.find(Filters.all("favorites.cites", "东京","东莞"));
@SuppressWarnings("unchecked")
Block<Document> block = new Block() {
@Override
public void apply(Object t) {
logger.info(t.toString());
}
};
result.forEach(block);
//查询username中含有“s”,country为“English”或"USA"
FindIterable<Document> result2 = collection.find(Filters.and(Filters.regex("username", ".*s.*"),
Filters.in("country", "English","USA")));
result2.forEach(block);
//db.users.find({"username":"lison"},{"comments":{"$slice":[0,3]},"$id":1}).pretty();
FindIterable<Document> result3 = collection.find(Filters.eq("username", "lison"))
.projection(Projections.fields(Projections.include("$id"),Projections.slice("comments", 0, 3)));
result3.forEach(block);
FindIterable<Document> result4 = collection.find(Filters.eq("username", "lison"))
.projection(Projections.fields(Projections.include("$id"),Projections.slice("comments", 3, 3)));
result4.forEach(block);
}
/**
* db.users.aggregate([{"$match":{"username":"lison"}},
{"$unwind":"$comments"},
{$sort:{"comments.commentTime":-1}},
{"$project":{"comments":1}},
{"$skip":6},
{"$limit":3}])
如果有多种排序需求怎么处理?使用聚合
*/
@Test
public void query1() {
Block<Document> block = new Block<Document>() {
@Override
public void apply(Document t) {
logger.info(t.toJson());
}
};
AggregateIterable<Document> aggregate = collection.aggregate(Arrays.asList(Aggregates.match(Filters.eq("username", "lison")),
Aggregates.unwind("$comments"),Aggregates.sort(Sorts.descending("commentTime")),
Aggregates.project(Projections.include("comments")),Aggregates.skip(6),Aggregates.limit(3)));
aggregate.forEach(block);
}
//测试DbRef
@Test
public void test() {
Block<Document> block = new Block<Document>() {
@Override
public void apply(Document t) {
logger.info("---------------------");
// logger.info(t.toJson());
Object object = t.get("comments");
System.out.println(object);
logger.info("---------------------");
}
};
FindIterable<Document> find = collection.find(Filters.eq("username", "lison"));
find.forEach(block);
}
public Block<Document> getBlock(){
return new Block<Document>() {
@Override
public void apply(Document t) {
logger.info(t.toJson());
}
};
}
public void forEach(FindIterable<Document> projection,Block<Document> block) {
projection.forEach(block);
}
}
注意:如何发现连不上远程mongodb,请查看另一篇文章。
pojo形式:
package com.shidebin.mongodb.java_pojo;
import static com.mongodb.client.model.Filters.all;
import static com.mongodb.client.model.Filters.and;
import static com.mongodb.client.model.Filters.eq;
import static com.mongodb.client.model.Filters.gt;
import static com.mongodb.client.model.Filters.lt;
import static com.mongodb.client.model.Filters.or;
import static com.mongodb.client.model.Filters.regex;
import static com.mongodb.client.model.Updates.addEachToSet;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import org.bson.Document;
import org.bson.codecs.configuration.CodecRegistries;
import org.bson.codecs.configuration.CodecRegistry;
import org.bson.codecs.pojo.PojoCodecProvider;
import org.bson.conversions.Bson;
import org.junit.Before;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import com.dongnao.mongo.entity.Address;
import com.dongnao.mongo.entity.Favorites;
import com.dongnao.mongo.entity.User;
import com.mongodb.Block;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.ServerAddress;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
//原生java驱动 Pojo的操作方式
public class QuickStartJavaPojoTest {
private static final Logger logger = LoggerFactory.getLogger(QuickStartJavaPojoTest.class);
private MongoDatabase db;
private MongoCollection<User> doc;
private MongoClient client;
@Before
public void init(){
//编解码器的list
List<CodecRegistry> codecResgistes = new ArrayList<CodecRegistry>();
//编解码器的list加入默认的编解码器结合
codecResgistes.add(MongoClient.getDefaultCodecRegistry());
//生成一个pojo的编解码器
CodecRegistry pojoProviders = CodecRegistries.
fromProviders(PojoCodecProvider.builder().automatic(true).build());
codecResgistes.add(pojoProviders);
//通过编解码器的list生成编解码器注册中心
CodecRegistry registry = CodecRegistries.fromRegistries(codecResgistes);
//把编解码器注册中心放入MongoClientOptions
MongoClientOptions build = MongoClientOptions.builder().
codecRegistry(registry).build();
ServerAddress serverAddress = new ServerAddress("192.168.126.128",27022);
client = new MongoClient(serverAddress, build);
db =client.getDatabase("lison");
doc = db.getCollection("users",User.class);
}
@Test
public void insertDemo(){
User user = new User();
user.setUsername("cang");
user.setCountry("USA");
user.setAge(20);
user.setLenght(1.77f);
user.setSalary(new BigDecimal("6265.22"));
Address address1 = new Address();
address1.setaCode("411222");
address1.setAdd("sdfsdf");
user.setAddress(address1);
Favorites favorites1 = new Favorites();
favorites1.setCites(Arrays.asList("东莞","东京"));
favorites1.setMovies(Arrays.asList("西游记","一路向西"));
user.setFavorites(favorites1);
User user1 = new User();
user1.setUsername("chen");
user1.setCountry("China");
user1.setAge(30);
user1.setLenght(1.77f);
user1.setSalary(new BigDecimal("6885.22"));
Address address2 = new Address();
address2.setaCode("411000");
address2.setAdd("我的地址2");
user1.setAddress(address2);
Favorites favorites2 = new Favorites();
favorites2.setCites(Arrays.asList("珠海","东京"));
favorites2.setMovies(Arrays.asList("东游记","一路向东"));
user1.setFavorites(favorites2);
doc.insertMany(Arrays.asList(user,user1));
}
//@Test
public void testDelete(){
//delete from users where username = ‘lison’
DeleteResult deleteMany = doc.deleteMany(eq("username", "lison"));
logger.info(String.valueOf(deleteMany.getDeletedCount()));
//delete from users where age >8 and age <25
DeleteResult deleteMany2 = doc.deleteMany(and(gt("age",8),lt("age",25)));
logger.info(String.valueOf(deleteMany2.getDeletedCount()));
}
//@Test
public void testUpdate(){
//update users set age=6 where username = 'lison'
UpdateResult updateMany = doc.updateMany(eq("username", "lison"),
new Document("$set",new Document("age",6)));
logger.info(String.valueOf(updateMany.getModifiedCount()));
//update users set favorites.movies add "小电影2 ", "小电影3" where favorites.cites has "东莞"
UpdateResult updateMany2 = doc.updateMany(eq("favorites.cites", "东莞"),
addEachToSet("favorites.movies", Arrays.asList( "小电影2 ", "小电影3")));
logger.info(String.valueOf(updateMany2.getModifiedCount()));
}
//@Test
public void testFind(){
final List<User> ret = new ArrayList<>();
Block<User> printBlock = new Block<User>() {
@Override
public void apply(User t) {
// logger.info();
System.out.println(t.getUsername());
System.out.println(t.getSalary());
ret.add(t);
}
};
//select * from users where favorites.cites has "东莞"、"东京"
FindIterable<User> find = doc.find(all("favorites.cites", Arrays.asList("东莞","东京")));
find.forEach(printBlock);
logger.info(String.valueOf(ret.size()));
ret.removeAll(ret);
//select * from users where username like '%s%' and (contry= English or contry = USA)
String regexStr = ".*s.*";
Bson regex = regex("username", regexStr);
Bson or = or(eq("country","English"),eq("country","USA"));
FindIterable<User> find2 = doc.find(and(regex,or));
find2.forEach(printBlock);
logger.info(String.valueOf(ret.size()));
}
}
pom.xml:
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.shidebin.mongodb</groupId>
<artifactId>java-pojo</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>java-pojo</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongo-java-driver</artifactId>
<version>3.5.0</version>
</dependency>
<dependency>
<groupId>org.slf4j</groupId>
<artifactId>slf4j-api</artifactId>
<version>1.7.10</version>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
<version>1.1.2</version>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-core</artifactId>
<version>1.1.2</version>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>2.1</version>
<configuration>
<source>1.7</source>
<target>1.7</target>
</configuration>
</plugin>
</plugins>
</build>
</project>
注意:此类用到的java bean请到git仓库下载:https://github.com/shidebin/mongodb/tree/master/java-pojo。