18-Java中操作redis实践

最新推荐文章于 2024-07-16 08:13:46 发布

2401_84048671

最新推荐文章于 2024-07-16 08:13:46 发布

阅读量847

点赞数 22

分类专栏：程序员文章标签： java redis 开发语言

本文链接：https://blog.csdn.net/2401_84048671/article/details/138809527

版权

程序员专栏收录该内容

448 篇文章 0 订阅

订阅专栏

package com.jt;

import org.junit.Test;

import redis.clients.jedis.Jedis;

import java.util.concurrent.TimeUnit;

public class JedisTests {

//字符串类型练习

@Test

public void testStringOper() throws InterruptedException {

//建立链接(与redis建立链接)

Jedis jedis=new Jedis(“192.168.126.130”,6379);

jedis.auth(“123456”);//假如设置了密码,需要密码认证

String result=jedis.ping();

System.out.println(result);

//存储数据(key/value)

jedis.set(“count”,“1”);

jedis.set(“id”,“10001”);

jedis.set(“content”,“aaaaaaaadfas”);

//更新数据

jedis.expire(“id”,1);//设置key的有效时长

jedis.incr(“count”);//对key的值进行自增操作

//获取数据

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);

//释放资源

jedis.close();

}

//json数据练习

@Test

public void testJsonOper(){

//构建对象

Map<String,Object> map=new HashMap<>();

map.put(“id”,100);

map.put(“title”,“spring 认证”);

map.put(“content”,“very good”);

//将对象转换为json格式字符串

Gson gson=new Gson();

String jsonStr=gson.toJson(map);

//将json字符串写入到redis

Jedis jedis=new Jedis(“192.168.126.128”,6379);

jedis.set(“user”,jsonStr);

//读取redis中数据

jsonStr=jedis.get(“user”);

System.out.println(jsonStr);

Map<String,Object> obj=gson.fromJson(jsonStr,Map.class);

System.out.println(obj);

jedis.close();

}

//hash类型练习

@Test

public void testHashOper01(){

//1.建立连接

Jedis jedis=new Jedis(“192.168.126.128”,6379);

//2.存储一篇博客信息

jedis.hset(“article”,“id”,“1”);

jedis.hset(“article”,“title”,“mybatis”);

jedis.hset(“article”,“content”,“framework”);

//3.获取博客内容并输出

String id=jedis.hget(“article”,“id”);

String title=jedis.hget(“article”,“title”);

String content= jedis.hget(“article”,“content”);

System.out.println(id+“/”+title+“/”+content);

//4.释放资源

jedis.close();

}

//hash类型练习（直接存储map对象）

@Test

public void testHashOper02(){

//1.建立连接

Jedis jedis=new Jedis(“192.168.126.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();

}

//list类型练习:实现一个秒杀队列

@Test

public void testListOper01(){

//1.连接redis

Jedis jedis=new Jedis(“192.168.126.128”,6379);

//2.向队列存数据

jedis.rpush(“list1”,“A”,“B”,“C”);

//3.按先进先出的顺序从队列取数据

Long n=jedis.llen(“list1”);//获取队列长度

List list=jedis.lpop(“list1”,n.intValue());

System.out.println(list);

//4.释放资源

jedis.close();

}

//list类型练习：实现一个阻塞式队列

@Test

public void testListOper02(){

//1.连接redis

Jedis jedis=new Jedis(“192.168.126.128”,6379);

//2.向队列存数据

//jedis.lpush(“list1”,“A”,“B”,“C”);

//3.按先进先出的顺序从队列取数据

List list= jedis.brpop(40,“list1”);

System.out.println(list);

jedis.brpop(40,“list1”);

//4.释放资源

jedis.close();

}

//set类型练习

@Test

public void testSetOper01() {

//1.连接redis

Jedis jedis = new Jedis(“192.168.126.128”, 6379);

//2.朋友圈点赞

jedis.sadd(“count”, “1”, “1”, “2”);

//3.取出点赞数

Set set = jedis.smembers(“count”);

System.out.println(set);

//4.释放资源

jedis.close();

}

连接池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(){

//定义连接池的配置

JedisPoolConfig config=new JedisPoolConfig();

config.setMaxTotal(1000);//最大连接数

config.setMaxIdle(60);//最大空闲时间(连接不用了要释放)

//创建连接池

JedisPool jedisPool=

new JedisPool(config,“192.168.126.130”,6379);

//从池中获取一个连接

Jedis resource = jedisPool.getResource();

resource.auth(“123456”);

//通过jedis连接存取数据

resource.set(“class”,“cgb2004”);

String clazz=resource.get(“class”);

System.out.println(clazz);

//将链接返回池中

resource.close();

//关闭连接池

jedisPool.close();

}

RedisTemplate应用

=========================================================================

简介

RedisTemplate为SpringBoot工程中操作redis数据库的一个Java对象，此对象封装了对redis的一些基本操作。

准备工作

第一步：创建工程配置文件application.yml,其内容如下：

spring:

redis:

host: 192.168.64.129 #写自己的ip

port: 6379

第二步：创建工程启动类，例如：

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);

}

快速入门实现

StringRedisTemplate 应用

StringRedisTemplate 是一个专门用于操作redis字符串类型数据的一个对象，其应用方式如下：

package com.jt.redis;

@SpringBootTest

public class StringRedisTemplateTests {

/*此对象为spring提供的一个用于操作redis数据库中的字符串的一个对象/

@Autowired

private StringRedisTemplate stringRedisTemplate;

@Test

void testConnection(){

RedisConnection connection =

stringRedisTemplate.getConnectionFactory()

.getConnection();

String ping = connection.ping();

System.out.println(ping);

}

@Test

void testRedisStringOper()throws Exception{

//获取用于操作字符串的值对象

ValueOperations<String, String> valueOperations

= stringRedisTemplate.opsForValue();

//向redis中存储数据

valueOperations.set(“ip”, “192.168.174.130”);

valueOperations.set(“state”,“1”,1, TimeUnit.SECONDS);

valueOperations.decrement(“state”);

// Thread.sleep(2000);

//从redis中取数据

String ip=valueOperations.get(“ip”);

System.out.println(“ip=”+ip);

String state=valueOperations.get(“state”);

System.out.println(“state=”+state);

}

RedisTemplate 应用

RedisTemplate是一个专门用于实现对远端redis中复杂数据的操作的对应，应用案例如下：

package com.jt.redis;

@SpringBootTest

public class RedisTemplateTests {

/**

通过此对象操作redis中复杂数据类型的数据，例如hash结构

@Autowired

private RedisTemplate redisTemplate;

@Test

void testConnection(){

String result=

redisTemplate.getConnectionFactory().getConnection().ping();

System.out.println(result);

}

@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);

}

/*通过此方法操作redis中的hash数据/

@Test

void testHashData(){

HashOperations hashOperations = redisTemplate.opsForHash();//hash

Map<String,String> blog=new HashMap<>();

blog.put(“id”, “1”);

blog.put(“title”, “hello redis”);

hashOperations.putAll(“blog”, blog);

hashOperations.put(“blog”, “content”, “redis is very good”);

Object hv=hashOperations.get(“blog”,“id”);

System.out.println(hv);

Object entries=hashOperations.entries(“blog”);

System.out.println(“entries=”+entries);

}

@Test

void testFlushdb(){

redisTemplate.execute(new RedisCallback() {

@Override

public Object doInRedis(RedisConnection redisConnection) throws DataAccessException {

//redisConnection.flushDb();

redisConnection.flushAll();

return “flush ok”;

}

});

}

定制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 + ‘’’ +

‘}’;

}

在RedisTemplateTests类中添加如下单元测试方法,进行测试,例如:

@Test

void testJsonOper() throws JsonProcessingException {

ValueOperations valueOperations = redisTemplate.opsForValue();

Blog blog=new Blog(10,“study redis”);

valueOperations.set(“blog”,blog);//序列化

blog=(Blog)valueOperations.get(“blog”);//反序列化

System.out.println(“blog=”+blog);

}

项目工程实践

================================================================

单点登陆

业务描述

在分布式系统中,通过会有多个服务,我们登录了一个服务以后,再访问其它服务时,不想再登录,就需要有一套单独的认证系统,我们通常会称之为单点登录系统,在这套系统中提供一个认证服务器,服务完成用户身份认证,在一些中小型分布式系统中中,我们通常会借助redis存储用户的认证信息,例如:

在这里插入图片描述

关键代码实现

package com.jt.demos;

public class SSODemo01 {

//校验session的有效性

public static boolean isValidSession(String token){

if(token==null||“”.equals(token)){

return false;

}

//1.建立连接

Jedis jedis=new Jedis(“192.168.126.130”,6379);

jedis.auth(“123456”);

//2.从redis获取会话信息

//2.1用户token对应的用户信息,将来可以是一个json格式的字符串

String user=jedis.hget(“session”,token);//session这里表示会话对象

System.out.println(“user=”+user);

if(user==null||“”.equals(user)){

System.out.println(“还没有登录”);

jedis.close();

return false;

}

//3.判定是否登录超时

String dateStr=jedis.hget(“session”,token+“:expired”);

Date expired=new Date(Long.valueOf(dateStr));

if(dateStr==null||“”.equals(dateStr)||expired.before(new Date())) {

System.out.println(“登录超时”);

jedis.close();

return false;

}

return true;

};

//执行登录操作

public static String login(String username,String password){

System.out.println(“基于”+username+“/”+password+“进行登录”);

//1.创建token(一般可以用一个随机的字符串)

String token= UUID.randomUUID().toString()

.replace(“-”,“”);

System.out.println(token);

//2.创建有效登录时长

Calendar calendar=Calendar.getInstance();

calendar.add(Calendar.MINUTE,30);

//3.存储会话信息

Map<String,String> map=new HashMap<>();

map.put(token,username);//username这里可以是包含更多用户信息的json字符串

map.put(token+“:expired”,String.valueOf(calendar.getTimeInMillis()));

Jedis jedis=new Jedis(“192.168.126.130”,6379);

jedis.auth(“123456”);

jedis.hset(“session”,map);

jedis.close();

return token;

}

public static void main(String[] args) {

System.out.println(“=访问系统资源=”);

//第一访问:访问redis,检查是否有有效的会话信息

String token=null;

boolean flag=isValidSession(token);

System.out.println(flag?“第一次:已登录”:“第一次:未登录”);

//执行登录

if(!flag){

System.out.print(“执行登录:”);

token=login(“jack”,“123456”);

//登录成功的这个token将来响应到客户端

}

//第二次访问:

flag=isValidSession(token);

System.out.println(flag?“第二次:已登录”:“第二次:未登录”);

//第三次访问:

flag=isValidSession(token);

System.out.println(flag?“第三次:已登录”:“第三次:未登录”);

}

投票系统

业务描述

在很多系统中设计中,都会有一个活动设计,开启一个活动之前,可以对这个活动的支持力度先进行一个调查,例如基于这个活动设计一个投票系统,例如:

在这里插入图片描述

关键代码实现

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);

static{

jedis.auth(“123456”);

}

//进行投票(key为活动id,value为userId)

static void vote(String activityId,String userId){

jedis.sadd(activityId,userId);

}

//查看投票次数

static Long getVoteCount(String activityId){

Long count = jedis.scard(activityId);

return count;

}

//查看这个活动被哪写用户投过票

static Set getVoteUsers(String activityId){

Set smembers = jedis.smembers(activityId);

return smembers;

}

//检查这个用户是否已对这个活动投过票

static Boolean checkVote(String activityId,String userId){

Boolean flag = jedis.sismember(activityId, userId);

return flag;

}

public static void main(String[] args) {

//0.初始化

String activityId=“10001”;

String user1=“201”;

String user2=“202”;

String user3=“203”;

//1.投票

vote(activityId,user1);

vote(activityId,user2);

vote(activityId,user3);

//2.获取投票次数

Long voteCount = getVoteCount(activityId);

System.out.println(“投票次数:”+voteCount);

//3.输出哪些人投过票

Set users=getVoteUsers(activityId);

System.out.println(users);

//4.检查用户是否投过票

boolean flag=checkVote(activityId,user1);

System.out.println(user1+“:”+(flag?“已投过票”:“还没投票”));

}

秒杀队列

业务描述

在设计一个秒杀或抢购系统时,为了提高系统的响应速度,通常会将用户的秒杀或抢购请求先存储到一个redis队列,这里我们就基于redis实现一个先进先出队列,例如:

在这里插入图片描述

关键代码实现

package com.jt.demos;

import redis.clients.jedis.Jedis;

//秒杀队列演示

//描述逻辑中会将商品抢购信息先写到redis(以队列形式进行存储),

//因为写redis内存数据库要比写你的mysql数据库快很多倍

//算法:先进先出(FIFO)-体现公平性

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Java开发知识点，不论你是刚入门Java开发的新手，还是希望在技术上不断提升的资深开发者，这些资料都将为你打开新的学习之门！

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！
(users);

//4.检查用户是否投过票

boolean flag=checkVote(activityId,user1);

System.out.println(user1+“:”+(flag?“已投过票”:“还没投票”));

}

秒杀队列

业务描述

在这里插入图片描述

关键代码实现

package com.jt.demos;

import redis.clients.jedis.Jedis;

//秒杀队列演示

//描述逻辑中会将商品抢购信息先写到redis(以队列形式进行存储),

//因为写redis内存数据库要比写你的mysql数据库快很多倍

//算法:先进先出(FIFO)-体现公平性

最后

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。

[外链图片转存中…(img-aJ9IfV0w-1715590167731)]

[外链图片转存中…(img-RRkp22Ix-1715590167732)]

[外链图片转存中…(img-NHvkXM57-1715590167732)]

如果你觉得这些内容对你有帮助，需要这份全套学习资料的朋友可以戳我获取！！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

2401_84048671

关注

22
点赞
踩
25

收藏

觉得还不错? 一键收藏
0
评论
18-Java中操作redis实践

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
复制链接

扫一扫