Cet article a fait l'objet d'une traduction automatique.
.NET Framework
Création d'une recherche de contenu d'entreprise pour .NET
L'émergence du cloud computing dans ces dernières années a été une aubaine pour les organisations et les utilisateurs finaux. Les organisations peuvent savoir leurs clients comme jamais auparavant et de les cibler avec des communications personnalisées. Utilisateurs peuvent obtenir à leurs données de presque n'importe où, en rendant beaucoup plus accessible et utile. Centres de données énormes ont été construits dans le monde entier pour stocker toutes ces données. Mais les données volumineuses conduit à grands défis.
La célèbre citation de John Naisbitt, "nous sommes noyade dans les données mais affamés pour plus d'informations," dans son livre, "grandes tendances : Dix nouvelles orientations transforme notre vie » (Warner Books, 1982), décrit parfaitement la situation actuelle sur le marché de données volumineuses. Entreprises sont en mesure de stocker des pétaoctets de données, mais être capable pour comprendre ces données et de le rendre consultable, est beaucoup plus difficile, surtout parce que la plupart des entrepôts de données stockent des données de manière non structurée (NoSQL) à travers plusieurs collections à l'intérieur des magasins de données Big particulières ou même dans une forme répartie entre différents entrepôts. En outre, il y a une variété de formats de données, tels que documents JSON, fichiers Microsoft Office et ainsi de suite. La recherche à travers une collection unique de non structurée en général n'est pas un problème, mais il est beaucoup plus difficile de rechercher toutes les données non structurées à travers plusieurs collections de trouver juste un petit sous-ensemble des résultats lorsque l'utilisateur n'a aucune idée où il pourrait être. Il s'agit là recherche d'entreprise entre en jeu.
Recherche d'entreprise
Voici l'enjeu essentiel de recherche d'entreprise : Comment une organisation de grande taille avec un grand nombre de sources de données peut fournir des utilisateurs internes et externes avec la possibilité de rechercher toutes les sources de données entreprise publique via une interface ? Cette interface unique peut être une API, un site Web de la société ou même une simple zone de texte avec la fonctionnalité de saisie semi-automatique, mis en place sous le capot. N'importe quelle interface choisie par une entreprise, il doit fournir la capacité de recherche par le biais de son univers de données entière, qui peuvent inclure des bases de données structurées et non structurées, documents de l'intranet sous différents formats, autres API et autres types de sources de données.
La recherche par le biais de plusieurs ensembles de données étant assez complexe, il y a seulement quelques solutions de recherche reconnue entreprise — et la barre est haute. Une solution de recherche d'entreprise doit comporter les fonctions suivantes :
- Sensibilisation du contenu : Savoir où certains types de données peuvent être trouvées.
- Indexation en temps réel : Conserver toutes les données indexées.
- Traitement de contenu : Rendre les différentes sources de données accessibles.
Une des solutions de recherche entreprise plus populaires est l'open source Elasticsearch (elasticsearch.org). Cette Java-basé sur serveur basé sur Apache Lucene (lucene.apache.org) offre évolutive, texte intégral de rechercher sur plusieurs sources de données, avec prise en charge JSON et une interface Web de repos, ainsi que haute disponibilité, gestion des conflits et analytique en temps réel. Visitez bit.ly/1vzoUrR de voir sa pleine fonctionnalité définie.
D'un niveau élevé, la façon dont Elasticsearch stocke les données est très simple. L'élément le plus haut de la structure au sein d'un serveur est appelé un index, et plusieurs indices peuvent exister dans la même banque de données. L'indice lui-même est juste un conteneur pour les documents (un ou plusieurs), et chaque document est une collection d'un ou plusieurs champs (avec aucune structure définie). Chaque index peut contenir des données agrégées en unités appelées types qui représentent des groupes logiques de données dans un index particulier.
Il peut être utile de considérer Elasticsearch comme semblable à un tableau du monde des bases de données relationnelles. La même corrélation existe entre les lignes de la table et colonnes et d'un index documents et champs, où un document correspond à une ligne et un champ d'une colonne. Cependant, avec Elasticsearch, il n'y a aucun schéma de structure ou de base de données de données fixes.
Comme je l'ai noté, les développeurs peuvent communiquer avec le serveur de Elasticsearch via une interface Web REST. Autrement dit, qu'ils peuvent interroger l'index, types, données ou autres informations système juste en envoyant des requêtes Web reste depuis un navigateur ou tout autre type de client Web. Voici quelques exemples de requêtes GET :
- Requête pour tous les indices :
http://localhost:9200/_cat/indices /? v - Requête pour les métadonnées de l'index :
clients/http://localhost:9200/_stats - Requête pour toutes les données d'index :
http://localhost:9200/clients/_search? q = *: * - Recherche d'une valeur de champ spécifique au sein de l'indice :
http://localhost:9200/clients/_search? q = valeur du champ : - Obtenir toutes les données dans le type de mappage d'index :
http://localhost:9200/clients/commandes/_search? q = *: *
Création d'une recherche
Pour montrer comment créer un simple, solution multi-sources, je vais utiliser Elasticsearch 1.3.4 avec des documents PDF du document JSON et une base de données du SQL Server . Pour commencer, je vais décrire brièvement le programme d'installation de Elasticsearch et ensuite montrer comment brancher dans chaque source de données pour rendre les données consultables. Pour garder les choses simples, je vais présenter un exemple de close-to-real-life qui utilise des sources de données de la célèbre compagnie de Contoso.
Je vais utiliser une base de données du SQL Server 2014 avec plusieurs tables en elle, même si je vais seulement utiliser un, dbo.Commandes. Comme la table nom l'indique, il stocke les dossiers concernant les ordres de clients de la société — un grand nombre d'enregistrements, mais facile à gérer :
CREATE TABLE [dbo].[Orders]
(
[Id] [int] IDENTITY(1,1) NOT NULL primary key,
[Date] [datetime] NOT NULL,
[ProductName] [nvarchar](100) NOT NULL,
[Amount] [int] NOT NULL,
[UnitPrice] [money] NOT NULL
);
J'ai aussi un réseau partager avec plusieurs documents de société organisées en une hiérarchie de dossiers. Les documents sont liés aux campagnes de marketing de produit différent la société organisé par le passé et est stockée dans plusieurs formats, y compris les PDF et Microsoft Office Word. La taille moyenne des documents est d'environ 1 Mo.
Enfin, j'ai un internes de la société API qui expose les informations client de la société au format JSON ; parce que je sais la structure de la réponse, je suis capable de désérialiser facilement à un objet de client de type. Mon but est de faire toutes les sources de données interrogeables en utilisant le moteur de Elasticsearch. De plus, je veux créer un service Web basé sur Web API 2 qui, sous le capot, se produira une requête de l'entreprise à travers tous les indices en faisant un seul appel au serveur Elasticsearch. (Plus d'informations sur Web API 2 à bit.ly/1ae6uya.) Le service Web renvoie les résultats sous forme de liste de suggestions avec les indices potentiels à l'utilisateur final ; une telle liste peut plus tard être consommée par un contrôle de saisie semi-automatique intégré dans l'application MVC ASP.NET , ou par tout autre type de site Web.
Mise en place
La première chose que je dois faire est d'installer le serveur Elasticsearch. Pour Windows, vous pouvez faire cela soit automatiquement, soit manuellement, avec le même résultat — un service Windows en cours d'exécution, hébergeant le serveur Elasticsearch. L'installation automatique est très rapide et facile ; tout ce que vous devez faire est de télécharger et d'exécuter le programme d'installation MSI Elasticsearch (bit.ly/12RkHDz). Malheureusement, il n'y a aucun moyen de choisir une version de Java ou, beaucoup plus important, une version de Elasticsearch. Le processus d'installation manuelle, en revanche, nécessite un peu plus d'efforts, mais il permet beaucoup plus de contrôle sur les composants, il est donc plus approprié dans ce cas.
Mise en place Elasticsearch comme un service Windows manuellement nécessite les étapes suivantes :
- Télécharger et installer la plus récente Java SE Runtime Environment (bit.ly/1m1oKlp).
- Ajoutez la variable d'environnement JAVA_HOME. Sa valeur sera le chemin du dossier vous avez installé Java dans (par exemple, C:\Program Files\Java\jre7), comme le montre Figure 1.
- Télécharger le fichier Elasticsearch (bit.ly/1upadla) et décompressez-le.
- Déplacez les sources décompressés à Program Files | Elasticsearch (facultatif).
- Exécutez l'invite de commandes en tant qu'administrateur et exécutez service.bat avec le paramètre d'installation :
C:\Program Files\Elasticsearch\elasticsearch-1.3.4\bin>service.bat installer
.png "Paramétrage de la Variable d'environnement Java_Home")
Figure 1 Paramétrage de la Variable d'environnement Java_Home
C'est tout ce qu'il faut pour obtenir le service de Windows vers le haut et la course à pied, avec le serveur de Elasticsearch accessible sur localhost, sur le port de 9200. Maintenant, je peux effectuer une requête Web à l'URL http://localhost:9200 / via n'importe quel Web browser et je vais obtenir une réponse qui ressemble à ceci :
{
"status" : 200,
"name" : "Washout",
"version" : {
"number" : "1.3.4",
"build_hash" : "a70f3ccb52200f8f2c87e9c370c6597448eb3e45",
"build_timestamp" : "2014-09-30T09:07:17Z",
"build_snapshot" : false,
"lucene_version" : "4.9"
},
"tagline" : "You Know, for Search"
}
Mon instance locale de Elasticsearch est maintenant prêt à partir ; Toutefois, la version raw ne me donne pas la possibilité de se connecter au SQL Server ou lancez une recherche de texte intégral par le biais de fichiers de données. Pour rendre ces fonctionnalités disponibles, je dois aussi installer plusieurs plug-ins.
Extension Elasticsearch
Comme je le disais, la version brute de Elasticsearch ne vous permet pas une source de données externe comme SQL Server, au bureau ou même un PDF de l'index. Pour faire toutes ces sources de données interrogeables, j'ai besoin d'installer quelques plugins, qui est assez facile.
Mon premier objectif est de soutenir la recherche en texte intégral pour les pièces jointes. Par attachement, j'entends un base64 -codé représentation du fichier source qui a été téléchargé à un magasin de données de Elasticsearch comme un document JSON. (Voir bit.ly/12RGmvg pour plus d'informations sur le type de pièce jointe.) Le plug-in, j'ai besoin pour cette fin est le Type de pièces jointes de Mappeur pour Elasticsearch version 2.3.2, disponible à bit.ly/1Alj8sy. Il s'agit de l'extension Elasticsearch qui permet une recherche de texte intégral pour les documents, et il est basé sur le projet Apache Tika (tika.apache.org), qui détecte et extrait les métadonnées et texte contenu de divers types de documents et prend en charge les formats de fichiers répertoriés au bit.ly/1qEyVmr.
Comme pour la plupart plug-ins pour Elasticsearch, cette installation est extrêmement simple, et tout ce que je dois faire est d'exécuter l'invite de commandes en tant qu'administrateur et exécutez la commande suivante :
bin>plugin --install elasticsearch/elasticsearch-mapper-attachments/2.3.2
Après téléchargement et extraction du plug-in, j'ai besoin de redémarrer le service Elasticsearch Windows.
Quand cela est fait, j'ai besoin de configurer le support du SQL Server . Bien sûr, il est également un plug-in pour cela. Ça s'appelle la rivière JDBC (bit.ly/12CK8Zu) et permet l'extraction de données d'une source JDBC, comme SQL Server, pour l'indexation dans Elasticsearch. Le plug-in est facilement installé et configuré, bien que le processus d'installation comporte trois étapes qui doivent être remplis.
- Tout d'abord, j'ai installer le Microsoft JDBC Driver 4.0, un Java-basé pour SQL Server qui peut être téléchargé à partir bit.ly/1maiM2j. La chose importante à retenir est que j'ai besoin d'extraire le contenu du fichier téléchargé dans le dossier nommé Microsoft JDBC Driver 4.0 pour SQL Server (qui doit être créée si elle n'existe pas), directement sous le dossier Program Files, si le chemin d'accès qui en résulte ressemble à : C:\Program Files\Microsoft pilote JDBC 4.0 pour SQL Server.
- Ensuite, j'ai installer le plug-in à l'aide de la commande suivante :
bin> plugin--installer
JDBC--url « http://xbib.org/repository/org/xbib/elasticsearch/plugin/elasticsearch-river-jdbc/1.3.4.4/elasticsearch-river-jdbc-1.3.4.4-plugin.zip » - Enfin, j'ai copier le fichier de SQLJDBC4.jar extrait dans la première étape (C:\Program Files\Microsoft JDBC DRIVER 4.0 pour SQL Server\sqljdbc_4.0\enu\SQLJDBC4.jar) dans le dossier lib dans le répertoire Elasticsearch (C:\Program Files\Elasticsearch\lib). Lorsque j'ai terminé, j'ai besoin de ne pas oublier de redémarrer le service Windows.
Maintenant, tous les plug-ins requis ont été installés. Toutefois, pour vérifier les installations fini correctement, j'ai besoin d'envoyer la commande suivante dans une demande HTTP GET :
http://localhost:9200/_nodes/_all/plugins
Dans la réponse, je m'attends à voir les deux plug-ins installés dans la liste, comme le montre Figure 2.
.png "les Plug-Ins installés")
Figure 2 les Plug-Ins installés
Configurer SQL Server
Pour utiliser JDBC River avec SQL Server, l'instance de SQL Server doit être accessible via TCP/IP, qui, par défaut, est désactivé. Cependant, ce qui lui permet est simple et tout ce que je dois faire est ouvrir le gestionnaire de Configuration de SQL Server et, sous la Configuration réseau du SQL Server , pour l'instance de SQL Server que je veux me connecter, pour changer la valeur d'État à activer pour le protocole TCP/IP, comme le montre Figure 3. Après avoir fait cela, je devrais être capable de vous connecter sur mon instance de SQL Server via Management Studio en utilisant localhost 1433 dans le nom du serveur (port 1433 est le port par défaut pour accéder à SQL Server via TCP/IP).
.png "activation TCP/IP pour l'Instance du SQL Server")
Figure 3 activation TCP/IP pour l'Instance du SQL Server
Rendre les Sources consultable
Les plug-ins requis ont été installés, donc maintenant il est temps pour charger les données. Comme mentionné précédemment, j'ai trois sources de données différentes (JSON documents, fichiers et une table de commandes d'une base de données du SQL Server ) que je souhaite avoir indexé sur Elasticsearch. Je peux indexer ces sources de données de différentes manières, mais je veux démontrer combien il est facile, c'est en utilisant un.Application basée sur le NET que j'ai mis en place. Par conséquent, comme condition préalable pour l'indexation, je dois installer une bibliothèque externe appelée NEST (bit.ly/1vZjtCf) pour mon projet, qui n'est rien d'autre qu'un wrapper managé autour d'une interface Web de Elasticsearch. Parce que cette bibliothèque est disponible sur NuGet, ce qui en fait partie de mon projet est aussi simple que l'exécution d'une seule commande dans la Console Gestionnaire de package :
PM> Install-Package NEST
Maintenant, avec la bibliothèque de nid disponible dans ma solution, je peux créer un nouveau projet de bibliothèque de classe appelé ElasticSearchRepository. J'ai utilisé ce nom parce que j'ai décidé de garder tous les appels de fonction de la classe ElasticClient (qui appartient à la bibliothèque de nid) séparé du reste de la solution. Ce faisant, le projet devient semblable au référentiel design modèle largement appliqué dans le Entity Framework-selon les demandes, il devrait être facile à comprendre. En outre, dans ce projet, j'ai juste trois classes : la classe BaseRepository, qui initialise et expose les classes héritées et l'instance de l'ElasticClient, et deux autres classes du référentiel :
- IndexRepository — une classe de lecture/écriture, je vais utiliser pour manipuler des indices, définir des mappages et télécharger des documents.
- DiscoveryRepository — une classe en lecture seule je vais l'utiliser pendant les opérations de recherche basées sur l'API.
Figure 4 montre la structure de la classe BaseRepository avec une propriété protégée de type ElasticClient. Ce type, prévu dans le cadre de la bibliothèque de nid, centralise la communication entre le serveur Elasticsearch et l'application cliente. Pour créer une instance de celui-ci, je peux passer une URL au serveur Elasticsearch, que je le passer comme un paramètre de constructeur de classe facultative. Si le paramètre est null, une valeur par défaut de http://localhost:9200 serviront.
Figure 4 la classe de BaseRepository
namespace ElasticSearchRepository
{
using System;
using Nest;
public class BaseRepository
{
protected ElasticClient client;
public BaseRepository(Uri elastiSearchServerUrl = null)
{
this.client = elastiSearchServerUrl != null ?
new ElasticClient(new ConnectionSettings(elastiSearchServerUrl)) :
: new ElasticClient();
}
}
}
Avec le client est prêt, tout d'abord je vais indexer les données du Client ; C'est le scénario plus facile car aucun plug-ins supplémentaires ne sont nécessaires :
public class Client
{
public int Id { get; set; }
public string Name { get; set; }
public string Surname { get; set; }
public string Email { get; set; }
}
Pour ce type de données de l'index, la parole est l'instance de mon client de Elasticsearch, ainsi que l'Index<T> fonction, où T est le type de ma classe de Client, qui représente des données retournées par l'API sérialisées. Cette fonction générique prend trois paramètres : l'instance de T classe d'objet, un nom d'index cible et un nom de mappage dans l'index :
public bool IndexData<T>(T data, string indexName =
null, string mappingType = null)
where T : class, new()
{
if (client == null)
{
throw new ArgumentNullException("data");
}
var result = this.client.Index<T>(data,
c => c.Index(indexName).Type(mappingType));
return result.IsValid;
}
Les deux derniers paramètres sont facultatifs parce que le NID s'appliquera sa logique par défaut pour la création d'un nom d'index cible basé sur le type générique.
Maintenant, je veux indexer les documents de commercialisation, qui portent sur les produits de la société. Comme je l'ai ces fichiers stockés sur un partage réseau, je peux envelopper les informations sur chaque document particulier dans une classe simple de MarketingDocument. Il est à noter ici que, si je veux un document indexé dans Elasticsearch, j'ai besoin de le télécharger sous forme de chaîne codée en Base64 :
public class MarketingDocument
{
public int Id { get; set; }
public string Title { get; set; }
public string ProductName { get; set; }
// Base64-encoded file content.
public string Document { get; set; }
}
La classe est prête, si je peux utiliser le ElasticClient pour marquer un champ particulier dans ma classe MarketingDocument en pièce jointe. Je peux y parvenir en créant un nouvel indice dénommé les « produits » et y ajouter un nouveau mappage de commercialisation (pour plus de simplicité, le nom de la classe sera le nom de mappage) :
private void CreateMarketingIndex()
{
client.CreateIndex("products", c =>
c.AddMapping<Marketing>
(m => m.Properties(ps =>ps.Attachment(a =>
a.Name(o =>o.Document).TitleField(t =>
t.Name(x => x.Name)
TermVector(TermVectorOption.WithPositionsOffsets)
)))));
}
Maintenant que j'ai le type .NET et le mappage des données marketing, ainsi que la définition d'une pièce jointe, je peux commencer mes fichiers l'indexation de la même façon, que j'ai répertorié les données du client :
var documents = GetMarketingDocumentsMock();
documents.ForEach((document) =>
{
indexRepository.IndexData<MarketingDocument>(document, "marketing");
});
La dernière étape est la configuration de la rivière JDBC sur Elasticsearch. Malheureusement, nid ne supporte JDBC rivière encore. En théorie, je peux créer un mappage de JDBC rivière en utilisant une fonction Raw pour envoyer une requête brute avec JSON, mais je ne veux pas overcomplicate les choses. Je vais donc, pour compléter le processus de création de la cartographie, pour spécifier les paramètres suivants :
- Une chaîne de connexion à la base de données du SQL Server
- Une requête SQL qui sera utilisée pour rechercher des données
- Calendrier de mise à jour
- Nom de l'index cible et le type (facultatif)
(Vous trouverez une liste complète des paramètres configurables à bit.ly/12CK8Zu.)
Pour créer un nouveau mappage de JDBC River, j'ai besoin d'envoyer une requête PUT avec un corps de demande spécifié dedans à l'URL suivante :
http://localhost:9200/_river/{river_name}/_meta
Dans l'exemple de Figure 5, j'ai mis un corps de la requête pour créer un nouveau mappage de JDBC River, qui se connecte à la base de données Contoso hébergée sur l'instance locale de SQL Server , qui est accessible sur le port 1433 via TCP/IP.
Figure 5 HTTP mettre la demande de création d'un nouveau mappage de JDBC River
PUT http://localhost:9200/_river/orders_river/_meta
{
"type":"jdbc",
"jdbc":
{
"driver": "com.microsoft.sqlserver.jdbc.SQLServerDriver",
"url":"jdbc:sqlserver://127.0.0.1:1433;databaseName=Contoso",
"user":"elastic",
"password":"asd",
"sql":"SELECT * FROM dbo.Orders",
"index" : "clients",
"type" : "orders",
"schedule": "0/30 0-59 0-23 ? * *"
}
}
Il utilise le login « élastique » et le mot de passe « asd » pour authentifier l'utilisateur et exécuter la commande SQL suivante :
SELECT * FROM dbo.Orders
Chaque ligne de données renvoyées par cette requête SQL est indexé selon l'index de clients dans les ordonnances type de cartographie et de l'indexation aura lieu toutes les 30 secondes (représentés dans la notation de Cron, voir bit.ly/1hCcmnN pour plus d'informations).
Une fois ce processus terminé, vous devriez voir dans les informations du fichier (/logs/ elasticsearch.log) Elasticsearch journal semblables au suivant :
[2014-10-2418:39:52,190][INFO][river.jdbc.RiverMetrics]
pipeline org.xbib.elasticsearch.plugin.jdbc.RiverPipeline@70f0a80d
complete: river jdbc/orders_river metrics: 34553 rows, 6.229481683638776 mean,
(0.0 0.0 0.0), ingest metrics: elapsed 2 seconds,
364432.0 bytes bytes, 1438.0 bytes avg, 0.1 MB/s
Si quelque chose ne va pas avec la configuration de la rivière, le message d'erreur sera également dans le journal.
La recherche des données
Une fois que toutes les données ont été indexés dans le moteur de Elasticsearch, je peux commencer à interroger. Bien sûr, je peux envoyer des demandes simples sur le serveur de Elasticsearch à la requête un ou plusieurs indices et types de mappage dans le même temps, mais je veux construire quelque chose de plus utile et plus proche d'un scénario réel. Donc je vais diviser mon projet en trois volets différents. Le premier volet, que j'ai déjà présenté, est Elasticsearch, qui est disponible via http://localhost:9200 /. Le deuxième volet est une API je vais construire en utilisant la technologie Web API 2. Le dernier élément est une application de console, que je vais utiliser pour mettre en place mon indice de Elasticsearch, ainsi que de le nourrir avec des données.
Pour créer mon projet Web API 2, tout d'abord, j'ai besoin de créer un projet d'Application Web ASP.NET vide et ensuite dans la Console Gestionnaire de package , exécuter la que commande d'installation de ce qui suit :
Install-Package Microsoft.AspNet.WebApi
Une fois le projet créé, l'étape suivante consiste à ajouter un nouveau contrôleur, que je vais utiliser pour traiter les requêtes d'interrogation du client et les transmettre à Elasticsearch. Ajout d'un nouveau contrôleur nommé DiscoveryController implique rien plus d'ajouter un nouvel élément, une classe de Web API ApiController (v2.1). Et j'ai besoin de mettre en œuvre une fonction de recherche, qui sera exposée via l'URL : http://website/API/Discovery/search?searchterm=user_input :
[RoutePrefix("api/discovery")]
public class DiscoveryController : ApiController
{
[HttpGet]
[ActionName("search")]
public IHttpActionResult Search(string searchTerm)
{
var discoveryRepository = new DiscoveryRepository();
var result = discoveryRepository.Search(searchTerm);
return this.Ok(result);
}
}
Si le moteur Web API 2 ne peut pas sérialiser une réponse grâce à une boucle auto-référencement, vous devrez ajouter ce qui suit dans le fichier WebApiConfig.cs qui se trouve dans le dossier AppStart :
GlobalConfiguration.Configuration
.Formatters
.JsonFormatter
.SerializerSettings
.ReferenceLoopHandling =
ReferenceLoopHandling.Ignore;
Comme Figure 6 montre, dans le corps du régulateur, j'ai créé, j'ai instancié d'une classe de type DiscoveryRepository, qui est simplement un wrapper autour du type ElasticClient de la bibliothèque de nid. À l'intérieur de ce référentiel non générique, en lecture seule, j'ai mis en place deux types de fonctions de recherche et deux d'entre eux retournent un type dynamique. Cette partie est importante car en faisant cela dans les deux instances de la fonction, je ne suis pas en limitant mes questions juste pour un index ; au lieu de cela, j'interroge tous les indices et tous les types en même temps. Cela signifie que mes résultats a une structure différente (seront de différents types). La seule différence entre les fonctions est la méthode de requête. Dans la première fonction je viens d'utiliser une méthode de QueryString (bit.ly/1mQEEg7), qui est une recherche de correspondance exacte et dans le second, une méthode floue (bit.ly/1uCk7Ba), qui effectue une recherche floue sur les indices.
Figure 6 mise en œuvre de deux Types de recherche
namespace ElasticSearchRepository
{
using System;
using System.Collections.Generic;
using System.Linq;
public class DiscoveryRepository : BaseRepository
{
public DiscoveryRepository(Uri elastiSearchServerUrl = null)
: base(elastiSearchServerUrl)
{
}
///<summary>
public List<Tuple<string, string>> SearchAll(string queryTerm)
{
var queryResult=this.client.Search<dynamic>(d =>
d.AllIndices()
.AllTypes()
.QueryString(queryTerm));
return queryResult
.Hits
.Select(c => new Tuple<string, string>(
c.Indexc.Source.Name.Value))
.Distinct()
.ToList();
}
///<summary>
public dynamic FuzzySearch(string queryTerm)
{
return this.client.Search<dynamic>(d =>
d.AllIndices()
.AllTypes()
.Query(q => q.Fuzzy(f =>
f.Value(queryTerm))));
}
}
}
Maintenant quand mon API est prêt, je peux courir et commencer à tester il juste en envoyant des requêtes GET pour http://website:port/api/découverte/recherche? searchTerm = user_input et passez l'entrée d'utilisateur comme la valeur du paramètre de requête searchTerm. Par conséquent, Figure 7 montre les résultats que mon API génère pour le terme de recherche « scrum ». Comme je l'ai souligné sur la capture d'écran, une fonction de recherche effectué une requête sur tous les indices dans les banques de données et retourné hits de multiples indices en même temps.
.png "API sultats de la recherche pour le terme « mêlée »")
Figure 7 API sultats de la recherche pour le terme « mêlée »
En mettant en place la couche API, j'ai créé la possibilité d'implanter plusieurs clients (comme un site Web ou une application mobile), qui seront en mesure d'en consommer. Cela permet de donner la fonctionnalité de recherche d'entreprise aux utilisateurs finaux. Vous pouvez trouver un exemple d'implémentation de la saisie semi-automatique de contrôle pour un client de base 4 MVC Web ASP.NET sur mon blog à bit.ly/1yThHiZ.
Jaquette en haut
Données volumineuses a apporté beaucoup sur le marché de la technologie, en termes de possibilités et de défis. Un des défis, qui est aussi potentiellement une grande opportunité, est la possibilité de mise en œuvre de recherche rapide en pétaoctets de données sans avoir à connaître l'emplacement exact des données dans l'univers de données. Dans cet article, j'ai décrit comment implémenter la recherche d'entreprise et a démontré comment le faire dans le .NET Framework en combinaison avec les bibliothèques Elasticsearch et nid.
Damian Zapart est un responsable du développement chez Citigroup Inc. et se concentre principalement sur les solutions d'entreprise. Dans le même temps, il est un geek programmation intéressé par des technologies de pointe, des design patterns et des données volumineuses. Consultez son blog à bit.ly/1suoKN0 pour en savoir plus à son sujet.
Remercie les experts techniques suivants d'avoir relu cet article : Evren Onem (D&B) et Bruno Terkaly (Microsoft)
Evren Onem (D&B) est un principe software engineer chez D&B. Son travail consiste à concevoir et construire le reste massivement scalable API. Il est également chercheur nocturne sur les réseaux ad hoc de la radio cognitive.
Bruno Terkaly est un ingénieur logiciel principal chez Microsoft dans le but de permettre le développement des principales applications de l'industrie et des services entre des dispositifs. Il est chargé de conduire les nuages haut de la page et les opportunités mobiles aux États-Unis et au-delà du point de vue technologie habilitation. Il aide les partenaires apportent leurs applications sur le marché en fournissant des conseils architecturaux et technique approfondies engagement durant l'évaluation, de développement et de déploiement de l'ISV. Il travaille aussi étroitement avec les nuages et les groupes de la technologie mobiles, rétro-information et influer sur la feuille de route.