[[cache_manager]]
= Cache Managers
The main entry point to {brandname} is the `CacheManager` interface that lets you:

* Configure and obtain caches.
* Manage and monitor clustered {brandname} nodes.
* Execute code across your cluster.

If you embed {brandname} in your application, then you use an
`EmbeddedCacheManager`. If you run {brandname} as a remote server, then you use
a `RemoteCacheManager`.

Cache Managers are heavyweight objects so you should instantiate only one
`CacheManager` instance per JVM in most cases.

[source,java]
----
EmbeddedCacheManager manager = new DefaultCacheManager(); <1>
----

<1> Starts a local, non-clustered, Cache Manager with no caches.

Cache Managers have lifecycles and the default constructors also call the
`start()` method. Overloaded versions of the constructors are available, but
they do not start the `CacheManager`. However, you must always start the
`CacheManager` before you can create caches.

Likewise, you must call `stop()` when you no longer require a running
`CacheManager` so that it releases resources. This also ensures that the Cache 
Manager safely stops any caches that it controls.

== Obtaining caches
After you configure the `CacheManager`, you can obtain and control caches.

Invoke the link:{javadocroot}/org/infinispan/manager/EmbeddedCacheManager.html#getCache(java.lang.String)[`getCache(String)`] method to obtain caches, as follows:

[source,java,options="nowrap"]
----
include::code_examples/GetCache.java[]
----

The preceding operation creates a cache named `myCache`, if it does not already exist, and returns it.

Using the `getCache()` method creates the cache only on the node where you invoke the method. In other words, it performs a local operation that must be invoked on each node across the cluster. Typically, applications deployed across multiple nodes obtain caches during initialization to ensure that caches are _symmetric_ and exist on each node.

Invoke the link:{javadocroot}/org/infinispan/manager/EmbeddedCacheManagerAdmin.html#createCache(java.lang.String,java.lang.String)[`createCache()`] method to create caches dynamically across the entire cluster, as follows:

[source,java]
----
include::code_examples/CreateCache.java[]
----

The preceding operation also automatically creates caches on any nodes that subsequently join the cluster.

Caches that you create with the `createCache()` method are ephemeral by default. If the entire cluster shuts down, the cache is not automatically created again when it restarts.

Use the +PERMANENT+ flag to ensure that caches can survive restarts, as follows:

[source,java,options="nowrap"]
----
include::code_examples/CreateCacheWithFlagsPermanent.java[]
----

For the +PERMANENT+ flag to take effect, you must enable global state and set a configuration storage provider.

For more information about configuration storage providers, see link:{javadocroot}/org/infinispan/configuration/global/GlobalStateConfigurationBuilder.html#configurationStorage(org.infinispan.globalstate.ConfigurationStorage)[GlobalStateConfigurationBuilder#configurationStorage()].

== Clustering Information
The `EmbeddedCacheManager` has quite a few methods to provide information
as to how the cluster is operating.  The following methods only really make
sense when being used in a clustered environment (that is when a Transport
is configured).

== Member Information
When you are using a cluster it is very important to be able to find information
about membership in the cluster including who is the owner of the cluster.

.link:{javadocroot}/org/infinispan/manager/EmbeddedCacheManager.html#getMembers()[getMembers()]
The +getMembers()+ method returns all of the nodes in the current cluster.

.link:{javadocroot}/org/infinispan/manager/EmbeddedCacheManager.html#getCoordinator()[getCoordinator()]
The +getCoordinator()+ method will tell you which one of the members is the coordinator
of the cluster.  For most intents you shouldn't need to care who the coordinator is.
You can use link:{javadocroot}/org/infinispan/manager/EmbeddedCacheManager.html#isCoordinator()[isCoordinator()]
method directly to see if the local node is the coordinator as well.
