mongodb语法以及springboot中操作mongodb数据库（query update Criteria的使用）

mongodb语法

1. 创建数据库：use DATABASE_NAME

2. 创建集合：db.createCollection("COLLECTION_NAME")

3. 插入数据：db.COLLECTION_NAME.insert({key:value})

4. 查询数据：db.COLLECTION_NAME.find()

5. 更新数据：db.COLLECTION_NAME.update({query}, {update}, {upsert}, {multi})

6. 删除数据：db.COLLECTION_NAME.remove({query}, {justOne})

7. 条件查询：db.COLLECTION_NAME.find({key:value})

8. 范围查询：db.COLLECTION_NAME.find({key:{$gt:value1,$lt:value2}})

9. 排序：db.COLLECTION_NAME.find().sort({key:1})（按升序排列）或db.COLLECTION_NAME.find().sort({key:-1})（按降序排列）

10. 分页查询：db.COLLECTION_NAME.find().skip(NUMBER_OF_DOCUMENTS_TO_SKIP).limit(NUMBER_OF_DOCUMENTS_TO_SHOW)

11. 聚合查询：db.COLLECTION_NAME.aggregate([{stage1},{stage2},...])

12. 建立索引：db.COLLECTION_NAME.createIndex({key:1})（按升序建立索引）或db.COLLECTION_NAME.createIndex({key:-1})（按降序建立索引）

13. 删除索引：db.COLLECTION_NAME.dropIndex({key:1})

14. 退出MongoDB：quit()或exit() 

springboot使用

引入依赖

    org.springframework.boot
    spring-boot-starter-data-mongodb

 
使用 mongoTemplate 进行 MongoDB 增删改查的例子：

首先创建一个实体类 User：
@Document(collection = "users")
public class User {
    @Id
    private String id;
    private String name;
    private Integer age;
    // getters and setters
}
使用 @Document 注解标记该实体类对应到 MongoDB 的 users 集合中，并使用 @Id 注解标识 id 字段为主键。

创建一个 UserDao 类，用来进行 MongoDB 的增删改查操作：
@Repository
public class UserDao {
    @Autowired
    private MongoTemplate mongoTemplate;
    
    public User addUser(User user) {
        mongoTemplate.save(user);
        return user;
    }
    
    public void updateUser(User user) {
        Query query = new Query(Criteria.where("id").is(user.getId()));
        Update update = new Update().set("name", user.getName())
                                    .set("age", user.getAge());
        mongoTemplate.updateFirst(query, update, User.class);
    }
    
    public User findUserById(String id) {
        Query query = new Query(Criteria.where("id").is(id));
        return mongoTemplate.findOne(query, User.class);
    }
    
    public List findUsersByName(String name) {
        Query query = new Query(Criteria.where("name").is(name));
        return mongoTemplate.find(query, User.class);
    }
 
    public void deleteUserById(String id) {
        Query query = new Query(Criteria.where("id").is(id));
        mongoTemplate.remove(query, User.class);
    }}

使用 @Repository 注解将 UserDao 交给 Spring 管理，并注入 mongoTemplate 对象。

addUser 方法用来添加用户，使用 mongoTemplate.save 方法保存对象到 MongoDB 中。

updateUser 方法用来修改用户信息，使用 mongoTemplate.updateFirst 方法进行更新操作。Query 类表示查询条件，Criteria 类表示查询条件的集合，Update 类表示更新操作的集合。

findUserById 方法用来根据用户 ID 查询用户信息，使用 mongoTemplate.findOne 方法查询单个对象。

findUsersByName 方法用来根据用户名查询符合条件的用户列表，使用 mongoTemplate.find 方法查询对象列表。

deleteUserById 方法用来根据用户 ID 删除用户信息，使用 mongoTemplate.remove 方法删除对象。

最后创建一个 UserController 类，用来测试 MongoDB 的增删改查操作：
@RestController
public class UserController {
    @Autowired
    private UserDao userDao;
    
    @PostMapping("/user")
    public User addUser(@RequestBody User user) {
        return userDao.addUser(user);
    }
    
    @PutMapping("/user")
    public void updateUser(@RequestBody User user) {
        userDao.updateUser(user);
    }
    
    @GetMapping("/user/{id}")
    public User findUserById(@PathVariable("id") String id) {
        return userDao.findUserById(id);
    }
    
    @GetMapping("/users/{name}")
    public List findUsersByName(@PathVariable("name") String name) {
        return userDao.findUsersByName(name);
    }
 
    @DeleteMapping("/user/{id}")
    public void deleteUserById(@PathVariable("id") String id) {
        userDao.deleteUserById(id);
    }
}

使用 @RestController 注解将 UserController 交给 Spring 管理，并注入 UserDao 对象。

addUser 方法用来添加用户信息，使用 @PostMapping 注解标记 HTTP POST 请求。

updateUser 方法用来修改用户信息，使用 @PutMapping 注解标记 HTTP PUT 请求。

findUserById 方法用来根据用户 ID 查询用户信息，使用 @GetMapping 注解标记 HTTP GET 请求。

findUsersByName 方法用来根据用户名查询符合条件的用户列表，使用 @GetMapping 注解标记 HTTP GET 请求。

deleteUserById 方法用来根据用户 ID 删除用户信息，使用 @DeleteMapping 注解标记 HTTP DELETE 请求。

以上就是使用 mongoTemplate 进行 MongoDB 增删改查的例子。

Query Update Criteria的用法
Query、Update 和 Criteria 是 Spring Data MongoDB 中的三个重要概念，它们用于进行 MongoDB 的复杂查询和更新操作。下面分别介绍它们的用法：

Query中的方法
addCriteria(Criteria criteria)
添加查询条件。可以使用 Criteria 对象来构建复杂的查询条件。

with(Sort sort)
设置排序规则。可以使用 Sort 对象来构建复杂的排序规则。

with(Pageable pageable)
设置分页规则。可以使用 PageRequest 对象来构建分页规则。

fields()
设置查询的字段。可以使用 Fields 对象来指定需要返回的字段。如果不调用 fields() 方法，则返回所有字段。

include(String... fields)
设置需要返回的字段。同 fields() 方法。

exclude(String... fields)
设置不需要返回的字段。同 fields() 方法。

limit(int limit)
设置查询结果的最大数量。

skip(int skip)
设置查询结果的偏移量。

count()
返回查询结果的数量。

one()
返回查询结果的第一条记录。

list()
返回查询结果的所有记录。

exists()
判断查询结果是否存在。

aggregate(Aggregation aggregation, Class resultType)
执行聚合操作。可以使用 Aggregation 对象来构建聚合操作。resultType 指定返回的结果类型。

query的使用
Query 使用 Criteria 对象来构建查询条件，并可以设置排序、分页等参数。例如：

Query query = new Query(Criteria.where("name").is("Tom").and("age").gte(20));
query.with(Sort.by(Sort.Direction.DESC, "age"));
query.skip(0).limit(10);
上面的代码表示查询名字为 "Tom" 且年龄大于等于 20 的用户，并按照年龄降序排序，返回第 1 到 10 条结果。

Query 还支持链式调用：

Query query = new Query()
    .addCriteria(Criteria.where("name").is("Tom").and("age").gte(20))
    .with(Sort.by(Sort.Direction.DESC, "age"))
    .skip(0).limit(10);

Update中的方法
set(String key, Object value)
设置字段的值。

unset(String key)
删除字段。

inc(String key, Number value)
增加数值类型字段的值。

push(String key, Object value)
将元素添加到数组字段中。

addToSet(String key, Object value)
将元素添加到集合字段中。

pop(String key, Position position)
从数组字段中删除元素。

pull(String key, Object value)
从数组或集合字段中删除元素。

pullAll(String key, Object[] values)
从数组或集合字段中删除多个元素。

rename(String oldName, String newName)
重命名字段。

currentDate(String key)
设置字段的值为当前日期。

max(String key, Number value)
如果字段的值小于指定值，则更新字段的值。

min(String key, Number value)
如果字段的值大于指定值，则更新字段的值。

mul(String key, Number value)
将数值类型字段的值乘以指定值。

addToSetEach(String key, Object... values)
将多个元素添加到集合字段中。

pushEach(String key, Object... values)
将多个元素添加到数组字段中。

bitwise(String key, Bitwise bitwise, int value)
执行位运算。

以上就是 Query 和 Update 中常用的方法，借助这些方法，可以构建出复杂的查询和更新操作。

update的使用
Update 用于构建更新操作，可以设置更新的字段和条件。例如：

Update update = new Update().set("name", "Jim").inc("age", 1);
上面的代码表示将名字为 "Jim" 的用户的年龄加 1。

Update 还支持链式调用：

Update update = new Update()
    .set("name", "Jim")
    .inc("age", 1);
Criteria的使用
Criteria 用于构建查询条件，支持多种操作符，例如：

Criteria criteria = Criteria.where("name").is("Tom").and("age").gte(20);

上面的代码表示查询名字为 "Tom" 且年龄大于等于 20 的用户。

Criteria 还支持链式调用：

Criteria criteria = new Criteria()
    .andOperator(
        Criteria.where("name").is("Tom"),
        Criteria.where("age").gte(20)
    );

除了 andOperator，还支持 orOperator、notOperator、norOperator 等逻辑操作符。

另外，Criteria 还支持比较操作符，例如：

Criteria.where("age").gt(18)   // 大于
Criteria.where("age").gte(18)  // 大于等于
Criteria.where("age").lt(18)   // 小于
Criteria.where("age").lte(18)  // 小于等于
Criteria.where("age").is(18)   // 等于
Criteria.where("age").ne(18)   // 不等于
Criteria.where("name").in("Tom", "Jim")  // 在集合中
Criteria.where("name").nin("Tom", "Jim") // 不在集合中
Criteria.where("name").regex("pattern") // 正则匹配
以上就是 Query、Update 和 Criteria 的用法。借助这些对象，可以进行更加灵活和高效的 MongoDB 查询和更新操作