Data se imperative example with Oracle DB and UCP DataSource.

Signed-off-by: Tomáš Kraus <[email protected]>

Author: Tomáš Kraus

examples/data/mysql/README.md

@@ -53,27 +53,27 @@ java -jar target/helidon-examples-data-mysql.jar
 
 The application provides `http://localhost:8080/pokemon` endpoint.
 
-**List all pokemons:**
+**List all pokémons:**
 ```shell
 curl http://localhost:8080/pokemon/all
 ```
 
-**List all normal type pokemons:**
+**List all normal type pokémons:**
 ```shell
 curl http://localhost:8080/pokemon/type/Normal
 ```
 
-**Retrieve a pokemon by name (`Meowth`):**
+**Retrieve a pokémon by name (`Meowth`):**
 ```shell
 curl http://localhost:8080/pokemon/get/Meowth
 ```
 
-**Insert new pokemon:**
+**Insert new pokémon:**
 ```shell
 curl -i -X POST -H 'Content-type: application/json' -d '{"name":"Charmander","type":"Fire"}' http://localhost:8080/pokemon
 ```
 
-**Delete existing pokemon by ID (`20`):**
+**Delete existing pokémon by ID (`20`):**
 ```shell
 curl -i -X DELETE http://localhost:8080/pokemon/20
 ```

examples/data/mysql/pom.xml

@@ -59,8 +59,7 @@
         </dependency>
         <dependency>
             <groupId>io.helidon.http.media</groupId>
-            <artifactId>helidon-http-media-jsonb</artifactId>
-            <scope>runtime</scope>
+            <artifactId>helidon-http-media-jsonp</artifactId>
         </dependency>
         <dependency>
             <groupId>io.helidon.logging</groupId>

examples/data/mysql/src/main/java/io/helidon/examples/data/mysql/Main.java

@@ -17,7 +17,6 @@
 
 import io.helidon.logging.common.LogConfig;
 import io.helidon.webserver.WebServer;
-import io.helidon.webserver.http.HttpRouting;
 
 /**
  * The Main class serves as the entry point for the application.
@@ -35,30 +34,13 @@ private Main() {
      * @param args command-line arguments passed to the application
      */
     public static void main(String... args) {
-
-        // load logging configuration
         LogConfig.configureRuntime();
-
-        // configure and start the HTTP server
         WebServer webServer = WebServer.builder()
                 .port(8080)
-                .routing(Main::routing)
+                .routing(routing -> routing.register("/pokemon", new PokemonService()))
                 .build();
         webServer.start();
         System.out.println("Server started on: http://localhost:" + webServer.port());
-
-    }
-
-    /**
-     * Configures HTTP routing for the application.
-     * Registers HTTP services with their respective endpoint prefixes.
-     *
-     * @param routing HTTP routing builder to configure routes for this service
-     */
-    private static void routing(HttpRouting.Builder routing) {
-        // register HTTP service with endpoint prefix
-        routing.register("/pokemon", new PokemonService());
-
     }
 
 }

examples/data/mysql/src/main/java/io/helidon/examples/data/mysql/PokemonDto.java

@@ -15,33 +15,43 @@
  */
 package io.helidon.examples.data.mysql;
 
-import java.util.List;
 import java.util.Optional;
+import java.util.stream.Stream;
 
 import io.helidon.data.Data;
 
+/**
+ * {@link Pokemon} entity data repository interface.
+ * <p>
+ * {@code PokemonRepository} interface acts as a data access layer, encapsulating the logic for interacting
+ * with the {@link Pokemon} entity data, and also provides basic CRUD (Create, Read, Update, Delete) operations
+ * for the {@link Pokemon} entity.
+ *
+ * @see Data.CrudRepository
+ * @see Pokemon
+ */
 @Data.Repository
 public interface PokemonRepository extends Data.CrudRepository<Pokemon, Integer> {
 
     /**
-     * Retrieves a list of {@link Pokemon} entities ordered by its {@code name}.
+     * Retrieves a stream of {@link Pokemon} entities ordered by its {@code name}.
      * <p>
-     * Query defined by method name: return list of {@link Pokemon} entities ordered by {@code name} property.
+     * Query defined by method name: return stream of {@link Pokemon} entities ordered by {@code name} property.
      *
-     * @return a list of {@link Pokemon} entities
+     * @return a stream of {@link Pokemon} entities
      */
-    List<Pokemon> listOrderByName();
+    Stream<Pokemon> streamOrderByName();
 
     /**
-     * Retrieves a list of {@link Pokemon} entities associated with a specific {@link Type} name.
+     * Retrieves a stream of {@link Pokemon} entities associated with a specific {@link Type} name.
      * <p>
-     * Query defined by method name: return unordered list of {@link Pokemon} entities with {@code breed.name}
-     * property matching the {@code breedName} method argument.
+     * Query defined by method name: return unordered stream of {@link Pokemon} entities with {@code type.name}
+     * property matching the {@code typeName} method argument.
      *
-     * @param breedName the name of the {@link Type}
-     * @return a list of {@link Pokemon} entities with the specified breed name
+     * @param typeName the name of the {@link Type}
+     * @return a stream of {@link Pokemon} entities with the specified type name
      */
-    List<Pokemon> listByType_Name(String breedName);
+    Stream<Pokemon> streamByType_Name(String typeName);
 
     /**
      * Retrieves a {@link Pokemon} entity by its name.

examples/data/mysql/src/main/java/io/helidon/examples/data/mysql/PokemonRepository.java

@@ -15,6 +15,8 @@
  */
 package io.helidon.examples.data.mysql;
 
+import java.util.stream.Collector;
+
 import io.helidon.http.BadRequestException;
 import io.helidon.service.registry.Services;
 import io.helidon.transaction.Tx;
@@ -24,90 +26,81 @@
 import io.helidon.webserver.http.ServerRequest;
 import io.helidon.webserver.http.ServerResponse;
 
+import jakarta.json.Json;
+import jakarta.json.JsonArrayBuilder;
+import jakarta.json.JsonObject;
+
 class PokemonService implements HttpService {
 
-    // Helidon Data repository interface providing Pokemon entity operations.
     private final PokemonRepository pokemonRepository = Services.get(PokemonRepository.class);
-    // Helidon Data repository interface providing Pokemon entity operations.
     private final TypeRepository typeRepository = Services.get(TypeRepository.class);
 
-    // Pokemon endpoint routing rules
     @Override
     public void routing(HttpRules rules) {
         rules.get("/all", this::all)
                 .get("/type/{name}", this::type)
                 .get("/get/{name}", this::pokemon)
-                .post("/", Handler.create(PokemonDto.class, this::insert))
+                .post("/", Handler.create(JsonObject.class, this::insert))
                 .delete("/{id}", this::delete);
     }
 
-    /**
-     * Handles the {@code GET /all} request and returns a list of all {@link Pokemon} entities.
-     *
-     * @param request  the server request
-     * @param response the server response
-     */
     private void all(ServerRequest request, ServerResponse response) {
-        response.send(pokemonRepository.listOrderByName());
+        response.send(pokemonRepository.streamOrderByName()
+                              .map(pokemon -> Json.createObjectBuilder()
+                                      .add("id", pokemon.getId())
+                                      .add("name", pokemon.getName())
+                                      .add("type", pokemon.getType().getName())
+                                      .build())
+                              .collect(Collector.of(Json::createArrayBuilder,
+                                                    JsonArrayBuilder::add,
+                                                    JsonArrayBuilder::add,
+                                                    JsonArrayBuilder::build)));
     }
 
-    /**
-     * Handles the {@code GET /type/{name}} request and returns a list of {@link Pokemon} entities
-     * associated with a specific breed name.
-     *
-     * @param request  the server request
-     * @param response the server response
-     */
     private void type(ServerRequest request, ServerResponse response) {
         String name = request.path().pathParameters().get("name");
-        response.send(pokemonRepository.listByType_Name(name));
-    }
+        response.send(pokemonRepository.streamByType_Name(name)
+                              .map(pokemon -> Json.createObjectBuilder()
+                                      .add("id", pokemon.getId())
+                                      .add("name", pokemon.getName())
+                                      .add("type", pokemon.getType().getName())
+                                      .build())
+                              .collect(Collector.of(Json::createArrayBuilder,
+                                                    JsonArrayBuilder::add,
+                                                    JsonArrayBuilder::add,
+                                                    JsonArrayBuilder::build)));    }
 
-    /**
-     * Handles the {@code GET /get/{name}} request and returns a {@link Pokemon} entity by its name.
-     *
-     * @param request  the server request
-     * @param response the server response
-     */
     private void pokemon(ServerRequest request, ServerResponse response) {
         String name = request.path().pathParameters().get("name");
-        response.send(pokemonRepository.findByName(name));
+        pokemonRepository.findByName(name)
+                .ifPresentOrElse(
+                        pokemon -> response.send(Json.createObjectBuilder()
+                                                         .add("id", pokemon.getId())
+                                                         .add("name", pokemon.getName())
+                                                         .add("type", pokemon.getType().getName())
+                                                         .build()),
+                        () -> response.send(JsonObject.EMPTY_JSON_OBJECT));
     }
 
-    /**
-     * Handles the {@code POST /} request and inserts a new {@link Pokemon} entity.
-     * <p>
-     * Pokémon entity content is supplied as JSON object and translated to {@link PokemonDto} class by HTTP
-     * request processing layer.
-     * Pokémon type record must already exist. Pokémon entity must not exist in the database.
-     *
-     * @param pokemonDto the pokémon to insert into the database
-     * @param response   the server response
-     */
-    private void insert(PokemonDto pokemonDto, ServerResponse response) {
-        // Pokemon data modification task is executed as single database transaction
-        response.send(Tx.transaction(() -> {
-            // Retrieve Type entity for provided name
-            Type type = typeRepository.getByName(pokemonDto.type());
-            // Prepare and insert new Pokemon entity into the database
-            Pokemon pokemonEntity = new Pokemon(pokemonDto.name(), type);
+    private void insert(JsonObject pokemonJson, ServerResponse response) {
+        Pokemon pokemon = Tx.transaction(() -> {
+            Type type = typeRepository.getByName(pokemonJson.getString("type"));
+            Pokemon pokemonEntity = new Pokemon(pokemonJson.getString("name"), type);
             return pokemonRepository.insert(pokemonEntity);
-        }));
+        });
+        response.send(Json.createObjectBuilder()
+                              .add("id", pokemon.getId())
+                              .add("name", pokemon.getName())
+                              .add("type", pokemon.getType().getName())
+                              .build());
     }
 
-    /**
-     * Handles the {@code DELETE /{id}} request and deletes a {@link Pokemon} entity by its ID.
-     *
-     * @param request  the server request
-     * @param response the server response
-     */
     private void delete(ServerRequest request, ServerResponse response) {
         int id = request.path()
                 .pathParameters()
                 .first("id").map(Integer::parseInt)
                 .orElseThrow(() -> new BadRequestException("No pokémon id"));
-        // Rely on internal transaction handling for this simple data modification task
-        response.send(new DmlResult(pokemonRepository.deleteById(id), "DELETE"));
+        response.send("Deleted: " + pokemonRepository.deleteById(id) + " values");
     }
 
 }

examples/data/mysql/src/main/java/io/helidon/examples/data/mysql/PokemonService.java

@@ -1,9 +1,33 @@
+/*
+ * Copyright (c) 2025 Oracle and/or its affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package io.helidon.examples.data.mysql;
 
 import io.helidon.data.Data;
 
+/**
+ * {@link Type} entity data repository interface.
+ * <p>
+ * {@code TypeRepository} interface acts as a data access layer, encapsulating the logic for interacting
+ * with the {@link Type} entity data and provides user defined operations for the {@link Type} entity.
+ *
+ * @see Data.GenericRepository
+ * @see Type
+ */
 @Data.Repository
-public interface TypeRepository extends Data.GenericRepository <Type, Integer>{
+public interface TypeRepository extends Data.GenericRepository <Type, Integer> {
 
     /**
      * Retrieves a {@link Type} entity by its name.