Section Contents

• .NET — GigaSpaces .NET provides efficient interoperability between Java and .NET, unmatched levels of high-throughput and low-latency, the PONO, and support for Portable Binary Serialization (PBS).
  • .NET Executable Configuration — Defining parameters in XML configuration file and <Default.JvmSettings>.
  • .Net PONO API Framework — GigaSpaces JavaSpaces API Plain Old .NET Object support – the PONO.
  • Building Your First PONO Application — Build and run a .NET application using the GigaSpaces PONO API.
  • Monitoring JVM Memory and Threads in .NET Applications — Monitoring JVM memory and threads in .Net Applications, when troubleshooting application memory and thread consumption.
  • Using ExternalEntry — How to get your .NET application to work with the GigaSpaces JavaSpaces interface.
  • Using JDBC API and PONO API with .NET Applications — How to use the JDBC and POJO API with a C# application.
• About Interfaces & APIs
• CPP — C++ applications can communicate with the space by wrapping objects using the C++ projection of the ExternalEntry class, and using the C++ projections of the JavaSpaces methods.
  • CPP Examples — Finding a space; writing to and reading from space; working with transactions; using notifications; working with exceptions.
  • Java-to-CPP Mapping of Arrays — Array types; features; user restriction; multi-dimensional arrays; block accessors.
  • Java-to-CPP Mapping of Strings — Creating and using a Java String instance; extracting native characters; using strings in printf calls; mixing MFC CString and Java String instances.
  • Monitoring JVM Memory and Threads in CPP Applications — Monitoring JVM memory and threads in C++ Applications, when troubleshooting application memory and thread consumption.
• J2EE — GigaSpaces offers a large set of J2EE solutions and patterns, including caching, messaging, parallel processing, load-balancing and integration, all based on one common technology – the space.
  • J2EE JBoss Integration — JBoss installation; server configuration; GigaSpaces JBoss demo.
  • J2EE WebLogic 8 Integration — Installing WebLogic; setting security policy; GigaSpaces Weblogic 8 demo.
  • J2EE Websphere Integration — Installing WSAD; using correct JDK and JRE; ReplicatedSessionBean object; configuring server for an application; GigaSpaces WebSphere demo.
• JavaSpaces — JavaSpaces is the native API of the space, based on four methods: write(), read(), take(), and notify(). JavaSpaces supports local and distributed transactions, and allows applications to register for notifications on space data.
  • About Entries — An Entry is a typed set of objects, each of which may be tested for exact match with a template.
  • About Jini — Jini is an open architecture that allows the implementation of network services - One such service is JavaSpaces.
  • About Space Operations — A description of Entries, templates, the four primary kinds of operations – write, read, take, and notify, and the UpdateModifiers.UPDATE_OR_WRITE modifier.
  • Batch Operations — An extension of the JavaSpaces API, enabling operations with multiple objects in one call.
  • Compute Server - Master-Worker Pattern — Demonstrates how the master-worker is used to implement a parallel computing engine that calculates whether or not a given number is prime.
  • Continuous Query — How to continuously query the space with advanced matching, including boolean operators and inequalities.
  • Custom Query Pattern — The purpose of the custom query pattern is to extend the existing query capabilities by enabling users to write code and execute it as part of the query path.
  • ExternalEntry — A wrapper that allows any Java class to be written to the space, even if it does not comply with JavaSpaces requirements.
  • Externalizable Support — Using Externalizable to boost remote space performance with JavaSpaces operations.
  • FIFO Support — How to get objects in the same order in which they were written to the space.
  • Hello World Example — The Hello World example provides a short and simple illustration of how to use the space API.
  • Inheritance Support — GigaSpaces provides implicit access to the inheritence capabilities in the JavaSpaces specification.
  • JavaSpaces Iterator — Used to read objects matching multiple templates in one call.
  • JavaSpaces Notifications — Registering to receive notifications when objects are added or modified in the space – unicast, multicast and tokenized notifications.
  • JavaSpaces POJO — GigaSpaces JavaSpaces API Plain Old Java Object support - the POJO.
  • JavaSpaces Transaction Support — How to use distributed transactions (with Jini Transaction Manager), or local transactions.
  • JavaSpaces UID Support — How to access space objects using their unique identifiers (UID).
  • Managing Resources Lease — The LeaseRenewalManager provides systematic renewal and overall management of a set of leases associated with one or more remote entities on behalf of a local entity.
  • Moving From Outrigger to GigaSpaces — How to migrate from Outrigger with no re-compilation or re-deployment of code to clients.
  • Partial Update — Updating only some of the fields of an object in the space.
  • POJO Class and Field Level Annotations — POJO class and field level decorations using annotations and XML configuration files.
  • POJO Class and Field Level Annotations - 5.1 — POJO class and field level decorations using annotations and XML configuration files.
  • Querying the Space — An extension to the JavaSpaces API which allows object matching by SQL syntax or regular expression.
  • Space Administration API — Allows applications to start and stop a space; get status, statistics, and cluster mode; and shutdown a container.
  • Space Locking and Blocking — Using optimistic and pessimistic locking to preserve the integrity of changes in multi-user scenarios.
  • Typical JavaSpaces Workflow — How an application allocates a space and then uses the space to share information with another application.
• JDBC — GigaSpaces allows applications to connect to a space/cache using JDBC. A GigaSpaces JDBC driver accepts SQL statements, translates them to space operations, and returns standard result sets.
  • Getting JDBC Connection — Connecting to embedded or standalone space using the JDBC driver.
  • JDBC Application Requirements — JARs an application must have under its classpath to work with GigaSpaces.
  • JDBC Error Codes — List of JDBC error codes and their descriptions.
  • JDBC Procedure Call — Similar to the DBMS stored procedure; allows definition of Java business logic for calling JDBC statements on the space.
  • JDBC Query Processor JMX Console — Starting the JMX console; viewing cached SQL queries; viewing connection SQL queries.
  • JDBC Reserved Words — List of JDBC reserved keywords, datatypes, separators and operators.
  • JDBC Supported Features — Supported and non-supported features by GigaSpaces JDBC.
  • Running Query Processor — Running the Query Processor in standalone mode; relevant properties for JDBC applications.
  • SQL-Java Type Mapping — Mapping of Java class attributes; class names; field names; SQL/Java types.
  • Using iSQL with JDBC Driver — Setting up the GigaSpaces JDBC Connection in iSQL-Viewer, an open-source database front-end written in Java.
  • Using JDBC Driver with Embedded Space — Space connection URL; setting qp.properties; setting schema file properties, setting classpath.
• JMS — GigaSpaces allows applications to use the space as a messaging hub. Applications use JMS to create topics and queues as usual; these are transparently translated into space Entries.
  • About JMS Messages — Messages types, headers, and properties; creating a message.
  • Closing Down JMS — Closing message consumer objects, open sessions, and the JMS connection.
  • GigaSpaces JMS Limitations — Known limitations of the GigaSpaces virtual JMS implementation.
  • JMS Local Transactions — Starting, committing, rolling back; sending/consuming messages under local transaction; avoiding redelivery loops.
  • JMS User Security — How to specify a username and password when creating the JMS connection.
  • Message Selectors — Allowing the JMS provider, instead of each client, to select messages for deletion.
  • Obtaining JMS Connection — How to obtain a connection, either by creating a connection factory or obtaining it with JNDI.
  • Obtaining JMS Destination — Obtaining a destination from the session or using JNDI, and binding destination to the JNDI namespace.
  • Obtaining JMS Session — How to obtain a JMS session for transacted or non-transacted sessions, and for P2P queues or Pub/Sub topics.
  • Point-to-Point Messaging — Creating a QueueSender, sending messages, creating a QueueReceiver, receiving messages (sync/async), browsing messages.
  • Publish and Subscribe Messaging — Creating a TopicPublisher, publishing messages, creating a TopicSubscriber, receiving messages (sync/async), durable subs.
• Map-JCache — GigaSpaces provides a Map/JCache interface, which allows applications to write to a space/cache using the Map APIs – put(), get(), remove(), transaction() – or the richer JCache specification.
  • Map Exceptions — The two main exceptions thrown for cache problems: EntryVersionConflictException and CacheTimeoutException.
  • Map Iterator — Used to get objects matching multiple templates in one call.
  • Map Notifications — How to register to be notified when objects are put to or removed from the space/cache.
  • Map Optimistic Locking — How to you write applications under the assumption that put operations may fail, if the updated object is changed by someone else since it was read.
  • Map Pessimistic Locking — How to explicitly prevent multiple users from from performing get, put or remove operations with the same key under a transaction.
  • Map Transactions — Performing distributed and 'local' transactions on space/cache instances.
  • Writing Your First Map API Application — Environment setup and writing a Map hello world application.
• Spring — How to access the GigaSpaces Data Grid, Messaging Grid and Compute Grid using the Spring Framework, and deploy Spring applications and POJOs using the Service Grid.
  • About Spring Framework — An overview, architecture and basic usage scenarios of the Spring Framework (from Spring Reference Documentation).
  • Spring Configuration Files — A sample application context file; attributes of the POJO's DAO definition; transaction configuration; supported operations and code sample for POJO primary key setting.
  • Spring Data Grid Integration — Examples of the JavaSpaces Spring Template and JDBC Spring Template, two ways to access the Data Grid via Spring.
  • Spring Infrastructure Services — GigaSpaces automatically converts POJOs to space Entries, and provides Spring support for local and distributed transactions.
  • Spring Integration Implementation — Description of GigaSpaces Spring implementation classes: the factory bean; the Spring template; an extension of the JavaSpacesTemplate; and a local transaction factory bean.
  • Spring Messaging Grid Integration — An example of a JMS application working with Spring in GigaSpaces.
  • Spring Parallel Processing Integration — Sample implementation showing how to perform remote invocation for business logic of parallel processing units.