概念: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 这里事务,安装,操作,分区全有。
opsforvalue: Redis 字符串数据类型的相关命令用于管理 redis 字符串
opsforHash: Redis hash 是一个string类型的field和value的映射表,hash特别适合用于存储对象
opsforList: Redis列表是简单的字符串列表,按照插入顺序排序。你可以添加一个元素到列表的头部(左边)
(二) jedis操作redis 缓存(jedis类型 自己做的增删改查):
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>