几个主要的概念常用缓存注解#
几个主要的概念&常用缓存注解#
名称 解释
Cache 缓存接口，主要实现由 RedisChache， EhCacheCachem , ConcurrentMapCache
CacheManager 缓存管理器,管理存放着不同类型的缓存 Cache 组件
@Cacheable 加在方法上,根据方法的请求参数对结果进行缓存
@CacheEvict 清空缓存
@CachePut 保证方法被调用,又希望对方法的结果进行缓存
@EnableCaching 添加在启动类上,表示开始缓存
@keyGenerator 缓存数据时key生成策略
serialize 混存数据时,value的序列化策略
@Cacheable#
上手使用#
第一步:
开启基于注解的缓存 @EnableCaching
第二步:
使用缓存注解@Cacheable
Copy
@Target({ElementType.METHOD, ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented public @interface Cacheable { @AliasFor("cacheNames") String[] value() default {}; @AliasFor("value") String[] cacheNames() default {}; String key() default ""; String keyGenerator() default ""; String cacheManager() default ""; String cacheResolver() default ""; String condition() default ""; String unless() default ""; boolean sync() default false; }
value 和 cacheNames 作用一样,都是在指定缓存的名字, 接收一个数组,可以指定多个缓存
key, 指定当前这条数据在缓存中的唯一标识,支持SPEL表达式,默认是方法的参数值
最好都提前确定好使用哪个key
keyGenerator, 指定key的生成策略
Copy
// 自定义key的生成器 @Configuration public class MyCacheConfig { @Bean("myKeyGenerator") public KeyGenerator keyGenerator() { return new KeyGenerator() { @Override public Object generate(Object o, Method method, Object... objects) { return method.getName() + "[" + Arrays.asList(objects).toString() + "]"; } }; } } // 使用 @Cacheable(cacheNames = "dept",key = "#id",keyGenerator = "myKeyGenerator")
一般key和keyGenerator二选一就行
cacheManager, 指定缓存管理器
cacheResolver, 指定缓存解析器
condition, 当条件为ture时, 进行缓存支持SPEL表达式
Copy
当id>0时,缓存 @Cacheable(cacheNames = "dept",key = "#id",condition = "#id>0") 使用and添加更多的条件 @Cacheable(cacheNames = "dept",key = "#id",condition = "#id>0 and #id<10")
unless, 当条件为true时, 不进行缓存支持SPEL表达式
Copy
当结果为空时,不缓存 @Cacheable(cacheNames = "dept",key = "#id",unless="#result == null")
sync, 异步缓存
异步模式下,不支持 unless
默认的缓存配置#
在诸多的缓存自动配置类中, SpringBoot默认装配的是SimpleCacheConfigguration, 他使用的CacheManager是 CurrentMapCacheManager, 使用 CurrentMap当底层的数据结构,按照Cache的名字查询出Cache, 每一个Cache中存在多个k-v键值对,缓存值
几个主要的概念&常用缓存注解#
名称 解释
Cache 缓存接口，主要实现由 RedisChache， EhCacheCachem , ConcurrentMapCache
CacheManager 缓存管理器,管理存放着不同类型的缓存 Cache 组件
@Cacheable 加在方法上,根据方法的请求参数对结果进行缓存
@CacheEvict 清空缓存
@CachePut 保证方法被调用,又希望对方法的结果进行缓存
@EnableCaching 添加在启动类上,表示开始缓存
@keyGenerator 缓存数据时key生成策略
serialize 混存数据时,value的序列化策略
@Cacheable#
上手使用#
第一步:
开启基于注解的缓存 @EnableCaching
第二步:
使用缓存注解@Cacheable
Copy
@Target({ElementType.METHOD, ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented public @interface Cacheable { @AliasFor("cacheNames") String[] value() default {}; @AliasFor("value") String[] cacheNames() default {}; String key() default ""; String keyGenerator() default ""; String cacheManager() default ""; String cacheResolver() default ""; String condition() default ""; String unless() default ""; boolean sync() default false; }
value 和 cacheNames 作用一样,都是在指定缓存的名字, 接收一个数组,可以指定多个缓存
key, 指定当前这条数据在缓存中的唯一标识,支持SPEL表达式,默认是方法的参数值
最好都提前确定好使用哪个key
keyGenerator, 指定key的生成策略
Copy
// 自定义key的生成器 @Configuration public class MyCacheConfig { @Bean("myKeyGenerator") public KeyGenerator keyGenerator() { return new KeyGenerator() { @Override public Object generate(Object o, Method method, Object... objects) { return method.getName() + "[" + Arrays.asList(objects).toString() + "]"; } }; } } // 使用 @Cacheable(cacheNames = "dept",key = "#id",keyGenerator = "myKeyGenerator")
一般key和keyGenerator二选一就行
cacheManager, 指定缓存管理器
cacheResolver, 指定缓存解析器
condition, 当条件为ture时, 进行缓存支持SPEL表达式
Copy
当id>0时,缓存 @Cacheable(cacheNames = "dept",key = "#id",condition = "#id>0") 使用and添加更多的条件 @Cacheable(cacheNames = "dept",key = "#id",condition = "#id>0 and #id<10")
unless, 当条件为true时, 不进行缓存支持SPEL表达式
Copy
当结果为空时,不缓存 @Cacheable(cacheNames = "dept",key = "#id",unless="#result == null")
sync, 异步缓存
异步模式下,不支持 unless
执行流程&时机#
@Cacheable标注的方法在执行之前,会先去检查缓存中有没有这个数据, 根据这种对应关系查询 key->value, key是使用keyGenerator生成的: 它的默认实现是SimpleKeyGenerate
参数个数 key
没有参数 new SimpleKey()
有一个参数 参数值
多个参数 new SimpleKey(多个参数)
常用的SPEL表达式#
描述 示例
当前被调用的方法名 #root.mathodName
当前被调用的方法 #root.mathod
当前被调用的目标对象 #root.target
当前被调用的目标对象类 #root.targetClass
当前被调用的方法的参数列表 #root.args[0] 第一个参数, #root.args[1] 第二个参数...
根据参数名字取出值 #参数名, 也可以使用 #p0 #a0 0是参数的下标索引
当前方法的返回值 #result
@CachePut#
调用时机:#
目标方法执行完之后生效, @Cache被使用于修改操作比较多,哪怕缓存中已经存在目标值了,但是这个注解保证这个方法依然会执行,执行之后的结果被保存在缓存中
常用更新操作,前端会把id+实体传递到后端使用,我们就直接指定方法的返回值从新存进缓存时的key="#id", 如果前端只是给了实体,我们就使用key="#实体.id" 获取key. 同时,他的执行时机是目标方法结束后执行, 所以也可以使用 key="#result.id", 拿出返回值的id
@CacheEvict 缓存清除#
Copy
@Target({ElementType.METHOD, ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented public @interface CacheEvict { @AliasFor("cacheNames") String[] value() default {}; @AliasFor("value") String[] cacheNames() default {}; String key() default ""; String keyGenerator() default ""; String cacheManager() default ""; String cacheResolver() default ""; String condition() default ""; boolean allEntries() default false; boolean beforeInvocation() default false; }
同样,key的默认值就是参数的id的值,也可以手动指定
condition, 指定条件
value锁定Cache组件
allEntries 指定是否删除当前缓存组件中的全部值,默认是flase不全部删除
beforeInvocation, 缓存的清除,是否在方法之前执行, 默认是flase, 表示在方法执行之后执行
如果是在方法执行之前就清空缓存了, 然后方法执行过程中出现异常被中断,缓存依然会被清除
Copy
@CacheEvict(value="",key="") public void deleteById(Integer id){ // todo }
@Caching#
Copy
@Target({ElementType.METHOD, ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Inherited @Documented public @interface Caching { Cacheable[] cacheable() default {}; CachePut[] put() default {}; CacheEvict[] evict() default {}; }
这是个组合注解,适用于更复杂的情况, 添加在方法上,使用:
Copy
@Caching( cacheable={@Cacheable(...),@Cacheable(...) } put={@CachePut(...),@CachePut(...) } ) public void xxx(XXX){...}
@CacheConfig#
使用场景, 比如,在一个部门的控制器中, 所有的缓存使用的value都是一样的,所有的方法又不能不写,于是使用@CacheConfig简化开发
Copy
@Target({ElementType.TYPE}) @Retention(RetentionPolicy.RUNTIME) @Documented public @interface CacheConfig { String[] cacheNames() default {}; String keyGenerator() default ""; String cacheManager() default ""; String cacheResolver() default ""; }
添加在类头上
cacheNames , 指定缓存使用的公共的名字, 使用在标注在类头上, 类中方法上的缓存相关的注解都可以不写value="XXX"
整和其他混存中间件#
整合Redis当缓存中间件#
引入启动器
Copy
<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency>
当我们添加进redis相关的启动器之后, SpringBoot会使用RedisCacheConfigratioin当做生效的自动配置类进行缓存相关的自动装配,容器中使用的缓存管理器是
RedisCacheManager, 这个缓存管理器创建的Cache为 RedisCache, 进而操控redis进行数据的缓存
使用RedisTemplate,默认保存进去的数据 k-v 全是Obeject, 被保存的对象需要实现序列化接口, 虽然可以达到缓存的目的,但是对象被序列化成一堆看不懂的乱码, 需要我们自定义Redis 的 Template, 以及自定义CacheManager, 但是这样的话相对于它默认的配置就变的异常的麻烦;
使用redisTemplate做缓存的常用方式
查询:#
首先去redis中尝试获取,如果有redis中有值,直接返回redis中的结果 , 如果没有,去数据库中查询,把结果存入redis
Copy
// todo 使用redis做缓存,减少和数据库的接触次数 public Label findById(Long labelId) { // 先尝试从缓存中查询当前对象 Label label = (Label) redisTemplate.opsForValue().get("label_id" + labelId); if (label==null){ // 从数据库中查询 // 将查出的结果存进缓存中 redisTemplate.opsForValue().set("label_id"+label.getId(),label); } return label;
修改:#
先更新数据库, 然后删除redis中对应的缓存
Copy
public void update(Long labelId, Label label) { label.setId(labelId); Label save = labelRepository.save(label); // todo 数据库修改成功后, 将缓存删除 redisTemplate.delete("label_id"+save.getId()); }
删除:#
同样,先删除数据库中的数据, 再删除缓存
这个是最普通的socket编程的服务端，没什么好多说的。就是绑定本地的8899端口，死循环不断接受数据。
2|1传统IO传输
public class OldIOClient {
public static void main(String[] args) throws Exception {
Socket socket = new Socket("localhost", 8899);
String fileName = "C:\\Users\\Administrator\\Desktop\\test.zip"; //大小两百M的文件
InputStream inputStream = new FileInputStream(fileName);
DataOutputStream dataOutputStream = new DataOutputStream(socket.getOutputStream());
byte[] buffer = new byte[4096];
long readCount;
long total = 0;
long startTime = System.currentTimeMillis();
while ((readCount = inputStream.read(buffer)) >= 0) {
total += readCount;
dataOutputStream.write(buffer);
}
System.out.println("发送总字节数： " + total + ", 耗时： " + (System.currentTimeMillis() - startTime));
dataOutputStream.close();
socket.close();
inputStream.close();
}
}
客户端向服务端发送一个119M大小的文件。计算一下耗时用了多久
由于我的笔记本性能太渣，大概平均每次消耗的时间大概是 500ms左右。值得注意的是，我们客户端和服务端分配的缓存大小都是4096个字节。如果将这个字节分配的更小一点，那么所耗时间将会更多。因为上述传统的IO实际表现并不是我们想象的那样直接将文件读到内存，然后发送。
实际情况是什么样的呢？我们在后续分析。
2|2NIO传输
public class NewIOClient {
public static void main(String[] args) throws Exception {
SocketChannel socketChannel = SocketChannel.open();
socketChannel.connect(new InetSocketAddress("localhost", 8899));
socketChannel.configureBlocking(true);
String fileName = "C:\\Users\\Administrator\\Desktop\\test.zip"; //大小200M的文件
FileChannel fileChannel = new FileInputStream(fileName).getChannel();
long startTime = System.currentTimeMillis();
long transferCount = fileChannel.transferTo(0, fileChannel.size(), socketChannel); //1
System.out.println("发送总字节数：" + transferCount + "，耗时： " + (System.currentTimeMillis() - startTime));
fileChannel.close();
}
}
NIO编程不熟的同学没关系，后面会有一篇专门的章节来讲。
这里我们来关注一下注释1关于FileChannel的transferTo方法。（方法的doc文档很长。我删除了很多，只看重点）
/**
* Transfers bytes from this channel's file to the given writable byte
* channel.
*
* <p> This method is potentially much more efficient than a simple loop
* that reads from this channel and writes to the target channel. Many
* operating systems can transfer bytes directly from the filesystem cache
* to the target channel without actually copying them. https://www.douban.com/people/187906486/</p>
*/
public abstract long transferTo(long position, long count,
WritableByteChannel target)
throws IOException;
翻译一下：
将文件channel的数据写到指定的channel
这个方法可能比简单的将数据从一个channel循环读到另一个channel更有效，
许多操作系统可以直接从文件系统缓存传输字节到目标通道，**而不实际复制它们**。
意思是我们调用FileChannel的transferTo方法就实现了零拷贝（想实现零拷贝并不止这一种方法，有更优雅的方法，这里只是作为一个演示）。当然也要看你操作系统支不支持底层zero copy。因为这部分工作其实是操作系统来完成的。
我的电脑平均执行下来大概在200ms左右。比传统IO快了300ms。
3|0底层原理
num_rows, num_cols = img_mat.shape[:2]
tx=5
ty=0
translation_matrix =www.meiwanyule.cn np.float32([ [1,0,tx], [0,1,ty] ])
img_translation = cv2.warpAffine(img_mat, translation_matrix, (num_cols, num_rows),borderValue=(0,0,0))
效果如下
图像旋转
图像的旋转其实和平移的原理是类似的,opencv里提供了一个api帮我们去获取旋转矩阵.我们只需要给出旋转中心和旋转角度即可.
cv::Mat src = cv::imread(www.yongshenyuL.com "lenna.jpg"www.yuxinyulept.com );
cv::Mat dst;
//旋转角度
double angle = 45;
cv::Size src_sz = src.size();
cv::Size dst_sz(src_sz.height, src_sz.width);
int len = std::max(www.yacuangpt.com src.cols, src.rows);
/http://blog.sina.com.cn/u/5125835408
https://www.douban.com/people/187906486/
cv::Point2f center(www.hnawesm.com / 2., len / 2.);
//获取旋转矩阵（2x3矩阵）
cv::Mat rot_mat = cv::getRotationMatrix2D(center, angle, 1.0);
//根据旋转矩阵进行仿射变换
cv::warpAffine(src,www.51kunlunyule.com dst, rot_mat, dst_sz);
//显示旋转效果
cv::imshow("image", src);
cv::imshow("result", dst);
cv::waitKey(0);
return 0;
大家也可以用自己的电脑运行一下上述代码，看看NIO传输一个文件比IO传输一个文件快多少。
在上诉代码中，楼主这里指定的缓存只有4096个字节，而传送的文件大小有125581592个字节。
在前面我们分析过，对于传统的IO而言，读取的缓存满了以后会有两次零拷贝过程。那么换算下来传输这个文件大概在内存中进行了6w多次无意义的内存拷贝，这6w多次拷贝在我的笔记本上大概所耗费的时间就是300ms左右。这就是导致NIO比传统IO快的更本原因。
3|1传统IO底层时序图
由上图我们可以看到。当我们想将磁盘中的数据通过网络发送的时候，
底层调用的了sendfile()方法，然后切换用户态（User space）->内核态（Kemel space）。
从本地磁盘获取数据。获取的数据存储在内核态的内存空间内。
将数据复制到用户态内存空间里。
切换内核态->用户态。
用户操作数据，这里就是我们编写的java代码的具体操作。
调用操作系统的write()方法，将数据复制到内核态的socket buffer中。
切换用户态->内核态。
发送数据。
发送完毕以后，切换内核态->用户态。继续执行我们编写的java代码。
由上图可以看出。传统的IO发送一次数据，进行了两次“无意义”的内存拷贝。虽然内存拷贝对于整个IO来说耗时是可以忽略不计的。但是操作达到一定次数以后，就像我们上面案例的代码。就会由量变引起质变。导致速率大大降低。
3|2linux2.4版本前的NIO时序图
转存失败
重新上传
取消
底层调用的了sendfile()方法，然后切换用户态（User space）->内核态（Kemel space）。
从本地磁盘获取数据。获取的数据存储在内核态的内存空间内。
将内核缓存中的数据拷贝到socket缓冲中。
将socket缓存的数据发送。
发送完毕以后，切换内核态->用户态。继续执行我们编写的java代码。
可以看出，即便我们使用了NIO，其实在我们的缓存中依旧会有一次内存拷贝。拷贝到socket buffer（也就是发送缓存区）中。
到这里我们可以看到，用户态已经不需要再缓存数据了。也就是少了用户态和系统态之间的数据拷贝过程。也少了两次用户态与内核态上下文切换的过程。但是还是不够完美。因为在底层还是执行了一次拷贝。
要想实现真真意义上的零拷贝，还是需要操作系统的支持，操作系统支持那就支持。不支持你代码写出花了也不会支持。所以在linux2.4版本以后，零拷贝进化为以下模式。
3|3linux2.4版本后的NIO时序图
转存失败
重新上传
取消
这里的步骤与上面的步骤是类似的。看图可以看出，到这里内存中才真正意义上实现了零拷贝。
很多人就会发问了。为什么少了一次内核缓存的数据拷贝到socket缓存的操作？
不急，听我慢慢道来~
我们再来看另一张NIO的流程图：
转存失败
重新上传
取消
上面这个图稍稍有点复杂，都看到这里了，别半途而废。多看几遍是能看懂的！
首先第一条黑线我们可以看出，在NIO只切换了两次用户态与内核态之间的上下文切换。
我们重点看这张图下面的部分。
首先我们将硬盘（hard drive）上的数据复制到内核态缓存中（kemel buffer）。然后发生了一次拷贝（CPU copy）到socket缓存中(socket buffer)。最后再通过协议引擎将数据发送出去。
在linux2.4版本前的的确是这样。但是！！！！
在linux2.4版本以后，上图中的从内核态缓存中（kemel buffer）的拷贝到socket缓存中(socket buffer)的就不再是数据了。而是对内核态缓存中数据的描述符（也就是指针）。协议引擎发送数据的时候其实是通过socket缓存中的描述符。找到了内核态缓存中的数据。再将数据发送出去。这样就实现了真正的零拷贝。
几个主要的概念常用缓存注解#相关推荐
- 深入理解Java：注解（Annotation）基本概念、自定义注解、注解解析器
深入理解Java:注解(Annotation)基本概念 什么是注解(Annotation): Annotation(注解)就是Java提供了一种元程序中的元素关联任何信息和着任何元数据(metadat ...
- 详解Spring缓存注解@Cacheable,@CachePut , @CacheEvict使用
注释介绍 @Cacheable @Cacheable 的作用 主要针对方法配置,能够根据方法的请求参数对其结果进行缓存 @Cacheable 作用和配置方法 参数 解释 example value 缓 ...
- cacheable更新_详解Spring缓存注解@Cacheable,@CachePut , @CacheEvict使用
注释介绍 @Cacheable @Cacheable 的作用 主要针对方法配置,能够根据方法的请求参数对其结果进行缓存 @Cacheable 作用和配置方法 参数 解释 example value 缓 ...
- 【日常】SpringBoot缓存注解器及整合redis实现（附近期一些python零碎的内容）
序言 似乎灵感枯竭了,完全不知道该写些什么东西,非常的痛苦,决定走读博这条路之后就失去了很多乐趣,总是想应该积累更多的论文和相关项目代码量,但是效率却总是很低,需要应付课程与考试,一篇paper的阅读 ...
- 微服务架构-5-Redis实战-5-SpringBoot整合Redis缓存注解开发
文章目录 redis缓存注解 一.概念 二.缓存编程 三 设置缓存有效期 1 配置文件 2 Controller redis缓存注解 Spring Boot缓存注解@Cacheable.@CacheE ...
- Spring缓存注解【@Cacheable、@CachePut、@CacheEvict、@Caching、@CacheConfig】使用及注意事项
文章目录 一.概述 二.缓存注解种类 三.优劣势说明 四.如何使用? 五.详细介绍介绍 1)@Cacheable(常用) 1.value/cacheNames 属性 2.key属性 3.keyGene ...
- [JAVA EE] Thymeleaf 高级用法：模板布局，带参数的引用片段，表单验证，常用校验注解
模板布局 公共部分通常定义为模板布局:如页眉,页脚,公共导航栏.菜单等. 模板布局定义方法 布局页中用 th:fragment 定义模板片段,其他页面用 th:insert 引用片段 例如:foote ...
- Spring 缓存注解@Cacheable 在缓存时候 ，出现了第一次进入调用 方法 ，第二次不调用的异常
Spring 缓存注解@Cacheable 在缓存时候 ,出现了第一次进入调用 方法 ,第二次不调用的异常 参考文章: (1)Spring 缓存注解@Cacheable 在缓存时候 ,出现了第一次进入 ...
- Spring Cache抽象-缓存注解
文章目录 概述 Spring缓存的基本原理 @Cacheable :主要针对方法配置,能够根据方法的请求参数对其结果进行缓存 键生成器 带条件的缓存 @Cacheable 注解参数说明 示例-缓存管理 ...
最新文章
- CentOS 安装Python3
- 深入理解计算机系统 -资料整理 高清中文版_在所不辞的博客-CSDN博客_深入理解计算机系统第四版pdf
- 使用data uri将图片内嵌到html中
- 约会安排 （区间合并）毒瘤题
- Dubbo源码解析 --- DIRECTORY和ROUTER
- linux端口转发到windows,Linux及Windows基于工具的端口转发
- mysql binaryVInstall
- 分布式与人工智能课程(part3)--第三课
- javascript中编码与解码的decodeURI()、decodeURIComponent()区别
- Android应用基础知识（4）---Android处理运行时变更
- 一：Java语言概述
- Java案例3-1 基于控制台的购书系统
- 2017 年，最热开源静态网站生成器 TOP 20 揭晓！
- http server response 一览
- iphone7p配置参数详情_iPhone12系列最全的详细参数，参数党可以看看
- 工厂模式之抽象工厂模式
- C程序设计（第五版）谭浩强第七章课后答案
- 云打码的简单使用举例
- xprivacy改IMEI
- 人生苦短，我用Python，那么问题来了，普通人要学python吗？