{"id":63690,"date":"2017-02-13T16:00:28","date_gmt":"2017-02-13T14:00:28","guid":{"rendered":"http:\/\/www.javacodegeeks.com\/?p=63690"},"modified":"2023-12-11T10:14:33","modified_gmt":"2023-12-11T08:14:33","slug":"elasticsearch-java-developers-introduction","status":"publish","type":"post","link":"https:\/\/www.javacodegeeks.com\/2017\/02\/elasticsearch-java-developers-introduction.html","title":{"rendered":"Elasticsearch for Java Developers: Introduction"},"content":{"rendered":"

This article is part of our Academy Course titled Elasticsearch Tutorial for Java Developers<\/a>.<\/p>\n

In this course, we provide a series of tutorials so that you can develop your own Elasticsearch based applications. We cover a wide range of topics, from installation and operations, to Java API Integration and reporting. With our straightforward tutorials, you will be able to get your own projects up and running in minimum time. Check it out here<\/a>!<\/em><\/p>\n

<\/a>1. Introduction<\/h2>\n

Effective, fast and accurate search functionality is an integral part of vast majority of the modern applications and software platforms. Either you are running a small e-commerce web site and need to offer your customers a search over product catalogs, or you are a service provider and need to expose an API to let the developers filter over users and companies, or you are building any kind of messaging application where finding a conversation in the history is a must-have feature from day one \u2026 What is really important is that, delivering as relevant results as fast as possible could be yet another competitive advantage of the product or platform you are developing.<\/p>\n

\n

Table Of Contents<\/h3>\n
\n
1. Introduction<\/a><\/dt>\n
2. Elasticsearch Basics<\/a><\/dt>\n
\n
\n
2.1. Documents<\/a><\/dt>\n
2.2. Indices<\/a><\/dt>\n
2.3. Index Settings<\/a><\/dt>\n
2.4. Mappings<\/a><\/dt>\n
2.5. Advanced Mappings<\/a><\/dt>\n
2.6. Indexing<\/a><\/dt>\n
2.7. Internalization (i18n)<\/a><\/dt>\n<\/dl>\n<\/dd>\n
3. Running Elasticsearch<\/a><\/dt>\n
\n
\n
3.1. Standalone Instance<\/a><\/dt>\n
3.2. Clustering<\/a><\/dt>\n
3.3. Embedding Into Application<\/a><\/dt>\n
3.4. Running As Container<\/a><\/dt>\n<\/dl>\n<\/dd>\n
4. Where Elasticsearch Fits<\/a><\/dt>\n
5. Conclusion<\/a><\/dt>\n
6. What\u2019s next<\/a><\/dt>\n<\/dl>\n<\/div>\n

Indeed, the search could have many faces, purposes, goals and different scale. It could be as simple as looking by exact word match or as complex as trying to understand the intent and the contextual meaning of the words one\u2019s is looking for (semantic search<\/a> engines). In terms of scale, it could be as trivial as querying a single database table, or as complex as crunching over billions and billions of web pages in order to deliver the desired results. It is very interesting and flourishing area of research, with many algorithms and papers published over the years.<\/p>\n

In case you are a Java \/ JVM developer, you may have heard about Apache Lucene<\/a> project, a high-performance, full-featured indexing and search library. It is the first and the best in class choice to unleash the power of full-text search and embed it into your applications. Although it is a terrific library by all means, many developers have found Apache Lucene<\/a> too low-level and not easy to use. That is one of the reasons why two other great projects, Elasticsearch<\/a> and Apache Solr<\/a>, have been born.<\/p>\n

In this tutorial, we are going to talk about Elasticsearch<\/a>, making an emphasis on development side of things rather than operational. We are going to learn the basics of Elasticsearch<\/a>, get familiarized with the terminology and discuss different ways to run it and communicate with it from within Java \/ JVM applications or command line. At the very end of the tutorial we are going to talk about Elastic Stack<\/a> to showcase the ecosystem around Elasticsearch<\/a> and its amazing capabilities.<\/p>\n

If you are a junior or seasoned Java \/ JVM developer and interested in learning about Elasticsearch<\/a>, this tutorial is definitely for you.<\/p>\n

<\/a>2. Elasticsearch Basics<\/h2>\n

To get started, it would be great to answer the question: so, what is Elasticsearch<\/a>, how it can help me and why should I use it?<\/p>\n

\n

Elasticsearch is a highly scalable open-source full-text search and analytics engine. It allows you to store, search, and analyze big volumes of data quickly and in near real time. It is generally used as the underlying engine\/technology that powers applications that have complex search features and requirements. \u2013 <\/em>https:\/\/www.elastic.co\/<\/em><\/a><\/p>\n<\/blockquote>\n

Elasticsearch<\/a> is built on top of Apache Lucene<\/a> but favors communication over RESTful APIs<\/a> and advanced in-depth analytics features. The RESTful<\/a> part makes Elasticsearch<\/a> particularly easy to learn and use. As of the moment of this writing, the latest stable release branch of the Elasticsearch<\/a> was 5.2<\/code>, with the latest released version being 5.2.0<\/code>. We should definitely give Elasticsearch<\/a> guys the credit for keeping the pace of delivering new releases so often, 5.0.x \/ 5.1.x <\/code>branches are just a few months old \u2026.<\/p>\n

In perspective of Elasticsearch<\/a>, being RESTful APIs<\/a> has another advantage: every single piece of data sent to or received from Elasticsearch<\/a> is itself a human-readable JSON<\/a> document (although this is not the only protocol Elasticsearch<\/a> supports as we are going to see later on).<\/p>\n

To keep the discussion relevant and practical, we are going to pretend that we are developing the application to manage the catalog of books. The data model will include categories, authors, publisher, book details (like publishing date, ISBN, rating) and brief description.<\/p>\n

\"Book<\/a>
Book Catalog<\/figcaption><\/figure><\/p>\n

Let us see how we could leverage Elasticsearch<\/a> to make our book catalog easily searchable but before that we need to get familiarized a bit with the terminology. Although in the next couple of sections we are going to go over most of the concepts behind Elasticsearch<\/a>, please do not hesitate to consult Elasticsearch official documentation<\/a> any time.<\/p>\n

<\/a>2.1. Documents<\/h3>\n

To put it simply, in context of Elasticsearch<\/a> document is just an arbitrary piece of data (usually, structured). It could be absolutely anything which makes sense to your applications (like users, logs, blog posts, articles, products, \u2026) but this is a basic unit of information which Elasticsearch<\/a> could manipulate.<\/p>\n

<\/a>2.2. Indices<\/h3>\n

Elasticsearch<\/a> stores documents inside indices and as such, an index is simply a collection of the documents. To be fair, persisting absolutely different kind of the documents in the same index would be somewhat convenient but quite difficult to work with so every index may have one or more types. The types group documents logically by defining a set of common properties (or fields) every document of such type should have. Types serve as a metadata about documents and are very useful for exploring the structure of the data and constructing meaningful queries and aggregations.<\/p>\n

<\/a>2.3. Index Settings<\/h3>\n

Each index in Elasticsearch<\/a> could have specific settings associated with it at the time of its creation. The most important ones are number of shards and replication factor. Let us talk about that for a moment.<\/p>\n

Elasticsearch<\/a> has been built from the ground up to operate over massive amount of indexed data which will very likely exceed the memory and\/or storage capabilities of a single physical (or virtual) machine instance. As such, Elasticsearch<\/a> uses sharding as a mechanism to split the index into several smaller pieces, called shards, and distribute them among many nodes. Please notice, once set the number of shards could not be altered (although this is not entirely true anymore, the index could be shrunk into fewer shards<\/a>).<\/p>\n

Indeed, sharding solves a real problem but it is vulnerable to data loss issues due to individual node failures. To address this problem, Elasticsearch<\/a> supports high availability by leveraging replication. In this case, depending on replication factor, Elasticsearch<\/a> maintains one or more copies of each shard and makes sure that each shard\u2019s replica is placed on different node.<\/p>\n

<\/a>2.4. Mappings<\/h3>\n

The process of defining the type of the documents and assigning it to a particular index is called index mapping, mapping type or just a mapping. Coming up with a proper type mapping is, probably, one of the most important design exercises you would have to make in order to get most out of Elasticsearch<\/a>. Let us take some time and talk about mappings in details.<\/p>\n

Each mapping consists of optional meta-fields (they usually start from the underscore \u2018_\u2019<\/code> character like _index<\/code>, _id<\/code>, _parent<\/code>) and regular document fields (or properties). Each field (or property) has a data<\/strong> type<\/strong>, which in Elasticsearch<\/a> could fall into one of those categories:<\/p>\n