[Serie SpringBoot] Solución de capa de datos NoSQL

Pre-importación

NoSQL sabemos que es una base de datos no relacional. Las soluciones de integración de 10 tecnologías relacionadas se proporcionan en la documentación oficial de Springboot. Este artículo cubrirá varias de las soluciones de integración de bases de datos NoSQL más populares en el mercado nacional, a saber:

• redis
• MongoDB
• ES

Los mejores casos de uso para las tecnologías anteriores se implementan en servidores Linux, pero aún usamos la plataforma Windows en este artículo.

SpringBoot integra Redis

Introducción básica e instalación de Redis

Redis es una base de datos NoSQL en memoria con una estructura de almacenamiento de clave-valor:

• Admite múltiples formatos de almacenamiento de datos
• Persistencia
• Soporte de clúster

Concéntrese en el formato de almacenamiento de datos, que es el formato clave-valor, es decir, la forma de almacenamiento de pares clave-valor. A diferencia de la base de datos MySQL, la base de datos MySQL tiene tablas, campos y registros. Redis no tiene estas cosas, es decir, un nombre corresponde a un valor, y los datos se almacenan principalmente en la memoria para su uso. ¿Qué se almacena principalmente en la memoria? De hecho, Redis tiene sus soluciones de persistencia de datos, a saber, RDB y AOF, pero Redis en sí no nació para la persistencia de datos. Principalmente guarda datos en la memoria y acelera el acceso a los datos, por lo que es una base de datos a nivel de memoria. .

Redis admite una variedad de formatos de almacenamiento de datos, por ejemplo, puede almacenar cadenas directamente, o puede almacenar una colección de mapas, una colección de listas y algunas operaciones de datos en diferentes formatos se realizarán más adelante.

Dirección de descarga del paquete de instalación de la versión de Windows: https://github.com/tporadowski/redis/releases

El paquete de instalación descargado tiene dos formas, una es el archivo msi para la instalación con un solo clic y la otra es el archivo zip que se puede usar después de la descompresión.

Qué es msi, de hecho, es un paquete de instalación de archivos, que no solo instala el software, sino que también lo ayuda a asociar las funciones necesarias para la instalación del software y las operaciones del paquete. Como la secuencia de instalación, la creación y configuración de rutas de instalación, la configuración de dependencias del sistema, la configuración de opciones de instalación predeterminadas y las propiedades que controlan el proceso de instalación. En pocas palabras, es un servicio integral y el proceso de instalación es una operación integral, que es un programa de instalación de software para usuarios novatos.

Una vez completada la instalación, obtendrá los siguientes archivos: hay dos archivos que corresponden a dos comandos, que son los comandos principales para iniciar Redis y deben ejecutarse en el modo de línea de comandos CMD.

iniciar el servidor

redis-server.exe redis.windows.conf

Aquí estamos usando el puerto predeterminado 6379

iniciar el cliente

redis-cli.exe

Si falla el inicio del servidor Redis, puede iniciar el cliente primero, luego ejecutar la operación de apagado y luego salir. En este momento, el servidor Redis se puede ejecutar normalmente.

Demostremos:

Primero inicie el servidor y descubra que el inicio falló:

Luego continuamos:

vaya a abrir el servidor nuevamente, ok:

si aparece esta imagen, significa que el servidor se ha abierto con éxito.

Operación básica

Una vez que se inicia el servidor, puede usar el cliente para conectarse al servidor, similar a iniciar la base de datos MySQL y luego iniciar la línea de comando SQL para operar la base de datos.

Coloque una cadena de datos en redis, primero defina un nombre para los datos, como nombre, edad, etc., y luego use el conjunto de comandos para configurar los datos en el servidor redis

set name nefu
set age 12

Saque los datos que se han ingresado desde redis y obtenga los datos correspondientes según el nombre. Si no hay datos correspondientes, obtendrá (nulo)

get name
get age

P.ej:

El almacenamiento de datos utilizado anteriormente es un nombre que corresponde a un valor. Si hay demasiados datos para mantener, se pueden utilizar otras estructuras de almacenamiento de datos. Por ejemplo, hash es un modelo de almacenamiento que puede almacenar varios datos con un solo nombre y cada dato también puede tener su propio nombre de almacenamiento secundario. El formato de almacenamiento de datos en la estructura hash es el siguiente:

hset a a1 aa1		#对外key名称是a，在名称为a的存储模型中，a1这个key中保存了数据aa1
hset a a2 aa2

El comando para obtener los datos en la estructura hash es el siguiente

hget a a1			#得到aa1
hget a a2			#得到aa2

Tenga en cuenta que no puede obtener directamente

P.ej:

Aquí solo cubrimos algunas operaciones simples sobre Redis

Integrar

Antes de la integración, aclaremos la idea de integración, Springboot integra cualquier tecnología para usar la API de la tecnología correspondiente en springboot. Si las dos tecnologías no se cruzan, no hay concepto de integración. La llamada integración es en realidad el uso de la tecnología springboot para administrar otras tecnologías.Varios problemas no se pueden evitar:

• Primero, las coordenadas de la tecnología correspondiente deben importarse primero, y después de la integración, estas coordenadas tienen algunos cambios.

• En segundo lugar, cualquier tecnología suele tener alguna información de configuración relacionada.Después de la integración, cómo y dónde escribir esta información es un problema.

• En tercer lugar, si la operación antes de la integración es el modo A, si no brinda algunas operaciones convenientes para los desarrolladores después de la integración, la integración no tendrá sentido. Por lo tanto, la operación después de la integración debe simplificarse y el modo de operación correspondiente será naturalmente diferente. diferente

Es una idea general pensar en la integración de springboot de todas las tecnologías de acuerdo con las tres preguntas anteriores. En el proceso de integración, descubriremos gradualmente la rutina de integración, y la aplicabilidad es muy fuerte. Después de la integración de varias tecnologías, Básicamente se puede resumir un Conjunto de pensamiento fijo.

Comencemos a integrar redis con springboot, los pasos de la operación son los siguientes:

Paso 1 : importe las coordenadas iniciales de springboot para integrar redis

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

Las coordenadas anteriores se pueden seleccionar comprobando al crear un módulo y pertenecen a la categoría NoSQL.

Paso 2 : Realice la configuración básica

spring:
  redis:
    host: localhost
    port: 6379

Para operar redis, la información más básica es qué servidor redis operar, por lo que la dirección del servidor pertenece a la información de configuración básica y es indispensable. Pero incluso si no lo configura, todavía está disponible ahora. Porque los dos conjuntos de información anteriores tienen configuraciones predeterminadas, que son exactamente los valores de configuración anteriores.

Paso 3 : use Springboot para integrar la operación de interfaz de cliente dedicada de redis, aquí está RedisTemplate

@SpringBootTest
class Springboot16RedisApplicationTests {
    
    
    @Autowired
    private RedisTemplate redisTemplate;
    @Test
    void set() {
    
    
    	//首先决定要操作哪种数据类型
        ValueOperations ops = redisTemplate.opsForValue();
        ops.set("age",41);
    }
    @Test
    void get() {
    
    
        ValueOperations ops = redisTemplate.opsForValue();
        Object age = ops.get("name");
        System.out.println(age);
    }
    @Test
    void hset() {
    
    
        HashOperations ops = redisTemplate.opsForHash();
        ops.put("info","a","csdn");
    }
    @Test
    void hget() {
    
    
        HashOperations ops = redisTemplate.opsForHash();
        Object val = ops.get("info", "a");
        System.out.println(val);
    }
}

Dos conjuntos de resultados get/set:

Al operar redis, debe confirmar qué tipo de datos operar y obtener la interfaz de operación de acuerdo con el tipo de datos. Por ejemplo, use opsForValue() para obtener la interfaz de operación de datos de tipo cadena, use opsForHash() para obtener la interfaz de operación de datos de tipo hash, y el resto es llamar a la operación api correspondiente. Varios tipos de interfaces de manipulación de datos son los siguientes:

Resumir

1. Springboot integra pasos de redis
   1. Importe las coordenadas iniciales de springboot para integrar redis
   2. Haz la configuración básica
   3. Use springboot para integrar la operación RedisTemplate de la interfaz de cliente dedicada de redis

Hay un punto a tener en cuenta aquí: cuando buscamos el par clave-valor que acabamos de agregar en la prueba en el cliente de Redis, no podemos encontrarlo. No porque no se haya agregado, sino por un problema de tipo de datos. Podemos usar el comando para ver todas las claves almacenadas en este momento:

descubrimos que no es que no se puedan encontrar, sino porque están almacenadas en forma de objetos y serializadas por Redis usando un método especial, por lo que ingresamos directamente No se pueden encontrar las cadenas de caracteres.

También podemos verlo en RedisTemplate:

aquí se usan genéricos, y cuando no escribimos nada, se trata como un objeto Object

Para evitar esto podemos usar StringRedisTemplate:

Entonces podemos encontrar:

SpringBoot integra MongoDB

Introducción básica e instalación de MongoDB

El uso de la tecnología Redis puede mejorar efectivamente la velocidad de acceso a los datos, pero debido al formato de datos único de Redis, no puede operar datos estructurados. Cuando opera datos de tipo objeto, Redis se estira . En el caso de asegurar la velocidad de acceso, si se quiere operar datos estructurados, parece que Redis no puede cumplir con los requisitos, en este momento se necesita utilizar una nueva estructura de almacenamiento de datos para solucionar este problema.

MongoDB es una base de datos de documentos sin esquema, de alto rendimiento y de código abierto, que es uno de los productos de base de datos NoSQL.es una base de datos no relacional que se parece más a una base de datos relacional.

De las pocas palabras de la descripción anterior, las que menos nos resultan familiares no tienen patrón. ¿Qué es sin modelo? En pocas palabras, como base de datos, no existe una estructura fija de almacenamiento de datos. La primera pieza de datos puede tener 3 campos de A, B y C, la segunda pieza de datos puede tener 3 campos de D, E y F, y el tercer dato puede tener campos 3. Los datos pueden ser campos A, C, E3, es decir, la estructura de los datos no es fija, que no es un esquema . Algunas personas dirán ¿de qué sirve esto? Flexible, cambia en cualquier momento, sin restricciones. Según las características anteriores, el lado de la aplicación de MongoDB también sufrirá algunos cambios. A continuación, se enumeran algunos escenarios en los que se puede usar MongoDB como almacén de datos, pero no es necesario usar MongoDB:

• Datos de usuario de Taobao

  • Ubicación de almacenamiento: Base de datos
  • Características: almacenamiento permanente, frecuencia de modificación extremadamente baja
  • 

• Datos del equipo del juego, datos de accesorios del juego

  • Ubicación de almacenamiento: base de datos, Mongodb
  • Características: combinación de almacenamiento permanente y almacenamiento temporal, alta frecuencia de modificación
  • 

• Datos de transmisión en vivo, datos de recompensa, datos de fanáticos

  • Ubicación de almacenamiento: base de datos, Mongodb
  • Características: combinación de almacenamiento permanente y almacenamiento temporal, la frecuencia de modificación es extremadamente alta
  • 

• datos IoT

  • Ubicación de almacenamiento: Mongodb
  • Características: almacenamiento temporal, frecuencia de modificación rápida
  • 

Después de una breve comprensión de MongoDB, hablemos de su instalación.

Dirección de descarga del paquete de instalación de la versión de Windows: https://www.mongodb.com/try/download

El paquete de instalación descargado también tiene dos formas, una es el archivo msi para la instalación con un solo clic y la otra es el archivo zip que se puede usar después de la descompresión.

Después de la descompresión, obtendrá los siguientes archivos, donde el directorio bin contiene todos los comandos ejecutables de mongodb

mongodb necesita especificar un directorio de almacenamiento de datos en tiempo de ejecución, así que cree un directorio de almacenamiento de datos, generalmente ubicado en el directorio de instalación, donde se crea el directorio de datos para almacenar datos (también creamos una carpeta db en la carpeta de datos También se usa para almacenar datos), de la siguiente manera

Si aparece el siguiente mensaje de advertencia durante el proceso de instalación, le indica que a su sistema operativo actual le faltan algunos archivos del sistema, así que no se preocupe.

La solución se puede resolver de acuerdo con la siguiente solución: busque en el navegador el archivo correspondiente al nombre que falta, descárguelo, copie el archivo descargado en el directorio system32 del directorio de instalación de Windows y luego ejecute el comando regsvr32 en la línea de comando para registrar el archivo. Dependiendo del nombre del archivo descargado, cambie el nombre correspondiente antes de ejecutar el comando.

regsvr32 vcruntime140_1.dll

iniciar el servidor

mongod --dbpath=..\data\db

Al iniciar el servidor, debe especificar la ubicación de almacenamiento de datos, que se puede configurar a través del parámetro –dbpath Puede configurar la ruta de almacenamiento de datos de acuerdo con sus necesidades.Puerto de servicio predeterminado 27017.

Luego, cuando ingresemos a la carpeta db en datos, encontraremos algo más:

estos archivos solo se generan una vez para la inicialización, y no se generarán nuevamente cuando el servidor se inicie más tarde.

Luego volvemos a iniciar el cliente:

iniciar el cliente

mongo --host=127.0.0.1 --port=27017

Debido a que nuestra configuración es predeterminada, por lo que cuando se ejecuta, también mongoes posible directamente

La siguiente interfaz aparece para indicar el éxito:

Tenga cuidado de no apagar el servidor, las dos ventanas cmd deben existir al mismo tiempo

Operación básica

​ Aunque MongoDB es una base de datos, sus operaciones no se realizan mediante instrucciones SQL, por lo que es posible que no esté familiarizado con el método de operación. Afortunadamente, existen algunos software de cliente de base de datos similares a Navicat, que pueden operar MongoDB fácilmente. Instale un cliente y luego operar MongoDB.

Hay muchos software del mismo tipo. El software que se instalará esta vez es Robo3t. Robot3t es un software verde, que se puede descomprimir sin instalación. Después de la descompresión, ingrese al directorio de instalación y haga doble clic en robot3t.exe para usarlo.

Para abrir el software, primero debe conectarse al servidor MongoDB, seleccionar el menú [Archivo] y seleccionar [Conectar…]

Después de ingresar a la interfaz de administración de conexión, seleccione el enlace [Crear] en la esquina superior izquierda para crear una nueva configuración de conexión

Si ingresa el valor de configuración, puede conectarse (el puerto 27017 de la máquina local se puede conectar sin modificaciones de forma predeterminada)

Después de que la conexión sea exitosa, ingrese los comandos en el área de entrada de comandos para operar MongoDB.

Crear una base de datos: haga clic derecho para crear en el menú de la izquierda e ingrese el nombre de la base de datos.

Crear una colección: use el botón derecho en Colecciones para crear, ingrese el nombre de la colección, la colección es equivalente al rol de la tabla en la base de datos

新增文档: (el documento es un tipo de datos en formato similar a json, pero en realidad no son datos json)

db.集合名称.insert/save/insertOne(文档)

Por ejemplo:

Resultado:

删除文档:

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

修改文档:

db.集合名称.update(条件，{操作种类:{文档}})

查询文档:

基础查询
查询全部：		   db.集合.find();
查第一条：		   db.集合.findOne()
查询指定数量文档：	db.集合.find().limit(10)					//查10条文档
跳过指定数量文档：	db.集合.find().skip(20)					//跳过20条文档
统计：			  	db.集合.count()
排序：				db.集合.sort({age:1})						//按age升序排序
投影：				db.集合名称.find(条件,{name:1,age:1})		 //仅保留name与age域

条件查询
基本格式：			db.集合.find({条件})
模糊查询：			db.集合.find({域名:/正则表达式/})		  //等同SQL中的like，比like强大，可以执行正则所有规则
条件比较运算：		   db.集合.find({域名:{$gt:值}})				//等同SQL中的数值比较操作，例如：name>18
包含查询：			db.集合.find({域名:{$in:[值1，值2]}})		//等同于SQL中的in
条件连接查询：		   db.集合.find({$and:[{条件1},{条件2}]})	   //等同于SQL中的and、or

Aquí solo están involucradas algunas operaciones básicas de MongoDB

Integrar

¿Cómo integrar MongDB usando springboot? De hecho, la razón por la cual springboot usa tantos desarrolladores es porque sus rutinas son casi exactamente las mismas. Importe coordenadas, configure y use la interfaz API para operar. Lo mismo es cierto para la integración de Redis y lo mismo es cierto para la integración de MongoDB.

Primero, primero importe las coordenadas de inicio integradas de la tecnología correspondiente

En segundo lugar, configure la información necesaria

En tercer lugar, use la API provista para operar

Empecemos a integrar MongoDB con springboot, los pasos son los siguientes:

Paso 1 : Importe Springboot para integrar las coordenadas iniciales de MongoDB

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

Las coordenadas anteriores también se pueden seleccionar comprobando al crear un módulo, que también pertenece a la categoría NoSQL.

Paso 2 : Realice la configuración básica

spring:
  data:
    mongodb:
      uri: mongodb://localhost/nefu   #我们对nefu集合进行操作

La configuración requerida para operar MongoDB es la misma que para operar Redis. La información más básica es qué servidor operar. La diferencia es que la dirección IP y el puerto del servidor conectado son diferentes, y el formato de escritura es diferente.

Paso 3 : use Springboot para integrar la interfaz de cliente dedicada MongoTemplate de MongoDB para la operación

@SpringBootTest
class Springboot17MongodbApplicationTests {
    
    
    @Autowired
    private MongoTemplate mongoTemplate;
    @Test
    void contextLoads() {
    
    
        Book book = new Book();
        book.setId(2);
        book.setName("springboot2");
        book.setType("springboot2");
        book.setDescription("springboot2");
        mongoTemplate.save(book);
    }
    @Test
    void find(){
    
    
        List<Book> all = mongoTemplate.findAll(Book.class);
        System.out.println(all);
    }
}

Después de ejecutar la operación de guardar, podemos ver los nuevos datos en la base de datos:

El trabajo de integración se realiza aquí, y se siente tanto familiar como desconocido. Estoy familiarizado con esta rutina, tres ejes, solo estos tres trucos, que guían las coordenadas para configurar las operaciones de la API. Con lo que no estoy familiarizado es con esta tecnología, y la API de operación específica puede no estar familiarizada. Hablaremos sobre Springboot integrando MongoDB aquí.

Resumir

1. Springboot integra los pasos de MongoDB
   1. Importe springboot para integrar las coordenadas iniciales de MongoDB
   2. Haz la configuración básica
   3. Use springboot para integrar las operaciones MongoTemplate de la interfaz de cliente dedicada de MongoDB

SpringBoot integra ES

ES introducción básica e instalación

La solución NoSQL ha terminado la integración de las dos tecnologías. Redis puede usar la memoria para cargar datos y lograr un acceso rápido a los datos. MongoDB puede almacenar datos similares a los objetos en la memoria y lograr un acceso rápido a los datos. En el desarrollo de nivel empresarial, la velocidad de la la búsqueda nunca termina. El contenido que se discutirá a continuación también es una solución NoSQL, pero su función no es acelerar directamente la lectura y escritura de datos, sino acelerar la consulta de datos, lo que se denomina tecnología ES .

ES (Elasticsearch) es un motor de búsqueda de texto completo distribuido que se centra en la búsqueda de texto completo.

Entonces, ¿qué es la búsqueda de texto completo? Por ejemplo, si un usuario quiere comprar un libro y busca con Java como palabra clave, ya sea en el título del libro, en la introducción del libro o incluso en el nombre del autor del libro, siempre que contiene Java, se devolverá al usuario como resultado de una consulta. Se utiliza el proceso anterior. Tecnología de búsqueda de texto completo. Las condiciones de búsqueda ya no se usan solo para comparar un campo determinado, sino para usar condiciones de búsqueda en un dato para comparar más campos , siempre que coincidan, se incluirán en los resultados de la consulta, que es el objetivo de la búsqueda completa. -búsqueda de texto. . La tecnología ES es una tecnología que puede lograr los efectos anteriores.

Para lograr el efecto de la búsqueda de texto completo, es imposible usar la operación similar en la base de datos para comparar, lo cual es demasiado ineficiente. ES ha diseñado una nueva idea para realizar búsquedas de texto completo. El proceso de operación específico es el siguiente:

1. Consultar y puntuar toda la información de texto de los datos del campo a consultar, y dividirla en varias palabras

   • Por ejemplo, "Spring Actual 5th Edition" se dividirá en tres palabras, a saber, "Spring", "Actual Combat" y "5th Edition". La terminología profesional denomina este proceso 分词. Diferentes estrategias de segmentación de palabras tienen diferentes efectos de separación.Diferentes estrategias de segmentación de palabras se denominan tokenizadores.

2. Almacene el resultado de la segmentación de palabras, correspondiente a la identificación de cada dato
   

   • Por ejemplo, el valor del elemento de nombre en los datos con id 1 es "Spring Actual 5th Edition", luego, después del final de la segmentación de palabras, aparecerá que "Spring" corresponde a id 1, "actual combat" corresponde a id 1, "Versión 5" "El id correspondiente es 1

   • Por ejemplo, el valor del elemento de nombre en los datos con id 3 es "Modo de diseño Spring5", luego, después del final de la segmentación de palabras, "Spring" corresponde a id 3 y "modo de diseño" corresponde a id 3

   • En este punto, aparecerán los siguientes resultados correspondientes.De acuerdo con el formulario anterior, todosDocumentaciónHaz segmentación de palabras. Cabe señalar que el proceso de segmentación de palabras no solo se realiza sobre un campo, sino sobre cada campo que participa en la consulta, y los resultados finales se resumen en una tabla.

   Tal pieza de datos se puede llamar un documento:
   

   resultado de la segmentación de palabras palabra clave	identificación correspondiente
   Primavera	1, 2, 3, 4, 5
   combate real	1
   5ª edición	1

3. Al consultar, si ingresa "combate real" como la condición de consulta, puede comparar los datos de la tabla anterior para obtener el valor de identificación de 1, y luego puede obtener los datos de resultado de la consulta de acuerdo con el valor de identificación.
   

En el proceso anterior, el contenido de cada palabra clave en el resultado de la segmentación de palabras es diferente y su función es algo similar al índice en la base de datos, que se utiliza para acelerar la consulta de datos. Sin embargo, el índice en la base de datos es para agregar un índice a un campo determinado, y la palabra clave de resultado de segmentación aquí no es un valor de campo completo, sino solo una parte del contenido de un campo. Y el índice se usa para encontrar todos los datos de acuerdo con el contenido del índice. El resultado de la segmentación de palabras en la búsqueda de texto completo no da como resultado todos los datos, sino la identificación de los datos. Si desea obtener los datos específicos, debe necesita consultar nuevamente, por lo que aquí se le da un nuevo nombre a este tipo de palabra clave de resultado de segmentación de palabras, que se llama índice invertido .

A continuación, hablemos de la instalación: La
dirección de descarga del paquete de instalación de la versión de Windows : https://www.elastic.co/cn/downloads/elasticsearch

​ El paquete de instalación descargado es un archivo zip que se puede utilizar después de la descompresión.Después de la descompresión, se obtendrán los siguientes archivos

• directorio bin: contiene todos los comandos ejecutables
• directorio de configuración: contiene los archivos de configuración utilizados por el servidor ES
• Directorio jdk: este directorio contiene un kit de herramientas jdk completo, versión 17. Cuando se actualice ES, use la última versión de jdk para asegurarse de que no haya problemas de soporte de versión insuficiente
• directorio lib: contiene los archivos jar dependientes que ejecuta ES
• directorio de registros: contiene todos los archivos de registro generados después de la ejecución de ES
• directorio de módulos: contiene todos los módulos funcionales en el software ES, y también es un paquete jar uno por uno. A diferencia del directorio jar, el directorio jar es el paquete jar del que depende ES durante el tiempo de ejecución, y los módulos son el paquete jar funcional del propio software ES.
• directorio de complementos: contiene complementos instalados por el software ES, vacío de forma predeterminada

iniciar el servidor

elasticsearch.bat

Haga doble clic en el archivo elasticsearch.bat para iniciar el servidor ES y el puerto de servicio predeterminado es 9200. Acceda a http://localhost:9200 a través de un navegador y vea la siguiente información ya que el servidor ES se inicia normalmente

Durante el proceso de ejecución, hay dos números de puerto que deben recordarse:
Puerto 9300: el puerto de comunicación del componente de clusterware de elasticsearch, que es simplemente el puerto para la comunicación interna de elasticsearch.
Puerto 9200: El puerto de acceso del navegador.

En ocasiones, la operación informará el siguiente error:

GeoIP informó error, procesador GeoIP | Guía de Elasticsearch [7.14] | Elastic

El mensaje de error es principalmente

javax.net.ssl.SSLHandshakeException: sun.security.validator.ValidatorException: la creación de la ruta PKIX falló: sun.security.provider.certpath.SunCertPathBuilderException: no se pudo encontrar una ruta de certificación válida para el destino solicitado

La solución es la siguiente, que consiste en agregar el certificado de seguridad ssh al directorio de seguridad del jre descargado. Sin embargo, no afecta el funcionamiento, por lo que no se puede solucionar.

Resolviendo PKIX: La Solución

Algunos usuarios pueden hacer clic en el archivo elasticsearch.bat y la ventana emergente cmd se cerrará automáticamente después de mostrar algunas líneas de texto. En este caso, ábralo varias veces hasta que se ejecute normalmente.

Operación básica

Los datos que queremos consultar se almacenan en ES, pero el formato es diferente del formato de los datos almacenados en la base de datos. En ES, primero debemos crear un índice invertido, que es similar en función a una tabla de base de datos, y luego agregar datos al índice invertido. Los datos agregados se denominan documento. Por lo tanto, para realizar operaciones de ES, primero debe crear un índice y luego agregar documentos, para que se puedan realizar las operaciones de consulta posteriores.

​ Para operar ES se puede hacer a través de solicitudes tipo Rest, es decir, enviando una solicitud se puede realizar una operación. Por ejemplo, la creación de un índice y la eliminación de un índice se pueden realizar en forma de envío de una solicitud.

• Cree un índice, libros es el nombre del índice, lo mismo a continuación

  PUT请求		http://localhost:9200/books
  

  Después de enviar la solicitud, verá la siguiente información de que el índice se creó con éxito

  {
        
        
      "acknowledged": true,
      "shards_acknowledged": true,
      "index": "books"
  }
  

  La creación repetida de un índice existente dará como resultado un mensaje de error, el motivo del error se describe en el atributo de motivo

  {
        
        
      "error": {
        
        
          "root_cause": [
              {
        
        
                  "type": "resource_already_exists_exception",
                  "reason": "index [books/VgC_XMVAQmedaiBNSgO2-w] already exists",
                  "index_uuid": "VgC_XMVAQmedaiBNSgO2-w",
                  "index": "books"
              }
          ],
          "type": "resource_already_exists_exception",
          "reason": "index [books/VgC_XMVAQmedaiBNSgO2-w] already exists",	# books索引已经存在
          "index_uuid": "VgC_XMVAQmedaiBNSgO2-w",
          "index": "book"
      },
      "status": 400
  }
  

• índice de consulta

  GET请求		http://localhost:9200/books
  

  Consulta el índice para obtener información relacionada con el índice, de la siguiente manera

  {
        
        
      "book": {
        
        
          "aliases": {
        
        },
          "mappings": {
        
        },
          "settings": {
        
        
              "index": {
        
        
                  "routing": {
        
        
                      "allocation": {
        
        
                          "include": {
        
        
                              "_tier_preference": "data_content"
                          }
                      }
                  },
                  "number_of_shards": "1",
                  "provided_name": "books",
                  "creation_date": "1645768584849",
                  "number_of_replicas": "1",
                  "uuid": "VgC_XMVAQmedaiBNSgO2-w",
                  "version": {
        
        
                      "created": "7160299"
                  }
              }
          }
      }
  }
  

  Si se consulta un índice que no existe, se devolverá un mensaje de error. Por ejemplo, la información después de consultar un índice llamado libro es la siguiente

  {
        
        
      "error": {
        
        
          "root_cause": [
              {
        
        
                  "type": "index_not_found_exception",
                  "reason": "no such index [book]",
                  "resource.type": "index_or_alias",
                  "resource.id": "book",
                  "index_uuid": "_na_",
                  "index": "book"
              }
          ],
          "type": "index_not_found_exception",
          "reason": "no such index [book]",		# 没有book索引
          "resource.type": "index_or_alias",
          "resource.id": "book",
          "index_uuid": "_na_",
          "index": "book"
      },
      "status": 404
  }
  

• índice de caída

  DELETE请求	http://localhost:9200/books
  

  Después de eliminar todo, dar resultado de eliminación

  {
        
        
      "acknowledged": true
  }
  

  Si se elimina el duplicado, aparecerá un mensaje de error y el motivo específico del error también se describe en el atributo de motivo.

  {
        
        
      "error": {
        
        
          "root_cause": [
              {
        
        
                  "type": "index_not_found_exception",
                  "reason": "no such index [books]",
                  "resource.type": "index_or_alias",
                  "resource.id": "book",
                  "index_uuid": "_na_",
                  "index": "book"
              }
          ],
          "type": "index_not_found_exception",
          "reason": "no such index [books]",		# 没有books索引
          "resource.type": "index_or_alias",
          "resource.id": "book",
          "index_uuid": "_na_",
          "index": "book"
      },
      "status": 404
  }
  

• Crear un índice y especificar un tokenizador

  ​ El índice creado anteriormente no especifica un tokenizador. Puede agregar parámetros de solicitud para configurar el tokenizador al crear el índice. En la actualidad, el tokenizador más popular en China es el tokenizador IK. Antes de usarlo, descargue el tokenizador correspondiente y luego utilícelo.
  Dirección de descarga del tokenizador IK: https://github.com/medcl/elasticsearch-analysis-ik/releases

  Después de descargar el tokenizador, extráigalo al directorio de complementos del directorio de instalación de ES.Después de instalar el tokenizador, debe reiniciar el servidor ES. Cree un formato de índice utilizando el tokenizador IK:

  PUT请求		http://localhost:9200/books
  
  请求参数如下（注意是json格式的参数）
  {
        
        
      "mappings":{
        
        							#定义mappings属性，替换创建索引时对应的mappings属性		
          "properties":{
        
        						#定义索引中包含的属性设置
              "id":{
        
        							#设置索引中包含id属性
                  "type":"keyword"			#当前属性可以被直接搜索
              },
              "name":{
        
        						#设置索引中包含name属性
                  "type":"text",              #当前属性是文本信息，参与分词  
                  "analyzer":"ik_max_word",   #使用IK分词器进行分词             
                  "copy_to":"all"				#分词结果拷贝到all属性中
              },
              "type":{
        
        
                  "type":"keyword"
              },
              "description":{
        
        
                  "type":"text",	                
                  "analyzer":"ik_max_word",                
                  "copy_to":"all"
              },
              "all":{
        
        							#定义属性，用来描述多个字段的分词结果集合，当前属性可以参与查询
                  "type":"text",	                
                  "analyzer":"ik_max_word"
              }
          }
      }
  }
  

  Una vez completada la creación, el resultado devuelto es el mismo que el resultado de crear un índice sin usar el tokenizador. En este momento, puede observar al ver la información del índice que las asignaciones de parámetros de solicitud agregadas han ingresado al atributo de índice.

  {
        
        
      "books": {
        
        
          "aliases": {
        
        },
          "mappings": {
        
        						#mappings属性已经被替换
              "properties": {
        
        
                  "all": {
        
        
                      "type": "text",
                      "analyzer": "ik_max_word"
                  },
                  "description": {
        
        
                      "type": "text",
                      "copy_to": [
                          "all"
                      ],
                      "analyzer": "ik_max_word"
                  },
                  "id": {
        
        
                      "type": "keyword"
                  },
                  "name": {
        
        
                      "type": "text",
                      "copy_to": [
                          "all"
                      ],
                      "analyzer": "ik_max_word"
                  },
                  "type": {
        
        
                      "type": "keyword"
                  }
              }
          },
          "settings": {
        
        
              "index": {
        
        
                  "routing": {
        
        
                      "allocation": {
        
        
                          "include": {
        
        
                              "_tier_preference": "data_content"
                          }
                      }
                  },
                  "number_of_shards": "1",
                  "provided_name": "books",
                  "creation_date": "1645769809521",
                  "number_of_replicas": "1",
                  "uuid": "DohYKvr_SZO4KRGmbZYmTQ",
                  "version": {
        
        
                      "created": "7160299"
                  }
              }
          }
      }
  }
  

En la actualidad, tenemos un índice, pero no hay datos en el índice, por lo que debemos agregar datos primero. Los datos se denominan documento en ES, y la operación del documento se realiza a continuación.

• Hay tres formas de agregar documentos

  POST请求	http://localhost:9200/books/_doc		#使用系统生成id
  POST请求	http://localhost:9200/books/_create/1	#使用指定id
  POST请求	http://localhost:9200/books/_doc/1		#使用指定id，不存在创建，存在更新（版本递增）
  
  文档通过请求参数传递，数据格式json
  {
        
        
      "name":"springboot",
      "type":"springboot",
      "description":"springboot"
  }  
  

• documento de consulta

  GET请求	http://localhost:9200/books/_doc/1		 #查询单个文档 		
  GET请求	http://localhost:9200/books/_search		 #查询全部文档
  

• consulta condicional

  GET请求	http://localhost:9200/books/_search?q=name:springboot	# q=查询属性名:查询属性值
  

• eliminar documento

  DELETE请求	http://localhost:9200/books/_doc/1
  

• Modificar el documento (actualización completa)

  PUT请求	http://localhost:9200/books/_doc/1
  
  文档通过请求参数传递，数据格式json
  {
        
        
      "name":"springboot",
      "type":"springboot",
      "description":"springboot"
  }
  

• Documentación revisada (parcialmente actualizada)

  POST请求	http://localhost:9200/books/_update/1
  
  文档通过请求参数传递，数据格式json
  {
        
        			
      "doc":{
        
        						#部分更新并不是对原始文档进行更新，而是对原始文档对象中的doc属性中的指定属性更新
          "name":"springboot"		#仅更新提供的属性值，未提供的属性值不参与更新操作
      }
  }
  

Integrar

¿Cómo integrar ES usando springboot? Las reglas antiguas, importan las coordenadas, hacen la configuración y usan la interfaz API para operar. La integración de Redis es la misma, la integración de MongoDB es la misma y la integración de ES sigue siendo la misma. No es nuevo, pero no es que no sea nuevo. Este es el poder de Springboot. Todo está hecho con las mismas reglas, lo cual es muy amigable para los desarrolladores.

Empecemos a integrar ES con springboot, los pasos son los siguientes:

Paso 1 : importe las coordenadas iniciales de springboot para integrar ES

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

Paso 2 : Realice la configuración básica

spring:
  elasticsearch:
    rest:
      uris: http://localhost:9200

Configurar la dirección del servidor ES, puerto 9200

Paso 3 : use Springboot para integrar la interfaz de cliente dedicada de ES, ElasticsearchRestTemplate, para operar

@SpringBootTest
class Springboot18EsApplicationTests {
    
    
    @Autowired
    private ElasticsearchRestTemplate template;
}

El formulario de operación anterior es el método de operación inicial de ES. El cliente utilizado se llama Cliente de bajo nivel. El rendimiento de este método de operación de cliente es ligeramente insuficiente, por lo que ES desarrolló un nuevo método de operación de cliente llamado Cliente de alto nivel. . El cliente de alto nivel se actualiza sincrónicamente con la versión de ES, pero Springboot usó un cliente de bajo nivel al principio al integrar ES, por lo que el desarrollo empresarial debe reemplazarse con un modo de cliente de alto nivel.

A continuación se utiliza el método de cliente de alto nivel para integrar ES con springboot. Los pasos de la operación son los siguientes:

Paso 1 : Importe Springboot para integrar las coordenadas del cliente de alto nivel ES Actualmente no hay un iniciador correspondiente para este formulario.

<dependency>
    <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
</dependency>

Paso 2 : configure el servidor ES conectado mediante programación y obtenga el objeto del cliente

@SpringBootTest
class Springboot18EsApplicationTests {
    
    
    private RestHighLevelClient client;
      @Test
      void testCreateClient() throws IOException {
    
    
          HttpHost host = HttpHost.create("http://localhost:9200");
          RestClientBuilder builder = RestClient.builder(host);
          client = new RestHighLevelClient(builder);
  
          client.close();
      }
}

Configure la dirección del servidor ES y el puerto 9200. Recuerde que el cliente debe cerrarse manualmente después de su uso. Dado que el cliente actual se mantiene manualmente, los objetos no se pueden cargar mediante cableado automático.

Paso 3 : use el objeto del cliente para operar ES, como crear un índice

@SpringBootTest
class Springboot18EsApplicationTests {
    
    
    private RestHighLevelClient client;
      @Test
      void testCreateIndex() throws IOException {
    
    
          HttpHost host = HttpHost.create("http://localhost:9200");
          RestClientBuilder builder = RestClient.builder(host);
          client = new RestHighLevelClient(builder);
          
          CreateIndexRequest request = new CreateIndexRequest("books");
          client.indices().create(request, RequestOptions.DEFAULT); 
          
          client.close();
      }
}

Las operaciones de cliente de alto nivel completan todas las operaciones mediante el envío de solicitudes. ES establece varios objetos de solicitud para varias operaciones. En el ejemplo anterior, el objeto que crea el índice es CreateIndexRequest, y otras operaciones también tendrán su propio objeto de solicitud dedicado.

​ En la operación actual, encontramos que no importa qué tipo de operación ES se realice, el primer paso siempre es obtener el objeto RestHighLevelClient y el último paso siempre es cerrar la conexión del objeto. En la prueba, las características de la clase de prueba se pueden usar para ayudar a los desarrolladores a completar las operaciones anteriores al mismo tiempo, pero también deben administrarse por sí mismos cuando escriben negocios. Convierta el formato de código anterior para usar el método de inicialización y destruya el método de la clase de prueba para mantener el objeto del cliente.

@SpringBootTest
class Springboot18EsApplicationTests {
    
    
    @BeforeEach		//在测试类中每个操作运行前运行的方法
    void setUp() {
    
    
        HttpHost host = HttpHost.create("http://localhost:9200");
        RestClientBuilder builder = RestClient.builder(host);
        client = new RestHighLevelClient(builder);
    }

    @AfterEach		//在测试类中每个操作运行后运行的方法
    void tearDown() throws IOException {
    
    
        client.close();
    }

    private RestHighLevelClient client;

    @Test
    void testCreateIndex() throws IOException {
    
    
        CreateIndexRequest request = new CreateIndexRequest("books");
        client.indices().create(request, RequestOptions.DEFAULT);
    }
}

Ahora la escritura es mucho más simplificada y más razonable. A continuación, use el modo anterior para ejecutar todas las operaciones de ES una vez y pruebe los resultados

Crear índice (tokenizador IK) :

@Test
void testCreateIndexByIK() throws IOException {
    
    
    CreateIndexRequest request = new CreateIndexRequest("books");
    String json = "{\n" +
            "    \"mappings\":{\n" +
            "        \"properties\":{\n" +
            "            \"id\":{\n" +
            "                \"type\":\"keyword\"\n" +
            "            },\n" +
            "            \"name\":{\n" +
            "                \"type\":\"text\",\n" +
            "                \"analyzer\":\"ik_max_word\",\n" +
            "                \"copy_to\":\"all\"\n" +
            "            },\n" +
            "            \"type\":{\n" +
            "                \"type\":\"keyword\"\n" +
            "            },\n" +
            "            \"description\":{\n" +
            "                \"type\":\"text\",\n" +
            "                \"analyzer\":\"ik_max_word\",\n" +
            "                \"copy_to\":\"all\"\n" +
            "            },\n" +
            "            \"all\":{\n" +
            "                \"type\":\"text\",\n" +
            "                \"analyzer\":\"ik_max_word\"\n" +
            "            }\n" +
            "        }\n" +
            "    }\n" +
            "}";
    //设置请求中的参数
    request.source(json, XContentType.JSON);
    client.indices().create(request, RequestOptions.DEFAULT);
}

El tokenizador IK se establece en forma de parámetros de solicitud, y los parámetros de solicitud se establecen utilizando el método de origen en el objeto de solicitud. En cuanto a los parámetros, depende de su tipo de operación. Cuando se requieren parámetros en la solicitud, los parámetros se pueden establecer en el formulario actual.

Añadir documentación :

@Test
//添加文档
void testCreateDoc() throws IOException {
    
    
    Book book = bookDao.selectById(1);
    IndexRequest request = new IndexRequest("books").id(book.getId().toString());
    String json = JSON.toJSONString(book);
    request.source(json,XContentType.JSON);
    client.index(request,RequestOptions.DEFAULT);
}

El objeto de solicitud que se usa para agregar documentos es IndexRequest, que es diferente del objeto de solicitud que se usa para crear un índice.

Añadir documentos de forma masiva :

@Test
//批量添加文档
void testCreateDocAll() throws IOException {
    
    
    List<Book> bookList = bookDao.selectList(null);
    BulkRequest bulk = new BulkRequest();
    for (Book book : bookList) {
    
    
        IndexRequest request = new IndexRequest("books").id(book.getId().toString());
        String json = JSON.toJSONString(book);
        request.source(json,XContentType.JSON);
        bulk.add(request);
    }
    client.bulk(bulk,RequestOptions.DEFAULT);
}

Al hacer lotes, primero cree un objeto BulkRequest, que puede entenderse como un contenedor para almacenar objetos de solicitud. Después de que se inicialicen todas las solicitudes, agréguelas al objeto BulkRequest y luego use el método masivo del objeto BulkRequest. Una vez ejecución sexual Esta completo.

Consultar documentos por id :

@Test
//按id查询
void testGet() throws IOException {
    
    
    GetRequest request = new GetRequest("books","1");
    GetResponse response = client.get(request, RequestOptions.DEFAULT);
    String json = response.getSourceAsString();
    System.out.println(json);
}

​ El objeto de solicitud utilizado para consultar documentos por id es GetRequest.

Consultar documentos por criterios :

@Test
//按条件查询
void testSearch() throws IOException {
    
    
    SearchRequest request = new SearchRequest("books");

    SearchSourceBuilder builder = new SearchSourceBuilder();
    builder.query(QueryBuilders.termQuery("all","spring"));
    request.source(builder);

    SearchResponse response = client.search(request, RequestOptions.DEFAULT);
    SearchHits hits = response.getHits();
    for (SearchHit hit : hits) {
    
    
        String source = hit.getSourceAsString();
        //System.out.println(source);
        Book book = JSON.parseObject(source, Book.class);
        System.out.println(book);
    }
}

​ El objeto de solicitud utilizado para consultar documentos por condición es SearchRequest. Al consultar, se llama al método termQuery del objeto SearchRequest y se debe proporcionar el nombre del atributo de consulta. Aquí se admite el campo de combinación, es decir, se agregan todos los atributos. cuando el atributo de índice se definió anteriormente.

La operación de springboot integrando ES termina aquí. La diferencia entre springboot integrando redis y mongodb en la etapa anterior sigue siendo bastante grande. La razón principal es que no usamos springboot para integrar objetos de cliente ES. En cuanto a la operación, debido a que hay demasiados tipos de operaciones ES, la operación parece ser un poco complicada.

Resumir

1. springboot integra pasos ES
   1. Importe springboot para integrar las coordenadas del cliente de alto nivel de ES
   2. Gestión manual de los objetos del cliente, incluidas las operaciones de inicialización y apagado
   3. Use el cliente de alto nivel para seleccionar diferentes objetos de solicitud para completar las operaciones correspondientes de acuerdo con los diferentes tipos de operaciones