We Keep Coding

How to get Calendar field from REST request in RestController in SpringBoot?

I am getting date in POST request in #RestController with Json like this:
{ "date":"2016-01-28" }
How can I get object with type java.util.Calendar?
Usually I use java.util.Date, but almost all methods are deprecated.
What Jackson annotation possible to use to get Calendar?
I tried to use
public class Test {
#JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd")
Calendar date;
}
but get null

You can use annotation #DateTimeFormat. According to Spring docs it's applicable to java.util.Calendar.
#PostMapping("/somemapping")
public void date(#RequestParam("date") #DateTimeFormat(pattern = "yyyy-MM-dd") Calendar date) {
//some other processing code
}

{
"calendar": 1558347802873
}
Sample json request
just pass date in number format
use below object
import java.util.Calendar;
public class TestCal {
private Calendar calendar;
public Calendar getCalendar() {
return calendar;
}
public void setCalendar(Calendar calendar) {
this.calendar = calendar;
}
}
sample spring Controller
#PostMapping("/testCal")
public void testCal(#RequestBody TestCal test) {
// do your stuff
test.getCalendar();
}

I would suggest using a java.util.Date instead of a Calendar. At least in your repository object. If you need the additional functionality of a Calendar you can create an instance as demonstrated by #Hamza.
Calendar is a pretty heavy-weight class. No need to create a new instance of it considering the tiny amount of data you are storing.
You can pick out the date from another class that operates on it to provide you the additional functionality as required.

Bizzare Issue With Java Timestamp

I am working on an application which sends an object to a server for processing. The object is sent in JSON format using Spring.
My issue is that all the fields are passed correctly - EXCEPT for the Date variables. They show up as a completely different value, and I am stumped as to why.
Here is an abbreviated version of the object that is being passed:
public class TransactionParameters {
public Date startDate;
public Date endDate;
public List<String> transactionCodes;
public Date getStartDate() {
return startDate;
}
public void setStartDate(Date startDate) {
this.startDate = startDate;
}
public Date getEndDate() {
return endDate;
}
public void setEndDate(Date endDate) {
this.endDate = endDate;
}
public List<String> getTransactionCodes() {
return transactionCodes;
}
public void setTransactionCodes(List<String> transactionCodes) {
this.transactionCodes = transactionCodes;
}
}
Here is the JSON created:
{"transactionCodes":["195"],"startDate":1524456000000,"endDate":1524456000000}
Here is the client code:
String responseString =
restTemplate.postForObject("http://localhost:9080/app/transaction"
+ "testUser123", transactionParameters, String.class);
Here is the server code:
#ApiOperation(value="Get Transactions for Customer")
#POST
#Produces({ MediaType.APPLICATION_JSON })
#Consumes(MediaType.APPLICATION_JSON)
#Path("/customerAccountTransactions/{customerCode: [a-zA-Z0-9]+}")
#RequestMapping(value ="/transaction/{customerCode: [a-zA-Z0-9]+}", method=RequestMethod.POST, produces=MediaType.APPLICATION_JSON, consumes=MediaType.APPLICATION_JSON)
#ApiImplicitParams(#ApiImplicitParam(name = AUTHORIZATION, value = AUTHORIZATION, required = true, dataType = STRING, paramType = HEADER))
public Response getAccountTransactionsForCustomer(#PathVariable(CUSTOMER_CODE) #PathParam(CUSTOMER_CODE) final String customerCode, TransactionParameters transactionParameters) throws IntegrationException {
LOGGER.info("getAccountTransactionsForCustomer()");
Response response = null;
try {
final AccountTransactionsBean atb = getTransactions(customerCode, transactionParameters)
response = ResponseBuilder.buildSuccessResponse(atb);
} catch (final NotAuthorizedException nae) {
response = ResponseBuilder.buildNotAuthorizedResponse();
}
return response;
}
But here's my issue - When I put a breakpoint at where the client calls the endpoint, the date is correct.
However, the date is wildly incorrect as it enters the server's endpoint.
All the the other variables in the TransactionParameters bean are correct. I have also replicated this call using SOAP UI, to rule out any issues with the client, and the issue still persists.
Can anyone offer any suggestions?
Thanks in advance for any help.

The reason for this issue is that Date and String are two different data types. When you are converting your Object to JSON, it is directly converting the date to String and in that process losing its essence.
In order to solve this, you need to tell the code that those particular fields are dates and thus, need to be retained as it is. You can do that by using annotations in your POJO:
Example:
#JsonFormat(shape = JsonFormat.Shape.STRING, pattern = "yyyy-MM-dd HH:mm:ss.SSSZ")
private Date changeTimestamp;
You can use the above syntax and then change the pattern as per your need.

Disclaimer admittedly I don't know much about Spring REST so I can only give you general pointers, but this really does seem like a de-serialization issue.
Some general things to consider:
Make sure the server and client have the same settings for serializing/de-serializing.
Make sure they are running the same versions of Spring REST and Jackson.
Set the JVM arg -Djavax.net.debug=all and run again to look at what is really being sent/recieved.
Being Spring REST this uses Jackson under the hood right?
Try explicitly annotating your dates and see if that helps:
public class TransactionParameters {
#JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
public Date startDate;
#JsonFormat(pattern="yyyy-MM-dd HH:mm:ss")
public Date endDate;
// ...
}

You probably have to either add or remove the milliseconds to get the conversion to work correctly. 000

Spring hibernate unwanted timezone adjustment

I have a simple service that takes a date in as a String (amongst other fields) and saves it to a mySql database. I am using Spring Boot with Hibernate.
If I post JSON with {"expenseDate":"04/02/2017"} the date that is being captured after the jackson mapping is "2017-04-01 19:00:00".
Incidentally, if I look at the row in the database, the date is "2017-04-02" just as I would expect. When I query the service, the date that comes back in the json is correct, but when I dump out the rows from the database, they all return the correct day minus six hours.
I live in the central time zone, so my guess is that the date in the database is UTC and Spring is taking six hours off for being in central time.
Controller:
#PostMapping("/expenses")
public ResponseEntity<Expense> submitExpense(#RequestBody Expense expense) throws BadHttpRequest {
expenseService.saveExpense(expense);
return new ResponseEntity<>(expense, HttpStatus.CREATED);
}
Entity:
#Entity
public class Expense {
#Id
#GeneratedValue
Integer id;
Double cost;
String location;
String expenseType;
String description;
#JsonFormat(pattern = "MM/dd/yyyy")
Date expenseDate;
I tried #JsonFormat(pattern = "MM/dd/yyyy", timezone = "UTC") on the date field but it changed nothing.
I also tried constructing the date from the view using the date parts and passing it as a long down to the service, but the result is the same. clearly I'm missing something excruciatingly vital and, likely, simple.
any thoughts?

You should set the "timezone" to whatever timezone you expect the incoming date to be in.
public class Data {
#JsonFormat(pattern = "MM/dd/yyyy", timezone="GMT-04:00")
Date date;
public Date getDate() {
return date;
}
public void setDate(Date date) {
this.date = date;
}
}
public class Main {
public static void main(String[] args) throws JsonParseException, JsonMappingException, IOException {
ObjectMapper mapper = new ObjectMapper();
Data data = mapper.readValue("{\"date\" : \"04/02/2017\"}", Data.class);
System.out.println(data.date);
}
}
Output
Sun Apr 02 00:00:00 EDT 2017
// I am located in EDT
If I assume the incoming date is in UTC
#JsonFormat(pattern = "MM/dd/yyyy", timezone="UTC")
Date date;
Output
Sat Apr 01 20:00:00 EDT 2017
By default it appears to be considering the date as UTC. In your case if you are in CST you should consider setting Central Time timezone (I believe US/Central).
Note
If your date inputs can come from clients in different timezones that will be another discussion. You will most likely have to define a contract that client enters a date in a particular timezone OR explicitly specify a timezone as additional input OR have your client side (if one exists) do a conversion to a specific timezone that your server-side expects.

There is a database connection url parameter called serverTimezone you may need put.

How to compare Google Appengine DateTime against a Date object in Java?

I am new to Google Appengine. In my application, the datastore entities store a java.util.Date object. I want to query the datastore to return all the entities before a particular time. My code for this is :
Date date = new Date();
Query<Event> query = ofy().load().type(Event.class).order("date");
query = query.filter("date <", date);
which upon execution, gives the error : Invalid date/time format: Sat Apr 04 00:40:22 IST 2015
If this format is invalid, which format do I need to use to query?

Here is a simple code
import java.util.Date;
import com.googlecode.objectify.annotation.Entity;
import com.googlecode.objectify.annotation.Id;
import com.googlecode.objectify.annotation.Index;
#Entity
public class EntityDate {
public EntityDate() {
// Objectify needed
}
#Id
private Long id;
#Index
public Date date;
}
and here the code which makes the query
Date date = new Date();
Objectify ofy = ObjectifyService.ofy();
ObjectifyService.register(EntityDate.class);
EntityDate entityDate = new EntityDate();
entityDate.date = date;
ofy.save().entities(entityDate);
Query<EntityDate> ofyQuery = ofy.load().type(EntityDate.class).order("date");
ofyQuery = ofyQuery.filter("date <", date);
List<EntityDate> list = ofyQuery.list();
Logger.getLogger("EntityDate").info(list.toString());
The entities are correctly saved
and the query provides the 4 results
[EntityDate#6780874d, EntityDate#27330551, EntityDate#6a21cf2, EntityDate#7d1a5744]
The default toString() of the class is a bit ugly, but it makes the point about the query correctly executed.
Can you provide the source of your Event class and the continuation of your code which execute the query?

Mapping Java Date Object to XML Schema datetime format

I am having some problem mapping my Java Data Type to standard Schema Date data type.
I have a simple class that I annotated like this. The period instance variable is of Java Date object type.
#XmlAccessorType(value = XmlAccessType.NONE)
public class Chart {
#XmlElement
private double amount;
#XmlElement
private double amountDue;
#XmlElement
private Date period;
//constructor getters and setters
}
Here is my Web Service
#WebService
public class ChartFacade {
#WebMethod
public Chart getChart() throws ParseException {
SimpleDateFormat df = new SimpleDateFormat("yyyy-mm-dd");
Chart chart = new Chart(20.0,20.5, df.parse("2001-01-01"));
return chart;
}
}
My problem is it returns the date data in a format not according to what I am expecting.
<S:Envelope xmlns:S="http://schemas.xmlsoap.org/soap/envelope/">
<S:Body>
<ns2:getChartResponse xmlns:ns2="http://ss.ugbu.oracle.com/">
<return>
<amount>20.0</amount>
<amountDue>20.5</amountDue>
**<period>2001-01-01T00:01:00+08:00</period>**
</return>
</ns2:getChartResponse>
</S:Body>
</S:Envelope>
I wanted the period element to be returned like this
<period>2001-01-01</period>
Is there any way I can achieve this?

You can do the following to control the schema type:
#XmlElement
#XmlSchemaType(name="date")
private Date period;
For More Information:
http://bdoughan.blogspot.com/2011/01/jaxb-and-datetime-properties.html

Use #XmlJavaTypeAdapter annotation and you can marshal/unmarshal your fields any way you want.
Cannot tell though if it's the simplest way.
And note also that it may harm interoperability with any code that would try to use your WSDL. The programmers for that other code would see xsd:string as the field type, and therefore will have to do formatting and parsing manually (just like you do, yes), introducing who knows how many bugs. So please consider if the xsd:date a bad choice really.
Stolen from here:
#XmlJavaTypeAdapter(value=DateAdapter.class, type=Date.class)
Date someDate;
...
public class DateAdapter extends XmlAdapter<String, Date> {
// the desired format
private String pattern = "MM/dd/yyyy";
public String marshal(Date date) throws Exception {
return new SimpleDateFormat(pattern).format(date);
}
public Date unmarshal(String dateString) throws Exception {
return new SimpleDateFormat(pattern).parse(dateString);
}
}
UPDATE: as was mentioned by #Blaise Doughan, a much shorter way is to annotate the date with
#XmlSchemaType("date")
Date someDate;
Despite it is still not clear why timezone information is not generated for the date, this code works in practice and requires much less typing.

Your Chart constructor seems to be parsing the formatted date string back into a Date, which is then being serialized using the default format to the XML response.
I guess using private String period; (and fixing the constructors) should work