refactored RestTemplate

client-impl/src/main/java/ru/dragonestia/picker/api/impl/repository/InstanceRepositoryImpl.java

@@ -1,5 +1,6 @@
 package ru.dragonestia.picker.api.impl.repository;
 
+import com.fasterxml.jackson.core.type.TypeReference;
 import ru.dragonestia.picker.api.impl.util.RestTemplate;
 import ru.dragonestia.picker.api.impl.util.type.HttpMethod;
 import ru.dragonestia.picker.api.model.entity.EntityId;
@@ -21,22 +22,22 @@ public class InstanceRepositoryImpl implements InstanceRepository {
 
     @Override
     public List<InstanceId> allInstancesIds() {
-        return Arrays.stream(rest.query("/instances", HttpMethod.GET, String[].class))
+        List<String> id = rest.queryWithRequest("/instances", HttpMethod.GET);
-                .map(InstanceId::of)
+        return id.stream().map(InstanceId::of).toList();
-                .toList();
     }
 
     @Override
     public Instance getInstance(InstanceId id) {
-        return rest.query("/instances/target/" + id.getValue(), HttpMethod.GET, ResponseObject.RInstance.class).convert();
+        ResponseObject.RInstance instance = rest.queryWithRequest("/instances/target/" + id.getValue(), HttpMethod.GET);
+        return instance.convert();
     }
 
     @Override
     public Map<InstanceId, Instance> getInstances(Collection<InstanceId> ids) {
         var map = new HashMap<InstanceId, Instance>();
-        Arrays.stream(rest.query("/instances/target/list", HttpMethod.GET, ResponseObject.RInstance[].class, params -> {
+        rest.queryWithRequest("/instances/target/list", HttpMethod.GET, new TypeReference<List<ResponseObject.RInstance>>() {}, params -> {
             params.put("id", String.join(",", ids.stream().map(InstanceId::getValue).toList()));
-        })).map(ResponseObject.RInstance::convert).forEach(instance -> map.put(instance.id(), instance));
+        }).stream().map(ResponseObject.RInstance::convert).forEach(instance -> map.put(instance.id(), instance));
         return map;
     }
 
@@ -64,7 +65,7 @@ public class InstanceRepositoryImpl implements InstanceRepository {
 
     @Override
     public ResponseObject.PickedRoom pickRoom(InstanceId id, Collection<EntityId> entities, boolean dontReturnEntities) {
-        return rest.queryPostWithBody("/instances/target/" + id.getValue() + "/pick", ResponseObject.PickedRoom.class, params -> {
+        return rest.queryPostWithBodyRequest("/instances/target/" + id.getValue() + "/pick", params -> {
             params.put("dontReturnEntities", Boolean.toString(dontReturnEntities));
         }, String.join(",", entities.stream().map(EntityId::getValue).toList()));
     }

client-impl/src/main/java/ru/dragonestia/picker/api/impl/repository/RoomRepositoryImpl.java

@@ -1,5 +1,6 @@
 package ru.dragonestia.picker.api.impl.repository;
 
+import com.fasterxml.jackson.core.type.TypeReference;
 import ru.dragonestia.picker.api.impl.util.RestTemplate;
 import ru.dragonestia.picker.api.impl.util.type.HttpMethod;
 import ru.dragonestia.picker.api.model.instance.InstanceId;
@@ -20,22 +21,22 @@ public class RoomRepositoryImpl implements RoomRepository {
 
     @Override
     public List<RoomId> allRoomsIds(InstanceId instanceId) {
-        return Arrays.stream(rest.query("/instances/target/%s/rooms".formatted(instanceId.getValue()), HttpMethod.GET, String[].class))
+        List<String> id = rest.queryWithRequest("/instances/target/%s/rooms".formatted(instanceId.getValue()), HttpMethod.GET);
-                .map(RoomId::of)
+        return id.stream().map(RoomId::of).toList();
-                .toList();
     }
 
     @Override
     public Room getRoom(InstanceId instanceId, RoomId roomId) {
-        return rest.query("/instances/target/%s/rooms/target/%s".formatted(instanceId.getValue(), roomId.getValue()), HttpMethod.GET, ResponseObject.RRoom.class).covert();
+        ResponseObject.RRoom room = rest.queryWithRequest("/instances/target/%s/rooms/target/%s".formatted(instanceId.getValue(), roomId.getValue()), HttpMethod.GET);
+        return room.covert();
     }
 
     @Override
     public Map<RoomId, Room> getRooms(InstanceId instanceId, Collection<RoomId> rooms) {
         var map = new HashMap<RoomId, Room>();
-        Arrays.stream(rest.query("/instances/target/%s/rooms/list".formatted(instanceId.getValue()), HttpMethod.GET, ResponseObject.RRoom[].class, params -> {
+        rest.queryWithRequest("/instances/target/%s/rooms/list".formatted(instanceId.getValue()), HttpMethod.GET, new TypeReference<List<ResponseObject.RRoom>>() {}, params -> {
             params.put("id", String.join(",", rooms.stream().map(RoomId::getValue).toList()));
-        })).map(ResponseObject.RRoom::covert).forEach(room -> map.put(room.id(), room));
+        }).stream().map(ResponseObject.RRoom::covert).forEach(room -> map.put(room.id(), room));
         return map;
     }
 

client-impl/src/main/java/ru/dragonestia/picker/api/impl/util/RestTemplate.java

@@ -2,6 +2,7 @@ package ru.dragonestia.picker.api.impl.util;
 
 import com.fasterxml.jackson.annotation.JsonAutoDetect;
 import com.fasterxml.jackson.core.JsonProcessingException;
+import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import okhttp3.*;
 import org.jetbrains.annotations.ApiStatus.Internal;
@@ -48,67 +49,40 @@ public class RestTemplate {
     }
 
     public void query(String uri, HttpMethod method, ParamsConsumer paramsConsumer) {
-        var request = client.prepareRequestBuilder(uri + queryEncode(paramsConsumer))
+        execute(client.prepareRequestBuilder(uri + queryEncode(paramsConsumer))
                 .method(method.name(), method == HttpMethod.GET? null : new FormBody.Builder().build())
-                .build();
+                .build());
-
-        try (var response = httpClient.newCall(request).execute()) {
-            checkResponseForErrors(response);
-        } catch (JsonProcessingException ex) {
-            throw new RuntimeException("Json processing error", ex);
-        } catch (IOException ex) {
-            throw new RuntimeException(ex);
-        }
     }
 
-    public <T> T query(String uri, HttpMethod method, Class<T> clazz) {
+    public <T> T queryWithRequest(String uri, HttpMethod method) {
-        return query(uri, method, clazz, ParamsConsumer.NONE);
+        return queryWithRequest(uri, method, ParamsConsumer.NONE);
     }
 
-    public <T> T query(String uri, HttpMethod method, Class<T> clazz, ParamsConsumer paramsConsumer) {
+    public <T> T queryWithRequest(String uri, HttpMethod method, ParamsConsumer paramsConsumer) {
-        var request = client.prepareRequestBuilder(uri + queryEncode(paramsConsumer))
+        return queryWithRequest(uri, method, new TypeReference<>(){}, paramsConsumer);
+    }
+
+    public <T> T queryWithRequest(String uri, HttpMethod method, TypeReference<T> type, ParamsConsumer paramsConsumer) {
+        return execute(client.prepareRequestBuilder(uri + queryEncode(paramsConsumer))
                 .method(method.name(), method == HttpMethod.GET? null : new FormBody.Builder().build())
-                .build();
+                .build(),
-
+                type);
-        try (var response = httpClient.newCall(request).execute()) {
-            checkResponseForErrors(response);
-
-            return json.readValue(new String(Objects.requireNonNull(response.body()).bytes(), StandardCharsets.UTF_8), clazz);
-        } catch (JsonProcessingException ex) {
-            throw new RuntimeException("Json processing error", ex);
-        } catch (IOException ex) {
-            throw new RuntimeException(ex);
-        }
     }
 
-    public <T> T queryPostWithBody(String uri, Class<T> clazz, ParamsConsumer paramsConsumer, String body) {
+    public <T> T queryPostWithBodyRequest(String uri, ParamsConsumer paramsConsumer, String body) {
-        var request = client.prepareRequestBuilder(uri + queryEncode(paramsConsumer))
+        return queryPostWithBodyRequest(uri, new TypeReference<>() {}, paramsConsumer, body);
+    }
+
+    public <T> T queryPostWithBodyRequest(String uri, TypeReference<T> type, ParamsConsumer paramsConsumer, String body) {
+        return execute(client.prepareRequestBuilder(uri + queryEncode(paramsConsumer))
                         .post(RequestBody.create(body, MediaType.get("text/plain")))
-                .build();
+                        .build(), type);
-
-        try (var response = httpClient.newCall(request).execute()) {
-            checkResponseForErrors(response);
-
-            return json.readValue(new String(Objects.requireNonNull(response.body()).bytes(), StandardCharsets.UTF_8), clazz);
-        } catch (JsonProcessingException ex) {
-            throw new RuntimeException("Json processing error", ex);
-        } catch (IOException ex) {
-            throw new RuntimeException(ex);
-        }
     }
 
     public void queryPostWithBody(String uri, ParamsConsumer paramsConsumer, String body) {
-        var request = client.prepareRequestBuilder(uri + queryEncode(paramsConsumer))
+        execute(client.prepareRequestBuilder(uri + queryEncode(paramsConsumer))
                 .post(RequestBody.create(body, MediaType.get("text/plain")))
-                .build();
+                .build());
-
-        try (var response = httpClient.newCall(request).execute()) {
-            checkResponseForErrors(response);
-        } catch (JsonProcessingException ex) {
-            throw new RuntimeException("Json processing error", ex);
-        } catch (IOException ex) {
-            throw new RuntimeException(ex);
-        }
     }
 
     private String queryEncode(ParamsConsumer paramsConsumer) {
@@ -124,6 +98,28 @@ public class RestTemplate {
         return "?" + String.join("&", pairs);
     }
 
+    private void execute(Request request) {
+        try (var response = httpClient.newCall(request).execute()) {
+            checkResponseForErrors(response);
+        } catch (JsonProcessingException ex) {
+            throw new RuntimeException("Json processing error", ex);
+        } catch (IOException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+
+    private <T> T execute(Request request, TypeReference<T> type) {
+        try (var response = httpClient.newCall(request).execute()) {
+            checkResponseForErrors(response);
+
+            return json.readValue(new String(Objects.requireNonNull(response.body()).bytes(), StandardCharsets.UTF_8), type);
+        } catch (JsonProcessingException ex) {
+            throw new RuntimeException("Json processing error", ex);
+        } catch (IOException ex) {
+            throw new RuntimeException(ex);
+        }
+    }
+
     private void checkResponseForErrors(Response response) throws IOException {
         var code = response.code();
         var statusCode = code / 100;