A brief introduction on java.time package introduced in Java 8

 



If you have ever worked with the java.util.Date data types for java web applications, some or the other time you might have faced the time zone issues.


Lets take the below example to understand one of the issue associated with this data type


You have a web application which the user needs to enter the date of birth in UI, and the backend API persists this into DB


Lets say User has born on June 15th 1978, 8:30PM in New Jersey, USA. lets say now the user is present in Japan his DOB is not going to change according to the Japan timezone. It is still the same fact that he was born on the date, time and location.


But if we use the java.util.Date data type for the DOB in java application, when ever the input date converts into Date data type in the backend java application java.util.Date will actually adds the timezone based on the location the application is running, for example in the above scenario if user sends the input as 1978-06-15T22:30:00 to the backend, and the backend application is running on Japan timezone our Date class will add timezone and when you access Date.toString will returns you the 1978-06-16T09:30:00 which means the DOB changed from June 15 to June 16th.


There are some workarounds we have to solve the above issue, before the java 8 we have third party libraries called Joda Time to solve the date and time issues associated with java.util.Date, but starting from java 8, new classes are introduced in java.time package which resolves so many issues associate with the java.util.Date.


All the classes in the java.time package that starts with Local** like LocalDate, LocalTime, LocalDateTime stores the date without adding the timezone


It has ZoneDateTime, Instant to deal with the dates with timezone.


Following are the brief introduction to the classes present in the java.time package.


Clock: provides the access to the current instant, date and time using the timezone

How to get Clock object

Clock.systemDefaultZone() — returns the clock representing the server timezone

Clock.systemUTC() — will return the clock representing the UTC timezone

Clock.system(ZoneId) — will return the clock with the provided zoneId

instant methods:

Clock.instant() — will return the Instant object

Clock.millis() — will return the milliseconds from the java epoch (since January 1st 1970)


Duration: represents the amount of time like for example 1 hour 


LocalDate: represents the date without time and timezone

LocalDate.now() — returns the LocalDate object with current date based on the system clock ex: 2022-06-22


LocalTime: represents the time without date and timezone

LocalTime.now() — returns the LocalTime object with the current time based on the system clock ex: 02:13:58.393902


LocalDateTime — represents the date and time without the timezone

LocalDateTime.now() — returns the LocalDateTime object ex: 2022-06-22T02:15:03.285727


ZonedDateTime: represents the Date and time based on the current timezone and also stores the timezone information

ZonedDateTime.now() — returns the current date and time with timezone info ex: “2022-06-22T02:15:28.132333-04:00[America/New_York]”


Instant: represents a single instantaneous point of the time line, for time and date it will query the system UTC clock.

Instant.now() — returns the Instant object with date and time with UTC timezone ex: 2022-06-22T06:20:19.775097Z


ZoneId: represents the Zone information based on the zone id string for a complete list of zone ids refer to ZoneId documentation at https://docs.oracle.com/javase/8/docs/api/java/time/ZoneId.html#SHORT_IDS

ZonedDateTime.ofInstant(Instant.now(),ZoneId.of("Asia/Kolkata")) — will return the Instant with the mentioned timezone


Some of the points to remember about Classes in this package.


  1. LocalDate, LocalTime, LocalDateTime, ZonedDateTime etc. are final classes and cannot create subclasses
  2. Date classes are immutable and hence the state of the object cannot be modified
  3. Any modification to the date object will return a new object instead of modifying the state of own Object.
    1. Lets say 

      var curr = Instant.now();
      var currplus1 = curr.plus(Duration.ofHours(1))
      currplus1 will be new object and the state of curr object remains same

  4. Its better to go through the java.time.temporal, java.time.chrono, java.time.format, java.time.Zone package

Comments

Post a Comment

Popular posts from this blog

How shared libraries work in ModuleFederationPlugin.

Image
courtesy: https://scriptedalchemy.medium.com/micro-fe-architecture-webpack-5-module-federation-and-custom-startup-code-9cb3fcd066c This is in continuation to the previous article https://mytechlearns.blogspot.com/2022/06/single-spa-using-single-spa-react-and.html . Application discussed below refers to the application mentioned in the previous article and code is shared in GitHub In this article lets see how shared libraries work in the ModuleFederationPlugin and also how we can run the two different versions of react can run in the host application (host uses the react version of 17.0.2 and remote uses version 18.2.0). Lets take a look into the shared section of MFP. Shared section represents the shared libs that will be shared with the host application or with the other remote application or with both. Similar to split chunks plugin, MFP splits your application into multiple chunks based on the shared dependencies provided. For example with the above configuration if we run webpa...
Read more

Single SPA using single-spa-react and ModuleFederationPlugin

Image
  SPA applications using single-spa framework and SystemJS is discussed in the below 2 articles Part1: https://mytechlearns.blogspot.com/2022/06/micro-frontend-and-implementation-using.html Part2 : https://mytechlearns.blogspot.com/2022/06/micro-frontend-and-implementation-using_27.html In this article we will see how to integrate remotes with host using ModuleFederationPlugin (MFP), and also we will use the single-SPA framework also (although not required using MFP) as discussed in the above 2 articles. What is a ModuleFederationPlugin (available in webpack v5.0+): As per the author of the plugin  “ A scalable solution to sharing code between independent applications has never been convenient, and near impossible at scale. The closest we had was externals or DLLPlugin, forcing centralized dependency on a external file. It was a hassle to share code, the separate applications were not truly standalone and usually, a limited number of dependencies are shared. Moreover, sharing ...
Read more

Micro Frontend and implementation using single-spa-react framework and SystemJS

Image
  What is a Micro Frontend: If you are familiar with backend development you might have heard about the Micro services, micro frontend also carries the same meaning, behaviour and advantages carried from micro services but from UI perspective. In Micro Frontend Architecture we break down a big monolith UI application to multiple separate UI applications, where each UI has its own separate development, testing and deployment. Lets take a banking website example, on a high level we have following screens. Account screen — account management Pay & Transfer screen — manage payments and transfer related actions Investments screen — investments related activities Profile screen — manage your profile If we follow micro frontend architecture we have following advantages, Each screen mentioned above can be developed, Tested and deployed separately. Each screen can be developed with its own UI frameworks, for example account screen can be be developed using angular, profile screen...
Read more