Introducción
Nuestro conocimiento es que el cuello de botella de un programa se encuentra en la base de datos, y nuestro conocimiento también sabe que la velocidad de la memoria es mucho más rápida que la del disco duro. Cuando nuestro departamento necesita obtener los mismos datos repetidamente, nuestro departamento solicita la base de datos o el servicio remoto una y otra vez, lo que resulta en mucho tiempo dedicado a la consulta de la base de datos o las llamadas de métodos remotos, lo que resulta en el deterioro del rendimiento del programa, lo que es aún más un problema que el caché de datos debe resolver.
soporte de almacenamiento en caché de primavera
Spring define el org.springframework.cache.cachemanager y org.springframework.cache.cache interfaces para unificar diferentes tecnologías de almacenamiento en caché. Entre ellos, Cachemanager es una interfaz abstracta para varias tecnologías de caché proporcionadas por Spring. La interfaz de caché incluye varias operaciones de caché (agregando y eliminando para obtener caché, nuestro sistema generalmente no se ocupa directamente de esta interfaz)
Cachemanager apoyado por la primavera
Para diferentes tecnologías de almacenamiento en caché, se deben implementar diferentes caché. Spring define la implementación de Cachemanager en la siguiente tabla.
Al implementar cualquier Cachemanager, debe registrar un Bean que implementa Cachemanager. Por supuesto, cada tecnología de almacenamiento en caché tiene muchas configuraciones adicionales, pero la configuración de Cachemanager es esencial.
Anotación de caché declarativo
Spring proporciona 4 anotaciones para declarar reglas de caché (un ejemplo vívido de AOP usando fórmulas anotadas), como se muestra en la tabla.
Encienda el caché declarativo
Encender el soporte de almacenamiento en caché declarativo es muy simple, solo necesita usar la anotación de @EnabelCaching en la clase de configuración.
Soporte para Springboot
La clave para usar la tecnología de caché en Spring China es configurar Cachemanager. Springbok configura automáticamente múltiples implementaciones de Cachemanager para nuestra puerta. En el entorno de arranque de Spring, el uso de la tecnología de caché solo requiere importar los paquetes de dependencia de la tecnología de caché relacionada en el proyecto y configurar la clase para habilitar el soporte de caché usando @EnabelCaching.
Pequeños ejemplos
Se implementa un pequeño ejemplo utilizando SpringBoot+JPA+Cache.
Directorio de pasos de ejemplo
1. Cree un proyecto maven
Cree un nuevo archivo Maven Pom.xml de la siguiente manera:
<? xml versión = "1.0" encoding = "utf-8"?> <Project xmlns = "http://maven.apache.org/pom/4.0.0" xmlns: xsi = "http://www.w3.org/2001/xmlschemainstance" xsi: schemalocation = "http://maven.apache.org/pom/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <ModelVersion> 4.0.0 </modelversion> <MoupRoMid> com.us </groupid> <artifactid> SpringBoot </ArtArcid> <versión> 1.0-snapshot </versión> <-parent> <grupoD> org.springframework.boot </groupid> <artifactid> spring-boot-starter-parent </artifactid> <versión> 1.3.0.release </versión> </parent> <properties> <sturte-class> com.us.application </start-class> <maven.compiler.target> 1.8 </maven.compiler.target> <maven.compiler.source> 1.8 </maven.compiler.source> </propiedades> <!-Agregue dependencias típicas para una aplicación web-> <propience> <fependency> <proupid> org.springframework.boot </groupid> <artifactID> spring-boot-starter-cache </artifactid> </pendency> <pendency> <uproupid> org.springframework.boot </groupid> <artifactid> spring-boot-starter-data-jpa </artifactid> </dependency> <epardency> <uproupid> org.springframework.boot </groupid> <artifactid> spring-boot-starter-web </artifactid> </pepertency> <pendency> <uproupid> net.sf.ehcache </groupid> <artifactid> ehcache </ artifactid> </pendency> <!-db-> <epartency> <proupid> mysql </proupid> <artifactid> mysql-confonnector-java </artifactid> <versión> 6.0.5 </versión> </pendency> <pendency> <proupid> com.mchange </groupid> <artifactid> c3p0 </artifactid> <versers> 0.5.2.2 </spersion> <exusions> <excusion> commons-logging </groupid> <artifactID> commons-logging </artifactid> </extusion> </excusionions> </pendency> </dependencias> </proyecto>
2. Configuración de la base de datos
Cree un nuevo archivo Aplicación.
Aplicación. Properties
ms.db.driverClassName = com.mysql.jdbc.driverms.db.url = jdbc: mysql: // localhost: 3306/caché? T = True & UseUnicode = true & caracterSencoding = UTF-8 & USessl = false & allowMultiqueries = truems.db.username = rootms.db.password = xxxxxxxms.db.maxactive = 500
Cree un nuevo archivo de configuración dbconfig.java y configure la fuente de datos
paquete com.us.example.config;/*** Creado por Yangyibo el 17/1/13. */import java.beans.propertyvetoException; import org.springframework.beans.factory.annotation.autewired; import org.springframework.context.annotation.bean; import og.springframework.context.annotation.configuration; importar orgepringframe.core. com.mchange.v2.c3p0.comBopooledDataSource; @ConfigurationPublic Class dbConfig {@autewired private entorno envínico; @Bean (name = "DataSource") public CombopooledDataSource DataSource () lanza PropertyVetoException {CombopooledDataSource dataSource = new ComboPooledDataSource (); dataSource.setDrivClass (env.getProperty ("ms.db.drivClassName")); 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.SetAcquireIrcrement (5); dataSource.SetIdLeconnectionTestperiod (60); devolver datos de datos; }}Diseño de la base de datos, la base de datos tiene solo una tabla de personas, y el diseño es el siguiente:
3. Configuración de JPA
El archivo de configuración Spring-Data-JPA es el siguiente:
paquete com.us.example.config; import java.util.hashmap; import java.util.map; import javax.persistence.entityManagerFactory; import javax.sql.dataSource; importar org.springFrameWork.Beans.annotation.aUtowired; importar orgeRGRING org.springframework.context.annotation.Configuration; import org.springframework.data.jpa.repository.config.enableJparePositories; import oj.springframework.orm.jpa.jpatransactionManager; import og.springframework.orm.jpa.LocalcontainererererererererererererererAnererAryManaer org.springframework.orm.jpa.vendor.HibernateJpavendorAdapter; import org.springframework.transaction.platformtransactionManager; import org.springframework.transaction.annotation.enabletransactionManagement;/*** creado por Yangyibo en 17/1/13. */@Configuration@enableJparePositories ("com.us.example.dao")@habiletransactionManagement@componentsCanPublic class jpaconfig {@aUtowired 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, object> 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 ()); return txManager; }}4. Escribe frijoles y capas Dao
Entity Class Person.java
paquete com.us.example.bean; import javax.persistence.entity; import javax.persistence.generatedValue; import javax.persistence.id; import javax.persistence.table;/*** creado por Yangyibo el 17/1/13. */ @Entity @table (name = "persona") Persona de clase pública {@id @GeneratedValue Private Long id; nombre de cadena privada; edad de entero privado; dirección de cadena privada; persona pública () {super (); } persona pública (ID de larga, nombre de cadena, edad de entero, dirección de cadena) {super (); this.id = id; this.name = name; this.age = edad; this.address = dirección; } public Long Long getId () {return id; } public void setid (ID long) {this.id = id; } public String getName () {nombre de retorno; } public void setName (nombre de cadena) {this.name = name; } public Integer GetAge () {return Age; } public void setAge (edad entera) {this.age = edad; } public String getAddress () {Dirección de retorno; } public void setAddress (dirección de cadena) {this.address = dirección; }}Dao Layer, PersonRepository.java
paquete com.us.example.dao; import com.us.example.bean.person; import org.springframework.data.jpa.repository.jparpository;/*** creado por Yangyibo el 17/1/13. */Public Interface PersonRepository extiende jParepository <Person, Long> {}5. Escribe la capa de servicio
interfaz de servicio
paquete com.us.example.service; import com.us.example.bean.person;/*** creado por Yangyibo el 17/1/13. */Public Interface Demoservice {Public Person Save (Person Person); Public void eliminar (identificación larga); persona pública Findone (persona persona);}Implementación: (clave, agregue caché aquí)
paquete com.us.example.service.impl; import com.us.example.bean.person; import com.us.example.dao.personRepository; import com.us.example.service.demoservice; importar org.springframework.beans.annotation.autowired; import orge.springfring.cache.cacheeTt.CeCheEttt; org.springframework.cache.annotation.cacheput; import org.springframework.cache.annotation.cachable; import org.springframework.stereotype.service;/*** creado por Yangyibo el 17/1/13. */ @ServicePublic Class DemoserviceImpl implementa DemosService {@aUtowired Private PersonRepository PersonRepository; @Override //@Cacheput Caches recién agregados o actualizados datos a la memoria caché, donde el nombre de la memoria caché es la gente. La clave de los datos es la identificación de la persona @Cacheput (value = "People", Key = "#Person.id") Persona pública salvar (persona persona) {Person P = PersonRepository.save (persona); System.out.println ("para ID, la tecla es:"+P.getID ()+"Datos en caché"); regreso p; } @Override // @cacheEvict Eliminar datos con ID de clave de Cache People @CacheEvict (value = "People") public void remove (Long ID) {System.out.println ("eliminó el caché de datos con ID y la clave"+id+"); // La operación de deletion real no está realizada aquí} @Override // @cachable Caches the Id Data de Id Data. se especifica, los parámetros del método se guardan en la caché como clave.6. Controlador de escritura
Para la conveniencia de las pruebas, se utiliza
paquete 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.stereotpe.controller; import; org.springframework.web.bind.annotation.requestMapping; import org.springframework.web.bind.annotation.ResponseBody; import org.springframework.web.bind.annotation.restcontroller;/*** creado por yangyibo el 17/1/13. */ @RestControllerPublic Class Cachecontroller {@aUtowired DemosService privado DemosService; // http: // localhost: 8080/put? name = abel & edad = 23 & direction = shanghai @requestmapping ("/put") persona pública put (persona persona) {return demoservice.save (persona); } // http: // localhost: 8080/sable? id = 1 @RequestMapping ("/capiente") @ResponseBody Public Person Cacheable (persona persona) {return demoservice.findone (persona); } // http: // localhost: 8080/evit? id = 1 @RequestMapping ("/evit") public String Evit (Long Id) {Demoservice.remove (id); regresar "OK"; }}7. Comienza el caché
Recuerde habilitar la configuración de caché en la clase de inicio.
paquete com.us.example; importar org.springframework.boot.autoconfigure.springbootapplication; import org.springframework.cache.annotation.enablecaching; importar org.springframework.context.configureApeAplicationContext; import org.springframework.contextation; Org.springframework.boot.springapplication.*;/*** creado por Yangyibo el 17/1/13. */@ComponentScan (basepackages = "com.us.example")@springbootapplication@habilicidad de la aplicación de clase publicitaria {public static void main (string [] args) {configurureableApplicationContext run = run (application.class, args); }}8. Capacidad de verificación y verificación de prueba:
Inicie la clase de aplicación, y después de comenzar, ingrese: http: // localhost: 8080/capac? Id = 1 en el navegador (primero para inicializar varios datos en la base de datos).
Salida de la consola:
"Los datos de ID y clave son: 1" se ha almacenado en caché para esta consulta. Si consulta los datos nuevamente, esta declaración no aparecerá, es decir, la base de datos no será consultada.
Inspección Put
Ingrese en el navegador: http: // localhost: 8080/put? Name = abel & Age = 23 & dirección = shanghai (inserte un datos en la base de datos y coloque los datos en el caché).
En este momento, la salida de la consola almacena en caché del registro:
Luego llame al método capaz nuevamente para consultar los datos. La base de datos ya no se consultará y los datos se leerán directamente desde el caché.
Evito de prueba
Ingrese: http: // localhost: 8080/evit? Id = 1 en el navegador (borre el registro de la memoria caché, después de borrarlo, el registro se pondrá nuevamente en el caché después de acceder al registro).
Salida de la consola:
Alferante de cambio
1. Cambie a ehcache como caché
Agregar dependencias en el archivo pom.xml
<Spendency> <ProupId> net.sf.ehcache </groupid> <artifactId> ehcache </artifactid> </pendency>
Cree el archivo de configuración ehcache.xml en la carpeta de recursos. El contenido del nuevo archivo de configuración de Ehcache es el siguiente. Este arranque de primavera de archivo escaneará automáticamente
<? xml versión = "1.0" encoding = "utf-8"?> <ehcache> <!-usado al cambiar a ehcache cache-> <cache name = "personas" maxelementsInmemory = "1000" /> < /ehcache>
2. Cambie a la guayaba como caché
Simplemente agregue dependencias en el POM
<Spendency> <MoupRId> com.google.guava </groupid> <artifactId> guava </arfactid> <versión> 18.0 </versión> </pendency>
3. Cambie a Redis como caché
Lea el próximo blog
Referencia para este artículo: "El disruptor de Javaee Development: Boot de primavera Batalla práctica"
Código fuente de este artículo: https://github.com/527515025/springboot.git
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.