Portal:
Documentación de MongoDB--Conceptos básicos - Un solo blog de Cheng - Blog de CSDN
Introducción al uso de la tecnología:
descripción del concepto:
spring-data-mongodb proporciona dos modos de operación de MongoTemplate y MongoRepository.
MongoRepository es simple de operar. La desventaja es que no es lo suficientemente flexible.
MongoTemplate tiene una operación flexible y puede usarse de manera flexible en el proyecto.
MongoTemplate
MongoTemplate es parte del proyecto Spring Data MongoDB, que es una extensión de Spring que proporciona una capa de abstracción para aplicaciones que utilizan la base de datos MongoDB. MongoTemplate proporciona una manera simple y poderosa de realizar varias operaciones de base de datos sin escribir el código del controlador MongoDB de bajo nivel.
Las funciones principales de MongoTemplate incluyen:
Inserción y actualización de documentos: MongoTemplate proporciona una forma conveniente de insertar y actualizar documentos en una base de datos MongoDB.
Consultar documentos: MongoTemplate proporciona una variedad de métodos de consulta que pueden usar varios parámetros de consulta para recuperar documentos en la base de datos, incluidas las condiciones de consulta, clasificación, restricciones y proyecciones.
Operaciones de agregación: MongoTemplate admite el marco de agregación, que puede realizar operaciones de agregación complejas, como contar, agrupar, sumar, etc.
Gestión de índices: MongoTemplate puede crear, eliminar y consultar índices de bases de datos.
Comandos y operaciones: MongoTemplate también admite varios comandos y operaciones de bases de datos, como el cálculo de estadísticas de bases de datos, la ejecución de procedimientos almacenados, etc.
El uso de MongoTemplate puede simplificar el trabajo de desarrollo de la operación de la base de datos MongoDB, proporcionar una mayor productividad y una mejor capacidad de mantenimiento.
MongoRepository
MongoRepository es otra capa de abstracción en el proyecto Spring Data MongoDB, que es una abstracción de nivel superior basada en MongoTemplate. MongoRepository proporciona una interfaz basada en anotaciones para definir interacciones con bases de datos MongoDB. Al usar MongoRepository, puede concentrarse en definir la lógica de acceso a datos sin escribir código de operación de base de datos de bajo nivel.
Las funciones principales de MongoRepository incluyen:
Consulta de documentos: MongoRepository proporciona un método conveniente para consultar documentos en la base de datos. Mediante el uso de anotaciones, puede definir las condiciones de consulta, el orden, las restricciones y las proyecciones.
Operaciones de agregación: MongoRepository admite el marco de agregación, que puede realizar operaciones de agregación complejas, como contar, agrupar, sumar, etc.
Consulta de paginación: MongoRepository proporciona una función de consulta de paginación, que puede limitar la cantidad de resultados de la consulta y obtener la siguiente página de resultados.
Consulta personalizada: si necesita realizar operaciones de consulta más complejas, MongoRepository también proporciona un método de consulta personalizada, puede escribir procedimientos almacenados o usar el lenguaje de consulta de MongoDB para ejecutar consultas personalizadas.
El uso de MongoRepository puede hacer que su código sea más conciso y mantenible, ya que proporciona una forma declarativa de acceder a la base de datos MongoDB. A través de anotaciones e interfaces implementadas automáticamente, puede concentrarse en implementar la lógica comercial sin preocuparse por los detalles operativos de la base de datos subyacente.
usarMongoTemplate完成简单增删改查
常用方法
常用方法
mongoTemplate.findAll(User.class): 查询User文档的全部数据
mongoTemplate.findById(<id>, User.class): 查询User文档id为id的数据
mongoTemplate.find(query, User.class);: 根据query内的查询条件查询
mongoTemplate.upsert(query, update, User.class): 修改
mongoTemplate.remove(query, User.class): 删除
mongoTemplate.insert(User): 新增
Query对象
1、创建一个query对象（用来封装所有条件对象)，再创建一个criteria对象（用来构建条件）
2、 精准条件：criteria.and(“key”).is(“条件”)
模糊条件：criteria.and(“key”).regex(“条件”)
3、封装条件：query.addCriteria(criteria)
4、大于（创建新的criteria）：Criteria gt = Criteria.where(“key”).gt（“条件”）
小于（创建新的criteria）：Criteria lt = Criteria.where(“key”).lt（“条件”）
5、Query.addCriteria(new Criteria().andOperator(gt,lt));
6、一个query中只能有一个andOperator()。其参数也可以是Criteria数组。
7、排序 ：query.with（new Sort(Sort.Direction.ASC, "age"). and(new Sort(Sort.Direction.DESC, "date")))
Adán:
Utilice el MongoDBMongoTemplate来完成的好处就是可以自己构造Query所以在操作的时候更加的灵活！在加上底层的一些封装。更加的易读易学。
1、引入依赖
Use las dependencias propietarias de MongoDB
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>Esta dependencia es la dependencia inicial proporcionada por Spring Boot para interactuar con la base de datos MongoDB. Contiene las bibliotecas y dependencias necesarias para usar fácilmente MongoDB al desarrollar aplicaciones con Spring Boot.
Específicamente, esta dependencia proporciona la siguiente funcionalidad:
Configuración automática: Spring Boot configurará automáticamente la conexión con la base de datos MongoDB, incluida la creación de un cliente Mongo, la configuración de las propiedades de conexión, etc.
MongoTemplate: configura automáticamente MongoTemplate, una clase central para realizar varias operaciones de base de datos. Al usar MongoTemplate, puede insertar, actualizar, consultar y otras operaciones de documentos fácilmente.
MongoRepository: MongoRepository se configura automáticamente, que es una interfaz basada en anotaciones para definir interacciones con bases de datos MongoDB. Al heredar MongoRepository, puede realizar cómodamente consultas, operaciones de agregación, etc.
Operaciones con plantilla: al usar MongoTemplate y MongoRepository, puede realizar operaciones de base de datos con una plantilla, lo que hace que el código sea más conciso y más legible.
En resumen, al agregar esta dependencia, puede usar fácilmente Spring Boot para integrarse con MongoDB sin configurar y escribir manualmente el código de operación de la base de datos de bajo nivel.
Otras dependencias: (si desea iniciar directamente un proyecto simple de arranque de resorte, puede eliminarlo)
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-tomcat</artifactId>
<scope>provided</scope>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
<exclusions>
<exclusion>
<groupId>org.junit.vintage</groupId>
<artifactId>junit-vintage-engine</artifactId>
</exclusion>
</exclusions>
</dependency>
</dependencies>2. Escriba el archivo de configuración para establecer la conexión
Escribir el archivo application.yml
spring:
data:
mongodb:
host: 127.0.0.1 #指定MongoDB服务地址
port: 27017 #指定端口，默认就为27017
database: article#指定使用的数据库(集合)
authentication-database: admin # 登录认证的逻辑库名
username: #用户名
password: #密码Aviso:
Si no hay ningún usuario conectado, algunos archivos de configuración se pueden eliminar según la situación real.
En comparación con MySQL, la diferencia es que un usuario puede administrar varias bases de datos en MySQL, pero cada base de datos de MongoDB necesita un usuario de administración independiente, y se debe ingresar la contraseña de usuario correspondiente al conectarse.
3. Visualización de clase de entidad
Notas principales:
1. @Document corresponde al documento en MongoDB, que es la unidad de datos más básica en la base de datos. Está compuesto por pares clave-valor, similar al formato JSON, y puede almacenar diferentes campos. El valor del campo puede incluir otros documentos, arreglos y arreglos de documentos.
2. @Id (clave principal): Se usa para mapear el valor de la variable miembro al valor del _id del documento, puedes ver cómo asignar un valor a _id en mi documento anterior.
3. @Index (índice): un índice es una estructura de datos especial que se almacena en una colección de datos que es fácil de recorrer y leer, y puede ordenar los datos en el documento de datos. La indexación puede mejorar en gran medida la eficiencia de la consulta de documentos.
4. @Field (campo): el campo en el documento, similar al concepto de columna en MySQL.
5. @Aggregation (agregación): la agregación se utiliza principalmente para el procesamiento de datos, como el promedio estadístico, la suma, etc.
anexo:
package com.example.mongodb_learn2.common;
import lombok.Data;
import org.springframework.data.annotation.Id;
import org.springframework.data.mongodb.core.mapping.Document;
import org.springframework.data.mongodb.core.mapping.Field;
/**
* 阿丹实体类
* */
@Data
@Document(collection = "ExampleDB")
public class Adn {
@Id
@Field("_id")
private Long id;//阿丹主键
@Field("name")
private String name;//阿丹名称
@Field("gender")
private String gender;//阿丹性别
@Field("specialty")
private String specialty;//特长描述
}
Aviso:
Asegúrese de escribir la anotación @Field("nombre") para asignar al nombre del campo, de lo contrario, ¡todos los resultados estarán vacíos! ! !
4. ¡Sube el código!, ¡se empieza a borrar, modificar y comprobar!
capa de control del controlador
package com.example.mongodb_learn2.controller;
import com.example.mongodb_learn2.common.Adn;
import com.example.mongodb_learn2.service.AdnService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import java.util.List;
@RestController
public class AdnController {
@Autowired
private AdnService adnService;
/**
* 根据id进行查找
* */
@GetMapping("/adnByid/{id}")
public Adn getAdn(@PathVariable String id) {
return adnService.getAdn(id);
}
/**
*添加阿丹
* */
@PostMapping("/saveAdn")
public String saveAdn(@RequestBody Adn adn) {
return adnService.saveAdn(adn);
}
/**
*根据id删除
*/
@GetMapping("/deleteAdn/{id}")
public String deleteAdn(@PathVariable String id) {
return adnService.deleteAdn(id);
}
/**
* 修改
* */
@PostMapping("/updateAdn")
public String updateAdn(@RequestBody Adn adn) {
return adnService.updateAdn(adn);
}
/**
* 查找所有展示列表
* */
@GetMapping("/getAllAdn")
public List<Adn> getAllAdn() {
return adnService.getAllAdn();
}
}
interfaz de capa de servicio
package com.example.mongodb_learn2.service;
import com.example.mongodb_learn2.common.Adn;
import java.util.List;
public interface AdnService {
Adn getAdn(String id);
String saveAdn(Adn adn);
String deleteAdn(String id);
String updateAdn(Adn adn);
List<Adn> getAllAdn();
}
clase de implementación de la capa de servicio
package com.example.mongodb_learn2.service.Impl;
import com.alibaba.fastjson.JSON;
import com.example.mongodb_learn2.common.Adn;
import com.example.mongodb_learn2.service.AdnService;
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.Service;
import java.util.List;
@Service
public class AdnServiceImpl implements AdnService {
@Autowired
private MongoTemplate mongoTemplate;
@Override
public Adn getAdn(String id) {
return mongoTemplate.findById(id, Adn.class);
}
@Override
public String saveAdn(Adn adn) {
Adn save = mongoTemplate.save(adn);
return JSON.toJSONString(save);
}
@Override
public String deleteAdn(String id) {
Query query = new Query();
query.addCriteria(Criteria.where("id").is(id));
mongoTemplate.remove(query, Adn.class);
return id;
}
@Override
public String updateAdn(Adn adn) {
Query query = new Query();
query.addCriteria(Criteria.where("id").is(adn.getId()));
Update update = new Update();
update.set("name", adn.getName());
update.set("gender", adn.getGender());
update.set("specialty", adn.getSpecialty());
mongoTemplate.updateFirst(query,update,Adn.class);
Long id = adn.getId();
return id+"";
}
@Override
public List<Adn> getAllAdn() {
return mongoTemplate.findAll(Adn.class);
}
}
se puede ver usandoMongoTemplate的优势就是更加的灵活。可以自定义化。