Welcome to RIFE
RIFE is a full-stack web application framework with tools and APIs to implement most common web features. Each of its toolkits is usable by itself and together they offer powerful integrated features that boost your productivity. RIFE ensures that every declaration and definition is handled in one place in the code. This simplifies the developer's task by reducing code replication, enforcing consistency, and easing maintenance.
RIFE's differentiators are:
- you get 90% of the features with 10% of the usual effort, thanks to its full stack
- logic-less HTML templates that can be previewed in any browser and edited with standard tools
- uniform component model, designed from the ground up for reusability: applications, sub-sites, pages, porlets, widgets, ... can be easily packaged and placed in any other context
- integrated native Java web continuations and flow continuations
- metaprogramming, driven by your domain model, but without polluting it
- flexible declaration and configuration with support for plain Java as well as XML
- core support for web data flow as well as page logic flow
- integrates with existing solutions such as Spring and standard JDBC datasources
- multi-dimensional conversational state management with scoping
- language-independent template engine with support for XHTML, HTML, XML, Text, SQL, Java
- persistence layer with content management integration and versioning
- designed for the creation of consistent maintainable applications as well as on quick delivery
- embraces standard protocols and specifications, providing larger building blocks by wrapping lower layers with high-level functionalities
- out-of-container testing with full introspection capabilities of the executed flow and components
- lightweight execution model that has been proven in production
- built for Java 5 with intelligent downgraded support for Java 4
- designed for developer comfort: minimal application restarts thanks to automatic detection of file modifications
What's inside the full stack?
RIFE's full stack provides you with most of the features you need to build a dynamic database-backed website. Each layer has been designed for tight integration with the others, but is still fully functional when used independently. You're not forced to use all the features and are free to still use other libraries like Spring, Hibernate, iBatis, Velocity, ...
This is an overview of what RIFE's full stack contains: (mouse over the diagram for more details)
Why RIFE's web engine?
RIFE's design provides the best of request-based and component-based approaches and blends them together in a consistent component object model. The web engine provides a solution that values maintainability without compromising on productivity. Through a centralized site structure, an application can be split up into easily reusable binary modules that can be seamlessly integrated into other projects.
Bruce Tate: RIFE is absolutely moving in the right direction. I think we'll all be using a continuation based approach in the next two or three years or so. It's just too compelling to do things any other way.... read more ...
There are currently two major schools of web application development frameworks: request-based and component-based.
Request-based frameworks are very close to the original CGI specification. They use controllers and actions that directly handle incoming requests. Each request is fundamentally stateless. With the introduction of server-side sessions, a certain degree of statefulness has been achieved. The different frameworks basically differentiate themselves by the way they map logic to URLs and how data is structured and provided to the developer.
Keith Lea: RIFE is the only framework that lets me have total control over how web applications behave without compromising on end-user experience, features, or productivity... read more ...
Component-based frameworks abstract the developer away from the internals of the request handling and encapsulate the logic into reusable components, often independent from the web medium. The state is automatically handled by the framework, based on the data that is present in each component instance. Together with some form of event handling, this development model is very similar to the features offered by desktop GUI toolkits. The different frameworks basically differentiate themselves by the provided component API and how components are combined together.
S. Meslin-Weber: RIFE's powerful, intuitive and fast database access layer coupled with its tiny footprint proved ideal for embedded use. read more ...
RIFE combines both by taking control of the entire data and logic flow in a request-based model. Developers remain close to the architecture of CGI applications and have full control over URLs, forms, parameters, cookies and pathinfos. However, instead of mapping actions and controllers directly to the request, RIFE provides a component object model that behaves identically in many different situations such as individual pages, intercepted requests, portal-like page fragments and integratable widgets. Components can be wired together and be packaged as groups that are components in their own right. They can be distributed separately and be seamlessly integrated into any other RIFE project. This provides the same form of reusability as component-based frameworks, but with the raw control of the request-based approach.
RIFE only starts here, many more features and capabilities are available for developers to use and build upon.