Overview
Other MyFaces Extensions
- ExtVal
- Ext-Script
- [Orchestra]
- [Portlet Bridge]
Community
Development
Sponsorship
Your browser does not support iframes
The JSF module provides additional features like new scopes and it improves existing JSF mechanisms.
CDI conversations are very limited. Therefore CODI provides grouped conversations which are similar to the conversations of MyFaces Orchestra. Compared to std. CDI conversations CODI provides completely different conversation concepts. "Just the name is the same." Every conversation scoped bean (or a group of beans) has/have a conversation. So it's possible to have multiple conversations in parallel (in the same window) with a different lifetime. Optionally you can use a fine grained memory management. You can easily just end the conversation of a single bean (or a group of conversation scoped beans) or all conversations within the current window.
You have to terminate conversations manually (or they we be terminated automatically after a timeout). However, sometimes you need beans with a lifetime which is as long as needed and as short as possible which are terminated automatically (as soon as possible). In such an use-case you can use this scope. The simple rule is, as long as the bean is referenced by a page - the bean will be available for the next page (if it's used again the bean will be forwarded again).
This scope is comparable with a session per window. It is useful for beans which contain e.g. preferences of the current user.
CODI allows using all CDI mechanisms for the new view scope of JSF 2.
CODI allows using @Inject within the following JSF artifacts:
Sometimes you don't need a full Phase-Listener. So CODI allows to annotate individual methods. Furthermore, it's possible to link those methods to special views.
JSF itself doesn't provide an annotation for phase-listeners. CODI provides such an annotation. Furthermore, CODI provides an optional annotation to define the invocation order of phase-listeners.
Methods annotated with these annotations are invoked before and after a faces-request. In comparison to similar mechanisms, the FacesContext is available for the listener.
Instead of using strings as outcome, it's possible to link a page to a special config class. So it's possible to use these classes as return values for action methods.
View configs are the base mechanism for type-safe navigation and further concepts like page-beans. It's planned to add further features based on this type-safe config approach.
It's mainly for used internally. However, you can use it to easily detect the type of the current request.
Esp. the JSF qualifier provided by CODI allows injecting pre-configured artifacts.