Przykłady nieco bardziej techniczne

PC32-Spring/src/main/java/alx/aplikacja/ParametryController.java

+package alx.aplikacja;
+
+import org.springframework.stereotype.Controller;
+import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestHeader;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestParam;
+import org.springframework.web.bind.annotation.ResponseBody;
+
+import jakarta.servlet.http.HttpServletRequest;
+
+@Controller
+@RequestMapping("/parametry")
+public class ParametryController {
+    // Najprostsze podejście, aby odczytać wartość parametru zapytania:
+    // zadeklarować parametr o takiej samej nazwie w metodzie kontrolera.
+    // "Spring nam to przekaże".
+    // Podejście polegające na tym, że framework wywołuje "naszą metodę",
+    // a gdy my czegoś potrzebujemy, to dodajemy odp. parametr do tej metody,
+    // nazywa się "inversion of control (IoC)".
+    
+    @GetMapping("/witaj")
+    @ResponseBody
+    public String witaj(String imie) {
+        return "Witaj " + imie;
+    }
+
+    // Dzięki adnotacji @RequestParam mamy większą kontrolę nad szczegółami parametru.
+    // Można m.in. podać inną nazwę niż nazw zmiennej w Javie, może podać wartość domyślną.
+    // http://localhost:8080/parametry/powtorz?tekst=Ala%20ma%20kota&n=10
+    @GetMapping(path="/powtorz", produces="text/plain;charset=utf-8")
+    @ResponseBody
+    public String powtorz(
+            @RequestParam(defaultValue="") String tekst,
+            @RequestParam(name="n", defaultValue="1") int ileRazy) {
+        return (tekst + "\n").repeat(ileRazy);
+    }
+
+    // Parametry bez adnotacji są opcjonalne - w razie braku Spring wywoła metodę i wstawi nulla.
+    // Parametry z adnotacją @RequestParam są domyślnie obowiązkowe. Aby był opcjonalny,
+    // trzeba wpisać required=false (wtedy brak parametru = null)
+    // lub podać defaultValue.
+    
+    // Wpisując do własnych metod parametry specjalnych typów, albo używając specjalnych adnotacji,
+    // możemy uzyskać dostęp do różnych klas narzędziowych serwera lub informacji związanych z zapytaniem.
+    @GetMapping(path="/techniczne", produces="text/plain;charset=UTF-8")
+    @ResponseBody
+    public String parametryTechniczne(
+            HttpServletRequest request,
+            @RequestHeader("User-Agent") String agent) {
+        return """
+                adres IP klienta: %s:%d
+                adres serwera: %s:%d
+                User-Agent z requestu: %s
+                User-Agent z parametru: %s
+                """.formatted(request.getRemoteAddr(), request.getRemotePort(),
+                        request.getLocalAddr(), request.getLocalPort(),
+                        request.getHeader("User-Agent"), agent);
+    }
+    
+}

PC32-Spring/src/main/java/alx/aplikacja/RootController.java

 package alx.aplikacja;
 
+import jakarta.servlet.http.HttpServletRequest;
 import org.springframework.stereotype.Controller;
+import org.springframework.ui.Model;
 import org.springframework.web.bind.annotation.GetMapping;
+import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.ResponseBody;
 
 import java.time.LocalDateTime;
+import java.util.Map;
 
 /* Klasa typu Controller decyduje, w jaki sposób będą obsługiwane zapytania przychodzące na serwer.
  * W projekcie może być wiele kontrolerów, a każdy kontroler może mieć wiele metod obsługujących zapytania.
@@ -31,4 +35,29 @@ public class RootController {
         return LocalDateTime.now();
     }
 
+    @RequestMapping("/ping")
+    public String ping(HttpServletRequest request, Model model) {
+        // Do metod w kontrolerze można dodawać parametry różnych typów,
+        // które "Spring zna" i gdy taki parametr się pojawia, to Spring
+        // wywołując metodę przekazuje nam w tym parametrze odpowiedni obiekt.
+        // To się nazywa wstrzykiwanie parametrów / parameter injection.
+        // A ogólnie to podejście, że nie my wywołuemy metodę, aby coś odczytać,
+        // tylko spring wywołuje NASZĄ metodę i Spring NAM przekazuje wymagane parametry,
+        // nazywa się "inversion of control" (IoC).
+
+        // Przykładowo tutaj dodaliśmy do metody parametr HttpServletRequest
+        // i Spring przekazuje nam tu techniczne informacje o zapytaniu (to samo, co
+        // było w serwletach).
+
+        // Do modelu można też dodać słownik / mapę.
+        // Odczyt wartości wygląda później np. tak ${clientInfo.userAgent}
+
+        String ip = request.getRemoteAddr();
+        String host = request.getRemoteHost();
+        System.out.println("Zapytanie z adresu " + ip);
+
+        model.addAttribute("clientInfo", Map.of("userAgent", request.getHeader("User-Agent"), "ip", ip, "host", host));
+        return "ping.html";
+    }
+
 }

PC32-Spring/src/main/resources/templates/ping.html

+<!DOCTYPE html>
+<html lang="pl" xmlns:th="http://www.thymeleaf.org">
+<head>
+    <meta charset="UTF-8">
+    <title>Ping</title>
+    <link rel="stylesheet" type="text/css" th:href="@{/styl.css}" href="../static/styl.css">
+</head>
+<body>
+<h2>Informacje o kliencie</h2>
+<ul>
+    <li>Adres: <strong th:text="${clientInfo.ip}">1.2.3.4</strong> (<span th:text="${clientInfo.host}">abc.com</span>)</li>
+    <li>Przeglądarka: <strong th:text="${clientInfo.userAgent}">IE</strong></li>
+</ul>
+
+</body>
+</html>