spring4.0.9结合redis进行数据的缓存

最新推荐文章于 2024-07-31 11:10:14 发布
最新推荐文章于 2024-07-31 11:10:14 发布
阅读量3.1k 收藏 1
点赞数 2
分类专栏： 数据库 redis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010634288/article/details/53708396
版权

一、今天将以前公司的由SpringMVC搭建的框架和redis整合。Spring版本为4.0.9  redis安装在linux(CentOS6.5)下面。数据库使用mysql。

由于redis，

 1、优异的读写性能

我在这里使用了Redis-benchmark这个自带的性能测试工具进行了测试，由于是学习的机子，性能一般所以测试结果

测试命令： redis-benchmark -h 192.168.100.131 -p 6379 -c 100 -n 100000

100个并发连接，100000个请求，检测host为localhost 端口为6379的redis服务器性能 

====== SET ======   

100000 requests completed in 5.15 seconds

19432.57 requests per second

====== GET ======
  100000 requests completed in 5.51 seconds

18162.01 requests per second

每秒钟可以set 或者get差不多2万条。

2 支持数据持久化，支持AOF和RDB两种持久化方式
3 支持主从复制，主机会自动将数据同步到从机，可以进行读写分离。
4 数据结构丰富：string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）

该项目是一个作品投票的项目，是一个互联网项目的一个子项目，我们知道作品投票有个特点就是：作品这个表是经常被查询，数据基本不变，我们就没有必要每次用户进入页面的时候就进行数据库查询，我们只要在redis中直接读取就可以了,下面我通过这个项目进行spring和redis进行整合。

1、项目的POM.xml文件加入所需要的jar包

<dependency>
		    <groupId>org.apache.commons</groupId>
		    <artifactId>commons-pool2</artifactId>
		    <version>2.4.2</version>
		</dependency> 
		<dependency>
		    <groupId>redis.clients</groupId>
		    <artifactId>jedis</artifactId>
		    <version>2.8.0</version>
		</dependency>
	
		<dependency>
        <groupId>org.springframework.data</groupId>
        <artifactId>spring-data-redis</artifactId>
        <version>1.6.6.RELEASE</version>
    </dependency>

2、为了便于redis配置的管理，我们把一些配置信息单独出来放入redis.properties 

redis.hostName=192.168.100.131
redis.port=6379
redis.timeout=15000
redis.usePool=true
redis.maxIdle=6
redis.minEvictableIdleTimeMillis=300000
redis.numTestsPerEvictionRun=3
redis.timeBetweenEvictionRunsMillis=60000
3、需要加入redis-context.xml 配置如下 

<beans xmlns="http://www.springframework.org/schema/beans" 
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd" default-autowire="byName"> 
 <bean id="jedisPoolConfig" class="redis.clients.jedis.JedisPoolConfig"> 
  <!-- <property name="maxIdle" value="6"></property> 
  <property name="minEvictableIdleTimeMillis" value="300000"></property> 
  <property name="numTestsPerEvictionRun" value="3"></property> 
  <property name="timeBetweenEvictionRunsMillis" value="60000"></property> -->
  
  <property name="maxIdle" value="${redis.maxIdle}"></property> 
  <property name="minEvictableIdleTimeMillis" value="${redis.minEvictableIdleTimeMillis}"></property> 
  <property name="numTestsPerEvictionRun" value="${redis.numTestsPerEvictionRun}"></property> 
  <property name="timeBetweenEvictionRunsMillis" value="${redis.timeBetweenEvictionRunsMillis}"></property>
 </bean> 
 <bean id="jedisConnectionFactory" class="org.springframework.data.redis.connection.jedis.JedisConnectionFactory" destroy-method="destroy"> 
  <property name="poolConfig" ref="jedisPoolConfig"></property> 
  <property name="hostName" value="${redis.hostName}"></property> 
  <property name="port" value="${redis.port}"></property> 
  <property name="timeout" value="${redis.timeout}"></property> 
  <property name="usePool" value="${redis.usePool}"></property>
  <property name="password" value="${redis.password}"></property>
  
 </bean> 
 <bean id="jedisTemplate" class="org.springframework.data.redis.core.RedisTemplate"> 
  <property name="connectionFactory" ref="jedisConnectionFactory"></property> 
  <property name="keySerializer"> 
   <bean class="org.springframework.data.redis.serializer.StringRedisSerializer"/> 
  </property> 
  <property name="valueSerializer"> 
   <bean class="org.springframework.data.redis.serializer.JdkSerializationRedisSerializer"/> 
  </property> 
 </bean> 
</beans>

4、在Spring配置文件中加入读取redis.properties 和redis-context.xml代码

<bean
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<list>				
				<value>classpath:/config/redis.properties</value> 
			</list>
		</property>
	</bean>
<import resource="classpath*:modules/redis-context.xml" />
这样以上环境就配置好了。下面我们加入代码进行测试

5、这里需要加入监听器，这个监听器的作用是我们启动项目的时候会把数据库中的数据（这些数据基本不变），放入redis中，下次们去拿的数据，可以直接总redis中获得，无需进入数据库中读取。

import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationListener;
import org.springframework.context.event.ContextRefreshedEvent;
import org.springframework.stereotype.Service;


@Service
public class StartAddCacheListener implements ApplicationListener<ContextRefreshedEvent> {
	// 日志
	private final Logger log = Logger.getLogger(StartAddCacheListener.class);

	@Autowired
	private RedisCacheUtil<Object> redisCache;

	@Autowired
	private VoteService voteService;

	@Override
	public void onApplicationEvent(ContextRefreshedEvent event) {
		if (event.getApplicationContext().getDisplayName().equals("Root WebApplicationContext")) {
			System.out.println("-------------缓存数据-------------");
			List<VoteProject> voteProjectList = voteService.getAllProject();

			Map<Integer, VoteProject> voteProjectMap = new HashMap<Integer, VoteProject>();

			int cityListSize = voteProjectList.size();

			for (int i = 0; i < cityListSize; i++) {
				voteProjectMap.put(voteProjectList.get(i).getId(), voteProjectList.get(i));
			}

			redisCache.setCacheIntegerMap("voteProjectMap", voteProjectMap);
		}
	}

}

6、将该监听器放入spring配置文件中 

	<bean id="startAddCacheListener" class="com.eshine.vote.redis.listener.StartAddCacheListener"></bean>
7、新建一个util缓存工具类 

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.redis.core.BoundSetOperations;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;

@Service
public class RedisCacheUtil<T> {

	@Autowired
	@Qualifier("jedisTemplate")
	public RedisTemplate redisTemplate;

	/**
	 * 缓存基本的对象，Integer、String、实体类等
	 * 
	 * @param key
	 *            缓存的键值
	 * @param value
	 *            缓存的值
	 * @return 缓存的对象
	 */
	public <T> ValueOperations<String, T> setCacheObject(String key, T value) {

		ValueOperations<String, T> operation = redisTemplate.opsForValue();
		operation.set(key, value);
		return operation;
	}

	/**
	 * 获得缓存的基本对象。
	 * 
	 * @param key
	 *            缓存键值
	 * @param operation
	 * @return 缓存键值对应的数据
	 */
	public <T> T getCacheObject(String key/* ,ValueOperations<String,T> operation */) {
		ValueOperations<String, T> operation = redisTemplate.opsForValue();
		return operation.get(key);
	}

	/**
	 * 缓存List数据
	 * 
	 * @param key
	 *            缓存的键值
	 * @param dataList
	 *            待缓存的List数据
	 * @return 缓存的对象
	 */
	public <T> ListOperations<String, T> setCacheList(String key, List<T> dataList) {
		ListOperations listOperation = redisTemplate.opsForList();
		if (null != dataList) {
			int size = dataList.size();
			for (int i = 0; i < size; i++) {

				listOperation.rightPush(key, dataList.get(i));
			}
		}

		return listOperation;
	}

	/**
	 * 获得缓存的list对象
	 * 
	 * @param key
	 *            缓存的键值
	 * @return 缓存键值对应的数据
	 */
	public <T> List<T> getCacheList(String key) {
		List<T> dataList = new ArrayList<T>();
		ListOperations<String, T> listOperation = redisTemplate.opsForList();
		Long size = listOperation.size(key);

		for (int i = 0; i < size; i++) {
			dataList.add((T) listOperation.leftPop(key));
		}

		return dataList;
	}

	/**
	 * 缓存Set
	 * 
	 * @param key
	 *            缓存键值
	 * @param dataSet
	 *            缓存的数据
	 * @return 缓存数据的对象
	 */
	public <T> BoundSetOperations<String, T> setCacheSet(String key, Set<T> dataSet) {
		BoundSetOperations<String, T> setOperation = redisTemplate.boundSetOps(key);
		/*
		 * T[] t = (T[]) dataSet.toArray(); setOperation.add(t);
		 */

		Iterator<T> it = dataSet.iterator();
		while (it.hasNext()) {
			setOperation.add(it.next());
		}

		return setOperation;
	}

	/**
	 * 获得缓存的set
	 * 
	 * @param key
	 * @param operation
	 * @return
	 */
	public Set<T> getCacheSet(String key/*
										 * ,BoundSetOperations<String,T>
										 * operation
										 */) {
		Set<T> dataSet = new HashSet<T>();
		BoundSetOperations<String, T> operation = redisTemplate.boundSetOps(key);

		Long size = operation.size();
		for (int i = 0; i < size; i++) {
			dataSet.add(operation.pop());
		}
		return dataSet;
	}

	/**
	 * 缓存Map
	 * 
	 * @param key
	 * @param dataMap
	 * @return
	 */
	public <T> HashOperations<String, String, T> setCacheMap(String key, Map<String, T> dataMap) {

		HashOperations hashOperations = redisTemplate.opsForHash();
		if (null != dataMap) {

			for (Map.Entry<String, T> entry : dataMap.entrySet()) {

				/*
				 * System.out.println("Key = " + entry.getKey() + ", Value = " +
				 * entry.getValue());
				 */
				hashOperations.put(key, entry.getKey(), entry.getValue());
			}

		}

		return hashOperations;
	}

	/**
	 * 获得缓存的Map
	 * 
	 * @param key
	 * @param hashOperation
	 * @return
	 */
	public <T> Map<String, T> getCacheMap(String key/*
													 * ,HashOperations<String,String
													 * ,T> hashOperation
													 */) {
		Map<String, T> map = redisTemplate.opsForHash().entries(key);
		/* Map<String, T> map = hashOperation.entries(key); */
		return map;
	}

	/**
	 * 缓存Map
	 * 
	 * @param key
	 * @param dataMap
	 * @return
	 */
	public <T> HashOperations<String, Integer, T> setCacheIntegerMap(String key, Map<Integer, T> dataMap) {
		HashOperations hashOperations = redisTemplate.opsForHash();
		if (null != dataMap) {

			for (Map.Entry<Integer, T> entry : dataMap.entrySet()) {

				/*
				 * System.out.println("Key = " + entry.getKey() + ", Value = " +
				 * entry.getValue());
				 */
				hashOperations.put(key, entry.getKey(), entry.getValue());
			}

		}

		return hashOperations;
	}

	/**
	 * 获得缓存的Map
	 * 
	 * @param key
	 * @param hashOperation
	 * @return
	 */
	public <T> Map<Integer, T> getCacheIntegerMap(String key/*
															 * ,HashOperations<
															 * String,String,T>
															 * hashOperation
															 */) {
		Map<Integer, T> map = redisTemplate.opsForHash().entries(key);
		/* Map<String, T> map = hashOperation.entries(key); */
		return map;
	}

}

8、测试类 

import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.servlet.ModelAndView;



@Controller("/RedisTest")
@RequestMapping({ "/RedisTest*" })
public class RedisTest {

	@Autowired
	private RedisCacheUtil<Object> redisCache;

	@RequestMapping("/testGetCache")
	public ModelAndView testGetCache(HttpServletRequest req, HttpServletResponse rsp) {

		ModelAndView mav = new ModelAndView("html/website/index");

		Map<Integer, VoteProject> voteProjectMap = redisCache.getCacheIntegerMap("voteProjectMap");

		for (int key : voteProjectMap.keySet()) {
			System.out.println("key = " + key + ",value=" + voteProjectMap.get(key).getContent());
		}
		return mav;
	}

}
以上我们已经将代码以及配置全部搭建好了，现在我数据库中一共有17条数据。如下图所示


下面我启动项目，日志提示将读取17条数据


 9、上面提到，有个测试工具类，我们触发它，查看控制台打印数据


我这里数据库并不多，只有十几条，如果数量达到几百万上千万的时候，我每次重启项目都去查询数据库的一千万条记录，显然不合理，所以，对这个项目整合只是一个开始，后面我会尝试在表中加入大量数据,并且对数据进行持久化，如果有时间和机会会在项目尝试redis的主从复制以及读写分离等等。










Spring 4 集成 redis 实现缓存 一
暴走编程的博客
01-19 803
背景 随着Web项目的复杂程度逐渐增加，可能会涉及诸如高并发、海量数据查询的的业务场景也逐渐增多；若频繁的操作数据库，会触发数据库的I/O瓶颈，因此需要加入缓存，尽量减少直接操作数据库的频率和次数；同时在分布式系统中，分布式锁等应用场景也需要依赖redis等缓存数据库；redis作为nosql数据库的代表，拥有广泛的应用场景； 这里介绍下Spring集成redis，实现缓存： 准备工作： 1.引入依赖； <!-- jedis 客户端 --> <dependency> <
Spring-data-reids缓存简单使用例子，Spring+Redis注解式
weixin_43992507的博客
08-03 213
引入依赖 版本可根据需求添加 <!--spring-data-redis包--> <dependency> <groupId>org.springframework.data</groupId> <artifactId>spring-data-redis</artifactId> </dependency> 简单实例 以下字符串都是自定义 CacheManager cacheManager = Sp
Spring4.*+Redis整合使用
weixin_34223655的博客
03-14 929
2019独角兽企业重金招聘Python工程师标准>>> ...
Springboot集成Redis缓存框架
qq_38292982的博客
12-08 461
一、简介 Redis作为缓存框架可以将数据存储在内存中，也可以持久化到磁盘，并且支持灾难恢复机制（服务器宕机了重启Redis服务时可以加载文件恢复缓存的数据） Redis支持多种数据类型：string,list,set,sorted set,hash 二、使用 1.使用前需安装redis，官网地址：http://www.redis.cn/download.html，下载完成后解压，根据不同操作系统启动redis服务即可 2.pom文件引入依赖： <dependency> &lt
Redis 实现缓存 Spring Cache框架的使用
dhsjdh124的博客
03-09 2250
在我们做项目的时候，往往会遇到访问数据库的操作，如果重复的进行某一个操作，会反复访问数据库，造成运行速度缓慢，这时候我们就需要使用缓存数据，减少数据库查询的操作。因为redis是基于内存的数据库，直接存储在内存上的，所以查询会很方便。
Spring Boot 4.0.9整合Redis集群必备jar包
Spring Data Redis是Spring Data的一个子模块，专为Redis设计，提供了对Redis数据存储的访问和操作支持。它简化了与Redis的交互，包括查询、CRUD操作和事务管理等。在这个版本中，Spring Data Redis与Spring 4.0.9...
spring cache + redis 主从
09-14
整合Spring Cache与Redis，可以使应用程序轻松地使用Redis作为缓存存储，提高数据读取的效率，减轻数据库的压力。 总结以上步骤，完成Redis主从配置与高可用哨兵模式的搭建，再整合Spring Cache，可以使应用程序在...
Spring Cache整合Redis主从及哨兵模式实现高可用
"本文主要介绍了如何配置Redis的主从模式，并结合Spring Cache实现高可用的缓存系统。我们将探讨配置流程、关键配置项以及哨兵模式的设置，以确保服务的稳定性和数据的一致性。" 在分布式系统中，Redis作为缓存服务...
spring+redis集成，以及遇到的异常 Could not resolve placeholder的解决
volleyfo_的博客
11-19 8639
spring+redis 概述 本文主要为了集成spring和redis，以及记录解决中间遇到的问题。 什么是redis？ Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API。 换句话说，Redis就像是一个HashMap，不过不是在JVM中运行，而是以一个独立进程的形式运行。 一般说来，会被当作缓存使用...
centos7 Redis主从复制+哨兵模式）redis集群部署搭建
背景模版
09-14 491
今天下午有搭建了公司测试环境的redis集群模式，主从复制+哨兵模式，现详细记录下搭建过程以及遇到的问题 172.16.21.238 6379主机(master) 172.16.21.1516380从机(slave) 一:redis安装 这里我采用的是压缩包安装，也可以用yum安装。 1 安装redis编译的c环境。 redis是c语言开发的，安装redis需要先将官网下载的源码进行编译，编译依赖gcc环境。如果没有gcc环境，需要安装gcc环境 yum install gcc-c++ .
各种版本的redis+Jedis驱动包
08-24
Redis Windows32位+64位安装包，Linux压缩包， Redis图形操作管理软件，Jedis
spring5整合spring-data-redis2做查询缓存
u011189939的博客
12-18 631
在http://blog.csdn.net/u011189939/article/details/78621724基础上，加了hiberhate的配置 主要配置如下 applicationContext.xml<?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/be
SpringCache:SpringCache + Redis缓存框架
最新发布
qq_55630615的博客
07-31 342
可以通过简单的注解实现缓存 我们如果需要使用Redis进行缓存需要先配置RedisCacheManager否则使用的是默认的SimpleCacheManager实现 @EnableCaching 添加在启动类上开启缓存针对方法,如果缓存中存在就返回缓存,如果没有就执行方法对方法的返回值进行缓存eg:REDIS_CACHE_KEY::#{id}每次都会触发方法调用,根据返回值更新缓存数据eg:REDIS_CACHE_KEY::#{id}根据一定的条件对缓存进行清空eg:REDIS_CACHE_KEY::#{i
spring4.0.9结合redis进行数据的缓存--续1
u010634288的博客
12-18 495
我继续改造我上一篇文章中提到的项目，这里需要要实现几个目标：1，redis集群（一主三从）的主从复制  2、读写分离  3、Redis只做缓存，MySQL做持久化。 增：直接操作MySQL,并利用trigger机制向Redis更新。 删：直接操作MySQL,并利用trigger机制向Redis更新。 改：直接操作MySQL,并利用trigger机制向Redis更新。 查：首先从Redis读
简单示例：Spring4 整合 单个Redis服务
weixin_33861800的博客
10-15 99
1. 引入spring-data-redis.jar 　　API：https://docs.spring.io/spring-data/redis/docs/current/api/org/springframework/data/redis/core/package-summary.html#package.description 2. spring配置文件添加如下配置 &lt;!-- re...
基于spring-data-redis的redis缓存的Serive实现（代码记录）
cc_梅
08-16 474
这个只是一次代码记录，是redies的Service层实现 public class RedisCacheServiceImpl implements RedisCacheService { @Autowired public RedisTemplate&lt;String, Object&gt; redisTemplate; public ValueOperations&lt;St...
Spring4.0整合Redis实用示例
_听风吻雨的Code港湾
07-09 2966
上篇我们介绍了redis数据的安装与使用,以及顺便介绍了redis一款可视化工具，所以这篇我们开始介绍Spring4.0与Redis的整合,通过两种方式来示例Redis的使用,一种是AOP方式,对所有满足表达式的类与方法进行redis缓存，另一种是使用自定义注解方式达到灵活配置自己需要注解的方法。下面将慢慢介绍如何从一步一步的整合与使用，本文所示范的项目框架为：spring4.0+SpringMV
Spring集成Redis
www419216217的博客
03-09 142
1.redis所需jar包依赖 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.9.0</version> </dependency> <dependency&gt...
Spring整合Redis实例
liangsw
06-10 298
一、添加依赖 请注意你的spring版本与 <dependency> <groupId>redis.clients</groupId> <artifactId>jedis</artifactId> <version>2.9.0</version> </dependency> <dependency> <groupId>org.springframework.data</
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值