文章目录
准备工作
创建工程
创建maven父工程,例如05-jt-redis,并在此工程下创建两个子工程,一个为jt-jedis,一个为jt-tempate,例如:
添加项目依赖
jt-jedis 工程依赖
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.5.2</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
<version>2.8.6</version>
</dependency>
添加jt-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的应用
简介
Jedis是Java中操作redis的一个客户端,类似通过jdbc访问mysql数据库。
准备工作
在java中远程连接redis,需要将redis.conf配置文件中的bind 127.0.0.1元素注释掉,并且将其保护模式(protected-mode)设置为no(redis3.0之后默认开启了这个策略) ,当修改了配置以后,一定要记得重启redis,然后再进行访问。
快速入门实现
在Jedis工程中定义单元测试类,在类中定义单元测试方法:
基础类型操作
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<String> 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<String> 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<String> 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<String> getVoteUsers(String activityId){
Set<String> 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<String> 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)-体现公平性
public class SecondKillDemo01 {
//商品抢购首先是入队
static void enque(String msg){//入队
Jedis jedis=new Jedis("192.168.126.130",6379);
jedis.auth("123456");//没有认证不需要写这个语句
jedis.lpush("queue",msg);
jedis.close();
}
//底层异步出队(基于这个消息,生成订单,扣减库存,...)
static String deque(){//出队
Jedis jedis=new Jedis("192.168.126.130",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();
}
}
分布式id
业务描述
在分布式系统中,数据量将越来越大时,就需要对数据进行分表操作,但是,分表后,每个表中的数据都会按自己的节奏进行自增,很有可能出现ID冲突。这时就需要一个单独的机制来负责生成唯一ID,生成出来的ID也可以叫做 分布式ID,这里我们借助redis实现一个简易的分布式id进行实现,当然还有一些第三方的系统,可以帮你生成这样的id,可以自己进行拓展学习.
关键代码实现
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.126.130",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();
}
}
}
购物车简易实现
业务描述
简易购物车业务设计如图所示:
基础指令操作,例如:
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
关键代码实现
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.126.130",6379);
jedis.auth("123456");
//2.向购物车添加商品
String product = jedis.hget("cart:" + userId, String.valueOf(productId));
//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.126.130",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);
}
}
总结(Summary)
本章节主要对Java中操作redis数据库的方式及API应用进行了分析和实践,具体方法的理解可以在实践中基于结果进行分析,逐步进行强化记忆。