Welcome to Janno

Welcome to Janno, the core Web Application platform for the Jamecs modular web application server. Janno is an advanced Web Application Platform that provides the foundation for high-quality, cutting edge software systems with web-based architecture and user interfaces based on the Java(tm) Servlets specification. Janno's advanced inversion of control functionality, firm grounding in the precepts of MVC design, and sophisticated constructor dependency injection-based architecture make for a powerful, flexible, elegantly functional alternative to traditional web frameworks.

The goal of Janno, as with every Roscopeco Open Tech project, is to provide a high-quality, solidly engineered, firmly user-focused platform that makes use of existing best-of-breed solutions with the sole aim of making your job easier. Janno provides a great many advanced and esoteric features for those really complex cases but we try wherever possible to cover the common use-cases with sensible defaults, single parameters, and (the equivalent of) null constructors.

At it's most basic, Janno provides an 'empty box' into which self-contained modules (deployed in standard Jar files) can be deployed according to some configuration. The Janno core provides a basic Moxy-based runtime dependency tree, module deployment and lifecycle support, and generic support for side-issues such as configuration and classloader setup. This core is based upon the PicoContainer DI container, and integrates this dependency tree with the various 'scopes' defined by the Servlets specification.

Advanced configuration issues such as dependency clashes (a primary indicator of Classpath Hell), module resource and proxy support, scripting, and support for advanced techniques such as AOP are provided by the Moxy modular IoC framework. Moxy provides complete sandboxing for modules, avoiding the normal Java classloader delegation and placing the onus on the container and the module to agree on a set of compatible classes / packages to export to other modules, the core, and the request pipeline, while retaining full backward compatibility with the PicoContainer system (and thus it's standard components).

Major Features

Currently Janno provides the following major features:

  • Advanced constructor-based dependency injection component architecture, allowing components to be written in small, concise code files and freeing developers from configuration and initialization issues in many cases.

  • Scripting-based configuration support from the core up. Janno follows the example set by Nanocontainer in aiming to be metadata-language-neutral - all configuration is accomplished by gluing Java objects together in any of the (currently five) supported languages.

  • Tight integration with Servlets 'scopes', by literally mapping a container to each scope. As you would expect, these containers inherit components from above, and provide a very fine-grained control over precisely what components are available with which keys in which sessions and requests.

  • Full support for deployable modules, and associated lifecycle management. Adding support for complex systems such as hibernate is simply a case of supplying a module Jar with appropriate composition script, and then declaring an appropriate parameter (e.g. org.hibernate.Session) in your action class constructor.

  • Powerful, easy to use MVC-based action/view support, allowing actions to be written in both Java and the Java-based Groovy scripting language. These actions are (compiled to) Java classes, and take full advantage of the dependency injection component architecture together with other advanced functionality such as automatic mapping of parameters to fields before your action is even called, parameter constraints, advanced pluggable view dispatch, and much more. Although currently only Groovy is explicitly supported for scripted actions, we hope to directly support other languages before a 1.0 release.

  • Alternative integration with both traditional Groovy scripts and Groovy Template Language for cases where full action functionality is not required. Just need to grab a component from the session container and call a method on it? Drop in a one-line script (without even restarting your container) like this:

    sess.getAttribute("janno.session").getComponentInstance(Your.class).method()


    and you circumvent the features you don't need, going straight to those that you do!

  • Powerful, flexible, easy to use view-based layout and templating based on the Sitemesh layout system and Jakarta Velocity template engine. This is fully integrated with the action-processing features of Janno, and a number of advanced features such as interchangable 'skin' support are made possible by it.

Janno is now becoming fairly mature in terms of stability and functionality, and is well on track to enter feature development. While we still don't consider Janno of production quality, we should now be beyond untraceable problems, wierd bugs, and 'get the CVS' support.

That said, the developers out there can always find the latest stable snapshot by checking out the HEAD branch from anonymous CVS:

          cvs -d:pserver:anonymous@cvs.sourceforge.net:/cvsroot/jamecs login
          cvs -z3 -d:pserver:anonymous@cvs.sourceforge.net:/cvsroot/jamecs co -P janno

Just hit [return] when prompted for a password.

In line with our usual policy, Janno is a full-time POSS project, and is thus under very active development. The best place to find up to the minute information is on our wiki.

Release Notes

The release notes for this Janno release are included here.

Licence

Janno is part of the Jamecs project, and is covered by the same Open Source Apache Software Licence as the rest of the project. The full licence terms are included here.