SpringBoot之緩存-專題五

SpringBoot之緩存-專題五

1、JSR-107

本文JSR-107部分借鑑JSR107官方文檔

一、介紹

JSR是Java Specification Requests的縮寫，意思是Java 規範提案。是指向JCP(Java Community Process)提出新增一個標準化技術規範的正式請求。任何人均可以提交JSR，以向Java平臺增添新的API和服務。JSR已成爲Java界的一個重要標準。

1.1 JSR 107

2012年10月26日JSR規範委員會發布了JSR 107（JCache API）的首個早期草案。自該JSR啓動以來，已通過去近12年時間，所以該規範頗爲Java社區所詬病，但因爲目前對緩存需求愈來愈多，所以專家組加快了這一進度。

1.2 規範

JCache規範定義了一種對Java對象臨時在內存中進行緩存的方法，包括對象的建立、共享訪問、假脫機（spooling）、失效、各JVM的一致性等，可被用於緩存JSP內最常常讀取的數據，如產品目錄和價格列表。利用JCACHE，多數查詢的反應時間會由於有緩存的數據而加快（內部測試代表反應時間大約快15倍）。

1.3 發展方向

JSR 107將成爲2013年第2季度發佈的JavaEE 7的一部分。

這裏只是對jsr107基礎瞭解

二、Java Caching

Java Caching定義了5個核心接口，分別是CachingProvider, CacheManager, Cache, Entry 和 Expiry。

CachingProvider定義了建立、配置、獲取、管理和控制多個CacheManager。一個應用能夠在運行期訪問多個CachingProvider。

CacheManager定義了建立、配置、獲取、管理和控制多個惟一命名的Cache，這些Cache存在於CacheManager的上下文中。一個CacheManager僅被一個CachingProvider所擁有。

Cache是一個相似Map的數據結構並臨時存儲以Key爲索引的值。一個Cache僅被一個CacheManager所擁有。

Entry是一個存儲在Cache中的key-value對。

Expiry 每個存儲在Cache中的條目有一個定義的有效期。一旦超過這個時間，條目爲過時的狀態。一旦過時，條目將不可訪問、更新和刪除。緩存有效期能夠經過ExpiryPolicy設置。

2、Spring緩存抽象

一、介紹

Spring從3.1開始定義了org.springframework.cache.Cache

和org.springframework.cache.CacheManager接口來統一不一樣的緩存技術；

並支持使用JCache（JSR-107）註解簡化咱們開發；

Cache接口爲緩存的組件規範定義，包含緩存的各類操做集合；

Cache接口下Spring提供了各類xxxCache的實現；如RedisCache，EhCacheCache , ConcurrentMapCache等；

每次調用須要緩存功能的方法時，Spring會檢查檢查指定參數的指定的目標方法是否已經被調用過；若是有就直接從緩存中獲取方法調用後的結果，若是沒有就調用方法並緩存結果後返回給用戶。下次調用直接從緩存中獲取。

使用Spring緩存抽象時咱們須要關注如下兩點；

一、肯定方法須要被緩存以及他們的緩存策略

二、從緩存中讀取以前緩存存儲的數據

將方法的運行結果進行緩存；之後再要相同的數據，直接從緩存中獲取，不用調用方法； CacheManager管理多個Cache組件的，對緩存的真正CRUD操做在Cache組件中，每個緩存組件有本身惟一一個名字；

二、緩存註解

2.1 Cache

緩存接口，定義緩存操做。實現有：RedisCache、EhCacheCache、ConcurrentMapCache等

2.2 CacheManager

緩存管理器，管理各類緩存（Cache）組件

2.3 @Cacheable

主要針對方法配置，可以根據方法的請求參數對其結果進行緩存

運行流程： 一、方法運行以前，先去查詢Cache（緩存組件），按照cacheNames指定的名字獲取； （CacheManager先獲取相應的緩存），第一次獲取緩存若是沒有Cache組件會自動建立。 二、去Cache中查找緩存的內容，使用一個key，默認就是方法的參數； key是按照某種策略生成的；默認是使用keyGenerator生成的，默認使用SimpleKeyGenerator生成key； SimpleKeyGenerator生成key的默認策略； 若是沒有參數；key=new SimpleKey()； 若是有一個參數：key=參數的值 若是有多個參數：key=new SimpleKey(params)； 三、沒有查到緩存就調用目標方法； 四、將目標方法返回的結果，放進緩存中

核心：

1）、使用CacheManager【ConcurrentMapCacheManager】按照名字獲得Cache【ConcurrentMapCache】組件

2）、key使用keyGenerator生成的，默認是SimpleKeyGenerator

屬性：
cacheNames/value：指定緩存組件的名字;將方法的返回結果放在哪一個緩存中，是數組的方式，能夠指定多個緩存；
key：緩存數據使用的key；能夠用它來指定。默認是使用方法參數的值  1-方法的返回值
                   編寫SpEL； #i d;參數id的值   #a0  #p0  #root.args[0]
                  getEmp[2]
keyGenerator：key的生成器；能夠本身指定key的生成器的組件id
                 key/keyGenerator：二選一使用;

cacheManager：指定緩存管理器；或者cacheResolver指定獲取解析器

condition：指定符合條件的狀況下才緩存；
		condition = "#id>0"
		condition = "#a0>1"：第一個參數的值》1的時候才進行緩存
unless:否認緩存；當unless指定的條件爲true，方法的返回值就不會被緩存；能夠獲取到結果進行判斷
		unless = "#result == null"
 		unless = "#a0==2":若是第一個參數的值是2，結果不緩存；
sync：是否使用異步模式

@Cacheable(value = {"emp"},keyGenerator = "myKeyGenerator",condition = "#a0>1",unless = "#a0==2")
複製代碼

2.4 @CachePut

保證方法被調用，又但願結果被緩存。

既調用方法，又更新緩存數據；同步更新緩存；修改了數據庫的某個數據，同時更新緩存；

運行時機：

一、先調用目標方法

二、將目標方法的結果緩存起來

@CachePut(value = "emp",key = "#result.id")
複製代碼

2.5 @CacheEvict

清空緩存

key：指定要清除的數據

allEntries = true：指定清除這個緩存中全部的數據

beforeInvocation = false：緩存的清除是否在方法以前執行;默認表明緩存清除操做是在方法執行以後執行;若是出現異常緩存就不會清除

beforeInvocation = true：表明清除緩存操做是在方法運行以前執行，不管方法是否出現異常，緩存都清除

@CacheEvict(value="emp",beforeInvocation = truekey = "#id",)
複製代碼

2.6 @EnableCaching

開啓基於註解的緩存

2.7 @Caching

定義複雜的緩存規則

@Caching(
         cacheable = {
             @Cacheable(value="emp",key = "#lastName")
         },
         put = {
             @CachePut(value="emp",key = "#result.id"),
             @CachePut(value="emp",key = "#result.email")
         }
    )
複製代碼

三、Cache原理

一、自動配置類；CacheAutoConfiguration 二、緩存的配置類

org.springframework.boot.autoconfigure.cache.GenericCacheConfiguration
org.springframework.boot.autoconfigure.cache.JCacheCacheConfiguration
org.springframework.boot.autoconfigure.cache.EhCacheCacheConfiguration
org.springframework.boot.autoconfigure.cache.HazelcastCacheConfiguration
org.springframework.boot.autoconfigure.cache.InfinispanCacheConfiguration
org.springframework.boot.autoconfigure.cache.CouchbaseCacheConfiguration
org.springframework.boot.autoconfigure.cache.RedisCacheConfiguration
org.springframework.boot.autoconfigure.cache.CaffeineCacheConfiguration
org.springframework.boot.autoconfigure.cache.GuavaCacheConfiguration
org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration【默認】
org.springframework.boot.autoconfigure.cache.NoOpCacheConfiguration
複製代碼

三、配置類默認生效：SimpleCacheConfiguration；

四、給容器中註冊了一個CacheManager：ConcurrentMapCacheManager 五、能夠獲取和建立ConcurrentMapCache類型的緩存組件；他的做用將數據保存在ConcurrentMap中；

四、Cache的使用

新建工程的什麼的都不說了，直接上代碼。

pom.xml文件依賴

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.0.RELEASE</version>
</parent>

<dependencies>
	<!--cache緩存 -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-cache</artifactId>
	</dependency>
	<!--Redis -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-data-redis</artifactId>
	</dependency>
	<dependency>
		<groupId>org.apache.commons</groupId>
		<artifactId>commons-pool2</artifactId>
	</dependency>

	<dependency>
		<groupId>org.projectlombok</groupId>
		<artifactId>lombok</artifactId>
	</dependency>
	<dependency>
		<groupId>com.alibaba</groupId>
		<artifactId>druid</artifactId>
		<version>1.1.10</version>
	</dependency>
	<!-- 測試 -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-test</artifactId>
		<scope>test</scope>
	</dependency>
	<dependency>
		<groupId>org.mybatis.spring.boot</groupId>
		<artifactId>mybatis-spring-boot-starter</artifactId>
		<version>1.1.1</version>
	</dependency>
	<!-- mysql 依賴 -->
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
	</dependency>
	<!-- springboot-web組件 -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
	<!-- springboot 整合 pagehelper -->
	<dependency>
		<groupId>com.github.pagehelper</groupId>
		<artifactId>pagehelper-spring-boot-starter</artifactId>
		<version>1.2.5</version>
	</dependency>
	<dependency>
		<groupId>org.apache.commons</groupId>
		<artifactId>commons-lang3</artifactId>
		<version>3.7</version>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-devtools</artifactId>
		<optional>true</optional>
		<scope>true</scope>
	</dependency>
	<dependency>
		<groupId>org.apache.tomcat.embed</groupId>
		<artifactId>tomcat-embed-jasper</artifactId>
	</dependency>

	<!-- spring boot start -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter</artifactId>
		<exclusions>
			<!-- 排除自帶的logback依賴 -->
			<exclusion>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-starter-logging</artifactId>
			</exclusion>
		</exclusions>
	</dependency>

	<!-- springboot-log4j -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-log4j</artifactId>
		<version>1.3.8.RELEASE</version>
	</dependency>
	<!-- aop -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-aop</artifactId>
	</dependency>
</dependencies>
複製代碼

實體類

package com.gitboy.redis.pojo;

import java.io.Serializable;

public class Department implements Serializable{
	
	private static final long serialVersionUID = 1L;
	private Integer id;
	private String departmentName;
	
	
	public Department() {
		super();
	}
	public Department(Integer id, String departmentName) {
		super();
		this.id = id;
		this.departmentName = departmentName;
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getDepartmentName() {
		return departmentName;
	}
	public void setDepartmentName(String departmentName) {
		this.departmentName = departmentName;
	}
	@Override
	public String toString() {
		return "Department [id=" + id + ", departmentName=" + departmentName + "]";
	}
	

}

複製代碼

package com.gitboy.redis.pojo;

import java.io.Serializable;

public class Employee implements Serializable {
	
	private static final long serialVersionUID = 1L;
	private Integer id;
	private String lastName;
	private String email;
	private Integer gender; //性別 1男 0女
	private Integer dId;
	
	
	public Employee() {
		super();
	}

	
	public Employee(Integer id, String lastName, String email, Integer gender, Integer dId) {
		super();
		this.id = id;
		this.lastName = lastName;
		this.email = email;
		this.gender = gender;
		this.dId = dId;
	}
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getLastName() {
		return lastName;
	}
	public void setLastName(String lastName) {
		this.lastName = lastName;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public Integer getGender() {
		return gender;
	}
	public void setGender(Integer gender) {
		this.gender = gender;
	}
	public Integer getdId() {
		return dId;
	}
	public void setdId(Integer dId) {
		this.dId = dId;
	}
	@Override
	public String toString() {
		return "Employee [id=" + id + ", lastName=" + lastName + ", email=" + email + ", gender=" + gender + ", dId="
				+ dId + "]";
	}


}

複製代碼

配置類

package com.gitboy.redis.conf;

import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.lang.reflect.Method;
import java.util.Arrays;

@Configuration
public class MyCacheConfig {

    @Bean("myKeyGenerator")
    public KeyGenerator keyGenerator(){
        return new KeyGenerator(){

            @Override
            public Object generate(Object target, Method method, Object... params) {
                return method.getName()+"["+ Arrays.asList(params).toString()+"]";
            }
        };
    }
}
複製代碼

mapper

package com.gitboy.redis.mapper;

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import com.gitboy.redis.pojo.Department;

@Mapper
public interface DepartmentMapper {

    @Select("SELECT * FROM department WHERE id = #{id}")
    Department getDeptById(Integer id);
}

複製代碼

package com.gitboy.redis.mapper;

import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import com.gitboy.redis.pojo.Employee;

@Mapper
public interface EmployeeMapper {

    @Select("SELECT * FROM employee WHERE id = #{id}")
    public Employee getEmpById(Integer id);

    @Update("UPDATE employee SET lastName=#{lastName},email=#{email},gender=#{gender},d_id=#{dId} WHERE id=#{id}")
    public void updateEmp(Employee employee);

    @Delete("DELETE FROM employee WHERE id=#{id}")
    public void deleteEmpById(Integer id);

    @Insert("INSERT INTO employee(lastName,email,gender,d_id) VALUES(#{lastName},#{email},#{gender},#{dId})")
    public void insertEmployee(Employee employee);

    @Select("SELECT * FROM employee WHERE lastName = #{lastName}")
    Employee getEmpByLastName(String lastName);
}

複製代碼

service

package com.gitboy.redis.service;

import com.gitboy.redis.pojo.Department;

public interface DeptService {

	Department getDeptById(Integer id);

}

package com.gitboy.redis.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.gitboy.redis.mapper.DepartmentMapper;
import com.gitboy.redis.pojo.Department;
import com.gitboy.redis.service.DeptService;

@Service
public class DeptServiceImpl implements DeptService {

	@Autowired
	private DepartmentMapper departmentMapper;

	@Override
	public Department getDeptById(Integer id) {

		System.out.println("查詢部門"+id);
        Department department = departmentMapper.getDeptById(id);
        return department;
	}
}

複製代碼

package com.gitboy.redis.service;

import com.gitboy.redis.pojo.Employee;

public interface EmployeeService {

	Employee getEmp(Integer id);

	Employee updateEmp(Employee employee);

	void deleteEmp(Integer id);

	Employee getEmpByLastName(String lastName);


}
package com.gitboy.redis.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.gitboy.redis.mapper.DepartmentMapper;
import com.gitboy.redis.pojo.Department;
import com.gitboy.redis.service.DeptService;

@Service
public class DeptServiceImpl implements DeptService {

	@Autowired
	private DepartmentMapper departmentMapper;

	@Override
	public Department getDeptById(Integer id) {

		System.out.println("查詢部門"+id);
        Department department = departmentMapper.getDeptById(id);
        return department;
	}
}

複製代碼

controller

package com.gitboy.redis.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import com.gitboy.redis.pojo.Department;
import com.gitboy.redis.service.DeptService;

@RestController
public class DeptController {

	@Autowired
	private DeptService deptService;
	
	
    @GetMapping("/dept/{id}")
    public Department getDept(@PathVariable("id") Integer id){
        return deptService.getDeptById(id);
    }
}
複製代碼

package com.gitboy.redis.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import com.gitboy.redis.pojo.Employee;
import com.gitboy.redis.service.EmployeeService;

/** * @author No * 緩存採用cache */
@RestController
public class EmployeeController {

	@Autowired
	private EmployeeService employeeService;
	
	@GetMapping("/emp/{id}")
    public Employee getEmployee(@PathVariable("id") Integer id){
        Employee employee = employeeService.getEmp(id);
        return employee;
    }

    @GetMapping("/emp")
    public Employee update(Employee employee){
        Employee emp = employeeService.updateEmp(employee);

        return emp;
    }

    @GetMapping("/delemp")
    public String deleteEmp(Integer id){
        employeeService.deleteEmp(id);
        return "success";
    }

    @GetMapping("/emp/lastname/{lastName}")
    public Employee getEmpByLastName(@PathVariable("lastName") String lastName){
       return employeeService.getEmpByLastName(lastName);
    }
	
}


複製代碼

yml文件

#端口
server:
 port: 8081
  
spring:
 datasource:
 driver-class-name: com.mysql.jdbc.Driver
 url: jdbc:mysql://localhost:3306/springboot?characterEncoding=utf8&useSSL=false
 username: root
 password: root
 type: com.alibaba.druid.pool.DruidDataSource
 thymeleaf:
 cache: false
    
 redis:
 host: 134.175.30.90
mybatis:
 configuration:
 map-underscore-to-camel-case: true
    
#分頁插件
pagehelper:
 helper-dialect: mysql
 reasonable: true
 support-methods-arguments: true
 params: count=countSql
 page-size-zero: true
複製代碼

日誌文件

#log4j.rootLogger=CONSOLE,info,error,DEBUG
log4j.rootLogger=info,error,CONSOLE,DEBUG
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender     
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout     
log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n     
log4j.logger.info=info
log4j.appender.info=org.apache.log4j.DailyRollingFileAppender
log4j.appender.info.layout=org.apache.log4j.PatternLayout     
log4j.appender.info.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
log4j.appender.info.datePattern='.'yyyy-MM-dd
log4j.appender.info.Threshold = info   
log4j.appender.info.append=true   
#log4j.appender.info.File=/home/admin/pms-api-services/logs/info/api_services_info
log4j.appender.info.File=C:logs/info/api_services_info
log4j.logger.error=error  
log4j.appender.error=org.apache.log4j.DailyRollingFileAppender
log4j.appender.error.layout=org.apache.log4j.PatternLayout     
log4j.appender.error.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
log4j.appender.error.datePattern='.'yyyy-MM-dd
log4j.appender.error.Threshold = error   
log4j.appender.error.append=true   
#log4j.appender.error.File=/home/admin/pms-api-services/logs/error/api_services_error
log4j.appender.error.File=C:logs/error/api_services_error
log4j.logger.DEBUG=DEBUG
log4j.appender.DEBUG=org.apache.log4j.DailyRollingFileAppender
log4j.appender.DEBUG.layout=org.apache.log4j.PatternLayout     
log4j.appender.DEBUG.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
log4j.appender.DEBUG.datePattern='.'yyyy-MM-dd
log4j.appender.DEBUG.Threshold = DEBUG   
log4j.appender.DEBUG.append=true   
#log4j.appender.DEBUG.File=/home/admin/pms-api-services/logs/debug/api_services_debug
log4j.appender.DEBUG.File=C:logs/debug/api_services_debug
複製代碼

啓動類

package com.gitboy.redis;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@MapperScan(basePackages="com.gitboy.redis.mapper")
@EnableScheduling
@EnableCaching
public class AppRedis {
    public static void main(String[] args) {

        SpringApplication.run(AppRedis.class, args);
    }
}

複製代碼

3、SpringBoot整合Redis緩存中間件

想要了解redis的基礎入門能夠查看往期的Redis初識

一、Redis常見的五大數據類型

String（字符串）、List（列表）、Set（集合）、Hash（散列）、ZSet（有序集合）

SpringBoot整合封裝：

stringRedisTemplate.opsForValue()[String（字符串）]

stringRedisTemplate.opsForList()[List（列表）]

stringRedisTemplate.opsForSet()[Set（集合）]

stringRedisTemplate.opsForHash()[Hash（散列）]

stringRedisTemplate.opsForZSet()[ZSet（有序集合）]

二、RedisCacheConfiguration使用

新建工程的什麼的都不說了，直接上代碼。

pom.xml文件依賴

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.0.0.RELEASE</version>
</parent>

<dependencies>
	<!--cache緩存 -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-cache</artifactId>
	</dependency>
	<!--Redis -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-data-redis</artifactId>
	</dependency>
	<dependency>
		<groupId>org.apache.commons</groupId>
		<artifactId>commons-pool2</artifactId>
	</dependency>

	<dependency>
		<groupId>org.projectlombok</groupId>
		<artifactId>lombok</artifactId>
	</dependency>
	<dependency>
		<groupId>com.alibaba</groupId>
		<artifactId>druid</artifactId>
		<version>1.1.10</version>
	</dependency>
	<!-- 測試 -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-test</artifactId>
		<scope>test</scope>
	</dependency>
	<dependency>
		<groupId>org.mybatis.spring.boot</groupId>
		<artifactId>mybatis-spring-boot-starter</artifactId>
		<version>1.1.1</version>
	</dependency>
	<!-- mysql 依賴 -->
	<dependency>
		<groupId>mysql</groupId>
		<artifactId>mysql-connector-java</artifactId>
	</dependency>
	<!-- springboot-web組件 -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
	<!-- springboot 整合 pagehelper -->
	<dependency>
		<groupId>com.github.pagehelper</groupId>
		<artifactId>pagehelper-spring-boot-starter</artifactId>
		<version>1.2.5</version>
	</dependency>
	<dependency>
		<groupId>org.apache.commons</groupId>
		<artifactId>commons-lang3</artifactId>
		<version>3.7</version>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-devtools</artifactId>
		<optional>true</optional>
		<scope>true</scope>
	</dependency>
	<dependency>
		<groupId>org.apache.tomcat.embed</groupId>
		<artifactId>tomcat-embed-jasper</artifactId>
	</dependency>

	<!-- spring boot start -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter</artifactId>
		<exclusions>
			<!-- 排除自帶的logback依賴 -->
			<exclusion>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-starter-logging</artifactId>
			</exclusion>
		</exclusions>
	</dependency>

	<!-- springboot-log4j -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-log4j</artifactId>
		<version>1.3.8.RELEASE</version>
	</dependency>
	<!-- aop -->
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-aop</artifactId>
	</dependency>
</dependencies>
複製代碼

實體類

package com.gitboy.redis.pojo;

import java.io.Serializable;

public class Department implements Serializable{
	
	private static final long serialVersionUID = 1L;
	private Integer id;
	private String departmentName;
	
	
	public Department() {
		super();
	}
	public Department(Integer id, String departmentName) {
		super();
		this.id = id;
		this.departmentName = departmentName;
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getDepartmentName() {
		return departmentName;
	}
	public void setDepartmentName(String departmentName) {
		this.departmentName = departmentName;
	}
	@Override
	public String toString() {
		return "Department [id=" + id + ", departmentName=" + departmentName + "]";
	}
	

}

複製代碼

package com.gitboy.redis.pojo;

import java.io.Serializable;

public class Employee implements Serializable {
	
	private static final long serialVersionUID = 1L;
	private Integer id;
	private String lastName;
	private String email;
	private Integer gender; //性別 1男 0女
	private Integer dId;
	
	
	public Employee() {
		super();
	}

	
	public Employee(Integer id, String lastName, String email, Integer gender, Integer dId) {
		super();
		this.id = id;
		this.lastName = lastName;
		this.email = email;
		this.gender = gender;
		this.dId = dId;
	}
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getLastName() {
		return lastName;
	}
	public void setLastName(String lastName) {
		this.lastName = lastName;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public Integer getGender() {
		return gender;
	}
	public void setGender(Integer gender) {
		this.gender = gender;
	}
	public Integer getdId() {
		return dId;
	}
	public void setdId(Integer dId) {
		this.dId = dId;
	}
	@Override
	public String toString() {
		return "Employee [id=" + id + ", lastName=" + lastName + ", email=" + email + ", gender=" + gender + ", dId="
				+ dId + "]";
	}


}

複製代碼

Redis的配置

package com.gitboy.redis.conf;
 
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
 
import java.time.Duration;
 
@Configuration
public class RedisConfig extends CachingConfigurerSupport {
 
    /** * 配置自定義redisTemplate * *org.springframework.boot.autoconfigure.data.redis.RedisAutoConfiguration * @param * @return */
   @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
 
        RedisTemplate<String, Object> template = new RedisTemplate<>();
 
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
 
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
 
        template.setConnectionFactory(factory);
        //key序列化方式
        template.setKeySerializer(redisSerializer);
        //value序列化
        template.setValueSerializer(jackson2JsonRedisSerializer);
        //value hashmap序列化
        template.setHashValueSerializer(jackson2JsonRedisSerializer);
 
        return template;
    }
 
    /** * json序列化 * org.springframework.data.redis.serializer.RedisSerializer<T> * org.springframework.data.redis.serializer.RedisSerializer.serialize(T) * @return */
    @Bean
    public RedisSerializer<Object> jackson2JsonRedisSerializer() {
        //使用Jackson2JsonRedisSerializer來序列化和反序列化redis的value值
        Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
 
        ObjectMapper mapper = new ObjectMapper();
        mapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        mapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        serializer.setObjectMapper(mapper);
        return serializer;
    }
 
 
    /** * 配置緩存管理器 * org.springframework.cache.support.AbstractCacheManager * org.springframework.cache.CacheManager * @param * @return */
    @Bean
    public CacheManager cacheManager(RedisConnectionFactory factory) {
        RedisSerializer<String> redisSerializer = new StringRedisSerializer();
        Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<Object>(Object.class);
 
        //解決查詢緩存轉換異常的問題
        ObjectMapper om = new ObjectMapper();
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
        jackson2JsonRedisSerializer.setObjectMapper(om);
 
        // 配置序列化（解決亂碼的問題）,過時時間
        RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
                .entryTtl(Duration.ofHours(1))
                .serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
                .serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
                .disableCachingNullValues();
 
        RedisCacheManager cacheManager = RedisCacheManager.builder(factory)
                .cacheDefaults(config)
                .build();
        return cacheManager;
    }
}

複製代碼

mapper

package com.gitboy.redis.mapper;

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import com.gitboy.redis.pojo.Department;

@Mapper
public interface DepartmentMapper {

    @Select("SELECT * FROM department WHERE id = #{id}")
    Department getDeptById(Integer id);
}

複製代碼

package com.gitboy.redis.mapper;

import org.apache.ibatis.annotations.Delete;
import org.apache.ibatis.annotations.Insert;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import org.apache.ibatis.annotations.Update;

import com.gitboy.redis.pojo.Employee;

@Mapper
public interface EmployeeMapper {

    @Select("SELECT * FROM employee WHERE id = #{id}")
    public Employee getEmpById(Integer id);

    @Update("UPDATE employee SET lastName=#{lastName},email=#{email},gender=#{gender},d_id=#{dId} WHERE id=#{id}")
    public void updateEmp(Employee employee);

    @Delete("DELETE FROM employee WHERE id=#{id}")
    public void deleteEmpById(Integer id);

    @Insert("INSERT INTO employee(lastName,email,gender,d_id) VALUES(#{lastName},#{email},#{gender},#{dId})")
    public void insertEmployee(Employee employee);

    @Select("SELECT * FROM employee WHERE lastName = #{lastName}")
    Employee getEmpByLastName(String lastName);
}

複製代碼

service

package com.gitboy.redis.service;

import com.gitboy.redis.pojo.Employee;

public interface EmployeeRedisService {

	Employee getEmp(Integer id);

	Employee updateEmp(Employee employee);

	void deleteEmp(Integer id);

	Employee getEmpByLastName(String lastName);


}




package com.gitboy.redis.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.cache.annotation.Caching;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import com.gitboy.redis.mapper.EmployeeMapper;
import com.gitboy.redis.pojo.Employee;
import com.gitboy.redis.service.EmployeeRedisService;

@CacheConfig(cacheNames= {"empRedis"})
@Service
public class EmployeeRedisServiceImpl implements EmployeeRedisService {

	@Autowired
	private EmployeeMapper employeeMapper;
	
	
	@Autowired
	private RedisTemplate redisTemplate;
	@Autowired
	private StringRedisTemplate stringRedisTemplate;
	
	@Cacheable(value="empRedis"/*,keyGenerator = "myKeyGenerator",unless="#result == null"key = "#id"*/)
	@Override
	public Employee getEmp(Integer id) {
		System.out.println("查詢"+id+"號員工");
        Employee emp = employeeMapper.getEmpById(id);
        
        //empRedisTemplate.opsForValue().set(id, emp);
        
        
        return emp;
	}

	@CachePut(key = "#result.id")
	@Override
	public Employee updateEmp(Employee employee) {
		System.out.println("updateEmp:"+employee);
        employeeMapper.updateEmp(employee);
        return employee;
	}

	@CacheEvict(beforeInvocation = true/*key = "#id",*/)
	@Override
	public void deleteEmp(Integer id) {
		System.out.println("deleteEmp:"+id);
        employeeMapper.deleteEmpById(id);
        //int i = 10/0;
	}

	 @Caching(
	         cacheable = {
	             @Cacheable(key = "#lastName")
	         },
	         put = {
	             @CachePut(key = "#result.id"),
	             @CachePut(key = "#result.email")
	         }
	    )
	@Override
	public Employee getEmpByLastName(String lastName) {
		return employeeMapper.getEmpByLastName(lastName);
	}

}

複製代碼

package com.gitboy.redis.service;

import com.gitboy.redis.pojo.Department;

public interface DeptRedisService {

	Department getDeptById(Integer id);

}


package com.gitboy.redis.service.impl;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheConfig;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import com.gitboy.redis.mapper.DepartmentMapper;
import com.gitboy.redis.pojo.Department;
import com.gitboy.redis.service.DeptRedisService;

@Service
@CacheConfig(cacheNames= {"deptRedis"})
public class DeptRedisServiceImpl implements DeptRedisService {

	@Autowired
	private DepartmentMapper departmentMapper;

	@Cacheable(key="#id")
	@Override
	public Department getDeptById(Integer id) {

		System.out.println("查詢部門"+id);
        Department department = departmentMapper.getDeptById(id);
        return department;
	}
}

複製代碼

comtroller

package com.gitboy.redis.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import com.gitboy.redis.pojo.Department;
import com.gitboy.redis.service.DeptRedisService;

@RestController
public class DeptRedisController {

	@Autowired
	private DeptRedisService deptRedisService;
	
	
    @GetMapping("/deptRedis/{id}")
    public Department getDept(@PathVariable("id") Integer id){
        return deptRedisService.getDeptById(id);
    }
}
複製代碼

package com.gitboy.redis.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import com.gitboy.redis.pojo.Employee;
import com.gitboy.redis.service.EmployeeRedisService;

/** * @author No * 緩存採用redis中間件 */
@RestController
public class EmployeeRedisController {

	@Autowired
	private EmployeeRedisService employeeRedisService;
	
	@GetMapping("/empRedis/{id}")
    public Employee getEmployee(@PathVariable("id") Integer id){
        Employee employee = employeeRedisService.getEmp(id);
        return employee;
    }

    @GetMapping("/empRedis")
    public Employee update(Employee employee){
        Employee emp = employeeRedisService.updateEmp(employee);

        return emp;
    }

    @GetMapping("/delEmpRedis")
    public String deleteEmp(Integer id){
    	employeeRedisService.deleteEmp(id);
        return "success";
    }

    @GetMapping("/empRedis/lastname/{lastName}")
    public Employee getEmpByLastName(@PathVariable("lastName") String lastName){
       return employeeRedisService.getEmpByLastName(lastName);
    }
	
}


複製代碼

yml文件

#端口
server:
 port: 8081
  
spring:
 datasource:
 driver-class-name: com.mysql.jdbc.Driver
 url: jdbc:mysql://localhost:3306/springboot?characterEncoding=utf8&useSSL=false
 username: root
 password: root
 type: com.alibaba.druid.pool.DruidDataSource
 thymeleaf:
 cache: false
    
 redis:
 host: 134.175.30.90
mybatis:
 configuration:
 map-underscore-to-camel-case: true
    
#分頁插件
pagehelper:
 helper-dialect: mysql
 reasonable: true
 support-methods-arguments: true
 params: count=countSql
 page-size-zero: true
複製代碼

日誌文件

#log4j.rootLogger=CONSOLE,info,error,DEBUG
log4j.rootLogger=info,error,CONSOLE,DEBUG
log4j.appender.CONSOLE=org.apache.log4j.ConsoleAppender     
log4j.appender.CONSOLE.layout=org.apache.log4j.PatternLayout     
log4j.appender.CONSOLE.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n     
log4j.logger.info=info
log4j.appender.info=org.apache.log4j.DailyRollingFileAppender
log4j.appender.info.layout=org.apache.log4j.PatternLayout     
log4j.appender.info.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
log4j.appender.info.datePattern='.'yyyy-MM-dd
log4j.appender.info.Threshold = info   
log4j.appender.info.append=true   
#log4j.appender.info.File=/home/admin/pms-api-services/logs/info/api_services_info
log4j.appender.info.File=C:logs/info/api_services_info
log4j.logger.error=error  
log4j.appender.error=org.apache.log4j.DailyRollingFileAppender
log4j.appender.error.layout=org.apache.log4j.PatternLayout     
log4j.appender.error.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
log4j.appender.error.datePattern='.'yyyy-MM-dd
log4j.appender.error.Threshold = error   
log4j.appender.error.append=true   
#log4j.appender.error.File=/home/admin/pms-api-services/logs/error/api_services_error
log4j.appender.error.File=C:logs/error/api_services_error
log4j.logger.DEBUG=DEBUG
log4j.appender.DEBUG=org.apache.log4j.DailyRollingFileAppender
log4j.appender.DEBUG.layout=org.apache.log4j.PatternLayout     
log4j.appender.DEBUG.layout.ConversionPattern=%d{yyyy-MM-dd-HH-mm} [%t] [%c] [%p] - %m%n  
log4j.appender.DEBUG.datePattern='.'yyyy-MM-dd
log4j.appender.DEBUG.Threshold = DEBUG   
log4j.appender.DEBUG.append=true   
#log4j.appender.DEBUG.File=/home/admin/pms-api-services/logs/debug/api_services_debug
log4j.appender.DEBUG.File=C:logs/debug/api_services_debug
複製代碼

啓動類

package com.gitboy.redis;

import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.scheduling.annotation.EnableScheduling;

@SpringBootApplication
@MapperScan(basePackages="com.gitboy.redis.mapper")
@EnableScheduling
@EnableCaching
public class AppRedis {
    public static void main(String[] args) {

        SpringApplication.run(AppRedis.class, args);
    }
}

複製代碼