Pour améliorer les performances dans les applications Java, choisissez entre ehcache et caféine en fonction de vos besoins. 1. Pour la mise en cache en mémoire moderne légère, utilisez de la caféine - affrontez-la en ajoutant la dépendance, en configurant un haricot de cache avec la taille et l'expiration et en l'injectant dans les services. 2. Pour les cas d'utilisation avancés ou au niveau de l'entreprise nécessitant un stockage ou un clustering de disque, utilisez ehcache - azé sa dépendance, définissez des configurations dans ehcache.xml et initialisez un gestionnaire de cache pour l'utilisation de la mémoire tas et off-mal. 3. Appliquer des stratégies d'expulsion comme l'invalidation basée sur le temps, la taille ou la taille manuelle, et gérer la cohérence du cache en fonction des modèles de lecture / écriture pour garantir les performances et la précision des données.

La mise en cache est un moyen puissant d'améliorer les performances des applications Java en réduisant les calculs redondants ou les appels de base de données. Si vous travaillez avec des frameworks comme le printemps ou le création d'applications autonomes, la mise en ?uvre d'une stratégie de mise en cache solide à l'aide de bibliothèques comme Ehcache ou de la caféine peut faire une réelle différence.

Choisissez la bonne bibliothèque de mise en cache

La première décision que vous devez prendre est la bibliothèque à utiliser. Ehcache et la caféine sont des choix populaires, mais ils répondent aux besoins légèrement différents.

• EHCACH est riche en fonctionnalités, prend en charge le stockage, le clustering basé sur le disque et s'intègre bien aux applications Java EE plus anciennes.
• La caféine est légère, moderne et a une API plus intuitive, en particulier pour la mise en cache en mémoire dans les applications de démarrage de Spring.

Si vous démarrez frais et que vous n'avez pas besoin de mettre en cache distribué hors de la bo?te, optez pour la caféine. Si votre système peut évoluer à travers les n?uds ou si vous avez besoin de persévérance, ehcache pourrait être mieux adapté.

Configurez la mise en cache de base avec de la caféine

Passons un exemple simple à l'aide de la caféine dans une application de démarrage de printemps.

Tout d'abord, ajoutez la dépendance:

 <dépendance>
    <GroupId> com.github.ben-manes.caffeine </rombandid>
    <ArtefactId> Cafeine </RetingActid>
</Dependance>

Ensuite, configurez le haricot de cache:

 @Configuration
classe publique Cacheconfig {

    @Haricot
    Cache publique <String, objet> CaffeineCache () {
        retourner caféine.newbuilder ()
                .MaximumSize (100)
                .expirefterwrite (10, timeUnit.Minutes)
                .construire();
    }
}

Vous pouvez maintenant injecter ce cache dans votre service et l'utiliser:

 @Service
classe publique MyService {

    cache final privé <string, objet> cache;

    public myService (cache <string, objet> cache) {
        this.cache = cache;
    }

    objet public getData (clé de cha?ne) {
        return cache.getItifpresent (clé);
    }

    public void putData (clé de cha?ne, valeur d&#39;objet) {
        cache.put (clé, valeur);
    }
}

Cela vous donne un cache en mémoire qui inscrit automatiquement les entrées après 10 minutes ou lorsque la taille dépasse 100 éléments.

Configurer ehcache pour des cas d'utilisation plus avancés

Ehcache est un peu plus impliqué mais offre plus de flexibilité, surtout si vous avez affaire aux applications de niveau d'entreprise.

Commencez par ajouter la dépendance:

 <dépendance>
    <bandrandId> org.ehcache </rombandid>
    <ArtefactId> ehcache </ artifactid>
</Dependance>

Créez un fichier ehcache.xml dans votre dossier de ressources:

 <config xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance"
        xmlns = "http://www.ehcache.org/v3"
        XSI: ScheMalation = "http://www.ehcache.org/v3 http://www.ehcache.org/schema/ehcache-core-3.0.xsd">

    <cache alias = "mydatacache">
        <key-type> java.lang.string </ key-type>
        <Value-Type> java.lang.object </ Value-Type>
        <Sessiers>
            <Heap Unit = "Entrées"> 2000 </ tas>
            <offheap Unit = "MB"> 10 </ offheap>
        </ Ressources>
    </cache>
</ config>

Créez ensuite un gestionnaire de cache et utilisez-le:

 CacheManager CacheManager = CacheManagerBuilder.NewCacheManagerBuilder (). Build ();
cacheManager.init ();

Cache <string, objet> myCache = cacheManager.getCache ("myDatacache", string.class, object.class);

// utilisation
myCache.put ("SomeKey", SomeValue);
Valeur objet = myCache.get ("SomeKey");

Cela met en place un cache qui utilise à la fois une mémoire de tas et de mémoire hors tas, ce qui aide à réduire la pression GC et permet des ensembles de données plus grands.

Considérez l'expulsion et la cohérence du cache

Peu importe la bibliothèque que vous choisissez, vous devez réfléchir attentivement à la fa?on et au moment où les données sont supprimées du cache.

Voici quelques stratégies d'expulsion courantes:

• Basé dans le temps: expirer les entrées après un certain temps (par exemple, 5 à 10 minutes).
• Taille basée sur la taille: limitez le nombre d'entrées conservées en mémoire.
• Invalidation manuelle: effacer les clés spécifiques lorsque les données sous-jacentes changent.

Envisagez également la cohérence du cache:

• Dans les systèmes lourds en écriture, mettez à jour ou invalider des valeurs mises en cache sur les écritures.
• Pour les scénarios à lutte à lutte élevée, les lectures périmées peuvent être acceptables si vous utilisez un rafra?chissement ou autorisez les lectures périmées avec des politiques de rafra?chissement.

Assurez-vous que votre stratégie s'aligne sur la fa?on dont vos données se comportent et le type de garantie de performance dont vous avez besoin.

C'est essentiellement ?a. Ce n'est pas trop complexe, mais cela nécessite une configuration réfléchie en fonction des besoins de votre application.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!