moduł klient-rest

Wielomodulowy/pom.xml

@@ -17,5 +17,6 @@
 		<module>wielomodulowy-model</module>
 		<module>wielomodulowy-baza</module>
 		<module>wielomodulowy-rest</module>
+		<module>wielomodulowy-klient_rest</module>
 	</modules>
 </project>

Wielomodulowy/wielomodulowy-klient_rest/.gitignore

+/wynik*.*

Wielomodulowy/wielomodulowy-klient_rest/pom.xml

+<project xmlns="http://maven.apache.org/POM/4.0.0"
+	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
+	<modelVersion>4.0.0</modelVersion>
+	<parent>
+		<groupId>pl.alx.kjava</groupId>
+		<artifactId>Wielomodulowy</artifactId>
+		<version>1.0</version>
+	</parent>
+	<artifactId>wielomodulowy-klient_rest</artifactId>
+	
+	<properties>
+		<resteasy.version>6.2.6.Final</resteasy.version>
+	</properties>
+
+	<dependencies>
+		<dependency>
+			<groupId>${project.groupId}</groupId>
+			<artifactId>wielomodulowy-model</artifactId>
+			<version>${project.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.eclipse.parsson</groupId>
+			<artifactId>parsson</artifactId>
+			<version>1.1.4</version>
+		</dependency>
+		<dependency>
+			<groupId>org.jboss.resteasy</groupId>
+			<artifactId>resteasy-client</artifactId>
+			<version>${resteasy.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.jboss.resteasy</groupId>
+			<artifactId>resteasy-jaxb-provider</artifactId>
+			<version>${resteasy.version}</version>
+		</dependency>
+		<dependency>
+			<groupId>org.jboss.resteasy</groupId>
+			<artifactId>resteasy-jackson2-provider</artifactId>
+			<version>${resteasy.version}</version>
+		</dependency>
+	</dependencies>
+</project>
\ No newline at end of file

Wielomodulowy/wielomodulowy-klient_rest/src/main/java/rest_klient/Klient01_URL.java

+package rest_klient;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+
+public class Klient01_URL {
+
+	public static void main(String[] args) {
+		// Najprostszy sposób w Javie, aby pobrać dane z adresu URL, to użyć klasy URL.
+		try {
+			URL url = new URL("http://localhost:8080/PC35-RestSerwer/products.json");
+			System.out.println("Odczytuję dane...");
+			try (InputStream input = url.openStream()) {
+				// teraz z inputa możemy czytać ciąg bajtów
+				// ja przerzucę bajty czytane z sieci bezpośrednio do System.out
+				// (w przypadku obcego serwisu może być to niebezpieczne)
+				input.transferTo(System.out);
+			}
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+}

Wielomodulowy/wielomodulowy-klient_rest/src/main/java/rest_klient/Klient02_URL_JSON.java

+package rest_klient;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+
+import jakarta.json.Json;
+import jakarta.json.JsonArray;
+import jakarta.json.JsonReader;
+import jakarta.json.JsonValue;
+
+public class Klient02_URL_JSON {
+
+	public static void main(String[] args) {
+		try {
+			URL url = new URL(Ustawienia.ADRES_USLUGI + "/products.json");
+			try(InputStream inputStream = url.openStream();
+				JsonReader reader = Json.createReader(inputStream)) {
+				JsonArray array = reader.readArray();
+				// System.out.println(array);
+				for(JsonValue jsonValue : array) {
+					//System.out.println(jsonValue);
+					System.out.println(jsonValue.asJsonObject().getString("productName"));
+					System.out.println("    opis: " + jsonValue.asJsonObject().getString("description", ""));
+					System.out.println("    cena: " + jsonValue.asJsonObject().getJsonNumber("price").bigDecimalValue());
+				}
+			}
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+	}
+
+}

Wielomodulowy/wielomodulowy-klient_rest/src/main/java/rest_klient/Klient03_HttpClient.java

+package rest_klient;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodyHandlers;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+
+public class Klient03_HttpClient {
+    /* W Java 11 pojawiło się rozwiązanie "HttpClient", które umożliwia komunikację HTTP z dużą kontrolą nad szczegółami.
+     * Wysyłając zapytanie, od razu trzeba podać odpowiedni "BodyHandler",
+     * który pozwoli nam odczytać treść odpowiedzi we właściwy dla nas sposób.
+     * 
+     * W tej wersji wynik jest zapisywany do pliku.
+     */
+
+    public static void main(String[] args) {
+        HttpClient httpClient = HttpClient.newHttpClient();
+        try {
+            URI uri = new URI(Ustawienia.ADRES_USLUGI + "/products.json");
+            HttpRequest request = HttpRequest.newBuilder(uri).build();
+            HttpResponse<Path> response = httpClient.send(request, BodyHandlers.ofFile(Paths.get("wynik03.json")));
+            System.out.println("response " + response);
+            System.out.println("status: " + response.statusCode());
+            System.out.println("Content-Type: " + response.headers().firstValue("Content-Type").orElse("BRAK"));
+            System.out.println("OK, zapisany plik: " + response.body());
+        } catch (URISyntaxException | IOException | InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

Wielomodulowy/wielomodulowy-klient_rest/src/main/java/rest_klient/Klient04_HttpClient_String.java

+package rest_klient;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodyHandlers;
+
+public class Klient04_HttpClient_String {
+
+    public static void main(String[] args) {
+        HttpClient httpClient = HttpClient.newHttpClient();
+        try {
+            URI uri = new URI(Ustawienia.ADRES_USLUGI + "/products.json");
+            HttpRequest request = HttpRequest.newBuilder(uri).build();
+            // Body z odpowiedzi pobierzemy jako obiekt String z całą treścią
+            HttpResponse<String> response = httpClient.send(request, BodyHandlers.ofString());
+            System.out.println("response " + response);
+            System.out.println("status: " + response.statusCode());
+            System.out.println("Content-Type: " + response.headers().firstValue("Content-Type").orElse("BRAK"));
+            System.out.println("Treść odpowiedzi:\n" + response.body()); // tutaj
+        } catch (URISyntaxException | IOException | InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

Wielomodulowy/wielomodulowy-klient_rest/src/main/java/rest_klient/Klient05_HttpClient_Accept.java

+package rest_klient;
+
+import java.io.IOException;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodyHandlers;
+
+public class Klient05_HttpClient_Accept {
+
+    public static void main(String[] args) {
+        HttpClient httpClient = HttpClient.newHttpClient();
+        try {
+            URI uri = new URI(Ustawienia.ADRES_USLUGI + "/products");
+            // W tej wersji do zapytania dodajemy nagłówek Accept
+            HttpRequest request = HttpRequest.newBuilder(uri)
+            		.header("Accept", "text/plain")
+            		.build();
+            HttpResponse<String> response = httpClient.send(request, BodyHandlers.ofString());
+            System.out.println("response " + response);
+            System.out.println("status: " + response.statusCode());
+            System.out.println("Content-Type: " + response.headers().firstValue("Content-Type").orElse("BRAK"));
+            System.out.println("Treść odpowiedzi:\n" + response.body());
+        } catch (URISyntaxException | IOException | InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

Wielomodulowy/wielomodulowy-klient_rest/src/main/java/rest_klient/Klient06_HttpClient_JSON.java

+package rest_klient;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.math.BigDecimal;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodyHandlers;
+
+import jakarta.json.Json;
+import jakarta.json.JsonObject;
+import jakarta.json.JsonReader;
+
+public class Klient06_HttpClient_JSON {
+	/* W tej wersji używamy technologii Jakarta JSON P.
+	 * 
+	 * Widzimy drzewo danych jsonowych i jego elementytakie jak JsonObject, JsonArray, ...
+	 * Mamy dostęp do poszczególnych pól.
+	 */
+
+    public static void main(String[] args) {
+        HttpClient httpClient = HttpClient.newHttpClient();
+        try {
+            URI uri = new URI(Ustawienia.ADRES_USLUGI + "/products/1");
+            HttpRequest request = HttpRequest.newBuilder(uri)
+            		.header("Accept", "application/json")
+            		.build();
+            HttpResponse<InputStream> response = httpClient.send(request, BodyHandlers.ofInputStream());
+            System.out.println("response " + response);
+            System.out.println("status: " + response.statusCode());
+            System.out.println("Content-Type: " + response.headers().firstValue("Content-Type").orElse("BRAK"));
+            
+            JsonReader reader = Json.createReader(response.body());
+            JsonObject product = reader.readObject();
+            System.out.println("Pobrany obiekt jsonowy: " + product);
+            String nazwa = product.getString("productName");
+            String opis = product.getString("description", "BRAK OPISU");
+            BigDecimal cena = product.getJsonNumber("price").bigDecimalValue();
+            System.out.println(nazwa + " za cenę " + cena + " , opis: " + opis);
+            reader.close();
+        } catch (URISyntaxException | IOException | InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

Wielomodulowy/wielomodulowy-klient_rest/src/main/java/rest_klient/Klient07_HttpClient_JSON_Lista.java

+package rest_klient;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.URISyntaxException;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodyHandlers;
+
+import jakarta.json.Json;
+import jakarta.json.JsonArray;
+import jakarta.json.JsonObject;
+import jakarta.json.JsonReader;
+import jakarta.json.JsonValue;
+
+public class Klient07_HttpClient_JSON_Lista {
+
+    public static void main(String[] args) {
+        try {
+            JsonArray array = pobierzJsona(Ustawienia.ADRES_USLUGI + "/products.json");
+            for(JsonValue jsonValue : array) {
+                JsonObject jsonObject = jsonValue.asJsonObject();
+                System.out.println(jsonObject.getString("productName"));
+                if(jsonObject.containsKey("description")) {
+                    System.out.println("    opis: " + jsonObject.getString("description", ""));
+                }
+                System.out.println("    cena: " + jsonObject.getJsonNumber("price").bigDecimalValue());
+            }
+        } catch (IOException | InterruptedException | URISyntaxException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static JsonArray pobierzJsona(String adres) throws IOException, InterruptedException, URISyntaxException {
+        HttpClient httpClient = HttpClient.newHttpClient();
+        URI uri = new URI(adres);
+        HttpRequest request = HttpRequest.newBuilder(uri).build();
+        HttpResponse<InputStream> response = httpClient.send(request, BodyHandlers.ofInputStream());
+        System.out.println("response " + response);
+        System.out.println("status: " + response.statusCode());
+        System.out.println("Content-Type: " + response.headers().firstValue("Content-Type").orElse("BRAK"));
+        return wczytajJsona(response.body());
+    }
+
+    private static JsonArray wczytajJsona(InputStream input) {
+        try(JsonReader reader = Json.createReader(input)) {
+            return reader.readArray();
+        }
+    }
+
+}

Wielomodulowy/wielomodulowy-klient_rest/src/main/java/rest_klient/Klient11_RestClient.java

+package rest_klient;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+
+import jakarta.ws.rs.client.Client;
+import jakarta.ws.rs.client.ClientBuilder;
+import jakarta.ws.rs.client.Invocation;
+import jakarta.ws.rs.client.WebTarget;
+import jakarta.ws.rs.core.Response;
+
+// Ten i kolejne przykłady pokazują jak aplikacja kliencka napisana w Javie może wysyłać
+// zapytania do usługi REST-owej (głównie GET, jest też gdzieś POST)
+// korzystając z technologii JAX-RS "po stronie klienta".
+// Aby z tego skorzystać, do projektu trzeba dodać bibliotekę z implementacją JAX-RS.
+// Tutaj jest to resteasy-client.
+
+public class Klient11_RestClient {
+
+	public static void main(String[] args) {
+		System.out.println("Startujemy");
+		Client client = ClientBuilder.newClient();
+		
+		System.out.println("Przygotowuję zapytanie");
+		WebTarget target = client.target(Ustawienia.ADRES_USLUGI).path("products.json");
+		Invocation invocation = target.request().buildGet();
+		
+		System.out.println("Wysyłam zapytanie");
+		Response response = invocation.invoke();
+        // Wynikiem jest obiekt klasy Response - tej samej, co na serwerze (używaliśmy np. do generowania kodów 404).
+        // W obiekcie można sprawdzić informacji o odpowiedzi: media type, status code.
+		
+		System.out.println("Mam odpowiedź: " + response);
+		System.out.println("Status: " + response.getStatus());
+		System.out.println("C-Type: " + response.getMediaType());
+		System.out.println("Length: " + response.getLength());
+		
+        // Aby odczytać zawartość zwróconą przez serwer, używamy metody readEntity.
+        // (przy domyślnych ustawieniach) tę metodę można wywołać tylko raz.
+	    // Dopiero w tym momencie podajemy typ, na który zostanie skonwertowana treść odpowiedzi
+		// (w miarę możliwości - po prostu niektóre typy zadziałają, a niektóre nie).
+		byte[] dane = response.readEntity(byte[].class);
+		System.out.println("Dane mają " + dane.length + " bajtów.");
+		try {
+			Files.write(Paths.get("wynik11.json"), dane);
+			System.out.println("Zapisałem w pliku");
+		} catch (IOException e) {
+			System.err.println(e);
+		}
+		System.out.println("Koniec");
+	}
+
+}

Wielomodulowy/wielomodulowy-klient_rest/src/main/java/rest_klient/Klient12_RestClient_String.java

+package rest_klient;
+
+import jakarta.ws.rs.client.Client;
+import jakarta.ws.rs.client.ClientBuilder;
+import jakarta.ws.rs.core.Response;
+
+public class Klient12_RestClient_String {
+
+	public static void main(String[] args) {
+		Client client = ClientBuilder.newClient();
+		
+		// Taki styl programowania to "fluent API"
+		Response response = client.target(Ustawienia.ADRES_USLUGI)
+			.path("products.json")
+			.request()
+			.buildGet()
+			.invoke();
+		
+		System.out.println("Mam odpowiedź: " + response);
+		System.out.println("Status: " + response.getStatus());
+		System.out.println("C-Type: " + response.getMediaType());
+		System.out.println("Length: " + response.getLength());
+		
+		// readEntity(OKREŚLENIE TYPU) stara się odczytać tresc odpowiedzi jako obiekt podanego typu
+		// Obsługiwane typy to m.in: byte[], String, InputStream, File
+		// Dodając odpowiednie "MeassgeBodyReader", możemy obsługiwać dowolne typy.
+		// W szczególności, gdy dodamy do projektu obsługę XML lub JSON (zob. zależności Mavena),
+		// będziemy mogli odczytywać dane w postaci obiektów naszego modelu, np. Product.
+		String dane = response.readEntity(String.class);
+		System.out.println("Otrzymane dane:");
+		System.out.println(dane);
+	}
+
+}

Wielomodulowy/wielomodulowy-klient_rest/src/main/java/rest_klient/Klient13_RestClient_Multiformat.java

+package rest_klient;
+
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
+
+import javax.swing.JOptionPane;
+
+import jakarta.ws.rs.client.Client;
+import jakarta.ws.rs.client.ClientBuilder;
+import jakarta.ws.rs.core.Response;
+
+public class Klient13_RestClient_Multiformat {
+
+	public static void main(String[] args) {
+		try {
+            Client client = ClientBuilder.newClient();
+            
+            String[] formaty = {"txt", "json", "xml", "html", "pdf"};
+            String format = (String) JOptionPane.showInputDialog(null, "Wybierz format danych", "Wybór",
+                    JOptionPane.QUESTION_MESSAGE, null, formaty, "txt");
+
+            if(format == null) {
+            	return;
+            }
+            
+            String mediaType = switch(format) {
+                case "txt" -> "text/plain";
+                case "json" -> "application/json";
+                case "xml" -> "application/xml";
+                case "html" -> "text/html";
+                case "pdf" -> "application/pdf";
+                default -> throw new IllegalArgumentException();
+            };
+            
+            // Klient może wybrać format (mediaType), w jakim oczekuje odpowiedzi - to wpływa na nagłówek Accept
+            Response response = client.target(Ustawienia.ADRES_USLUGI)
+            	.path("products")
+            	.request(mediaType)
+            	.buildGet()
+            	.invoke();
+            
+            JOptionPane.showMessageDialog(null, String.format("""
+                    Status: %d
+                    C-Type: %s
+                    Length: %d""", response.getStatus(), response.getMediaType(), response.getLength()));
+            
+            Path plik = Paths.get("wynik13." + format);
+            InputStream stream = response.readEntity(InputStream.class);
+            Files.copy(stream,  plik, StandardCopyOption.REPLACE_EXISTING);
+            JOptionPane.showMessageDialog(null, "Zapisano plik " + plik);
+        } catch(Exception e) {
+            e.printStackTrace();
+        }
+	}
+
+}

Wielomodulowy/wielomodulowy-klient_rest/src/main/java/rest_klient/Klient14_RestClient_PDF.java

+package rest_klient;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Paths;
+import java.nio.file.StandardCopyOption;
+
+import jakarta.ws.rs.client.Client;
+import jakarta.ws.rs.client.ClientBuilder;
+import jakarta.ws.rs.client.WebTarget;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+
+public class Klient14_RestClient_PDF {
+	
+	private static final MediaType PDF_TYPE = new MediaType("application", "pdf");
+
+	public static void main(String[] args) {
+		int productId = 1;
+		
+		System.out.println("Startujemy...");
+		Client client = ClientBuilder.newClient();
+		
+		WebTarget root = client.target(Ustawienia.ADRES_USLUGI);
+		
+		Response response = root
+				.path("products")
+				.path("{id}")
+				.resolveTemplate("id", productId)
+				.request()
+				.accept(PDF_TYPE)
+				.buildGet()
+				.invoke();
+
+		System.out.println("Otrzymałem response: " + response);
+		System.out.println("Status: " + response.getStatus());
+		System.out.println("Content-Type: " + response.getMediaType());
+		
+		if(response.getStatus() != 200) {
+			System.out.println("Chyba coś nie tak, więc przerywam.");
+			return;
+		}
+		
+		String nazwaPliku = "wynik.pdf";
+		String contentDisposition = response.getHeaderString("Content-Disposition");
+		if(contentDisposition != null && contentDisposition.contains(";filename=")) {
+			nazwaPliku = contentDisposition.split(";filename=")[1];
+		}
+		
+		try(InputStream strumienDanych = response.readEntity(InputStream.class)) {
+			long ileBajtow = Files.copy(strumienDanych, Paths.get(nazwaPliku), StandardCopyOption.REPLACE_EXISTING);
+			System.out.printf("Zapisano %d bajtów do pliku %s\n", ileBajtow, nazwaPliku);
+		} catch (IOException e) {
+			e.printStackTrace();
+		}
+		System.out.println("Gotowe");
+	}
+
+}

Wielomodulowy/wielomodulowy-klient_rest/src/main/java/rest_klient/Klient21_RestClient_JAXB.java

+package rest_klient;
+
+import jakarta.ws.rs.client.Client;
+import jakarta.ws.rs.client.ClientBuilder;
+import jakarta.ws.rs.core.Response;
+import sklep.model.Product;
+import sklep.model.ProductList;
+
+public class Klient21_RestClient_JAXB {
+
+	public static void main(String[] args) {
+		Client client = ClientBuilder.newClient();
+		
+		Response response = client.target(Ustawienia.ADRES_USLUGI)
+			.path("products.xml")
+			.request()
+			.buildGet()
+			.invoke();
+		
+		System.out.println("Mam odpowiedź: " + response);
+		System.out.println("Status: " + response.getStatus());
+		System.out.println("C-Type: " + response.getMediaType());
+		System.out.println("Length: " + response.getLength());
+		
+		ProductList products = response.readEntity(ProductList.class);
+		
+		System.out.println("Otrzymane dane:");
+		for (Product product : products.getProducts()) {
+			System.out.println(product);
+		}
+	}
+
+}

Wielomodulowy/wielomodulowy-klient_rest/src/main/java/rest_klient/Klient22_RestClient_JSON.java

+package rest_klient;
+
+import java.util.List;
+
+import jakarta.ws.rs.client.Client;
+import jakarta.ws.rs.client.ClientBuilder;
+import jakarta.ws.rs.core.GenericType;
+import jakarta.ws.rs.core.Response;
+import sklep.model.Product;
+
+public class Klient22_RestClient_JSON {
+
+    public static void main(String[] args) {
+        Client client = ClientBuilder.newClient();
+        
+        Response response = client.target(Ustawienia.ADRES_USLUGI)
+            .path("products.json")
+            .request()
+            .buildGet()
+            .invoke();
+        
+        System.out.println("Mam odpowiedź: " + response);
+        System.out.println("Status: " + response.getStatus());
+        System.out.println("C-Type: " + response.getMediaType());
+        System.out.println("Length: " + response.getLength());
+        
+        // Ponieważ wersja JSON na serwerze zwraca wynik typu List<Product>, to tutaj musimy podać "typ generyczny",
+        // a nie wystarczy zwykła klasa.
+        // Nie zadziała:
+        // List<Product> products = response.readEntity(List.class);
+            
+        GenericType<List<Product>> typListy = new GenericType<>() {};
+        List<Product> products = response.readEntity(typListy);
+        // albo jednolinijkowo:
+        // List<Product> products = response.readEntity(new GenericType<List<Product>>() {});
+        for(Product product : products) {
+            System.out.println(product);
+        }
+    }
+
+}

Wielomodulowy/wielomodulowy-klient_rest/src/main/java/rest_klient/Klient23_RestClient_JSON_JedenProdukt.java

+package rest_klient;
+
+import jakarta.ws.rs.client.Client;
+import jakarta.ws.rs.client.ClientBuilder;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+import sklep.model.Product;
+
+public class Klient23_RestClient_JSON_JedenProdukt {
+
+	public static void main(String[] args) {
+		Client client = ClientBuilder.newClient();
+		
+		Response response = client.target(Ustawienia.ADRES_USLUGI)
+			.path("products")
+			.path("1")
+			.request()
+			.accept(MediaType.APPLICATION_JSON)
+			.buildGet()
+			.invoke();
+		
+		System.out.println("Mam odpowiedź: " + response);
+		System.out.println("Status: " + response.getStatus());
+		System.out.println("C-Type: " + response.getMediaType());
+		System.out.println("Length: " + response.getLength());
+		
+		Product product = response.readEntity(Product.class);
+		System.out.println("Odczytany produkt: " + product);
+	}
+
+}

Wielomodulowy/wielomodulowy-klient_rest/src/main/java/rest_klient/Klient24_Interaktywna_Edycja.java

+package rest_klient;
+
+import java.math.BigDecimal;
+import java.util.Scanner;
+
+import jakarta.ws.rs.client.Client;
+import jakarta.ws.rs.client.ClientBuilder;
+import jakarta.ws.rs.client.Entity;
+import jakarta.ws.rs.client.WebTarget;
+import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+import sklep.model.Product;
+
+public class Klient24_Interaktywna_Edycja {
+
+	public static void main(String[] args) {
+		System.out.println("Startujemy...");
+		Scanner scanner = new Scanner(System.in);
+		
+		Client client = ClientBuilder.newClient();
+		WebTarget path = client.target(Ustawienia.ADRES_USLUGI)
+				.path("products")
+				.path("{id}");
+		
+		System.out.println("Przygotowana ścieżka: " + path);
+
+		while (true) {
+			System.out.print("\nPodaj id: ");
+			int id = scanner.nextInt();
+			if(id == 0) break;
+			
+			Response response = path
+					.resolveTemplate("id", id)
+					.request(MediaType.APPLICATION_JSON)
+					.get();
+			
+			System.out.println("Status: " + response.getStatus());
+			System.out.println("Content-Type: " + response.getMediaType());
+			if (response.getStatus() == 200) {
+				Product product = response.readEntity(Product.class);
+				System.out.println("Mam produkt:");
+				System.out.println("  Nazwa: " + product.getProductName());
+				System.out.println("  Cena: " + product.getPrice());
+				System.out.println("  Opis: " + product.getDescription());
+				System.out.println();
+				System.out.println("Podaj zmianę ceny (0 aby nie zmieniać):");
+				BigDecimal zmianaCeny = scanner.nextBigDecimal();
+				if(zmianaCeny.compareTo(BigDecimal.ZERO) != 0) {
+					BigDecimal newPrice = product.getPrice().add(zmianaCeny);
+					System.out.println("PUT nowej ceny...");
+					Response odpPut = path.path("price").resolveTemplate("id", id).request()
+							.put(Entity.entity(newPrice, MediaType.TEXT_PLAIN_TYPE));
+					System.out.println("PUT zakończył się kodem " + odpPut.getStatus());
+				}
+			} else {
+				System.out.println("nie mogę odczytać");
+			}
+		}
+	}
+
+}

Wielomodulowy/wielomodulowy-klient_rest/src/main/java/rest_klient/Ustawienia.java

+package rest_klient;
+
+public class Ustawienia {
+    public static final String ADRES_USLUGI = "http://localhost:8080/wielomodulowy-rest";
+}