Inne przykłady pobierania danych z sieci

PC28-RestKlient/src/main/java/pobieranie/Pobieranie1_URL.java

+package pobieranie;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+
+public class Pobieranie1_URL {
+
+    public static void main(String[] args) {
+        final String adres = "http://api.nbp.pl/api/exchangerates/tables/A/?format=json";
+
+        try {
+            URL url = new URL(adres);
+            // Od Java 21 bardziej zalecane jest:
+            // URI uri = new URI(adres);
+            // URL url = uri.toURL();
+            try(InputStream input = url.openStream()) {
+                // z input stream dane można czytać porcjami jako ciągi bajtów
+                // byte[] tablica_bajtow = new byte[1024];
+                // int ile = input.read(tablica_bajtow);
+                // System.out.println(new String(tablica_bajtow, 0, ile));
+                // ale tutaj całość pobrnaych danych zapiszemy do pliku
+                Files.copy(input, Path.of("waluty.json"), StandardCopyOption.REPLACE_EXISTING);
+                System.out.println("Gotowe");
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

PC28-RestKlient/src/main/java/pobieranie/Pobieranie2_HttpClient_DoPliku.java

+package pobieranie;
+
+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 java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+
+public class Pobieranie2_HttpClient_DoPliku {
+
+    public static void main(String[] args) {
+        final String adres = "http://api.nbp.pl/api/exchangerates/tables/A/?format=json";
+
+        try {
+            URI uri = new URI(adres);
+            HttpClient client = HttpClient.newHttpClient();
+            HttpRequest request = HttpRequest.newBuilder(uri).build();
+            HttpResponse<InputStream> response = client.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("--"));
+            if(response.statusCode() != 200) {
+                return;
+            }
+            // body jest takiego typu, jaki wynika z użytego BodyHandler
+            try(InputStream input = response.body()) {
+                Files.copy(input, Path.of("waluty.json"), StandardCopyOption.REPLACE_EXISTING);
+                System.out.println("Gotowe");
+            }
+        } catch (IOException | URISyntaxException | InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

PC28-RestKlient/src/main/java/pobieranie/Pobieranie3_HttpClient_String.java

+package pobieranie;
+
+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 Pobieranie3_HttpClient_String {
+
+    public static void main(String[] args) {
+        final String adres = "http://api.nbp.pl/api/exchangerates/tables/A/?format=json"; // spróbuj xml
+
+        try {
+            URI uri = new URI(adres);
+            HttpClient client = HttpClient.newHttpClient();
+            HttpRequest request = HttpRequest.newBuilder(uri).build();
+            HttpResponse<String> response = client.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("--"));
+//			if(response.statusCode() != 200) {
+//				return;
+//			}
+            // body jest takiego typu, jaki wynika z użytego BodyHandler
+            String body = response.body();
+            System.out.println("Długość stringa: " + body.length());
+            System.out.println(body);
+        } catch (IOException | URISyntaxException | InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

PC28-RestKlient/src/main/java/pobieranie/Pobieranie4_JSON.java

+package pobieranie;
+
+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.JsonArray;
+import jakarta.json.JsonObject;
+import jakarta.json.JsonReader;
+import jakarta.json.JsonValue;
+
+public class Pobieranie4_JSON {
+
+    public static void main(String[] args) {
+        final String adres = "http://api.nbp.pl/api/exchangerates/tables/A/?format=json";
+
+        try {
+            URI uri = new URI(adres);
+            HttpClient client = HttpClient.newHttpClient();
+            HttpRequest request = HttpRequest.newBuilder(uri).build();
+            HttpResponse<InputStream> response = client.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("--"));
+            if(response.statusCode() != 200) {
+                return;
+            }
+            // parsowanie JSONa z pomocą biblioteki Jakarta JSON (utworzone w Java EE 7 i dalej rozwijane)
+            // alternatywy: GSON, org.json, Jackson
+            
+            JsonArray json;
+            try(JsonReader reader = Json.createReader(response.body())) {
+                json = reader.readArray();				
+            } // tutaj już zamykamy połączenie
+            // zerowym (i jedynym) elementem tablicy jest {obiekt JSONowy} odpowiadający tabeli walut
+            JsonObject tabela = json.getJsonObject(0);
+            // bezpośrednio w tym obiekcie są takie pola, jak numer i data
+            System.out.println("Numer tabeli: " + tabela.getString("no"));
+            System.out.println("Data: " + tabela.getString("effectiveDate"));
+            // w polu rates znajduje się tablica zawierająca dane poszczególnych walut
+            JsonArray rates = tabela.getJsonArray("rates");
+            System.out.println("Liczba walut: " + rates.size());
+            System.out.println();
+            for(JsonValue rate : rates) {
+                // System.out.println(rate);
+                JsonObject rateObj = rate.asJsonObject();
+                String nazwa = rateObj.getString("currency");
+                String kod = rateObj.getString("code");
+                BigDecimal kurs = rateObj.getJsonNumber("mid").bigDecimalValue();
+                System.out.println(kod + " " + nazwa + ": " + kurs);
+            }
+        } catch (IOException | URISyntaxException | InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

PC28-RestKlient/src/main/java/pogoda/PobierzPogode1.java

+package pogoda;
+
+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;
+
+// Pobieramy pogodę dla konkretnej lokalizacji (współrzędne Warszawy)
+// i wypisujemy surowe dane JSON.
+public class PobierzPogode1 {
+
+    public static void main(String[] args) {
+        String adres = "https://api.open-meteo.com/v1/forecast?latitude=52&longitude=21&current_weather=true";
+
+        try {
+            HttpClient client = HttpClient.newHttpClient();
+            HttpRequest request = HttpRequest.newBuilder(new URI(adres)).build();
+            HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
+            String tekstJSON = response.body();
+            System.out.println(tekstJSON);
+        } catch (URISyntaxException | IOException | InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

PC28-RestKlient/src/main/java/pogoda/PobierzPogode2.java

+package pogoda;
+
+import jakarta.json.Json;
+import jakarta.json.JsonObject;
+import jakarta.json.JsonReader;
+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;
+
+// Pobieramy pogodę dla konkretnej lokalizacji (współrzędne Warszawy)
+// parsujemy JSONa i wyciągamy informację o temperaturze
+public class PobierzPogode2 {
+
+    public static void main(String[] args) {
+        String adres = "https://api.open-meteo.com/v1/forecast?latitude=52&longitude=21&current_weather=true";
+
+        try {
+            HttpClient client = HttpClient.newHttpClient();
+            HttpRequest request = HttpRequest.newBuilder(new URI(adres)).build();
+            HttpResponse<InputStream> response = client.send(request, HttpResponse.BodyHandlers.ofInputStream());
+
+            JsonReader reader = Json.createReader(response.body());
+            JsonObject json = reader.readObject();
+            System.out.println("Cały JSON: " + json);
+            JsonObject weather = json.getJsonObject("current_weather");
+            System.out.println("weather: " + weather);
+            double temperatura = weather.getJsonNumber("temperature").doubleValue();
+            System.out.println("temperatura: " + temperatura);
+        } catch (URISyntaxException | IOException | InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+}

PC28-RestKlient/src/main/java/pogoda/PobierzPogodeDlaMiasta.java

+package pogoda;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.util.Scanner;
+
+import jakarta.json.Json;
+import jakarta.json.JsonArray;
+import jakarta.json.JsonObject;
+import jakarta.json.JsonReader;
+import jakarta.json.JsonValue;
+
+public class PobierzPogodeDlaMiasta {
+    private Scanner scanner = new Scanner(System.in);
+    private double lat;
+    private double lon;
+    private String miasto;
+    
+
+    public static void main(String[] args) {
+        new PobierzPogodeDlaMiasta().run();
+    }
+
+    public void run() {
+        try {
+        System.out.print("Podaj nazwę miasta: ");
+        String szukane = scanner.nextLine();
+        if(znajdzMiasto(szukane)) {
+            pobierzIWypiszPogode();
+        }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+    
+    private boolean znajdzMiasto(String szukane) throws IOException {
+        URL url = new URL("https://geocoding-api.open-meteo.com/v1/search?name=" + szukane);
+        try(InputStream input = url.openStream();
+            JsonReader reader = Json.createReader(input)) {
+            JsonObject json = reader.readObject();
+            JsonArray results = json.getJsonArray("results");
+            if(results.isEmpty()) {
+                System.out.println("Brak znalezionych lokalizacji");
+                return false;
+            }
+            System.out.println("Znalezione lokalizacje:");
+            int i = 0;
+            for(JsonValue result : results) {
+                JsonObject resulto = result.asJsonObject();
+                //System.out.print(result);
+                System.out.printf("%2d: <%+.3f %+.3f> → %s, %s%n", i++,
+                        resulto.getJsonNumber("latitude").doubleValue(),
+                        resulto.getJsonNumber("longitude").doubleValue(),
+                        resulto.getString("name"), resulto.getString("country"));
+            }
+            System.out.print("Wybierz numer lokalizacji: ");
+            i = scanner.nextInt();
+            if(i < 0 || i >= results.size()) {
+                return false;
+            }
+            JsonObject loc = results.getJsonObject(i);
+            lat = loc.getJsonNumber("latitude").doubleValue();
+            lon = loc.getJsonNumber("longitude").doubleValue();
+            miasto = loc.getString("name");
+            return true;
+        }
+    }
+    
+    private void pobierzIWypiszPogode() throws IOException {
+        URL url = new URL("https://api.open-meteo.com/v1/forecast?latitude=" + lat + "&longitude="+ lon +"&current_weather=true&hourly=temperature_2m");
+        try(InputStream input = url.openStream();
+            JsonReader reader = Json.createReader(input)) {
+            JsonObject json = reader.readObject();
+            JsonObject weather = json.getJsonObject("current_weather");
+            
+            System.out.printf("Bieżąca pogoda dla miasta %s:%n", miasto);
+            System.out.println(weather);
+            System.out.printf("Temperatura %.1f °C%n", weather.getJsonNumber("temperature").doubleValue());
+            System.out.printf("Wiatr:      %.1f km/h%n", weather.getJsonNumber("windspeed").doubleValue());
+        }
+    }
+    
+}

PC28-RestKlient/src/main/java/pogoda/WyswietlPogodeDlaWspolrzednych.java

+/*
+ * Click nbfs://nbhost/SystemFileSystem/Templates/Licenses/license-default.txt to change this license
+ * Click nbfs://nbhost/SystemFileSystem/Templates/GUIForms/JFrame.java to edit this template
+ */
+package pogoda;
+
+import jakarta.json.Json;
+import jakarta.json.JsonObject;
+import jakarta.json.JsonReader;
+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;
+
+/**
+ *
+ * @author kurs
+ */
+public class WyswietlPogodeDlaWspolrzednych extends javax.swing.JFrame {
+
+    /**
+     * Creates new form WyswietlPogodeDlaWspolrzednych
+     */
+    public WyswietlPogodeDlaWspolrzednych() {
+        initComponents();
+    }
+
+    /**
+     * This method is called from within the constructor to initialize the form.
+     * WARNING: Do NOT modify this code. The content of this method is always
+     * regenerated by the Form Editor.
+     */
+    @SuppressWarnings("unchecked")
+    // <editor-fold defaultstate="collapsed" desc="Generated Code">//GEN-BEGIN:initComponents
+    private void initComponents() {
+
+        jSpinner1 = new javax.swing.JSpinner();
+        jSpinner2 = new javax.swing.JSpinner();
+        jLabel1 = new javax.swing.JLabel();
+        jLabel2 = new javax.swing.JLabel();
+        jButton1 = new javax.swing.JButton();
+        jLabel3 = new javax.swing.JLabel();
+        jLabel_Temperatura = new javax.swing.JLabel();
+
+        setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
+
+        jSpinner1.setFont(new java.awt.Font("Segoe UI", 0, 18)); // NOI18N
+        jSpinner1.setModel(new javax.swing.SpinnerNumberModel(52.0d, -90.0d, 90.0d, 1.0d));
+
+        jSpinner2.setFont(new java.awt.Font("Segoe UI", 0, 18)); // NOI18N
+        jSpinner2.setModel(new javax.swing.SpinnerNumberModel(21.0d, -180.0d, 180.0d, 1.0d));
+
+        jLabel1.setFont(new java.awt.Font("Segoe UI", 0, 18)); // NOI18N
+        jLabel1.setText("Szerokość geograficzna");
+
+        jLabel2.setFont(new java.awt.Font("Segoe UI", 0, 18)); // NOI18N
+        jLabel2.setText("Długość geograficzna");
+
+        jButton1.setFont(new java.awt.Font("Segoe UI", 1, 24)); // NOI18N
+        jButton1.setText("Pobierz pogodę");
+        jButton1.addActionListener(new java.awt.event.ActionListener() {
+            public void actionPerformed(java.awt.event.ActionEvent evt) {
+                jButton1ActionPerformed(evt);
+            }
+        });
+
+        jLabel3.setFont(new java.awt.Font("Segoe UI", 0, 18)); // NOI18N
+        jLabel3.setText("Temperatura");
+
+        jLabel_Temperatura.setFont(new java.awt.Font("Segoe UI", 1, 18)); // NOI18N
+        jLabel_Temperatura.setText("jLabel4");
+
+        javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());
+        getContentPane().setLayout(layout);
+        layout.setHorizontalGroup(
+            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGroup(layout.createSequentialGroup()
+                .addContainerGap()
+                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING, false)
+                    .addComponent(jButton1, javax.swing.GroupLayout.Alignment.TRAILING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
+                    .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
+                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+                            .addComponent(jLabel1, javax.swing.GroupLayout.PREFERRED_SIZE, 228, javax.swing.GroupLayout.PREFERRED_SIZE)
+                            .addComponent(jLabel2, javax.swing.GroupLayout.PREFERRED_SIZE, 228, javax.swing.GroupLayout.PREFERRED_SIZE))
+                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
+                        .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+                            .addComponent(jSpinner2, javax.swing.GroupLayout.PREFERRED_SIZE, 119, javax.swing.GroupLayout.PREFERRED_SIZE)
+                            .addComponent(jSpinner1, javax.swing.GroupLayout.PREFERRED_SIZE, 119, javax.swing.GroupLayout.PREFERRED_SIZE)))
+                    .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup()
+                        .addComponent(jLabel3, javax.swing.GroupLayout.PREFERRED_SIZE, 114, javax.swing.GroupLayout.PREFERRED_SIZE)
+                        .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
+                        .addComponent(jLabel_Temperatura, javax.swing.GroupLayout.PREFERRED_SIZE, 169, javax.swing.GroupLayout.PREFERRED_SIZE)))
+                .addContainerGap(18, Short.MAX_VALUE))
+        );
+        layout.setVerticalGroup(
+            layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)
+            .addGroup(layout.createSequentialGroup()
+                .addGap(41, 41, 41)
+                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+                    .addComponent(jSpinner1, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+                    .addComponent(jLabel1))
+                .addGap(29, 29, 29)
+                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+                    .addComponent(jSpinner2, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)
+                    .addComponent(jLabel2))
+                .addGap(18, 18, 18)
+                .addComponent(jButton1, javax.swing.GroupLayout.PREFERRED_SIZE, 64, javax.swing.GroupLayout.PREFERRED_SIZE)
+                .addGap(18, 18, 18)
+                .addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE)
+                    .addComponent(jLabel3, javax.swing.GroupLayout.PREFERRED_SIZE, 31, javax.swing.GroupLayout.PREFERRED_SIZE)
+                    .addComponent(jLabel_Temperatura, javax.swing.GroupLayout.PREFERRED_SIZE, 31, javax.swing.GroupLayout.PREFERRED_SIZE))
+                .addContainerGap(61, Short.MAX_VALUE))
+        );
+
+        pack();
+    }// </editor-fold>//GEN-END:initComponents
+
+    private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {//GEN-FIRST:event_jButton1ActionPerformed
+        double lat = (Double)jSpinner1.getValue();
+        double lon = (Double)jSpinner2.getValue();
+
+        String adres = "https://api.open-meteo.com/v1/forecast?latitude=" + lat
+                + "&longitude=" + lon
+                + "&current_weather=true";
+        try {
+            HttpClient client = HttpClient.newHttpClient();
+            HttpRequest request = HttpRequest.newBuilder(new URI(adres)).build();
+            HttpResponse<InputStream> response = client.send(request, HttpResponse.BodyHandlers.ofInputStream());
+
+            JsonReader reader = Json.createReader(response.body());
+            JsonObject json = reader.readObject();
+            JsonObject weather = json.getJsonObject("current_weather");
+            double temperatura = weather.getJsonNumber("temperature").doubleValue();
+
+            jLabel_Temperatura.setText(String.valueOf(temperatura));
+        } catch (URISyntaxException | IOException | InterruptedException e) {
+            e.printStackTrace();
+        }
+    }//GEN-LAST:event_jButton1ActionPerformed
+
+    /**
+     * @param args the command line arguments
+     */
+    public static void main(String args[]) {
+        /* Set the Nimbus look and feel */
+        //<editor-fold defaultstate="collapsed" desc=" Look and feel setting code (optional) ">
+        /* If Nimbus (introduced in Java SE 6) is not available, stay with the default look and feel.
+         * For details see http://download.oracle.com/javase/tutorial/uiswing/lookandfeel/plaf.html
+         */
+        try {
+            for (javax.swing.UIManager.LookAndFeelInfo info : javax.swing.UIManager.getInstalledLookAndFeels()) {
+                if ("Nimbus".equals(info.getName())) {
+                    javax.swing.UIManager.setLookAndFeel(info.getClassName());
+                    break;
+                }
+            }
+        } catch (ClassNotFoundException ex) {
+            java.util.logging.Logger.getLogger(WyswietlPogodeDlaWspolrzednych.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
+        } catch (InstantiationException ex) {
+            java.util.logging.Logger.getLogger(WyswietlPogodeDlaWspolrzednych.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
+        } catch (IllegalAccessException ex) {
+            java.util.logging.Logger.getLogger(WyswietlPogodeDlaWspolrzednych.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
+        } catch (javax.swing.UnsupportedLookAndFeelException ex) {
+            java.util.logging.Logger.getLogger(WyswietlPogodeDlaWspolrzednych.class.getName()).log(java.util.logging.Level.SEVERE, null, ex);
+        }
+        //</editor-fold>
+
+        /* Create and display the form */
+        java.awt.EventQueue.invokeLater(new Runnable() {
+            public void run() {
+                new WyswietlPogodeDlaWspolrzednych().setVisible(true);
+            }
+        });
+    }
+
+    // Variables declaration - do not modify//GEN-BEGIN:variables
+    private javax.swing.JButton jButton1;
+    private javax.swing.JLabel jLabel1;
+    private javax.swing.JLabel jLabel2;
+    private javax.swing.JLabel jLabel3;
+    private javax.swing.JLabel jLabel_Temperatura;
+    private javax.swing.JSpinner jSpinner1;
+    private javax.swing.JSpinner jSpinner2;
+    // End of variables declaration//GEN-END:variables
+}

PC28-RestKlient/src/main/java/rest_klient/Klient24_Interaktywna_Edycja.java

@@ -48,9 +48,10 @@ public class Klient24_Interaktywna_Edycja {
                         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());
+                            try(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ć");

PC28-RestKlient/src/main/java/waluty/BladAplikacji.java

+package waluty;
+
+public class BladAplikacji extends Exception {
+
+    public BladAplikacji() {
+        super();
+    }
+
+    public BladAplikacji(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public BladAplikacji(String message) {
+        super(message);
+    }
+
+    public BladAplikacji(Throwable cause) {
+        super(cause);
+    }
+
+}

PC28-RestKlient/src/main/java/waluty/DrukujWaluty.java

+package waluty;
+
+public class DrukujWaluty {
+
+    public static void main(String[] args) {
+        System.out.println("Startujemy...");
+        try {
+            Pobieranie pobieranie = Pobieranie.utworz("JSON");
+            TabelaWalut tabelaWalut = pobieranie.pobierzBiezaceKursy();
+            System.out.println(tabelaWalut);
+            
+            for(Waluta waluta : tabelaWalut.getRates()) {
+                System.out.println(waluta);
+            }			
+        } catch (BladAplikacji e) {
+            e.printStackTrace();
+        }
+    }
+
+}

PC28-RestKlient/src/main/java/waluty/Pobieranie.java

+package waluty;
+
+import java.time.LocalDate;
+
+public abstract class Pobieranie {
+
+    protected static final String ADRES_BAZOWY = "https://api.nbp.pl/api/exchangerates/tables";
+
+    public abstract TabelaWalut pobierzBiezaceKursy() throws BladAplikacji;
+
+    public abstract TabelaWalut pobierzArchiwalneKursy(String data) throws BladAplikacji;
+    
+    // Jeśli jakaś część implementacji jest wpólna dla wszystkich podklas,
+    // to można umieścić ja w klasie abstrakcyjnej
+    public TabelaWalut pobierzArchiwalneKursy(LocalDate data) throws BladAplikacji {
+        return pobierzArchiwalneKursy(data.toString());
+    }
+    
+    // fabryka nowych obiektów
+    public static Pobieranie utworz(String format) {
+        return switch(format.toUpperCase()) {
+            case "XML" -> new PobieranieXML();
+            case "JSON" -> new PobieranieJSON();
+            default -> throw new IllegalArgumentException("Nieznany format " + format);
+        };
+    }
+
+}

PC28-RestKlient/src/main/java/waluty/PobieranieJSON.java

+package waluty;
+
+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 java.time.LocalDate;
+
+import jakarta.json.Json;
+import jakarta.json.JsonArray;
+import jakarta.json.JsonObject;
+import jakarta.json.JsonReader;
+import jakarta.json.JsonValue;
+
+public class PobieranieJSON extends Pobieranie {
+    
+    public TabelaWalut pobierzBiezaceKursy() throws BladAplikacji {
+        String adres = ADRES_BAZOWY + "/A?format=json";
+        return pobierzZAdresu(adres);
+    }
+    
+    public TabelaWalut pobierzArchiwalneKursy(String data) throws BladAplikacji {
+        return pobierzZAdresu(ADRES_BAZOWY + "/A/" + data + "?format=json");
+    }
+
+    private TabelaWalut pobierzZAdresu(String adres) throws BladAplikacji {
+        try {
+            HttpClient httpClient = HttpClient.newHttpClient();
+            URI uri = new URI(adres);
+            HttpRequest request = HttpRequest.newBuilder(uri).build();
+            HttpResponse<InputStream> response = httpClient.send(request, BodyHandlers.ofInputStream());
+            if(response.statusCode() != 200) {
+                throw new BladAplikacji("Zapytanie HTTP zwróciło " + response.statusCode());
+            }
+            // dane odebrane z sieci "parsujemy" jako JSON
+            try(JsonReader reader = Json.createReader(response.body())) {
+                JsonArray array = reader.readArray();
+                JsonObject tabela = array.getJsonObject(0);
+                String no = tabela.getString("no");
+                LocalDate effectiveDate = LocalDate.parse(tabela.getString("effectiveDate"));
+                TabelaWalut tabelaWalut = new TabelaWalut(no, effectiveDate);
+                
+                JsonArray rates = tabela.getJsonArray("rates");
+                for(JsonValue rate : rates) {
+                    JsonObject rateObj = rate.asJsonObject();
+                    Waluta waluta = new Waluta(rateObj.getString("code"),
+                            rateObj.getString("currency"),
+                            rateObj.getJsonNumber("mid").bigDecimalValue());
+                    tabelaWalut.addRate(waluta);
+                }
+                return tabelaWalut;
+            }
+        } catch (URISyntaxException | IOException | InterruptedException e) {
+            throw new BladAplikacji(e);
+        }
+    }
+    
+}

PC28-RestKlient/src/main/java/waluty/PobieranieXML.java

+package waluty;
+
+import java.io.InputStream;
+import java.math.BigDecimal;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.net.http.HttpResponse.BodyHandlers;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.xpath.XPath;
+import javax.xml.xpath.XPathConstants;
+import javax.xml.xpath.XPathExpressionException;
+import javax.xml.xpath.XPathFactory;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+
+public class PobieranieXML extends Pobieranie {
+    private HttpClient httpClient = HttpClient.newHttpClient();
+    private DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
+    private XPathFactory xpf = XPathFactory.newInstance();
+
+    @Override
+    public TabelaWalut pobierzBiezaceKursy() throws BladAplikacji {
+        return pobierzZAdresu(ADRES_BAZOWY + "/A" + "?format=xml");
+    }
+    
+    @Override
+    public TabelaWalut pobierzArchiwalneKursy(String data) throws BladAplikacji {
+        return pobierzZAdresu(ADRES_BAZOWY + "/A/" + data + "?format=xml");
+    }
+
+    private TabelaWalut pobierzZAdresu(String adres) throws BladAplikacji {
+        try {
+            URI uri = new URI(adres);
+            HttpRequest request = HttpRequest.newBuilder(uri).build();
+            HttpResponse<InputStream> response = httpClient.send(request, BodyHandlers.ofInputStream());
+            if(response.statusCode() != 200) {
+                throw new BladAplikacji("Brak danych w odpowiedzi HTTP, kod " + response.statusCode());
+            }
+            DocumentBuilder builder = dbf.newDocumentBuilder();
+            Document document = builder.parse(response.body());
+            return tabelaZXML(document);
+        } catch(BladAplikacji e) {
+            throw e;
+        } catch(Exception e) {
+            throw new BladAplikacji("Błąd podczas pobierania XML: " + e.getMessage(), e);
+        }
+    }
+
+    private TabelaWalut tabelaZXML(Document document) throws XPathExpressionException {
+        XPath xpath = xpf.newXPath();
+        
+//        String no = xpath.evaluate("/ArrayOfExchangeRatesTable/ExchangeRatesTable/No", document);
+//        String date = xpath.evaluate("/ArrayOfExchangeRatesTable/ExchangeRatesTable/EffectiveDate", document);
+        String no = xpath.evaluate("//No", document);
+        String date = xpath.evaluate("//EffectiveDate", document);
+        TabelaWalut tabela = new TabelaWalut(no, date);
+        
+        NodeList rates = (NodeList) xpath.evaluate("//Rate", document, XPathConstants.NODESET);
+        final int length = rates.getLength();
+        for(int i = 0; i < length; i++) {
+            Node rate = rates.item(i);
+            String currency = xpath.evaluate("Currency", rate);
+            String code = xpath.evaluate("Code", rate);
+            BigDecimal mid = new BigDecimal(xpath.evaluate("Mid", rate));
+            Waluta waluta = new Waluta(code, currency, mid);
+            tabela.addRate(waluta);
+        }
+        return tabela;
+    }
+
+}

PC28-RestKlient/src/main/java/waluty/ProstyPrzelicznik.java

+package waluty;
+
+import java.math.BigDecimal;
+import java.util.Locale;
+import java.util.Optional;
+import java.util.Scanner;
+
+/* Napisz program, który pobiera aktualne kursy (dodatkowa opcja - możliwość podania daty i pobranie archowalnego)
+ * 
+ * Następnie: użytkownik podaje kod waluty oraz kwotę, a program przelicza kwotę w tej walucie na złote
+ * (ew. przeliczanie w drugą stronę)
+ */
+public class ProstyPrzelicznik {
+
+    public static void main(String[] args) {
+        Pobieranie pobieranie = Pobieranie.utworz("JSON");
+        Scanner scanner = new Scanner(System.in);
+        scanner.useLocale(Locale.US);
+        
+        System.out.println("Podaj datę lub naciśnij enter, aby pobrać najnowsze kursy:");
+        String data = scanner.nextLine();
+        try {
+            TabelaWalut tabela = data.isBlank() ? pobieranie.pobierzBiezaceKursy() : pobieranie.pobierzArchiwalneKursy(data);
+            System.out.println("Pobrano tabelę: " + tabela);
+            
+            System.out.println("\nPodawaj kwoty do przeliczenia w postaci 1000 USD , a żeby zakończyć wpisz Q");
+            while(true) {
+                System.out.print("> ");
+                if(scanner.hasNextBigDecimal()) {
+                    BigDecimal kwota = scanner.nextBigDecimal();
+                    String kod = scanner.next().toUpperCase();
+                    Optional<Waluta> found = tabela.findByCode(kod);
+                    if(found.isPresent()) {
+                        Waluta waluta = found.get();
+                        BigDecimal wynik = waluta.przeliczNaZlote(kwota);
+                        System.out.println(wynik + " PLN");
+                    } else {
+                        System.out.println("Nieznana waluta");
+                    }
+                } else {
+                    if(scanner.next().equalsIgnoreCase("Q"))
+                        break;
+                }
+            }
+        } catch (BladAplikacji e) {
+            System.out.println("Nastąpił błąd: " + e);
+            e.printStackTrace(System.out);
+        }
+        System.out.println("Do widzenia");
+    }
+
+}

PC28-RestKlient/src/main/java/waluty/PrzelicznikKonsolowy.java

+
+package waluty;
+
+import java.math.BigDecimal;
+import java.util.Locale;
+import java.util.Optional;
+import java.util.Scanner;
+
+public class PrzelicznikKonsolowy {
+    private Scanner scanner;
+    private Pobieranie pobieranie;
+    
+    public PrzelicznikKonsolowy() {
+        scanner = new Scanner(System.in);
+        scanner.useLocale(Locale.US);
+    }
+    
+    public static void main(String[] args) {
+        new PrzelicznikKonsolowy().run();
+    }
+    
+    public void run() {
+        System.out.println("Wybierz format danych: XML / JSON");
+        String format = scanner.nextLine().trim().toUpperCase();
+        switch(format) {
+            case "XML" -> pobieranie = new PobieranieXML();
+            case "", "JSON" -> pobieranie = new PobieranieJSON();
+            default -> {
+                System.out.println("Nieznany format, kończę program.");
+                return;
+            }
+        }
+        
+        program: while(true) {
+            System.out.println("\nWpisz datę w formacie YYYY-MM-DD lub naciśnij ENTER, aby pobrać bieżące kursy.");
+            System.out.println("Możesz też wpisać Q , aby zakończyć program");
+            String data = scanner.nextLine();
+            try {
+                TabelaWalut tabela;
+                switch(data) {
+                    case "q", "Q" -> {break program;}
+                    case "" -> tabela = pobieranie.pobierzBiezaceKursy();
+                    default -> tabela = pobieranie.pobierzArchiwalneKursy(data);
+                }
+                dzialajDlaWybranejTabeli(tabela);
+            } catch(BladAplikacji e) {
+                System.out.println("Wyjątek! " + e.getMessage());
+            }
+        }
+        System.out.println("Koniec programu");
+    }
+
+    private void dzialajDlaWybranejTabeli(TabelaWalut tabela) {
+        System.out.println(tabela);
+        
+        while(true) {
+            System.out.println("\nPodaj kod waluty, lub Q aby zakończyć pracę z bieżącą tabelą");
+            String code = scanner.nextLine().toUpperCase();
+            if("Q".equals(code)) {
+                break;
+            }
+            Optional<Waluta> found = tabela.findByCode(code);
+            if(found.isEmpty()) {
+                System.out.println("Nie ma waluty o kodzie " + code);
+                continue;
+            }
+            dzialajDlaWybranejWaluty(found.get());
+        }
+    }
+
+    private void dzialajDlaWybranejWaluty(Waluta waluta) {
+        System.out.println("Wybrana waluta: " + waluta.getCode() + " (" + waluta.getCurrency() + ")" + ", kurs " + waluta.getMid());
+        while(true) {
+            System.out.println("\nPodaj kwotę do przeliczenia. 0 oznacza koniec:");
+            BigDecimal kwota = scanner.nextBigDecimal();
+            scanner.nextLine();
+            if(kwota.compareTo(BigDecimal.ZERO) == 0) {
+                break;
+            }
+            BigDecimal wynikWaluta = waluta.przeliczNaWalute(kwota);
+            BigDecimal wynikPLN = waluta.przeliczNaZlote(kwota);
+            
+            System.out.println(kwota + " " + waluta.getCode() + " = " + wynikPLN + " PLN");
+            System.out.println(kwota + " PLN = " + wynikWaluta + " " + waluta.getCode());
+        }
+    }
+
+}

PC28-RestKlient/src/main/java/waluty/TabelaWalut.java

+package waluty;
+
+import java.time.LocalDate;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+
+public class TabelaWalut {
+    private final String no;
+    private final LocalDate effectiveDate;
+    private final List<Waluta> rates = new ArrayList<>();
+    
+    public TabelaWalut(String no, LocalDate effectiveDate) {
+        this.no = no;
+        this.effectiveDate = effectiveDate;
+    }
+    
+    public TabelaWalut(String no, String effectiveDate) {
+        this(no, LocalDate.parse(effectiveDate));
+    }
+    
+    public void addRate(Waluta waluta) {
+        rates.add(waluta);
+    }
+
+    public String getNo() {
+        return no;
+    }
+
+    public LocalDate getEffectiveDate() {
+        return effectiveDate;
+    }
+
+    public List<Waluta> getRates() {
+        // dostęp tylko do odczytu
+        return Collections.unmodifiableList(rates);
+    }
+    
+    @Override
+    public String toString() {
+        return "Tabela nr " + no + " z dnia " + effectiveDate + ", " + rates.size() + " walut";
+    }
+
+    public Optional<Waluta> findByCode(String code) {
+        for(Waluta waluta : rates) {
+            if(waluta.getCode().equals(code) ) {
+                return Optional.of(waluta);
+            }
+        }
+        return Optional.empty();
+    }
+
+    public String[] codes() {
+        return rates.stream()
+                .map(Waluta::getCode)
+                .toArray(String[]::new);
+    }
+
+}

PC28-RestKlient/src/main/java/waluty/Waluta.java

+package waluty;
+
+import java.math.BigDecimal;
+import java.math.RoundingMode;
+
+public class Waluta {
+    private final String code;
+    private final String currency;
+    private final BigDecimal mid;
+    
+    public Waluta(String code, String currency, BigDecimal mid) {
+        this.code = code;
+        this.currency = currency;
+        this.mid = mid;
+    }
+    
+    public String getCode() {
+        return code;
+    }
+
+    public String getCurrency() {
+        return currency;
+    }
+
+    public BigDecimal getMid() {
+        return mid;
+    }
+
+    @Override
+    public String toString() {
+        return code + " (" + currency + "): " + mid;
+    }
+    
+    public BigDecimal przeliczNaZlote(BigDecimal kwota) {
+        return kwota.multiply(mid).setScale(2, RoundingMode.HALF_EVEN);
+    }
+    
+    public BigDecimal przeliczNaWalute(BigDecimal kwota) {
+        return kwota.divide(mid, 2, RoundingMode.HALF_EVEN);
+    }
+
+}