一、准备工作
1、创建工程
创建maven父工程,例如03-sca-redis,并在此工程下创建两个子工程,一个为sca-jedis,一个为sca-template,例如:
2、添加项目依赖
2.1)sca-jedis 工程依赖
<dependencies>
<!--jedis依赖(主要依赖)-->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.5.2</version>
</dependency>
<!--junit依赖(单元测试)-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<!--Gson依赖(json数据材质)json串-->
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.6</version>
</dependency>
</dependencies>
2.2)添加sca-template工程依赖
<dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-dependencies</artifactId>
<version>2.3.2.RELEASE</version>
<scope>import</scope>
<type>pom</type>
</dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
二、Jedis的应用
1、简介
Jedis是Java中操作redis的一个客户端,类似通过jdbc访问mysql数据库。
2、准备工作
2.1)第一步:从redis.io官方下载对应版本的redis.conf文件,地址如下(假如下载不下来从code上去取或者从同学那拿):
https://redis.io/topics/config/
2.2)第二步:停止redis并删除挂载目录下(/usr/local/docker/redis01/conf)的redis.conf配置文件。
2.3)第三步:将下载的redis.conf文件拷贝到redis挂载目录(/usr/local/docker/redis01/conf)
2.4)第四步:基于vim打开redis.conf文件,然后注释 bind 127.0.0.1这一行,并修改protected-mode的值修改为no。
2.5)第五步:重启redis服务,并检查启动日志(docker logs 容器id)
3、快速入门实现
在Jedis工程中定义单元测试类,在类中定义单元测试方法:
3.1)基础类型操作
在项目的src/test/java目录创建单元测类,例如:
package com.jt;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import java.util.concurrent.TimeUnit;
public class JedisTests {
@Test
public void testGetConnection(){
//假如不能连通,要注释掉redis.conf中 bind 127.0.0.1,
//并将protected-mode的值修改为no,然后重启redis再试
Jedis jedis=new Jedis("192.168.64.128",6379);
//jedis.auth("123456");//假如在redis.conf中设置了密码
String ping = jedis.ping();
System.out.println(ping);
}
3.1.1)字符串类型练习
//字符串类型练习
@Test
public void testStringOper() throws InterruptedException {
//1.建立链接(与redis建立链接)
Jedis jedis=new Jedis("192.168.64.128",6379);
//2.存储数据(key/value)
jedis.set("count","1");
jedis.set("id","10001");
jedis.set("content","aaaaaaaadfas");
//3.更新数据
jedis.expire("id",1);//设置key的有效时长,1秒
jedis.incr("count");//对key的值进行自增操作
//4.删除指定数据
jedis.del("content");
//5.获取数据
String count = jedis.get("count");
//TimeUnit是Java中枚举类型,SECONDS为枚举类型的实例,sleep底层会调用Thread.sleep()方法
//TimeUnit.SECONDS.sleep(1);//休眠一秒
Thread.sleep(1000);
String id=jedis.get("id");
Long num=jedis.strlen("content");
System.out.println("cart.count="+count);
System.out.println("id="+id);
System.out.println("num="+num);
String result=String.format("id=%s,content=%s,count=%s",id,content,count);
System.out.println(result);
//6.释放资源
jedis.close();
}
3.1.2)将一个对象(例如map)转换为json格式字符串,然后写入到redis
/**
*将一个对象(例如map)转换为json格式字符串,然后写入到redis
* */
@Test
public void testJsonOper(){
//1.建立连接
Jedis jedis=new Jedis("192.168.126.130",6379);
//2.构建一个map对象,存储一些用户信息
Map<String,Object> map=new HashMap<>();
map.put("id",100);
map.put("title","spring 认证");
map.put("content","very good");
//3.将对象转换为json格式字符串
Gson gson=new Gson();
String jsonStr=gson.toJson(map);
//4.将json字符串写入到redis
Jedis jedis=new Jedis("192.168.64.128",6379);
jedis.set("user",jsonStr);
//5.读取redis中数据
jsonStr=jedis.get("user");
System.out.println(jsonStr);
Map<String,Object> obj=gson.fromJson(jsonStr,Map.class);
System.out.println(obj);
//6.释放资源
jedis.close();
}
3.1.3)Hash类型数据的操作实践
/**
* Hash类型数据的操作实践
*/
@Test
public void testHashOper01(){
//1.建立连接
Jedis jedis=new Jedis("192.168.64.128",6379);
//2.基于hash类型存储对象信息
jedis.hset("member","id","101");
jedis.hset("member","username","jack");
jedis.hset("member","mobile","3333333");
//3.更新hash类型存储的数据
jedis.hset("member","username","tony");
//4.获取hash类型数据信息
String username=jedis.hget("member","username");
String mobile = jedis.hget("member", "mobile");
System.out.println(username);
System.out.println(mobile);
//5.释放资源
jedis.close();
}
3.1.4)hash类型练习(直接存储map对象)
//hash类型练习(直接存储map对象)
@Test
public void testHashOper02(){
//1.建立连接
Jedis jedis=new Jedis("192.168.64.128",6379);
//2.存储一篇博客信息
Map<String,String> map=new HashMap<>();
map.put("x","100");
map.put("y","200");
jedis.hset("point",map);
//3.获取博客内容并输出
map=jedis.hgetAll("point");
System.out.println(map);
//4.释放资源
jedis.close();
}
3.1.5)基于FIFO(First In First Out)(先进先出)算法,借助redis实现一个队列
/**
* 测试:redis中list结构的应用
* 基于FIFO(First In First Out)算法,借助redis实现一个队列
*/
@Test
public void testListOper01(){
//1.建立连接
Jedis jedis=new Jedis("192.168.64.128",6379);
//2.存储数据
jedis.lpush("lst1","A","B","C","C");
//3.更新数据
Long pos=jedis.lpos("lst1","A");//获取A元素的位置
jedis.lset("lst1",pos,"D");//将A元素位置的内容修改为D
//4.获取数据
int len=jedis.llen("lst1").intValue();//获取lst1列表中元素个数
List<String> rpop = jedis.rpop("lst1",len);//获取lst1列表中所有元素
System.out.println(rpop);
//5.释放资源
jedis.close();
}
3.1.6)list类型练习:实现一个阻塞式队列
==
brpop意思 block right pop 阻塞式右侧出队
blpop意思 block left pop 阻塞式左侧出队
第一个要出队的Key,第二个是Timeout 阻塞延时,如果填写0,那么默认是永久阻塞,当List有值的时候,会立刻pop出来==
/**
* 阻塞式队列,brpop/blpop
*/
@Test
public void testListOper02(){
System.out.println(Thread.currentThread().getName()); //获取当前线程的名字
//1.建立连接
Jedis jedis=new Jedis("192.168.64.128",6379);
//2.存储数据
jedis.lpush("lst2","A","B","C");
//3.取数据(队列为空则阻塞)
//第一个要出队的Key,第二个是Timeout 阻塞延时,如果填写0,那么默认是永久阻塞,当List有值的时候,会立刻pop出来
jedis.brpop(5,"lst2");
jedis.brpop(5,"lst2");
jedis.brpop(5,"lst2");
jedis.brpop(5,"lst2");//当队列中没有内容时会阻塞
System.out.println("waiting finish");
//4.释放资源
jedis.close();
}
3.1.7)set类型练习
/**
* Set数据类型测试
*/
@Test
public void testSetOper01(){
//1.建立连接
Jedis jedis=new Jedis("192.168.64.128",6379);//TCP/IP
//2.存储数据(不允许重复,且值无序)
jedis.sadd("set01","A","A","B","B","C");
//3.删除集合中元素
jedis.srem("set01","A");
//4.获取存储的数据
System.out.println(jedis.scard("set01"));//集合元素的个数
Set<String> set01 = jedis.smembers("set01");//输出集合中的成员 (点赞的成员)
System.out.println(set01);
//5.释放资源
jedis.close();
}
3.2)连接池JedisPool应用
我们直接基于Jedis访问redis时,每次获取连接,释放连接会带来很大的性能开销,可以借助Jedis连接池,重用创建好的连接,来提高其性能,简易应用方式如下:
package com.jt;
import org.junit.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
public class JedisPoolTests {
@Test
public void testJedisPool(){
//1.定义连接池的配置
JedisPoolConfig config=new JedisPoolConfig();
config.setMaxTotal(1000);//最大连接数
config.setMaxIdle(60);//最大空闲时间(连接不用了要释放)
//2.创建连接池
JedisPool jedisPool=
new JedisPool(config,"192.168.64.128",6379);
//3.从池中获取一个连接
Jedis resource = jedisPool.getResource();
resource.auth("123456");
//4.通过jedis连接存取数据
resource.set("class","cgb2004");
String clazz=resource.get("class");
System.out.println(clazz);
//5. 将链接返回池中
resource.close();
//关闭连接池
jedisPool.close();
}
}
三、RedisTemplate应用
1、简介
RedisTemplate为SpringBoot工程中操作redis数据库的一个Java对象,此对象封装了对redis的一些基本操作。
2、准备工作
2.1)第一步:创建工程配置文件application.yml,其内容如下:
spring:
redis:
host: 192.168.64.128 #写自己的ip
port: 6379
2.2)第二步:创建工程启动类,例如:
package com.jt;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication
public class RedisApplication {
public static void main(String[] args) {
SpringApplication.run(RedisApplication.class,args);
}
}
3、快速入门实现
3.1)StringRedisTemplate 应用
StringRedisTemplate 是一个专门用于操作redis字符串类型数据的一个对象,其应用方式如下:
3.1.1)连接redis服务器测试
package com.jt.redis;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.connection.RedisConnection;
import org.springframework.data.redis.core.StringRedisTemplate;
@SpringBootTest
public class StringRedisTemplateTests {
/**此对象为spring提供的一个用于操作redis数据库中的字符串的一个对象*/
/**StringRedisTemplate 对象是spring data模块推出的一个用于
* 操作redis字符串类型数据的一个API对象,底层序列方式使用的是
* StringRedisSerializer对象
* */
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Test
void testConnection(){
RedisConnection connection =
stringRedisTemplate.getConnectionFactory()
.getConnection();
String ping = connection.ping();
System.out.println(ping);
}
3.1.2)字符串数据基本操作实践
/**
* 字符串数据基本操作实践
* @throws InterruptedException
*/
@Test
void testStringOper01() throws InterruptedException {
//1.获取一个操作redis字符串的值对象
ValueOperations<String, String> vo =
redisTemplate.opsForValue();
//2.基于这个值对象操作redis中的字符串数据
vo.set("x","100");
vo.increment("x"); //自增,默认自增1
vo.set("y","200",1, TimeUnit.SECONDS);//设置key的失效时间 ,1秒
TimeUnit.SECONDS.sleep(1);//阻塞1秒
String x = vo.get("x");
System.out.println(x);
String y=vo.get("y");
System.out.println(y);
}
3.1.3)以json格式存储一个对象到redis数据库
/**以json格式存储一个对象到redis数据库
* 提示:不能使用Gson,可以使用jackson*/
@Test
void testStringOper02() throws JsonProcessingException {
//1.创建一个map,用于存储对象数据
Map<String,String> map=new HashMap<String,String>();
map.put("id","101");
map.put("username","jack");
//2.将map转换为json格式字符串
String jsonStr =
new ObjectMapper().writeValueAsString(map);
//(需要转换的对象)
System.out.println(jsonStr);
//3.将json字符串借助StringRedisTemplate存储到redis,并读取
ValueOperations<String, String> vo =
redisTemplate.opsForValue();
vo.set("userJsonStr",jsonStr);
jsonStr=vo.get("userJsonStr");
//4.将json格式的字符串转成map
map= new ObjectMapper().readValue(jsonStr,Map.class);
//(json格式,需要转成的格式)
System.out.println(map);
}
3.1.4)基于StringRedisTemplate对象操作hash数据类型
/**
* 基于StringRedisTemplate对象操作hash数据类型
*/
@Test
void testHashOper01(){
//1.获取操作hash类型数据的对象
HashOperations<String, Object, Object> ho
= redisTemplate.opsForHash();
//2.操作hash类型数据
ho.put("user","id","100");
ho.put("user","username","jack");
ho.put("user","state","true");
List<Object> user = ho.values("user");
System.out.println(user);
}
3.2)RedisTemplate 应用
RedisTemplate是一个专门用于实现对远端redis中复杂数据的操作的对应,应用案例如下:
package com.jt;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.redis.core.*;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
@SpringBootTest
public class RedisTemplateTests {
/**RedisTemplate对象也Spring data模块提供的一个操作redis数据库数据的API对象,
* 此对象主要用于操作redis数据库中的复杂数据类型数据,默认序列化方式为
* JdkSerializationRedisSerializer*/
@Autowired
private RedisTemplate redisTemplate;//将来可以按照自己的业务需求定制RedisTempalte
@Test
void testSetData(){
SetOperations setOperations=redisTemplate.opsForSet();
setOperations.add("setKey1", "A","B","C","C");
Object members=setOperations.members("setKey1");
System.out.println("setKeys="+members);
//........
}
@Test
void testListData(){
//向list集合放数据
ListOperations listOperations = redisTemplate.opsForList();
listOperations.leftPush("lstKey1", "100"); //lpush
listOperations.leftPushAll("lstKey1", "200","300");
listOperations.leftPush("lstKey1", "100", "105");
listOperations.rightPush("lstKey1", "700");
Object value= listOperations.range("lstKey1", 0, -1);
System.out.println(value);
//从list集合取数据
Object v1=listOperations.leftPop("lstKey1");//lpop
System.out.println("left.pop.0="+v1);
value= listOperations.range("lstKey1", 0, -1);
System.out.println(value);
}
@Test
void testHashOper01(){
HashOperations ho = redisTemplate.opsForHash();
ho.put("blog", "id", 101);
ho.put("blog", "title", "redis template");
List blog = ho.values("blog");
System.out.println(blog);
Map<String,Object> map=new HashMap<String,Object>();
map.put("id", 201);
map.put("name", "redis");
ho.putAll("tag",map);
Object name= ho.get("tag", "name");
System.out.println(name);
}
@Test
void testStringOper01(){
//默认采用了JDK的序列化方式,存储key/value默认会将key/value都转换为字节再进行存储
//redisTemplate.setKeySerializer(new JdkSerializationRedisSerializer());
//自己设置序列化方式
//redisTemplate.setKeySerializer(new StringRedisSerializer());
//redisTemplate.setValueSerializer(new StringRedisSerializer());
ValueOperations vo =
redisTemplate.opsForValue();
vo.set("token", UUID.randomUUID().toString());
Object token = vo.get("token");
System.out.println(token);
}
}
3.3)定制RedisTemplate对象(拓展)
对于系统默认的RedisTemplate默认采用的是JDK的序列化机制,假如我们不希望实用JDK的序列化,可以采用的定制RedisTemplate,并采用自己指定的的序列化方式,例如:
package com.jt.redis.config;
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<Object,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
//1.构建RedisTemplate对象
RedisTemplate<Object,Object> redisTemplate=new RedisTemplate<>();
//2.设置连接工厂
redisTemplate.setConnectionFactory(redisConnectionFactory);
//3.定义序列化方式(在这里选择jackson)
Jackson2JsonRedisSerializer redisSerializer= new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper objectMapper=new ObjectMapper();
//设置要序列化的域(属性)
//any表示任意级别访问修饰符修饰的属性 private,public,protected
objectMapper.setVisibility(PropertyAccessor.ALL,JsonAutoDetect.Visibility.ANY);
//启动输入域检查(类不能是final修饰的)
objectMapper.activateDefaultTyping(objectMapper.getPolymorphicTypeValidator(),
ObjectMapper.DefaultTyping.NON_FINAL,
JsonTypeInfo.As.PROPERTY);
redisSerializer.setObjectMapper(objectMapper);
//4.设置RedisTemplate的序列化
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(redisSerializer);
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
redisTemplate.setHashValueSerializer(redisSerializer);
//spring规范中假如修改bean对象的默认特性,建议调用一下afterPropertiesSet()
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
}
创建Blog对象,然后基于RedisTemplate进行序列化实践,Blog代码如下:
package com.jt.redis.pojo;
import java.io.Serializable;
public class Blog implements Serializable {//{"id":10,"title":"redis"}
private static final long serialVersionUID = -6721670401642138021L;
private Integer id;
private String title;
public Blog(){
System.out.println("Blog()");
}
public Blog(Integer id,String title){
this.id=id;
this.title=title;
}
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getTitle() {
return title;
}
public void setTitle(String title) {
this.title = title;
}
@Override
public String toString() {
return "Blog{" +
"id=" + id +
", title='" + title + '\'' +
'}';
}
}
四、项目工程实践
1、单点登陆
1.1)业务描述
在分布式系统中,通过会有多个服务,我们登录了一个服务以后,再访问其它服务时,不想再登录,就需要有一套单独的认证系统,我们通常会称之为单点登录系统,在这套系统中提供一个认证服务器,服务完成用户身份认证,在一些中小型分布式系统中,我们通常会借助redis存储用户的认证信息,例如:
1.2)关键代码实现
package com.jt.demos;
import redis.clients.jedis.Jedis;
import java.util.UUID;
/**
* 单点登录应用实践
*/
public class SSODemo01 {
static String token;
//模仿访问服务端的资源
static void doGetResource(){
//1.检查token是否存在,(token是存储在客户端-Cookie,localStorage)
if(token==null){
System.out.println("please login");
return;
}
//2.检查token是否已经失效
Jedis jedis=new Jedis("192.168.64.128",6379);
String user = jedis.get(token);
jedis.close();
if(user==null){
System.out.println("login timeout or token invalid");
return;
}
//3.返回你要访问的资源
System.out.println("return user resource");
}
static void doLogin(String username,String password){
if("jack".equals(username)&&"123456".equals(password)){
System.out.println("login ok");
String token= UUID.randomUUID().toString();
Jedis jedis=new Jedis("192.168.64.128",6379);
jedis.set(token,username);//存储用户信息
jedis.expire(token,1); //token有效期是1秒
jedis.close();
//将token存储到客户端
SSODemo01.token=token;
return;
}
System.out.println("username or password error");
}
public static void main(String[] args) throws InterruptedException {//这里的main方法代表客户端
//1.访问资源
doGetResource();
//2.执行登录操作
doLogin("jack","123456");
//3.再次访问资源
Thread.sleep(1000);
doGetResource();
}
}
2、投票系统
2.1)业务描述
在很多系统中设计中,都会有一个活动设计,开启一个活动之前,可以对这个活动的支持力度先进行一个调查,例如基于这个活动设计一个投票系统,例如:
2.2)关键代码实现
package com.jt.demos;
import redis.clients.jedis.Jedis;
import java.util.Set;
/**
* 投票系统演示:模拟基于某个活动的投票程序
* 业务说明:一个用户只能投票一次(不允许重复)
* 数据结构设计:基于redis的set类型进行数据存储
*/
public class VoteDemo01 {
//注意,将来这个连接不能多线程共享
private static Jedis jedis=new Jedis("192.168.126.130",6379);
/**
* 判定userId是否参与过activityId这个活动的投票
* @param activityId
* @param userId
* @return true表示参与过投票
*/
static boolean checkVote(String activityId,String userId){
//判断set集合activityId对应的值中是否包含这个userId
return jedis.sismember(activityId,userId);
}
/**
* 执行投票逻辑
* @param activityId
* @param userId
* @return true 表示投票ok
*/
static boolean addVote(String activityId,String userId){
if(checkVote(activityId,userId)){
System.out.println("您已经参与过这个投票");
return false;
}
jedis.sadd(activityId,userId);
return true;
}
/**
* 获取活动的总票数
* @param activityId
* @return
*/
static Long getActivityVotes(String activityId){
return jedis.scard(activityId);
}
/**
* 获取参与了投票的用户id
* @param activityId
* @return
*/
static Set<String> getActivityUsers(String activityId){
return jedis.smembers(activityId);
}
public static void main(String[] args) {
//1.设置一个活动
//1)获取id
String activityId="10001";
//2)活动标题
//3)活动内容
//2.基于活动进行投票设计
String user1="201";
String user2="202";
String user3="203";
//2.1 一个用户对同一个活动不能重复投票
//boolean flag=checkVote(activityId,user1);
//System.out.println("flag="+flag);
//2.2 执行投票
addVote(activityId,user1);
addVote(activityId,user2);
addVote(activityId,user3);
//2.3 能够显示参与投票的人数
long voteCount=getActivityVotes(activityId);
System.out.println(voteCount);
//2.4 管理员可以查看哪些人参与了投票
Set<String> userIds=getActivityUsers(activityId);
System.out.println(userIds);
}
}
3、秒杀队列
3.1)业务描述
在设计一个秒杀或抢购系统时,为了提高系统的响应速度,通常会将用户的秒杀或抢购请求先存储到一个redis队列,这里我们就基于redis实现一个先进先出队列,例如:
3.2)关键代码实现
3.2.1)jedis写法
package com.jt.demos;
import redis.clients.jedis.Jedis;
//秒杀队列演示
//描述逻辑中会将商品抢购信息先写到redis(以队列形式进行存储),
//因为写redis内存数据库要比写你的mysql数据库快很多倍
//算法:先进先出(FIFO)-体现公平性
public class SecondKillDemo01 {
//商品抢购首先是入队
static void enque(String msg){//入队
Jedis jedis=new Jedis("192.168.64.128",6379);
jedis.auth("123456");//没有认证不需要写这个语句
jedis.lpush("queue",msg);
jedis.close();
}
//底层异步出队(基于这个消息,生成订单,扣减库存,...)
static String deque(){//出队
Jedis jedis=new Jedis("192.168.64.128",6379);
jedis.auth("123456");//没有认证不需要写这个语句
String result=jedis.rpop("queue");
jedis.close();
return result;
}
public static void main(String[] args){
//1.多次抢购(模拟在界面上多次点击操作)
new Thread(){
@Override
public void run() {
for(int i=1;i<=10;i++){//模拟页面上按钮点击
enque(String.valueOf(i));
try{Thread.sleep(100);}catch(Exception e){}
}
}
}.start();
//2.从队列取内容(模拟后台从队列取数据)
new Thread(){
@Override
public void run() {
for(;;){
String msg=deque();
if(msg==null)continue;
System.out.print(msg);
}
}
}.start();
}
}
3.2.2)RedisTemplate写法
package com.jt.redis.demos;
import org.springframework.data.redis.core.ListOperations;
import org.springframework.stereotype.Repository;
import javax.annotation.Resource;
/**
* 定义一个简易的秒杀队列,算法FIFO
*/
//@Component
@Repository //@Repository 注解用于描述数据层对象
public class SecondKillQueue {
// @Autowired
// private StringRedisTemplate stringRedisTemplate;
//这种写法:参考官网https://spring.io/projects/spring-data-redis#overview
@Resource(name = "stringRedisTemplate")
private ListOperations<String,String> lo;
/**执行入队操作*/
public void enque(String msg){
// ListOperations<String, String> lo =
// stringRedisTemplate.opsForList();
lo.leftPush("killQueue", msg);
}
/**执行出队操作*/
public String deque(){
// ListOperations<String, String> lo =
// stringRedisTemplate.opsForList();
return lo.rightPop("killQueue");
}
}
package com.jt;
import com.jt.redis.demos.SecondKillQueue;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
public class SecondKillQueueTests {
@Autowired
private SecondKillQueue queue;
@Test
void testEnque(){
queue.enque("A");
queue.enque("B");
queue.enque("C");
}
@Test
void testDeque(){
System.out.println(queue.deque());
System.out.println(queue.deque());
System.out.println(queue.deque());
}
}
4、分布式id
4.1)业务描述
在分布式系统中,数据量将越来越大时,就需要对数据进行分表操作,但是,分表后,每个表中的数据都会按自己的节奏进行自增,很有可能出现ID冲突。这时就需要一个单独的机制来负责生成唯一ID,生成出来的ID也可以叫做 分布式ID,这里我们借助redis实现一个简易的分布式id进行实现,当然还有一些第三方的系统,可以帮你生成这样的id,可以自己进行拓展学习。
4.2)关键代码实现
4.2.1)Jedis写法
package com.jt.demos;
import redis.clients.jedis.Jedis;
/**
* 需求:生成一个分布递增的id
* 多张表基于这个方法中生成的id作为主键id值(分布式环境不会采用数据库
* 表中自带的自增策略-auto_increment)
*/
public class IdGeneratorDemo01 {
public static Long getId(){
Jedis jedis=new Jedis("192.168.64.128",6379);
jedis.auth("123456");
Long id = jedis.incr("id");
jedis.close();
return id;
}
public static void main(String[] args) {
for(int i=0;i<10;i++) {
new Thread(){
@Override
public void run() {
String tName=Thread.currentThread().getName();
System.out.println(tName+"->"+
IdGeneratorDemo01.getId());
}
}.start();
}
}
}
4.2.2)RedisTemplate写法
package com.jt.redis.demos;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
import javax.annotation.Resource;
@Component
public class IdGenerator {
@Resource(name = "stringRedisTemplate")
private ValueOperations valueOperations;
/**基于redis生成一个递增的id值*/
public Long generatorId(){
return valueOperations.increment("id");
}
}
package com.jt;
import com.jt.redis.demos.IdGenerator;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
@SpringBootTest
public class IdGeneratorTests {
@Autowired
private IdGenerator idGenerator;
@Test
void doGeneratorId(){
for(int i=0;i<10;i++){
new Thread(()->{
System.out.println(idGenerator.generatorId());
System.out.println(idGenerator.generatorId());
System.out.println(idGenerator.generatorId());
}).start();
}
while(true){}//等new的线程执行结束
}
}
5、购物车简易实现
5.1)业务描述
简易购物车业务设计如图所示:
5.2)基础指令操作,例如:
1)向购物车添加商品
hset cart:101 2001 1
hset cart:101 2002 1
hset cart:101 2003 2
2)查看购物车商品
hgetall cart:101
3)删除购物车商品
hdel cart:101 2003
4)改变购物车某个商品的购买数量
hincrby cart:101 2002 2
5.3)关键代码实现
5.3.1)Jedis写法
package com.jt.demos;
import redis.clients.jedis.Jedis;
import java.util.Map;
/**
* 作业:基于redis存储商品购物车信息
*/
public class CartDemo01 {
public static void addCart(Long userId,Long productId,int num){
//1.建立redis链接
Jedis jedis=new Jedis("192.168.64.128",6379);
jedis.auth("123456");
//2.向购物车添加商品
//hincrBy这个函数在key不存在时会自动创建key
jedis.hincrBy("cart:" + userId, String.valueOf(productId),num);
//3.释放redis链接
jedis.close();
}
//查看我的购物车
public static Map<String, String> listCart(Long userId){
//1.建立redis链接
Jedis jedis=new Jedis("192.168.64.128",6379);
jedis.auth("123456");
//2.查看购物车商品
Map<String, String> map = jedis.hgetAll("cart:" + userId);
//3.释放redis链接
jedis.close();
return map;
}
public static void main(String[] args) {
//1.向购物车添加商品
addCart(101L,201L,1);
addCart(101L,202L,1);
addCart(101L,203L,2);
//2.查看购物车商品
Map<String, String> map = listCart(101L);
System.out.println(map);
}
}
5.3.2)RedisTemplate写法
package com.jt.redis.demos;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import java.util.Map;
@Service
public class CartService {
@Autowired
private RedisTemplate redisTemplate;
/**
* 向购物车添加数据
*/
public void addCart(Integer userId,String productId,int num){
HashOperations hashOperations = redisTemplate.opsForHash();
//key不存在则会自动创建
hashOperations.increment("cart:"+userId, productId, num);
}
/**
* 查看购物车商品
* @param userId
* @return
*/
public Map<String,Object> listCart(Integer userId){
HashOperations hashOperations = redisTemplate.opsForHash();
return hashOperations.entries("cart:"+userId);
}
}
package com.jt;
import com.jt.redis.demos.CartService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.util.Map;
@SpringBootTest
public class CartServiceTests {
@Autowired
private CartService cartService;
@Test
void testAddCart(){
cartService.addCart(101, "201", 1);
cartService.addCart(101, "201", 2);
}
@Test
void testListCart(){
Map<String, Object> stringObjectMap =
cartService.listCart(101);
System.out.println(stringObjectMap);
}
}
定制序列化方式
package com.jt.redis.demos;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
//定制序列化
@Configuration
public class RedisConfig {
@Bean
public RedisTemplate<Object,Object> redisTemplate(RedisConnectionFactory redisConnectionFactory){
//1.构建RedisTemplate对象
RedisTemplate<Object,Object> redisTemplate=new RedisTemplate<Object,Object>();
//2.设置连接工厂
redisTemplate.setConnectionFactory(redisConnectionFactory);
//3.定义序列化方式(在这里选择jackson)
Jackson2JsonRedisSerializer redisSerializer= new Jackson2JsonRedisSerializer(Object.class);
ObjectMapper objectMapper=new ObjectMapper();
//设置要序列化的域(属性)
//any表示任意级别访问修饰符修饰的属性 private,public,protected
objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
//启动输入域检查(类不能是final修饰的)
objectMapper.activateDefaultTyping(objectMapper.getPolymorphicTypeValidator(),
ObjectMapper.DefaultTyping.NON_FINAL,
JsonTypeInfo.As.PROPERTY);
redisSerializer.setObjectMapper(objectMapper);
//4.设置RedisTemplate的序列化
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(redisSerializer);
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
redisTemplate.setHashValueSerializer(redisSerializer);
//spring规范中假如修改bean对象的默认特性,建议调用一下afterPropertiesSet()
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
}
5.3.3 注解的方式,自定义序列化方式
package com.jt.redis.demos;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.HashOperations;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import java.util.Map;
@Service
public class CartService {
@Autowired
private RedisTemplate redisTemplate;
@Resource(name = "stringRedisTemplate") //注解的方式,定制序列化方式
private HashOperations hashOperations;
/**
* 向购物车添加数据
*/
public void addCart(Integer userId,String productId,int num){
//HashOperations hashOperations = redisTemplate.opsForHash();
//key不存在则会自动创建
hashOperations.increment("cart:"+userId, productId, num);
}
/**
* 查看购物车商品
* @param userId
* @return
*/
public Map<String,Object> listCart(Integer userId){
//HashOperations hashOperations = redisTemplate.opsForHash();
return hashOperations.entries("cart:"+userId);
}
}
6、登录验证码实践
6.1)业务描述
1)进入登录页面之前先创建一个验证码,并将其存储在redis中
2)登录时输入验证码,并且将验证码与redis中的验证码进行比对
6.2)关键代码实现
package com.jt.demos;
import redis.clients.jedis.Jedis;
/**登录验证码实践
* 1)进入登录页面之前先创建一个验证码,并将其存储在redis中
* 2)登录时输入验证码,并且将验证码与redis中的验证码进行比对
* */
public class CodeDemo01 {
static void doLogin(String username,String password,String inputCode){
//1.校验验证码
//1.1验证是否为空
if(inputCode==null||"".equals(inputCode)){
System.out.println("please input code");
return;
}
//1.2验证redis中的code
Jedis jedis=new Jedis("192.168.126.130",6379);
String dbCode=jedis.get("code");
if(dbCode==null){
System.out.println("code timeout");
return;
}
if(!inputCode.equals(dbCode)){
System.out.println("code error");
return;
}
//2......
System.out.println("继续验证用户身份合法性");
}
public static void main(String[] args) {
char[] chars={
'A','B','C','D','1','2','.'
};//后续可以写一个算法从这个数组中随机取出四个值
//1.生成一个随机验证码
String code="12AB";
Jedis jedis=new Jedis("192.168.64.128",6379);
jedis.set("code","12AB");
jedis.expire("code",60);
jedis.close();
//2.执行登录操作
doLogin("jack","123456","12AB");
}
}