[JAVA] J'ai essayé d'utiliser la fonction de cache d'Application Container Cloud Service

Oracle Application Container Cloud Service fournit des fonctionnalités de mise en cache. Vous pouvez l'utiliser pour mettre en cluster des applications, remplacer l'accès à la base de données, etc.

La description

Les capacités de mise en cache d'Oracle Application Container Cloud Service sont faciles à utiliser. La création d'un service de cache est terminée en définissant simplement la capacité utilisée pour le cache.

Les deux méthodes suivantes sont fournies pour accéder à cette fonction de cache.

REST API
Java API

** L'API REST ** est une méthode permettant d'utiliser directement l'API REST fournie par le service de cache à l'aide de l'API client REST telle que Jersey.

** L'API Java ** est une méthode permettant d'utiliser l'API pour le service de cache depuis l'application en utilisant la bibliothèque fournie par Oracle. Les étapes suivantes décrivent cette méthode API Java.

C'est un service de cache facile à utiliser, mais avec les règles d'utilisation suivantes:

--Plusieurs caches peuvent être créés dans un service de cache

Un seul service de cache peut être utilisé simultanément à partir d'une application. (Plusieurs caches peuvent être utilisés dans le service de cache)
Un service de cache peut être utilisé par plusieurs services de cache en même temps

une fonction

Les données de cache sont répliquées dans les membres du cluster ―― Même si un cache est corrompu, il peut être automatiquement récupéré à partir d'un autre cache.
Les données sont enregistrées même lorsque le service de cache est redémarré
Configuration évolutive

supposition

Les bibliothèques suivantes sont requises pour utiliser l'API Java pour les applications clientes du service de cache.

cache-client-api-1.0.0.jar

Obtenu par Maven en décrivant les dépendances suivantes:

Artifact ID: cache-client-api
- Group ID: com.oracle.cloud.caching

<dependency>
    <groupId>com.oracle.cloud.caching</groupId>
    <artifactId>cache-client-api</artifactId>
    <version>1.0.0</version>
</dependency>

comment utiliser

L'utilisation est expliquée ci-dessous en utilisant la méthode de rétention de session en utilisant HttpSession et Cache comme exemple.

Pour HttpSession

Si vous souhaitez utiliser HttpSession pour tenir une session, vous écrivez généralement un code comme celui-ci:

Obtenir des objets de session et définir des données

HttpSession session = request.getSession(true);
session.setAttribute("KEY", "1");

Obtenir les données de session

String value = (String) session.getAttribute("KEY");

Pour Cache (com.oracle.cloud.cache.basic.Cache)

1. Initialisation

Tout d'abord, récupérez le cache du service de cache et, s'il n'existe pas, créez le cache.

import com.oracle.cloud.cache.basic.Cache;
import com.oracle.cloud.cache.basic.RemoteSessionProvider;
import com.oracle.cloud.cache.basic.Session;
import com.oracle.cloud.cache.basic.options.Transport;
import com.oracle.cloud.cache.basic.options.ValueType;

String CACHE_HOST = System.getenv("CACHING_INTERNAL_CACHE_URL");
String CACHE_URL = "http://" + CACHE_HOST + ":8080/ccs/";
String CACHE_NAME = "sample";

Session cacheSession = new RemoteSessionProvider(CACHE_URL).createSession(Transport.rest());
Cache cache = cacheSession.getCache(CACHE_NAME, ValueType.of(String.class));

L'URL du service de cache est obtenue à partir de la variable d'environnement. La variable d'environnement à utiliser est ** CACHING_INTERNAL_CACHE_URL **. Utilisez System.getenv () pour obtenir la valeur.

String CACHE_HOST = System.getenv("CACHING_INTERNAL_CACHE_URL");

Vous pouvez choisir entre deux méthodes pour accéder au cache:

REST API
gRPC

Utilisez ** Transport ** pour configurer les paramètres lors de la création d'un objet Session comme indiqué ci-dessous:

RemoteSessionProvider(CACHE_URL).createSession(Transport.rest());
- Transport.rest(): REST API
- Transport.grpc(): GRPC API

2. Fonctionnement du cache

Ajouter / référencer / mettre à jour / supprimer des données dans le cache comme suit

ajouter à
cache.put("KEY", "VALUE") --Référence
cache.get("KEY") --Mise à jour
cache.replace("KEY", "VALUE")
Effacer
cache.remove("KEY")

Exemple de création d'environnement de cache d'application et d'exécution d'application

1. Création d'un service de cache

1.1. Sélection du cache d'application

Sélectionnez ** Application Cache ** dans le menu.

1.2. Création d'une instance de service de cache

Cliquez sur ** Créer une instance **.

1.3. Configuration du cache et paramètres de capacité

--Basic: ** Un seul ** Un conteneur pour le cache sera créé.

Recommandé: ** 3 conteneurs de cache ou plus ** seront créés.

1.4. Écran de confirmation

1.5. Création de l'écran

1.6. Achèvement de la création du service de cache

2. Déployez l'exemple d'application

2.1. Sélection des applications

Sélectionnez ** Application ** dans le menu.

2.2. Déployer l'application

Cliquez sur ** Créer une application **.

2.3. Sélection du temps d'exécution

Sélectionnez ** Java SE **.

2.4. Sélection de l'application à déployer

Sélectionnez l'application téléchargée à partir de l'URL suivante :

https://github.com/shinyay/oracle-accs-cache-api/releases/download/v1.0.0/cache-sample-1.0.0-SNAPSHOT.zip

Dans les choix en bas de l'écran, sélectionnez le service de cache que vous avez créé.

Cliquez sur ** Créer **.

3. Fonctionnement à l'aide de HttpSession

3.1. Accéder à l'exemple d'application

Cliquez sur l'URL affichée sur l'écran du tableau de bord. Les applications accessibles à partir de cette URL utiliseront HttpSession pour compter le nombre d'accès.

3.2. Premier accès

3.3. Deuxième accès

3.4. Troisième accès

3.5. Redémarrage de l'application

Cliquez sur ** Redémarrer ** dans le menu.

3.6. Quatrième accès après le redémarrage

Les données de session ne sont pas persistantes, donc un redémarrage initialise la session. Par conséquent, il sera à nouveau affiché comme ** Premier accès **.

4. Fonctionnement à l'aide du cache

4.1. Premier accès

Accédez à la racine de contexte en tant que ** cache **.

/ session: Servlet pour l'opération HttpSession
/ cache: Servlet avec opération Cache

4.2. Deuxième accès

4.3. Troisième accès

4.4. Redémarrage de l'application

4.5. Quatrième accès après redémarrage

Les informations de décompte d'accès sont stockées en tant que cache sur le service de cache, de sorte qu'il continue à compter même après le redémarrage.

5. Clustering avec cache

5.1. Déployer la même application avec un nom différent

Renommez et déployez la même application. Sélectionnez le service de cache comme à l'étape précédente.

5.2. Accéder à l'exemple d'application

Accédez à l'application qui exécute le cache.

5.3. Confirmation de l'opération de mise en cluster à l'aide du cache

Nous partagerons le nombre d'accès de chaque application et compterons chacun.

GitHub https://github.com/shinyay/oracle-accs-cache-api

Résumé

Avant l'avènement de la fonction de cache, la seule façon de conserver les données était de les stocker dans une base de données ou sous forme de fichier, il est donc pratique de pouvoir utiliser la fonction de cache. De plus, la fonction de cache n'avait pas d'API Java lors de son apparition, mais je pense que c'est également pratique en termes de codage car l'API Java est également fournie.