⑴ spring cache 注解 缓存名有什么用
来看下@Cacheable 的说明
@Cacheable(value="accountCache")，这个注释的意思是，当调用这个方法的时候，会从一个名叫 accountCache 的缓存中查询，如果没有，则执行实际的方法（即查询数据库），并将执行的结果存入缓存中，否则返回缓存中的对象。这里的缓存中的 key 就是参数 userName，value 就是 Account 对象。“accountCache”缓存是在 spring*.xml 中定义的名称。
示例：
@Cacheable(value="accountCache")//使用了一个缓存名叫accountCache
publicAccountgetAccountByName(StringuserName){
//方法内部实现不考虑缓存逻辑，直接实现业务
System.out.println("realqueryaccount."+userName);
returngetFromDB(userName);
}
主要作用是给 cache 取个名称
⑵ spring 如何解决循环依赖，为什么要创建三个缓存
spring是如何解决单例的循环依赖注入
首先看下面三个缓存：
1.singletonObjects:存放初始化好的bean
2.earlySingletonObjects：存放了刚实例化好的，但是还未配置属性和初始化的bean，我们在获取该bean的时候会调用beanPostProcessor的getEarlyReference进行一些提前获取bean的必要操作
3.singletonFactories:存放我刚实例化的bean，通过ObjectFactory，可以让如果有提前需要bean的需要可以调用该
objectfactory 其会将刚实例化好的bean经过beanPostProcessor的getEarlyReference处理进行返回
我们先实例化A，实例化好后
调用addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
() -> getEarlyBeanReference(beanName, mbd, bean)是objectFactory的实现匿名类，然后此时我们设置属性的时候会发现我们还依赖B，于是我们去实例化B而当我们此时实例化B的会经过下面这个方法
由此可见 如果之前已经把A存放在singletonFactories，那么B会把其调出来放入earlySingletonObjects，然后整个单例创建完成在塞入singletonObjects。存放在singletonFactories好处是可扩展，我们在这个里面会调用beanPostProcessor 从而可以在我们实现提前获取对象引用的时候进行一些操作
⑶ windows环境下Redis+Spring缓存实例
一、Redis了解
1.1、Redis介绍：
redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set –有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更新的数据写入磁盘或者把修改操作写入追加的记录文件，并且在此基础上实现了master-slave(主从)同步。
Redis数据库完全在内存中，使用磁盘仅用于持久性。相比许多键值数据存储，Redis拥有一套较为丰富的数据类型。Redis可以将数据复制到任意数量的从服务器。
1.2、Redis优点：
（1）异常快速：Redis的速度非常快，每秒能执行约11万集合，每秒约81000+条记录。
（2）支持丰富的数据类型：Redis支持最大多数开发人员已经知道像列表，集合，有序集合，散列数据类型。这使得它非常容易解决各种各样的问题，因为我们知道哪些问题是可以处理通过它的数据类型更好。
（3）操作都是原子性：所有Redis操作是原子的，这保证了如果两个客户端同时访问的Redis服务器将获得更新后的值。
（4）多功能实用工具：Redis是一个多实用的工具，可以在多个用例如缓存，消息，队列使用(Redis原生支持发布/订阅)，任何短暂的数据，应用程序，如Web应用程序会话，网页命中计数等。
1.3、Redis缺点：
（1）单线程
（2）耗内存
二、64位windows下Redis安装
Redis官方是不支持windows的，但是Microsoft Open Tech group 在 GitHub上开发了一个Win64的版本，下载地址：https://github.com/MSOpenTech/redis/releases。注意只支持64位哈。
小宝鸽是下载了Redis-x64-3.0.500.msi进行安装。安装过程中全部采取默认即可。
安装完成之后可能已经帮你开启了Redis对应的服务，博主的就是如此。查看资源管理如下，说明已经开启：
已经开启了对应服务的，我们让它保持，下面例子需要用到。如果没有开启的.，我们命令开启，进入Redis的安装目录（博主的是C:Program FilesRedis），然后如下命令开启：
redis-server redis.windows.conf
OK，下面我们进行实例。
三、详细实例
本工程采用的环境：Eclipse + maven + spring + junit
3.1、添加相关依赖（spring+junit+redis依赖），pom.xml：
4.0.0 com.luo redis_project 0.0.1-SNAPSHOT 3.2.8.RELEASE 4.10 org.springframework spring-core ${spring.version} org.springframework spring-webmvc ${spring.version} org.springframework spring-context ${spring.version} org.springframework spring-context-support ${spring.version} org.springframework spring-aop ${spring.version} org.springframework spring-aspects ${spring.version} org.springframework spring-tx ${spring.version} org.springframework spring-jdbc ${spring.version} org.springframework spring-web ${spring.version} junit junit ${junit.version} test org.springframework spring-test ${spring.version} test org.springframework.data spring-data-redis 1.6.1.RELEASE redis.clients jedis 2.7.3
3.2、spring配置文件application.xml：
<"1.0" encoding="UTF-8"> classpath:properties/*.properties
3.3、Redis配置参数，redis.properties：
#redis中心#绑定的主机地址redis.host=127.0.0.1#指定Redis监听端口，默认端口为6379redis.port=6379#授权密码（本例子没有使用）redis.password=123456 #最大空闲数：空闲链接数大于maxIdle时，将进行回收redis.maxIdle=100 #最大连接数：能够同时建立的“最大链接个数”redis.maxActive=300 #最大等待时间：单位msredis.maxWait=1000 #使用连接时，检测连接是否成功 redis.testOnBorrow=true#当客户端闲置多长时间后关闭连接，如果指定为0，表示关闭该功能redis.timeout=10000
3.4、添加接口及对应实现RedisTestService.Java和RedisTestServiceImpl.java：
package com.luo.service; public interface RedisTestService { public String getTimestamp(String param);}
package com.luo.service.impl; import org.springframework.stereotype.Service;import com.luo.service.RedisTestService; @Servicepublic class RedisTestServiceImpl implements RedisTestService { public String getTimestamp(String param) { Long timestamp = System.currentTimeMillis(); return timestamp.toString(); } }
3.5、本例采用spring aop切面方式进行缓存，配置已在上面spring配置文件中，对应实现为MethodCacheInterceptor.java：
package com.luo.redis.cache; import java.io.Serializable;import java.util.concurrent.TimeUnit;import org.aopalliance.intercept.MethodInterceptor;import org.aopalliance.intercept.MethodInvocation;import org.springframework.data.redis.core.RedisTemplate;import org.springframework.data.redis.core.ValueOperations; public class MethodCacheInterceptor implements MethodInterceptor { private RedisTemplate redisTemplate; private Long defaultCacheExpireTime = 10l; // 缓存默认的过期时间,这里设置了10秒 public Object invoke(MethodInvocation invocation) throws Throwable { Object value = null; String targetName = invocation.getThis().getClass().getName(); String methodName = invocation.getMethod().getName(); Object[] arguments = invocation.getArguments(); String key = getCacheKey(targetName, methodName, arguments); try { // 判断是否有缓存 if (exists(key)) { return getCache(key); } // 写入缓存 value = invocation.proceed(); if (value != null) { final String tkey = key; final Object tvalue = value; new Thread(new Runnable() { public void run() { setCache(tkey, tvalue, defaultCacheExpireTime); } }).start(); } } catch (Exception e) { e.printStackTrace(); if (value == null) { return invocation.proceed(); } } return value; } /** * 创建缓存key * * @param targetName * @param methodName * @param arguments */ private String getCacheKey(String targetName, String methodName, Object[] arguments) { StringBuffer sbu = new StringBuffer(); sbu.append(targetName).append("_").append(methodName); if ((arguments != null) && (arguments.length != 0)) { for (int i = 0; i < arguments.length; i++) { sbu.append("_").append(arguments[i]); } } return sbu.toString(); } /** * 判断缓存中是否有对应的value * * @param key * @return */ public boolean exists(final String key) { return redisTemplate.hasKey(key); } /** * 读取缓存 * * @param key * @return */ public Object getCache(final String key) { Object result = null; ValueOperations operations = redisTemplate .opsForValue(); result = operations.get(key); return result; } /** * 写入缓存 * * @param key * @param value * @return */ public boolean setCache(final String key, Object value, Long expireTime) { boolean result = false; try { ValueOperations operations = redisTemplate .opsForValue(); operations.set(key, value); redisTemplate.expire(key, expireTime, TimeUnit.SECONDS); result = true; } catch (Exception e) { e.printStackTrace(); } return result; } public void setRedisTemplate( RedisTemplate redisTemplate) { this.redisTemplate = redisTemplate; }}
3.6、单元测试相关类：
package com.luo.baseTest; import org.junit.runner.RunWith; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; //指定bean注入的配置文件 @ContextConfiguration(locations = { "classpath:application.xml" }) //使用标准的JUnit @RunWith注释来告诉JUnit使用Spring TestRunner @RunWith(SpringJUnit4ClassRunner.class) public class SpringTestCase extends { }
package com.luo.service; import org.junit.Test;import org.springframework.beans.factory.annotation.Autowired; import com.luo.baseTest.SpringTestCase; public class RedisTestServiceTest extends SpringTestCase { @Autowired private RedisTestService redisTestService; @Test public void getTimestampTest() throws InterruptedException{ System.out.println("第一次调用：" + redisTestService.getTimestamp("param")); Thread.sleep(2000); System.out.println("2秒之后调用：" + redisTestService.getTimestamp("param")); Thread.sleep(11000); System.out.println("再过11秒之后调用：" + redisTestService.getTimestamp("param")); } }
3.7、运行结果：
四、源码下载：redis-project().rar
以上就是本文的全部内容，希望对大家的学习有所帮助。
⑷ SpringBoot整合SpringSeesion实现Redis缓存
使用Spring Boot开发项目时我们经常需要存储Session，因为Session中会存一些用户信息或者登录信息。传统的web服务是将session存储在内存中的，一旦服务挂了，session也就消失了，这时候我们就需要将session存储起来，而Redis就是用来缓存seesion的一种非关系型数据库，我们可以通过配置或者注解的方式将Spring Boot和Redis整合。而在分布式系统中又会涉及到session共享的问题，多个服务同时部署时session需要共享，Spring Session可以帮助我们实现这一功能。将Spring Session集成到Spring Boot框架中并使用Redis进行缓存是目前非常流行的解决方案，接下来就跟着我一起学习吧。
工具/材料
IntelliJ IDEA
首先我们创建一个Spring Boot 2.x的项目，在application.properties配置文件中添加Redis的配置，Spring和Redis的整合可以参考我其他的文章，此处不再详解。我们设置服务端口server.port为8080端口用于启动第一个服务。
接下来我们需要在pom文件中添加spring-boot-starter-data-redis和spring-session-data-redis这两个依赖，spring-boot-starter-data-redis用于整合Spring Boot和Redis，spring-session-data-redis集成了spring-session和spring-data-redis，提供了session与redis的整合方案。
接下来我们创建一个配置类RedisSessionConfig，这个类使用@Configuration注解表明这是一个配置类。在这个类上我们同时添加注解@EnableRedisHttpSession，表示开启Redis的Session管理。如果需要设置失效时间可以使用@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 3600)表示一小时后失效。若同时需要设置Redis的命名空间则使用@EnableRedisHttpSession(maxInactiveIntervalInSeconds=3600, redisNamespace="{spring.session.redis.namespace}") ，其中{spring.session.redis.namespace}表示从配置文件中读取这个命名空间。
配置完成后我们写一个测试类SessionController，在这个类中我们写两个方法，一个方法用于往session中存数据，一个用于从session中取数据，代码如下图所示，我们存取请求的url。启动类非常简单，一般都是通用的，我们创建一个名为SpringbootApplication的启动类，使用main方法启动。
接下来我们使用Postman分别请求上面两个接口，先请求存数据接口，再请求取数据接口，结果如下图所示，我们可以看到数据已从redis中取出。另外需要注意sessionId的值，这是session共享的关键。
为了验证两个服务是否共享了session，我们修改项目的配置文件，将服务端口server.port改为8090，然后再启动服务。此时我们不必在请求存数据的接口，只需要修改请求端口号再一次请求取数据的接口即可。由下图可以看到两次请求的sessionId值相同，实现了session的共享。
以上我们完成了SpringBoot整合SpringSeesion实现Redis缓存的功能，在此我们还要推荐一个Redis的可视化工具RedisDesktopManager，我们可以配置Redis数据库的连接，然后便可以非常直观地查看到存储到Redis中的session了，如下图所示，session的命名空间是share，正是从配置文件中读取到的。
特别提示
如果Redis服务器是很多项目共用的，非常建议配置命名空间，否则同时打开多个项目的浏览器页面可能会导致session错乱的现象。
⑸ hibernate二级缓存 和 spring整合的缓存(就是用哪个Cacheable注解的)有什么区别么
二级缓存配置（spring+hibernate）
说明：本人不建议使用查询缓存，因为查询缓存要求完全相同的查询sql语句才会起作用，所说的查询缓存是针对第二次查询时 sql语句与第一次sql语句完全相同 那么就可以从缓存中取数据而不去数据库中取数据了，在不启用查询缓存的情况下 每次的查询数据也会缓存到二级缓存的 只不过每次查询都会去查询数据库（不包括根据ID查询），启用查询缓存很麻烦 需要每次查询时 调用Query.setCacheable(true)方法才可以，如：List<OrgiData> orgiDatas = (List<OrgiData>) s.createQuery("from OrgiData").setCacheable(true).list();
因此建议将查询缓存设置为如下：
hibernate.cache.use_query_cache=false
还有就是最重要的一点：对于经常修改或重要的数据不宜进行缓存，因为多并发时会造成数据不同步的情况。
首先增加ehcache-1.4.1.jar和backport-util-concurrent-3.1.jar或oscache-2.1.jar
一、spring配置
<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">
<property name="dataSource" ref="dataSource" />
<property name="mappingResources">
<list>
<value>com/handpay/core/merchant/bean/MerchGroupBuy.hbm.xml
</value>
</list>
</property>
<property name="hibernateProperties">
<value>
hibernate.dialect=org.hibernate.dialect.SQLServerDialect
hibernate.show_sql=true
hibernate.format_sql=true
hibernate.hbm2ddl.auto=update
hibernate.cache.use_second_level_cache=true
hibernate.cache.use_query_cache=false
hibernate.cache.provider_class=org.hibernate.cache.EhCacheProvider </value>
</property>
</bean>
<!---红色字体是二级缓存相关的设置->
二、hbm.xml文件示例
<?xml version="1.0"?>
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping package="com.handpay.core.merchant.bean">
<class name="MerchGroupBuy" table="merch_group_buy">
<cache usage="read-write" region="com.handpay.core.merchant.bean.MerchGroupBuy"/>
<id name="id">
<generator class="native" />
</id>
<property name="code" />
<property name="createTime"/>
<property name="minNum"/>
<property name="status">
</property>
<property name="title"/>
<property name="typeCode"/>
<property name="updateTime"/>
</class>
</hibernate-mapping>
三、注解示例
@Entity
@Cache(usage = CacheConcurrencyStrategy.READ_ONLY)
@Table(name = "alcor_t_countries", catalog = "alcorweb")
public class AlcorTCountries implements java.io.Serializable{。。。。}
四、配置文件参数详解
ehcache.xml是ehcache的配置文件，并且存放在应用的classpath中。下面是对该XML文件中的一些元素及其属性的相关说明：
<diskStore>元素：指定一个文件目录，当EHCache把数据写到硬盘上时，将把数据写到这个文件目录下。 下面的参数这样解释：
user.home – 用户主目录
user.dir – 用户当前工作目录
java.io.tmpdir – 默认临时文件路径
<defaultCache>元素：设定缓存的默认数据过期策略。
<cache>元素：设定具体的命名缓存的数据过期策略。
<cache>元素的属性
name：缓存名称。通常为缓存对象的类名（非严格标准）。
maxElementsInMemory：设置基于内存的缓存可存放对象的最大数目。
maxElementsOnDisk：设置基于硬盘的缓存可存放对象的最大数目。
eternal：如果为true，表示对象永远不会过期，此时会忽略timeToIdleSeconds和timeToLiveSeconds属性，默认为false;
timeToIdleSeconds： 设定允许对象处于空闲状态的最长时间，以秒为单位。当对象自从最近一次被访问后，如果处于空闲状态的时间超过了timeToIdleSeconds属性值，这个对象就会过期。当对象过期，EHCache将把它从缓存中清空。只有当eternal属性为false，该属性才有效。如果该属性值为0，则表示对象可以无限期地处于空闲状态。
timeToLiveSeconds：设定对象允许存在于缓存中的最长时间，以秒为单位。当对象自从被存放到缓存中后，如果处于缓存中的时间超过了 timeToLiveSeconds属性值，这个对象就会过期。当对象过期，EHCache将把它从缓存中清除。只有当eternal属性为false，该属性才有效。如果该属性值为0，则表示对象可以无限期地存在于缓存中。timeToLiveSeconds必须大于timeToIdleSeconds属性，才有意义。
overflowToDisk：如果为true,表示当基于内存的缓存中的对象数目达到了maxElementsInMemory界限后，会把益出的对象写到基于硬盘的缓存中。注意：如果缓存的对象要写入到硬盘中的话，则该对象必须实现了Serializable接口才行。
memoryStoreEvictionPolicy：缓存对象清除策略。有三种：
1 FIFO ，first in first out ，这个是大家最熟的，先进先出，不多讲了
2 LFU ， Less Frequently Used ，就是上面例子中使用的策略，直白一点就是讲一直以来最少被使用的。如上面所讲，缓存的元素有一个hit 属性，hit 值最小的将会被清出缓存。
2 LRU ，Least Recently Used ，最近最少使用的，缓存的元素有一个时间戳，当缓存容量满了，而又需要腾出地方来缓存新的元素的时候，那么现有缓存元素中时间戳离当前时间最远的元素将被清出缓存。
五 、查看 二级缓存数据
1、使用sessionFactory直接获取
Map cacheEntries = sessionFactory().getStatistics()
.getSecondLevelCacheStatistics("cacheRegionName")
.getEntries();
其中 cacheRegionName 既是 ehcache.xml配置中的<cache 标签的name属性值
2、让log4j打印缓存信息（生成环境下请注释掉，以免影响性能）
log4j.logger.org.hibernate.cache=debug
⑹ Spring本地缓存的使用方法
我们现在在用的Spring Cache，可以直接看Spring Boot提供的缓存枚举类，有如下这些：
EhCache：一个纯Java的进程内缓存框架，所以也是基于本地缓存的。(注意EhCache2.x和EhCache3.x相互不兼容)。
Redis：分布式缓存，只有Client-Server(CS)模式，Java一般使用Jedis/Luttuce来操纵。
Hazelcast：基于内存的数据网格。虽然它基于内存，但是分布式应用程序可以使用Hazelcast进行分布式缓存、同步、集群、处理、发布/订阅消息等。
Guava：它是Google Guava工具包中的一个非常方便易用的本地化缓存实现，基于LRU（最近最少使用）算法实现，支持多种缓存过期策略。在Spring5.X以后的版本已经将他标记为过期了。
Caffeine：是使用Java8对Guava缓存的重写版本，在Spring5中将取代了Guava，支持多种缓存过期策略。
SIMPLE：使用ConcurrentMapCacheManager，因为不支持缓存过期时间，所以做本地缓存基本不考虑该方式。
关于分布式缓存，我们需要后面会专门讨论Redis的用法，这里只看本地缓存。性能从高到低，依次是Caffeine，Guava，ConcurrentMapCacheManager，其中Caffeine在读写上都快了Guava近一倍。
这里我们只讨论在Spring Boot里面怎么整合使用Caffeine和EhCache。
主要有以下几个步骤：
1)加依赖包：
2)配置缓存：
这里有两种方法，通过文件配置或者在配置类里面配置，先看一下文件配置，我们可以写一个properties文件，内容像这样：
然后还要在主类中加上@EnableCaching注解：
另外一种更灵活的方法是在配置类中配置：
应用类：
测试类：
导入依赖包，分为2.x版本和3.x版本。
其中2.x版本做如下导入：
3.x版本做如下导入：
导包完成后，我们使用JCacheManagerFactoryBean + ehcache.xml的方式配置：
参考资料：
https://blog.csdn.net/f641385712/article/details/94982916
http://www.360doc.com/content/17/1017/20/16915_695800687.shtml
⑺ springboot缓存怎么来操作
1.在pom.xml中引入cache依赖，添加如下内容：
复制代码
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>
复制代码
2.在Spring Boot主类中增加@EnableCaching注解开启缓存功能，如下：
复制代码
@SpringBootApplication
@EnableCaching
public class Application {
public static void main(String[] args) {
SpringApplication.run(Application.class, args);
}
}
复制代码
3.在数据访问接口中，增加缓存配置注解，如：
复制代码
@CacheConfig(cacheNames = "users")
public interface UserRepository extends JpaRepository<User, Long> {
@Cacheable
User findByName(String name);
}
复制代码
SpringBoot支持很多种缓存方式：redis、guava、ehcahe、jcache等等。