1. Uso de MongDB
-- 显示数据库
show dbs
-- 切换/创建数据库
use dbname
-- 删除数据库
Usuarios y permisos de MongoDB
Lista de permisos de usuario
| Leer | Permitir al usuario leer la base de datos especificada |
|---|---|
| leer escribir | Permitir que el usuario lea y escriba la base de datos especificada |
| Administrador de base de datos | Permite a los usuarios realizar funciones administrativas en la base de datos especificada, como la creación de índices, la eliminación, la visualización de estadísticas o el acceso a system.profile |
| administrador de usuario | Permita que los usuarios escriban en la colección system.users, puede crear, eliminar y administrar usuarios en la base de datos especificada |
| clusterAdmin | Solo disponible en la base de datos de administración, otorgando al usuario privilegios administrativos para todas las funciones relacionadas con el conjunto de réplicas y fragmentos |
| leer cualquier base de datos | Solo disponible en la base de datos de administración, otorgando al usuario acceso de lectura a todas las bases de datos |
| readWriteAnyDatabase | Solo disponible en la base de datos de administración, otorgando a los usuarios permisos de lectura y escritura para todas las bases de datos |
| usuarioAdminAnyDatabase | Solo disponible en la base de datos de administración, otorgando al usuario permisos de administrador de usuario para todas las bases de datos |
| dbAdminAnyDatabase | Solo disponible en la base de datos de administración, otorgando al usuario privilegios dbAdmin para todas las bases de datos |
| raíz | Solo disponible en la base de datos de administración. super cuenta, super autoridad |
Adiciones, eliminaciones, comprobaciones y cambios de usuarios
①, crea un usuario (createUser)
mongodb tiene un mecanismo de administración de usuarios, descrito simplemente como, hay un grupo de usuarios de administración, los usuarios de este grupo están especialmente configurados para la administración de usuarios comunes y, por el momento, se denominan administradores. Los administradores generalmente no tienen permisos de lectura y escritura para la base de datos, sino que solo tienen la autoridad para operar usuarios, por lo que solo debemos otorgarle al administrador el rol userAdminAnyDatabase. Además, la cuenta de administrador debe crearse en la base de datos de administración.
- Cambiar al repositorio de administración
use admin
- Ver usuarios en admin
db.system.users.find()
- crear usuario
- En MongoDB, puede usar la función db.createUser({información del usuario}) para crear un usuario.
- 1) usuario: crea un nuevo nombre de usuario.
- 2) pwd: crea una nueva contraseña de usuario.
- 3) customData: almacene algunos datos personalizados relacionados con el usuario, este atributo también se puede ignorar.
- 4) roles: tipo de matriz, configurar permisos de usuario.
db.createUser({ user: "<name>", pwd: "<cleartext password>", customData: { <any information> }, roles: [ { role: "<role>", db: "<database>" } | "<role>", ... ] });
db.createUser({
user:"itxiong",pwd:"itxiong",roles:[{role:"userAdminAnyDatabase",db:"admin"}]})
- reiniciar
db.shutdownServer()
② Actualizar usuarios
- Role:
- db.updateUser("nombre de usuario", {"funciones":[{"función":"nombre de función"},{"actualizar elemento 2":"actualizar contenido"}]})
- contraseña:
- db.updateUser("nombre de usuario", {"pwd":"nueva contraseña"})
Si no aparece ningún aviso, significa que la actualización se ha realizado correctamente. Salga del cliente actual y vuelva a conectarse para que surta efecto
- actualizar rol
db.updateUser("itxiong", {
"roles":[{
"role":"userAdminAnyDatabase","db":"admin"},{
"role":"dbAdminAnyDatabase","db":"admin"}]})
- Actualiza contraseña
- Hay dos formas de actualizar las contraseñas de los usuarios:
- 1) Utilice la función db.updateUser() para actualizar la contraseña.
- 2) Use la función db.changeUserPassword() para actualizar la contraseña
- db.changeUserPassword("nombre de usuario", "nueva contraseña")
- método uno
db.changeUserPassword("itxiong","itxiong")
- forma dos
db.updateUser("itxiong",{
"pwd":"it123456"})
③ Eliminar usuario
El usuario especificado se puede eliminar a través de la función db.dropUser(). Devuelve verdadero después de una eliminación exitosa. Al eliminar un usuario, es necesario cambiar a la base de datos especificada al crear el usuario. Nota: Debe usar un usuario administrador con el rol userAdminAnyDatabse para eliminar otros usuarios. El usuario itsxt está en la base de datos sxt, por lo que primero debe cambiar a la base de datos sxt.
db.dropUser("nombre de usuario")
db.dropUser("itxiong")
④ Ver información del usuario
show users
Otras acciones del usuario
①, autenticación de usuario
De forma predeterminada, MongoDB no habilita la autenticación de usuarios. Si agregamos usuarios, debemos habilitar el mecanismo de autenticación de usuarios. Al modificar el archivo de configuración mongodb.conf, agregue auth=true al archivo. usar
cd /usr/local/mongodb/etc/
vim mongodb.conf
# 修改内容
# 指定 db 路径
dbpath=/usr/local/mongodb/data/db
# 指定日志文件
logpath=/usr/local/mongodb/log/mongodb.log
# 配置端口
port=27017
# 配置允许访问
bind_ip=0.0.0.0
# 配置后置启动
fork=true
# 开启认证
auth=true
- certificado
db.auth('nombre de usuario','contraseña')
Si el resultado devuelve 1, significa que la autenticación fue exitosa y si devuelve 0, significa que la autenticación falló. El usuario puede ser consultado después de un inicio de sesión exitoso
db.auth("itxiong","itxiong")
② Ver la relación entre usuarios y bases de datos.
Podemos ver toda la información del usuario en la biblioteca de administración a través de la función db.system.users.find().
db.system.users.find()
Colección MongoDB (tabla)
Una colección en MongoDB es un conjunto de documentos, lo que equivale a una tabla en una base de datos relacional
①, crea una colección
MongoDB usa la función db.createCollection() para crear colecciones.
- Formato: db.createCollection(nombre, opciones).
- name: El nombre de la colección a crear.
- opciones: parámetro opcional, especifica opciones sobre el tamaño de la memoria y el índice.
| campo | tipo | describir |
|---|---|---|
| tapado | booleano | (opcional) Si es verdadero, crea una colección limitada. Una colección fija es una colección con un tamaño fijo que sobrescribe automáticamente los documentos más antiguos cuando se alcanza el valor máximo. Cuando el valor es verdadero, se debe especificar el parámetro de tamaño. |
| autoIndexId | booleano | (Opcional) Si es verdadero, crea automáticamente un índice en el campo _id. El valor predeterminado es falso. |
| tamaño | valor | (Opcional) Especifique un valor máximo (en bytes) para colecciones limitadas. Si capped es verdadero, este campo también debe especificarse. |
| máximo | valor | (Opcional) Especifica el número máximo de documentos contenidos en una colección limitada. |
- colección predeterminada
db.数据库名.insert({
'xx':'xxxx'})
- sin conjunto de parámetros
db.createCollection("dev2")
- con conjunto de parámetros
db.createCollection("dev3",{capped:true,autoIndexId:true,size:2000000,max:1000})
②, eliminar colección
Si queremos eliminar una colección, debemos cambiar a la base de datos donde se debe eliminar la colección y usar la función drop() para eliminar la colección.
- Formato: db.nombre de colección.drop().
db.dev3.drop()
③, ver colección
Si desea ver las colecciones existentes, puede usar el comando show collections o show tables.
show collections
Documento MongoDB (datos de colección)
La estructura de datos de los documentos en MongoDB es básicamente la misma que en JSON. Todos los datos almacenados en la colección están en formato BSON.
manipulación de documentos
①, Insertar documento
- Formato:
- Insertar un solo documento:
- db.nombre de colección.insertar(documento).
- db.setname.insertOne(documento).
- db.nombre de colección.guardar(documento).
- Insertar varios documentos:
- db.nombre de colección.insertar([{},{},{}…]).
- db.nombre de la colección.guardar([{},{},{}…])
- db.nombre de la colección.insertMany([{},{},{},…]).
- prueba
- documento único
-- insert 函数
db.dev2.insert({title:'java',description:'编程语言',url:'www.baodu.com',tags:['file','io','string']})
-- insertOne 函数
db.dev2.insertOne({title:'css',description:'编程语言',url:'www.baodu.com',tags:['id','class','*']})
-- save 函数
db.dev2.save({title:'html',description:'编程语言',url:'www.baodu.com',tags:['p','div','span']})
- varios documentos
-- insertMany 函数
db.dev2.insertMany([{title:'java',tags:['JavaSE','JavaEE','JavaME']},{title:'ORM',tags:['Mybatis','Hibernate']},{title:'Spring',tags:['SpringMVC','SpringBoot','SpringCloud']}])
② Modificar el documento
MongoDB actualiza los documentos de la colección a través de la función de actualización o la función de guardar.
-
Formato:
-
Actualizar todo (borrar): db.nombre de colección.actualizar({condición de consulta},{actualizar contenido},{actualizar parámetros (opcional)})
-
Actualización del operador: db.nombre de colección.actualización({condición de consulta},{operador de actualización:{actualizar contenido}},{parámetro de actualización (opcional)})
-
Reemplace el documento de origen: db.nombre de la colección.save({document})
nota\textcolor{rojo}{nota}Nota : el método save() reemplaza el documento existente con el documento pasado.
-
-- update 函数
db.dev2.update({title:"xxx"},{title:"xxx"})
-- save 函数
db.dev2.save({_id: ObjectId("63a94e3e2371d5f083222b02"),title:"SpringCloud1",tags: [ "Spring Cloud Netflix", "Spring Cloud Consul" ] })
actualizar parámetros
| parámetro | efecto |
|---|---|
| multi | Implementar actualizaciones por lotes. El valor predeterminado es falso y la modificación por lotes se cambia a verdadero |
operador de actualización
| operador | efecto |
|---|---|
| $establecer | Se utiliza para especificar una clave y actualizar el valor de la clave, si la clave no existe y crearla. |
| $inc | Puede aumentar o disminuir una clave cuyo valor sea un número en el documento (solo puede ser un número que cumpla con los requisitos). |
| $desarmado | Se utiliza principalmente para eliminar claves. |
| $ empujar | Agrega un elemento de matriz a una clave de un tipo de matriz en el documento, sin filtrar datos duplicados. Cuando la clave existe al agregar, se requiere que el tipo clave-valor sea una matriz, si la clave no existe, se crea una clave de tipo matriz. |
| $ pop | Eliminar elementos de datos. 1 significa eliminar del final de la matriz, -1 significa eliminar elementos del encabezado de la matriz |
| $tirar | Elimina los elementos que cumplen la condición de la matriz. |
| $pullAll | Eliminar múltiples elementos de una matriz que satisfacen una condición |
| $renombrar | Cambiar el nombre de la clave. |
- el caso
-- multi 批量修改
db.dev2.update({title:"java"},{$set:{title:"java学习",num:1}},{multi:true})
-- $set 操作符
db.dev2.update({title:"java"},{$set:{title:"java",tags:["spring","springmvc"]}})
-- $inc 操作符
db.dev2.update({title:"java学习"},{$inc:{num:5}})
-- $unset 操作符
db.dev2.update({title:"SpringCloud"},{$unset:{tags:[ "Spring Cloud Netflix"]}})
-- $push 操作符
db.dev2.update({title:"SpringCloud"},{$push:{tags:"Spring Data Redis"}})
-- $pop 操作符
db.dev2.update({title:"SpringCloud2"},{$pop:{tags:1}})
db.dev2.update({title:"SpringCloud2"},{$pop:{tags:-1}})
-- $pull 操作符
db.dev2.update({title:"SpringCloud4"},{$pull:{tags:"Spring Cloud Security"}})
-- $pullAll 操作符
db.dev2.update({title:"SpringCloud"},{$pullAll:{tags:[ "Spring Cloud Netflix"]}})
-- $rename 操作符
db.dev2.update({title:"SpringCloud"},{$rename:{tags:"tag"}})
③, eliminar el documento
eliminar función
Use la función remove() para eliminar un documento específico en una colección.
- Formato: db.nombre de colección.remove({condición de eliminación especificada}, parámetro de eliminación (parámetro opcional))
nota\textcolor{rojo}{nota}Nota : el método remove() en realidad no libera espacio. Necesita continuar ejecutando db.repairDatabase() para recuperar espacio en disco.
-- 指定条件删除
db.dev2.remove({title:"SpringCloud"})
db.repairDatabase()
-- 删除所有
db.dev2.remove({})
db.repairDatabase()
eliminarUna función
La función deleteOne() es el método oficial recomendado para eliminar documentos. Este método solo elimina el primer documento que cumple la condición.
- Formato: db.nombre de la colección.deleteOne({condición de eliminación especificada})
-- 指定条件删除
db.dev2.deleteOne({title:"java学习"})
función deleteMany
La función deleteMany es el método de eliminación recomendado oficialmente. Este método elimina todos los datos que cumplen la condición.
- Formato: db.nombre de colección.deleteMany({condición de eliminación especificada})
-- 指定条件删除
db.dev2.deleteMany({title:"java学习"})
-- 删除所有
db.dev2.deleteMany({})
④, ver el documento
función buscar()
Los documentos se pueden consultar en MongoDB utilizando la función find().
- Formato:
- Método 1: db.nombre de colección.find({condición de consulta (opcional)},{clave de proyección especificada (opcional)})
- Método 2 (proyección): db.nombre de la colección.find({condición de consulta},{nombre de la clave de proyección: 1(mostrar la columna)|0(no mostrar la columna),nombre de la clave de proyección:1|0,... })
- Método 3 (condición): db.nombre de la colección.find({clave:{operador:condición}})
- Aviso:
- Si no se proporciona ningún parámetro, significa consultar todos los datos.
- bonito ( ) \textcolor{Cian}{bonito()}La función pre tt y ( ) puede mostrar todos los documentos formateados.
- límite ( número ) \textcolor{Cian}{límite(número)}La función de límite ( n u m ) lee el número especificado de registros de datos.
- saltar ( número ) \textcolor{Cyan}{saltar (número)}s ki p ( n u m ) salta el número especificado de datos
- Tenga en cuenta que las condiciones de consulta no se pueden colocar entre comillas dobles o simples cuando se utiliza una consulta aproximada.
función de consulta
| Nombre de la función | efecto |
|---|---|
| bonito() | Las funciones se pueden utilizar para mostrar todos los documentos de forma formateada. |
| límite | La función lee el número especificado de registros de datos. |
| saltar (num) | Omitir el número especificado de datos |
| ordenar ({clave de clasificación: 1}) | Especifique el campo para ordenar por parámetro. 1 para orden ascendente y -1 para orden descendente. |
| explicar() | Ver plan de consulta detallado |
parámetros de consulta difusos
| condición | efecto |
|---|---|
| /^condición/ | Use ^: para indicar la posición inicial |
| /condición$/ | Utilice $: para indicar la posición final. |
| /condición/ | Contenido con condición |
Parámetros de operación de proyección
| parámetro | significado | ejemplo |
|---|---|---|
| 1 | mostrar la columna | {nombre de clave de proyección: 1, nombre de clave de proyección: 1,...} |
| 0 | no mostrar esta columna | {nombre de clave de proyección: 0, nombre de clave de proyección: 0,...} |
| incompleto | 默认，不显示该列 | ------------------------------------ |
条件操作符
条件操作符用于比较两个表达式并从 mongoDB 集合中获取数据。
| 操作符 | 名称 | 作用 |
|---|---|---|
| $gt | (>) 大于操作符 | 使用$gt 操作做大于的条件判断。该操作符可以数字或日期进行判断。 |
| $lt | (<) 小于操作符 | 使用$lt 操作做小于的条件判断。该操作符可以数字或日期进行判断。 |
| $gte | (>=)大于或等于操作符 | 使用$gte 操作做大于或等于的条件判断。该操作符可以数字或日期进行判断。 |
| $lte | (<=)小于或等于操作符 | 使用$lte 操作做小于或等于的条件判断。该操作符可以数字或日期进行判断。 |
| $eq | (==)等于操作符 | 使用$eq 操作做相等的条件判断。 |
| $ne | (!=)不等操作符 | 使用$ne 操作做不等的条件判断 |
| $and | find({$and:[{条件一},{,条件二},…]}) | 使用$and 操作符来表示多条件间的并且关系。 |
| $or | find({$or:[{条件一},{条件二},…]}) | 使用$or 操作符来表示多条件间的或者关系。 |
| $type | $type 操作符是基于 BSON 类型来检索集合中匹配的数据类型，并返回结果。 |
示例
-- 查询所有数据
db.dev2.find()
-- 格式化显示所有数据
db.dev2.find().pretty()
-- 查询指定数量的数据
db.dev2.find().limit(2)
-- 查询跳过指定数量的数据
db.dev2.find().skip(3)
-- 排序查询
db.dev2.find().sort({
index:1})
-- 查询指定数据（格式化）
db.dev2.find({title:"html"}).pretty()
-- 模糊查询
db.dev2.find({title:/p/})
db.dev2.find({title:/^S/})
db.dev2.find({title:/1$/})
-- 投影操作
db.dev2.find({title:/S/},{_id:0,title:1,tags:1})
-- 条件操作符
-- $gt 操作符
db.dev3.find({size:{$gt:300}})
-- $lt 操作符
db.dev3.find({size:{$lt:300}})
-- $gte 操作符
db.dev3.find({size:{$gte:300}})
-- $lte 操作符
db.dev3.find({size:{$lte:300}})
-- $eq 操作符
db.dev3.find({size:{$eq:300}})
-- $ne 操作符
db.dev3.find({size:{$ne:300}})
-- $and 操作符
db.dev3.find({$and:[{size:{$gt:100}},{size:{$lt:300}}]})
-- $or 操作符
db.dev3.find({$or:[{size:{$gt:400}},{size:{$lt:200}}]})
-- $and和$or 综合
db.dev3.find({$or:[{$and:[{title:{$eq:"test5"}},{size:500}]},{size:{$lt:400}}]})
-- $type 操作符
db.dev3.find({title:{$type:"number"}})
findOne()函数
- 格式：
- 方式一：db.集合名.findOne({查询条件(可选)},{投影操作(可选)})
- 方式二(投影)：db.集合名.findOne({查询条件},{投影键名:1(显示该列)|0(不显示该列),投影键名:1|0,…})
- 方式三(条件)：db.集合名.findOne({键:{操作符:条件}})
- 注意
- findOne()函数只返回满足条件的第一条数据。
- 未做投影操作该方法则自带格式化功能。
模糊查询参数
| 条件 | 作用 |
|---|---|
| /^condition/ | 使用^：表示起始位置 |
| /condition$/ | 使用$：表示结尾位置。 |
| /condition/ | 含有condition的内容 |
投影操作参数
| 参数 | 含义 | 示例 |
|---|---|---|
| 1 | 显示该列 | {投影键名:1,投影键名:1,…} |
| 0 | 不显示该列 | {投影键名:0,投影键名:0,…} |
| 未写全 | 默认，不显示该列 | ------------------------------------ |
条件操作符
条件操作符用于比较两个表达式并从 mongoDB 集合中获取数据。
| 操作符 | 名称 | 作用 |
|---|---|---|
| $gt | (>) 大于操作符 | 使用$gt 操作做大于的条件判断。该操作符可以数字或日期进行判断。 |
| $lt | (<) 小于操作符 | 使用$lt 操作做小于的条件判断。该操作符可以数字或日期进行判断。 |
| $gte | (>=)大于或等于操作符 | 使用$gte 操作做大于或等于的条件判断。该操作符可以数字或日期进行判断。 |
| $lte | (<=)小于或等于操作符 | 使用$lte 操作做小于或等于的条件判断。该操作符可以数字或日期进行判断。 |
| $eq | (==)等于操作符 | 使用$eq 操作做相等的条件判断。 |
| $ne | (!=)不等操作符 | 使用$ne 操作做不等的条件判断 |
| $and | find({$and:[{条件一},{,条件二},…]}) | 使用$and 操作符来表示多条件间的并且关系。 |
| $or | find({$or:[{条件一},{条件二},…]}) | 使用$or 操作符来表示多条件间的或者关系。 |
| $type | $type 操作符是基于 BSON 类型来检索集合中匹配的数据类型，并返回结果。 |
示例
-- 查询第一条数据
db.dev2.findOne()
-- 模糊查询
db.dev2.findOne({title:/p/})
db.dev2.findOne({title:/^S/})
db.dev2.findOne({title:/1$/})
-- 投影操作
db.dev2.findOne({title:/c/},{_id:0,title:1,description:1,url:1})
-- 条件操作符
-- $gt 操作符
db.dev3.findOne({size:{$gt:300}})
-- $lt 操作符
db.dev3.findOne({size:{$lt:300}})
-- $gte 操作符
db.dev3.findOne({size:{$gte:300}})
-- $lte 操作符
db.dev3.findOne({size:{$lte:300}})
-- $eq 操作符
db.dev3.findOne({size:{$eq:300}})
-- $ne 操作符
db.dev3.findOne({size:{$ne:300}})
-- $and 操作符
db.dev3.findOne({$and:[{size:{$gt:100}},{size:{$lt:300}}]})
-- $or 操作符
db.dev3.findOne({$or:[{size:{$gt:400}},{size:{$lt:200}}]})
-- $and和$or 综合
db.dev3.findOne({$or:[{$and:[{title:{$eq:"test5"}},{size:500}]},{size:{$lt:400}}]})
-- $type 操作符
db.dev3.findOne({title:{$type:"number"}})
文档其他操作
①、变量定义
Mongo Shell 工具允许我们定义变量。所有的变量类型为 var 类型。也可忽略变量类型。变量中赋值符号后侧需要使用小括号来表示变量中的值。我们可以将变量作为任意插入文档的函数的参数。
- 格式：
- 单个文档：变量名=({变量值})
- 多个文档：变量名=([{},{},{},…])
-- 定义变量 1
document=({title:'SpringCloud',tags:['Spring Cloud Netflix','Spring Cloud Security','Spring Cloud Consul']})
-- 定义变量 2
docu=([{title:'SpringCloud2',tags:['Spring Cloud Netflix','Spring Cloud Security','Spring Cloud Consul']},{title:'SpringCloud3',tags:['Spring Cloud Netflix','Spring Cloud Security','Spring Cloud Consul']},{title:'SpringCloud4',tags:['Spring Cloud Netflix','Spring Cloud Security','Spring Cloud Consul']}])
-- 使用变量
db.dev2.insert(document)
db.dev2.insert(docu)
MongoDB索引(文档索引)
索引操作
①、创建索引
在创建索引时，需要使用具有 dbAdmin 或者 dbAdminAnyDatabase 角色的用户。
- 格式：db.集合名.createIndex({创建索引的键:排序规则,…},{创建索引的参数(可选参数)})
排序规则
| 规则 | 含义 |
|---|---|
| 1 | 按照升序规则创建索引 |
| -1 | 按照降序规则创建索引。 |
参数
| 参数 | 数据类型 | 默认值 | 功能 |
|---|---|---|---|
| background | Boolean | false | 后台创建索引 |
| unique | Boolean | false | 创建唯一索引 |
| name | String | 指定索引名称，如果未指定，MongoDB指挥满足过滤表达式的记录 | |
| partialFilterExpression | document | 如果指定MongoDB指挥满足过滤表达式的记录 | |
| sparse | Boolean | false | 对文档中不存在的字段数据不启用索引 |
| expireAfterSeconds | integer | 指定索引的过期时间 | |
| storageEngine | document类型允许用户配置索引的存储引擎 |
-- 创建索引：1（升序）、background（后台创建索引）
db.dev3.createIndex({title:1},{background:true})
②、修改索引
MongoDB 没有单独的修改索引函数，如果要修改某个索引，需要先删除旧的索引，再创建新的索引。
③、删除索引
- 我们可以通过 d r o p I n d e x ( ) \textcolor{Cyan}{dropIndex()} dropIndex()函数来删除指定索引。
- 我们可以使用 d r o p I n d e x e s ( ) \textcolor{Cyan}{dropIndexes()} dropIndexes()函数删除集合中的全部索引，_id 键的索引除外。
-
- 格式：
- 方式一：db.集合名.dropIndex(“索引名称”)。
- 方式二：db.集合名.dropIndexes()
-- 删除指定索引
db.dev3.dropIndex("title_1")
-- 删除全部索引
db.dev3.dropIndexes()
④、查看索引
- 我们可以通过 g e t I n d e x e s ( ) \textcolor{Cyan}{getIndexes()} getIndexes()或者 g e t I n d e x S p e c s ( ) \textcolor{Cyan}{getIndexSpecs()} getIndexSpecs()函数查看集合中的所有索引信息。
- 我们可以通过使用 g e t I n d e x K e y s ( ) \textcolor{Cyan}{getIndexKeys()} getIndexKeys()函数查看集合的索引键。
- 我们可以通过 t o t a l I n d e x S i z e ( ) \textcolor{Cyan}{totalIndexSize()} totalIndexSize()函数来查看当前集合中索引的大小，单位为字节。
-
查看集合索引
- 方式一：db.集合名.getIndexse()
- 方式二：db.集合名.getIndexSpecs()
-
查看索引键
- 格式：db.集合名.getIndexKeys();
-
查看索引大小
-
格式：db.集合名.totalIndexSize([detail](可选参数))
-
参数解释：
detail 含义 除 0 或 false 外的任意数据 显示该集合中每个索引的大小及集合中索引的总大小。 0 或 false 只显示该集合中所有索引的总大小。默认值为 false。
-
-
-- 查看集合索引 getIndexes
db.dev3.getIndexes()
-- 查看集合索引 getIndexSpecs
db.dev3.getIndexSpecs()
-- 查看所有索引键
db.dev3.getIndexKeys()
-- 查看索引大小
db.dev3.totalIndexSize()
db.dev3.totalIndexSize([1])
--
索引类型
①、单字段索引
- 所谓单字段索引是指在 索引中只包含了一个键 \textcolor{red}{索引中只包含了一个键} 索引中只包含了一个键。查询时，可加速对该字段的各种查询请求，是最常见的索引形式。
- MongoDB 默认创建的_Id 索引也是这种类型。
- 我们可以使用createIndexes({索引键：排序规则})函数来创建单字段索引。
- 格式：db.集合名.createIndex({索引键名:排序规则})
-- 创建单字段索引
db.dev3.createIndex({title:1},{background:true})
②、交叉索引
- 所谓交叉索引就是为一个集合的 多个字段分别建立索引 \textcolor{red}{多个字段分别建立索引} 多个字段分别建立索引，在查询的时候通过多个字段作为查询条件，这种情况称为交叉索引。
- 在查询文档时，在查询条件中包含一个交叉索引键或者在一次查询中使用多个交叉索引键作为查询条件都会触发交叉索引。
-- 创建交叉索引
db.dev3.createIndex({title:1},{background:true})
db.dev3.createIndex({size:1},{background:true})
③、复合索引
复合索引是单字段的升级版本，它针对 多个字段联合创建索引 \textcolor{red}{多个字段联合创建索引} 多个字段联合创建索引，先按第一个字段排序，第一个字段相同的文档按第二个字段排序，依次类推。
- 格式：db.集合名.createIndex({索引键名:排序规则, 索引键名:排序规则,…});
-- 创建复合索引
db.dev3.createIndex({title:1,size:1})
④、多key索引
当 索引的字段为数组 \textcolor{red}{索引的字段为数组} 索引的字段为数组时，创建出的索引称为多 key 索引，多 key 索引会为数组的每个元素建立一条索引。
- 格式：db.集合名.createIndex({数组键名:排序规则});
-- 创建多Key索引
db.dev3.createIndex({tags:1})
⑤、唯一索引
唯一索引会保证索引对应的键不会出现相同的值，比如_id 索引就是唯一索引。如果唯一索引所在字段有重复数据写入时，抛出异常。
- 格式：db.集合名.createIndex({索引键名:排序规则},{unique:true})
-- 创建唯一索引：unique（唯一索引）
db.dev3.createIndex({title:1},{
unique:true})
⑥、部分索引
- 部分索引是只针对符合某个特定条件的文档建立索引，3.2 版本才支持该特性。
- MongoDB 部分索引只为那些在一个集合中，满足指定的筛选条件的文档创建索引。由于部分索引是一个集合文档的一个子集，因此部分索引具有较低的存储需求，并降低了索引创建和维护的性能成本。
- 部分索引通过指定过滤条件来创建，可以为 MongoDB 支持的所有索引类型使用部分索引。
- 格 式 ： db.集合名.createIndex({ 索引键名 : 排 序 规则},{partialFilterExpression:{键名:{匹配条件:条件值}}})
-- 创建部分索引
db.dev3.createIndex({size:1},{partialFilterExpression:{size:{$gt:300}}})
⑦、稀疏索引
- 稀疏索引仅包含具有索引字段的文档的条目，即使索引字段包含空值也是如此。索引会跳过缺少索引字段的任何文档。
- 索引是“稀疏的”，因为它不包含集合的所有文档。相反，非稀疏索引包含集合中的所有文档，为那些不包含索引字段的文档存储空值。
- 格式：db.集合名.createIndex({索引键名:排序规则},{sparse:true})
-- 创建稀疏索引
db.dev3.createIndex({tag:1},{sparse:true})
MongoDB正则查询
MongoDB 中查询条件也可以使用正则表达式作为匹配约束。
- 格式
- 方式一：db.集合名.find({字段名:正则表达式});
- 方式二：db.集合名.find({字段名:{$regex:正则表达式,$options:正则选项}});
- 正则表达式格式
- 表达式：/condition/正则选项
正则选项
| 正则选项 | 作用 |
|---|---|
| i | 不区分大小写以匹配大小写的情况。 |
| m | 多行查找，如果内容里面不存在换行符号或者条件上没有（start/end），该选项没有任何效果 |
| x | 设置 x 选项后，正则表达式中的非转义的空白字符将被忽略。需要$regex 与$options |
| s | 允许点字符（即.）匹配包括换行符在内的所有字符。需要$regex 与$options 语法 |
运算逻辑符
| 逻辑符 | 作用 |
|---|---|
| $in | 字段满足条件1或条件2或条件3…的数据 |
| $not | 字段不满足条件的数据 |
| $nin | 字段不满足条件1或条件2或条件3…的数据 |
示例
-- ^：以条件开头，i：忽略大小写
-- 方式一
db.dev2.find({title:/^s/i})
-- 方式二
db.dev2.find({title:{$regex:/^s/i}})
-- $：以条件结尾，i：忽略大小写
-- 方式一
db.dev2.find({title:/G$/i})
-- 方式二
db.dev2.find({title:{$regex:/G/,$options:"i"}})
-- 包含
-- 方式一
db.dev2.find({title:/ing/})
-- 方式二
db.dev2.find({title:{$regex:/ing/}})
-- $in
db.dev2.find({title:{$in:[/^s/i,/^j/]}})
-- $not
db.dev2.find({title:{$not:/^s/i}})
-- $nin
db.dev2.find({title:{$nin:[/^s/i,/^c/]}})
MongoDB聚合查询
在 MongoDB 中我们可以通过 aggregate()函数来完成一些聚合查询，aggregate()函数主要用于处理诸如统计,平均值,求和等，并返回计算后的数据结果。
-
格式：
db.集合名.aggregate([ {$group: {_id:"$分组键名","$分组键名",...,别名:{聚合运算:"$运算列"}} }, {条件筛选: {键名:{运算条件:运算值}} } ])
聚合函数
| mongodb聚合操作 | 含义 | SQL函数 |
|---|---|---|
| $match | 查询集合有多少文档满足条件。 表聚合之前进行条件筛选。 | where |
| $group | 分组。 | group by |
| $match | 查询集合有多少文档满足条件。 表聚合之后进行条件筛选。 | having |
| $project | 使用$project 操作符做聚合投影操作。 | select |
| $sort | order by | |
| $limit | limit | |
| $sum | 集合中的所有指定键中的值的总和。（聚合运算） | sum |
| $sum | 查询集合中一共有多少个文档。（聚合运算） | count |
| $lookup | join |
运算函数
| 函数 | 作用 |
|---|---|
| $max | 查询集合中指定键最大的文档。 |
| $min | 查询集合中指定键最小的文档。 |
| $avg | 查询集合中指定键的平均值 |
| $push | 查询集合，按照指定键(_id)分组并返回指定键($push)，使用数组返回他们的指定键($push)。 |
| $unwind | 查询集合，将数组中的内容拆分显示。 |
示例
-- $sum：查询集合中一共有多少个文档
db.dev2.aggregate([{$group:{_id:null,count:{$sum:1}}}])
-- $sum：集合中的所有指定键中的值的总和
db.dev3.aggregate([{$group:{_id:$title,totalSize:{$sum:"$size"}}}])
-- $match：查询集合有多少文档满足条件
db.dev3.aggregate([{$match:{size:{$gt:200}}},{$group:{_id:null,totalSize:{$sum:1}}}])
db.dev3.aggregate([{$group:{_id:"$title",totalSize:{$sum:"$size"}}},{$match:{totalSize:{$gt:200}}}])
-- $max：查询集合中指定键最大的文档
db.dev3.aggregate([{$group:{_id:null,maxSize:{$max:"$size"}}}])
-- $min：查询集合中指定键最小的文档
db.dev3.aggregate([{$group:{_id:null,minSize:{$min:"$size"}}}])
-- $avg：查询集合中指定键的平均值
db.dev3.aggregate([{$group:{_id:null,maxSize:{$avg:"$size"}}}])
-- $push：查询集合，按照指定键(_id)分组并返回指定键($push)，使用数组返回他们的指定键($push)。
db.dev3.aggregate([{$group:{_id:"$size",title:{$push:"$title"}}}])
-- $unwind
db.dev2.aggregate([{$unwind:"$tags"}])
聚合投影($project)
- 格式：db.集合名.aggregate([{$unwind:“集合名”},{ KaTeX parse error: Expected '}', got 'EOF' at end of input: …ect:{_id:0,别名:"键名",别名:“$键名”}}])
-- $project
db.dev2.aggregate([{$unwind:"$tags"},{$project:{_id:0,tags:"$tags",title:"$title"}}])
是 ，对于中文要使用$substrCP
①、字符串操作
在$project 中我们可以通过 MongoDB 的字符串操作符对投影的内容做字符串处理。
| 操作符 | 作用 |
|---|---|
| $toLower:“$键名” | 将键的值转换为小写 |
| $toUpper:“$键名” | 将键的值转换为大写 |
| $concat:[“$键名1”,“$键名2”…] | 将键的值1与键的值2…的值拼接为新的字符串 |
| $substr:[“$键名”,star,length] | 将键的值从start开始截取截length，只能匹配 ASCII 的数据 |
| $substrCP:[“$键名”,star,length] | 将键的值从start开始截取截num位，可以匹配中文 |
- 示例
-- $toLower：将键的值转换为小写，
db.dev2.aggregate([{$unwind:"$tags"},{$project:{_id:0,New_Title:{$toLower:"$title"}}}])
-- $toUpper：将键的值转换为大写
db.dev2.aggregate([{$unwind:"$tags"},{$project:{_id:0,New_Tags:{$toUpper:"$tags"}}}])
-- $concat：将字段1与字段2...的值拼接为新的字符串
db.dev2.aggregate([{$unwind:"$tags"},{$project:{_id:0,Title_Tags:{$concat:["$title","-","$tags"]}}}])
-- $substr：将键的值从start开始截取截num位，只能匹配 ASCII 的数据
db.dev2.aggregate([{$unwind:"$tags"},{$project:{_id:0,Title_Prefix:{$substr:["$title",0,3]}}}])
-- $substrCP：将键的值从start开始截取截num位，可以匹配中文
db.dev2.aggregate([{$unwind:"$tags"},{$project:{_id:0,Title_Prefix:{$substrCP:["$description",0,3]}}}])
②、算数运算
在$project 中我们可以通过 MongoDB 的算数作符对投影的内容做运算处理。
| 操作符 | 作用 |
|---|---|
| $add:[“$键名”,n] | 对键的值做加n处理 |
| $subtract:[“$键名”,n] | 对键的值做减n处理 |
| $multiply:[“$键名”,n] | 对键的值做乘n处理 |
| $divide:[“$键名”,n] | 对键的值做除n处理 |
| $mod:[“$键名”,n] | 对键的值做模n处理 |
- 示例
-- $add：对键的值做加n处理
db.dev3.aggregate([{$project:{_id:0,title:1,New_Size:{$add:["$size",1]}}}])
-- $subtract：对键的值做减n处理
db.dev3.aggregate([{$match:{size:{$ne:null}}},{$project:{_id:0,title:1,New_Size:{$subtract:["$size",1]}}}])
-- $multiply：对键的值做乘n处理
db.dev3.aggregate([{$match:{size:{$ne:null}}},{$project:{_id:0,title:1,New_Size:{$multiply:["$size",3]}}}])
-- $divide：对键的值做除n处理
db.dev3.aggregate([{$match:{size:{$ne:null}}},{$project:{_id:0,title:1,New_Size:{$divide:["$size",2]}}}])
-- $mod：对键的值做模n处理
db.dev3.aggregate([{$match:{size:{$ne:null}}},{$project:{_id:0,title:1,New_Size:{$mod:["$size",3]}}}])
③、日期处理
MongoDB 中的时间会比系统当前时间少 8 个小时。因为他的时间是 UTC 的时间，而中国的时区是东八区，比 UTC 快 8 个小时，所以会比当前时间少 8 个小时。
- 格式：
- 创建日期：
- db.集合名.insert({date:new Date()})
- db.集合名.insert({date:ISODate()})
- 查询日期：
- db.集合名.find({time:{条件操作符:new Date(“yyyy-MM-ddThh:mm:ss”)}})
- db.集合名.find({time:{条件操作符:ISODate(“yyyy-MM-ddThh:mm:ss”)}})
- 创建日期：
创建日期
-- 创建当前日期
db.dev3.insert({
date:new Date()})
-- 创建指定日期：日期格式为 yyyy-MM-ddThh:mm:ss
-- 方式一
db.dev3.insert({
time:new Date("2022-12-27T15.52:33")})
-- 方式二
db.dev3.insert({
time:ISODate("2022-12-27T15:57:00")})
查询日期
显示：年-月-日
| 操作符 | 作用 |
|---|---|
| {$year:“$日期键”} | 显示年份 |
| {$month:“$日期键”} | 显示月份 |
| {$dayOfMonth:“$日期键”} | 显示日期 |
- 示例
-- 显示年份
db.dev3.aggregate([{$match:{name:"admin"}},{$project:{年份:{$year:"$birth"}}}])
-- 显示月份
db.dev3.aggregate([{$match:{name:"admin"}},{$project:{月份:{$month:"$birth"}}}])
-- 显示日期
db.dev3.aggregate([{$match:{name:"admin"}},{$project:{月份:{$dayOfMonth:"$birth"}}}])
显示：时-分-秒-毫秒
| 操作符 | 作用 |
|---|---|
| {$hour:“$日期键”} | 显示小时 |
| {$minute:“$日期键”} | 显示分钟 |
| {$second:“$日期键”} | 显示秒 |
| {$millisecond:“$日期键”} | 显示毫秒 |
- 示例
-- 显示小时
db.dev3.aggregate([{$match:{name:"admin"}},{$project:{小时:{$hour:"$birth"}}}])
-- 显示分钟
db.dev3.aggregate([{$match:{name:"admin"}},{$project:{分钟:{$minute:"$birth"}}}])
-- 显示秒
db.dev3.aggregate([{$match:{name:"admin"}},{$project:{秒:{$second:"$birth"}}}])
-- 显示毫秒
db.dev3.aggregate([{$match:{name:"admin"}},{$project:{毫秒:{$millisecond:"$birth"}}}])
显示：第几天
一周星期几、一年第几周、一年第几天
| 操作符 | 作用 |
|---|---|
| {$dayOfWeek:“$日期键”} | 星期日为 1，星期六为 7。 |
| {$week:“$birth”} | 全年的周计数从 0 开始。 |
| {$dayOfYear:“$birth”} | 全年中的第几天。 |
- 示例
-- 显示一周中的星期几，星期日为 1，星期六为 7。
db.dev3.aggregate([{$match:{name:"admin"}},{$project:{星期:{$dayOfWeek:"$birth"}}}])
-- 显示一年中的第几周，全年的周计数从 0 开始。
db.dev3.aggregate([{$match:{name:"admin"}},{$project:{第几周:{$week:"$birth"}}}])
-- 显示一年中的第几天，全年中的第几天。
db.dev3.aggregate([{$match:{name:"admin"}},{$project:{第几天:{$dayOfYear:"$birth"}}}])
显示自定义日期格式
- 格式：$dateToString:{format:“%Y 年%m 月%d 日 %H:%M:%S”,date:“birth”}
- 示例
db.dev3.aggregate([{$match:{name:"admin"}},{$project:{年份:{$dateToString:{format:"%Y年%m月%d日 %H:%M:%S",date:"$birth"}}}}])
- 格式表
| 字符 | 含义 | 取值范围 |
|---|---|---|
| %Y | Year(4 digits,zero padded) | 0000-9999 |
| %m | Month(2 digits,zero padded) | 01-12 |
| %d | Day of Month(2 digits,zero padded) | 01-31 |
| %H | Hour(2 digits,zero padded,24-hour clock) | 00-23 |
| %M | Minute(2 digits,zero padded) | 00-59 |
| %S | Second(2 digits,zero padded) | 00-60 |
| %L | Millisecond(3 digits,zero padded) | 000-999 |
| %j | Day of year(3 digits,zero padded) | 001-366 |
| %w | Day of week(1-Sunday,7-Saturday) | 1-7 |
| %U | Week of year(2 digits,zero padded) | 00-53 |
二、Maven使用MongoDB
version1.0
导入依赖
<!-- mongodb依赖 -->
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongo-java-driver</artifactId>
<version>3.12.11</version>
</dependency>
配置连接方式工具
①、不使用连接池
数据库直连
- 修改参数
- ip地址、端口
- 使用工具类
- getCollection(String dbName, String collName)
- 数据库名
- 集合名
- getCollection(String dbName, String collName)
public class MongoDBUtil {
private static MongoClient client = null;
/**
* MongoDB连接参数：
* 1. ip地址；
* 2. 端口
*/
static{
if(client == null){
client = new MongoClient("192.168.66.11",27017);
}
}
/**
* 获取 MongoDB 数据库
* @param dbName
* @return
*/
public static MongoDatabase getDatabase(String dbName){
return client.getDatabase(dbName);
}
/**
* 获取 MongoDB 中的集合
* @param dbName
* @param collName
* @return
*/
public static MongoCollection getCollection(String dbName, String collName){
MongoDatabase database = getDatabase(dbName);
return database.getCollection(collName);
}
/**
* 删除 MongoDB 中的集合
* @param dbName
* @param collName
*/
public static void dropCollection(String dbName, String collName) {
MongoCollection coll = getCollection(dbName, collName);
coll.drop();
}
}
用户认证连接
创建 MongoDB 拦截-使用用户认证
- 修改参数
- 用户名、数据库名、用户密码
- ip地址、端口
- 使用工具类
- getCollection(String dbName, String collName)
- 数据库名
- 集合名
- getCollection(String dbName, String collName)
public class MongoDBAuthUtil {
private static MongoClient client = null;
/**
* MongoDB连接参数
* 1. 用户名、数据库名、用户密码
* 2. ip地址、端口
*/
static {
if (client == null) {
//创建一个封装用户认证信息
MongoCredential credential = MongoCredential.createCredential("admin", "dev1", "xiongPassWord".toCharArray());
//封装 MongoDB 的地址与端口
ServerAddress address = new ServerAddress("192.168.66.11", 27017);
client = new MongoClient(address, Arrays.asList(credential));
}
}
/**
* 获取 MongoDB 数据库
* @param dbName
* @return
*/
public static MongoDatabase getDatabase(String dbName) {
return client.getDatabase(dbName);
}
/**
* 获取 MongoDB 中的集合
* @param dbName
* @param collName
* @return
*/
public static MongoCollection getCollection(String dbName, String collName) {
MongoDatabase database = getDatabase(dbName);
return database.getCollection(collName);
}
/**
* 删除 MongoDB 中的集合
* @param dbName
* @param collName
*/
public static void dropCollection(String dbName, String collName) {
MongoCollection coll = getCollection(dbName, collName);
coll.drop();
}
}
②、使用连接池
数据库池连
使用池连的方式获取连接
- 修改参数
- ip地址、端口
- 使用工具类
- getCollection(String dbName, String collName)
- 数据库名
- 集合名
- getCollection(String dbName, String collName)
public class MongoDBPoolUtil {
private static MongoClient client = null;
/**
* MongoDB连接参数：
* 1. ip地址；
* 2. 端口
*/
static{
if(client == null){
MongoClientOptions.Builder builder = new MongoClientOptions.Builder();
builder.connectionsPerHost(10);//每个地址的最大连接数
builder.connectTimeout(5000);//连接超时时间
builder.socketTimeout(5000);//设置读写操作超时时间
ServerAddress address = new ServerAddress("192.168.66.11",27017);
client = new MongoClient(address,builder.build());
}
}
/**
* 获取数据库数据源
* @param dbName
* @return
*/
public static MongoDatabase getDatabase(String dbName){
return client.getDatabase(dbName);
}
/**
* 获取数据库连接对象
* @param dbName
* @param collName
* @return
*/
public static MongoCollection getCollection(String dbName, String collName){
MongoDatabase database = getDatabase(dbName);
return database.getCollection(collName);
}
/**
* 删除 MongoDB 中的集合
* @param dbName
* @param collName
*/
public static void dropCollection(String dbName, String collName) {
MongoCollection coll = getCollection(dbName, collName);
coll.drop();
}
}
用户认证池连
支持用户认证的池连
- 修改参数
- 用户名、数据库名、用户密码
- ip地址、端口
- 使用工具类
- getCollection(String dbName, String collName)
- 数据库名
- 集合名
- getCollection(String dbName, String collName)
public class MongoDBAuthPoolUtil {
private static MongoClient client = null;
/**
* MongoDB连接参数
* 1. 用户名、数据库名、用户密码
* 2. ip地址、端口
*/
static {
if (client == null) {
MongoClientOptions.Builder builder = new MongoClientOptions.Builder();
builder.connectionsPerHost(10);//每个地址的最大连接数
builder.connectTimeout(5000);//连接超时时间
builder.socketTimeout(5000);//设置读写操作超时时间
MongoCredential credential = MongoCredential.createCredential("admin", "develop", "itxiongpwd".toCharArray());
ServerAddress address = new ServerAddress("192.168.66.11", 27017);
client = new MongoClient(address, credential, builder.build());
}
}
/**
* 获取 MongoDB 数据库
* @param dbName
* @return
*/
public static MongoDatabase getDatabase(String dbName) {
return client.getDatabase(dbName);
}
/**
* 获取 MongoDB 中的集合
* @param dbName
* @param collName
* @return
*/
public static MongoCollection getCollection(String dbName, String collName) {
MongoDatabase database = getDatabase(dbName);
return database.getCollection(collName);
}
/**
* 删除 MongoDB 中的集合
* @param dbName
* @param collName
*/
public static void dropCollection(String dbName, String collName) {
MongoCollection coll = getCollection(dbName, collName);
coll.drop();
}
}
Mongo操作
操作集合
①、创建集合
createCollection(String collectionName)：创建集合
public static void main(String[] args) {
// 1. 通过工具类获取数据库
MongoDatabase adminDB = MongoDBUtil.getDatabase("admin");
// 2. 创建集合
adminDB.createCollection("dev5");
System.out.println("创建成功~~~~~~");
}
②、获取集合
通过工具类获取集合
public static void main(String[] args) {
// 1. 通过工具类获取集合
MongoCollection dev5 = MongoDBUtil.getCollection("admin", "dev5");
// 2. 获取集合名
System.out.println(dev5.getNamespace());
}
③、删除集合
通过工具类删除集合
public static void main(String[] args) {
// 1. 通过工具类删除集合
MongoDBUtil.dropCollection("admin","dev1");
}
操作文档
创建文档
- 单个文档
- new Document()：创建一个文档
- append(String key,Object value)：为文档添加信息
- insertOne：新增单个文档
public static void main(String[] args) {
// 1. 通过工具类获取集合
MongoCollection dev4 = MongoDBUtil.getCollection("admin", "dev4");
// 2. 创建 Document 文档
/**
* 1. 创建文档：new Document();
* 2. 添加文档信息：append(String key,Object value)
*/
Document docu = new Document();
docu.append("username","ls")
.append("userage",26)
.append("userdesc","very goog")
.append("userlike",Arrays.asList(new String[]{
"Music","Sport"}));
// 3. 添加文档到集合中
dev4.insertOne(docu);
}
- 多个文档
- new Document()：创建一个文档
- append(String key,Object value)：为文档添加信息
- insertMany：新增多个文档
public static void main(String[] args) {
// 1. 通过工具类获取集合
MongoCollection dev4 = MongoDBUtil.getCollection("admin", "dev4");
// 2. 创建 Document 文档
/**
* 1. 创建文档：new Document()集合;
* 2. 添加文档信息：append(String key,Object value)
*/
List<Document> docus = new ArrayList<Document>();
for (int i = 0; i < 5; i++) {
Document docu = new Document();
docu.append("username","ls"+i)
.append("userage",26+i)
.append("userdesc","very goog"+i)
.append("userlike",Arrays.asList(new String[]{
"Music","Sport"}));
docus.add(docu);
}
// 3. 添加文档到集合中
dev4.insertMany(docus);
}
更新文档
更新单个文档
- 单个键
- new Document()：文档、条件
- updateOne：更新一个文档
- Filters：mongodb自带的条件过滤器
public static void main(String[] args) {
// 1. 通过工具类获取集合
MongoCollection dev4 = MongoDBUtil.getCollection("admin", "dev4");
// 2. 更新文档
/**
* Filters封装了条件的一个工具类
*/
dev4.updateOne(Filters.eq("username","ls"),new Document("$set",new Document("userage",26)));
}
- 多个键
- new Document()：文档、条件
- updateOne：更新一个文档
- Filters：mongodb自带的条件过滤器
public static void main(String[] args) {
// 1. 通过工具类获取集合
MongoCollection dev4 = MongoDBUtil.getCollection("admin", "dev4");
// 2. 更新文档
/**
* Filters封装了条件的一个工具类
*/
dev4.updateOne(Filters.eq("username","ls0"),new Document("$set",new Document("userage",18).append("userdesc","Very Good")));
}
更新多个文档
- 单个建
- new Document()：文档、条件
- updateMany：更新多个文档
- Filters：mongodb自带的条件过滤器
public static void main(String[] args) {
// 1. 通过工具类获取集合
MongoCollection dev4 = MongoDBUtil.getCollection("admin", "dev4");
// 2. 更新文档
/**
* Filters封装了条件的一个工具类
*/
dev4.updateMany(Filters.ne("username",null),new Document("$set",new Document("userdesc","Very Good")));
}
- 多个键
- new Document()：文档、条件
- updateMany：更新多个文档
- Filters：mongodb自带的条件过滤器
public static void main(String[] args) {
// 1. 通过工具类获取集合
MongoCollection dev4 = MongoDBUtil.getCollection("admin", "dev4");
// 2. 更新文档
/**
* Filters封装了条件的一个工具类
*/
dev4.updateMany(Filters.ne("username",null),new Document("$set",new Document("userdesc","OK").append("userage",20)));
}
更新文档中的数组
- new Document()：文档、条件
- updateMany/updateOne：更新文档
- Filters：mongodb自带的条件过滤器
public static void main(String[] args) {
// 1. 通过工具类获取集合
MongoCollection dev4 = MongoDBUtil.getCollection("admin", "dev4");
// 2. 更新文档
/**
* Filters封装了条件的一个工具类
*/
dev4.updateOne(Filters.eq("username","ls"),new Document("$push",new Document("userlike","Art")));
}
查询文档
查看全部文档
- collection.find()：获取所有集合迭代器
- iterable.iterator()：迭代器转换
- hasNext：是否存在
- next：获取文档
- docu.get(“key”)：获取文档中的信息
public static void main(String[] args) {
// 1. 根据工具类获取集合
MongoCollection dev4 = MongoDBUtil.getCollection("admin", "dev4");
// 2. 获取文档的迭代器
FindIterable<Document> iterable = dev4.find();
MongoCursor<Document> cursor = iterable.iterator();
// 3. 遍历获取文档信息
while (cursor.hasNext()) {
Document docu = cursor.next();
System.out.println("username:"+docu.get("username"));
System.out.println("userage:"+docu.get("userage"));
System.out.println("userdesc:"+docu.get("userdesc"));
System.out.println("userlike:"+docu.get("userlike"));
System.out.println("##############################");
}
}
根据_id查询文档
- collection.find(条件)：获取所有集合迭代器
- new ObjectId()：id对象
- iterable.iterator()：迭代器转换
- hasNext：是否存在
- next：获取文档
- docu.get(“key”)：获取文档中的信息
public static void main(String[] args) {
// 1. 根据工具类获取集合
MongoCollection dev4 = MongoDBUtil.getCollection("admin", "dev4");
// 2. 获取文档的迭代器
FindIterable<Document> iterable = dev4.find(Filters.eq("_id",new ObjectId("63aad42c22371f29b10f025c")));
MongoCursor<Document> cursor = iterable.iterator();
// 3. 遍历获取文档信息
while (cursor.hasNext()) {
Document docu = cursor.next();
System.out.println("username:"+docu.get("username"));
System.out.println("userage:"+docu.get("userage"));
System.out.println("userdesc:"+docu.get("userdesc"));
System.out.println("userlike:"+docu.get("userlike"));
System.out.println("##############################");
}
}
查询多个文档
- Filters
- gt：大于
- type：类型
- in：在集合内
- nin：不在集合内
- 非正则
public static void main(String[] args) {
// 1. 根据工具类获取集合
MongoCollection dev4 = MongoDBUtil.getCollection("admin", "dev4");
// 2. 获取文档的迭代器
FindIterable<Document> iterable = dev4.find(Filters.gt("userage", 19));
MongoCursor<Document> cursor = iterable.iterator();
// 3. 遍历获取文档信息
while (cursor.hasNext()) {
Document docu = cursor.next();
System.out.println("username:"+docu.get("username"));
System.out.println("userage:"+docu.get("userage"));
System.out.println("userdesc:"+docu.get("userdesc"));
System.out.println("userlike:"+docu.get("userlike"));
System.out.println("##############################");
}
}
- 正则
Filters
- regex：正则的键
- Pattern.compile(“正则表达式”)：正则表达式不加 //
public static void main(String[] args) {
// 1. 根据工具类获取集合
MongoCollection dev4 = MongoDBUtil.getCollection("admin", "dev4");
// 2. 获取文档的迭代器
FindIterable<Document> iterable = dev4.find(Filters.regex("username", Pattern.compile("^l.*2$")));
MongoCursor<Document> cursor = iterable.iterator();
// 3. 遍历获取文档信息
while (cursor.hasNext()) {
Document docu = cursor.next();
System.out.println("username:"+docu.get("username"));
System.out.println("userage:"+docu.get("userage"));
System.out.println("userdesc:"+docu.get("userdesc"));
System.out.println("userlike:"+docu.get("userlike"));
System.out.println("##############################");
}
}
- 逻辑运算符
Filters
- and
- or
- sort
public static void main(String[] args) {
// 1. 根据工具类获取集合
MongoCollection dev4 = MongoDBUtil.getCollection("admin", "dev4");
// 2. 获取文档的迭代器
FindIterable<Document> iterable = dev4.find(Filters.and(Filters.eq("username","ls2"),Filters.eq("userage",20)));
MongoCursor<Document> cursor = iterable.iterator();
// 3. 遍历获取文档信息
while (cursor.hasNext()) {
Document docu = cursor.next();
System.out.println("username:"+docu.get("username"));
System.out.println("userage:"+docu.get("userage"));
System.out.println("userdesc:"+docu.get("userdesc"));
System.out.println("userlike:"+docu.get("userlike"));
System.out.println("##############################");
}
}
- 排序查询
public static void main(String[] args) {
// 1. 根据工具类获取集合
MongoCollection dev4 = MongoDBUtil.getCollection("admin", "dev4");
// 2. 获取文档的迭代器
FindIterable<Document> iterable = dev4.find(Filters.regex("username", Pattern.compile("4$"))).sort(new Document("username",-1));
MongoCursor<Document> cursor = iterable.iterator();
// 3. 遍历获取文档信息
while (cursor.hasNext()) {
Document docu = cursor.next();
System.out.println("username:"+docu.get("username"));
System.out.println("userage:"+docu.get("userage"));
System.out.println("userdesc:"+docu.get("userdesc"));
System.out.println("userlike:"+docu.get("userlike"));
System.out.println("##############################");
}
}
操作日期
日期工具类
public class DateUtil {
/**
* Date To String
* @param pattern
* @param date
* @return
*/
public static String dateToString(String pattern, Date date){
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
return simpleDateFormat.format(date);
}
/**
* String To Date
* @param pattern
* @param date
* @return
*/
public static Date stringToDate(String pattern, String date){
SimpleDateFormat simpleDateFormat = new SimpleDateFormat(pattern);
Date d = null;
try{
d = simpleDateFormat.parse(date);
}catch(Exception e){
e.printStackTrace();
}
return d;
}
}
插入日期
- 插入系统当前日期
public static void main(String[] args) {
// 1. 通过工具类获取集合
MongoCollection dev5 = MongoDBUtil.getCollection("admin", "dev5");
Document docu = new Document();
docu.append("username","ww")
.append("userage",22)
.append("userdesc","Very Good")
.append("userlike", Arrays.asList(new String[]{
"Music","Art"}))
.append("userbirth",new Date());
dev5.insertOne(docu);
}
- 插入指定日期
public static void main(String[] args) {
// 1. 通过工具类获取集合
MongoCollection dev5 = MongoDBUtil.getCollection("admin", "dev5");
// 2. 通过工具类获取自定义日期
Date date = DateUtil.stringToDate("yyyy-MM-dd HH:mm:ss", "2022-05-01 13:33:11");
Document docu = new Document();
docu.append("username","zl")
.append("userage",24)
.append("userdesc","Very Good")
.append("userlike", Arrays.asList(new String[]{
"Music","Art"}))
.append("userbirth",date);
dev5.insertOne(docu);
}
查询日期
Filters
- eq：等于
- gt：大于
public static void main(String[] args) {
// 1. 根据工具类获取集合
MongoCollection dev4 = MongoDBUtil.getCollection("admin", "dev5");
// 2. 通过工具类获取日期
Date date = DateUtil.stringToDate("yyyy-MM-dd HH:mm:ss", "2022-12-28 13:32:13");
// 获取文档的迭代器
FindIterable<Document> iterable = dev4.find(Filters.eq("userbirth",date));
MongoCursor<Document> cursor = iterable.iterator();
// 3. 遍历获取文档信息
while (cursor.hasNext()) {
Document docu = cursor.next();
System.out.println("username:"+docu.get("username"));
System.out.println("userage:"+docu.get("userage"));
System.out.println("userdesc:"+docu.get("userdesc"));
System.out.println("userlike:"+docu.get("userlike"));
System.out.println("##############################");
}
}
聚合操作
普通查询
- new Document()：相当于{}
- aggregate：聚合操作
public static void main(String[] args) {
// 1. 通过工具类获取集合
MongoCollection dev5 = MongoDBUtil.getCollection("admin", "dev5");
// 2. 创建aggregate
Document sum = new Document();
sum.append("$sum",1);
Document count = new Document();
count.append("_id",null).append("count",sum);
Document group = new Document();
group.append("$group",count);
// 3. 创建容器
List<Document> list = new ArrayList<Document>();
list.add(group);
// 4. 通过集合获取聚合操作数据
AggregateIterable iterable = dev5.aggregate(list);
MongoCursor<Document> cursor = iterable.iterator();
while (cursor.hasNext()) {
Document docu = cursor.next();
System.out.println(docu.get("count"));
}
}
聚合投影约束
- new Document()：相当于{}
- aggregate：聚合操作
public static void main(String[] args) {
// 1. 通过工具类获取集合
MongoCollection dev2 = MongoDBUtil.getCollection("admin", "dev2");
// 2. 创建aggregate
Document unwind = new Document();
unwind.append("$unwind","$tags");
Document pro = new Document();
pro.append("_id",0).append("tags","$tags").append("title","$title");
Document project = new Document();
project.append("$project",pro);
// 3. 创建容器
List<Document> list = new ArrayList<Document>();
list.add(unwind);
list.add(project);
// 4. 通过集合获取聚合操作数据
AggregateIterable iterable = dev2.aggregate(list);
MongoCursor<Document> cursor = iterable.iterator();
while (cursor.hasNext()) {
Document docu = cursor.next();
System.out.println(docu);
}
}
分页操作
- 使用 skip 与 limit 方法分页
public static void main(String[] args) {
// 1. 创建分页条件
int pageIndex = 2;
int page = (pageIndex - 1) * 2;
// 2. 通过工具类获取集合
MongoCollection dev3 = MongoDBUtil.getCollection("admin", "dev3");
// 3. 通过集合获取集合文档数
Document condition = new Document("size", new Document("$ne", null));
long countNum = dev3.countDocuments(condition);
System.out.println(countNum);
// 4. 分页查询
FindIterable iterable = dev3.find(condition).skip(page).limit(2);
MongoCursor<Document> cursor = iterable.iterator();
while (cursor.hasNext()) {
Document docu = cursor.next();
System.out.println(docu);
}
}
-
优化分页查询
public static void main(String[] args) { // 1. 创建分页条件 /** * int pageIndex = 2; * int pageSize = 3; * String lastId = ""; */ int pageIndex = 2; int pageSize = 3; String lastId = "63a976244d18206c11b226a2"; // 2. 通过工具类获取集合 MongoCollection dev3 = MongoDBUtil.getCollection("admin", "dev3"); // 3. 通过集合获取集合文档数 Document condition = new Document("size", new Document("$ne", null)); long countNum = dev3.countDocuments(condition); System.out.println(countNum); // 4. 分页查询 FindIterable iterable = null; if(pageIndex == 1){ iterable = dev3.find(condition).limit(pageSize); }else { if (lastId != null) { condition.append("_id",new Document("$gt",new ObjectId(lastId))); iterable = dev3.find(condition).limit(pageSize); } } MongoCursor<Document> cursor = iterable.iterator(); while (cursor.hasNext()) { Document docu = cursor.next(); System.out.println(docu); } }