缓存的引入

怼烎@ 2022-01-28 07:51 206阅读 0赞

高性能读，数据的读取，延时性很低

# 一、设计数据库 #

## 1.1t\_menu ##

Id  
pid  
Name  
Icon  
![在这里插入图片描述][20190523162813596.png]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70]

INSERT INTO `t_menu` VALUES (1, 0, '家用电器', NULL);
    INSERT INTO `t_menu` VALUES (2, 0, '电脑/数码/运营商', NULL);
    INSERT INTO `t_menu` VALUES (3, 1, '电视', NULL);
    INSERT INTO `t_menu` VALUES (4, 1, '空调', NULL);
    INSERT INTO `t_menu` VALUES (5, 1, '洗衣机', NULL);
    INSERT INTO `t_menu` VALUES (6, 2, '手机通讯', NULL);
    INSERT INTO `t_menu` VALUES (7, 2, '运营商', NULL);
    INSERT INTO `t_menu` VALUES (8, 2, '手机配件', NULL);
    INSERT INTO `t_menu` VALUES (9, 3, '超薄', NULL);
    INSERT INTO `t_menu` VALUES (10, 3, '高清电视', NULL);
    INSERT INTO `t_menu` VALUES (11, 3, '智能电视', '');

## 1.2生成实体和数据库的操作对象 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 1]

## 1.3导入实体 ##

![在这里插入图片描述][20190523162852819.png]  
给Menu 添加一个字段  
![在这里插入图片描述][20190523162858854.png]  
![在这里插入图片描述][20190523162903958.png]

## 1.4java 接口（user-api） ##

/**
     * 操作菜单的接口
     * @author CodeLab
     *
     */
    public interface MenuService {
        
    	/**
    	 *加载所有的菜单（代表一次性将所有的树加载出来）
    	 *Menu 里面的nodes 是否为空？
    	 * @return
    	 */
      List<Menu> loadAllMenu();
      
      /**
       * 通过父id 查询它的字节点
       * @param pid
       * @return
       */
      List<Menu> loadMenu(Integer pid);
    }

## 1.5实现类 ##

@Service
    public class MenuServiceImpl implements MenuService {
        
    
    	@Autowired
    	private MenuMapper menuMapper;
    	
    	/*
    	 * 一次性加载所有 全部加载
    	 *(non-Javadoc)
    	 * @see com.sxt.service.MenuService#loadAllMenu()
    	 * 如何加载全部的菜单：
    	 * 1 2 层循环加载（缺点：树的深度必须确认下来 优点：速度快）
    	 *  全查询
    	 *  将查询的数据自己拼接为一个树
    	 * 2 使用递归（优点：树的深度可以事先不知道缺点：速度慢，使用的内存大，不好理解）
    	 * 
    	 */
    	@Override
    	public List<Menu> loadAllMenu() {
        
    		return loadAllMenu(0);
    	}
    	
    	/**
    	 * 递归查询树菜单
    	 * @param pid
    	 * @return
    	 */
    	public List<Menu> loadAllMenu(Integer pid){
        
    		 List<Menu> menus = new ArrayList<Menu>();
    		MenuExample menuExample = new MenuExample();
    		Criteria createCriteria = menuExample.createCriteria();
    		createCriteria.andPidEqualTo(pid);
    		menus.addAll(menuMapper.selectByExample(menuExample));
    		for (Menu menu : menus) {
        
    			menu.setNodes(loadAllMenu(menu.getId()));
    		}
    		return menus ;
    	}
    
    	/**
    	 * 根据父id 加载子菜单，不全部加载
    	 * select * from t_menu where pid = #{id}
    	 */
    	@Override
    	public List<Menu> loadMenu(Integer pid) {
        
    		Assert.notNull(pid, "加载子菜单时，父id 不能为null");
    		
    		// MenuExample 查询对象，使用它可以生成各式各样的sql 语句，以后查询的sql ，不需要我们自己写
    		MenuExample menuExample = new MenuExample();
    		// 查询条件，在该对象里面可以添加任意的条件
    		Criteria createCriteria = menuExample.createCriteria();
    		createCriteria.andPidEqualTo(pid);
    		
    		List<Menu> menus = menuMapper.selectByExample(menuExample);
    		return menus;
    	}
    
    }

## 1.6测试 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 2]  
单个数据：[json.cn][]  
整个树：  
[http://www.bejson.com/jsonviewernew/][http_www.bejson.com_jsonviewernew]

## 1.7结果 ##

查询速度慢，缓存解决

# 二、新的问题 #

![在这里插入图片描述][20190523163000202.png]

## 2.1 使用jvm的空间换时间 ##

当缓存达到一定程度后，容易引发OOM问题

## 2.2 该缓存位于一个jvm 里面 ##

该缓存不能共享  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 3]  
需要redis 解决

## 2.3 缓存的模型对代码的改造太大，不容易扩展 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 4]  
![在这里插入图片描述][20190523163033129.png]  
Spring aop ？

## 2.3.1 引入切面的包 ##

aspectj

<dependency>
        <groupId>org.aspectj</groupId>
        <artifactId>aspectjweaver</artifactId>
        <version>1.8.7</version>
    </dependency>

不需要classmate 该依赖了

## 2.3.2 定义一个切面类 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 5]

## 2.3.3 切点的切入 ##

大家有会切面表达时的写法  
@Around(“execution (\* com.sxt.service.impl.MenuServiceImpl.loadAllMenu())”)

## 2.3.4 实现环绕通知的逻辑 ##

@Component
    @Aspect
    public class CacheAspect {
        
    
    	private static Map<String,Object> caches = new HashMap<>();
    	
    	private static final String ALL_MENU_LABEL = "alll-menu-data"; 
    	
    	@Around("execution (* com.sxt.service.impl.MenuServiceImpl.loadAllMenu())")
    	public Object cache(ProceedingJoinPoint ponit) {
        
    		if(caches.containsKey(ALL_MENU_LABEL)) {
        
    			System.out.println("缓存里面有");
    			return caches.get(ALL_MENU_LABEL);
    		}
    		
    		Object result = null ; 
    		try {
        
    			System.out.println("执行真实方法的调用");
    			result = ponit.proceed(ponit.getArgs()); // 在此实现了真实方法的调用
    //			放入缓存
    			caches.put(ALL_MENU_LABEL, result);
    		} catch (Throwable e) {
        
    			e.printStackTrace();
    		}
    
    		return result;
    	}
    }

## 2.3.5 开启切面的注解开发 ##

新增一个配置文件  
Spring-aop.xml  
![在这里插入图片描述][20190523163158274.png]

## 2.3.6 改造代码测试 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 6]

# 三、缓存的其他问题 #

## 3.1 缓存的击穿 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 7]  
Select \* from t\_user where id = -10;  
查询的数据一致无法命中缓存（缓存里面一直没有）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 8]  
那缓存击穿的本质原因是：  
数据库没有这个值，查询数据库都是无用的操作  
1 在执行查询之前，如果预先知道数据库里面没有这个值，我可以不查询数据库  
2 查询数据库，发现没有该值，现在我在缓存里面缓存一个null 值

## 3.2 缓存的雪崩 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 9]  
当黑客使用大量的数据测试（不止是-1 ，-1–> 无穷）则缓存里面可能缓存很多null，null 也占用空间，过一个缓存慢了，无法存入新的值了，该现象被称为缓存的雪崩。

## 3.3 击穿和雪崩的解决方案 ##

产生的原因是：数据库里面，没有该值产生的  
若实现知道该数据库里面没有该值，这个问题就可以解决。要求不能查数据。  
HashSet  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 10]

## 3.4 问题 ##

![在这里插入图片描述][20190523163312965.png]

## 3.5 解决方案 ##

什么数据结构不占内存  
1 int = 4个字节=4*8 = 32 bit  
1bit 内存占用下来了  
图片怎么存储（1980*1080p）  
位图-> 存储图片  
![在这里插入图片描述][20190523163322167.png]  
借着该图片的存储，我们可以使用BloomFilter  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 11]

/**
     * 基于java bit集合 做bloomfilter ，之后将使用Redis的bitset 来实现
     * @author CodeLab
     *
     */
    public class BloomFilter {
        
    
    	/**
    	 * 位集合的大小
    	 */
    	private static final Integer BIT_SIZE = 2<<(30-1) ;
    	/**
    	 * 位集合
    	 */
    	private static BitSet bitSet = new BitSet(BIT_SIZE);
    	/**
    	 * hash的个数
    	 */
    	private static final Integer HASH_SIZE = 5 ;
    
    	/**
    	 * hash 函数的种子
    	 */
    	private static final Integer []SEEDS = new Integer[] {
        17,19,23,29,31};
    	/**
    	 * 5 个hash 函数
    	 */
    	private static HashFun []hashs = new HashFun[HASH_SIZE];
    
    	static {
        
    		for (int i = 0; i < hashs.length; i++) {
        
    			hashs[i] = new HashFun(SEEDS[i]);
    		}
    	}
    	/**
    	 * 将对象放入位集合里面
    	 * 
    	 * @param object
    	 */
    	public static void putBit(Object object) {
        
    		for (HashFun hashFun : hashs) {
        
    			Integer hashCode = hashFun.hash(object);
    			Integer pos = hashCode & (BIT_SIZE - 1); // 将该hashcode 映射在位集合上面
    			bitSet.set(pos);// 把改点描黑
    		}
    	}
    
    	/**
    	 * 判断该位集合里面是否存在该值
    	 * @param object
    	 *  该对象
    	 * @return
    	 * 存在：true
    	 * 不存在：false
    	 */
    	public static boolean isExist(Object object) {
        
    		for (HashFun hashFun : hashs) {
        
    			Integer hashCode = hashFun.hash(object);
    			Integer pos = hashCode & (BIT_SIZE-1);// 将该hashcode 映射在位集合上面
    			boolean flag = bitSet.get(pos);
    			if(!flag) {
         //描黑了
    				return false;
    			}
    		}
    		return true; // 代表所有的点都符合，则为true
    	}
    
    	public static void main(String[] args) {
        
    		String name1 = "MAYUN";
    		String name2 = "MAHAATENG";
    		String name3 = "WANGJIAN";
    		String name4 = "CUIHUA";
    		putBit(name1);
    		putBit(name2);
    		putBit(name3);
    		putBit(name4);
    		if(isExist(name1)) {
        
    			System.out.println("ok");
    		}
    		if(isExist(name2)) {
        
    			System.out.println("ok");
    		}
    		if(isExist(name3)) {
        
    			System.out.println("ok");
    		}
    		if(isExist(name4)) {
        
    			System.out.println("ok");
    		}
    		
    	}
    }

## 3.5.1 往位集合里面存数据 ##

1 得到该数据的5个hash值  
2 使用该hash 值映射在位集合上面  
3 将位集合的该点设置为1

/**
    	 * 将对象放入位集合里面
    	 * 
    	 * @param object
    	 */
    	public static void putBit(Object object) {
        
    		for (HashFun hashFun : hashs) {
        
    // hashcode
    			Integer hashCode = hashFun.hash(object);
    // 映射到位上
    			Integer pos = hashCode & (BIT_SIZE - 1); // 将该hashcode 映射在位集合上面
    //设置为1
    			bitSet.set(pos);// 把改点描黑
    		}
    	}

## 3.5.2 在位集合里面怎么判断是否有该数据 ##

1 算该对象的hash 值  
2 使用该hash 映射在位上面  
3 看该为上面是否为1 若为1 继续往下判断，直到所有的hash 都 判断通过

public static boolean isExist(Object object) {
        
    		for (HashFun hashFun : hashs) {
        
    			Integer hashCode = hashFun.hash(object);
    			Integer pos = hashCode & (BIT_SIZE-1);// 将该hashcode 映射在位集合上面
    			boolean flag = bitSet.get(pos);
    			if(!flag) {
         //描黑了
    				return false;
    			}
    		}
    		return true; // 代表所有的点都符合，则为true
    	}

## 3.5.3 位集合 ##

只能存储0/1 的集合

## 3.5.4 hash 的生成 ##

参考了String 的源码实现

private Integer seed = null ;
    	
    	public HashFun(Integer seed) {
        
    		this.seed = seed ;
    	}
    	
    	public Integer hash(Object object) {
        
    		// 得到该对象的string
    		char[] value = object.toString().toCharArray();
    		
    		  int h = 0;
    	        if (h == 0 && value.length > 0) {
        
    	            char val[] = value;
    
    	            for (int i = 0; i < value.length; i++) {
        
    	                h = seed * h + val[i]; // hash的种子数31质数
    	            }
    	        }
    	        return h;
    	}

# 四、将Hash函数推广 #

每个hash 函数都能提出一个对象的特征  
推荐到人脸识别？  
人脸（鼻子，耳朵，眼睛，额骨，眉毛）  
我们有5 个hash 函数能得到该5 个特征的值  
高斯模糊-> 得到一个鼻子的特征  
需要5 个高斯模糊，即可得到该5 个特征  
人工智能（核过滤）

如何判断该人脸是德华不是你  
5 个特征函数得到5个特征值  
你的脸：【1001,1004,101,1007,1006】  
德华的脸：【999,782,865,431,107】  
求导，稀疏矩阵的求导  
机器人：对抗神经网络（淘宝的实现）

第一次：T-shirt 点击到七匹狼的T-shirt  
第二次搜索：T-shirt ->七匹狼的T-shirt - > 纯棉  
第三次搜索：七匹狼的纯棉T-shirt

[20190523162813596.png]: /images/20220128/2c07c15f1727448db37af2061f175871.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70]: /images/20220128/35648f24c293442a8b1cd41f68cf26c9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 1]: /images/20220128/7d6510e2b90649169c5e1acaf172d0e7.png
[20190523162852819.png]: /images/20220128/352283c56e7d4520a302d19d8f57bfa6.png
[20190523162858854.png]: /images/20220128/a4eb7d0eac674812b34bcb808dc5f02c.png
[20190523162903958.png]: /images/20220128/1f0878ee00ad4c8fa6e2afe85d2e7808.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 2]: /images/20220128/29c250a626fb4311a157e8d064298c54.png
[json.cn]: http://json.cn
[http_www.bejson.com_jsonviewernew]: http://www.bejson.com/jsonviewernew/
[20190523163000202.png]: /images/20220128/a48fb50bb2a449cfa486476f5d361afa.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 3]: /images/20220128/2bd5e2a762104da29ebe2b5e299d7963.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 4]: /images/20220128/9a1d949a3945440ea1cf328fc0091597.png
[20190523163033129.png]: /images/20220128/cc4d81c2fdc247be95e62c6f030eaac6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 5]: /images/20220128/acf3e3c7d6a44dd7a685c9d36ec9a845.png
[20190523163158274.png]: /images/20220128/473a3ab8ca2e45b1be014283f707ad36.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 6]: /images/20220128/7e12f8af4cb94c4bb5ecdffeed900879.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 7]: /images/20220128/038a4f080f8740b3a80893a5b5494037.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 8]: /images/20220128/4aa8b55be34747eabe9b5dedd5ab3689.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 9]: /images/20220128/979006844a7747ceaf5543414d6717c5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 10]: /images/20220128/8e05ed6c78e444d2b661c579a714731a.png
[20190523163312965.png]: /images/20220128/36adf4b60fed4b6bb44dad255a638e58.png
[20190523163322167.png]: /images/20220128/1d718297f0334fcb93221c207b5843a8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0MDEzNzkw_size_16_color_FFFFFF_t_70 11]: /images/20220128/454062018a96474b939900246a522372.png