Mongodb 前端和后端集成

一、前端篇

1.1mongoose介绍

Mongoose 是一个对象文档模型库，官网 http://www.mongoosejs.net/
方便使用代码操作 mongodb 数据库
pnpm i mongoose@5.13.15

1.2初步使用

import mongoose from 'mongoose';
//设置 strictQuery 为 true
mongoose.set('strictQuery', true);
//3. 连接 mongodb 服务                        数据库的名称,没有会自动创建
mongoose.connect('mongodb://user:pwd@ip:27017/admin2');
console.log('1111111');
//4. 设置回调
// 设置连接成功的回调  once 一次   事件回调函数只执行一次
mongoose.connection.once('open', () => {
        console.log('连接成功');
        //5. 创建文档的结构对象
        //设置集合中文档的属性以及属性值的类型
        const BookSchema = new mongoose.Schema({
            name: String,
            author: String,
            price: Number
        });
        
        //6. 创建模型对象  对文档操作的封装对象
        const BookModel = mongoose.model('book', BookSchema);
        //7. 新增文档
        //7. 新增
        BookModel.create({
            name: '西游记111111111111111',
            author: '吴承恩',
            price: 19.9
        }, (err, data) => {
            //判断是否有错误
            if (err) {
                console.log(err);
                return;
            }
            //如果没有出错, 则输出插入后的文档对象
            console.log(data);
            // //8. 关闭数据库连接 (项目运行过程中, 不会添加该代码)
            // mongoose.disconnect();
        });

    }
);

// 设置连接错误的回调
mongoose.connection.on('error', () => {
    console.log('连接失败');
});

//设置连接关闭的回调
mongoose.connection.on('close', () => {
    console.log('连接关闭');
});

// 关闭 mongodb 的连接
// setTimeout(() => {
//   mongoose.disconnect();
// }, 2000)

1.3字段类型

1.4字段值验证

Mongoose 有一些内建验证器，可以对字段值进行验证

• 必填项

title: {
type: String,
required: true // 设置必填项
},

• 默认值

author: {
type: String,
default: '匿名' //默认值
},

• 唯一值

username: {
type: String,
unique: true
},
## unique 需要 重建集合 才能有效果

• 总结

 let BookSchema = new mongoose.Schema({
            name: {
                type: String,
                required: true, // 表明该属性必须不为空
                unique: true// 设置为独一无二的
            },
            author: {
                type: String,
                default: '匿名'
            },
            //类型
            style: {
                type: String,
                //枚举
                enum: ['言情','城市','志怪','恐怖']
            },
            price: Number
        });

1.5CURD

数据库的基本操作包括四个，增加（create），删除（delete），修改（update），查（read）

• 增加

import mongoose from 'mongoose';
// 设置 strictQuery 为 true
mongoose.set('strictQuery', true);
// 连接 MongoDB 服务
mongoose.connect('mongodb://user:1213@118.89.91.246:27017/admin2');
console.log('1111111');

// 设置连接成功、失败和关闭的回调
mongoose.connection.once('open', () => {
  console.log('连接成功');

  // 定义 Phone 文档结构
  const PhoneSchema = new mongoose.Schema({
    brand: String,
    color: String,
    price: Number,
    tags: [String],
  });

  // 创建 Phone 模型
  const PhoneModel = mongoose.model('phone', PhoneSchema);

  // 批量插入 Phone 记录
  PhoneModel.insertMany([
    {
      brand: '华为',
      color: '灰色',
      price: 2399,
      tags: ['电量大', '屏幕大', '信号好'],
    },
    {
      brand: '小米',
      color: '白色',
      price: 2099,
      tags: ['电量大', '屏幕大', '信号好'],
    },
  ], (err, data) => {
    if (err) {
      throw err;
    }

    console.log('写入成功');
    mongoose.connection.close();
  });
});

mongoose.connection.on('error', () => {
  console.log('连接失败');
});

mongoose.connection.on('close', () => {
  console.log('连接关闭');
});

• 删除

删除一条数据
SongModel.deleteOne({_id:'5dd65f32be6401035cb5b1ed'}, function(err){
if(err) throw err;
console.log('删除成功');
mongoose.connection.close();
});

批量删除
SongModel.deleteMany({author:'Jay'}, function(err){
if(err) throw err;
console.log('删除成功');
mongoose.connection.close();
});

• 更新

更新一条数据
SongModel.updateOne({author: 'JJ Lin'}, {author: '林俊杰'}, function (err) {
if(err) throw err;
mongoose.connection.close();
});


批量更新数据
SongModel.updateMany({author: 'Leehom Wang'}, {author: '王力宏'}, function (err) {
if(err) throw err;
mongoose.connection.close();
});

• 查询

查询一条数据
SongModel.findOne({author: '王力宏'}, function(err, data){
if(err) throw err;
console.log(data);
mongoose.connection.close();
});
//根据 id 查询数据
SongModel.findById('5dd662b5381fc316b44ce167',function(err, data){
if(err) throw err;
console.log(data);
mongoose.connection.close();
});

批量查询数据
//不加条件查询
SongModel.find(function(err, data){
if(err) throw err;
console.log(data);
mongoose.connection.close();
});
//加条件查询
SongModel.find({author: '王力宏'}, function(err, data){
if(err) throw err;
console.log(data);
mongoose.connection.close();
});

条件控制

• 运算符

 在 mongodb 不能 > < >= <= !== 等运算符，需要使用替代符号
> 使用 $gt
< 使用 $lt
>= 使用 $gte
<= 使用 $lte
!== 使用 $ne
db.students.find({id:{$gt:3}}); id号比3大的所有的记录

• 逻辑运算

$or 逻辑或的情况
db.students.find({KaTeX parse error: Expected 'EOF', got '}' at position 23: …e:18},{age:24}]}̲); `and 逻辑与的情况db.students.find({$and: [{age: {$lt:20}}, {age: {$gt: 15}}]});正则匹配条件中可以直接使用 JS 的正则语法，通过正则可以进行模糊查询

1.6个性化读取

• 字段筛选

//0:不要的字段
//1:要的字段
SongModel.find().select({_id:0,title:1}).exec(function(err,data){
if(err) throw err;
console.log(data);
mongoose.connection.close();
});

• 数据排序

//sort 排序
//1:升序
//-1:倒序
SongModel.find().sort({hot:1}).exec(function(err,data){
if(err) throw err;
console.log(data);
mongoose.connection.close();
});

• 数据截取

//skip 跳过 limit 限定
SongModel.find().skip(10).limit(10).exec(function(err,data){
if(err) throw err;
console.log(data);
mongoose.connection.close();
});

二、后端篇

2.1Java操作MongoDB

方式一原生Java（了解）

方式一采用的原生Java操作MongoDB

前期准备

首先我们需要驱动，MongoDB的Java驱动我们可以直接在Maven*仓库去下载，也可以创建Maven工程添加如下依赖：

<dependency>
    <groupId>org.mongodb</groupId>
    <artifactId>mongodb-driver</artifactId>
    <version>3.5.0</version>
</dependency>

获取集合

所有准备工作完成之后，我们首先需要一个MongoClient，如下：

MongoClient client = new MongoClient("192.168.248.136", 27017);

然后通过如下方式获取一个数据库，如果要获取的数据库本身就存在，直接获取到，不存在MongoDB会自动创建：

MongoDatabase sang = client.getDatabase("sang");

然后通过如下方式获取一个名为c1的集合，这个集合存在的话就直接获取到，不存在的话MongoDB会自动创建出来，如下：

MongoCollection<Document> c = sang.getCollection("c1");

有了集合之后，我们就可以向集合中插入数据了。

增加操作

和在shell中的操作一样，我们可以一条一条的添加数据，也可以批量添加，添加单条数据操作如下：

Document d1 = new Document();
d1.append("name", "三国演义").append("author", "罗贯中");
c.insertOne(d1);

添加多条数据的操作如下：

List<Document> collections = new ArrayList<Document>();
Document d1 = new Document();
d1.append("name", "三国演义").append("author", "罗贯中");
collections.add(d1);
Document d2 = new Document();
d2.append("name", "红楼梦").append("author", "曹雪芹");
collections.add(d2);
c.insertMany(collections);

当然也可以通过 Robo 3T查看修改结果：db.集合名.find()

修改操作
可以修改查到的第一条数据，操作如下：

c.updateOne(Filters.eq("author", "罗贯中"), new Document("$set", new Document("name",

上例中小伙伴们也看到了修改器要如何使用，不管是inc，用法都一致，我这里不再一个一个演示。也可以修改查到的所有数据，如下：

c.updateMany(Filters.eq("author", "罗贯中"), new Document("$set", new Document("name", "三国演义456")));

删除操作

可以删除查到的一条数据，如下：

c.deleteOne(Filters.eq("author", "罗贯中"));

也可以删除查到的所有数据：

c.deleteMany(Filters.eq("author", "罗贯中"));

Filters里边还有其他的查询条件，都是见名知意，不赘述。

 查询操作

可以直接查询所有文档：

FindIterable<Document> documents = c.find();
MongoCursor<Document> iterator = documents.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

也可以按照条件查询：

FindIterable<Document> documents = c.find(Filters.eq("author", "罗贯中"));
MongoCursor<Document> iterator = documents.iterator();
while (iterator.hasNext()) {
    System.out.println(iterator.next());
}

方式二SpringBoot

主要讲解SpringBoot操作MongoDB实现增删改查的功能

环境准备

1、pom.xml引入依赖

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

创建application.yml

spring:
  application:
    name: mongo-test
  data:
    mongodb:
      host: 192.168.1.8
      port: 27017
      database: test
      username: mongo
      password: '1213' # 密码按char[]处理。纯数字要加单引号，最好都加单引号
      authentication-database: admin
      auto-index-creation: true # 仅声明索引注解无效，必须显式声明。

logging:
  level:
    root: warn
    com:
      example: debug
  pattern:
    console: '%-5level %C.%M[%line] - %msg%n'

概述

Spring Data

Spring 数据框架 JPA 、Redis、Elasticsearch、AMQP、MongoDB

• `JdbcTemplate`
• `RedisTemplate`
• `ElasticTempalte`
• `AmqpTemplate`
• `MongoTemplate`

相关注解讲解

• @Document 是一个注解，用于修饰类。它的作用是将这个类的一个对象映射为 MongoDB 中一条文档数据。属性 value 和 collection 用来指定操作的集合名称。
• @Id 是一个注解，用于修饰成员变量或方法。它的作用是将成员变量的值映射为文档的 _id 的值。
• @Field 是一个注解，用于修饰成员变量或方法。它的作用是将成员变量以及值映射为文档中的一个键值对。属性 name 和 value 用来指定在文档中的键的名称，默认为成员变量名。
• @Transient 是一个注解，用于修饰成员变量或方法。它的作用是指定该成员变量不参与文档的序列化。

创建实体类

创建包com.changan.mongodb，包下建包entiy 用于存放实体类，创建实体类

package com.yanyu.mongotest.entity;

import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;

import java.io.Serializable;
@Data
@Document(collection = "student")
public class Student implements Serializable {

    @Id
    private Long id;

    private String name;

    private String sex;

    private String age;

    private String introduce;

}

创建数据访问接口

com.changan.mongodb包下创建dao包，包下创建接口

package com.yanyu.mongotest.service;

import com.yanyu.mongotest.entity.Student;

import java.util.List;

public interface StudentDao {


    void save(Student student);

    void update(Student student);

    List<Student> findAll();

    void delete(Integer id);
}

创建业务逻辑类

com.changan.mongodb包下创建impl包，包下创建类

package com.yanyu.mongotest.service;

import com.yanyu.mongotest.entity.Student;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.mongodb.core.MongoTemplate;
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.stereotype.Component;


import java.util.List;

@Component
public class StudentDaoImpl implements StudentDao {

    @Autowired
    private MongoTemplate mongoTemplate;

    /**
     * 新增信息
     * @param student
     */
    @Override
    public void save(Student student) {
        mongoTemplate.save(student);
    }

    /**
     * 修改信息
     * @param student
     */
    @Override
    public void update(Student student) {

        //修改的条件
        Query query = new Query(Criteria.where("id").is(student.getId()));

        //修改的内容
        Update update = new Update();
        update.set("name",student.getName());

        mongoTemplate.updateFirst(query,update,Student.class);
         //单条更新
        mongoTemplate.updateFirst(query, update, User.class);
        //多条更新
        mongoTemplate.updateMulti(query, update, User.class);
        //更新插入
        mongoTemplate.upsert(query,update,User.class);
  
        //返回值均为 updateResult
        //System.out.println("匹配条数:" + updateResult.getMatchedCount());
        //System.out.println("修改条数:" + updateResult.getModifiedCount());
        //System.out.println("插入id_:" + updateResult.getUpsertedId());
    }

    /**
     * 查询所有信息
     * @return
     */
    @Override
    public List<Student> findAll() {
        return mongoTemplate.findAll(Student.class);
    }

    /**
     * 根据id查询所有信息
     * @param id
     */
    @Override
    public void delete(Integer id) {
        Student byId = mongoTemplate.findById(id,Student.class);
        mongoTemplate.remove(byId);
    }

}

常见查询

Criteria 是 Java Persistence API (JPA) 中的一个类，用于构建类型安全的查询。它提供了一种在不使用字符串查询语言（如 JPQL 或 SQL）的情况下创建查询的方式。通过使用 Criteria 类，你可以以编程方式构建查询，从而避免因手动编写查询字符串而产生的错误。 

 @Test
    public void testQuery(){
      //基于 id 查询
      template.findById("1",User.class);
    
      //查询所有
      template.findAll(User.class);
      template.find(new Query(),User.class);
    
      //等值查询
      template.find(Query.query(Criteria.where("name").is("编程不良人")), 
                   User.class);
    
      // > gt  < lt  >= gte  <= lte
      template.find(Query.query(Criteria.where("age").lt(25)),
                    User.class);
      template.find(Query.query(Criteria.where("age").gt(25)),
                    User.class);
      template.find(Query.query(Criteria.where("age").lte(25)),
                    User.class);
      template.find(Query.query(Criteria.where("age").gte(25)),
                    User.class);
    
      //and
      template.find(Query.query(Criteria.where("name").is("编程不良人")
                                .and("age").is(23)),User.class);
    
      //or
      Criteria criteria = new Criteria()
        .orOperator(Criteria.where("name").is("编程不良人_1"),
         Criteria.where("name").is("编程不良人_2"));
      template.find(Query.query(criteria), User.class);
    
      //and or
      Criteria criteria1 = new Criteria()
        .and("age").is(23)
        .orOperator(
        Criteria.where("name").is("编程不良人_1"),
        Criteria.where("name").is("编程不良人_2"));
      template.find(Query.query(criteria1), User.class);
    
      //sort 排序
      Query query = new Query();
      query.with(Sort.by(Sort.Order.desc("age")));//desc 降序  asc 升序
      template.find(query, User.class);
    
    
      //skip limit 分页
      Query queryPage = new Query();
      queryPage.with(Sort.by(Sort.Order.desc("age")))//desc 降序  asc 升序
        .skip(0) //起始条数
        .limit(4); //每页显示记录数
      template.find(queryPage, User.class);
    
    
      //count 总条数
      template.count(new Query(), User.class);
    
      //distinct 去重
      //参数 1:查询条件 参数 2: 去重字段  参数 3: 操作集合  参数 4: 返回类型
      template.findDistinct(new Query(), "name", 
                            User.class, String.class);
      
      //使用 json 字符串方式查询 
            Query query = new BasicQuery(
              "{$or:[{name:'编程不良人'},{name:'徐凤年'}]}", 
              "{name:0}");
    
      template.find(query, User.class);
    }

创建测试类

package com.yanyu.mongotest;

import com.yanyu.mongotest.entity.Student;
import com.yanyu.mongotest.service.StudentDao;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;

import java.util.List;

@SpringBootTest
class MongoTestApplicationTests {

    @Autowired
    private StudentDao studentDao;

    /**
     * 查询所有信息
     */
    @Test
    public void findAll() {
        List<Student> all = studentDao.findAll();
        System.out.println(all.size());
    }

    /**
     * 新增信息
     */
    @Test
    public void save() {
        Student student = new Student();
        student.setId(6l);
        student.setName("宋人头");
        studentDao.save(student);
    }

    /**
     * 修改信息
     */
    @Test
    public void update() {
        Student student = new Student();
        student.setId(6l);
        student.setName("吴很帅");
        studentDao.update(student);
    }

    /**
     * 删除信息
     */
    @Test
    public void delete() {
        studentDao.delete(6);
    }

}

2.2python调用MongoDB

分布式数据库NoSQL(七)——Python 访问MongoDB