Client is thin, lightweight, and stateless.
Cross platform GUI support with desktop power using Java.
Centrally hosted and managed applications.
Program in Java Swing with no restrictions and no special API.
All critical processing managed on the server via web services over SSL.
All business logic and database transactions handled on server side. Client handles presentation while server handles business logic.
No special presentation server - uses plain web server infrastructure and web services.
Reduced load on web servers and less frequent round trip requests.
Easy to upgrade both client and server software at anytime.
There are large a number of web GUI frameworks out there, however, they all fall short of taking advantage of modern desktop application technology. The vast majorities are based on HTML and web browsers with the bulk of the processing, including UI, happening on the server side. jThinRich is a framework that enables developers to take full advantage of both modern front-end and back-end technologies while maintaining the full benefits of traditional networked and stateless browser type applications, but without the restrictions of a HTML browser.
Remember the first time you saw an applet running in a browser? Many thought this would be the future of desktop software? While applets were/are still very limiting, the concept of distributing software in a secure sandbox offered a lot of promise. But for whatever reason, the technology never evolved much from those early days. So, here we are today, still stuck programming in HTML and trying to convince ourselves that this is how GUI applications should be built.
jThinRich is designed for applications that want to take full advantage of desktop power but still want the benefits of traditional and centrally hosted HTML browser applications.
So what does jThinRich provide?
- A thin client desktop container that can dynamically load and run Java Swing applications. Applications
are downloaded and managed using JNLP. The thin client desktop container provides a lightweight
application framework for running applications and for communicating with the web server via web services. The client container provides an intuitive metaphor and design patterns for designing and running networked applications.
- Create unique application "products" within a hosted web server container. Each application product can
be accessed by its corresponding client Swing application in a secure and controlled manner. The client
application is only allowed to make remote (HTTP) calls to its corresponding server representation. Client and server are seamlessly tied together from both networking perspective and API perspective.
- The ability for secure single sign-on (SSO) between jThinRich client application and web browser session. jThinRich applications are launched from the browser and can use an authenticated web browser session once started to allow for seamless SSO capability. jThinRich applications are allows launched from the browser and every jThinRich application has a browser home page from which to access it.
- jThinRich client applications use a stateless web services interface to communicate with their web host. The web services API is very lightweight and easy to use and based on POJO (plain old java objects) that frees the developer from dealing with XML. Remote server calls automatically lock the GUI and allow the interactive user to terminate/stop requests as needed. So long running server requests are no problem to deal with as the user always has visual feedback when the client is communicating with the server. Swing threading is automatically handled, freeing developer to focus on business logic.
- Every jThinRich application has a remote web hosted server representation for executing remote processing logic that is invoked from the client. It provides
authentication, session management, and a remote server API for implementing backend logic. This is a thin layer around servlets and does not attempt to replace or remove the need for EJB or any other backend J2EE API, it only complements them.
- jThinRich provides supporting tools for managing client and server upgrades and application deployment. Server can be upgraded independent of the client and visa versa. Upgrading is seamless to the user. Each application can be taken online, offline, and upgraded independent of other applications. A desktop client can always use most current version of code.
- Sample applications that demonstrate the features of jThinRich.
What are some of the design goals of jThinRich?
- Java desktop software is distributed from a central server with dynamic and seamless updating of software. The only thing you need to have installed on your desktop is Java.
- Client software updates of jars happen using incremental updates. This way the server only sends jar diffs to the client application, which keeps the update process fast and lightweight and without the need to resend the entire jar the client. This leverages core JNLP capabilities to accomplish this.
- Client application can be forced to upgrade at the command of web application administrators.
- Java desktop applications can run in a secure restricted sandbox or have full access to the desktop. This must be configurable.
- Provide server tools and APIs for managing the upgrading process of both the server and client software.
- No presentation server required. You use simple Java Servlets on the backend with a lightweight messaging API to allow client to invoke remote methods on the server via a web services API.
- Clear and intuitive separation between GUI client code and remote server API. Client deals with GUI logic and server deals with server logic and two shall not meet.
- Lightweight HTTP based messaging API for managing communication between server including session management and authentication. No need to mess with XML.
What are the benefits of jThinRich over HTML browser applications?
- More work done on client. Server freed from rendering user interface logic.
- Reduced hits on server. No more unnecessary screen refreshes associated with navigating application.
Application decides when it needs to get a refresh of data from the server.
- Programmers can take full advantage of OO design on the client side, because all GUI programming is in Java. Over the long-term this will allow for better programmer productivity and code maintainability.
jThinRich is a framework, set of tools, and coding conventions that empower programmers to take Internet applications to their next logical evolution and far beyond HTML browsers.
jThinRich leverages and builds on existing internet technologies to provide a product and framework for the next generation of web applications. If you have questions or comments contact firstname.lastname@example.org.