With many new features, JSF 2.0 is an evolution from 1.2, but it’s also a step forward—for example, in
terms of PDL, where Facelets is preferred to JSP. New features of JSF 2.0 include the following:
• An alternative viewing technology to JSP based on Facelets
• Easier navigation between pages with implicit and conditional navigation
• JSF has been using POST HTTP requests intensively; this new release brings back GET requests as a first-class citizen (allowing users to bookmark pages)
• Additional scopes (view scope, flash and component scope)
• Easy development with annotations for managed beans, renderers, converters,validators, and so on.
• Reducing XML configuration by exploiting annotations and configuration by exception (faces-config.xml is optional)
• Ajax support
• Better error handling (provides information such as line numbers and not just a stack trace)
• Easy component development
I will also point some differences between JSF 1.2 and JSF 2.0
JSF 1.2 JSF 2.0
Pure JSF without any bells and whistles specific to JSF 2 (Ajax stuff and such) – the difference while in JSF 2.0 this has become mostly unnecessary. But that is not really where
won’t be that great. What you have additionally in JSF 1.2 is the need to declare everything i you lose the time.Only when you start to think about custom components will JSF
n a faces-config.xml file. 2.0 give you faster development cycle because it has made easier through facelets.
It take little more time than JSF 2.0 It can save your time compared to JSF 1.2
ConcurrentHashMap is sort of hidden class. Not many people know about it and not many people care to use it. The class offers a very robust and fast (comparatively, we all know java concurrency isn’t the fastest) method of synchronizing a Map collection.
On the internet there is lot of article which tell difference between hashmap and ConcurrentHashMap. This class obeys the same functional specification as Hashtable, and includes versions of methods corresponding to each method of Hashtable. However, even though all operations are thread-safe, retrieval operations do not entail locking, and there is not any support for locking the entire table in a way that prevents all access. This class is fully inter-operable with Hashtable in programs that rely on its thread safety but not on its synchronization details.
Ideally we should not ask for difference.Its like comparing orange with apple.One is giving you synchronize feature and other one is note.
concurrentHashMap is thread-safe implementation of Map interface. In this class put and remove method are synchronized but not get method. This class is different from Hashtable in terms of locking; it means that hashtable use object level lock but this class uses bucket level lock thus having better performance.
If you use HashMap in your application, it is working perfectly in development or test environment ,but gave pain in production..
But obvious is—when heavy load, HashMap behaves starting weird. If we use HashTable.Hashtable’s offer concurrent access to their entries, with a small caveat, the entire map is locked to perform any sort of operation. While this overhead is ignorable in a web application under normal load, under heavy load it can lead to delayed response times and overtaxing of your server for no good reason.
This is where ConcurrentHashMap’s step in. They offer all the features of Hashtable with a performance almost as good as a HashMap. ConcurrentHashMap’s accomplish this by a very simple mechanism.Instead of Map’s lock ,the collection keep a list of 16 lock by default,each of which is used to guard (or lock on) a single bucket of the map. This effectively means that 16 threads can modify the collection at a single time (as long as they’re all working on different buckets). Infact there is no operation performed by this collection that locks the entire map. The concurrency level of the collection, the number of threads that can modify it at the same time without blocking, can be increased. However a higher number means more overhead of maintaining this list of locks.
Retrieval operations on a ConcurrentHashMap do not block unless the entry is not found in the bucket or if the value of the entry is null. In such a case the map synchronizes on the bucket and then tries to look for the entry again just in case the entry was put or removed right after the get in synchronized mode.Removal operations do require a bit of overhead. All removal operations require the chain of elements before and after to be cloned and joined without the removed element. Since the value of the map key is volatile (not really, the value of the inner Entry class is volatile) if a thread already traversing the bucket from which a value is removed reaches the removed element, it automatically sees a null value and knows to ignore such a value.
Showing what ADF developers can get from using WebCenter Portal
Source- Uploaded by ShayJDev on youtube
Privacy & Cookies Policy
Necessary cookies are absolutely essential for the website to function properly. This category only includes cookies that ensures basic functionalities and security features of the website. These cookies do not store any personal information.
Any cookies that may not be particularly necessary for the website to function and is used specifically to collect user personal data via analytics, ads, other embedded contents are termed as non-necessary cookies. It is mandatory to procure user consent prior to running these cookies on your website.