DZone
Thanks for visiting DZone today,
Edit Profile
  • Manage Email Subscriptions
  • How to Post to DZone
  • Article Submission Guidelines
Sign Out View Profile
  • Post an Article
  • Manage My Drafts
Over 2 million developers have joined DZone.
Log In / Join
Refcards Trend Reports
Events Video Library
Refcards
Trend Reports

Events

View Events Video Library

Zones

Culture and Methodologies Agile Career Development Methodologies Team Management
Data Engineering AI/ML Big Data Data Databases IoT
Software Design and Architecture Cloud Architecture Containers Integration Microservices Performance Security
Coding Frameworks Java JavaScript Languages Tools
Testing, Deployment, and Maintenance Deployment DevOps and CI/CD Maintenance Monitoring and Observability Testing, Tools, and Frameworks
Culture and Methodologies
Agile Career Development Methodologies Team Management
Data Engineering
AI/ML Big Data Data Databases IoT
Software Design and Architecture
Cloud Architecture Containers Integration Microservices Performance Security
Coding
Frameworks Java JavaScript Languages Tools
Testing, Deployment, and Maintenance
Deployment DevOps and CI/CD Maintenance Monitoring and Observability Testing, Tools, and Frameworks

How does AI transform chaos engineering from an experiment into a critical capability? Learn how to effectively operationalize the chaos.

Data quality isn't just a technical issue: It impacts an organization's compliance, operational efficiency, and customer satisfaction.

Are you a front-end or full-stack developer frustrated by front-end distractions? Learn to move forward with tooling and clear boundaries.

Developer Experience: Demand to support engineering teams has risen, and there is a shift from traditional DevOps to workflow improvements.

Related

  • Text Analysis Within a Full-Text Search Engine
  • Modern Cloud-Native Jakarta EE Frameworks: Tips, Challenges, and Trends.
  • Reactive Elasticsearch With Quarkus
  • A Systematic Approach for Java Software Upgrades

Trending

  • Exploring Reactive and Proactive Observability in the Modern Monitoring Landscape
  • Integrating Cursor and LLM for BDD Testing With Playwright MCP (Model Context Protocol)
  • Automating Sentiment Analysis Using Snowflake Cortex
  • Before You Microservice Everything, Read This
  1. DZone
  2. Data Engineering
  3. Big Data
  4. Connecting Elasticsearch Directly to your Java EE Application

Connecting Elasticsearch Directly to your Java EE Application

Elasticsearch can help the Java EE world with both NoSQL documents and a search engine. See how to join the best of these two worlds using Eclipse JNoSQL.

By 
Otavio Santana user avatar
Otavio Santana
DZone Core CORE ·
Apr. 20, 18 · Tutorial
Likes (11)
Comment
Save
Tweet
Share
30.9K Views

Join the DZone community and get the full member experience.

Join For Free

The trendy word big data comes of the 3 Vs: volume, variety, and velocity. Volume refers to the size of data, variety refers to the diverse types of data, and velocity refers to the speed of data processing. To handle persistent big data, there are NoSQL databases that write and read data faster. But with the diversity in a vast volume, a search engine is required to find information that is without significant computer power and that takes too much time. A search engine is a software system that is designed to search for information; this mechanism makes it more straightforward and clear for users get the information that they want.

This article will cover NoSQL that is both document type and search engine Elasticsearch.

Elasticsearch is a NoSQL document type and a search engine based on Lucene. It provides a distributed, multi-tenant-capable full-text search engine with an HTTP web interface and schema-free JSON documents. Elasticsearch is developed in Java and is released as open-source under the terms of the Apache License. Elasticsearch is the most popular enterprise search engine followed by Apache Solr, which is also based on Lucene. It is a near-real-time search platform. What this means is there is a slight latency (normally one second) from the time you index a document until the time it becomes searchable.

Steps in a Search Engine

In Elasticsearch, the progress of a search engine is based on the analyzer, which is a package containing three lower-level building blocks: character filters, tokenizers, and token filters. Through the Elasticstatic documentation, the definitions are:

  • A character filter receives the original text as a stream of characters and can transform the stream by adding, removing, or changing characters. For instance, a character filter could be used to convert Hindu-Arabic numerals into their Arabic-Latin equivalents or to strip HTML elements from the stream.

  • A tokenizer receives a stream of characters, breaks it up into individual tokens (usually individual words), and outputs a stream of tokens. For instance, a whitespace tokenizer breaks the text into tokens whenever it sees any whitespace. It would convert the text "Quick brown fox!" into the terms [Quick, brown, fox!].

  • A token filter receives the token stream and may add, remove, or change tokens. For example, a lowercase token filter converts all tokens to lowercase, a stop token filter removes common words (stop words) like the from the token stream, and a synonym token filter introduces synonyms into the token stream.

How to Install ElasticSearch in Docker

The first step to use ES is to install it in Docker. You can install both manually and through Docker. The easiest way is with Docker following the steps below:

  • Install Docker

  • Refer to here.

  • Run the following command:

docker run -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" docker.elastic.co/elasticsearch/elasticsearch:6.2.3

Elasticsearch and Java EE Working Together

Eclipse JNoSQL is the bridge to work between these platforms (Java EE and the search engine). An important point to remember is that Elasticsearch is also a NoSQL document type, so a developer may model the application as such. To use both the standard document behavior and the Elasticsearch API, a programmer needs to use the the Elasticsearch extension.

<dependency>
	<groupId>org.jnosql.artemis</groupId>
	<artifactId>elasticsearch-extension</artifactId>
	<version>0.0.5</version>
</dependency>

For this demo, we'll create a contacts agenda for a developer that will have a name, address, and, of course, the language that they know. An address has fields and becomes a subdocument that is a document inside a document.

@Entity("developer")
public class Developer {

 @Id
 private Long id;

 @Column
 private String name;

 @Column
 private List < String > phones;

 @Column
 private List < String > languages;

 @Column
 private Address address;
}

@Embeddable
public class Address {

 @Column
 private String street;

 @Column
 private String city;

 @Column
 private Integer number;

}

With the model defined, let's set the mapping. Mapping is the process of determining how a document and the fields it contains are stored and indexed. For this example, the fields are usually the type keyword and those are only searchable by their exact value. Also, there is the languages field that we defined as text with a custom analyzer. This custom analyzer, the whitespace_analyzer, has one tokenizer, whitespace, and three filters (standard, lowercase, and asciifolding).

{
  "settings": {
    "analysis": {
      "filter": {
      },
      "analyzer": {
        "whitespace_analyzer": {
          "type": "custom",
          "tokenizer": "whitespace",
          "filter": [
            "standard",
            "lowercase",
            "asciifolding"
          ]
        }
      }
    }
  },
  "mappings": {
    "developer": {
      "properties": {
        "name": {
          "type": "keyword"
        },
        "languages": {
          "type": "text",
          "analyzer": "whitespace_analyzer"
        },
        "phones": {
          "type": "keyword"
        },
        "address": {
          "properties": {
            "street": {
              "type": "text"
            },
            "city": {
              "type": "text"
            },
            "number": {
              "type": "integer"
            }
          }
        }
      }
    }
  }
}

With the API, the developer can do the basic operations of a document NoSQL database — at least, a CRUD — however, in ES, the behavior of search engine matters and is useful. That why it has an extension.

public class App {


 public static void main(String[] args) {

  Random random = new Random();
  Long id = random.nextLong();
  try (SeContainer container = SeContainerInitializer.newInstance().initialize()) {

   Address address = Address.builder()
    .withCity("Salvador")
    .withStreet("Rua Engenheiro Jose")
    .withNumber(10).build();

   Developer developer = Developer.builder().
   withPhones(Arrays.asList("85 85 343435684", "55 11 123448684"))
    .withName("Poliana Lovelace")
    .withId(id)
    .withAddress(address)
    .build();

   DocumentTemplate documentTemplate = container.select(DocumentTemplate.class).get();
   Developer saved = documentTemplate.insert(developer);
   System.out.println("Developer saved" + saved);


   DocumentQuery query = select().from("developer")
    .where("_id").eq(id).build();

   Optional < Developer > personOptional = documentTemplate.singleResult(query);
   System.out.println("Entity found: " + personOptional);

  }
 }

 private App() {}
}

From the Elasticsearch extension, the user might use the QueryBuilders, a utility class to create search queries in the database.

public class App3 {


 public static void main(String[] args) throws InterruptedException {

  try (SeContainer container = SeContainerInitializer.newInstance().initialize()) {
   Random random = new Random();
   long id = random.nextLong();

   Address address = Address.builder()
    .withCity("São Paulo")
    .withStreet("Av. nove de Julho 1854")
    .withNumber(10).build();

   Developer developer = Developer.builder().
   withPhones(Arrays.asList("85 85 343435684", "55 11 123448684"))
    .withName("Maria Lovelace")
    .withId(id)
    .withAddress(address)
    .withLanguage("Java SE")
    .withLanguage("Java EE")
    .build();

   ElasticsearchTemplate template = container.select(ElasticsearchTemplate.class).get();
   Developer saved = template.insert(developer);

   System.out.println("Developer saved" + saved);
   TimeUnit.SECONDS.sleep(2 L);

   TermQueryBuilder query = QueryBuilders.termQuery("phones", "85 85 343435684");

   List < Developer > people = template.search(query);
   System.out.println("Entity found from phone: " + people);


   people = template.search(QueryBuilders.termQuery("languages", "java"));
   System.out.println("Entity found from languages: " + people);
  }
 }

 private App3() {}
}

Conclusion

An application that has an intuitive way to find data in an enterprise application is prime, mainly when the software handles a massive and with several data kinds. Elasticsearch can help the Java EE world with both NoSQL documents and a search engine. This post covered how to join the best of these two worlds using Eclipse JNoSQL.

Elasticsearch Database Java EE application Search engine (computing) Java (programming language) Big data Document Engine Filter (software)

Opinions expressed by DZone contributors are their own.

Related

  • Text Analysis Within a Full-Text Search Engine
  • Modern Cloud-Native Jakarta EE Frameworks: Tips, Challenges, and Trends.
  • Reactive Elasticsearch With Quarkus
  • A Systematic Approach for Java Software Upgrades

Partner Resources

×

Comments

The likes didn't load as expected. Please refresh the page and try again.

ABOUT US

  • About DZone
  • Support and feedback
  • Community research
  • Sitemap

ADVERTISE

  • Advertise with DZone

CONTRIBUTE ON DZONE

  • Article Submission Guidelines
  • Become a Contributor
  • Core Program
  • Visit the Writers' Zone

LEGAL

  • Terms of Service
  • Privacy Policy

CONTACT US

  • 3343 Perimeter Hill Drive
  • Suite 100
  • Nashville, TN 37211
  • [email protected]

Let's be friends: