Introduction
Notre connaissance est que le goulot d'étranglement d'un programme réside dans la base de données, et nos connaissances savent également que la vitesse de la mémoire est beaucoup plus rapide que celle du disque dur. Lorsque notre département doit obtenir les mêmes données à plusieurs reprises, notre département demande la base de données ou le service à distance encore et encore, ce qui entraîne beaucoup de temps consacré à la requête de base de données ou à des appels de méthode distante, entraînant une détérioration des performances du programme, ce qui est encore plus un problème que le cache de données doit résoudre.
Support de mise en cache de printemps
Spring définit l'org.springframework.cache.cachemanager et org.springframework.cache.cache interfaces pour unifier différentes technologies de mise en cache. Parmi eux, Cachemanager est une interface abstraite pour diverses technologies de cache fournies par le printemps. L'interface de cache comprend diverses opérations de cache (en ajoutant et en supprimant pour obtenir du cache, notre système ne traite généralement pas directement de cette interface)
Cachemanager soutenu par le printemps
Pour différentes technologies de mise en cache, différents cache -mangers doivent être mis en œuvre. Spring définit la mise en œuvre de CacheManager dans le tableau suivant.
Lors de la mise en œuvre d'un CacheManager, vous devez enregistrer un haricot qui implémente CacheManager. Bien sûr, chaque technologie de mise en cache a de nombreuses configurations supplémentaires, mais la configuration de CacheManager est essentielle.
Annotation de cache déclarative
Spring fournit 4 annotations pour déclarer les règles de cache (un exemple vivant d'AOP à l'aide de formules annotées), comme le montre le tableau.
Activer le cache déclaratif
L'activation du support de mise en cache déclaratif est très simple, il vous suffit d'utiliser l'annotation @enabelcaching sur la classe de configuration.
Prise en charge de Springboot
La clé de l'utilisation de la technologie de cache en Chine printanière est de configurer CacheManager. Springbok configure automatiquement plusieurs implémentations CacheManager pour notre porte. Dans l'environnement de démarrage Spring, l'utilisation de la technologie Cache nécessite uniquement l'importation des packages de dépendance de la technologie de cache associée dans le projet et la configuration de la classe pour activer le support de cache à l'aide de @enabelcaching.
Petits exemples
Un petit exemple est implémenté à l'aide du cache Springboot + JPA +.
Exemple d'étapes répertoire
1. Créer un projet Maven
Créez un nouveau fichier Maven Project Pom.xml comme suit:
<? xml version = "1.0" Encoding = "utf-8"?> <project xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.w3.org/2001/xmlschema-instance" XSI: ScheMalocation = "http://maven.apache.org/pom/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelversion> 4.0.0 </déraphine> <proupId> COM.us </prounid> <ArtifActid> Springbache-Cache </ ArtiFatrid> <version> 1.0-snapshot </ version> <parent> <proupId> org.springframework.boot </proupId> <Artifactid> printemps-boot-starter-Parent </ artifactid> <version> 1.3.0.release </-version> </dart-class> <maven.compiller.target> 1.8 </maven.compiller.target> <maven.compiller.source> 1.8 </maven.compiller.source> </ properties> <! - Ajouter des dépendances typiques pour une application Web -> <dépendances> <dependency> <proupId> org.springFrameworkwork. <ArtefactId> printemps-boot-starter-cache </letefactid> </dpendance> <dependency> <proupId> org.springframework.boot </proncId> <Artifactid> printemp-boot-starter-data-jpa </lefactive> </pedigency> <dependency> <proupId> org.springFrameworkwork.boot </ groupID> <ArtefactId> Spring-Boot-starter-web </letefactId> </ Dependency> <Dependency> <ProupId> net.sf.ehcache </pruipId> <Artifactid> ehcache </lefactid> </pedidency> <! - DB -> <Dedency> <ProupId> MySQL </prounid> <ArtefactId> MySQL-Connector-Java </ ArfactId> <Dersion> 6.0.5 </DERNIERSE> </ Dependency> <Dedency> <ProupId> com.mchange </proncID> <Artefactive> C3P0 </carfactive> <version> 0.9.5.2 </preinty> <cuslisions> <exclusion> <pouprid> Commons-Logging </ GroupId> <ArtefactId> Commons-Logging </ artifactid> </clusion> </clusion> </dependency> </Dependances> </rands>
2. Configuration de la base de données
Créez un nouveau fichier Application.Properties dans le répertoire SRC / Main / Esouches, et le contenu est des informations de connexion de base de données, comme suit:
application.properties
MS.DB.DRIVERCLASSNAME = com.mysql.jdbc.Divererms.db.url = jdbc: mysql: // localhost: 3306 / cache? prepstmtcachesize = 517 & cacheprepstmts = true & autoreConnec t = true & useunicode = true & caractotcoding = utf-8 & usessl = false & allatMultiqueries = truems.db.username = rootms.db.password = xxxxxxms.db.maxactive = 500.
Créez un nouveau fichier de configuration dbconfig.java et configurez la source de données
package com.us.example.config; / ** * créé par Yangyibo le 17/1/13. * / Importer java.beans.propertyvetoException; import org.springframework.beans.factory.annotation.autowired; import org.springframework.context.annotation.bean; import org.springframework.context.env.connironment; import org.springframework.core.env. com.mchange.v2.c3p0.CombopooledDatasource; @configurationpublic classe dbconfig {@autowired private Environment Env; @Bean (name = "DataSource") public combopoolEdDataSource dataSource () lève PropertyVetoException {combopooledDataSource dataSource = new combopoolEdDataSource (); DataSource.setDriverClass (Env.getProperty ("Ms.DB.DriverClassName")); dataSource.setjdbcurl (Env.getProperty ("Ms.db.url")); DataSource.SetUser (Env.GetProperty ("Ms.DB.Username")); DataSource.SetPassword (Env.GetProperty ("Ms.DB.Password")); dataSource.setMaxPoolSize (20); DataSource.setMinpoolSize (5); DataSource.SetInitialPoolSize (10); DataSource.setMaxidleTime (300); DataSource.setacquireInCment (5); DataSource.SetIdleConnectionTestPeriod (60); return dataSource; }}Conception de la base de données, la base de données n'a qu'une seule table de personne et la conception est la suivante:
3. JPA Configuration
Le fichier de configuration Spring-Data-JPA est le suivant:
package com.us.example.config; import java.util.hashmap; import java.util.map; import javax.persistence.entityManagerFactory; import javax.sql.datasource; import org.springframework.beans.factory.annotation.autowired; import; org.springframework.context.annotation.bean; import org.springframework.context.annotation.configuration; import org.springframework.data.jpa.repository.config.enablejpaSitries; import org.springframework.or org.springframework.orm.jpa.LocalContainerentityManagerFactoryBean; import org.springframework.orm.jpa.vendor.hibernatejpavendoradapter; import org.springframework.transaction.platformtransactionManager; org.springframework.transaction.annotation.enabletransactionManagement; / ** * créé par Yangyibo le 17/1/13. * / @ Configuration @ activerjParePositories ("com.us.example.dao") @ impletransactionManagement @ ComponentsCanpublic class jpaconfig {@autowired private dataSource dataSource; @Bean Public EntityManagerFactory EntityManagerFactory () {HiberNateJPavendorAdapter VendorAdapter = new HiberNateJPavendorAdapter (); LocalContainerEntityManagerFactoryBean Factory = new localContainerEntityManagerFactoryBean (); factory.setjpavendoradapter (vendoradapter); factory.setPackAgEstoscan ("com.us.example.bean"); factory.setDataSource (dataSource); Map <string, objet> jpaproperties = new hashmap <> (); jpaproperties.put ("hibernate.ejb.naming_strategy", "org.hibernate.cfg.improvednamingstrategy"); jpaproperties.put ("hibernate.jdbc.batch_size", 50); factory.setjpapropertymap (jpaproperties); factory.afterpropertiesset (); return factory.getObject (); } @Bean Public PlatformTransactionManager TransactionManager () {JPatransactionManager txManager = new JPatransactionManager (); txManager.SetEntityManagerFactory (EntityManagerFactory ()); retour txManager; }}4. Écrivez des haricots et des couches DAO
Person de classe d'entité.java
package com.us.example.bean; import javax.persistence.entity; import javax.persistence.generatedValue; import javax.persistence.id; import javax.persistence.table; / ** * créé par yangyibo le 17/1/13. * / @ Entité @ table (name = "personne") Personne de classe publique {@id @GeneratedValue Private Long ID; nom de chaîne privé; Âge entier privé; adresse de chaîne privée; Public () {super (); } Personne publique (ID long, nom de chaîne, âge entier, adresse de chaîne) {super (); this.id = id; this.name = name; this.age = âge; this.address = adresse; } public long getID () {return id; } public void setid (long id) {this.id = id; } public String getName () {Nom de retour; } public void setName (string name) {this.name = name; } public Integer Getage () {Return Age; } public void Setage (entier Âge) {this.age = age; } public String getAddress () {return adresse; } public void setAddress (adresse de chaîne) {this.address = adresse; }}Couche Dao, PersonRepostory.java
package com.us.example.dao; import com.us.example.bean.person; import org.springframework.data.jpa.repository.jParepository; / ** * créé par Yangyibo le 17/1/13. * / Interface publique PersonPository étend JParePository <personne, long> {}5. Écrivez la couche de service
interface de service
package com.us.example.service; import com.us.example.bean.person; / ** * créé par Yangyibo le 17/1/13. * / interface publique Démoservice {Person public Save (personne personne); public Void supprimer (ID long); Personne publique Findone (personne personne);}Implémentation: (clé, ajouter du cache ici)
package com.us.example.service.impl; import com.us.example.bean.person; import com.us.example.dao.personrepository; import com.us.example.service.demoservice; import org.springframework.beans.factory.annotation.autowired; import org.springframeworkwork.cache.cache.cootation; importation; org.springframework.cache.annotation.cacheput; import org.springframework.cache.annotation.cacheable; import org.springframework.steoteotype.service; / ** * créé par Yangyibo le 17/1/13. * / @ ServicePublic Class DemoServiceIMP implémente DemoService {@Autowired PersonPository PersonRepository; @Override // @ Cacheput cache des données nouvellement ajoutées ou mises à jour dans le cache, où le nom du cache est des gens. La clé des données est l'ID de la personne @cacheput (valeur = "People", key = "# personne.id") Personne publique Save (personne personne) {Person P = PersonRepository.save (personne); System.out.println ("Pour ID, la clé est:" + p.getID () + "Data Cached"); Retour p; } @Override // @ cacheevict Supprimer les données avec l'identifiant clé de cache personnes @cacheevict (value = "People") public void supprimer (id long) {System.out.println ("supprimé le cache de données avec l'ID et la clé" + id + "); // L'opération de suppression réelle n'est pas effectuée ici} @Override // @ @ cacheable Cache est spécifié, les paramètres de la méthode sont enregistrés dans le cache en tant que clé.6. Écrivez le contrôleur
Pour la commodité des tests, Get est utilisé
package com.us.example.controller; import com.us.example.bean.person; import com.us.example.service.demoservice; import org.springframework.beans.factory.annotation.autowired; import org.springframework.sterreotype.controller; import; org.springframework.web.bind.annotation.requestmapping; import org.springframework.web.bind.annotation.responsebody; import org.springframework.web.bind.annotation.restController; / ** * créé par Yangyibo le 17/1/13. * / @ RestControllerPublic Class CacheController {@Autowired private Demoservice Demoservice; // http: // localhost: 8080 / put? name = abel & age = 23 & adresse = shanghai @requestmapping ("/ put") Person public put (personne personne) {return DemoService.save (personne); } // http: // localhost: 8080 / cap? id = 1 @RequestMapping ("/ capy") @ResponseBody Person Personableable (personne personne) {return Demoservice.FindOne (personne); } // http: // localhost: 8080 / evit? id = 1 @requestmapping ("/ evit") public String Evit (long id) {DemoService.Remove (id); retourner "ok"; }}7. Démarrer le cache
N'oubliez pas d'activer la configuration du cache dans la classe de démarrage.
package com.us.example; import org.springframework.boot.autoconfigure.springbootapplication; import org.springframework.cache.annotation.enablecaching; import org.springframework.context.configurableApplicationContex org.springframework.boot.springApplication. *; / ** * Créé par Yangyibo le 17/1/13. * / @ ComponentsCan (basepackages = "com.us.example") @ SpringbootApplication @ perteCachingPublic class application {public static void main (String [] args) {configurableApplicationContext run = run (application.class, args); }}8. Capacité de vérification et de vérification de test:
Démarrez la classe d'application, et après l'avoir démarré, entrez: http: // localhost: 8080 / cap? Id = 1 dans le navigateur (d'abord pour initialiser plusieurs données dans la base de données.)
Sortie de la console:
"Les données de l'ID et de la clé sont: 1" a été mise en cache pour cette requête. Si vous interrogez à nouveau les données, cette instruction n'apparaîtra pas, c'est-à-dire que la base de données ne sera pas interrogée.
Inspection mise en place
Entrez dans le navigateur: http: // localhost: 8080 / put? Name = abel & age = 23 & adresse = shanghai (insérer une données dans la base de données et mettre les données dans le cache.)
À l'heure actuelle, la sortie de la console cache l'enregistrement:
Ensuite, appelez à nouveau la méthode ABLE pour interroger les données. La base de données ne sera plus interrogée et les données seront lues directement à partir du cache.
Tester
Entrez: http: // localhost: 8080 / evit? Id = 1 dans le navigateur (effacez l'enregistrement du cache, après l'avoir effacé, l'enregistrement sera remis dans le cache après avoir accédé à l'enregistrement.)
Sortie de la console:
Cache de commutation
1. Passez à ehcache comme cache
Ajouter des dépendances dans le fichier pom.xml
<dependency> <proupId> net.sf.ehcache </rompuprid> <letfactId> ehcache </ artifactid> </dependency>
Créez le fichier de configuration ehcache.xml dans le dossier de ressources. Le contenu du nouveau fichier de configuration ehcache est le suivant. Ce démarrage de Spring File scannera automatiquement
<? xml version = "1.0" coding = "utf-8"?> <ehcache> <! - utilisé lors du passage à ehcache cache -> <cache name = "People" maxElementsInMemory = "1000" /> </hcache>
2. Passez à la goyave comme cache
Ajoutez simplement des dépendances dans le pom
<dependency> <proupId> com.google.guava </rom groupeid> <lefactive> goyava </refactive> <version> 18.0 </-version> </pedency>
3. Passer à Redis en cache
Veuillez lire le prochain blog
Référence pour cet article: "Le perturbateur du développement de Javaee: Battre de Spring Boot"
Code source de cet article: https://github.com/527515025/springboot.git
Ce qui précède est tout le contenu de cet article. J'espère que cela sera utile à l'apprentissage de tous et j'espère que tout le monde soutiendra davantage Wulin.com.