Java SE 8 new features tour: Calculating timespans with the new DateTime API

Cleaner, readable, and powerful coding with Java SE 8 New DateTime API JSR 310. ….


Java SE 8, JSR 310

In the previous article “Processing Collections with Streams API”; I have deeply dived into explanation, and exploration on how to traversing collections with streams, Creating streams from collections and arrays, and finally Aggregating stream values.In this article of the “Java SE 8 new features tour” series, we will deep dig into explanation, and exploring the code of JSR 310 specification, on how to Calculating timespans with the new DateTime API, Calculating time spans with Instant and Duration, Representing date and time values, Formatting date and time values, and Supporting time-zone offsets.

Source code is hosted on my Github account: clone it from here.

Table of Content:
Calculating time spans with Instant and Duration.
Representing date and time values.
Formatting date and time values.
Supporting time-zone offsets.
1- Calculating time spans with Instant and Duration:

Introduction:
Java SE 8 includes a complete new API for managing date and time values. The classes that actually hold the data in this new API are all immutable and thread safe. So that means you don’t have to worry about passing objects around in a multi threading environment. And if you’re using them in parallel streams, everything will always work perfectly. All of the classes in this new API are members of the packagejava.time. And I’ll start with two of the core classes named Instant and Duration.

How it works:
I’ll start with this example in the package eg.com.tm.java8.features.datetime.InstDuration of projectJava8Features. In a class code named InstantAndDuration. And I’ll place all this code inside the mainmethod. The first class I’ll describe is named Instant. I’ll type the name of the class and press Ctrl + Space, and choose the class from the java.time package, and it’s imported above. An instant object represents an instant on the Java timeline. Just as with the date class which is a part of the old way of managing dates and times, an instance represents a number of milliseconds.

Since the Java epoch time, January 1st 1970. To declare an instant object, I’ll declare it with its type, and give it a name of start. And then I’ll call a static method of the instant class called now(). And this represents the moment on the current machine when the code was called. Then I’ll output that value as a string, using standard system output. Run the code and you will see the output starting off with the date in year, month, date format and then the time after the letter T.

Result:

1 2016-08-05T21:21:59.601Z


Once you have a moment in time, you can use it to calculate a difference between that and another moment in time. So I’ll create another instant, which I’ll call end. And I’ll get it’s value from the method now() as well. Then I’ll use system output, and output that value. Notice that there is a slight difference between the two values, and that’s the amount of time it is taking on my system. To process this line of code, that’s outputting the start value.

Result:

1 2016-08-05T21:33:55.971Z


2 2016-08-05T21:33:56.048Z


If I were to move that line of code down, so I wasn’t doing any other processing between the two calls to the now method, the two values would be identical, Or they might be off by a thousandth of a second.

Result:

1 2016-08-05T21:34:43.365Z


2 2016-08-05T21:34:43.365Z


Now, I’ll show you how to calculate the difference between these two values. When you compare two instants to each other, you’ll get an object called a duration. It’s represented by the Duration class, which is also a member of Java.time. I’ll name this object elapsed. An I’ll call a static method of the duration class calledbetween(Temporal startInclusive, Temporal endExclusive). Notice that it’s looking for objects typed as something called Temporal. The Instant class is a sub-class of Temporal.

Result:

1 Elapsed: PT0S


I’ll pass in start and end as my two temporal values. And then I’ll output the difference. I’ll pass in a literal label of elapsed, and then I’ll pass in my variable. That duration object starts with the letter p and then t for time. This is again an ISO formatted value. And then it shows me zero seconds. Well let’s see what happens if we toss in a call to the sleep method. I’ll place the cursor here between the start and end calls. And I’ll use the Thread class.

I’ll press the period, and then press Ctrl+Space. And then I’ll call the sleep() method and pass in a value of 1,000. Meaning sleep for one second. The sleep method can throw an error, so I’ll use a quick fix, and I’ll add a throws declaration to the main methods signature. I’ll save and run the code, and I see that my lapse time is now 1.001 seconds. You can never really count on things being exact, it all depends on what’s going on, on the processing computer.

Result:

1 Elapsed: PT1.001S


Next, I’ll take this printline call, and move it back to its original location. So now after I get the start value, I’ll be executing a printline command. And I’ll be sleeping for one second. And I’ll run the code. And now my lapse time is 1.057 seconds.

Result:

1 2016-08-05T22:28:42.685Z


2 2016-08-05T22:28:43.769Z


3 Elapsed: PT1.084S


To make this a little bit more readable, I’ll add a call to the method of the duration object using elapsed.to millis. That means, get the milliseconds equivalent. And I’ll append to that, milliseconds, and I’ll run the code.

Result:

1 2016-08-05T22:32:52.657Z


2 2016-08-05T22:32:53.731Z


3 Elapsed: 1074 milliseconds


Conclusion:
And now I see, a readable value, of 1,054 milliseconds. So, that’s the Instant class and the Duration class. Two of the core classes, of the new date time API, in Java SE 8.
2- Representing date and time values:

Introduction:
I previously described how to use the instant class in the new date time API to represent a moment in the Java timeline. Here are three more useful classes to represent parts of dates and times. They’re called local date, local time, and local date time. Lets say, for example, that you only want to represent a date value. And you don’t care about times or seconds or milliseconds but only the current date. Create an instance of a class named LocalDate.
How it works:
I’m working in a package eg.com.tm.java8.features.datetime.localdt of project Java8Features. In a class code named LocalDateAndTime. with a main method. I’ll start with the name of the class LocalDate. And when I press Ctrl + Space, I’ll choose the class from the java.time package. I’ll name the objectcurrentDate and I’ll get its value with localDate.now. Notice that there’s consistency in the syntax between working with an instant, a date, a time and a date time.

To get the current value on the current machine, you always use the now method. Now, I’ll output that date in its default format. I’ll save and run the code, and it shows me the date in year-month-date format.

Result:

1 2016-08-06


You can also create a date object using specific year, month, and date values. Once again, I’ll create an object typed as LocalDate. And I’ll name this one specificDate. To get this value, call LocalDate.of.

And there are a couple of available versions. I’m going to use the one that takes three integer values. They aren’t named in the documentation but they represent the year, the month, and the day. I’ll patch in the values of 2,000, 1, and 1. Now, in the older version of the date time API using the date class. When you were dealing with months, you always had to do it with a 0 based off set. So for January you’d use 0, for February 1 and so on.

And that wasn’t particularly intuitive. In the new day time API, everything is 1 based. So 1 means January, 2 means February and so on. Just as you would normally expect.

I’ll once again use system output, and this time I’ll, I’ll put the new specific date. And when I save and run that, I get the value that I put in, January 1st, 2000.

Result:

1 2016-01-01


If you only want to represent a time value, use the LocalTime class, I’ll type the name of the class and import it, I’ll name the object currentTime and I’ll get its value from LocalTime.now.

Again, using the same sort of syntax as with localdate and with instant. Then I’ll use system output. And I’ll output that current time. The default value for the time is in 24 hour notation, and it shows the hour, the minute, the second, and the milliseconds.

Result:

1 01:18:11.779


I’ll use LocalTime. I’ll name this specificTime. And, just as with the local date class, I’ll call the method named of. Again, there are a number of different versions taking varying numbers of arguments.

I’ll use the version that’s looking for three integer values and I’ll type in 14, 0 and 45. And then I’ll output that value to the console. And there’s the result. 14, 00 and 45 seconds. Notice that because I didn’t provide a milliseconds value the formatted version of that time doesn’t show values after the dot.

Result:

1 14:00:45


Finally, I’ll show how to use the LocalDateTime class.

I’ll type the name of the class and import it. I’ll name this object currentDT. And I’ll get its value fromLocalDateTime.now. When you output a date time value, you’ll get a long format ISO date time. Starting with the date, and ending with the time. And if there are milliseconds in the value, they’ll be displayed. And finally, I’ll create a specific date, time and I’ll do this by combining my specific date and my specific time.

That code will look like the next code. I’ll create a LocalDateTime object. I’ll name it, specificDT and I’ll callLocalDateTime.of again. And this time, I’ll use this first version of the method that accepts a local date object and a local time object. You can also construct your date time value from combinations of years, months, dates, and time values. I’ll pass in my specific date and my specific time. And then I’ll output it to the console. And when I run that code, my specific date time is a combination of my specific date and my specific time.

Result:

1 2016-08-06T01:30:46.625


2 2016-01-01T14:00:45


Conclusion:
So, those are the three classes that you can use to represent date and time values on the local machine in the current time zone. There are also classes you can use to get time zone sensitive values. And I’ll describe those next.
3- Formatting date and time values:

Introduction:
I’ve previously described how to use the LocalDate, LocalTime, and LocalDateTime classes to represent time values. To present this information to a user, you’ll need to format it. And for that purpose, there’s a new class named DateTimeFormatter. I’ll show you how to create formatters using some simple syntax. And then how to do very custom work using a class called Daytime Formatter Builder.

How it works:
I’m working in a package eg.com.tm.java8.features.datetime.format of project Java8Features. In a class code named DateTimeFormater. with a main method.

First, I’ll create a date. I’ll give it a type of LocalDate, making sure to import that class. And I’ll name itcurrentDate. And I’ll get its value from LocalDate.now. Next I’ll create a formatter object. I’ll type the name of the class, DateTimeFormatter, and select it from the java.time.format package. I’ll name this object df. Now there are a number of ways of creating a formatter. One of the simplest is to use a constant of theDateTmeFormatter class.

I’ll once again type in DateTimeFormatter. And then after I type in the period I see a list of all of the available constants. I’ll choose ISO Date. And this will provide the default formatting for this object. Then, I’ll use System Output. I’ll call the formatted object format method and pass in the date object. And here is the result. I’m outputting the value in year month date format. With the month and the date padded out to two characters each. Now you can do the same sort of thing with times and date times.

Result:

1 2016-08-06


I’ll take above bit of code and I’ll duplicate it a couple of times and I’ll make some changes. In the second version, I’ll change the type from local date to local time. The object name to current time, and the name of the class I’m using to get the value to local time. I’ll change the name of the date time formatter from DF to TF for time formatter. And I’ll change the constant I’m using to ISO Time. And then I’ll change the object that I’m formatting. I’ll be sure to import the LocalTime class.

And then I’ll make similar changes to the third version. The class that I’ll be working with this time isLocalDateTime. I’ll be sure to import it. I’ll name this object, current DT. And I’ll change the class that I’m calling the now method from. I’ll change the formatter to DTF for DateTimeFormatter. And I’ll change the constant to ISO Date Time. And then I’ll format the current DT object. I’ll be sure I’m using the right formatters in each version of the code. I’ll save the change, and run the code.

And there are the three formatted values. Now so far, I haven’t really accomplished that much, because I’ve used the constants that represent the default formatting. But let’s take a look at some custom formats that are available.

Result:

1 2016-08-09


2 20:37:11.535


3 2016-08-09T20:37:11.538


I move down to below the existing code. And i’ll create another DateTimeFormatter, i’ll name this one f_longfor the long date format and i’ll get its value by calling a method of the DateTimeFormatter class called a Localised Date.

Notice that there are methods for date, time and date-time, with a variety of arguments. I’ll choose this one, of localized date, and I’ll pass in a constant of a class called, FormatStyle. Be sure to import this class. And then after you type the period, you’ll see that there are four constants available. Full, long, medium and short. I’ll choose the long version and then I’ll output the formatted date by calling F _ long.format and I’ll pass in the current DT object.

When i run this code i get the long version of the date.

Result:

1 August 9, 2016


I’ll show you another version of this by duplicating these two lines of code and for this version i’ll change the formatter name to f_short, i’ll change the constant I’m using to short also. And I’ll change the name of the formatter that I’m calling. So the long version is the name of the months spelled out. A comma after the date, and then the year in four digit format, and the short version at least for the current locale, is the month and date, without padding, with slashes separating values, and a two character year.

Result:

1 8/9/16


And next, I’ll show you how to use locales. I’ll create a couple of strings. The first will be called fr_ short, for French, in short format. To get that value i’ll call my f_short formatter and then i’ll will call method namewithLocal(). To get a locale value i’ll use the Local class, this is an existing class that’s been available inprevious versions of Java. It’s a member of the package Java.util.

And then, I can call one of the many constants representing various locales. I’ll use French. And then from there, I’ll call the format method, and pass in the current date time.

I’ll duplicate that line of code and for this version I’ll use fr_long. I’ll use the long formatter and otherwise the code will be the same. And then I will output those two values fr_short and fr_long.

And here’s the result. Notice for fr_short that the month and the day are reversed from the US version. And that’s because in Europe, the date is stated first, and then the month, and then the year. And when I use the long version I get the months spelled in French.

Result:

1 09/08/16


2 9 août 2016


Finally I’ll show you how to build completely custom formatters using a class called the date time formatter builder. It uses the builder design pattern, where you can call multiple methods, each returning an instance of the current builder.

I’ll type the name of the class and make sure that it’s been imported. And I’ll name the object b. I’ll instantiate it with the new keyword, and the constructor method.

Now, at the end of that code I won’t put in the semicolon because I want to immediately call a series of methods that let me build the formatter from scratch. I’ll start with a method named Append Value. Notice there’s Append Instant, Append Literal, Append Localized and many many others. I’m going to call a method named appendValue() that accepts an instance of a class named TemporalField and then I’ll use an enumerator named ChronoField. Which is extended from that TemporalField.

And from there I’ll use a constant name month of the year. Next I will append a literal value. This can be any character or any string. And just to make this thoroughly unique, I’ll put in a couple of pipe characters. Now I’ll take these two lines of code and duplicate them for the second version instead of month of year. I’ll put in day of month. Notice there’s also day of week and day of year. Then I’ll duplicate that line of code and move it down. And I’ll finish the expression with ChronoField.year.

Once you’ve created the builder object, you can get the formatter. I’ll create new object, typed asDateTimeFormatter. I’ll name it f for Formatter. And called builder objects, to formatter methods, and then finally I’ll format the current date time value. I’ll use system output and call f.format(), and pass incurrentDT.

And now when I run my code, I get completely customized format.

Result:

1 222||9||2016


Conclusion:
You can use the DateTimeFormatter builder to build any format you like. And because it uses the builder design pattern, it’s easy to create and to maintain the code.
4- Supporting time-zone offsets:

Introduction:
The new date time API offers a number of classes that let you manage time zones. Creating day time objects that are offset from Greenwich Mean Time, by certain number of hours, or by particular locations, and calculating differences between time zones.

How it works:
I’m working in a package eg.com.tm.java8.features.datetime.zone of project Java8Features. In a class code named TimeZones. with a main method.

In its main method, I’ve created a DateTimeFormatter and a LocalDateTime object. The LocalDateTimerepresents the current date and time on my system, in my time zone. And that’s Egyptian Time because I’m on the Middle East.

And then I’m outputting a formatted value to the console. I’m outputting the value using a short format. And in Egypt notation, it’s month, day and year.

Result:

1 8/9/16 10:22 PM


In order to represent a time zone based date time value, use the class ZonedDateTime. Just likeLocalDateTime, it’s immutable and thread safe. I’ll type the name of the class, and then press Control + Space to add the import statement. And I’ll name the object gmt for Greenwich Mean Time.

There are a few different ways of creating this object. I’ll show you how to create the object calculating an offset from Greenwich Mean Time. I’ll use the ZonedDateTime class again, and after I type the period, I’ll see that there are many methods available. I can call now() again, to get the date time value in my area. I can call of() methods that let me do various calculations. I can parse strings, but I’m going to use this version of the now method. I’ll pass in an instance of the ZoneId class.

A ZoneId represents a certain number of hours offset from Greenwich Mean Time. And I’ll get that value by calling a method named ZoneId.of(). And I’ll pass in a literal string of “GMT+0”. That means, show me the current date and time value in Greenwich Mean Time.

Now I’ll duplicate my code that’s outputting the value to the console. I’ll move that down, and I’ll change this version to output gmt. I’ll run the code, and there’s the result.

Result:

1 8/9/16 8:28 PM


I’m in the Middle East Egypt, and right now, Greenwich Mean Time is two hours ahead.

Here is another approach to getting a ZonedDateTime. Lets say you wanted to get the ZoneDateTime in New York. There are many built-in strings, or constants, that will let you name particular locations, and you’ll get back the correct ZoneId for that location, and you won’t have to worry about the math yourself. I’ll create another ZonedDateTime object, and this time i’ll name it ny for New York, and I’ll get it value by callingZonedDateTime.now(), and again I’ll pass in ZoneId.of(), but this time i’ll pass in a string ofAmerica/New_York.

Make sure to spell this string exactly as you see it here. I’ll create a line of code to output that value. I’ll save the change, and run it. And New York is on East Coast time, three hours ahead of Pacific time.

Result:

1 8/9/16 4:36 PM


To find out about all of the available strings, you can call a method of the ZoneId class calledgetAvailableZoneIds(). You’ll get back a set. I’ll type Set and press Control + Space, and then choose set from Java.util.

And I’ll set the generic type of the items in this set to String. I’m name the set zones. And then I’ll call the method, ZoneId.getAvailableZoneIds. Then I’ll loop through the strings with the forEach() method. And then I’ll pass in a Lambda expression. So I can deal with each of the items in turn.

Result:
When I run that code, I see all of the available strings.

01 Asia/Aden


02 America/Cuiaba


03 Etc/GMT+9


04 Etc/GMT+8


05 Africa/Nairobi


06 America/Marigot


07 Asia/Aqtau


08 Pacific/Kwajalein


09 America/El_Salvador


10 Asia/Pontianak


11 Africa/Cairo


12 Pacific/Pago_Pago


13 Africa/Mbabane


14 Asia/Kuching


15 Pacific/Honolulu


16 Pacific/Rarotonga


17 America/Guatemala


18 Australia/Hobart


19 Europe/London


20 America/Belize


21 America/Panama


22 Asia/Chungking


23 America/Managua


24 America/Indiana/Petersburg


25 Asia/Yerevan


26 Europe/Brussels


27 GMT


28 Europe/Warsaw


29 America/Chicago


30 Asia/Kashgar


31 Chile/Continental


32 Pacific/Yap


33 CET


34 Etc/GMT-1


35 Etc/GMT-0


36 Europe/Jersey


37 America/Tegucigalpa


38 Etc/GMT-5


39 Europe/Istanbul


40 America/Eirunepe


41 Etc/GMT-4


42 America/Miquelon


43 Etc/GMT-3


44 Europe/Luxembourg


45 Etc/GMT-2


46 Etc/GMT-9


47 America/Argentina/Catamarca


48 Etc/GMT-8


49 Etc/GMT-7


50 .................


Now, there are so many it might be hard to find the one that you’re looking for. So let’s say that I wanted to look for London.

And use the time zone for that particular location, at this particular time of year. As I showed earlier in the article, I could use a predicate to search the strings. I’ll create a predicate object. And I’ll set the generic type to String. And I’ll name the object condition. Then I’ll implement the predicate with a lambda expression. I’ll pass in str, and then I’ll implement the predicate with a condition. str.contains, and I’ll pass in a string of London.

Then I’ll refactor my Lamba expression. I’m going to wrap System.out.println() in braces. Then I’ll expand the code to make it a little bit easier to work with. I’ll add the semi colon at the end of the print line, and then I’ll create an if statement. And I’ll set the condition to condition.test(), and I’ll pass in z for the current zone. I’ll move the println() statement, to within the condition, and now i’ll only printout strings that match my predicate test.

I’ll save the change and run the code, and there’s the result. I find that the correct string for London is:

Result:

1 Europe/London


Conclusion:
So that’s a little bit about working with time zones. Again, use the ZonedDateTime class instead ofLocalDateTime to represent values that you can modify and calculate against. The ZoneId represents an off set from Greenwich Mean Time. And there’s also a class called Zone Offset that you can use to calculate different time zones against each other.
#copied

Job Vacancies in NTG Egypt (in House and outsource)

Available Opportunities in NTG Egypt 

(in House and outsource) 

1. Oracle Developers
2. Java Developers 
3. .Net Developers
4. Share Point Developers 
5. Android/IOS Developers 

Required experience : 1-5 years of experience BSc in Computer Science / Engineering 
Location: Giza - Cairo 
Qualified interested candidates 
please send your updated CV to "hr@ntgclarity.com"
and make sure to insert the job title in the mail subject.

Job Vacancies. in Gulf Sky LLC

Oracle ADF Interview Questions and Answers/Tips - Part1

Oracle ADF Interview Questions and Answers/Tips

Here are a set of Interview Question and Answers/Tips for Oracle ADF :

Q : What is Oracle ADF?
A : Oracle ADF is an commercial java/j2ee framework, which is used to build enterprise applications.
It is one of the most comprehensive and advanced framework in market for J2EE

Q : What are the advantages of using ADF?
A : Following are the advantages of using :

• It supports Rapid Application Development.
• It is based on MVC architecture
• Declarative Approach (XML Driven)
• Secure
• Reduces maintenance cost and time
• SOA Enabled

Q : What are various components in ADF?
A : Oracle ADF has following components

• ADF Business Components(Model)
• ADF Faces (View)
• ADF Taskflows(Controller)

Q : What is the return type of Service Methods?
A : Service Methods can return Scalar or Primitive Data types.

Q : Can Service Methods return type Void?
A : Yes, Service Methods can Return type Void

Q : Can Service Methods return Complex Data types?
A : No, service methods can return only primitive/scalar data types.

Q : Which component in ADF BC manages transaction ?
A : Application Module, manages transaction.

Q : Can an entity object be based on two Database Objects(tables/views) or two Webservices ?
A : No entity objects will always have one to one relationship with a database object or web service.

Q : Where is that we write business rules/validations in ADF and why?
A : We should be writing validations at Entity Object level, because they provide highest degree of reuse.

Q : What is Managed Bean?
A : Managed bean is a java class, which is initialized by JSF framework. It is primarily used to hold view and controller logic. It is also used to execute java code to be executed on a user action like Button Click.

Q : What are Backing Bean?
A : Backing beans are those managed beans which have 1:1 mapping with a page. They have getters and setters
for all the components in the related page.

Q : What is difference between managed and backing beans?
A : Backing bean has 1:1 relation with page whereas managed beans can be used in multiple pages.
Backing beans scope is limited to the page whereas managed beans can have other scopes too.

Q : What is a Taskflow?
A : Taskflow is the controller of an ADF application, it provides us an declarative approach to define the control flow.  It is used to define the navigation between pages and various taskflow activites.

Q : What are the different types/categories of Taskflows ?
A :  Taskflows are of two categories : Bounded and UnBounded.

Q : What is the difference between Bounded and UnBounded taskflows?
A : Differences between Bounded and UnBounded taskflows :

• Bounded taskflows can be secured but Unbounded can’t.
• Bounded taskflows can accept parameter and return values but unbounded taskflows don’t support parameters
• Bounded taskflows has a single entry point or a default activity but unbounded taskflows have multiple entry points.
• Bounded taskflows can be called from other bounded/unbounded taskflows but unbounded cannot be called or reused.
• Bounded taskflows support transactions unbounded don’t

Q : What are the various access scopes supported by ADF?
A : ADF Faces supports the following scopes

• Application Scope
• Session Scope
• PageFlow Scope
• Request Scope
• BackingBean Scope.

Q : Describe life cycle of a ADF Page?
A : ADF page is an extension of JSF and has following phases in its lifecycle

1. Initialize Context: In this phase the adf page initializes the LifecycleContext with information that will be used during the Lifecycle.
2. Prepare Model:  In this phase ui model is prepared and initialized. In this phase page parameters are set and methods in the executable section of the page definition of the ADF page are executed.
3. Apply Input Values: This phase handles the request parameters. The values from the HTML are sent to the server  and applied to the page binding in page definitions.
4. Validate Input Values:  This phase validates the values that were built in the Apply input values phase
5. Update Model:  Validated values supplied from user are sent to ADF business components data model
6. Validate Model Updates:  In this phase the business components will validate user supplied values.
7. Invoke Application:  This phase will process the ui events stack built during the life cycle of page and also fire navigational events
8. Prepare Render:  This is the final phase where HTML code is generated from the view tree.

Top Ten Useful Java Frameworks From Web

Top Ten Useful Java Frameworks From Web 

At First What is Java Web Framework?

A Java web application framework is a software framework which specially designed to support the development of dynamic websites, Web applications and Web services by using java platform.

Basically framework use for create structure in developing applications by providing reusable classes and functions which can reduce development time significantly.

Now , We will introduce the Top 10 #Java Frameworks

1. Dojo Toolkit

Dojo Toolkit is an open source java framework that specially designed to solve some long-standing historical problems with DHTML which prevented mass adoption of dynamic web application development. it allow you to easily build dynamic capabilities into web pages and any other environment that supports JavaScript also. You can use the components that Dojo provides to make your web sites more usable, responsive, and functional. With Dojo Toolkit you can build degradable user interfaces more easily, prototype interactive widgets quickly, and animate transitions. to download it follow this link  DOJO TOOLOKIT 

2-Apache Struts 

Apache Struts 2 is an enterprise-ready Java web framework that specially designed to streamline the full development cycle, from building, to deploying, maintaining applications over time. It’s an easy to use and easy to startup. Apache Struts 2 was previously known as WebWork 2. The WebWork and Struts communities joined forces to create Struts. Struts 2 comes with an improved design with clean code for HTTP-independent framework interfaces. Added interactivity and flexibility with AJAX tags gives the look and feel just like standard Struts tags. It doesn’t use Action forms, instead Struts 2 uses JavaBean to capture form input or put properties directly on an Action class.Use both binary and String properties. Customize your tag mark-up by editing a Free Marker template. No need to grok the taglib API! JSP, FreeMarker, and Velocity tags are fully supported.

to see more follow this link Apache Struts  

 3- jMaki

jMaki is an lightweight client/server side Ajax framework that allow developers to use JavaScript in their Java based applications as either a JSP tag library or a JSF component.It’sJavaScript Wrapper Framework for the Java platform. 

 TO SEE MORE FOLLOW THIS LINK  JMAKI

4- AjaxAnywhere – Ajax without javascript coding

AjaxAnywhere is designed to turn any set of existing JSP or JSF components into AJAX-aware components without complex JavaScript coding. It is not component-oriented, the page needing to be separated into different zones, where AJAX will be applied.Simply separate your web page into multiple zones, and use AjaxAnywhere to refresh only those zones that needs to be updated. 

5- Apache Tapestry – object oriented java frameworks

Apache Tapestry is an object oriented, open-source java framework for creating dynamic, robust, highly scalable web applications in Java. In Tapestry, you create your own application in terms of objects, and the methods and properties of those objects – and specifically not in terms of URLs and query parameters. Tapestry brings true object oriented development to Java web applications.

6-DWR java library

DWR is a open source java library that allow you to write Ajax web sites. It’s a Easy Ajax for Java. It allow you to code in a browser to use Java functions running on a web server just as if it was in the browser. DWR works by dynamically generating JavaScript based on Java classes.It canmarshal virtually any data including collections, POJOs, XML and binary data like images and PDF files. All that is required is a security policy that defines what is allowed. DWR provides integration with Dojo, TIBCO GI, Scriptaculous in the browser, and with Spring, Struts, Guice, Hibernate and others on the server.

7-Echo web framework

Echo is a next-generation open source framework for developing rich web applications. From the developer’s Point of you, Echo behaves as a user interface toolkit–like Swing or Eclipse SWT. AJAX technology is employed to deliver a user experience to web clients that approaches that of desktop-based applications.

8-Sigma Visual Ajax GUI Builder

Sigma Visual Ajax GUI Builder is a web based tool for AJAX RIA application UI rapid design and involved scripts programming. With this powerful builder, developers can develop there web application just like what you do in VB or Delphi.

9-SweetDEV RIA

SweetDEV RIA is a complete set of world-class Ajax tags in Java/J2EE. It helps you to design Rich GUI in a thin client.It provide you Out-Of-The-Box Ajax components. Continue to develop your application with frameworks like Struts. SweetDEV RIA tags can be easily plugged into your JSP pages.

10-xWire Framework – Enterprise-ready java toolkit

xWire Framework is a object oriented, enterprise-ready java toolkit. It used to build Java web applications, but is flexible enough for other uses. It is ideal for building AJAX apps and consists of both client and server components, each of which can be used independently of the other.

FOR MORE INFO CONTACT ME ON 

LINKEDIN -  Mahmoud Elasry

FACEBOOK - Programmer Elasry

Gmail - mahmoudelasry2013@gmail.com