mongodb基本操作和在springboot中的使用

• 本文介绍mongodb的使用
  • 说明
  • 起步
  • mongo通用类型
  • mongoshell的操作
    • CRUD操作
    • shell命令操作
    • 索引操作
  • mongo在springboot中的使用
    • 目录结构
    • 依赖
    • properties配置
    • User
    • WebConfig
    • TestController
    • 其他的一些增删改操作例子
  • 结尾

本文介绍mongodb的使用

说明

mongodb主要是用来存储json文档的，mongodb提供了操作json文档的一系列的方法

mongodb的语法结构和javascript类似，你可以直接运行JavaScript甚至js文件

由于本人也是刚涉及mongodb，本文仅仅写了一些入门级别的操作，和在springboot中如何使用mongo

本文会持续更新...

起步

下载地址 https://www.mongodb.com/download-center/v2/community

net start MongoDB           启动服务
net stop MongoDB            停止服务
sc.exe delete MongoDB       卸载服务

mongo的shell可以直接运行JavaScript

切换到程序安装目录
mongo                       运行本地mongo
db                          查看当前运行哪个数据库
use mydb                    使用指定数据库
db.version()

mongo通用类型

null
布尔            true false
数值            3.3
字符串          "a"
日期            new Date()
正则            /[a-z]/
数组            ["a", "b", "c"]
对象            {"a": 1}
对象id          ObjectId()
代码            对象值可以直接保存代码

mongoshell的操作

CRUD操作

mongo的操作风格类似JavaScript

insert操作
    post = {"a":1, "b": 2}
    db.obj.insert(post)
    db.obj.find()                                   列出全部结果集
    db.obj.findOne()                                列出第一个
    db.obj.insert([{"a": 1}, {"b": 2}, {"c": 3}])   批量插入
update操作
    post={"name": "yejiawei", "age": 18}
    db.obj.update({"a":1}, post)                                                                    直接将包含{"a":1}的数据替换成新数据
    db.foo.update({"c": 3}, {"$inc": {"c": 1}})                                                     使{"c": 3}记录的c属性自增1
    db.foo.update({"c": 4}, {"$set": {"i": {"ii": 11}}})                                            在{"c": 4}记录中添加{"i": {"ii": 11}}属性
    db.foo.update({"c": 4}, {"$set": {"i.ii": 111}})
    db.foo.update({"c": 4}, {"$push": {"j": 3}})                                                    往j属性，下面push成员
    db.foo.update({"c": 4}, {"$push": {"j": {"$each": [4,5,6]}}})                                   往j属性，下面push多个成员
    db.foo.update({"c": 4}, {"$push": {"j": {"$slice": -5, "$each": [7,8,9]}}})                     往j属性，下面push多个成员，数组只保留最后5个元素
    db.foo.update({"c": 4}, {"$push": {"j": {"$slice": -5, "$each": [13,14,15], "$sort": -1}}})     往j属性，下面push多个成员，数组只保留最后5个元素，降序排序
    db.obj.update({"a": 1}, {"$inc": {"a": 1}}, true)                                               第三个参数表示，如果记录没有则创建一个
    其他的修饰器:
        $addToSet                                   避免值重复插入
        {"$pop": {"key": 1}}                        从数组末尾删除一个元素
        {"$pop": {"key": -1}}                       从数组开头删除一个元素
        update({}, {"$pull", {"arr": "somevalue"}}) 指定元素删除
delete操作
    db.obj.remove({"c": 3})                         删除包含{"c": 3}的数据
find 操作
    db.obj.find({}, {"a": 1})                       查找第一个包含a的记录
    db.obj.find({"a": {"$gte": 0}})                 查找a值大于等于0的记录
    其他修饰符
        $lt 小于
        $lte 小于等于
        $gt 大于
        $in 包含 {"$in", [1,2,3]}
        $nin
        $or 或者 db.obj.find({"$or": [{"a": 1}, {"a":2}]})
        $mod 取模 {"$mod": [2, 1]}
        $not 非
        $and 与
        $all 共
        $size 长度
        $slice 截取
    限制结果
        db.obj.find().limit(2)      限制返回结果只能2个
        db.obj.find().skip(2)       忽略前2个
        db.obj.find().sort({a: 1})  升序排

shell命令操作

链接数据库

mongo some-host:30000/mydb  运行远程mongo
mongo --nodb                启动mongo不连接数据库

手动链接
conn = new Mongo("some-host:30000")
db = conn.getDB("mydb")

查看帮助文档

db.help()
db.obj.help()
只要你不知道的东西，调用help就行了

执行JavaScript文件

mongo C:\Users\26401\Desktop\demo.js

mongorc配置文件

.mongorc.js文件在用户主目录 C:\Users\26401 下，可以在里面添加js，在mongo开启时自动执行

prompt = function () {
  return "Uptime:" + db.serverStatus().uptime + " Documents:" + db.stats().objects + " > ";
}

索引操作

文本索引

db.obj.createIndex({name: "text", description: "text"})         创建索引
db.obj.find( { $text: { $search: "小李" } } )                   利用索引查找

db.obj.find(
   { $text: { $search: "小李" } },
   { score: { $meta: "textScore" } }
).sort( { score: { $meta: "textScore" } } )                     相关性排序

单字段索引和聚合索引

单字段索引
    db.obj.createIndex( { age: -1 } )                               降序索引
    db.obj.createIndex( { age: -1 }, { unique: true } )             唯一索引
    db.obj.find({"age": {$gt: 18}})                                 这种使用方式，降序索引生效

聚合索引
    原理和单个索引一样
    db.products.createIndex( { "item": 1, "stock": 1 } )

mongo在springboot中的使用

目录结构

依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>

properties配置

# ===============================
# MONGODB
# ===============================
spring.data.mongodb.host=127.0.0.1
spring.data.mongodb.port=27017
spring.data.mongodb.database=test

User

package com.springlearn.learn.model;

import org.springframework.data.annotation.Id;
import org.springframework.data.annotation.Version;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;

@Document(collection = "user")  // mongo数据库中的json对象名
public class User {
    @Id                         // 自动映射_id属性，每一个model都必须要一个这个
    private String id;

    @Version                    // 类似更新标识的作用，防止脏查
    private Long version;

    @Field(value = "name")
    private String name;

    @Field(value = "age")
    private Integer age;

    @Field(value = "sex")
    private String sex;

    public User(String name, Integer age, String sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

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

    public String getId() {
        return id;
    }

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

    public String getname() {
        return name;
    }

    public void setage(Integer age) {
        this.age = age;
    }

    public Integer getage() {
        return age;
    }

    public void setsex(String sex) {
        this.sex = sex;
    }

    public String getsex() {
        return sex;
    }

    @Override
    public String toString() {
        return "Person [id=" + id + ", name=" + name + ", age=" + age + ", sex=" + sex + "]";
    }
}

WebConfig

package com.springlearn.learn.config;

import java.util.ArrayList;
import java.util.List;

import javax.annotation.Resource;

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.MongoDbFactory;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver;
import org.springframework.data.mongodb.core.convert.DefaultMongoTypeMapper;
import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport;

@Configuration
public class WebConfig extends WebMvcConfigurationSupport {

    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**").allowedOrigins("*").allowedMethods("GET", "POST", "PUT", "DELETE").allowedOrigins("*")
        .allowedHeaders("*");
    }

    @Bean
    public MongoTemplate mongoTemplate(MongoDbFactory mongoDbFactory, MongoMappingContext context) {

        // 自定义mongoConverter
        MappingMongoConverter converter = new MappingMongoConverter(new DefaultDbRefResolver(mongoDbFactory), context);
        converter.setTypeMapper(new DefaultMongoTypeMapper(null));

        MongoTemplate mongoTemplate = new MongoTemplate(mongoDbFactory, converter);
        return mongoTemplate;

    }
}

TestController

package com.springlearn.learn.controller;

import javax.servlet.http.HttpServletRequest;

import com.springlearn.learn.model.User;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Example;
import org.springframework.data.domain.Sort;
import org.springframework.data.mongodb.core.MongoOperations;
import org.springframework.data.mongodb.core.MongoTemplate;
import org.springframework.data.mongodb.core.mapreduce.GroupBy;
import org.springframework.data.mongodb.core.mapreduce.GroupByResults;
import org.springframework.data.mongodb.core.query.Criteria;
import org.springframework.data.mongodb.core.query.Query;
import org.springframework.data.mongodb.core.query.TextCriteria;
import org.springframework.data.mongodb.core.query.TextQuery;
import org.springframework.data.mongodb.core.query.Update;

import static org.springframework.data.mongodb.core.query.Query.query;
import static org.springframework.data.mongodb.core.query.Criteria.where;
import static org.springframework.data.mongodb.core.query.Update.update;

import java.util.List;

import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController{

    @Autowired
    MongoTemplate mongoTemplate;

    @ResponseBody
    @RequestMapping(value = "/test1/{id}", method = RequestMethod.GET, produces = "application/json")
    public Object Test1(HttpServletRequest request, @PathVariable int id){
        MongoOperations mongoOps = mongoTemplate;

        // 插入数据
        // User u = new User("小红", 10, "女");
        // mongoOps.insert(u);

        // 获取数据
        // u = mongoOps.findById(u.getId(), User.class);

        // 更新数据
        // mongoOps.updateFirst(query(where("name").is("小红")), update("age", 18), User.class);
        // User u = mongoOps.findOne(query(where("name").is("小红")), User.class);
        // return u;

        // mongoOps.updateFirst(query(where("name").is("小王")), new Update().inc("age", 10), User.class);
        // User u = mongoOps.findOne(query(where("name").is("小王")), User.class);
        // return u;

        // 删除数据
        // mongoOps.remove(query(where("name").is("小红")), User.class);
        // return "删除成功";

        // 全文索引
        // Query query = new TextQuery(new TextCriteria().matchingAny("小张", "小李")).sortByScore();
        // List<User> users = mongoOps.find(query, User.class);
        // return users;

        // 规范使用
        // Query query = new Query();
        // query.with(new Sort(Sort.Direction.DESC, "age"));
        // query.limit(1);
        // User maxUser = mongoTemplate.findOne(query, User.class);
        // if (maxUser == null) {
        //     return "没有数据";
        // }
        // return maxUser;

    }
}

其他的一些增删改操作例子

// { $push : { "category" : { "$each" : [ "spring" , "data" ] } } }
new Update().push("category").each("spring", "data")

// { $push : { "key" : { "$position" : 0 , "$each" : [ "Arya" , "Arry" , "Weasel" ] } } }
new Update().push("key").atPosition(Position.FIRST).each(Arrays.asList("Arya", "Arry", "Weasel"));

// { $push : { "key" : { "$slice" : 5 , "$each" : [ "Arya" , "Arry" , "Weasel" ] } } }
new Update().push("key").slice(5).each(Arrays.asList("Arya", "Arry", "Weasel"));

// { $addToSet : { "values" : { "$each" : [ "spring" , "data" , "mongodb" ] } } }
new Update().addToSet("values").each("spring", "data", "mongodb");

// 不存在则创建document
template.upsert(query(where("ssn").is(1111).and("firstName").is("Joe").and("Fraizer").is("Update")), update("address", addr), Person.class); 

// findAndModify的使用
Query query = new Query(Criteria.where("firstName").is("Harry"));
Update update = new Update().inc("age", 1);
Person p = mongoTemplate.findAndModify(query, update, Person.class)

// 使用原始shell命令
BasicQuery query = new BasicQuery("{ age : { $lt : 50 }, accounts.balance : { $gt : 1000.00 }}");
List<Person> result = mongoTemplate.find(query, Person.class);

结尾

由于本人涉及mongodb没多久，如果你想知道，但是本文没有的，请告诉我，我会第一时间总结出来并发布填充到本文

请下方留言