redisTemplate和jedis两种操作缓存

最新推荐文章于 2024-05-16 14:24:50 发布

stay hungry,stay you

最新推荐文章于 2024-05-16 14:24:50 发布

阅读量3.1k

点赞数 2

分类专栏： java redis

本文链接：https://blog.csdn.net/weixin_41987908/article/details/90897421

版权

java 同时被 2 个专栏收录

210 篇文章 2 订阅

订阅专栏

redis

11 篇文章 0 订阅

订阅专栏

概念：Jedis是Redis官方推荐的面向Java的操作Redis的客户端，而RedisTemplate是SpringDataRedis中对JedisApi的高度封装。SpringDataRedis相对于Jedis来说可以方便地更换Redis的Java客户端，比Jedis多了自动管理连接池的特性，方便与其他Spring框架进行搭配使用如：SpringCache。总体redisTemplate 用的多。

（一）操作引用自：
redis 菜鸟教程(opsfor类型)：
https://www.runoob.com/redis/redis-commands.html 这里事务，安装，操作，分区全有。
别人写的不错（配置util都有）： https://blog.csdn.net/weixin_44030218/article/details/87897032#2SerializeUtilclass_207
opsforvalue: Redis 字符串数据类型的相关命令用于管理 redis 字符串

opsforHash: Redis hash 是一个string类型的field和value的映射表，hash特别适合用于存储对象

opsforList: Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）

其他人写的redis操作：
https://blog.csdn.net/ruby_one/article/details/79141940

自己买的redis 小册子：
扫码阅读（仅限自己）在这里插入图片描述

(二) jedis操作redis 缓存（jedis类型自己做的增删改查）：
这个写的可以（配置util都有）：
https://blog.csdn.net/weixin_44030218/article/details/87553193
CRUD:

  /** 
 * <pre>项目名称:Commodity-Web 
 * 文件名称:RedisController.java 
 * 包名:com.jk.commodity.controller 
 * 创建日期:2018年6月23日下午8:38:28 
 * Copyright (c) 2018, yuxy123@gmail.com All Rights Reserved.</pre> 
 */  
package com.jk.commodity.controller;

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

import org.codehaus.jackson.annotate.JsonAnyGetter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.jk.commodity.model.User;
import com.jk.commodity.service.RedisService;

import redis.clients.jedis.ShardedJedis;
import redis.clients.jedis.ShardedJedisPool;

/** 
 * <pre>项目名称：Commodity-Web    
 * 类名称：RedisController    
 * 类描述：    
 * 创建人：
 * 创建时间：2018年6月23日 下午8:38:28    
 * 修改人：
 * 修改时间：2018年6月23日 下午8:38:28    
 * 修改备注：       
 * @version </pre>    
 */
@Controller
@RequestMapping(value="/Redis")
public class RedisController {
  @Autowired
  private RedisService redisService;
  @Autowired
  private ShardedJedisPool shardedJedisPool;
  @RequestMapping(value="/queryRedis")
  @ResponseBody
  public String queryRedis(Integer offset,Integer limit){
	  List <User>list=null;
	  //获取jedis
	  ShardedJedis jedis= shardedJedisPool.getResource();
	  Boolean exists = jedis.exists("list");
	  if(!exists){
		if(jedis.setnx("synouc","1")==1){ //加锁
			jedis.expire("synouc",20*60);//防止死锁
			//这里不需要加offset，limit！！！
			list= redisService.queryRedis();
			HashMap<String ,String>map=new HashMap<>();
			for (User user : list) {
			 jedis.lpush("list",user.getUserid().toString());
			 map.put("userid",user.getUserid().toString());
			 map.put("username",user.getUsername());
			 map.put("userpas",user.getUserpas().toString());
			 jedis.hmset("list_"+user.getUserid().toString(),map);
			 Random random=new Random();//准备失效时间 随机
			 int nextInt = random.nextInt(100);
			}
			jedis.del("synouc");
			jedis.expire("list",300*600);
		}else{
			try {
				Thread.sleep(50);
			} catch (InterruptedException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}   
	  }
//如果你把redis 中删了则全依靠下面的代码重新生成！！他这个分页是针对redis的与查询方法无关,但是你前台任然得写 server!!!!!!!!!!!!!!!
	  List<String> list2 = jedis.lrange("list", offset, offset+limit-1);
	  List<Map<String,String>>list1=new ArrayList();
	  for (String id : list2) {
		  Map<String, String> hgetAll = jedis.hgetAll("list_"+id);
		  list1.add(hgetAll);
	}
       JSONObject object=new JSONObject();
       object.put("total",jedis.llen("list"));
       object.put("rows",list1);
	  return object.toJSONString();
  }
}

-----------------------------------------------------------------------------------------------
redis 新增
    @Override
public void insertRedis(User user) {
	//新增没有传过来id 所以需要拿id 接收一下！！
	//利用username 查 id
	redisMapper.insertRedis(user);
	int id=redisMapper.queryRedisid(user.getUsername());
/*	List<User> list1=redisMapper.queryRediss(id);*/
	List<User> list1=redisMapper.queryRedisss(id);
	ShardedJedis jedis = shardedJedisPool.getResource();
	//存map 和hashMap都一样 HashMap hashmap=new HashMap();  
	Map<String,String> map=new HashMap();
	//往list中添加id 不是删了在建！！！
	jedis.lpush("list",list1.get(0).getUserid().toString());
	map.put("userid", list1.get(0).getUserid().toString());
	map.put("username",list1.get(0).getUsername());
	map.put("userpas",list1.get(0).getUserpas());
	jedis.hmset("list_"+list1.get(0).getUserid(),map);
}

sql:
  <insert id="insertRedis" parameterType="com.jk.commodity.model.User">
     insert into t_user(username,userpas) values(#{username},#{userpas})
   </insert>
    <select id="queryRedisid" resultType="int" parameterType="String">
    select t.userid from t_user t where t.username=#{username}
   </select>
   <select id="queryRedisss" resultType="com.jk.commodity.model.User" parameterType="int">
    select t.* from t_user t where t.userid=#{id} 
   </select>

-------------------------------------------------------------------------------------------------------------------------------
reids 删除：
1：用del 删除redis来做！！
      @RequestMapping(value="/delredis")
  @ResponseBody
  public void delredis(Integer id){
	  redisService.delredis(id); 
	 
  }

   @Override
public void delredis(Integer id) {
	redisMapper.delredis(id);
	 ShardedJedis jedis = shardedJedisPool.getResource();
	  jedis.del("list");
	  jedis.del("list_"+id);
}



就是在基本删除的基础上加上上面红字就行。
    jedis.del("list");  //先数据库删了之后再在redis中删了 list 然redis 查询方法 当list  不存在时会根据数据库中现在已有的数据新创建一个list 而 list_id id 为是数字这这个会直接删除了不会再redis中继续生成

2：用expire 过期时间来做！！
expire(String,seconds);   时间单位为秒
expire(list,seconds);
ShardedJedis jedis = shardedJedisPool.getResource();
	jedis.expire("list",10);
	jedis.expire("list_"+id,10);
代替：
 ShardedJedis jedis = shardedJedisPool.getResource();
	  jedis.del("list");
	  jedis.del("list_"+id); 
------------------------------------------------------------------------------------------------------------------------------
redis修改：
id 不能 修改所以redis中的list不需要过期！！！！ 
  一样意思，修改方法上后面加上过期在加上查询

配置：

配置文件：
  config.properties：
    #db driver
jdbc.driver=com.mysql.jdbc.Driver
#db url
jdbc.url=jdbc:mysql://主机ip:3306/888?&useUnicode=true&characterEncoding=utf8&mysqlEncoding=utf8
#db username
jdbc.username=root
#db password
jdbc.password=root
#db maxActive
jdbc.maxActive=2
#db minIdle
jdbc.minIdle=5
#db maxIdle
jdbc.maxIdle=5
#redis
maxTotal=2000
maxIdle=50
redisHost=127.0.0.1
redisPort=6379
redisTimeout=3000

spring-context:
      <?xml version="1.0" encoding="UTF-8"?>

<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
	xmlns:aop="http://www.springframework.org/schema/aop" xmlns:tx="http://www.springframework.org/schema/tx"
	xsi:schemaLocation="
            http://www.springframework.org/schema/beans
            http://www.springframework.org/schema/beans/spring-beans.xsd
            http://www.springframework.org/schema/context
            http://www.springframework.org/schema/context/spring-context.xsd
            http://www.springframework.org/schema/aop
            http://www.springframework.org/schema/aop/spring-aop.xsd
            http://www.springframework.org/schema/tx
            http://www.springframework.org/schema/tx/spring-tx.xsd">
	<!-- 开启注解扫描 识别框架搭建过程中的 @service 和 @repository base-package 扫描com.jk包下的所有类 
		识别类中有关于spring的注解 注解 其实就是在java类当中编写一个标志，能够被java代码所识别，通过该注解的形式，做对应的代码操作 -->
	<context:component-scan base-package="com.jk">
	</context:component-scan>

	<!-- 不需要扫描service等等 -->
	<!-- 配置数据源属性文件 spring读取properties文件所用工具类 -->
	<bean id="propertyConfigurer"
		class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
		<property name="locations">
			<list>
				<value>classpath:config.properties</value>
			</list>
		</property>
	</bean>
	<!-- 配置数据源 配置数据库连接池 获取数据源 -->
	<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
		<property name="driverClassName" value="${jdbc.driver}" />
		<property name="url" value="${jdbc.url}" />
		<property name="username" value="${jdbc.username}" />
		<property name="password" value="${jdbc.password}" />
		<!--maxActive: 最大连接数量 -->
		<property name="maxActive" value="${jdbc.maxActive}" />
		<!--minIdle: 最小空闲连接 -->
		<property name="minIdle" value="${jdbc.minIdle}" />
		<!--maxIdle: 最大空闲连接 -->
		<property name="maxIdle" value="${jdbc.maxIdle}" />

	</bean>
	
	
     <!--jedis   配置  -->
     	<!-- spring注入jedis  -->
		  <bean  id="jedisPoolConfig"  class="redis.clients.jedis.JedisPoolConfig">
			  	     	<property name="maxTotal" value="30" />
				        <property name="maxIdle" value="30" />
				        <property name="numTestsPerEvictionRun" value="1024"/>
				        <property name="timeBetweenEvictionRunsMillis" value="30000" />
				        <property name="minEvictableIdleTimeMillis" value="-1" />
				        <property name="softMinEvictableIdleTimeMillis" value="10000" />
				        <property name="maxWaitMillis" value="1500"/>
				        <property name="testOnBorrow" value="true" />
				        <property name="testWhileIdle" value="true"/>
				        <property name="testOnReturn" value="false"/>
				        <property name="blockWhenExhausted" value="false"/>
				        <property name="evictionPolicyClassName" value="org.apache.commons.pool2.impl.DefaultEvictionPolicy" />
			  </bean>
		  	
		  	<!-- spring注入jedis  -->
		  	  <bean id="jedisShardInfo" class="redis.clients.jedis.JedisShardInfo">
		        <constructor-arg index="0" value="${redisHost}" />
		        <constructor-arg index="1" value="${redisPort}" />
		        <constructor-arg index="2" value="${redisTimeout}" />
   			 </bean>
		  	
		  	
		  	<bean  id="shardedJedisPool"  class="redis.clients.jedis.ShardedJedisPool">
		  		 <constructor-arg index="0" ref="jedisPoolConfig"/>
		  		 <constructor-arg index="1">
		  		 	<list>
			  		 	<ref bean="jedisShardInfo"/>
		  		 	</list>
		  		 </constructor-arg>
		  	</bean>
     
	
	

	<!-- mybatis的SqlSession的工厂: SqlSessionFactoryBean dataSource:引用数据源 MyBatis定义数据源,同意加载配置 -->
	<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
		<!-- 引入数据配置 方便mybatis获取数据库连接 -->
		<property name="dataSource" ref="dataSource"></property>
		<!-- 配置mybatis的日志记录 mybatis-config.xml mybatis的全局配置文件 主要用来配置共有常量等信息 配置日志信息 -->
		<property name="configLocation" value="classpath:mybatis-config.xml"></property>
		<!--mapperLocations mybatis映射文件的扫描路径 扫描识别mybatis的映射文件 -->
		<property name="mapperLocations" value="classpath:com/jk/*/mapper/*.xml"></property>
	</bean>
	
	<!-- mybatis自动扫描加载Sql映射文件/接口 : MapperScannerConfigurer sqlSessionFactory 
		basePackage:指定sql映射文件/接口所在的包（自动扫描） -->

	<!-- 上传文件拦截，设置最大上传文件大小 10M=10*1024*1024(B)=10485760 bytes -->
	<bean id="multipartResolver"
		class="org.springframework.web.multipart.commons.CommonsMultipartResolver">
		<property name="maxUploadSize" value="10485760" />
	</bean>
	<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
		<!-- mybatis没有dao层 mybatis的映射接口充当dao层 -->
		<property name="basePackage" value="com.jk.*.mapper" />
		<!-- 注入sqlSessionFactory 相当于把Hibernate的sessionFactory注入到HibernateDaoSupport一样 -->
		<property name="sqlSessionFactoryBeanName" value="sqlSessionFactory" />
	</bean>



	<!-- 配置事务管理器 -->
	<bean id="transactionManager"
		class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
		<!-- 配置数据源 引入数据库连接池 获取到数数据连接 -->
		<property name="dataSource" ref="dataSource" />
	</bean>

	<!-- 定义advice,配置传播特性、事务隔离级别、只读事务、回滚策略 -->
	<tx:advice id="txAdvice" transaction-manager="transactionManager">
		<tx:attributes>
			<tx:method name="add*" propagation="REQUIRED" rollback-for="java.lang.Exception" />
			<tx:method name="save*" propagation="REQUIRED"
				rollback-for="java.lang.Exception" />
			<tx:method name="up*" propagation="REQUIRED" rollback-for="java.lang.Exception" />
			<tx:method name="del*" propagation="REQUIRED" rollback-for="java.lang.Exception" />
			<tx:method name="insert*" propagation="REQUIRED"
				rollback-for="java.lang.Exception" />
			<tx:method name="set*" propagation="REQUIRED" rollback-for="java.lang.Exception" />
			<tx:method name="*" propagation="REQUIRED" read-only="true" />
		</tx:attributes>
	</tx:advice>
 	<aop:config>
		<aop:advisor pointcut="execution(* com.jk.*.service.*.*(..))"
			advice-ref="txAdvice" />
	</aop:config>
	
		<!--
	<bean  id="aopMongoLog"  class="com.jk.aoplog.AopMongoLog"></bean>
	<aop:config> 
		<aop:advisor 
   			 pointcut="execution(* com.jk.service.impl.*.*(..))" 
    		 advice-ref="aopMongoLog"/> 
   </aop:config>
	 -->	
</beans>

Pom文件：

<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redis</artifactId>
			<version>1.5.0.RELEASE</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/redis.clients/jedis -->
		<dependency>
			<groupId>redis.clients</groupId>
			<artifactId>jedis</artifactId>
			<version>2.9.0</version>
		</dependency>
redis.client 这个jar包提供jedis的一些方法！！

**若是springboot 则可能是：**
<!-- 缓存支持 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-cache</artifactId>
		</dependency>
		<!-- Redis缓存支持 -->
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-data-redis</artifactId>
		</dependency>