2. 程式人生 > >SpringBoot25-spingboot資料訪問-資料快取Cache

SpringBoot25-spingboot資料訪問-資料快取Cache

阿新 • • 發佈：2019-02-10

    我們知道一個程式的瓶頸在於資料庫，我們也知道記憶體的速度是大大快於硬碟的速度的。當我們需要重複地獲取相同的資料的時候，我們一次又一次的請求資料庫或者遠端服務，導致大量的時間耗費在資料庫查詢或者遠端方法呼叫上，導致程式效能的惡化，這便是資料快取要解決的問題。

一，Spring 快取支援

     Spring定義了org.springframework.cache.CacheManager和org.springframework.cache.Cache介面用來統一不同的快取技術。其中CacheManager是Spring提供的各種快取技術抽象介面，Cache介面包含快取的各種操作（增加，刪除，獲得快取，我們一般不會直接和此介面打交道）

1，Spring支援的CacheManager

      針對不同的快取技術，需要實現不同的CacheManager，Spring定義瞭如下所示的CacheManager實現：

SimpleCacheManager：使用簡單的Collection來儲存快取，主要用來測試用途。

ConcurrentMapCacheManager：使用ConcurrentMap來儲存快取。

NoOpCacheManager：僅測試用途，不會實際儲存快取。

EhCacheCacheManager：使用EhCache作為快取技術。

GuavaCacheManager：使用Google Guava的GuavaCache作為快取技術。

HazelcastCacheManager：使用Hazelcast作為快取技術。

JCacheCacheManager：支援JCache標準的實現作為快取技術，如Apache Commons JCS

RedisCacheManager：使用Redis作為快取技術。

     在我們使用任意一個實現的CacheManager的時候，需要註冊實現CacheManager的Bean，例如：

@Bean
    public EhCacheCacheManager cacheManager(CacheManager ehCacheCacheManager){
        return new EhCacheCacheManager(ehCacheCacheManager);
    }

     當然，每種快取技術都有很多的額外配置，但配置cacheManager是必不可少的

2，聲名式快取註解

      Spring提供了4個註解來宣告快取規則（又是使用註解式的AOP的一個生動例子）。這四個註解如下：

@Cacheable：在方法執行前spring先檢視快取中是否有資料，如果有資料，則直接返回快取資料；若沒有資料，呼叫方法並將方法返回值放進快取。

@CachePut：無論怎樣，都會將方法的返回值放到快取中。@CachePut的屬性與@Cacheable保持一致。

@CacheEvict：將一條或多條資料從快取中刪除。

@Caching：可以通過@Caching註解組合多個註解策略在一個方法上。

     @Cacheable，@Cacheable，@CacheEvict都有value屬性，指定的是要使用的快取名稱；key屬性指定的是資料在快取中的儲存的鍵。

3，開啟聲名式快取支援

     開啟聲名式快取支援十分簡單，只需在配置類上使用@EnableCaching註解即可，如下：

package com.jack.springboot8cache.config;

import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Configuration;

/**
 * create by jack 2017/10/9
 */
@Configuration
@EnableCaching
public class AppConfig {
}


二，Spring Boot的支援

      在spring中使用快取技術的關鍵是配置CacheManager，而Spring Boot為我們自動配置了多個CacheManager的實現。

      Spring Boot的CacheManager的自動配置放置在org.springframework.boot.autoconfigure.cache包中，如下所示：


       通過上圖我們可以看出，Spring Boot為我們自動配置了EhCacheCacheConfiguration（使用EhCache），GenericCacheConfiguration（使用Collection），GuavaCacheConfiguration（使用Guava），HazelcastCacheConfiguration（使用Hazelcast），InfinispanCacheConfiguration（使用Infinispan），JCacheCacheConfiguration（使用JCache），NoOpCacheConfiguration（不使用儲存），RedisCacheConfiguration（使用Redis），SimpleCacheConfiguration（使用ConcurrentMap）。在不做任何額外配置的情況下，預設使用的是SimpleCacheConfiguration，即使用ConcurrentMapCacheManager。Spring boot支援以“spring.cache”為字首的屬性來配置快取：

spring.cache.type=#可選generic，ehcache，hazelcast，infinispan，jcache，redis，guava，simple，none

spring.cache.cache-names=#程式啟動時建立快取名稱

spring.cache.ehcache.config=#ehcache配置檔案地址

spring.cache.hazelcast.config=#hazelcast配置檔案地址

spring.cache.infinispan.config=#infinispan配置檔案地址

spring.cache.jcache.config=#jcache配置檔案地址

spring.cache.jcache.provider=#當多個jcache實現在類路徑中的時候，指定jcache實現

spring.cache.guava.spec=#guava specs

       在Spring Boot環境下，使用快取技術只需在專案中匯入相關快取技術的依賴包，並在配置類上使用@EnableCaching開啟快取即可。

三，實戰

      下面將以Spring Boot預設的ConcurrentMapCacheManager作為快取技術，演示@Cacheable，@CachePut，@CacheEvit，最後使用EhCache，Guava來替換快取技術。

1，新建Spring Boot專案

      新建Spring Boot專案依賴為Cache，JPA,WEB，新增mysql驅動，pom.xml的配置檔案如下：

<?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</modelVersion>

	<groupId>com.jack</groupId>
	<artifactId>springboot8cache</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>springboot8cache</name>
	<description>Demo project for Spring Boot</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.7.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-jpa</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<!--mysql連線驅動-->
		<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
		</dependency>

		<!-- https://mvnrepository.com/artifact/com.alibaba/fastjson -->
		<dependency>
			<groupId>com.alibaba</groupId>
			<artifactId>fastjson</artifactId>
			<version>1.2.39</version>
		</dependency>

		<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-cache -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-cache</artifactId>
		</dependency>


		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>


</project>

2，實體類
package com.jack.springboot8cache.entity;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

/**
 * create by jack 2017/10/3
 */
//@Entity註解指明這是一個和資料庫表對映的實體類
@Entity
public class Person {
    /**
     * 主鍵id
     * @Id註解指明這個屬性對映為資料庫的主鍵
     * @GeneratedValue定義主鍵生成的方式，下面採用的是mysql的自增屬性
     */
    @Id
    @GeneratedValue(strategy= GenerationType.AUTO)
    private Integer id;
    /**
     * 姓名
     */
    private String name;
    /**
     * 年齡
     */
    private Integer age;
    /**
     * 地址
     */
    private String address;

    public Person() {
        super();
    }

    public Person(Integer id, String name, Integer age, String address) {
        super();
        this.id = id;
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public Integer getId() {
        return id;
    }

    public void setId(Integer id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public String getAddress() {
        return address;
    }

    public void setAddress(String address) {
        this.address = address;
    }
}

3，實體類Repository
package com.jack.springboot8cache.dao;


import com.jack.springboot8cache.entity.Person;
import org.springframework.data.jpa.repository.JpaRepository;

/**
 * create by jack 2017/10/8
 * 實體類
 */
public interface PersonRepository extends JpaRepository<Person,Integer> {
}

4，業務服務

1）介面：

package com.jack.springboot8cache.service;

import com.jack.springboot8cache.entity.Person;

/**
 * create by jack 2017/10/9
 */
public interface DemoService {
    Person save(Person person);

    void remove(Integer id);

    Person findOne(Person person);
}

2）實現類
package com.jack.springboot8cache.impl;


import com.jack.springboot8cache.dao.PersonRepository;
import com.jack.springboot8cache.entity.Person;
import com.jack.springboot8cache.service.DemoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;

/**
 * create by jack 2017/10/9
 */
@Service
public class DemoServiceImpl implements DemoService {
    @Autowired
    private PersonRepository personRepository;
    /**
     * 注意：如果沒有指定key，則方法引數作為key儲存到快取中
     */
    /**
     *@CachePut快取新增的或更新的資料到快取，其中快取的名稱為people，資料的key是person的id
     * @param person
     * @return
     */
    @CachePut(value = "people",key="person.id")
    @Override
    public Person save(Person person) {
        Person p = personRepository.save(person);
        System.out.println("為id，key為："+p.getId()+"資料做了快取");
        return p;
    }

    /**
     * @CacheEvict從快取people中刪除key為id的資料
     * @param id
     */
    @CacheEvict(value = "people")
    @Override
    public void remove(Integer id) {
        System.out.println("刪除了id，key為"+id+"的資料快取");
        personRepository.delete(id);
    }

    /**
     * @Cacheable快取key為person的id資料到快取people中
     * @param person
     * @return
     */
    @Cacheable(value = "people",key = "person.id")
    @Override
    public Person findOne(Person person) {
        Person p = personRepository.findOne(person.getId());
        System.out.println("為id，key為："+p.getId()+"資料做了快取");
        return p;
    }
}

    注意：如果沒有指定key，則方法引數作為key儲存到快取中

5，控制器

package com.jack.springboot8cache.controller;

import com.jack.springboot8cache.entity.Person;
import com.jack.springboot8cache.service.DemoService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * create by jack 2017/10/9
 */
@RestController
@RequestMapping("cache")
public class CacheController {
    @Autowired
    private DemoService demoService;

    @RequestMapping("/put")
    public Person put(Person person){
        return demoService.save(person);
    }

    @RequestMapping("/evit")
    public String evit(Integer id){
        demoService.remove(id);
        return "ok";
    }

    @RequestMapping("/cacheable")
    public Person cacheable(Person person){
        return demoService.findOne(person);
    }

}

6，開啟快取支援
package com.jack.springboot8cache;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;

@SpringBootApplication
@EnableCaching
public class Springboot8cacheApplication {

	public static void main(String[] args) {
		SpringApplication.run(Springboot8cacheApplication.class, args);
	}
}

7，執行

     當我們對資料庫做了快取以後，資料的獲得將從快取中得到，而不是從資料庫中得到。當前的資料庫的資料情況如下所示：


    我們在每次執行測試情況下，都重啟了應用程式。

1）測試@Cacheable

      第一次訪問http://localhost:9090/cache/cacheable?id=85，第一次將呼叫方法查詢資料庫，並將資料放到快取people中。

此時控制檯輸出如下：

2017-10-09 23:29:05.877  INFO 2468 --- [nio-9090-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring FrameworkServlet 'dispatcherServlet'
2017-10-09 23:29:05.878  INFO 2468 --- [nio-9090-exec-1] o.s.web.servlet.DispatcherServlet        : FrameworkServlet 'dispatcherServlet': initialization started
2017-10-09 23:29:05.939  INFO 2468 --- [nio-9090-exec-1] o.s.web.servlet.DispatcherServlet        : FrameworkServlet 'dispatcherServlet': initialization completed in 61 ms
Hibernate: select person0_.id as id1_0_0_, person0_.address as address2_0_0_, person0_.age as age3_0_0_, person0_.name as name4_0_0_ from person person0_ where person0_.id=?
為id，key為：85資料做了快取

頁面輸出如下：


      再次訪問http://localhost:9090/cache/cacheable?id=85，此時控制檯沒有再次輸出hibernate的查詢語句，以及“為id，key為：85資料做了快取”字樣，表示沒有呼叫這個方法，頁面直接從資料快取中獲得資料，頁面輸出結果如下：


2）測試@CachePut

      訪問http://localhost:9090/cache/put?name=jack8&age=99&address=深圳深圳，此時控制檯輸出如下：

2017-10-09 23:37:10.823  INFO 1212 --- [nio-9090-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring FrameworkServlet 'dispatcherServlet'
2017-10-09 23:37:10.824  INFO 1212 --- [nio-9090-exec-1] o.s.web.servlet.DispatcherServlet        : FrameworkServlet 'dispatcherServlet': initialization started
2017-10-09 23:37:10.893  INFO 1212 --- [nio-9090-exec-1] o.s.web.servlet.DispatcherServlet        : FrameworkServlet 'dispatcherServlet': initialization completed in 69 ms
Hibernate: insert into person (address, age, name) values (?, ?, ?)
為id，key為：86資料做了快取

頁面輸出如下：


     我們再次訪問：http://localhost:9090/cache/cacheable?id=87，控制檯無輸出，從快取直接獲得資料，頁面顯示如上。

3）測試@CacheEvit

       訪問：http://localhost:9090/cache/cacheable?id=87，為id為87的資料做快取，再次訪問http://localhost:9090/cache/cacheable?id=87，確認資料已經從快取中獲取。

       訪問：http://localhost:9090/cache/evit?id=87，從快取中刪除key為87的快取資料：

刪除了id，key為87的資料快取
Hibernate: select person0_.id as id1_0_0_, person0_.address as address2_0_0_, person0_.age as age3_0_0_, person0_.name as name4_0_0_ from person person0_ where person0_.id=?
Hibernate: delete from person where id=?

     再次訪問：http://localhost:9090/cache/cacheable?id=87，觀察控制檯，資料已經從資料庫中刪除了，查詢快取，發現空指標異常了，查詢失敗

四，切換快取技術

      切換快取技術除了移入相關依賴包或者配置以外，使用方式和上面的實戰例子儲存一致。下面講解Spring Boot下EhCache和Guava作為快取技術的方式，其餘快取技術也是類似的方式。

1，EhCahce

      當我們需要使用EhCache作為快取技術的時候，我們只需要在pom.xml中新增EhCache的依賴即可：

<!-- https://mvnrepository.com/artifact/net.sf.ehcache/ehcache -->
<dependency>
    <groupId>net.sf.ehcache</groupId>
    <artifactId>ehcache</artifactId>
    <version>2.10.4</version>
</dependency>

     EhCache所需的配置檔案ehcache.xml只需放在類路徑下，Spring Boot會自動掃描，例如：

<?xml version="1.0" encoding="UTF-8">

<ehcache>

    <cache name="people" maxElementsInMemory="1000"/>

</ehcache>

Spring Boot會給我們自動配置EhcacheCacheManager的Bean。

2,Guava

     當我們需要使用Guava作為快取技術的時候，我們只需要在pom.xml中增加Guava的依賴即可：

<!-- https://mvnrepository.com/artifact/com.google.guava/guava -->
<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>23.0</version>
</dependency>

Spring Boot會給我們自動配置GuavaCacheManager這個Bean。

3，Redis

       使用Redis，只需新增下面的依賴即可：

<!-- https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-data-redis -->
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
    <version>1.5.7.RELEASE</version>
</dependency>

Spring Boot將會為我們自動配置RedisCacheManager以及RedisTemplate的Bean。

相關推薦

SpringBoot25-spingboot資料訪問-資料快取Cache

    我們知道一個程式的瓶頸在於資料庫，我們也知道記憶體的速度是大大快於硬碟的速度的。當我們需要重複地獲取相同的資料的時候，我們一次又一次的請求資料庫或者遠端服務，導致大量的時間耗費在資料庫查詢或者遠端方法呼叫上，導致程式效能的惡化，這便是資料快取要解決的問題。一，Spri

SpringBoot資料訪問-------------資料快取

Spring快取支援 　　Spring開始定義了org.springframework.cache.Cache和org.springframework.cache.CacheManager介面來統一不同的快取技術。Spring Cache的核心就是對某個方法進行快取，其實質就是快取該方法的返回結果，並把方法

mvc靜態資源訪問之快取cache-period

cache-period 對靜態資源的快取，這樣的話，下次請求就不會再請求伺服器，而是利用了瀏覽器的快取、從而降低了伺服器的壓力。 底層是怎楊處理的？ <!-- 對靜態資源的訪問--> <mvc:resources mapping="/images/*

SpringBoot之資料快取Cache操作

一、前言 快取要解決的問題：一個程式的瓶頸在於資料庫，我們也知道記憶體的速度是大大快於硬碟的速度的。當我們需要重複地獲取相同的資料的時候，我們一次又一次的請求資料庫或者遠端服務，導致大量的時間耗費在資料庫查詢或者遠端方法呼叫上，導致程式效能的惡化，這便是資料快取要解決的問題。

SpringBoot學習筆記(6) SpringBoot資料快取Cache [Guava和Redis實現]

Spring定義了org.springframework.cache.CacheManager和org.springframework.cache.Cache介面來統一不同的快取技術,而Spring

ASP.NET ADO.NET資料訪問技術(一使用Command物件的 增刪查改 )

使用Command物件進行資料庫操作 一、插入資料 //引用資料庫訪問名稱空間 using System.Data.SqlClient; using System.Configuration; string sqlconnstr = ConfigurationManager.Conne

關於vue-cliaxsios的使用和跨域訪問資料的總結

一、安裝axsois 　　1.安裝：在vue-cli根目錄下安裝axsois  　　2.更改原型鏈方法：在main.js下更改： 　　3.在元件中使用： 二、跨域 　　1.在config/index.js 新增如下程式碼： proxyTable: { './api':{ targ

Spring Boot（三）——Spring Boot資料訪問

一、簡介 對於資料訪問層，無論是SQL還是NOSQL，Spring Boot預設採用整合Spring Data的方式進行統一處理，新增大量自動配置，遮蔽了很多設定。引入各種xxxTemplate，xxxRepository來簡化我們對資料訪問層的操作。對我們來說只需要進行簡單的設定即

Spring Boot中使用Spring-data-jpa訪問資料

一 點睛 只需要通過編寫一個繼承自JpaRepository的介面就能完成資料訪問。 二 實戰 1 新建依賴 <dependencies> <dependency> <groupId>org

ASP.NET ADO.NET資料訪問技術(二 使用DataAdapter物件的 增刪查改 )

一、DataAdapter相關介紹 使用DataAdapter物件查詢資料庫相當於 在客戶端建立一個數據庫分部（即DataSet），在總部查詢資訊後通過fill方法填充DataSet，然後我們操作資料庫時不需要去資料庫總部拿資料了，只需要去分部（DataSet）中取出資料即可 二、建

關於面對物件過程中的三大架構以及資料訪問層（實體類、資料操作類）

關於面對物件過程中的三大架構以及資料訪問層（實體類、資料操作類） 面向物件開發專案三層架構： 介面層、業務邏輯層、資料訪問層 資料訪問層，分為實體類和資料訪問類 在專案的下面新增一個App_Code資料夾把所有的類放在App_Code這個資料夾下邊。

IIS 元資料訪問失敗

辦公室的機器上是裝的 VS2010，Win7, IIS 7.5 但家裡的機器是 XP Professional 2002 sp3, 沒辦法，只能裝 專門針對 xp pro sp3版的 IIS 5.1 這個版本的 iis 不是很好找, 最後還是在 CSDN上找到了： ( xp pro s

(轉)SQLServer_十步優化SQL Server中的資料訪問四

            原文地址：http://tech.it168.com/a2009/1125/814/000000814758_all.shtml 第八步：使用SQL事件探查器和效能監控工具有效地診斷效能問題 　　在SQL Ser

(轉)SQLServer_十步優化SQL Server中的資料訪問五

  　　第九步：合理組織資料庫檔案組和檔案 　　建立SQL Server資料庫時，資料庫伺服器會自動在檔案系統上建立一系列的檔案，之後建立的每一個數據庫物件實際上都是儲存在這些檔案中的。SQL Server有下面三種檔案： 　　1).mdf檔案 　　這是最主要的資料檔案，每個資料庫只能有一個

ASP.NET ADO.NET資料訪問技術(一使用Command物件執行)

【SQLConnection類】 常用方法： Open：開啟資料庫連線 Close：關閉資料庫連線 常用屬性： ConnectionString：設定開啟SQL Server資料庫的字串 State：判斷資料庫的連線狀態：Broken、Clos

Context - React跨元件訪問資料的利器

1. Context - React元件間傳遞資料的利器 Context提供了一種跨元件訪問資料的方法。它無需在元件樹間逐層傳遞屬性，也可以方便的訪問其他元件的資料 在經典的React應用中，資料是父元件通過props向子元件傳遞的。但是在某些特定場合，有些資料需要在各個元件之間共享。Context為我們

T-SQL執行內幕（9）——資料訪問

本文屬於SQL Server T-SQL執行內幕系列     在執行樹的葉子端（通常就是圖形化執行計劃每個分支的最右端），一般是實際訪問資料的操作符。當呼叫這些操作符上的next()方法時，會返回表或者索引上的實際資料。資料訪問通常有三類可能的操作

《大型網站系統與JAVA中介軟體實踐》 第五章 資料訪問層

         兩階段提交                 &nbs

Java是如何快速煮成C 的 （二） 資料訪問 1

分享一下我老師大神的人工智慧教程！零基礎，通俗易懂！http://blog.csdn.net/jiangjunshow 也歡迎大家轉載本篇文章。分享知識，造福人民，實現我們中華民族偉大復興！        

Spring的資料訪問---------------事務管理

ThreadLocal 　　ThreadLocal為每一個使用該變數的執行緒分配一個變數副本，所以每一個執行緒在改變自己的副本時，不會改變其他執行緒的副本資訊。該類主要包含四個方法： 　　public void set(Object obj) 　　public Object get() 　　publi