[Série SpringBoot] Solution de couche de données NoSQL

Pré-importation

NoSQL, nous le savons, est une base de données non relationnelle. Les solutions d'intégration de 10 technologies associées sont fournies dans la documentation officielle de Springboot. Cet article couvrira plusieurs des solutions d'intégration de bases de données NoSQL les plus populaires sur le marché national, à savoir :

• Redis
• MongoDB
• C'EST

Les meilleurs cas d'utilisation des technologies ci-dessus sont tous déployés sur des serveurs Linux, mais nous utilisons toujours la plate-forme Windows dans cet article.

SpringBoot intègre Redis

Introduction et installation de base de Redis

Redis est une base de données NoSQL en mémoire avec une structure de stockage clé-valeur :

• Prend en charge plusieurs formats de stockage de données
• Persistance
• Prise en charge des clusters

Concentrez-vous sur le format de stockage des données, qui est le format clé-valeur, c'est-à-dire la forme de stockage des paires clé-valeur. Contrairement à la base de données MySQL, la base de données MySQL contient des tables, des champs et des enregistrements. Redis n'a pas ces éléments, c'est-à-dire qu'un nom correspond à une valeur et que les données sont principalement stockées en mémoire pour être utilisées. Qu'est-ce qui est principalement stocké en mémoire ? En fait, Redis a ses solutions de persistance des données, à savoir RDB et AOF, mais Redis lui-même n'est pas né pour la persistance des données. Il enregistre principalement les données en mémoire et accélère l'accès aux données, c'est donc une base de données au niveau de la mémoire. .

Redis prend en charge une variété de formats de stockage de données, par exemple, il peut stocker des chaînes directement, ou il peut stocker une collection de cartes, une collection de listes, et certaines opérations de données dans différents formats seront impliquées plus tard

Adresse de téléchargement du package d'installation de la version Windows : https://github.com/tporadowski/redis/releases

Le package d'installation téléchargé a deux formes, l'une est le fichier msi pour une installation en un clic, et l'autre est le fichier zip qui peut être utilisé après la décompression.

Qu'est-ce que msi, en fait, c'est un package d'installation de fichiers, qui non seulement installe le logiciel, mais vous aide également à associer les fonctions requises pour l'installation du logiciel et les opérations de package. Tels que la séquence d'installation, la création et la définition des chemins d'installation, la définition des dépendances du système, la définition des options d'installation par défaut et les propriétés qui contrôlent le processus d'installation. Pour le dire simplement, il s'agit d'un service à guichet unique, et le processus d'installation est une opération à guichet unique, qui est un programme d'installation de logiciel pour les utilisateurs novices.

Une fois l'installation terminée, vous obtiendrez les fichiers suivants : Il y a deux fichiers correspondant à deux commandes, qui sont les commandes principales pour démarrer Redis et doivent être exécutées en mode ligne de commande CMD.

démarrer le serveur

redis-server.exe redis.windows.conf

Ici, nous utilisons le port par défaut 6379

démarrer le client

redis-cli.exe

Si le démarrage du serveur Redis échoue, vous pouvez d'abord démarrer le client, puis exécuter l'opération d'arrêt, puis quitter. À ce stade, le serveur Redis peut être exécuté normalement.

Démontrons :

Démarrez d'abord le serveur et constatez que le démarrage a échoué :

Puis on continue :

allez ouvrir à nouveau le serveur, ok :

si cette image apparaît, c'est que le serveur a été ouvert avec succès !

Opération de base

Une fois le serveur démarré, vous pouvez utiliser le client pour vous connecter au serveur, comme pour démarrer la base de données MySQL, puis démarrer la ligne de commande SQL pour faire fonctionner la base de données.

​ Placez une chaîne de données dans redis, définissez d'abord un nom pour les données, tel que nom, âge, etc., puis utilisez la commande set pour définir les données sur le serveur redis

set name nefu
set age 12

​ Retirez les données qui ont été saisies à partir de redis et obtenez les données correspondantes en fonction du nom. S'il n'y a pas de données correspondantes, il obtiendra (nil)

get name
get age

Par exemple:

Le stockage de données utilisé ci-dessus est un nom correspondant à une valeur.S'il y a trop de données à maintenir, d'autres structures de stockage de données peuvent être utilisées. Par exemple, le hachage est un modèle de stockage qui peut stocker plusieurs données sous un même nom, et chaque donnée peut également avoir son propre nom de stockage secondaire. Le format de stockage des données dans la structure de hachage est le suivant :

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

La commande pour obtenir les données dans la structure de hachage est la suivante

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

Notez que vous ne pouvez pas obtenir directement

Par exemple:

Ici, nous ne couvrons que quelques opérations simples sur Redis

Intégrer

Avant l'intégration, trions l'idée d'intégration.Springboot intègre n'importe quelle technologie pour utiliser l'API de la technologie correspondante dans springboot. Si les deux technologies ne se croisent pas, il n'y a pas de concept d'intégration. La soi-disant intégration est en fait l'utilisation de la technologie springboot pour gérer d'autres technologies. Plusieurs problèmes ne peuvent être évités :

• Tout d'abord, les coordonnées de la technologie correspondante doivent d'abord être importées, et après l'intégration, ces coordonnées ont quelques changements

• Deuxièmement, toute technologie contient généralement des informations de configuration associées. Après l'intégration, comment et où écrire ces informations est un problème.

• Troisièmement, si l'opération avant l'intégration est le mode A, si elle n'apporte pas d'opérations pratiques aux développeurs après l'intégration, l'intégration n'aura aucun sens.Par conséquent, l'opération après l'intégration doit être simplifiée et le mode de fonctionnement correspondant sera naturellement différent. différent

C'est une idée générale de penser à l'intégration de Springboot de toutes les technologies selon les trois questions ci-dessus. Au cours du processus d'intégration, nous découvrirons progressivement la routine d'intégration, et l'applicabilité est très forte. Après l'intégration de plusieurs technologies, nous peut essentiellement résumer un ensemble de pensée fixe.

Commençons à intégrer redis avec springboot. Les étapes de fonctionnement sont les suivantes :

Etape 1 : Importer les coordonnées de départ de springboot pour intégrer redis

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

Les coordonnées ci-dessus peuvent être sélectionnées en cochant lors de la création d'un module, et appartiennent à la catégorie NoSQL.

Étape 2 : Effectuez la configuration de base

spring:
  redis:
    host: localhost
    port: 6379

Pour faire fonctionner redis, les informations les plus élémentaires sont le serveur redis à exploiter, de sorte que l'adresse du serveur fait partie des informations de configuration de base et est indispensable. Mais même si vous ne le configurez pas, il est toujours disponible maintenant. Parce que les deux ensembles d'informations ci-dessus ont des configurations par défaut, qui sont exactement les valeurs de configuration ci-dessus.

Etape 3 : Utilisez springboot pour intégrer le fonctionnement de l'interface client dédiée de redis, voici 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);
    }
}

Deux ensembles de résultats get/set :

Lors de l'utilisation de redis, vous devez confirmer le type de données à exploiter et obtenir l'interface d'exploitation en fonction du type de données. Par exemple, utilisez opsForValue() pour obtenir l'interface d'opération de données de type chaîne, utilisez opsForHash() pour obtenir l'interface d'opération de données de type hachage, et le reste consiste à appeler l'opération api correspondante. Les différents types d'interfaces de manipulation de données sont les suivants :

Résumer

1. Springboot intègre les étapes redis
   1. Importez les coordonnées de démarrage de springboot pour intégrer redis
   2. Faire la configuration de base
   3. Utilisez springboot pour intégrer l'opération RedisTemplate de l'interface client dédiée de Redis

Il y a un point à noter ici : lorsque nous recherchons la paire clé-valeur que nous venons d'ajouter dans le test sur le client Redis, nous ne la trouvons pas. Non pas parce qu'il n'a pas été ajouté, mais à cause d'un problème de type de données. Nous pouvons utiliser la commande pour afficher toutes les clés stockées à ce moment :

nous avons constaté que ce n'est pas qu'elles sont introuvables, mais parce qu'elles sont stockées sous forme d'objets et sérialisées par Redis à l'aide d'une méthode spéciale, nous entrons donc directement caractères Chaînes introuvables.

On peut aussi le voir dans RedisTemplate :

les génériques sont utilisés ici, et quand on n'écrit rien, il est traité comme un objet Object

Pour éviter cela, nous pouvons utiliser StringRedisTemplate:

On peut alors trouver :

SpringBoot intègre MongoDB

Introduction et installation de base de MongoDB

L'utilisation de la technologie Redis peut améliorer efficacement la vitesse d'accès aux données, mais en raison du format de données unique de Redis, il ne peut pas exploiter de données structurées. Lors de l'exploitation de données de type objet, Redis est étiré . Dans le cas d'assurer la vitesse d'accès, si vous souhaitez exploiter des données structurées, il semble que Redis ne puisse pas répondre aux exigences.À l'heure actuelle, une nouvelle structure de stockage de données doit être utilisée pour résoudre ce problème.

MongoDB est une base de données de documents open source, hautes performances et sans schéma, qui est l'un des produits de base de données NoSQL.est une base de données non relationnelle qui ressemble le plus à une base de données relationnelle.

Parmi les quelques mots de la description ci-dessus, ceux qui nous sont les moins familiers sont sans modèle. Qu'est-ce qui est sans mode ? En termes simples, en tant que base de données, il n'y a pas de structure de stockage de données fixe. Le premier élément de données peut avoir 3 champs de A, B et C, le deuxième élément de données peut avoir 3 champs de D, E et F, et la troisième donnée peut avoir 3 champs, les données peuvent être des champs A, C, E3, c'est-à-dire que la structure des données n'est pas fixe, ce qui n'est pas un schéma . Certains diront à quoi ça sert ? Flexible, changez à tout moment, sans contrainte. Sur la base des caractéristiques ci-dessus, le côté application de MongoDB subira également quelques modifications. La liste suivante répertorie certains scénarios dans lesquels MongoDB peut être utilisé comme magasin de données, mais il n'est pas nécessaire d'utiliser MongoDB :

• Données utilisateur Taobao

  • Emplacement de stockage : base de données
  • Caractéristiques : Stockage permanent, fréquence de modification extrêmement faible
  • 

• Données d'équipement de jeu, données d'accessoires de jeu

  • Lieu de stockage : base de données, Mongodb
  • Caractéristiques : combinaison de stockage permanent et de stockage temporaire, fréquence de modification élevée
  • 

• Données de diffusion en direct, données de récompense, données de fans

  • Lieu de stockage : base de données, Mongodb
  • Caractéristiques : Combinaison de stockage permanent et de stockage temporaire, la fréquence de modification est extrêmement élevée
  • 

• Données IdO

  • Lieu de stockage : Mongodb
  • Caractéristiques : Stockage temporaire, fréquence de modification rapide
  • 

Après une brève compréhension de MongoDB, parlons de son installation.

Adresse de téléchargement du package d'installation de la version Windows : https://www.mongodb.com/try/download

Le package d'installation téléchargé a également deux formes, l'une est le fichier msi pour une installation en un clic, et l'autre est le fichier zip qui peut être utilisé après la décompression.

Après décompression, vous obtiendrez les fichiers suivants, où le répertoire bin contient toutes les commandes exécutables de mongodb

​ mongodb doit spécifier un répertoire de stockage de données lors de l'exécution, créez donc un répertoire de stockage de données, généralement placé dans le répertoire d'installation, où le répertoire de données est créé pour stocker les données (nous créons également un dossier db dans le dossier de données Il est également utilisé pour stocker des données), comme suit

Si le message d'avertissement suivant apparaît pendant le processus d'installation, il vous indique qu'il manque certains fichiers système à votre système d'exploitation actuel, alors ne vous inquiétez pas.

La solution peut être résolue selon la solution suivante : recherchez dans le navigateur le fichier correspondant au nom manquant, téléchargez-le, copiez le fichier téléchargé dans le répertoire system32 du répertoire d'installation de Windows, puis exécutez la commande regsvr32 sur la ligne de commande pour enregistrer le fichier. En fonction du nom du fichier téléchargé, modifiez le nom correspondant avant d'exécuter la commande.

regsvr32 vcruntime140_1.dll

démarrer le serveur

mongod --dbpath=..\data\db

Lors du démarrage du serveur, vous devez spécifier l'emplacement de stockage des données, qui peut être défini via le paramètre –dbpath.Vous pouvez définir le chemin de stockage des données en fonction de vos besoins.Port de service par défaut 27017.

Ensuite, lorsque nous entrons dans le dossier db dans data, nous trouverons quelque chose de plus :

ces fichiers ne sont générés qu'une seule fois pour l'initialisation, et ne seront pas générés à nouveau lors du démarrage ultérieur du serveur.

Ensuite, nous redémarrons le client :

démarrer le client

mongo --host=127.0.0.1 --port=27017

Parce que nos paramètres sont tous par défaut, donc lors de l'exécution, il mongoest également possible de directement

L'interface suivante apparaît pour indiquer le succès :

Attention à ne pas éteindre le serveur, les deux fenêtres cmd doivent exister en même temps

Opération de base

​ Bien que MongoDB soit une base de données, ses opérations ne sont pas effectuées à l'aide d'instructions SQL, vous n'êtes donc peut-être pas familier avec la méthode d'opération. Heureusement, il existe un logiciel client de base de données similaire à Navicat, qui peut facilement faire fonctionner MongoDB. Installez un client, puis faire fonctionner MongoDB.

Il existe de nombreux logiciels du même type, le logiciel à installer cette fois est Robo3t, Robot3t est un logiciel vert, qui peut être décompressé sans installation. Après la décompression, entrez dans le répertoire d'installation et double-cliquez sur robot3t.exe pour l'utiliser.

Pour ouvrir le logiciel, vous devez d'abord vous connecter au serveur MongoDB, sélectionner le menu [Fichier], puis sélectionner [Se connecter…]

Après être entré dans l'interface de gestion de connexion, sélectionnez le lien [Créer] dans le coin supérieur gauche pour créer un nouveau paramètre de connexion

Si vous entrez la valeur de réglage, vous pouvez vous connecter (le port 27017 de la machine locale peut être connecté sans modification par défaut)

Une fois la connexion établie, entrez les commandes dans la zone de saisie de commande pour faire fonctionner MongoDB.

Créer une base de données : cliquez avec le bouton droit pour créer dans le menu de gauche, puis saisissez le nom de la base de données.

Créer une collection : Utilisez le bouton droit sur Collections à créer, entrez le nom de la collection, la collection équivaut au rôle de la table dans la base de données

新增文档: (le document est une sorte de données au format json, mais ce ne sont pas réellement des données json)

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

Par exemple :

Résultat :

删除文档:

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

Seules quelques opérations MongoDB de base sont impliquées ici

Intégrer

Comment intégrer MongDB en utilisant springboot ? En fait, si springboot utilise autant de développeurs, c'est parce que ses routines sont presque exactement les mêmes. Importez les coordonnées, effectuez la configuration et utilisez l'interface API pour fonctionner. Il en va de même pour l'intégration de Redis, et il en va de même pour l'intégration de MongoDB.

Tout d'abord, importez d'abord les coordonnées de démarrage intégrées de la technologie correspondante

​ Deuxièmement, configurez les informations nécessaires

​ Troisièmement, utilisez l'API fournie pour opérer

​ Commençons à intégrer MongoDB avec springboot. Les étapes sont les suivantes :

Etape 1 : Importer springboot pour intégrer les coordonnées de démarrage de MongoDB

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

Les coordonnées ci-dessus peuvent également être sélectionnées en cochant lors de la création d'un module, qui appartient également à la catégorie NoSQL.

Étape 2 : Effectuez la configuration de base

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

La configuration requise pour faire fonctionner MongoDB est la même que pour faire fonctionner redis. Les informations les plus élémentaires sont le serveur à exploiter. La différence est que l'adresse IP et le port du serveur connecté sont différents, et le format d'écriture est différent.

Étape 3 : Utilisez springboot pour intégrer l'interface client dédiée de MongoDB MongoTemplate pour le fonctionnement

@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);
    }
}

Après avoir exécuté l'opération de sauvegarde, nous pouvons afficher les nouvelles données dans la base de données :

Le travail d'intégration se fait ici, et il semble à la fois familier et inconnu. Je connais cette routine, trois axes, juste ces trois astuces, des coordonnées de guidage pour configurer les opérations de l'API.Ce que je ne connais pas, c'est cette technologie, et l'API d'opération spécifique peut ne pas être familière.Nous parlerons ici de springboot intégrant MongoDB.

Résumer

1. Springboot intègre les étapes MongoDB
   1. Importer springboot pour intégrer les coordonnées de démarrage de MongoDB
   2. Faire la configuration de base
   3. Utilisez springboot pour intégrer les opérations MongoTemplate de l'interface client dédiée de MongoDB

SpringBoot intègre ES

Introduction et installation de base d'ES

La solution NoSQL a terminé l'intégration des deux technologies. Redis peut utiliser la mémoire pour charger des données et obtenir un accès rapide aux données. MongoDB peut stocker des données similaires à des objets en mémoire et obtenir un accès rapide aux données. Dans le développement au niveau de l'entreprise, la vitesse de The la poursuite est sans fin. Le contenu dont il sera question ci-dessous est également une solution NoSQL, mais son rôle n'est pas d'accélérer directement la lecture et l'écriture des données, mais d'accélérer l'interrogation des données, ce que l'on appelle la technologie ES .

ES (Elasticsearch) est un moteur de recherche en texte intégral distribué axé sur la recherche en texte intégral.

Qu'est-ce que la recherche plein texte ? Par exemple, si un utilisateur veut acheter un livre et recherche avec Java comme mot-clé, que ce soit dans le titre du livre, dans l'introduction du livre, ou même le nom de l'auteur du livre, tant que il contient java, il sera renvoyé à l'utilisateur en tant que résultat de la requête. Le processus ci-dessus est utilisé. Technologie de recherche en texte intégral. Les conditions de recherche ne sont plus seulement utilisées pour comparer un certain champ, mais pour utiliser des conditions de recherche dans un élément de données pour comparer plus de champs , tant qu'ils correspondent, ils seront inclus dans les résultats de la requête, ce qui est le but de la pleine -recherche de texte. . La technologie ES est une technologie qui peut obtenir les effets ci-dessus.

Pour obtenir l'effet d'une recherche en texte intégral, il est impossible d'utiliser l'opération similaire dans la base de données à des fins de comparaison, ce qui est trop inefficace. ES a conçu une nouvelle idée pour réaliser une recherche en texte intégral. Le processus de fonctionnement spécifique est le suivant :

1. Vérifiez et notez toutes les informations textuelles des données du champ à interroger, et divisez-les en plusieurs mots

   • Par exemple, "Spring Actual 5th Edition" sera divisé en trois mots, à savoir "Spring", "Actual Combat" et "5th Edition". Ce processus est appelé par la terminologie professionnelle 分词. Différentes stratégies de segmentation de mots ont des effets de séparation différents. Différentes stratégies de segmentation de mots sont appelées tokenizers.

2. Stocker le résultat de la segmentation des mots, correspondant à l'identifiant de chaque donnée
   

   • Par exemple, la valeur de l'élément de nom dans les données avec l'id 1 est "Spring Actual 5th Edition", puis après la fin du mot segmentation, il apparaîtra que "Spring" correspond à l'id 1, "actual combat" correspond à id 1, "Version 5" "L'identifiant correspondant est 1

   • Par exemple, la valeur de l'élément name dans les données avec l'id 3 est "Spring5 design mode", puis après la fin du mot segmentation, "Spring" correspond à l'id 3, et "design mode" correspond à l'id 3

   • À ce stade, les résultats correspondants suivants apparaîtront. Selon le formulaire ci-dessus, tousDocumentationFaites une segmentation des mots. Il convient de noter que le processus de segmentation des mots n'est pas seulement effectué sur un champ, mais sur chaque champ participant à la requête, et les résultats finaux sont résumés dans un tableau

   Une telle donnée peut être appelée un document :
   

   mot-clé de résultat de segmentation de mots	identifiant correspondant
   Le printemps	1, 2, 3, 4, 5
   combat réel	1
   5ème édition	1

3. Lors de l'interrogation, si vous entrez "combat réel" comme condition de requête, vous pouvez comparer les données du tableau ci-dessus pour obtenir la valeur id de 1, puis vous pouvez obtenir les données de résultat de la requête en fonction de la valeur id.
   

Dans le processus ci-dessus, le contenu de chaque mot clé dans le résultat de la segmentation des mots est différent et sa fonction est quelque peu similaire à l'index de la base de données, qui est utilisé pour accélérer la requête de données. Cependant, l'index dans la base de données consiste à ajouter un index à un certain champ, et le mot clé de résultat de segmentation de mot ici n'est pas une valeur de champ complète, mais seulement une partie du contenu d'un champ. Et l'index est utilisé pour trouver l'intégralité des données en fonction du contenu de l'index. Le résultat de la segmentation par mot dans la recherche en texte intégral n'aboutit pas à l'intégralité des données, mais à l'ID des données. Si vous souhaitez obtenir des données spécifiques, vous besoin d'interroger à nouveau, alors ici Un tout nouveau nom est donné à ce type de mot-clé de résultat de segmentation de mots, qui est appelé index inversé .

Parlons ensuite de l'installation : L'
adresse de téléchargement du package d'installation de la version Windows : https://www.elastic.co/cn/downloads/elasticsearch

​ Le package d'installation téléchargé est un fichier zip qui peut être utilisé après décompression. Après décompression, les fichiers suivants seront obtenus

• répertoire bin : contient toutes les commandes exécutables
• répertoire config : contient les fichiers de configuration utilisés par le serveur ES
• Répertoire jdk : ce répertoire contient une boîte à outils jdk complète, version 17. Lorsque ES est mis à niveau, utilisez la dernière version de jdk pour vous assurer qu'il n'y a pas de problème de prise en charge de version insuffisante
• Répertoire lib : contient les fichiers jar dépendants exécutés par ES
• répertoire logs : contient tous les fichiers journaux générés après l'exécution d'ES
• répertoire modules : contient tous les modules fonctionnels du logiciel ES, et est également un package jar un par un. Différent du répertoire jar, le répertoire jar est le package jar dont ES dépend pendant l'exécution, et les modules sont le package jar fonctionnel du logiciel ES lui-même.
• répertoire plugins : Contient les plugins installés par le logiciel ES, vide par défaut

démarrer le serveur

elasticsearch.bat

Double-cliquez sur le fichier elasticsearch.bat pour démarrer le serveur ES, et le port de service par défaut est 9200. Accédez à http://localhost:9200 via un navigateur et consultez les informations suivantes lorsque le serveur ES démarre normalement

Pendant le processus d'exécution, deux numéros de port doivent être mémorisés :
Port 9300 : le port de communication du composant clusterware elasticsearch, qui est simplement le port de communication interne d'elasticsearch.
Port 9200 : Le port d'accès du navigateur.

Parfois, l'opération signale l'erreur suivante : erreur

signalée par GeoIP, processeur GeoIP | Guide Elasticsearch [7.14] | Elastic

Le message d'erreur est principalement

javax.net.ssl.SSLHandshakeException : sun.security.validator.ValidatorException : la création du chemin PKIX a échoué : sun.security.provider.certpath.SunCertPathBuilderException : impossible de trouver un chemin de certification valide vers la cible demandée

La solution est la suivante, qui consiste à ajouter le certificat de sécurité ssh au répertoire de sécurité du jre téléchargé. Cependant, cela n'affecte pas le fonctionnement, il ne peut donc pas être résolu.

Résoudre PKIX : la solution

Certains utilisateurs peuvent cliquer sur le fichier elasticsearch.bat, et la fenêtre pop-up cmd se fermera automatiquement après avoir affiché quelques lignes de texte. Dans ce cas, ouvrez-le plusieurs fois jusqu'à ce qu'il fonctionne normalement.

Opération de base

Les données que nous voulons interroger sont stockées dans ES, mais le format est différent du format des données stockées dans la base de données. Dans ES, nous devons d'abord créer un index inversé, dont la fonction est similaire à celle d'une table de base de données, puis ajouter des données à l'index inversé. Les données ajoutées sont appelées un document. Par conséquent, pour effectuer des opérations ES, vous devez d'abord créer un index, puis ajouter des documents, afin que les opérations de requête suivantes puissent être effectuées.

​ Faire fonctionner ES peut se faire via des requêtes de type Rest, c'est-à-dire que l'envoi d'une requête peut effectuer une opération. Par exemple, la création d'un index et la suppression d'un index peuvent être effectuées sous la forme d'envoi d'une requête.

• Créer un index, livres est le nom de l'index, le même ci-dessous

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

  Après avoir envoyé la demande, vous verrez les informations suivantes indiquant que l'index a été créé avec succès

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

  La création répétée d'un index existant entraînera un message d'erreur, la raison de l'erreur est décrite dans l'attribut Reason

  {
        
        
      "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
  }
  

• index de requête

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

  Interrogez l'index pour obtenir des informations relatives à l'index, comme suit

  {
        
        
      "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 un index inexistant est interrogé, un message d'erreur est renvoyé. Par exemple, les informations après l'interrogation d'un index nommé livre sont les suivantes

  {
        
        
      "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
  }
  

• indice de baisse

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

  Après avoir tout supprimé, donnez le résultat de la suppression

  {
        
        
      "acknowledged": true
  }
  

  Si le doublon est supprimé, un message d'erreur s'affiche et la raison spécifique de l'erreur est également décrite dans l'attribut Reason.

  {
        
        
      "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
  }
  

• Créer un index et spécifier un tokenizer

  ​ L'index créé précédemment ne spécifie pas de tokenizer. Vous pouvez ajouter des paramètres de requête pour définir le tokenizer lors de la création de l'index. À l'heure actuelle, le tokenizer le plus populaire en Chine est le tokenizer IK.Avant de l'utiliser, téléchargez le tokenizer correspondant, puis utilisez-le.
  Adresse de téléchargement du tokenizer IK : https://github.com/medcl/elasticsearch-analysis-ik/releases

  ​ Après avoir téléchargé le tokenizer, extrayez-le dans le répertoire des plugins du répertoire d'installation ES. Après avoir installé le tokenizer, vous devez redémarrer le serveur ES. Créez un format d'index à l'aide du tokenizer 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"
              }
          }
      }
  }
  

  Une fois la création terminée, le résultat renvoyé est le même que celui de la création d'un index sans utiliser le tokenizer. À ce stade, vous pouvez observer en consultant les informations d'index que les mappages de paramètres de requête ajoutés sont entrés dans l'attribut d'index.

  {
        
        
      "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"
                  }
              }
          }
      }
  }
  

À l'heure actuelle, nous avons un index, mais il n'y a pas de données dans l'index, nous devons donc d'abord ajouter des données. Les données sont appelées un document dans ES, et l'opération de document est effectuée ci-dessous.

• Il existe trois façons d'ajouter des documents

  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"
  }  
  

• document de requête

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

• Requête conditionnelle

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

• supprimer le document

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

• Modifier le document (mise à jour complète)

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

• Documentation révisée (partiellement mise à jour)

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

Intégrer

Comment intégrer ES en utilisant springboot? Les anciennes règles, importent les coordonnées, effectuent la configuration et utilisent l'interface API pour fonctionner. L'intégration de Redis est la même, l'intégration de MongoDB est la même et l'intégration d'ES est toujours la même. Ce n'est pas nouveau, mais ce n'est pas que ce n'est pas nouveau. C'est la puissance de springboot. Tout est fait selon les mêmes règles, ce qui est très convivial pour les développeurs.

​ Commençons à intégrer ES avec springboot. Les étapes sont les suivantes :

Etape 1 : Importer les coordonnées de départ de springboot pour intégrer ES

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

Étape 2 : Effectuez la configuration de base

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

​ Configurer l'adresse du serveur ES, port 9200

Étape 3 : Utilisez springboot pour intégrer l'interface client dédiée d'ES ElasticsearchRestTemplate pour fonctionner

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

Le formulaire d'opération ci-dessus est la première méthode d'opération d'ES. Le client utilisé est appelé Client de bas niveau. Les performances de cette méthode d'opération client sont légèrement insuffisantes, ES a donc développé une nouvelle méthode d'opération client appelée Client de haut niveau. . Le client de haut niveau est mis à jour de manière synchrone avec la version ES, mais springboot a utilisé un client de bas niveau lors de l'intégration d'ES au début, de sorte que le développement d'entreprise doit être remplacé par un mode client de haut niveau.

​ Ce qui suit utilise la méthode client de haut niveau pour intégrer ES à springboot. Les étapes de fonctionnement sont les suivantes :

Etape 1 : Importer springboot pour intégrer les coordonnées du client de haut niveau ES Il n'y a actuellement aucun starter correspondant pour ce formulaire.

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

Étape 2 : Définissez le serveur ES connecté par programmation et récupérez l'objet client

@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();
      }
}

​ Configurez l'adresse du serveur ES et le port 9200. N'oubliez pas que le client doit être fermé manuellement après utilisation. Étant donné que le client actuel est géré manuellement, les objets ne peuvent pas être chargés via le câblage automatique.

Étape 3 : Utiliser l'objet client pour faire fonctionner ES, comme la création d'un index

@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();
      }
}

Les opérations client de haut niveau complètent toutes les opérations en envoyant des requêtes. ES définit divers objets de requête pour diverses opérations. Dans l'exemple ci-dessus, l'objet qui crée l'index est CreateIndexRequest, et d'autres opérations auront également son propre objet Request dédié.

Dans l'opération actuelle, nous avons constaté que quel que soit le type d'opération ES effectuée, la première étape consiste toujours à obtenir l'objet RestHighLevelClient et la dernière étape consiste toujours à fermer la connexion de l'objet. Dans le test, les fonctionnalités de la classe de test peuvent être utilisées pour aider les développeurs à effectuer les opérations ci-dessus en une seule fois, mais ils doivent également se gérer eux-mêmes lors de l'écriture de l'entreprise. Convertissez le format de code ci-dessus pour utiliser la méthode d'initialisation et la méthode de destruction de la classe de test pour maintenir l'objet client.

@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);
    }
}

Maintenant, l'écriture est beaucoup plus simplifiée et plus raisonnable. Ensuite, utilisez le mode ci-dessus pour exécuter toutes les opérations ES une fois et testez les résultats

Créer un index (tokenizer 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);
}

Le tokenizer IK est défini sous la forme de paramètres de requête, et les paramètres de requête sont définis à l'aide de la méthode source dans l'objet de requête. En ce qui concerne les paramètres, cela dépend de votre type d'opération. Lorsque des paramètres sont requis dans la demande, les paramètres peuvent être définis dans le formulaire actuel.

Ajouter de la documentation :

@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);
}

L'objet de requête utilisé pour ajouter des documents est IndexRequest, qui est différent de l'objet de requête utilisé pour créer un index.

Ajouter des documents en masse :

@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);
}

​ Lorsque vous effectuez des lots, créez d'abord un objet BulkRequest, qui peut être compris comme un conteneur pour stocker des objets de requête. Une fois toutes les requêtes initialisées, ajoutez-les à l'objet BulkRequest, puis utilisez la méthode en bloc de l'objet BulkRequest. est complet.

Interroger les documents par identifiant :

@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);
}

L'objet de requête utilisé pour interroger les documents par identifiant est GetRequest.

Interroger les documents par critères :

@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);
    }
}

​ L'objet de requête utilisé pour interroger les documents par condition est SearchRequest. Lors de l'interrogation, la méthode termQuery de l'objet SearchRequest est appelée et le nom de l'attribut de requête doit être donné. Le champ de fusion est pris en charge ici, c'est-à-dire que l'attribut all est ajouté lorsque l'attribut d'index a été défini précédemment.

L'opération de springboot intégrant ES est terminée ici. La différence entre springboot intégrant redis et mongodb à l'étape précédente est encore assez grande. La raison principale est que nous n'avons pas utilisé springboot pour intégrer les objets clients ES. En ce qui concerne l'opération, car il existe trop de types d'opérations ES, l'opération semble être un peu compliquée.

Résumer

1. springboot intègre les étapes ES
   1. Importer springboot pour intégrer les coordonnées du client de haut niveau d'ES
   2. Gestion manuelle des objets clients, y compris les opérations d'initialisation et d'arrêt
   3. Utilisez le client de haut niveau pour sélectionner différents objets de demande pour effectuer les opérations correspondantes en fonction des différents types d'opérations