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 API Configuration — Defining parameters in XML configuration file and <Default.JvmSettings>.
  • .NET-Java Interoperability — Enabling interoperability between Java and .NET - creating interoperable class, supported types for matching and interoperability.
  • Building Your First .NET Application — Build and run your first .NET application.
  • GigaSpaces .NET Session State Store Provider — How to use the .Net GigaSpaces Session State Store Provider implementation.
  • Monitoring JVM Memory and Threads in .NET Applications — Monitoring JVM memory and threads in .Net Applications, when troubleshooting application memory and thread consumption.
  • PONO Class and Field Level Attributes — GigaSpaces .NET framework supports attributes to define the space class meta data information.
  • Setting up Visual Studio Project References — Setting up Visual Studio project to use the space-based .NET API.
  • Space-Based .NET API — Performing space operations with GigaSpaces space-based .NET API.
  • 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 JDBC in a .Net application.
• 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.
• 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 — Enables continuous queries of 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.
  • 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.
  • Querying the Space — An extension to the JavaSpaces API which allows object matching by SQL syntax or regular expression.
  • Schema Evolution — The space schema can be evolved using codebase downloading and Java extentions, or an explicit data migration process.
  • Session Based Messaging API — The new Notify Session API provides a unified and consistent mechanism for event registration.
  • 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.
• 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.
  • Browsing JMS Queues — Using the QueueBrowser to examine messages in a queue without deleting them.
  • JMS Failover — JMS behavior during failover, How to recover JMS applications from failovers.
  • JMS Known Issues and Limitations — Open issues, unsupported features, and limitations in GigaSpaces XAP 6.0.
  • JMS Messages in GigaSpaces — JMS messages implementation; supported and unsupported message types; message compression; accessing JMS messages via space API.
  • JMS-Space Interoperability — Creating JMS messages with the space API; reading/taking JMS messages with the space API; using JMS API with the MessageConverter to send custom POJOs to the space.
  • JMS Transactions in GigaSpaces — Using local and distributed transactions with the JMS implementation.
  • JMS User Security — Obtaining connections using client authentication.
  • Working with GigaSpaces JNDI — JNDI Overview, Binding/Obtaining ConnectionFactory and Destination instances.
  • Working with GSJMSAdmin — Obtaining JMS resources without JNDI, Using JNDI with GSJMSAdmin.
• 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.
• More Interfaces and APIs
  • J2EE-JCA — Applications can interact with the space from a Session/Entity Bean or Servlet by obtaining a reference to a GigaSpaces connector, which shares the connection-pooling policy and transaction with the caller bean.
  • 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.