Ostatnie uzupełnienia

PC27-RestSerwer/src/main/java/sklep/rest/RCustomer.java

+package sklep.rest;
+
+import java.util.List;
+
+import jakarta.enterprise.context.RequestScoped;
+import jakarta.ws.rs.Consumes;
+import jakarta.ws.rs.DELETE;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.POST;
+import jakarta.ws.rs.PUT;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.PathParam;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.Response;
+import jakarta.ws.rs.core.UriBuilder;
+import sklep.db.CustomerDAO;
+import sklep.db.DBConnection;
+import sklep.db.DBException;
+import sklep.db.RecordNotFound;
+import sklep.model.Customer;
+
+@RequestScoped
+@Path("/customers")
+@Produces({ "application/xml", "application/json" })
+@Consumes({ "application/xml", "application/json" })
+public class RCustomer {
+
+    @POST
+    public Response save(final Customer customer) throws DBException {
+        try(DBConnection db = DBConnection.open()) {
+            CustomerDAO customerDAO = db.customerDAO();
+            customerDAO.save(customer);
+            db.commit();
+            return Response.created(UriBuilder.fromResource(RCustomer.class).path(String.valueOf(customer.getEmail())).build()).build();
+        }
+    }
+
+    @GET
+    @Path("/{id}")
+    public Customer findById(@PathParam("id") final String email) throws DBException, RecordNotFound {
+        try(DBConnection db = DBConnection.open()) {
+            CustomerDAO customerDAO = db.customerDAO();
+            return customerDAO.findByEmail(email);
+        }
+    }
+
+    @GET
+    public List<Customer> listAll() throws DBException {
+        try(DBConnection db = DBConnection.open()) {
+            CustomerDAO customerDAO = db.customerDAO();
+            return customerDAO.readAll();
+        }
+    }
+
+    @PUT
+    @Path("/{id}")
+    public Response update(@PathParam("id") String email, final Customer customer) throws DBException {
+        try(DBConnection db = DBConnection.open()) {
+            CustomerDAO customerDAO = db.customerDAO();
+            customer.setEmail(email);
+            customerDAO.save(customer);
+            db.commit();
+        }
+        return Response.noContent().build();
+    }
+
+    @DELETE
+    @Path("/{id}")
+    public Response deleteById(@PathParam("id") String email) throws DBException {
+        try(DBConnection db = DBConnection.open()) {
+            CustomerDAO customerDAO = db.customerDAO();
+            customerDAO.delete(email);
+            db.commit();
+        }
+        return Response.noContent().build();
+    }
+
+}

PC27-RestSerwer/src/main/java/sklep/rest/ROrder.java

+package sklep.rest;
+
+import java.net.URI;
+import java.util.List;
+
+import jakarta.enterprise.context.RequestScoped;
+import jakarta.ws.rs.Consumes;
+import jakarta.ws.rs.GET;
+import jakarta.ws.rs.Path;
+import jakarta.ws.rs.PathParam;
+import jakarta.ws.rs.Produces;
+import jakarta.ws.rs.core.Response;
+import jakarta.ws.rs.core.Response.Status;
+import jakarta.ws.rs.core.UriBuilder;
+import sklep.db.CustomerDAO;
+import sklep.db.DBConnection;
+import sklep.db.DBException;
+import sklep.db.OrderDAO;
+import sklep.db.RecordNotFound;
+import sklep.model.Customer;
+import sklep.model.Order;
+
+@RequestScoped
+@Path("/orders")
+@Produces({ "application/xml", "application/json" })
+@Consumes({ "application/xml", "application/json" })
+public class ROrder {
+    @GET
+    public List<Order> listAll() throws DBException {
+        try(DBConnection db = DBConnection.open()) {
+            OrderDAO orderDAO = db.orderDAO();
+            return orderDAO.readAll();
+        }
+    }
+
+    @GET
+    @Path("/{id:[0-9][0-9]*}")
+    public Response findById(@PathParam("id") final Integer id) {
+        // Klasa Response pozwala nam z pełną precyzją przygotować odpowiedź, która ma zostać odesłana klientowi.
+        // W przypadku pozytywnym (ok) zostanie odesłany obiekt przetłumaczony na XML lub JSON, a kod wynikowy to będzie 200.
+        // Ale w przypadku błędów możemy sami zdecydować co odsyłami (tutaj odpowiednie kody HTTP).		
+        try(DBConnection db = DBConnection.open()) {
+            OrderDAO orderDAO = db.orderDAO();
+            Order order = orderDAO.findById(id);
+            return Response.ok(order).build();
+        } catch (DBException e) {
+            e.printStackTrace();
+            return Response.status(Status.INTERNAL_SERVER_ERROR).build();
+        } catch (RecordNotFound e) {
+            return Response.status(Status.NOT_FOUND).build();
+        }
+    }
+
+    /*
+    // Metoda, która ma obsłużyć pobranie info o właścicielu zamówienia:
+    // /orders/1/customer
+    // W tej wersji metoda zwraca bezpośrednio dane klienta.
+    // Wada tego podejścia: ten sam rekord (konkretny klient) jest widoczny pod różnymi adresami URL.
+    @GET
+    @Path("/{id:[0-9][0-9]*}/customer")
+    public Customer getCustomer(@PathParam("id") Integer orderId) throws DBException, RecordNotFound {
+        try(DBConnection db = DBConnection.open()) {
+            OrderDAO orderDAO = db.orderDAO();
+            CustomerDAO customerDAO = db.customerDAO();
+            Order order = orderDAO.findById(orderId);
+            Customer customer = customerDAO.findByEmail(order.getCustomerEmail());
+            return customer;
+        }
+    }
+    */
+    
+    // W tej wersji w odpowiedzi na zapytanie o dane klienta, który złożył zamówienie,
+    // wyślemy przekierowanie pod adres tego klienta.
+    // To jest lepsze z punktu widzenia "dobrych praktyk REST".
+    @GET
+    @Path("/{id:[0-9][0-9]*}/customer")
+    public Response getCustomer(@PathParam("id") Integer orderId) throws DBException, RecordNotFound {
+        try(DBConnection db = DBConnection.open()) {
+            OrderDAO orderDAO = db.orderDAO();
+            Order order = orderDAO.findById(orderId);
+            
+            URI customerURI = UriBuilder.fromResource(RCustomer.class)
+                    .path("/{email}")
+                    .build(order.getCustomerEmail());
+            return Response.seeOther(customerURI).build();
+        }
+    }
+}

PC27-RestSerwer/src/main/java/sklep/rest/RProducts.java

@@ -2,6 +2,8 @@ package sklep.rest;
 
 import jakarta.ws.rs.*;
 import jakarta.ws.rs.core.MediaType;
+import jakarta.ws.rs.core.Response;
+import jakarta.ws.rs.core.UriBuilder;
 import sklep.db.DBConnection;
 import sklep.db.DBException;
 import sklep.db.ProductDAO;
@@ -9,8 +11,20 @@ import sklep.db.RecordNotFound;
 import sklep.model.Product;
 
 import java.math.BigDecimal;
+import java.net.URI;
 import java.util.List;
 
+/* W tej klasie wejdziemy nawet do wnętrza produktów i udostępnimy osobno cenę
+ * /products/2/price
+ * W praktyce nie robi się tego zbyt często, ale tu zobaczymy jako przykład możliwości.
+ *
+ * To od programisty (twórcy usługi) zależy jakie adresy i jakie operacje pod tymi adresami udostępnia.
+ *
+ * Ta klasa udostępnia (i przyjmuje) dane produktów w różnych formatach.
+ * Gdy w Produces jest wiele formatów, to klient może wybrać za pomocą nagłówka Accept
+ * Gdy w Consumes jest wiele formatów, to klient może przysłać dane w dowolnym z nich (nagłówek Content-Type)
+ */
+
 @Path("/products")
 public class RProducts {
     @GET
@@ -58,14 +72,21 @@ public class RProducts {
         return "<!DOCTYPE html>\n<html><body>" + product.toHtml() + "</body></html>";
     }
 
+    // W praktyce REST metoda POST jest używana do dodawania nowych rekordów do katalogu.
+    // Może być także używana w innych celach - gdy klient ma "przysłać dane na serwer", a serwer coś z tym zrobi (podobnie jak to było w SOAP).    @POST
+    // POST w tym miejscu jest lepszy niż PUT, bo zapisując nowy rekord, nie wiemy z góry jakie będzie będzie jego ID,
+    // czyli nie wiemy, pod adresem zapisze się nowy produkt.
+    // POST potrafi "dodać rekord do katalogu".
     @POST
     @Consumes({"application/json", "application/xml"})
-    public void saveProduct(Product product) throws DBException {
+    public Response saveProduct(Product product) throws DBException {
         try(DBConnection db = DBConnection.open()) {
             ProductDAO productDAO = db.productDAO();
             productDAO.save(product);
             db.commit();
         }
+        URI uri = UriBuilder.fromResource(RProducts.class).path("/{id}").build(product.getProductId());
+        return Response.created(uri).build();
     }
 
     // Nie praktykuje się tego zbyt często, ale można zdefiniować dedykowane metody dające dostęp do poszczególnych pól obiektu (aby nie transferować całego rekordu, gdy potrzebna tylko jedna informacja)
@@ -77,6 +98,10 @@ public class RProducts {
         return oneProduct(productId).getPrice();
     }
 
+    // Operacja HTTP PUT zapisuje zasób pod podanym adresem.
+    // W zapytaniach typu PUT i POST klient wysyła dane na serwer (treść zapytania: "body" / "entity" / "content" ...)
+    // W JAX-RS metoda może posiadać tylko jeden parametr bez adnotacji i to właśnie przez ten parametr przekazywana jest treść zapytania
+    // (te dane, które przysłał klient). Format tych danych opisuje adnotacja @Consumes
     @PUT
     @Path("/{id}/price")
     @Consumes({"application/json", "text/plain"})
@@ -90,6 +115,30 @@ public class RProducts {
         }
     }
 
+    // PUT vs POST
+    // PUT powinniśmy używać wtedy, gdy z góry wiadomo, pod jakim adresem zostaną zapisane dane.
+    // W praktyce PUT używa się najczęściej do aktualizacji istniejących danych, ale teoretycznie PUT
+    // można też użyć do zapisania nowych danych pod konkretnym adresem.
+    // Gdy wyślemy dane za pomocą PUT pod adres, to następnie GET z tego samego adresu powinien odczytać dane, które wysłał PUT (być może w innym formacie).
+
+    // POST używajmy wtedy, gdy nie wiemy z góry pod jakim adresem dane zostaną zapisane, np. gdy id rekordu jest generowane z sekwencji.
+    // Taka metoda powinna dać w odpowiedzi informację o ID utworzonego rekordu.
+    // Kilka możliwości:
+    // 1) odesłanie uzupełnionego rekordu - trochę niewydajne, ale wygodne
+    // 2) minimalny dokumencik JSON, w którego wnętrzu jest zawarta ta informacja (tak robi wiele usług w praktyce, np. PayU)
+    // 3) (teraz w tej wersji) - odesłać odpowiedź typu Created z nagłówkiem Location - najlepsze z punktu widzenia standardów/dobrych praktyk
+    // Aby zwracać taie "techniczne" odpowiedzi, używa się klasy Response.
+
+    @DELETE
+    @Path("/{id}")
+    public void usun(@PathParam("id") int productId) throws DBException, RecordNotFound {
+        try(DBConnection db = DBConnection.open()) {
+            ProductDAO productDAO = db.productDAO();
+            productDAO.delete(productId);
+            db.commit();
+        }
+    }
+
     @GET
     @Path("/{id}/photo")
     // przykładowo /api/products/3/photo