MongoDB入门

安装MongoDB

安装完成服务程序在目录： C:\Program Files\MongoDB\Server\3.2\bin 下

为了方便启动，将其设置到环境变量path中。

启动

1. 打卡命令提示符，创建一个用于存放数据的目录

   md d:\data

2. 启动服务

   mongod --dbpath=d:\data

启动过程中可以看到默认端口号是27017，可以通过--port来指定端口。

登录

• 命令行中输入 mongo 命令即可登录
• 输入 exit 退出MongoDB

常用命令

插入

db.集合名称.insert(数据);

以吐槽(spit)为例：db.spit.insert({content:"内容",userid:"1011",nickname:"昵称",visits:NumberInt(902)})

添加测试数据

db.spit.insert({_id:"1",content:"我还是没有想明白到底为啥出 错",userid:"1012",nickname:"小明",visits:NumberInt(2020)}); 

db.spit.insert({_id:"2",content:"加班到半夜",userid:"1013",nickname:"凯 撒",visits:NumberInt(1023)}); 

db.spit.insert({_id:"3",content:"手机流量超了咋 办？",userid:"1013",nickname:"凯撒",visits:NumberInt(111)}); 

db.spit.insert({_id:"4",content:"坚持就是胜利",userid:"1014",nickname:"诺 诺",visits:NumberInt(1223)});

查询

db.集合名称.find()

查询集合spit所有数据：db.spit.find()

条件查询：db.spit.find({userid:'1013'})

查询第一条数据：db.spit.findOne({userid:'1013'})

指定记录数：db.spit.find().limit(3)

修改

db.集合名称.update(条件,修改后的数据)

按条件修改：db.spit.update({_id:"1"},{visits:NumberInt(1000)}) 但是此时记录中只剩下visits和id，其他属性消失了

需要使用功能$set修改：db.spit.update({_id:"2"},{$set:{visits:NumberInt(2000)}})

删除

db.集合名称.remove(条件)

全部删除：db.spit.remove({})

条件删除：db.spit.remove({visits:1000})

统计条数

db.spit.count()

例：db.spit.count({userid:"1013"})

模糊查询

/模糊查询字符串/ （通过正则表达式实现的）

查询内容包含“流量”的所有文档：db.spit.find({content:/流量/})

查询内容中以“加班”开头的：db.spit.find({content:/^加班/})

大于小于不等于

db.集合名称.find({ "field" : { $gt: value }}) // 大于: field > value 

db.集合名称.find({ "field" : { $lt: value }}) // 小于: field < value 

db.集合名称.find({ "field" : { $gte: value }}) // 大于等于: field >= value 

db.集合名称.find({ "field" : { $lte: value }}) // 小于等于: field <= value 

db.集合名称.find({ "field" : { $ne: value }}) // 不等于: field != value

查询浏览量大于1000的记录：db.spit.find({visits:{$gt:1000}})

包含与不包含

• 包含使用 $in 操作符

  查询集合中userid字段包含1013和1014的文档 ：

  db.spit.find({userid:{$in:["1013","1014"]}})

• 不包含使用 $nin 操作符

  查询集合中userid字段不包含1013和1014的文档：

  db.spit.find({userid:{$nin:["1013","1014"]}})

条件连接

• $and

  $and:[ { },{ },{ } ]

  查询集合中visits大于等于1000 并且小于2000的文档：

  db.spit.find({$and:[ {visits:{$gte:1000}} ,{visits:{$lt:2000} }]})

• $or

  $or:[ { },{ },{ } ]

  查询集合中userid为1013，或者浏览量小于2000的文档记录

  db.spit.find({$or:[ {userid:"1013"} ,{visits:{$lt:2000} }]})

列值增长

想实现对某列值在原有值的基础上进行增加或减少，可以使用 $inc 运算符来实现：

db.spit.update({_id:"2"},{$inc:{visits:NumberInt(1)}} )

SpringBoot整合MongoDB

引入依赖

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

spring:
  application:
    name: demo-project
  data:
    mongodb:
      host: 172.22.73.25
      database: spitdb

Demo

测试MongoDB基本功能

import com.mongodb.BasicDBObject;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * mongodb 测试
 *
 * @author kai_qian
 * @version v1.0
 * @since 2020/03/06 10:03
 */
public class MongoDBDemo {
    public static void main(String[] args) {
        // 创建连接
        MongoClient mongoClient = new MongoClient("172.22.73.25");
        // 打卡数据库
        MongoDatabase spitdb = mongoClient.getDatabase("spitdb");
        // 获取集合
        MongoCollection<Document> spit = spitdb.getCollection("spit");
        // 查询记录获取文档集合
        FindIterable<Document> documents = spit.find();
        System.out.println("查询记录获取文档集合");
        printDocument(documents);

        // 查询浏览量大于1000的记录
        // 构建查询条件
        BasicDBObject bson = new BasicDBObject("visits", new BasicDBObject("$gt", 1000));
        FindIterable<Document> documents1 = spit.find(bson);
        System.out.println("查询浏览量大于1000的记录");
        printDocument(documents1);

        // 插入数据
        Map<String, Object> map = new HashMap<>();
        map.put("content", "我要吐槽");
        map.put("userid", "9999");
        map.put("visits", 134);
        map.put("publishtime", new Date());
        Document document = new Document(map);
        spit.insertOne(document);
        System.out.println("插入了一条数据");

        FindIterable<Document> documents2 = spit.find();
        System.out.println("再次查询记录获取文档集合");
        printDocument(documents2);
        // 关闭连接
        mongoClient.close();
    }

    /**
     * 打印集合内容
     * @param documents
     */
    private static void printDocument(FindIterable<Document> documents) {
        for (Document document : documents) {
            System.out.println("------");
            System.out.println("内容:" + document.getString("content"));
            System.out.println("用户ID:" + document.getString("userid"));
            System.out.println("浏览量：" + document.getInteger("visits"));
            System.out.println("------");
        }
        System.out.println("==============");
    }
}

增删改查API

官方文档给出的Quick Start

官方文档给的说明很详细，每个操作都有详细的说明，我这里直接把所有操作做了一个整合，推荐直接去官网看文档

MongoDB 3.6：https://mongodb.github.io/mongo-java-driver/3.6/driver/getting-started/quick-start/

QuickStart

import com.mongodb.Block;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import org.bson.Document;

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

import static com.mongodb.client.model.Filters.*;
import static com.mongodb.client.model.Updates.inc;

/**
 * quick start
 *
 * @author kai_qian
 * @version v1.0
 * @since 2020/03/06 16:11
 */
public class MongoDBQuickStart {
    public static void main(String[] args) {
        // access a instance
        MongoClient mongoClient = new MongoClient("172.22.73.25");
        // access a database
        MongoDatabase database = mongoClient.getDatabase("mydb");
        // access a collection
        MongoCollection<Document> collection = database.getCollection("test");

        // create a Document 创建一个文档
        Document doc = new Document("name", "mongoDB")
                .append("type", "database")
                .append("count", 1)
                .append("versions", Arrays.asList("v3.2", "v3.0", "v2.6"))
                .append("info", new Document("x", 203).append("y", 102));

        // insert one Document 插入文档
        collection.insertOne(doc);

        // insert multiple documents 批量插入
        /// If no top-level _id field is specified in the document, MongoDB automatically adds the _id field to the inserted document.
        List<Document> documents = new ArrayList<>();
        for (int i = 0; i < 100; i++) {
            documents.add(new Document("i", i));
        }
        collection.insertMany(documents);

        // count documents in a collection 获取集合中的数量
        System.out.println(collection.countDocuments());

        // prints the first document found in the collection 获取文档集合中的第一个文档
        Document myDoc = collection.find().first();
        System.out.println(myDoc.toJson());

        // find all documents in a collection 遍历所有文档
        MongoCursor<Document> cursor = collection.find().iterator();
        try {
            while (cursor.hasNext()) {
                System.out.println(cursor.next().toJson());
            }
        }finally {
            cursor.close();
        }
        // !!! avoid its use as the application can leak a cursor if the loop terminates early
        //尽管下面的迭代习惯用法是允许的，但请避免使用它，因为如果循环提前终止，应用程序可能会泄漏游标：
//        for (Document cur : collection.find()) {
//            System.out.println(cur.toJson());
//        }

        //specify a query filter 条件过滤

        // get a single document that matches a filter 一个简单的条件过滤查询
        myDoc = collection.find(eq("i",71)).first();
        System.out.println(myDoc.toJson());

        // get all documents that match a filter
        Block<Document> printBlock = new Block<Document>() {
            @Override
            public void apply(Document document) {
                System.out.println(document.toJson());
            }
        };
        // "i" > 50
        collection.find(gt("i",50)).forEach(printBlock);
        // 50 < i <= 100
        collection.find(and(gt("i",50),lte("i",100))).forEach(printBlock);

        // update document 更新文档

        // update a single document
        collection.updateOne(eq("i", 10), new Document("$set", new Document("i", 110)));

        // update multiple documents
        UpdateResult updateResult = collection.updateMany(lt("i", 100), inc("i", 100));
        System.out.println(updateResult.getModifiedCount());

        // delete documents 删除文档

        // delete a single document that match a filter
        collection.deleteOne(eq("i", 110));

        // delete all documents that match a filter
        DeleteResult deleteResult = collection.deleteMany(gte("i", 100));
        System.out.println(deleteResult.getDeletedCount());

    }
}

QuickStart-POJOs

import com.mongodb.Block;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import com.qiankai.qqlogin.demo.mongodb.pojo.Address;
import com.qiankai.qqlogin.demo.mongodb.pojo.Person;
import org.bson.Document;
import org.bson.codecs.configuration.CodecRegistry;
import org.bson.codecs.pojo.PojoCodecProvider;

import java.util.List;

import static com.mongodb.client.model.Filters.*;
import static com.mongodb.client.model.Updates.combine;
import static com.mongodb.client.model.Updates.set;
import static java.util.Arrays.asList;
import static org.bson.codecs.configuration.CodecRegistries.fromProviders;
import static org.bson.codecs.configuration.CodecRegistries.fromRegistries;

/**
 * 类描述
 *
 * @author kai_qian
 * @version v1.0
 * @since 2020/03/06 17:19
 */
public class MongoDBQuickStartPOJOs {
    public static void main(String[] args) {
        // access a instance
        MongoClient mongoClient0 = new MongoClient("172.22.73.25");
        // access a database
        MongoDatabase database = mongoClient0.getDatabase("mydb");
        // access a collection
//        MongoCollection<Document> collection = database.getCollection("test");

        // creating a custom codecRegistry
        CodecRegistry pojoCodecRegistry = fromRegistries(MongoClient.getDefaultCodecRegistry(),
                fromProviders(PojoCodecProvider.builder().automatic(true).build()));
        // using the codecRegistry
        // 1
        MongoClient mongoClient = new MongoClient("localhost",
                MongoClientOptions.builder().codecRegistry(pojoCodecRegistry).build());
        // 2
        database = database.withCodecRegistry(pojoCodecRegistry);
        // 3
//        collection = collection.withCodecRegistry(pojoCodecRegistry);

        /// TODO inserting a POJO into MongoDB 插入操作
        // before insert, you need a  MongoCollection instance configured with the Pojo's type
        MongoCollection<Person> collection = database.getCollection("people", Person.class);

        // insert a Person
        Person ada = new Person("Ada Byron", 20, new Address("St James Square", "London", "W1"));
        collection.insertOne(ada);

        // insert many persons
        List<Person> people = asList(
                new Person("Charles Babbage", 45, new Address("5 Devonshire Street", "London", "W11")),
                new Person("Alan Turing", 28, new Address("Bletchley Hall", "Bletchley Park", "MK12")),
                new Person("Timothy Berners-Lee", 61, new Address("Colehill", "Wimborne", null))
        );
        collection.insertMany(people);

        /// TODO query the collection 查询操作
        Block<Person> printBlock = new Block<Person>() {
            @Override
            public void apply(Person person) {
                System.out.println(person);
            }
        };
        collection.find().forEach(printBlock);

        // specify a query filter
        // get a single person that matches a filter
        Person somebody = collection.find(eq("address.city", "Winborne")).first();
        System.out.println(somebody);

        // get all person instances that match a filter
        collection.find(gt("age", 30)).forEach(printBlock);

        /// TODO update documents 更新操作
        // update a single people
        collection.updateOne(eq("name", "Ada Byron"), combine(set("age", 23), set("name", "Ada Lovelace")));

        // update multiple people
        UpdateResult updateResult = collection.updateMany(not(eq("zip", null)), set("zip", null));
        System.out.println(updateResult.getModifiedCount());

        // replace a single person
        collection.replaceOne(eq("name", "Ada Lovelace"), ada);

        /// TODO delete documents 删除操作
        // delete a single person that matches a filter
        collection.deleteOne(eq("address.city", "Wimborne"));

        // delete all Persons that Match a filter
        DeleteResult deleteResult = collection.deleteMany(eq("address.city", "London"));
        System.out.println(deleteResult.getDeletedCount());
        
    }
}

Spring Data MongoDB

MongoRepository

MongoRepository接口关系

interface MongoRepository<T, ID> extends PagingAndSortingRepository<T, ID>, QueryByExampleExecutor<T>

继承了两个接口，PagingAndSortingRepository 和 QueryByExampleExecutor

• 先看看PagingAndSortingRepository接口

  interface PagingAndSortingRepository<T, ID> extends CrudRepository<T, ID>

  分页和排序接口，PagingAndSorting接口包含两个方法:

  Iterable<T> findAll(Sort var1);
  
  Page<T> findAll(Pageable var1);
  

  例如，访问第二页，每页20条数据：Page<User> users = repository.findAll(PageRequest.of(1, 20));

  并且继承了CrudRepository接口，CurdRepository中方法如下：

  interface CrudRepository<T, ID> extends Repository<T, ID>

  <S extends T> S save(S entity);
  
  <S extends T> Iterable<S> saveAll(Iterable<S> entities);
  
  Optional<T> findById(ID id);
  
  boolean existsById(ID id);
  
  Iterable<T> findAll();
  
  Iterable<T> findAllById(Iterable<ID> ids);
  
  long count();
  
  void deleteById(ID id);
  
  void delete(T entity);
  
  void deleteAll(Iterable<? extends T> entities);
  
  void deleteAll();
  

• 再看看QueryByExampleExecutor接口

  interface QueryByExampleExecutor<T>

  方法如下：

  <S extends T> Optional<S> findOne(Example<S> example);
  
  <S extends T> Iterable<S> findAll(Example<S> example);
  
  <S extends T> Iterable<S> findAll(Example<S> example, Sort sort);
  
  <S extends T> Page<S> findAll(Example<S> example, Pageable pageable);
  
  <S extends T> long count(Example<S> example);
  
  <S extends T> boolean exists(Example<S> example);
  

由此可见，**MongoRepository接口并没有提供update方法 **

MongoTemplate

提供了大量的方法供调用，举几个简单的增删改查的例子，剩下方法慢慢探索就好

@Component
public class UserDao {

	@Autowired
    private MongoTemplate mongoTemplate;
	
	// 新增
    public void saveUser(User user) {
        mongoTemplate.save(user);
    }

	// 查询
    public User findUserByUsername(String userName) {
        // 构造查询条件
        Query query = new Query(Criteria.where("userName").is(userName));
        User user = mongoTemplate.findOne(query, User.class);
        return user;
    }

	// 修改
    public long updateUser(User user) {
        // 构造查询条件
        Query query = new Query(Criteria.where("id").is(user.getId()));
        // 更新内容
        Update update = new Update().set("userName", user.getUserName())
                .set("passWord", user.getPassWord());
        // 更新查询返回结果集的第一条
        UpdateResult result = mongoTemplate.updateFirst(query, update, User.class);
        // 更新查询返回结果集的所有
//        mongoTemplate.updateMulti(query, update, User.class);
        if (result != null) {
            return result.getMatchedCount();
        }
        return 0;
    }

	// 删除
    public void deleteUserById(Long id) {
        Query query = new Query(Criteria.where("id").is(id));
        mongoTemplate.remove(query, User.class);
    }
}