开发辅助三（缓存Redisson分布式锁+分页插件）

缓存

缓存穿透：查询一个不存在的数据，由于缓存不命中，将大量查询数据库，但是数据库也没有此记录。
没有将这次查询的null写入缓存，导致了这个不存在的数据每次请求都要到存储层查询，失去了缓存的意义。
解决：null结果缓存，并加入短暂的过期事件

缓存雪崩：设置缓存时采用了相同的过期时间，导致缓存存在某一时刻同时失效，请求全部转发到DB，DB瞬时压力过重
解决：原有的失效时间基础上增加一个随机值，这样缓存的过期时间重复率就会降低。

缓存击穿：对于一些设置了过期时间的key，如果这些key在某些时间点高并发地访问，同时正好失效，那么所有的压力都会到数据库上。
解决：大量并发只让一个去查，其他人等待，查到以后释放锁，其他人获取到锁，先查缓存，就有数据，不用去数据库。
将redis作为缓存工具

①、模块中导入依赖，并且配置文件application.yml添加reids连接信息IP和端口

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

②、Service业务类中使用

@Autowired
private StringRedisTemplate redisTemplate;

@Override
public Map<String,List<Categlo2Vo>> getCatelogJson(){
	
	String catelogJSON = redisTemplate.opsForValue().get("catelogJSON");
	if(!StringUtils.isEmpty(catalogJSON)){
		//如果redis不存在，则从数据库中查找，然后将数据库查找的结果放入缓存redis中
		Map<String,List<Catelog2Vo>> catalogJsonFromDb = getCatalogJsonFromDb();
		
		return catalogJsonFromDb;
	}
	//如果缓存中存在json，则需要转为对象
	Map<String,List<Catelog2Vo>> result = JSON.parseObject(catalogJSON,new TypeReference<Map<String,List<Catelog2Vo>>>(){});
	return result;
}

//查询数据库
public Map<String,List<Catelog2Vo>> getCatalogJsonFromDb(){
	
	synchronized(this){
		//得到锁以后，应该再去缓存确定一次，如果没有才需要继续查询
		String catalogJSON = redisTemplate.opsForValue().get("catalogJSON");
		if(!StringUtils.isEmpty(catalogJSON)){
			Map<String,List<Catelog2Vo>> result = JSON
				.parseObject(catalogJSON,new TypeReference<Map<String,List<Catelog2Vo>>>(){});
			return result;
		}
		
		//查询数据库的业务逻辑……
		//...
		

		//缓存中以json类型存储可以跨平台使用，所以将对象转为json，并放到缓存中
		String s = JSON.toJSONString(catalogJsonFromDb);
		redisTemplate.opsForValue().set("catalogJSON",s,1,TimeUnit.DAY);

		return parent_cid;
	}
	
}

产生堆外异常OutOfDirectMemoryError
SpringBoot2.0以后默认使用lettuce作为操作redis的客户端，使用netty进行网络通信
lettuce的bug导致netty堆外内存溢出，-Xmx300m
解决方案：①、升级lettuce客户端 ②、切换jedis

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
	<exclusions>
		<exclusion>
			<groupId>io.lettuce</groupId>
			<artifactId>lettuce-core<artifactId>
		</exclusion>
	</exclusions>
</dependency>
<dependency>
	<groupId>redis.clients</groupId>
	<artifactId>jedis</artifactId>
</denpendency>

分布式锁

redis命令

set locl 1111 NX

set lock 1111 EX 300 NX #占坑的同时添加了过期时间

①、若查询数据库业务中出现异常，导致delete锁无法执行，出现死锁情况，则通过添加expire过期时间来释放锁

public Map<String,List<Catelog2Vo>> getCatalogJsonFromDbWithRedisLock(){
	
	//占分布式锁(如果不存在，即设置)
	Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock","111");
	if(lock){//加锁成功，执行业务
	
		redisTemplate.expire("lock",30,TimeUnit.SECONDS);//防止查询数据库业务中出现异常导致的死锁
		Map<String,List<Catelog2Vo>> dataFromDb = getDataFromDb();//即使业务出现异常，还会删除锁
		redisTemplate.delete("lock");
		return dataFromDb
	}else{ //加锁失败
		
		//重试
		return getCatalogJsonFromDbWithRedisLock();
	}
	
}

②、若在执行过期时间的时候出现异常，造成无法释放锁

public Map<String,List<Catelog2Vo>> getCatalogJsonFromDbWithRedisLock(){
	
	Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock","1111",300,Time.SECONDS);//占锁的时候同时设置过期时间
	if(lock){
		Map<String,List<Catelog2Vo>> dataFromDb = getDataFromDb();//即使业务出现异常，还会删除锁
		redisTemplate.delete("lock");
		return dataFromDb
	}else{
		return getCatalogJsonFromDbWithRedisLock();
	}
}

③、删除锁导致将其他线程锁也删除，通过判断先获取自己的锁值，然后在删除自己的锁

public Map<String,List<Catelog2Vo>> getCatalogJsonFromDbWithRedisLock(){
	
	String uuid = UUID.randomUUID().toString();
	Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock",uuid,300,Time.SECONDS);//占锁的时候同时设置过期时间
	if(lock){
		Map<String,List<Catelog2Vo>> dataFromDb = getDataFromDb();

		String lockValue = redisTemplate.opsForValue().get("lock");
		if(uuid.equals(lockValue)){
			redisTemplate.delete("lock");
		}
		
		return dataFromDb;
	}else{
		return getCatalogJsonFromDbWithRedisLock();
	}
}

④、如果判断之后出现锁过期，而其他线程设置了锁，那么删除的依然是其他线程的锁(加锁、解锁都保证原子性)

public Map<String,List<Catelog2Vo>> getCatalogJsonFromDbWithRedisLock(){
	
	String uuid = UUID.randomUUID().toString();
	Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock",uuid,300,Time.SECONDS);//占锁的时候同时设置过期时间
	if(lock){
		Map<String,List<Catelog2Vo>> dataFromDb;
		try{
			dataFromDb = getDataFromDb();
		}finally{
			//通过lua脚本解锁
			String script = "if redis.call('get',KEYS[1] == ARGV[1] then return redis.call('del',KEYS[1])) else return 0 end";
			Long lock1 = redisTemplate.execute(new DefaultRedisScript<Long>(script,Integer.class),
				Arrays.asList("lock"),uuid);
		}
		
		return dataFromDb;
	}else{
		return getCatalogJsonFromDbWithRedisLock();
	}
}

分布式锁Redisson

①、导入依赖

<dependency>
	<groupId>org.redisson</groupId>
	<artifactId>redisson</artifactId>
	<version>3.12.0</version>
</dependency>

②、配置类

@Configuration
public class MyRedissonConfig{
	
	@Bean(destroyMethod="shutdown")
	public RedissonClient redisson() throws IOException{
		Config config = new Config();
		/**
			Redis集群模式
			config.useClusterServers()
			.addNodeAddress("127.0.0.1:7004","127.0.0.1:7001");
		*/
		//Redis单节点模式
		config.useSingleServer().setAddress("redis://192.168.56.10:6379");
		RedissonClient redissonClient = Redisson.create(config);
		return redissonClient;
	}
}

③、使用

@Autowired
private RedissonClient redisson;

public Map<String,List<Catelog2Vo>> getCatalogJsonFromDbWithRedissonLock(){
	
	//获取锁，锁的粒度越小越好
	RLock lock = redisson.getLock("catalogJson-lock");
	lock.lock();
	
	Map<String,List<Catelog2Vo>> dataFromDb;
	try{
		dataFromDb = getDataFromDb();
	}finally{
		lock.unlock();
	}
	return dataFromDb;
}

缓存一致性

整合SpringCache

①、引入依赖

<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
<dependency>
	<groupId>org.springframework.boot</groupId>
	<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

②、配置application.properties，配置使用redis作为缓存

spring.cache.type=redis
spring.cache.redis.time-to-live=1000 #设置过期时间，以毫秒为单位
spring.cache.redis.key-prefix=CACHE_
spring.cache.redis.use-key-prefix=true

#是否缓存空值(防止缓存穿透)
spring.cache.redis.cache-null-value=true

③、使用

先在启动类开启缓存注解 @EnableCaching

Service实现的业务类中：

@Cacheable(value={"category"},key="'level1Categorys'") //当前方法的结果需要缓存，如果缓存中有，方法不用调用
@Override
public List<CategoryEntity> getLevel1Categorys(){
	
	Long l = System.currentTimeMllis();
	List<CategoryEntity> categoryEntities = baseMapper.selectList();
	return categoryEntities;
}

@CacheEvict(value="category",key="getLevel1Categorys")//修改时，删除缓存
@Transactional
@Override
public void updateCascade(CategoryEntity category){
	
}

自定义缓存配置类

@EnableConfigurationProperties(CacheProperties.class) //开启和配置文件的绑定功能，使得配置文件的内容生效
@Configuration
@EnableCaching
public class MyCacheConfig{
	
	/**
		第一种方式：直接从容器的配置文件获取
		第二种方式：将其作为方法参数(如下方法的参数)
	*/
//	@Autowired
//	CacheProperties cacheProperties;//从容器中获取配置
	
	@Bean
	public RedisCacheConfiguration redisCacheConfiguration(CacheProperties cacheProperties){
		
		RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig();

		//对key和value进行序列化
		config = config.serializeKeysWith(RedisSerializetionContext.SerializationPair.fromSerializer(new StringRedisSerializer()));
		config = config.serializeValuesWith(RedisSerializetionContext.SerializationPair.fromSerializer(new StringRedisSerializer(new GenericJackson2JsoRedisSerializer()));

		//将配置文件中的所有配置生效
		CacheProperties.Redis redisProperties = cacheProperties.getRedis();
		if(redisProperties.getTimeToLive()!=null){
			config = config.entityTtl(redisProperties.getTimeToLive());
		}
		if(redisProperties.getKeyPrefix()!=null){
			config = config.prefixKeysWith(redis.getKeyPrefix());
		}
		if(!redisProperties.isCacheNullValues()){
			config = config.disableCachingNullValues();
		}
		if(!redisProperties.isUserKeyPrefix){
			config = config.disableKeyPrefix();
		}

		return config;
	}
}

分页插件

查询用户分页显示功能

①、myatis分页插件依赖

<dependency>
	<groupId>com.github.pagehelper</groupId>
	<artifactId>pagehelper</artifactId>
</dependency>

②、配置文件spring-persist-mybtis.xml

<bean id="sqlSessionFactoryBean" class="org.mybatis.spring.SqlSessionFactory">
	<property name="configLocation" value="classpath:mybatis-config.xml"/>
	<property name="mapperLocations" value="classpath:mybatis/mapper/*Mapper.xml"/>
	<property name="dataSource" ref="dataSource"/>
	
	<!--配置插件-->
	<property name="plugins">
		<array>
			<!--分页插件-->
			<bean class="com.github.pagehelper.PageHelper">
				<property name="properties">
					<props>
						<!--数据库方言-->
						<prop key="dialect">mysql</prop>
						<!--配置页码的合理化修正，在1~总页数之间修正页码-->
						<prop key="reasonable">true</prop>
					</props>
				</property>
			</bean>
		</array>
	</property>
</bean>

③、Mapper文件和Mapper接口

<select id="selectAdminByKeyword" resultMap="BaseResultMap">
	select id,login_acct,user_pswd,user_name,email,create_time
	from t_admin
	where 
	login_acct like concat("%",#{keyword},"%") or 
	user_name like concat("%",#{keyword},"%") or
	email like concat("%",#{keyword},"%")
</select>

List<Admin> selectAdminByKeyword(String keyword);

④、service实现

@Override
public PageInfo<Admin> getPageInfo(String keyword,Integer pageNum,Integer pageSize){
	
	//调用PageHelper静态方法开启分页功能
	PageHelper.startPage(pageNum,pageSize);

	//执行查询
	List<Admin> list = adminMapper.selectAdminByKeyword(keyword);

	//封装到PageInfo对象中
	return new PageInfo<>(list);
}

⑤、Controller

@RequestMapping("/admin/get/page.html")
public String getPageInfo(@RequestParam(value="keyword",defaultValue="")String keyword,
						  @RequestParam(value="pageNum",defaultValue="1")Integer pageNum,
						  @RequestParam(value="pageSize",defaultValue="5")Integr pageSize,
						  ModelMap modelMap){
	
	PageInfo<Admin> pageInfo = adminService.getPageInfo(keyword,pageNum,pageSize);
	
	modelMap.addAttribute(CrowdConstant.ATTR_NAME_PAGE_INFO,pageInfo);
	return "admin-page"
}

⑥、页面中循环遍历

<c:if test="${empty requestScope.pageInfo.list}">
	<tr>
		<td colspan="6" align="center">没有查询到你要的数据</td>
	</tr>
</c:if>
<c:if test="${!empty requestScope.pageInfo.list}">
	<c:forEach items="${requestScope.pageInfo.list}" var="admin">
		
	<c:forEach>
</c:if>