本文涉及到的语句及功能:
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/spring-mongodb
applicationContext.xml:
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:mongo="http://www.springframework.org/schema/data/mongo"
xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-4.0.xsd
http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-4.0.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd
http://www.springframework.org/schema/data/mongo http://www.springframework.org/schema/data/mongo/spring-mongo.xsd">
<!-- <context:property-placeholder location="classpath:/com/myapp/mongodb/config/mongo.properties"
/> -->
<!-- mongodb连接池配置 -->
<mongo:mongo-client host="192.168.126.128" port="27022">
<mongo:client-options
write-concern="ACKNOWLEDGED"
connections-per-host="100"
threads-allowed-to-block-for-connection-multiplier="5"
max-wait-time="120000"
connect-timeout="10000"/>
</mongo:mongo-client>
<!-- mongodb数据库工厂配置 -->
<mongo:db-factory dbname="lison" mongo-ref="mongo" />
<mongo:mapping-converter base-package="com.dongnao.mongodb.entity">
<mongo:custom-converters>
<mongo:converter>
<bean class="com.dongnao.mongo.convert.BigDecimalToDecimal128Converter"/>
</mongo:converter>
<mongo:converter>
<bean class="com.dongnao.mongo.convert.Decimal128ToBigDecimalConverter"/>
</mongo:converter>
</mongo:custom-converters>
</mongo:mapping-converter>
<!-- mongodb模板配置 -->
<bean id="anotherMongoTemplate" class="org.springframework.data.mongodb.core.MongoTemplate">
<constructor-arg name="mongoDbFactory" ref="mongoDbFactory" />
<constructor-arg name="mongoConverter" ref="mappingConverter"/>
<property name="writeResultChecking" value="EXCEPTION"></property>
</bean>
</beans>
Test类:
package com.shidebin.mongodb.spring_mongodb;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Date;
import java.util.List;
import org.bson.Document;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Sort;
import org.springframework.data.domain.Sort.Direction;
import org.springframework.data.mongodb.core.FindAndModifyOptions;
import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.aggregation.Aggregation;
import org.springframework.data.mongodb.core.aggregation.AggregationOperation;
import org.springframework.data.mongodb.core.aggregation.AggregationResults;
import org.springframework.data.mongodb.core.aggregation.Fields;
import org.springframework.data.mongodb.core.aggregation.LimitOperation;
import org.springframework.data.mongodb.core.aggregation.MatchOperation;
import org.springframework.data.mongodb.core.aggregation.ProjectionOperation;
import org.springframework.data.mongodb.core.aggregation.SkipOperation;
import org.springframework.data.mongodb.core.aggregation.SortOperation;
import org.springframework.data.mongodb.core.aggregation.UnwindOperation;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.Update;
import org.springframework.data.mongodb.core.query.Update.PushOperatorBuilder;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
import com.mongodb.WriteResult;
import com.mongodb.client.model.Filters;
import com.mongodb.client.model.FindOneAndUpdateOptions;
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.operation.FindAndUpdateOperation;
import com.shidebin.mongo.entity.Address;
import com.shidebin.mongo.entity.Comment;
import com.shidebin.mongo.entity.Favorites;
import com.shidebin.mongo.entity.User;
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration("classpath:applicationContext.xml")
public class SpringPojoTest {
private static final Logger logger = LoggerFactory.getLogger(SpringPojoTest.class);
@Autowired
private MongoOperations operation;
@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);
operation.insertAll(Arrays.asList(user,user1));
}
@Test
public void testDelete(){
//delete from users where username = ‘lison’
WriteResult result = operation.remove(Query.query(Criteria.where("username").is("lison")),
User.class);
logger.info("删除条数"+result.getN());
//delete from users where age >8 and age <25
WriteResult result2 = operation.remove(Query.query(new Criteria().andOperator(Criteria.where("age")
.gt(8),Criteria.where("age").lt(25))), User.class);
logger.info("删除条数"+result2.getN());
}
@Test
public void testUpdate(){
//update users set age=6 where username = 'lison'
WriteResult updateMany = operation.updateMulti(Query.query(Criteria.where("username").is("lison")),
Update.update("age", 6), User.class);
logger.info(String.valueOf(updateMany.getN()));
//update users set favorites.movies add "小电影2 ", "小电影3" where favorites.cites has "东莞"
WriteResult updateMany2 = operation.updateMulti(Query.query(Criteria.where("favorites.cites")
.is("东莞")),new Update().addToSet("favorites.movies").each("小电影2","小电影3"),
User.class);
logger.info(String.valueOf(updateMany2.getN()));
}
@Test
public void update1() {
/**
* db.users.updateOne({"username":"lison",},
{
"$push": {
"comments": {
$each: [
{
"author" : "james",
"content" : "lison是个好老师!",
"commentTime" : ISODate("2018-01-06T04:26:18.354Z")
}
],
$sort: {"commentTime":-1}
}
}
}
);
*/
Query query = Query.query(Criteria.where("username").is("mark"));
Update update = new Update();
Comment comment = new Comment();
comment.setAuthor("lison5");
comment.setContent("lison是苍老师的小迷弟");
comment.setCommentTime(new Date());
PushOperatorBuilder push = update.push("comments");
push.each(comment);
push.sort(new Sort(Direction.DESC,"commentTime"));
WriteResult updateMany3 = operation.updateFirst(query,update, User.class);
logger.info("++++++++++++++++++++++++");
logger.info(String.valueOf(updateMany3.getN()));
}
/**
* db.users.updateMany({"username":"lison"},{"$unset":{"country":"","age":""}})
*/
@Test
public void update2() {
Query query = Query.query(Criteria.where("username").is("lison"));
Update update = new Update();
update.unset("country");
update.unset("age");
WriteResult updateFirst = operation.updateFirst(query, update, User.class);
System.out.println("++++++"+updateFirst.getN());
}
/**
* db.users.updateMany({"username":"jack"},{"$rename":{"country":"guojia","age":"nianling"}})
*/
@Test
public void update3() {
Query query = Query.query(Criteria.where("username").is("jack"));
Update update = new Update();
update.rename("country", "guojia");
update.rename("age", "nianling");
WriteResult updateMulti = operation.updateMulti(query, update, User.class);
System.out.println("++++++"+updateMulti.getN());
}
/**
* db.users.updateMany({ "username" : "jack"}, { "$addToSet" : { "favorites.movies" :
* { "$each" : [ "小电影2 " , "小电影3"]}}})
*/
@Test
public void update4() {
Query query = Query.query(Criteria.where("username").is("jack"));
Update update = new Update();
update.addToSet("favorites.movies").each("小电影2 " , "小电影3");
WriteResult updateFirst = operation.updateFirst(query, update, User.class);
System.out.println("++++++"+updateFirst.getN());
}
/**
* db.users.updateMany({ "username" : "jack"}, { "$pullAll" : { "favorites.movies" : [ "小电影2 " , "小电影3"]}})
*/
@Test
public void update5() {
Query query = Query.query(Criteria.where("username").is("jack"));
Update update = new Update();
update.pullAll("favorites.movies", new Object[] {"小电影2 " , "小电影3"});
WriteResult updateMulti = operation.updateMulti(query, update, User.class);
System.out.println("++++++"+updateMulti.getN());
}
/**
* db.users.updateOne({"username":"jack"},{"$push":{"comments":{"author":"lison23","content":"ydddyyytttt"}}})
*/
@Test
public void update6() {
Query query = Query.query(Criteria.where("username").is("jack"));
Update update = new Update();
Comment comment = new Comment();
comment.setAuthor("lison23");
comment.setContent("ydddyyytttt");
update.push("comments",comment);
WriteResult updateMulti = operation.updateMulti(query, update, User.class);
System.out.println("++++++"+updateMulti.getN());
}
/**
* db.users.updateOne({"username":"jack"},
{"$push":{"comments":
{"$each":[{"author":"lison24","content":"yyyytttt"},
{"author":"lison25","content":"ydddyyytttt"}]}}})
*/
@Test
public void update7() {
Query query = Query.query(Criteria.where("username").is("jack"));
Update update = new Update();
Comment comment = new Comment();
comment.setAuthor("lison24");
comment.setContent("ydddyyytttt");
Comment comment1 = new Comment();
comment1.setAuthor("lison25");
comment1.setContent("ydddyyytttt");
update.push("comments").each(comment,comment1);
WriteResult updateMulti = operation.updateMulti(query, update, User.class);
System.out.println("++++++"+updateMulti.getN());
}
/**
* db.users.updateOne({"username":"jack"},
{"$push": {"comments":
{"$each":[ {"author":"lison22","content":"yyyytttt"},
{"author":"lison23","content":"ydddyyytttt"} ],
$sort: {"author":1} } } })
*/
@Test
public void update8() {
Query query = Query.query(Criteria.where("username").is("jack"));
Update update = new Update();
Comment comment = new Comment();
comment.setAuthor("lison24");
comment.setContent("ydddyyytttt");
Comment comment1 = new Comment();
comment1.setAuthor("lison25");
comment1.setContent("ydddyyytttt");
PushOperatorBuilder push = update.push("comments");
push.each(comment,comment1);
push.sort(new Sort(Direction.ASC,Arrays.asList("author")));
WriteResult updateMulti = operation.updateMulti(query, update, User.class);
System.out.println("++++++"+updateMulti.getN());
}
/**
* db.users.update({"username":"jack"},
{"$pull":{"comments":{"author":"lison22"}}})
*/
@Test
public void update9() {
Query query = Query.query(Criteria.where("username").is("jack"));
Update update = new Update();
Comment comment = new Comment();
comment.setAuthor("lison22");
update.pull("comments", comment);
WriteResult updateFirst = operation.updateFirst(query, update, User.class);
System.out.println("++++++"+updateFirst.getN());
}
/**
* db.users.update({"username":"lison"},
{"$pull":{"comments":{"author":"lison5",
"content":"lison是苍老师的小迷弟"}}})
*/
@Test
public void update10() {
Query query = Query.query(Criteria.where("username").is("lison"));
Update update = new Update();
Comment comment = new Comment();
comment.setAuthor("lison5");
comment.setContent("lison是苍老师的小迷弟");
update.pull("comments", comment);
WriteResult updateFirst = operation.updateFirst(query, update, User.class);
System.out.println("++++++"+updateFirst.getN());
}
/**
* db.users.updateMany({"username":"jack","comments.author":"lison1"},
{"$set":{"comments.$.content":"xxoo",
"comments.$.author":"lison10" }})
*/
@Test
public void update11() {
Query query = Query.query(Criteria.where("username").is("jack")
.andOperator(Criteria.where("comments.author").is("lison1")));
Update update = Update.update("comments.$.content", "xxoo").set("comments.$.author", "lison10");
WriteResult updateMulti = operation.updateMulti(query, update, User.class);
System.out.println("++++++"+updateMulti.getN());
}
/**
* db.users.findAndModify({{"username":"lison","comments.author":"lison1"},
{"$set":{"comments.$.content":"xxoo",
"comments.$.author":"lison10" }},"new":true})
*/
@Test
public void update14() {
Query query = Query.query(Criteria.where("username").is("lison").
andOperator(Criteria.where("comments.author").is("lison1")));
Update update = Update.update("comments.$.content", "xxoo").set("comments.$.author", "lison10");
FindAndModifyOptions returnNew = FindAndModifyOptions.options().returnNew(true);
User findAndModify = operation.findAndModify(query, update, returnNew, User.class);
System.out.println("++++++"+findAndModify.toString());
}
@Test
public void find2() {
// db.users.find({"comments":{"$elemMatch":{"author" : "lison5","content" :
// "lison是苍老师的小迷弟"}}}) .pretty()
Query query = Query.query(Criteria.where("comments").elemMatch(
new Criteria().andOperator(Criteria.where("author").is("lison5"),
Criteria.where("content").is("lison是苍老师的小迷弟"))));
List<User> find = operation.find(query, User.class);
logger.info("++++++++++++++++++++++++");
find.stream().forEach(user ->{System.out.println(user);});
}
/**
* db.users.aggregate([{"$match":{"username":"lison"}},
{"$unwind":"$comments"},
{$sort:{"comments.commentTime":-1}},
{"$project":{"comments":1}},
{"$skip":6},
{"$limit":3}])
*/
@Test
public void tesFind() {
AggregationOperation matchOperation = new MatchOperation(Criteria.where("username").is("lison"));
AggregationOperation unwindOperation = new UnwindOperation(Fields.field("$comments"));
AggregationOperation sortOperation = new SortOperation(new Sort(Direction.DESC,"comments.commentTime"));
AggregationOperation projectionOperation = new ProjectionOperation(Fields.fields("comments"));
AggregationOperation skipOperation = new SkipOperation(6);
AggregationOperation limitOperation = new LimitOperation(3);
Aggregation newAggregation = Aggregation.newAggregation(matchOperation,unwindOperation,sortOperation,projectionOperation,skipOperation,limitOperation);
AggregationResults<Object> agg = operation.aggregate(newAggregation,"users",Object.class);
agg.forEach(user ->{System.out.println(user);});
}
//测试DbRef
@Test
public void test() {
List<User> userList = operation.findAll(User.class);
userList.stream().forEach(user ->{System.out.println(user);});
}
@Test
public void testFind(){
//select * from users where favorites.cites has "东莞"、"东京"
List<User> userList = operation.find(Query.query(new Criteria().andOperator(Criteria.where("favorites.cites").is("东莞"),
Criteria.where("favorites.cites").is("东京"))), User.class);
userList.stream().forEach(consumer -> {System.out.println(consumer);});
//select * from users where username like '%s%' and (country= English or country = USA)
List<User> userList2 = operation.find(Query.query(new Criteria().andOperator(new Criteria().orOperator(Criteria.where("country").is("English"),
Criteria.where("country").is("USA")),Criteria.where("username").regex(".*s.*"))), User.class);
userList2.stream().forEach(consumer -> {System.out.println(consumer);});
//db.users.find({"username":"lison"},{"comments":{"$slice":[0,3]},"$id":1}).pretty();
Query query = Query.query(Criteria.where("username").is("lison"));
query.fields().include("comments").slice("comments",0,3).include("id");
List<User> userList3 = operation.find(query, User.class);
userList3.stream().forEach(consumer -> {System.out.println(consumer);});
//db.users.find({"username":"lison"},{"comments":{"$slice":[3,3]},"$id":1}).pretty();
query.fields().include("comments").slice("comments",3,3).include("id");
List<User> userList4 = operation.find(query, User.class);
userList4.stream().forEach(consumer -> {System.out.println(consumer);});
}
}
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>spring-mongodb</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>spring-mongodb</name>
<url>http://maven.apache.org</url>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
</properties>
<dependencies>
<!-- https://mvnrepository.com/artifact/org.mongodb/mongo-java-driver -->
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongo-java-driver</artifactId>
<version>3.5.0</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.springframework.data/spring-data-mongodb -->
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-mongodb</artifactId>
<version>1.10.9.RELEASE</version>
</dependency>
<!-- 单元测试相关依赖 -->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-test</artifactId>
<version>4.3.2.RELEASE</version>
<scope>test</scope>
</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>
<!-- spring核心依赖 -->
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.3.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>4.3.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context-support</artifactId>
<version>4.3.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-beans</artifactId>
<version>4.3.3.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-aop</artifactId>
<version>4.3.3.RELEASE</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>
- spring-data-mongodb的最新版本是2.x.x,如果是spring为5.0版本以上的才推荐使用;
- spring-data-mongodb的1.10.9版本基于spring4.3.x开发,但是默认依赖的mongodb驱动
为2.14.3,可以将mongodb的驱动设置为3.5.0的版本,兼容性待进一步测试; - spring-data-mongodb的1.10.9可能会支持3.5.0版本 mongodb驱动;
- spring-data-mongodb一般使用pojo的方式开发;
5.查询选择器:
6.mongodb连接池配置:
git上的工程代码:https://github.com/shidebin/mongodb/tree/master/spring-mongodb