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”);
jedis.brpop(40,“list1”);
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为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?“已投过票”:“还没投票”));
}
}
业务描述
在设计一个秒杀或抢购系统时,为了提高系统的响应速度,通常会将用户的秒杀或抢购请求先存储到一个redis队列,这里我们就基于redis实现一个先进先出队列,例如:
关键代码实现
package com.jt.demos;
import redis.clients.jedis.Jedis;
//秒杀队列演示
//描述逻辑中会将商品抢购信息先写到redis(以队列形式进行存储),
//因为写redis内存数据库要比写你的mysql数据库快很多倍
//算法:先进先出(FIFO)-体现公平性
最后
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长,自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
[外链图片转存中…(img-aJ9IfV0w-1715590167731)]
[外链图片转存中…(img-RRkp22Ix-1715590167732)]
[外链图片转存中…(img-NHvkXM57-1715590167732)]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,不论你是刚入门Java开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门!
如果你觉得这些内容对你有帮助,需要这份全套学习资料的朋友可以戳我获取!!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!