### JsonPath Examples

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Examples of JsonPath expressions applied to a sample JSON structure.

```text
$.store.book[*].author
$..author
$.store.*
$.store..price
$..book[2]
$..book[-2]
$..book[0,1]
$..book[:2]
$..book[1:2]
$..book[-2:]
$..book[2:]
$..book[?(@.isbn)]
$.store.book[?(@.price < 10)]
$..book[?(@.price <= $['expensive'])]
$..book[?(@.author =~ /.*REES/i)]
$..*
$..book.length()
```

--------------------------------

### Implement Custom Cache Provider

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Implement a custom cache provider by extending the Cache interface. This example shows a simple HashMap-based cache.

```java
CacheProvider.setCache(new Cache() {
    //Not thread safe simple cache
    private Map<String, JsonPath> map = new HashMap<String, JsonPath>();

    @Override
    public JsonPath get (String key){
        return map.get(key);
    }

    @Override
    public void put (String key, JsonPath jsonPath){
        map.put(key, jsonPath);
    }
});
```

--------------------------------

### JsonPath Bracket Notation Example

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Demonstrates the bracket notation for accessing elements, which can be an alternative to dot notation, especially for keys with special characters or spaces.

```jsonpath
$['store']['book'][0]['title']
```

--------------------------------

### Implement Custom Predicate

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Implement the Predicate interface to define custom filtering logic. This example checks if a book item contains an 'isbn' key.

```java
Predicate booksWithISBN = new Predicate() {
    @Override
    public boolean apply(PredicateContext ctx) {
        return ctx.item(Map.class).containsKey("isbn");
    }
};

List<Map<String, Object>> books = 
        reader.read("$.store.book[?].isbn", List.class, booksWithISBN);
```

--------------------------------

### JsonPath Dot Notation Example

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Illustrates the dot notation for accessing elements within a JSON structure. The root is always represented by '$'.

```jsonpath
$.store.book[0].title
```

--------------------------------

### Combine Inline Predicates with AND/OR

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Combine multiple conditions in inline predicates using '&&' for AND and '||' for OR. This example selects fiction books with a price less than 10, or reference books with a price greater than 10.

```java
List<Map<String, Object>> books = JsonPath.parse(json)
        .read("$.store.book[?(@.price < 10 && @.category == 'fiction')]");
```

```java
List<Map<String, Object>> books = JsonPath.parse(json)
        .read("$.store.book[?(@.category == 'reference' || @.price > 10)]");
```

--------------------------------

### Filter JSON using Filter API

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Build complex filters using the Filter API with Criteria. This example selects fiction books with a price less than or equal to 10D. Note the '?' placeholder in the path.

```java
import static com.jayway.jsonpath.JsonPath.parse;
import static com.jayway.jsonpath.Criteria.where;
import static com.jayway.jsonpath.Filter.filter;
...
...

Filter cheapFictionFilter = filter(
        where("category").is("fiction").and("price").lte(10D)
);

List<Map<String, Object>> books = 
        parse(json).read("$.store.book[?()]", cheapFictionFilter);
```

--------------------------------

### Filter JSON by Price using Inline Predicate

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Use inline predicates within the path to filter elements based on conditions. This example selects books with a price less than 10.

```java
List<Map<String, Object>> books = JsonPath.parse(json)
        .read("$.store.book[?(@.price < 10)]");
```

--------------------------------

### Combine Filter Criteria with OR and AND

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Combine multiple criteria within a Filter using 'or' and 'and' methods. These examples demonstrate filtering for books where 'foo' exists OR 'bar' exists, and where 'foo' exists AND 'bar' exists.

```java
Filter fooOrBar = filter(
        where("foo").exists(true)).or(where("bar").exists(true)
);

Filter fooAndBar = filter(
        where("foo").exists(true)).and(where("bar").exists(true)
);
```

--------------------------------

### Set Value in JSON

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Use the 'set' method to modify a value at a specific path within the JSON. This example changes the author of the first book to 'Paul'.

```java
String newJson = JsonPath.parse(json).set("$['store']['book'][0]['author']", "Paul").jsonString();
```

--------------------------------

### JsonPath Filter Expression Example

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Shows how to use a filter expression `[?(<expression>)]` to select elements from an array based on a condition. The `@` symbol refers to the current node.

```jsonpath
[?(@.age > 18)]
```

--------------------------------

### Negate Inline Predicate

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Use the '!' operator to negate an inline predicate. This example selects books that do not meet the condition of being fiction with a price less than 10.

```java
List<Map<String, Object>> books = JsonPath.parse(json)
        .read("$.store.book[?(!(@.price < 10 && @.category == 'fiction'))]");
```

--------------------------------

### JsonPath Filter with String Comparison (Double Quotes)

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Example of a filter expression comparing a string field to a value using double quotes for the string literal.

```jsonpath
[?(@.color == "blue")]
```

--------------------------------

### JsonPath Filter with String Comparison (Single Quotes)

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Example of a filter expression comparing a string field to a value using single quotes for the string literal.

```jsonpath
[?(@.color == 'blue')]
```

--------------------------------

### Importing JsonPath Matchers

Source: https://github.com/json-path/jsonpath/blob/master/json-path-assert/README.md

Statically import the library's entry point for using JsonPath matchers in your assertions.

```java
import static com.jayway.jsonpath.matchers.JsonPathMatchers.*;
```

--------------------------------

### Configure Default JsonProvider

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Set default JsonProvider and MappingProvider for JsonPath. This should only be done during application initialization.

```java
Configuration.setDefaults(new Configuration.Defaults() {

    private final JsonProvider jsonProvider = new JacksonJsonProvider();
    private final MappingProvider mappingProvider = new JacksonMappingProvider();

    @Override
    public JsonProvider jsonProvider () {
        return jsonProvider;
    }

    @Override
    public MappingProvider mappingProvider () {
        return mappingProvider;
    }

    @Override
    public Set<Option> options () {
        return EnumSet.noneOf(Option.class);
    }
});
```

--------------------------------

### Mapping JSON to POJO

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Shows how to map a JSON object directly into a Plain Old Java Object (POJO) using JsonPath with configured mapping providers.

```java
Book book = JsonPath.parse(json).read("$.store.book[0]", Book.class);
```

--------------------------------

### Retrieve Path List using Configuration Option

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Configure JsonPath to return a list of paths instead of values using Option.AS_PATH_LIST. This is useful when you need to know the location of the found elements.

```java
Configuration conf = Configuration.builder()
        .options(Option.AS_PATH_LIST).build();

List<String> pathList = using(conf).parse(json).read("$..author");

assertThat(pathList).

containsExactly(
    "$['store']['book'][0]['author']",
            "$['store']['book'][1]['author']",
            "$['store']['book'][2]['author']",
            "$['store']['book'][3]['author']");
```

--------------------------------

### Verifying JSON Path List Size and Content

Source: https://github.com/json-path/jsonpath/blob/master/json-path-assert/README.md

Use `hasJsonPath()` with matchers like `hasSize()` and `hasItem()` to assert properties of lists returned by JSON paths.

```java
assertThat(json, hasJsonPath("$.store.book[*].author", hasSize(4)));
assertThat(json, hasJsonPath("$.store.book[*].author", hasItem("Evelyn Waugh")));
```

--------------------------------

### Asserting Non-Empty Lists with Indefinite Paths

Source: https://github.com/json-path/jsonpath/blob/master/json-path-assert/README.md

When using indefinite paths (wildcards), explicitly check for list size if you need to ensure the list is not empty.

```java
// Given a JSON like this:
// {
//   "items": []
// }

// Both of these statements will succeed(!)
assertThat(json, hasJsonPath("$.items[*]"));
assertThat(json, hasJsonPath("$.items[*].name"));

// Make sure to explicitly check for size if you want to catch this scenario as a failure
assertThat(json, hasJsonPath("$.items[* PREDICATE ]", hasSize(greaterThan(0))));

// However, checking for the existence of an array works fine, as is
assertThat(json, hasJsonPath("$.not_here[*]"));
```

--------------------------------

### Parse JSON and Read Author

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Demonstrates parsing a JSON string into a document and reading specific author fields using JsonPath.

```java
Object document = Configuration.defaultConfiguration().jsonProvider().parse(json);

String author0 = JsonPath.read(document, "$.store.book[0].author");
String author1 = JsonPath.read(document, "$.store.book[1].author");
```

--------------------------------

### Initialize JakartaJsonProvider with Mutability

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Initialize JakartaJsonProvider to enable mutable Json arrays and objects, respecting the JsonPath API while adhering to the Json-P specification.

```java
JsonProvider jsonProvider = new JakartaJsonProvider(true);
```

```java
JsonProvider jsonProvider = new JakartaJsonProvider();
```

--------------------------------

### Require Properties with REQUIRE_PROPERTIES Option

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Use Option.REQUIRE_PROPERTIES to enforce that properties defined in an indefinite path must exist. If a property is missing, a PathNotFoundException is thrown. This contrasts with the default behavior where missing properties are ignored.

```java
Configuration conf = Configuration.defaultConfiguration();

//Works fine
List<String> genders = JsonPath.using(conf).parse(json).read("$[*]['gender']");

Configuration conf2 = conf.addOptions(Option.REQUIRE_PROPERTIES);

//PathNotFoundException thrown
List<String> genders = JsonPath.using(conf2).parse(json).read("$[*]['gender']");
```

--------------------------------

### Handle Missing Leaves with DEFAULT_PATH_LEAF_TO_NULL

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Enable Option.DEFAULT_PATH_LEAF_TO_NULL to return null for missing JSON leaves instead of throwing a PathNotFoundException. This is useful when dealing with potentially incomplete JSON structures.

```javascript
[
   {
      "name" : "john",
      "gender" : "male"
   },
   {
      "name" : "ben"
   }
]
```

```java
Configuration conf = Configuration.defaultConfiguration();

//Works fine
String gender0 = JsonPath.using(conf).parse(json).read("$[0]['gender']");
//PathNotFoundException thrown
String gender1 = JsonPath.using(conf).parse(json).read("$[1]['gender']");

Configuration conf2 = conf.addOptions(Option.DEFAULT_PATH_LEAF_TO_NULL);

//Works fine
String gender0 = JsonPath.using(conf2).parse(json).read("$[0]['gender']");
//Works fine (null is returned)
String gender1 = JsonPath.using(conf2).parse(json).read("$[1]['gender']");
```

--------------------------------

### Using TypeRef for Generic Types

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Explains how to use TypeRef to obtain full generic type information when reading JSON arrays or complex generic structures.

```java
TypeRef<List<String>> typeRef = new TypeRef<List<String>>() {
};

List<String> titles = JsonPath.parse(JSON_DOCUMENT).read("$.store.book[*].title", typeRef);
```

--------------------------------

### Maven Dependency for json-path-assert

Source: https://github.com/json-path/jsonpath/blob/master/json-path-assert/README.md

Add this dependency to your Maven POM file to include the json-path-assert library in your project.

```xml
<dependency>
    <groupId>com.jayway.jsonpath</groupId>
    <artifactId>json-path-assert</artifactId>
    <version>2.6.0</version>
</dependency>
```

--------------------------------

### Matching on Pre-compiled JSON Paths

Source: https://github.com/json-path/jsonpath/blob/master/json-path-assert/README.md

Compile complex JSON path expressions, including filters, and use them with `withJsonPath()` for assertions.

```java
Filter cheapFictionFilter = filter(
    where("category").is("fiction").and("price").lte(10D));
JsonPath cheapFiction = JsonPath.compile("$.store.book[? PREDICATE ]", cheapFictionFilter);
String json = ...;
assertThat(json, isJson(withJsonPath(cheapFiction)));
```

--------------------------------

### Typed Matchers for JSON Representations

Source: https://github.com/json-path/jsonpath/blob/master/json-path-assert/README.md

Use specific matchers like `isJsonString()` and `isJsonFile()` when you know the expected JSON representation.

```java
String json = ...
assertThat(json, isJsonString(withJsonPath("$..author")));

File json = ...
assertThat(json, isJsonFile(withJsonPath("$..author")));
```

--------------------------------

### Parse JSON Once with JsonPath

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Shows how to parse JSON once for multiple read operations to improve performance. This avoids re-parsing the document for subsequent reads.

```java
String json = "...";
```

--------------------------------

### Read JSON with JsonPath

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Demonstrates reading JSON data using the static read API of JsonPath. This method parses the JSON document on each call.

```java
String json = "...";

List<String> authors = JsonPath.read(json, "$.store.book[*].author");
```

--------------------------------

### Always Return List with ALWAYS_RETURN_LIST Option

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Use Option.ALWAYS_RETURN_LIST to ensure that JsonPath always returns a List, even when the path is definite and would normally return a single item. This helps prevent ClassCastExceptions when the return type is expected to be a list.

```java
Configuration conf = Configuration.defaultConfiguration();

//ClassCastException thrown
List<String> genders0 = JsonPath.using(conf).parse(json).read("$[0]['gender']");

Configuration conf2 = conf.addOptions(Option.ALWAYS_RETURN_LIST);

//Works fine
List<String> genders0 = JsonPath.using(conf2).parse(json).read("$[0]['gender']");
```

--------------------------------

### Assertions with Null JSON Values

Source: https://github.com/json-path/jsonpath/blob/master/json-path-assert/README.md

Asserting paths that resolve to `null` is supported. Use `nullValue()` to explicitly check for null.

```java
// Given a JSON like this:
// { "none": null }

// All of these will succeed, since '$.none' is a valid path
assertThat(json, hasJsonPath("$.none"));
assertThat(json, isJson(withJsonPath("$.none")));
assertThat(json, hasJsonPath("$.none", nullValue()));
assertThat(json, isJson(withJsonPath("$.none", nullValue())));

// But all of these will fail, since '$.not_there' is not a valid path
assertThat(json, hasJsonPath("$.not_there"));
assertThat(json, isJson(withJsonPath("$.not_there")));
assertThat(json, hasJsonPath("$.not_there", anything()));
assertThat(json, isJson(withJsonPath("$.not_there", anything())));
```

--------------------------------

### JSON Representations for Assertion

Source: https://github.com/json-path/jsonpath/blob/master/json-path-assert/README.md

The library can assert on JSON represented as a String, File, or an already parsed JSON object. Ensure the JSON is properly parsed before assertion.

```java
String json = ...;

File json = ...;

Object json = Configuration.defaultConfiguration().jsonProvider().parse(content);
```

--------------------------------

### Verifying JSON Validity

Source: https://github.com/json-path/jsonpath/blob/master/json-path-assert/README.md

Use the `isJson()` matcher to verify if the provided input is a valid JSON structure.

```java
assertThat(json, isJson());
```

--------------------------------

### JsonPath Operators

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Table of available operators for filtering and querying JSON data with JsonPath.

```text
==       left is equal to right (note that 1 is not equal to '1')
!=       left is not equal to right
<        left is less than right
<=       left is less or equal to right
>        left is greater than right
>=       left is greater than or equal to right
=~       left matches regular expression  [?(@.name =~ /foo.*?/i)]
in       left exists in right [?(@.size in ['S', 'M'])]
nin      left does not exists in right
subsetof left is a subset of right [?(@.sizes subsetof ['S', 'M', 'L'])]
anyof    left has an intersection with right [?(@.sizes anyof ['M', 'L'])]
noneof   left has no intersection with right [?(@.sizes noneof ['M', 'L'])]
size     size of left (array or string) should match right
empty    left (array or string) should be empty
```

--------------------------------

### Verifying JSON Path Evaluation

Source: https://github.com/json-path/jsonpath/blob/master/json-path-assert/README.md

Assert the evaluated value of a JSON path against an expected value using `hasJsonPath()` with specific matchers like `equalTo()`.

```java
assertThat(json, hasJsonPath("$.message", equalTo("Hi there")));
assertThat(json, hasJsonPath("$.quantity", equalTo(5)));
assertThat(json, hasJsonPath("$.price", equalTo(34.56)));
```

--------------------------------

### Verifying JSON Path Existence

Source: https://github.com/json-path/jsonpath/blob/master/json-path-assert/README.md

Assert whether a specific JSON path exists or does not exist within the JSON structure using `hasJsonPath()` and `hasNoJsonPath()`.

```java
assertThat(json, hasJsonPath("$.message"));
assertThat(json, hasNoJsonPath("$.message"));
```

--------------------------------

### Type Casting in JsonPath

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Illustrates how JsonPath attempts to cast results to the expected type. A ClassCastException may occur if the cast is not possible.

```java
//Will throw an java.lang.ClassCastException    
List<String> list = JsonPath.parse(json).read("$.store.book[0].author");
```

```java
//Works fine
String author = JsonPath.parse(json).read("$.store.book[0].author");
```

--------------------------------

### Combining JSON Path Matchers

Source: https://github.com/json-path/jsonpath/blob/master/json-path-assert/README.md

Combine multiple JSON path assertions into a single statement for greater expressiveness and efficiency. The JSON is parsed only once.

```java
assertThat(json, isJson(withoutJsonPath("...")));
assertThat(json, isJson(withJsonPath("", equalTo(3))));

assertThat(json, isJson(allOf(
    withJsonPath("$.store.name", equalTo("Little Shop")),
    withoutJsonPath("$.expensive"),
    withJsonPath("$..title", hasSize(4))))));
```

--------------------------------

### Suppress Exceptions with SUPPRESS_EXCEPTIONS Option

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Enable Option.SUPPRESS_EXCEPTIONS to prevent exceptions from propagating during path evaluation. The return value depends on whether Option.ALWAYS_RETURN_LIST is also present (empty list or null).

```java
/*
 * If option `ALWAYS_RETURN_LIST` is present an empty list will be returned
 * If option `ALWAYS_RETURN_LIST` is **NOT** present null returned
 */
```

--------------------------------

### Fluent API for Reading JSON

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Utilizes the fluent API of JsonPath for parsing JSON and extracting data, including filtering based on conditions.

```java
String json = "...";

ReadContext ctx = JsonPath.parse(json);

List<String> authorsOfBooksWithISBN = ctx.read("$.store.book[?(@.isbn)].author");
```

```java
List<Map<String, Object>> expensiveBooks = JsonPath
        .using(configuration)
        .parse(json)
        .read("$.store.book[?(@.price > 10)]", List.class);
```

--------------------------------

### Mapping JSON to Date

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Demonstrates mapping a JSON field containing a long value to a Java Date object using JsonPath.

```java
String json = "{\"date_as_long\" : 1411455611975}";

Date date = JsonPath.parse(json).read("$['date_as_long']", Date.class);
```

--------------------------------

### Add JsonPath Dependency to Maven POM

Source: https://github.com/json-path/jsonpath/blob/master/README.md

Include this dependency in your Maven project's POM file to use Jayway JsonPath. Version 3.0.0 requires Java 17.

```xml
<dependency>
    <groupId>com.jayway.jsonpath</groupId>
    <artifactId>json-path</artifactId>
    <version>3.0.0</version>
</dependency>
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.