The data access layer components developed with Speedy can employ both JPA and JDBC simultaneously. Transactions can span DAO components using any of those two strategies. In addition, you can configure each module's data access preference independently.
JDBC infrastructure provides a light-weight ORM mechanism that is sufficient to map relational tables to domain classes. By mapping domain classes to database tables, you can perform database CRUD operations and query data without SQL boilerplate. Not only do you query individual tables, you can also perform advanced queries that join multiple tables as well.
Speedy Framework facilitates the development of multi-tenant applications that serve multiple tenants and use the same database for all of them. Although the private data of tenants is strictly isolated, the interaction between tenants is possible for administrative purposes. Speedy Framework provides administrative screens to manage tenants and you can use them in your projects.
The first step for multitenancy is to identify the current tenant from the authenticated user. After logging in, it must be identified and stored in a context for the use of various modules. Of course, after closing the session, it must be removed from the context. Speedy Framework identifies the current tenant from username which is given as user@tenant format. This identification strategy can be customized according to the needs of the application.
Speedy Framework provides base classes for entities and value objects and fulfills multi-tenancy, optimistic locking and soft delete requirements for objects of classes derived from them regardless of underlying persistence mechanism, JDBC or JPA.
The EntityDao and EntityService classes are designed to execute CRUD operations for any entity, regardless of type. You can perform CRUD operations without writing a single line of code for DAO and service layers. In particular, it facilitates prototyping in the early stages of the development process.
The search criteria API allows you to query entities for both JDBC and JPA. The UI layer's search capabilities often use this facility at the backend, and this abstraction makes these UI components independent of the data access infrastructure details.
Database tables can hold millions of records, but UI components cannot handle all at once. Therefore, enterprise applications mostly use paging and lazy loading solutions. The Speedy Framework provides a pageable query structure and offers a lazy list. The lazy list can be seen as a specific java list implementation that holds only some records from the underlying data source and loads the remaining on demand. You can use it as simple as any ordinary list implementation without thinking about underlying lazy loading details.
Instead of deleting mission-critical data from database, Soft-delete facility can be used to deactivate it by marking as deleted. This data can be restored and activated again or permanently deleted.
The application context may contain some beans configured according to some data, and this data can be changed at run time. In this case, these beans should be informed and allowed to adjust their status for new conditions. You can annotate these kind of beans, so they can be refreshed when some critical data is changed and certain events are fired. Some security features use this facility to activate configuration changes immediately.
In addition to Spring Boot's script-based data population mechanism, Speedy Framework supports programmatic sample data population mechanism that enables the use of several services and DAO beans. You can generate sample data without SQL.
H2 is a lightweight Java-based database that can store data in memory or in a file system. While running your application, you can use Spring Boot's activator to investigate the data in the H2 database. Beside this, with Speedy Framework's H2Debugger, you can intercept any method invocation and open the H2-Console from the code. H2-Console opens in the default browser and you can see the data in the current active transaction. This can be used to investigate the data generated by transactional test methods that will eventually be rolled back at the end of the test.
Management screens are available for users, roles, and groups. Using these screens, administrators can create new records or modify or delete existing ones. They can also build role and group hierarchies, assign roles, add users to groups and reset users' passwords. The Speedy Framework sends users an automatic e-mail after the account creation and password reset. Users can update their profiles and change existing passwords.
Access control lists are widely used to manage restrictions for critical secure resources. You can use access control lists for any resource in your Speedy applications. The management screens simplify the configuration of access control lists and allow them to be updated at run time.
Security events are automatically published in authentication and authorization processes. These events are captured, security audit logs are created from them and these logs are saved for further analysis. Speedy Framework provides administrative screens for searching and browsing security audit logs. You can also handle these security events and apply detailed analysis for your own projects.
Spring Security can be configured to intercept urls and apply some restrictions. Speedy Framework makes this configuration updatable. You can change access configuration in runtime.
Enterprise applications can have a variety of users and their main focal points may differ from each other. For example, while the customer management screen may be the main screen for sales representatives, this screen has no special priority for a human resources specialist. The most important screen for him may be a screen related to organization hierarchy. With Speedy Framework's redirection feature, you can direct salespeople to the customer management screen and human resources specialists to the organization management screen.
Attempts to access the login page after successful authentication doesn't make sense and, can be confusing in some cases. Therefore, Speedy Framework doesn't allow authenticated users to access the login page and redirects them to the application's homepage.
During development, developers often want to see what they are developing, so they run the application repeatedly as a particular user. After some repetitions, the login process for each attempt can be annoying. Speedy Framework makes it possible for a particular user to skip the login process, so developers can access the homepage directly without logging in. This feature significantly speeds up the development process.
Users can perform some operations on behalf of other users. Substitution rules can be configured and audit logs hold information related with both actual user and substituted user.
Captcha strengthens security by eliminating repetitive malicious access attempts to steal user passwords. It guarantees that the authenticated user is not a machine, but a real person. Speedy Framework provides captcha validation support and this can be activated/deactivated easily.
Enterprise applications are generally security-sensitive applications, and restricting some users to access from outside a particular region is a common security requirement. Speedy Framework applies IP checks by default. If you want to allow some users to login from a specific IP block, simply enter this IP block from user management screen.
Enterprise applications are subject to strict security policies. Managing user secrets takes part in the heart of them. Thanks to Spring Security, most of requirements to keep them safe are met by default. Speedy Framework makes Spring Security's capabilities more useful, and adds some supporting features.
Passwords should be considered valid within a period of time and must be changed periodically. Speedy Framework checks the expiration time and directs the current user to the password change screen.
System administrators can be allowed/forbidden to define a password for other users. They can only be restricted to reset other users' passwords; so that the passwords can be stored as a secret known to the owners. After resetting a password, the generated password is sent to the user by e-mail and the system administrator does not see the user's new password.
Speedy Framework introduces configurative page level security. Read or write access to any UI field and actions on any page can be restricted for individual users, roles or user groups.
Root access in computer systems provides unlimited access to any file, and the root user can do anything within the system. Speedy Framework uses this concept for enterprise applications. For unlimited access to anything within the application, Speedy Framework offers a root user and a root role. This feature significantly speeds up the development process and can be enabled/disabled easily.
Spring's MessageSource is a powerfull i18n feature for enterprise applications. It resolves localized messages from *.properties files and allows them to be reloaded for changes in these files. Speedy Framework takes this feature a step further and allows administrators to update localized messages from screens at runtime. Additionally, new language supports can be added. The dynamic user interface and reporting capabilities of Speedy Framework allow screens and reports to be redesigned from scratch, and these screens and reports can be easily internationalized with this feature.
Although MessageSource bean is a Spring managed bean, libraries that are not familiar with Spring, such as reporting, can use it as a ResourceBundle.
The current user's locale can be determined from user preferences, from request or from a cookie and can be changed from the user interface. Others modules are automatically notified for locale changes and they can adjust themselves according to new locale settings.
Captions for UI components can be localized declaratively by specifiying message key and their localized values are automatically displayed according to the given key.
Enum values can be easily localized. If a localized message exists with the fully qualified name of the enum, Speedy Framework displays it.
For message aware runtime exception instances, localized messages are displayed on the screen.
The user profile screen contains a section for regional settings and users can change their default language, country, time-zone and currency preferences.
Service and entity level audit logging can be configured declaratively and system adminitrators can keep track of method invocations and can see which part of any entity has been changed by whom and when. Audit log records can be categorized and each module can add new categories to the system. Audit log records can be analyzed on the screen.
Speedy Framework can collect runtime statistics such as minimum, maximum and average execution times for methods. Administrators can analyze them on the screen and capture clues for bottlenecks. Methods that are subject to performance monitoring can be defined declaratively by XML and annotations. Performance monitoring can be activated/deactivated on the screen at runtime.
Speedy Framework provides a production-ready reporting screen. This screen allows users to enter report parameters and generate reports in various formats such as PDF, XLS, DOC and HTML. Users can view, download, or send the report directly as an e-mail attachment.
Reporting screen also allows administrators to configure access restrictions for reports. Access restrictions use resource-level security infrastructure and access control lists.
New reports can be designed from scratch on-demand and existing reports can be modified completely. Visual modifications can be done easily by dragging and dropping report elements.
Speedy Framework exposes an endpoint to fulfill report requests. Users can send reporting queries to this endpoint and receive the generated report in response. They can save report queries and recreate the same report. Thereby, changes in data can be monitored over a time period. This feature is also useful for interactive drill-down reports. Report rows can contain links to detailed reports and these links can be used even in PDF or XLS formats.
Thanks to Vaadin, UI components can be easily implemented with Java. However this should not encourage developers to write all code in their UI classes. The logic of appearance and presentation should be separated. MVP (Model-View-Presenter) recommends this. Speedy takes this up seriously and strongly encourages using MVP for UI components.
Todays interactive web applications require UI components to comunicate with each other. This forces them to be coupled with other components, making it difficult to manage the code. To eliminate this unwanted dependency and simplify the interaction between UI components, Speedy Framework offers an event bus. Published events are also multicasted through Spring's application event publisher and they can be handled by Spring's event listener beans.
The first impression is essential and the homepage gives the first impression of web applications. Production-ready homepage, login page and error page implementations are presented to you by Speedy Framework in advance. You can use, customize or completely replace them for your projects. Their layouts can be redesigned with UI Designer at runtime.
Placement of UI components in pages can be configured easily by dragging and dropping. Speedy Framework provides ready to use UI templates, but it doesn't enforce any fixed UI design.
Speedy Framework provides an infrastructure for information and confirmation messages. Localized information and error messages are automatically displayed according to the outcome of the service layer. The approval (confirmation) flow is performed automatically for annotated presenter methods.
Unhandled exceptions are processed just before the response is returned and an appropriate error message is automatically displayed. If a localized error message can be resolved, it is displayed. Otherwise, Speedy Framework displays a general error message so that the user scenario is executed without crash. Message aware runtime exceptions and errors related with access denial and data integrity violations can be easily converted to localized error messages.
Speedy Framework introduces declarative model binding for annotated UI fields. You can also bind nested complex objects to UI components declaratively.
For web based enterprise applications, it is important to alert the user for unsaved changes before exiting the current scenario. Speedy Framework provides a built-in mechanism for dirty-checking before navigation.
For an enterprise application, the majority of use cases can be classified as CRUD. CRUD scenarios require a search and filtering featured list for records. They also require detailed form components to edit the records. Speedy Framework provides list and detail templates ready for use. You can implement fully-featured CRUD scenarios including search, listing, creation, updating and deletion in a few minutes. These templates use EntityService and EntityDao at the back end so you don't need to implement anything for the service and dao layers. List and detail templates come with built-in paging, filtering and bulk processing capabilities and their layouts can be customized with UI Designer.
Speedy Framework creates an application menu by scanning annotated page classes. Annotations are also used for navigation and breadcrumb configuration. UI modules use this infrastructure to place their administrative pages in appropriate positions in the application menu. The placements, titles, and icons of menu items can be changed by administrators at run time.
You can implement several small UI widgets for your application and display them with Speedy Framework's built-in dashboard. Application level dashboard can be customized for each user independently.
Speedy Framework introduces a proxy-based mechanism for enriching pojos with new capabilities such as dirty-checking and change-tracking. Dirty-checking allows detection of unsaved changes and change-tracking makes it possible to handle old and new values of fields and added/removed items of collections.
Annotated methods can be used for building tool bars. The captions and visual features of the tool bar buttons can be customized and they can be enabled or disabled according to page level security configuration. Speedy Framework handles them automatically by using declarations given by method level annotations and you can override these declarations.
Vaadin Test Bench simplifies the UI tests. If you have a Vaadin Test Bench license and want to use it for your projects you can also take advantage of Speedy Framework's additional UI testing capabilities such as application bootstrapping, automatic web driver management and pause option after test scenarios.
Speedy Framework provides service level declarative and entity level programmatic validation capabilities based on JSR-303 validation specs. Validation errors from service level validation checks can be displayed as localized error messages and the corresponding UI components can be marked.
Speedy Framework supports both synchronous and asynchronous email sending. In case any error in synchronous sending, the user is alerted directly. For asynchronous mails, Speedy Framework retries to send again in a few minutes. Administrators can list all emails created in the system. They can edit them or compose new mails.
Speedy Framework provides context-sensitive, multilingual help facilities. Help content can be stored in the database or file system and can be accessed via the REST API.
Most enterprise applications are in close contact with documents and files. Speedy Framework introduces a REST based API for document uploading, downloading, updating content and versioning. You can store documents in the database or file system.
Speedy Framework simplifies multi-tenant access to caches and allows debugging cache content at runtime.
Speedy modules can be integrated together like plug-ins. They can enrich capabilities of others, change their configurations and add extra functionalities.
In addition to configuration features with text files such as *.properties and *.yml files, Speedy Framework introduces a type-safe variable definition and usage mechanism, so that environmental variables become easier to follow, and the affected codes can be easily detected after refactoring. Beside Speedy's type-safe configuration they can be overridden by text files as well.
ThreadLocals can only be accessed within the same thread and they must be cleared at the end. Otherwise they may cause information leakage, if their corressponding threads are pooled. Speedy Framework keeps values of thread local variables between sequential requests and safely removes them at the end of request-reponse process, so that the contextual data can be used inter-request operations without the possibility of data leakage caused by dirty thread locals.
Business event firing configuration can be made declaratively before or after any service method, or in case of any exception. The published events include the method parameters and the returned value as contextual data.