Red Hat Summit Red Hat SummitSupportoConsoleSviluppatoriInizia una provaContatti

Questo contenuto non è disponibile nella lingua selezionata.

Chapter 21. JsonPath

Overview
Copia collegamento

The JsonPath language provides a convenient syntax for extracting portions of a JSON message. The syntax of JSON is similar to XPath, but it is used to extract JSON objects from a JSON message, instead of acting on XML. The jsonpath DSL command can be used either as an expression or as a predicate (where an empty result gets interpreted as boolean false).

Adding the JsonPath package
Copia collegamento

To use JsonPath in your Camel routes, you need to add a dependency on camel-jsonpath to your project, as follows: 

<dependency>
  <groupId>org.apache.camel</groupId>
  <artifactId>camel-jsonpath</artifactId>
  <version>${camel-version}</version>
</dependency>
Copy to Clipboard Toggle word wrap

Java example
Copia collegamento

The following Java example shows how to use the jsonpath() DSL command to select items in a certain price range: 

from("queue:books.new")
  .choice()
    .when().jsonpath("$.store.book[?(@.price < 10)]")
      .to("jms:queue:book.cheap")
    .when().jsonpath("$.store.book[?(@.price < 30)]")
      .to("jms:queue:book.average")
    .otherwise()
      .to("jms:queue:book.expensive")
Copy to Clipboard Toggle word wrap

If the JsonPath query returns an empty set, the result is interpreted as false. In this way, you can use a JsonPath query as a predicate.

XML example
Copia collegamento

The following XML example shows how to use the jsonpath DSL element to define predicates in a route: 

<camelContext id="camel" xmlns="http://camel.apache.org/schema/spring">
  <route>
    <from uri="direct:start"/>
    <choice>
      <when>
        <jsonpath>$.store.book[?(@.price < 10)]</jsonpath>
        <to uri="mock:cheap"/>
      </when>
      <when>
        <jsonpath>$.store.book[?(@.price < 30)]</jsonpath>
        <to uri="mock:average"/>
      </when>
      <otherwise>
        <to uri="mock:expensive"/>
      </otherwise>
    </choice>
  </route>
</camelContext>
Copy to Clipboard Toggle word wrap

Easy Syntax
Copia collegamento

When you wish to define a basic predicate using jsonpath syntax it can be a bit hard to remember the syntax. For example, to find out all the cheap books, you have to write the syntax as follows: 

$.store.book[?(@.price < 20)]
Copy to Clipboard Toggle word wrap

However, what if you could just write it as: 

store.book.price < 20
Copy to Clipboard Toggle word wrap

You can also omit the path if you just want to look at nodes with a price key: 

price < 20
Copy to Clipboard Toggle word wrap

To support this, there is a EasyPredicateParser which you use to define the predicate using a basic style. That means the predicate must not start with the $ sign, and must include only one operator. The easy syntax is as follows: 

left OP right
Copy to Clipboard Toggle word wrap

You can use Camel simple language in the right operator, for example, 

store.book.price < ${header.limit}
Copy to Clipboard Toggle word wrap

Supported Message Body Types
Copia collegamento

Camel JSonPath supports message body using the following types:

Expand
TypeDescription

File

Reading from files

String

Plain strings

Map

essage body as java.util.Map type

List

Message body as java.util.List type

POJO

Optional If Jackson is on the classpath, then camel-jsonpath is able to use Jackson to read the message body as POJO and convert to java.util.Map which is supported by JSonPath. For example you can add camel-jackson as dependency to include Jackson.

InputStream

If none of the above types matches, then Camel will attempt to read the message body as an java.io.InputStream.

If a message body is of unsupported type then an exception is thrown by default, however you can configure JSonPath to suppress exceptions.

Suppress Exceptions
Copia collegamento

JsonPath will throw an exception if the path configured by the jsonpath expression is not found. The exception can be ignored by setting the SuppressExceptions option to true. For example, in the code below, adding the true option as part of the jsonpath parameters: 

from("direct:start")
    .choice()
        // use true to suppress exceptions
        .when().jsonpath("person.middlename", true)
            .to("mock:middle")
        .otherwise()
            .to("mock:other");
Copy to Clipboard Toggle word wrap

In XML DSL use the following syntax: 

<route>
  <from uri="direct:start"/>
  <choice>
    <when>
      <jsonpath suppressExceptions="true">person.middlename</jsonpath>
      <to uri="mock:middle"/>
    </when>
    <otherwise>
      <to uri="mock:other"/>
    </otherwise>
  </choice>
</route>
Copy to Clipboard Toggle word wrap

JsonPath injection
Copia collegamento

When using bean integration to invoke a bean method, you can use JsonPath to extract a value from the message and bind it to a method parameter. For example: 

// Java
public class Foo {

    @Consume(uri = "activemq:queue:books.new")
    public void doSomething(@JsonPath("$.store.book[*].author") String author, @Body String json) {
      // process the inbound message here
    }
}
Copy to Clipboard Toggle word wrap

Inline Simple Expressions
Copia collegamento

New in Camel 2.18.

Camel supports inline Simple expressions in the JsonPath expressions. The Simple language insertions must be expressed in Simple syntax as shown below: 

from("direct:start")
  .choice()
    .when().jsonpath("$.store.book[?(@.price < `${header.cheap}`)]")
      .to("mock:cheap")
    .when().jsonpath("$.store.book[?(@.price < `${header.average}`)]")
      .to("mock:average")
    .otherwise()
      .to("mock:expensive");
Copy to Clipboard Toggle word wrap

Turn off support for Simple expressions by setting the option allowSimple=false as shown below.

Java: 

// Java DSL
.when().jsonpath("$.store.book[?(@.price < 10)]", false, false)
Copy to Clipboard Toggle word wrap

XML DSL: 

// XML DSL
<jsonpath allowSimple="false">$.store.book[?(@.price &lt; 10)]</jsonpath>
Copy to Clipboard Toggle word wrap

Reference
Copia collegamento

For more details about JsonPath, see the JSonPath project page.

Torna in cima
Red Hat logoGithubredditYoutubeTwitter

Formazione

Prova, acquista e vendi

Community

Informazioni sulla documentazione di Red Hat

Aiutiamo gli utenti Red Hat a innovarsi e raggiungere i propri obiettivi con i nostri prodotti e servizi grazie a contenuti di cui possono fidarsi. Esplora i nostri ultimi aggiornamenti.

Rendiamo l’open source più inclusivo

Red Hat si impegna a sostituire il linguaggio problematico nel codice, nella documentazione e nelle proprietà web. Per maggiori dettagli, visita il Blog di Red Hat.

Informazioni su Red Hat

Forniamo soluzioni consolidate che rendono più semplice per le aziende lavorare su piattaforme e ambienti diversi, dal datacenter centrale all'edge della rete.

Theme

© 2025 Red Hat