2 About ActiveCache

This chapter describes the collection of WebLogic Server features referred to as ActiveCache. ActiveCache allows deployed applications to easily use Coherence data caches and seamlessly incorporate Coherence*Web for session management and TopLink Grid as an object-to-relational persistence framework.

ActiveCache is employed by applications running on WebLogic Server and provides replicated and distributed caching services that make an application's data available to all servers in a Coherence data cluster. ActiveCache provides direct access by applications to data caches, either through resource injection or component-based JNDI lookup, and lets you display, monitor, create, and configure Coherence clusters using the WebLogic Server Administration Console and WLST. New features in this release let you control (start, stop, and restart), configure, and monitor managed Coherence servers using the WebLogic Server Administration Server, via the Administration Console or WLST, along with the Java-based Node Manager.

Using ActiveCache with WebLogic Server instances enables you to create a data tier dedicated to caching application data and storing replicated session state. This is separate from the application tier—the WebLogic Server instances dedicated to running applications.

This chapter includes the following sections:


WebLogic Server 12.1.2 includes a Coherence container integration that standardizes the way Coherence applications are deployed and managed within a WebLogic Server domain. The instructions for setting up Coherence in this book are provided for backwards compatibility. New implementations should use the Coherence container integration. For details on packaging Coherence based applications, see Developing Oracle Coherence Applications for Oracle WebLogic Server. For details on creating and configuring Coherence clusters in a WebLogic Server domain, see Administering Clusters for Oracle WebLogic Server.

Adding Session State Persistence and Management

Using Coherence*Web with ActiveCache enables you to provide Coherence-based HTTP session state persistence to applications running on WebLogic Server. Coherence*Web enables HTTP session sharing and management across different Web applications, domains, and heterogeneous application servers. Session data can be stored in data caches outside of the application server, thus freeing application server heap space and enabling server restarts without losing session data.

For information on using Coherence*Web with WebLogic Server applications, see Administering HTTP Session Management with Oracle Coherence*Web.

Accessing Java Persistence API (JPA) Entities in the Data Cache

TopLink Grid's relational-to-object mapping capabilities allow ActiveCache to cache relational data. You can store copies of database queries and result sets in Coherence data caches. With this feature, database access occurs only when no cached copy of the required data exists, or when the application performs a create, update, or delete operation that must be persisted to the database. This added optimization provides improved scalability and performance to the system.

TopLink Grid allows JPA Entity caching. This lets you support very large, shared grid caches that span cluster nodes. Calls for JPA Entities cached in ActiveCache result in a get operation on the associated data cache. If the data cache does not contain the object, then the database is queried.

TopLink Grid enables you to direct queries to ActiveCache. If the desired query result is not found in the cache, it can be read from the database and then placed in the cache, making it available for subsequent queries. The ability of ActiveCache to manage very large numbers of objects increases the likelihood of a result being found in the cache, as read operations in one cluster member become immediately available to others.

Writing JPA Entities to the database is also made possible by TopLink Grid. Applications can directly write JPA Entities to the database, then put them into the data cache (so that it reflects the database state), or put JPA Entities into the data cache, and then have the data cache write them to the database.

For more information, see Accessing and Retrieving Relational Data.