com.smartgwt.client.docs

## Interface IscServer

-     public interface IscServer

  ### Smart GWT Server Summary

  The Smart GWT Server is a set of Java libraries, servlets and tools that provide the key server-side components needed to build a complete application in the modern web architecture.

  The Smart GWT Server can be `integrated` into any pre-existing Java application, and is designed to rapidly connect Smart GWT visual components to pre-existing Java business logic or persistence engines. Smart GWT's Ajax request processing facilities can be easily integrated into Struts Actions, `Spring controllers`, or custom servlets and JSPs.

  Alternatively, the Smart GWT Server provides a complete SQL and Hibernate-based persistence engine for new applications, with out-of-the-box servlets for processing Ajax data requests.

  The Smart GWT Server is optional, and Smart GWT's client-side Ajax engine can be integrated with any server that provides HTTP access, using XML, JSON, SOAP or proprietary data protocols. However any server in a modern web application will be required to provide most or all of the features of the Smart GWT Server (described below), and the Smart GWT Server represents a best-of-breed implementation of these facilities with a long history of high-volume production deployments.

  #### Server enforcement of `Validators`

  Data passed from the browser can be automatically validated by the Smart GWT Server. In contrast, when using `client-side integration`, data arrives as HTTP params or XML messages, and you must parse values into the correct types (eg java.util.Date) and validate them, or use a server framework that does so.

  #### High Speed Data Delivery / Data Compression

  The Smart GWT Server delivers data to and from the browser using a proprietary, maximally efficient protocol, providing simple Java APIs for sending and receiving data.

  Smart GWT's data protocol is:

  - automatically compressed: provides 6-8x improvement in bandwidth utilization
  - efficient on the server: high speed data serialization for any Java Object
  - efficient in the browser: faster than ordinary XML or JSON data delivery
  - minimal: facilities for `trimming` and `extracting` only the data you want the browser to see

  #### Transparent upload support

  Smart GWT provides special client and server-side support for `file\n upload`, which allows single and multiple-file HTTP uploads to be performed as a background Ajax request without reloading the page or launching sub-windows.

  Uploaded files arrive at the Smart GWT server as Java InputStreams accessible from the DSRequest object, and can optionally be automatically stored via Smart GWT's SQL subsystem.

  #### Transparent Queuing / "Batch" Operations

  Any request transmitted to the Smart GWT Server can be combined into a "queue" transmitted as a single HTTP request, with in-order execution for all queued operations. `startQueue()` starts a queue and `sendQueue()` transmits it; queuing is transparent to the code that initiates the individual requests. This enables:

  - re-use of data access operations across different screens
  - easy implementation of transaction boundaries
  - simplified saving and loading of screens with complex, master-detail views
  - guaranteed in-order processing of operations
  - more efficient network usage

  #### Visual Builder

  `Visual Builder` is included with the Smart GWT Server, and uses server features such as automatic SQL binding to provide a rapid prototyping environment.

  #### Automatic Bi-directional Java < - > JavaScript serialization and translation

  Provides a powerful, type-safe `data transmission mechanism` for moving data between a Java server and the browser.

  Any Java objects, including Java Beans, POJOs, Java Collections, XML DOMs and all Java primitives, with any level of nesting, can be automatically serialized and delivered as JavaScript Objects to the Smart GWT client-side components.

  JavaScript Objects existing in the browser can likewise be automatically transmitted to a Java Server and translated to Java Objects, with any level of nesting and automatic preservation of primitive types.

  #### SQL and Hibernate connectors

  DataSources of serverType:"sql" or serverType:"hibernate" can generate and execute queries against popular SQL engines or against the Hibernate ORM system, providing Smart GWT's `DataBoundComponent`s with the four standard CRUD operations (create, retrieve, update, delete) without writing any server-side code. For rapid prototyping, these DataSources can even generate SQL tables based on the DataSource declaration, using the `Admin Console` visual tool.

  Server-side APIs allow server-side modification of the request before it is executed (for example, to enforce security) and post-processing of the request after execution (for example, to provide calculated values).

  Both serverType:"sql" and serverType:"hibernate" support the field-operator-value queries that can be generated by using the `FilterBuilder` component (see example).

  #### Rich, Standardized Request / Response protocol

  The Smart GWT Server provides a standardized request and response protocol designed for data-oriented "CRUD" operations (create, retrieve, update, delete).

  This standardized protocol automatically handles `request metadata` (paging parameters, requested sort order, original values of data being modified) and `response metadata` (error handling, cache management, session expiration etc).

  Similar to the impact of Struts on early web applications, this standardized protocol avoids developers in different groups inventing their own incompatible and redundant request/response protocols, and allows developers to more easily learn code they didn't author.

  #### Bi-directional XPath binding to Java Objects

  Most UI designs do not directly reflect the underlying Object model and so some degree of translation is necessary in order to populate UI components with data and apply user changes to the Java Object model. This is often accomplished with brittle, difficult to understand data translation code sprinkled throughout the system, done in a different way for every screen or component.

  Smart GWT provides a standard, `XPath-based approach` to adapting any Java-based Object model to the requirements of the UI design. Data relevant to the application UI is centrally extracted in the server-side `DataSource` layer, so that all UI components have a consistent, unified view of the data model for both loading and saving data.

  #### Broadest possible browser support

  The Smart GWT Server can compensate for facilities `missing or disabled in certain browsers`, including ActiveX being disabled in IE6 and missing XML support in some versions of Apple's Safari browser.

  #### Transparent Proxying

  `Proxying` allows Smart GWT applications to access web services, RSS feeds, HTML content and other data services in a secure manner regardless of where they are located: across the enterprise or publicly available.

  #### Optional `Network Performance` Module

  Provides:

  - compressed delivery of Smart GWT runtime, application logic and other assets such as CSS
  - background download of Smart GWT and other assets for zero user-perceived load time
  - on-the-fly stripping and combining of JavaScript (application code and data)
  - browser cache control

  #### Optional Messaging Module (aka server push)

  The `Messaging` module allows the server to "push" messages to the client, without client polling, for real-time monitoring/dashboarding applications.