Notice: this Wiki will be going read only early in 2024 and edits will no longer be possible. Please see: https://gitlab.eclipse.org/eclipsefdn/helpdesk/-/wikis/Wiki-shutdown-plan for the plan.
Difference between revisions of "Scout/Concepts"
m |
(→Plugin-Set: explained the image) |
||
| Line 27: | Line 27: | ||
* Swing UI Plug-In for individual desktop applications (eg <code>your.application.ui.swing</code>) | * Swing UI Plug-In for individual desktop applications (eg <code>your.application.ui.swing</code>) | ||
* Rap UI Plugin for web (2.0) applications (eg <code>your.application.ui.rap</code>) | * Rap UI Plugin for web (2.0) applications (eg <code>your.application.ui.rap</code>) | ||
| + | |||
| + | The image "Plugin-Set of a Scout Application" shows how the plug-ins are organized. In the above part of the image you can see the plug-ins of a typical scout application: client, shared, server and the ui-plugin. In to bottom part there are the equivalent plug-ins of the Scout Runtime Framework. All these plug-ins follow strict dependency rules which are represented by the arrows. The application's server plug-in for example does not know anything about the client it only knows the shared plug-ins and the server plugin of scout. | ||
== Overview of the concept pages == | == Overview of the concept pages == | ||
Revision as of 04:42, 4 November 2011
The Scout documentation has been moved to https://eclipsescout.github.io/.
The Concepts pages define concepts and elements used in the Eclipse Scout Framework.
Contents
Big Picture - Main Architecture of Scout
Scout is a framework for creating modern business applications. Such applications are typically separated into multiple tiers where each tier is responsible for a specific part of the application like presenting information to the user or processing business logic and persisting data.
Scout solves these requirements by providing a separation of such tiers out of the box. The two main tiers of Scout are the client part and the server part.
Scout is also a framework, which is simple to use but yet flexible. This is achieved, amongst other things, by using a stable platform as base, namely Eclipse / Equinox. By using this base on both the client and the server side, it becomes possible to use the same technologies and tools for creating the server and the client part. Even though these tiers are separated, there is no need to use different Eclipse workspaces or even different developers for each tier. One developer is able to create a multi tier application in one Eclipse workspace and still has a strict separation of client and server thanks to OSGI/Equinox.
Another thing that makes it so simple is the communication between these tiers. There is no need to explicitly define webservice and exchange WSDLs in the same application, only to show some information on a dialog (not implying that it would not possible to do so, it actually is!). Instead OSGi services are used where only an interface is sufficient. That interface for a service including the data transfer objects (DTO) is known on client and server side. This is achieved by having these interfaces in a shared part. With that mechanism it is possible to provide a service tunnel, which actually is one webservice tunneling every OSGi service call from client to server.
Plugin-Set
A Scout project is composed of different Eclipse plug-ins (each plug-in is an Eclipse Project).
- Client Plug-In (eg
your.application.client) - Shared Plug-In (eg
your.application.shared) - Server Plug-In (eg
your.application.server)
Since the Scout runtime relies on a strict separation of business code and presentation code additional plugins are provided where GUI specific code is placed. Depending on the GUI implementation these plugins can be one of the following:
- SWT UI Plug-In for native desktop applications (eg
your.application.ui.swt) - Swing UI Plug-In for individual desktop applications (eg
your.application.ui.swing) - Rap UI Plugin for web (2.0) applications (eg
your.application.ui.rap)
The image "Plugin-Set of a Scout Application" shows how the plug-ins are organized. In the above part of the image you can see the plug-ins of a typical scout application: client, shared, server and the ui-plugin. In to bottom part there are the equivalent plug-ins of the Scout Runtime Framework. All these plug-ins follow strict dependency rules which are represented by the arrows. The application's server plug-in for example does not know anything about the client it only knows the shared plug-ins and the server plugin of scout.
Overview of the concept pages
- The Scout documentation has been moved to https://eclipsescout.github.io/.
- Service Tunnel
- Session Handling
- The Scout documentation has been moved to https://eclipsescout.github.io/.
- Separation of UI and GUI
- Threading and Jobs
- Layouting
- Component Model
- The Scout documentation has been moved to https://eclipsescout.github.io/.
- Providing data for the client
- Accessing persistent data
- Webservice (JAX-WS) support
- Server Side Equinox
- Transaction Handling
- The Scout documentation has been moved to https://eclipsescout.github.io/.
- The Scout documentation has been moved to https://eclipsescout.github.io/.
- The Scout documentation has been moved to https://eclipsescout.github.io/.
- The Scout documentation has been moved to https://eclipsescout.github.io/.
- The Scout documentation has been moved to https://eclipsescout.github.io/.
- The Scout documentation has been moved to https://eclipsescout.github.io/.
- Security Principles of Scout
- Authentication
- Authorization
- The Scout documentation has been moved to https://eclipsescout.github.io/.