La investigación principal en este artículo es sobre el contenido relacionado con la caché de primavera, como sigue.
Este artículo se modificó más o menos en base a la traducción de Google. Como no sé cuál es el texto original, puede conducir a errores e inexactitudes en la traducción, pero la dirección general se siente bastante bien, así que lo ordené aquí, con la esperanza de que sea útil.
El almacenamiento en caché siempre ha sido una gran necesidad de mejorar el rendimiento de la aplicación y reducir su carga de trabajo. Además, su utilidad es particularmente evidente hoy en día, que puede usarse para manejar a miles de visitantes en los concurrentes. Dirige la arquitectura de las aplicaciones web, la gestión de caché ortogonal a la lógica comercial de la aplicación y, por esta razón, debería tener un impacto mínimo en el desarrollo de la aplicación en sí. A partir de la versión 3.1, Spring proporciona una API de gestión de caché, similar a la gestión de transacciones declarativas. La interfaz abstracta de la caché, que usa diferentes soluciones de caché de una manera unificada, tiene el menor impacto en el código.
Spring utiliza métodos Java para solicitar un método por primera vez para una combinación con parámetros, y Spring almacena el valor de retorno en el caché. Por lo tanto, la próxima solicitud será usar el valor del caché directamente sin tener que llamar a un posible método costoso. Todo se aplica transparentemente sin afectar el método llamado.
En esta publicación, veremos implementaciones de dos almacenes de caché diferentes de Spring.
La integración de la primavera y el caché es simple y transparente. El método que necesita caché es anotado por @Cachable Annotation
@Cacheable (valor = "dataCache") public Reponse GetDatas (Long Param1, String Param2) {} DataCache es el nombre del caché asociado. Cuando se requiere este método por primera vez, el método ejecuta y almacena el resultado de la ejecución en el conjunto de resultados con la clave secreta que ha salido del <Parámetro 1 y el parámetro 2> como resultado. Cuando se llama nuevamente al mismo parámetro, este método no necesita ser ejecutado nuevamente.
Es posible que más de un caché esté asociado con nuestro método
@Cacheable ({"dataCache", "predeterminado"}) public Reponse getDatas (Long Param1, String Param2) {} En este caso, cada caché se verifica antes de ejecutar el método, y si hay un HIT, se devolverá el valor relevante.
La proporción de algoritmos básicos de un administrador de caché es relativamente pequeña. El caché puede considerarse como un área de memoria en la que los objetos almacenados se asignan por una clave única. El proceso de búsqueda de objetos es el siguiente:
1. Calcule la clave (use el método hash para obtener hashcode)
2. Encuentre objetos basados en el valor clave
3. Si se encuentra el objeto, devuelva el resultado
4. Si no se puede encontrar, se calculará la clave que realmente está asociada con el objeto y el objeto se almacenará en la ubicación correspondiente.
Spring utiliza un hash simple, que genera claves basadas en parámetros del método aprobado.
El método de destino no puede simplemente generar claves innecesarias basadas en parámetros, pero solo se generan algunos casos simples en función de los parámetros.
@Cacheable (valor = "dataCache") public Reponse GetDatas (Long Param1, String Param2, Boolean Param3) {}@Cachable permite a los desarrolladores especificar la forma en que la generación de claves es generada por ellos mismos. Puede usar expresiones de espel para hacer esto.
@Cacheable (valor = "dataCache", key = "#param2") public Reponse getDatas (Long Param1, String Param2, Boolean Param3) {} En este caso anterior, el parámetro de la clave en caché es solo Parma2
Spring también permite propiedades anidadas
@Cacheable (valor = "dataCache", key =#param2.name ") public Reponse getDatas (Long Param1, Data Param2, Boolean Param3) {} Esta situación es la clave calculada en función del atributo de nombre de Parma2
Hay un caché que puede no ser adecuado para el caché en el caso usado, pero en algunos casos, se requiere caché. Cuando se almacena en caché, el caché se procesa en función del verdadero o falso calculado por la expresión de Spel, y si la condición es verdadera, se realiza el caché.
@Cacheable (value = "dataCache", key = "#param2", condición = "#param2.length <64") public Reponse getDatas (Long Param1, String Param2, Boolean Param3) {} En este caso, el caché solo se realizará si la longitud del segundo parámetro es inferior a 64
El caché de Spring no solo puede almacenar datos en caché, sino también borrar un almacenamiento de caché. Este proceso se utiliza para eliminar datos obsoletos o datos en caché no utilizados. Anotación @CacheEvict Define métodos para realizar el vacío de caché, estos son desencadenantes para eliminar los datos en el caché.
@CacheEvict (valor = "dataCache") public void reloaddata () {}Esta opción es muy necesaria, y este método se utilizará cuando se debe borrar los datos en caché.
Para habilitar el soporte de caché para un proyecto de primavera, necesitamos agregar comentarios de caché al espacio de nombres.
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:cache="http://www.springframework.org/schema/cache" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns: context = "http://www.springframework.org/schema/context" xsi: schemalocation = "http://www.springframework.org/schema/beans http://www.springframework.org/schema/sbeans/spring-beat-3. http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache http://www.springframework.org/schema/cache/spring-cache.xsd http://www.springframework.org/schema/context "> <cache: annotation-driven/>
Eliminar la anotación puede deshabilitar el caché o habilitar el uso de caché en nuestra clase de configuración
@Configuration @Enablecaching Public Class AppConfig {} Limitaciones técnicas
Los parámetros del método de paso de objeto deben tener su propio método hashcode para calcular la clave secreta.
Como un objeto pasó y devuelve como parámetro, debe ser serializable
Selección de implementación
Spring proporciona dos implementaciones básicas:
Al usarlos, solo necesita declarar el Cachemanger y la Entidad del Gerente apropiado
Concurrenthashmap usando java
<bean id = "Cachemanager"> <span style = "White-space: pre"> </span> <Property name = "Caches"> <span style = "white-space: pre"> </span> <set> <span style = "white-space: pre"> </span> <bean name = "predeterminado"/> <span style = "white-space: pre"> </span> </sperty> </ahor>
Cada pesebre necesita un nombre, que es reconocido por los comentarios. Uno puede administrar múltiples SimpleCachemangers por un pesebre, y esta implementación es básicamente innecesaria.
Implementar ehcache
Declaración de Cachemanger
Bean id = "Cachemanager"> <Property name = "Cachemanager" ref = "ehcache"/> </ bean> <bean id = "ehcache"> <propiedad name = "configLocation" valor = "classpath: ehcache.xml"/> <propiedad name = "shared" value = "true"/> </bean>
En el archivo ehcache.xml está el archivo de parámetros de caché de la aplicación:
<ehcache xsi: nonamespaceschemalocation = "ehcache.xsd" updateCheck = "true" monitoreo = "autodetect" dynamicConfig = "true" maxbyteslocalheap = "150m"> <diskstore path = "java.io.tmpdir"/> <faultyCache eternal = "falso" falso "maal" mAxEnMeMinMeMinMeMinMiNEMEnMeMinMiMeMinMeNMINEMINET OverflowTodisk = "false"/> <cache name = "dataCache" eternal = "false" timetoidleseConds = "300" maxbyteslocalheap = "30m" timetoliveSeConds = "300" OverflowTodisk = "true" diskpersistent = "falso" diskexpirythreadingonds = "120" 120 " MemoryStoreEvictionPolicy = "Lru"/> </ehcache>
Usando ehcache, podemos definir múltiples caché diferentes parámetros de una manera muy simple
Nombre: identificador en caché
MaxbytesLocalheap: define el número de bytes que el caché puede usar para la máquina virtual. Si se ha establecido un Cachemanager MaxbytesLocalheap, el Cachemanager será restado el tamaño determinado del caché. Otros descansos compartidos de caché. El valor de esta propiedad son datos <número> k | K | M | M | G | G significa Kilobytes (K | K), Megabytes (M | M) o Gigabytes (G | G).
Eternidad: define si un elemento es eterno. Si este es el caso, el tiempo de espera se ignorará y el proyecto nunca expiró.
Timetoidlesegundos: este es el número de segundos, el elemento se ha dejado en la última utilización. El valor predeterminado de LA es 0, y el elemento permanece quieto
TimetoliveSeconds: este es el número de segundos que el proyecto ha vivido en la creación de valor predeterminado de caché.la es 0, y el proyecto estará vivo para siempre.
MemorySteeVictionPolicy Política de saqueo: LRU, menos recientemente usado, usado con poca frecuencia, primer elemento más antiguo por fecha de creación.
DiskexpiryThreadIntervalSeconds: el proceso de ejecución hipotecaria controla el número de segundos entre dos ejecuciones.
Diskpersistente: permite que los objetos se restauren entre dos coincidencias de máquinas virtuales almacenadas en el disco.
OverflowTodisk: determina si un objeto puede almacenarse en el disco para lograr el elemento de almacenamiento máximo.
Para resumirlo, use una fórmula matemática simple: expirationTime = Math.min((creationTime + timeToLive),(mostRecentTime + timeToIdle))
Lo anterior es toda la explicación detallada del código de caché de primavera en este artículo, espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a otros temas relacionados en este sitio. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!