We Keep Coding

How to get data from query string in Java Spring boot REST

We have a requirement to read data after '?' in service-url in Spring boot REST API.
For example, We exposed a service called sampleService and GET URL for this is
http://www.myservices.com/api/sampleServce
And clients will pass the data as http://www.myservices.com/api/sampleServce?dynamicdata
So we have to read that "dynamicdata" in my sample service and process.
Please let me know the possibilities.

GET: http://localhost:8080/api/foos?id=abc here the query string is id=abc . Now to extract the value of id, you can use the code something like this.
#GetMapping("/api/foos")
#ResponseBody
public String getFoos(#RequestParam String id) {
return "ID: " + id;
}
GET: http://www.myservices.com/api/sampleServce?dynamicdata is incorrect. Either it should be http://www.myservices.com/api/sampleServce/dynamicdata (PathVariable) or http://www.myservices.com/api/sampleServce?title=dynamicdata (RequestParam)
GET: http://www.myservices.com/api/sampleServce/dynamicdata to extract dynamicdata, you can use code something like
#GetMapping("/api/sampleServce/{id}")
#ResponseBody
public String getFooById(#PathVariable String id) {
return "ID: " + id; // here id = "dynamicdata"
}
GET: http://www.myservices.com/api/sampleServce?title=dynamicdata to extract title, you can use code something like
#GetMapping("/api/sampleServce")
#ResponseBody
public String getFoos(#RequestParam String title) {
return "title: " + title; // title="dynamicdata"
}

dynamicdata is path param, it cannot be placed after ?. It should be something like this:
http://www.myservices.com/api/dynamicdata/sampleServce
Check when and how to use query or path parameters

Accept dynamic data through request param:
#GetMapping("/api/sampleServce")
public void test(#RequestParam Map<String, String> dynamicdata) {
System.out.println(dynamicdata.keySet()); //http://localhost:9001/dag-backend/api/sampleServce?test&test11
Optional<String> data = dynamicdata.keySet().stream().findFirst();
String value = data.isPresent() ? data.get() : null;
System.out.println(value); //http://localhost:9001/dag-backend/api/sampleServce?test
}
URLs:
http://www.myservices.com/api/sampleServce?dynamicdata
http://www.myservices.com/api/sampleServce?dynamicdata&12344&1212
http://www.myservices.com/api/sampleServce?$999900&124434&234

You can add an HttpServletRequest object to your mapped method signature:
#RequestMapping("/api/sampleServce")
public Object sampleServce (HttpServletRequest request) {
//print everything after the question mark:
System.out.println("queryString: " + request.getQueryString());
//print key value pairs:
Enumeration<String> params = request.getParameterNames();
while(params.hasMoreElements()){
String paramName = params.nextElement();
String paramValue = request.getParameter(paramName);
System.out.println("name: " + paramName);
System.out.println("value: " + paramValue);
}
return request.getQueryString();
}

Request Specification is changing Object to String for query params

In the request specification trying to add query params using the Map<String, Object> but after the request spec gets generated any value in th Object is getting converted to String even if the value passed in Int or anything else
public Response postCall(String body, Map<String, Object> queryParams, int id1, int id2) {
RequestSpecification requestSpecification = genericRequestBuilder.getRequestSpecificationObject(); // setting the basepath and portno. and login
// The ids can be send via the queryParams map but in both the cases either in map or individual query, the values are getting converted into String
requestSpecification.queryParams(queryParams);
requestSpecification.queryParam("id1",id1);
requestSpecification.queryParam("id2",id2);
requestSpecification.body(body);
Response response =
requestSpecification.post(uri);
return response;
}
The query parameter changes as noticed in the debug mode:
result = {LinkedHashMap#4245} size = 6
"stringId1" -> "kmpySmUISimoRrJL6NL73w"
"stringId2" -> "YOgB1-WjSKyZWoCkuY7kBA"
"projectIdentifier" -> "1234"
"requestGuid" -> "1594123919225"
"id1" -> "1"
"id2" -> "1"
All the fields are string except the id1 and id2

getting a string payload to curl

I am trying to curl a string payload and I need it to throw an error if it contains certain parameters.
Here is my code:
#RequestMapping(value = "/payload3", method = RequestMethod.POST, produces = {"application/json"})
public String payloader3(#RequestParam Map<String, String> params ) throws IOException{
#NotNull
String type = mockendpoint.Payload3();
return type;
}

You need to change your return type so that you return a ResponseEntity.
In the event of a successful request, you return a HTTP 200, with the required response body:
return ResponseEntity.ok(json);
And in the event your parameter map size is not equal to your desired value, you can return a HTTP 400, with an appropriate error message:
return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(badRequestBody);

You can consume the input as a String instead of Map(that you currently have) and do a split on it with your delimeter |. If the returned array size is not 18 then throw an exception?

Store #PathParam values from REST call in a list or array

My function looks like this:
#PUT
#Path("property/{uuid}/{key}/{value}")
#Produces("application/xml")
public Map<String,ValueEntity> updateProperty(#Context HttpServletRequest request,
#PathParam("key") String key,
#PathParam("value") String value,
#PathParam("uuid") String uuid) throws Exception {
...
}
I have to modify it, so it accepts indefinite(or many) list of key-value pairs from REST call, something like
#Path("property/{uuid}/{key1}/{value1}/{key2}/{value2}/{key3}/{value3}/...")
Is it possible to store them in an array or list, so I do not list dozens of #PathParams and parameters, to avoid this:
#PathParam("key1") String key1,
#PathParam("key2") String key2,
#PathParam("key3") String key3,

Might be a good opportunity to rethink this design. By using /s, we are in a way signifying, with each / that we are trying to locate a different resource. Key/Value pairs (in the context of the URL) are mainly for query parameters or matrix parameters.
If /property/{uuid} is the path to a main resource, and we just want to offer some parameters to the client for accessing this resource, then we could allow matrix parameters or query parameters
Matrix Parameters (in a request url) will look something like
/12345;key1=value1;key2=value2;key3=value3
A resource method to obtain the values might look something like
#GET
#Path("/property/{uuid}")
public Response getMatrix(#PathParam("uuid") PathSegment pathSegment) {
StringBuilder builder = new StringBuilder();
// Get the {uuid} value
System.out.println("Path: " + pathSegment.getPath());
MultivaluedMap matrix = pathSegment.getMatrixParameters();
for (Object key : matrix.keySet()) {
builder.append(key).append(":")
.append(matrix.getFirst(key)).append("\n");
}
return Response.ok(builder.toString()).build();
}
See PathSegment
Query Parameters (in a request url) might look something like
/12345?key1=value1&key2=value2&key3=value3
A resource method to obtain the values might look something like
#GET
#Path("/property/{uuid}")
public Response getQuery(#PathParam("uuid") String uuid,
#Context UriInfo uriInfo) {
MultivaluedMap params = uriInfo.getQueryParameters();
StringBuilder builder = new StringBuilder();
for (Object key : params.keySet()) {
builder.append(key).append(":")
.append(params.getFirst(key)).append("\n");
}
return Response.ok(builder.toString()).build();
}
See UriInfo
The difference is that Matrix parameters can be embedded into path segments, while query parameters must be placed at the end of the URL. You can also notice a little difference in syntax.
Some Resources
Query String (Wikipedia)
When to use query parameters versus matrix parameters?
URL matrix parameters vs. request parameters
UPDATE
Also looking at the PUT in you method signature, it appears you are trying update a resource using the path as the values for which you are trying to update, as I don't see any parameters in your method for an entity body. When PUTting, you should be sending the representation in the the entity body, not as as path segments or parameters.

A workaround:
#Path("/foo/bar/{other: .*}
public Response foo(#PathParam("other") VariableStrings vstrings) {
String[] splitPath = vstrings.getSplitPath();
}
VariableStrings class:
public class VariableStrings {
private String[] splitPath;
public VariableStrings(String unparsedPath) {
splitPath = unparsedPath.split("/");
}
}
Path segment sequence to vararg array in JAX-RS / Jersey?
Another example where you map the optional parameter to a Map:
#GET
# Produces({"application/xml", "application/json", "plain/text"})
# Path("/location/{locationId}{path:.*}")
public Response getLocation(#PathParam("locationId") int locationId, #PathParam("path") String path) {
Map < String, String > params = parsePath(path);
String format = params.get("format");
if ("xml".equals(format)) {
String xml = "<location<</location<<id<</id<" + locationId + "";
return Response.status(200).type("application/xml").entity(xml).build();
} else if ("json".equals(format)) {
String json = "{ 'location' : { 'id' : '" + locationId + "' } }";
return Response.status(200).type("application/json").entity(json).build();
} else {
String text = "Location: id=" + locationId;
return Response.status(200).type("text/plain").entity(text).build();
}
}
private Map < String, String > parsePath(String path) {
if (path.startsWith("/")) {
path = path.substring(1);
}
String[] pathParts = path.split("/");
Map < String, String > pathMap = new HashMap < String, String > ();
for (int i = 0; i < pathParts.length / 2; i++) {
String key = pathParts[2 * i];
String value = pathParts[2 * i + 1];
pathMap.put(key, value);
}
return pathMap;
}

Spring 3 MVC jQuery POST submit variable number of data

In the client side, I am using jQuery to submit a number of pairs to the server.
But the number of entries is variable.
For example:
1: 1.55
2: 2.33
3: 5.66
In the server side, how should I design the Controller so that it could take the POST data and store it in a List / Map?
Something like:
#RequestMapping ("/submitdata")
public #ResponseBody String changeData (???) {
// changes to database
return "Success";
}
EDIT:
I got the answer:
#RequestMapping ("/submitdata")
public #ResponseBody String changeData (#RequestParam Map <String, String> params) {
for (Map.Entry<String, String> entry: params.entrySet()) {
System.out.println ("Key = " + entry.getKey() + " Value = " + entry.getValue());
}
// changes to database
return "Success";
}

You can use #RequestParam annotation to grab POST data

you can use
#ResponseBody Map<String,String> udpateIdentification(HttpServletResponse response, #ModelAttribute("jspObject") Test test,BindingResult result)
The values will be get bind to the ModelAttribute if you have used that in your JSP