100% Pure, Unadulterated Java
Start Developing Now with Zero-Install
At large institutions, developers often feel like caged rats running on a wheel. They can spend weeks, configuring environments, waiting for access to resources, creating a project structure, playing with tools, etc. With ExpressUI, the developer can start developing now without having to install or configuring anything.
ExpressUI applications are is built using Maven, which not only automates the build process but also downloads and generates all necessary dependencies. Here are some specifics:
- Quickly generates a starter application using a Maven archetype.
- Downloads all library dependencies automatically, including a lightweight database (H2) and web container (Jetty) for testing the application locally.
- Generates SQL DDL from the Java entity model defined with JPA annotations. The Hibernate strategy for generating SQL has also been refined to conform to enterprise-naming conventions.
- Creates the database schema and populates it with reference entities, e.g. states, countries and other menu choices. It also generates random test data.
- In addition to supporting standard maven features like running unit tests, the ExpressUI script also provides many extras such as generating code-audit and code-coverage reports.
- Supports alternative builds for configuring the application for deployment in the enterprise. ExpressUI has been compatibility tested against Jetty, H2, JBoss, MySQL, Weblogic and Oracle, although it should work with other databases and app servers as well.
Built on a Best-of-Breed Technology Stack
The ExpressUI architecture primarily consists of the latest versions of Spring, Hibernate/JPA 2 and Vaadin. Other components include Hibernate Validator, various Vaadin add-ons, and Apache open-source libraries.
These technologies provide the most lightweight, productive development environment available in today’s Java ecosystem. While technology stacks that rely on EJB, e.g. JBoss Seam, have improved greatly over the years, the ExpressUI technology stack is more lightweight, easier to test and easier to debug, while still providing competitive features. Check out these job trends.
Dramatically Simplifies Development
ExpressUI takes care of the hard technical problems and frees the developer to focus on business logic. For the most part, the developer does not have to worry about coding the UI, nor integrating technologies, nor managing build processes.
Here is a summary of implementation tasks that developers would typically follow to build an ExpressUI application:
- Define the entity model in the form of Java classes, JPA annotations and JSR303 validation annotations. Developers are encouraged to put business logic into their entities or separate services, whenever appropriate.
- Define DAOs that contain any entity-specific variations in CRUD logic.
- Define query logic that translates UI search forms into JPA Criteria API queries.
- Define search and edit forms as a grid layout of standard field inputs. ExpressUI automatically generates these field inputs along with labels. The developer only needs to define their coordinates on the grid. Of course, the developer can also override default behavior and programmatically change the type of input or the way it looks or behaves.
- Although most security rules can be controlled by the end-user in the UI, the developer is free to code role-specific logic as needed, e.g. perhaps, to limit query results to specific kinds of records.
Solves Common Technical Pain Points
Developing the ExpressUI framework itself was not easy. We had to work around many limitations of Vaadin and Hibernate and jump through hoops to get Spring, Hibernate and Vaadin to play nicely with one another. And yes, we had to apply some duck-tape in a few places.
We suffered this pain so you don’t have to. You may not agree with every single design decision we made, but you will undoubtedly find ExpressUI a cost-effective and pragmatic means to an end.
To give an idea of the pain you are being spared, here is a list of technical problems that ExpressUI solves:
- Nested Property Binding: automatically binds entity properties to UI field inputs, with support for nested property paths.
- No DTOs: avoids architecture clutter with data transfer objects and controllers. ExpressUI is a do-not-repeat-yourself, minimalist framework.
- Domain Driven Design: ExpressUI encourages domain-driven design by allowing developers to code business logic in their entities in the form of derived properties. Derived business logic instantly executes and refreshes the UI whenever the user makes any change to an input field.
- Entity Bean Injection: also in the spirit of domain-driven design, developers can inject services into their entities. For example, the demo application injects a currency exchange rate service into an entity so that it can offer derived properties for displaying foreign currency amounts in US dollars. This allows the user to change a foreign currency amount and then instantly see the amount translated into US dollars.
- Caching: provides abstract super classes for DAO and entity classes, which ensure that object identities and caching work correctly.
- Auditing: Entity super classes also keep an audit trail of who modified each entity at which time.
- No N+1 Select: the framework provides abstract super classes for coding queries using the JPA Criteria API. This approach allows queries to be executed with many parameters, as the user fills out complex search forms, while also handling column sorting and paging. It also optimizes performance by offering APIs to specify join-fetch strategies and avoiding the N+1 select problem.
- No LazyInitializationException: the end-to-end integration of technologies avoids all-too-common Hibernate errors such as LazyInitializationException or “session was closed.”
- Handling Concurrent Modifications: system automatically handles scenario where user tries to save an entity that was modified by another user and has become stale.
- One-Stop Validation: ExpressUI enables the developer to define validation rules in one layer of the architecture in the form of JSR303 bean annotations. These rules are enforced instantly in the UI whenever a user exits a field. They are also propagated to an extent to the database automatically in the form of DDL constraints.
- Multi-Property Validation: the developer can easily define validation logic that depends on multiple, nested properties across the entity tree. These rules are executed immediately whenever the user makes any change to any field on the form.
- Data Entry Formatting: the validation framework ensures that logic is executed on data after formatting has been removed, e.g. (704) 555-1212 is converted to 7045551212 for storage before validation is applied.
- Continuous Integration Friendly: ExpressUI provides Maven scripts that encourage the team to adopt continuous integration best practices. For example, the script automatically creates a lightweight development database populated with test data. This allows each developer to test entity model and database changes in their own sandbox before exposing them to the rest of the team.
Extra Domain Module
ExpressUI bundles an extra module that contains domain-level code that is almost universally needed by business applications. For example, this module provides services to download country, state and zip code information from various free web services during the build process.
In the sample demo, you can see that validation logic checks that zip codes are correctly formatted for the selected country. We intend to expand this module in the future.
ExpressUI integrates various Vaadin add-on components for accessing Google charting and mapping services. In addition to these integrated services, you are welcome to add your own.