JRFramework es un entorno de programación que permite el desarrollo rápido de aplicciones en Java.

La idea básica consiste en un fichero XML que describe la aplicación y unos servicios que proveen los métodos de negocio.

El fichero XML se genera por una aplicación (el Modeler) que permite desarrollar prototipos a gran velocidad y sin cononcimientos de metodologías, Java , EJB o conocimientos profundos de Java.

El fichero XML es ejecutado por una aplicación (el Runner) que puede estar implementado en diferentes plataformas, incluyendo versiones en cliente ligero (WEB)

El diseño de las aplicaciones se basa en definir cada aplicación como un conjunto de "Casos de Uso". Los casos de uso se definen como un conjunto de ventanas. Las ventanas se definen como un Panel y un conjunto de llamadas a Operaciones. En la definición de las ventanas se indica la navegación a otras ventanas.

Metodo de desarrollo de aplicaciones

Los analistas analizan el problema, y ven las entidades (u objetos) del ámbito de la aplicación. Después enumeran los casos de uso ( o procesos ) de la aplicación. Toman entonces el modeler y crean los casos de uso identificados.
Para cada Caso de uso se definen las ventanas que los forman.
Para cada ventana definen sus contenidos (sus componentes), los servicios que se pueden llamar desde cada ventana, y las navegaciones a otras ventanas según los resultados de los servicios.
Para describir la apariencia de la ventana se pueden describir ventanas específicas (que luego habrán de programarse) o bien se utilizan los paneles previamente definidos de uso general. Tambien se puede utilizar un diseñador de pantallas que incluye el modeler. Estas pantallas utilizan componentes de bajo nivel (button, label, checkBox, table,...) que se integran con la aplicacion.

El analista, una vez hecha la definición de ventanas, se lo pasa al equipo de programación que se encarga de implementar los servicios que falten por hacer y de hacer los componentes específicos que sean necesarios.

Una vez finalizado el desarrollo (con sus correspondientes pruebas) la puesta en servicio es muy sencilla, ya que únicamente se pasa al entorno de explotación un .jar con la descripción del caso de uso (el .xml), con los componentes especificos, los servicios, y los iconos y plantillas de esta aplicación. Se añade la classpath del 'runner' de explotación, y ya está¡ disponible para los clientes, sin afectar a otras aplicaciones.

A bajo nivel, la ejecución es posible porque se utilizan varias tecnicas y librerias que facilitan todo el proceso.

En primer lugar se consigue un desacoplamiento en las aplicaciones, igual que el principio de MVC (Modelo-Vista-Controlador), el controlador es el runner y los XML que describen los casos de uso, la vista son los paneles de las ventanas y el modelo son los servicios que se llaman y forman los métodos de negocio.

Para un caso de uso, tenemos separada la navegación de la lógica del programa. Igual que en 'Struts' para las aplicaciones WEB, definimos para cada ventana a que servicios puede llamar y a que ventanas irá según los resultados.
Los componentes de la ventana (paneles) y los métodos de negocio (servicios) se comunican, únicamente a través de un 'Contexto' (igual que en 'struts') de forma que estan muy levemente acoplados y son facilemente intercambiables y reutilizables.

Si definimos los paneles utilizando nuestro editor, nos permite utilizar componentes simples sin programarlos (label, textfield, button, combobox). El truco está en que estos widgets envian sus datos (contenido, selección,...) al contexto, y otros componentes tienen 'listeners' sobre el contexto, de forma que si el contexto cambia, ellos actualizan su información. De esta manera los componentes envian datos a los servicios, y estos envian datos a las ventanas.
De esta manera definimos las ventanas, con la interacción entre los componentes, y la interacción con los servicios, sin programar nada.

Implementación de los servicios.

Los servicios son clases java que se llaman. En el interfaz simplemente hay que tomar del contexto los datos que necesite el servicio y hacer el proceso. El resultado lo debe dejar en el contexto. Además debe dejar un resultado que luego se utilizará para la navegación entre ventanas. Estas clases interfaz son muy simples de hacer y permiten utilizar servicios a 2 ó 3 niveles, permiten usar EJB , WebServices, etc,...

Parece que se queda corto.

Efectivamente, es solo un entorno, igual que el 'Struts' para una aplicación WEB, no es una aplicación en sí. Simplemente necesita unos componentes y servicios básicos según el tipo de aplicación a realizar.
Necesita unos interfaces con Hibernate, con JDO, con EJB o con lo que se quiera utilizar.

A donde va...

Pues se pueden añadir ejecución en java en los componentes, es decir, que podemos añadir a los componentes fragmentos de codigo java a ejecutar segun ciertos eventos (onOpen, onSelect, onPress, etc,..) de forma que las aplicaciones sean similares a PowerBuilder, VisualBasic, Delphi, etc,.. pero en Java.

Tambien se puede añadir un componente 'Catalogo' que tenga información sobre los elementos, los campos, los tipos, los perfiles de visibilidad, etc,.. de forma que los paneles (y las tablas) se muestren en 'run-time' sin tener que cambiar ningun programa (ni xml, ni nada). Es decir, cambiando el 'catalogo' cambiamos los campos que aparecen al editar una determinada entidad. Con este catálogo el desarrollo es mucho más rápido, porque al definir ventanas o paneles, no hay que enumerar los campos y sus tipos, sino que el catálogo lo hace para todas las ventanas.

Por Hacer...

Falta hacer el catálogo y hacer una implementación de él.
Falta hacer unas aplicaciones de prueba en diferentes entornos (2, 3 niveles, web services, ejb, jdo,....)