Java中操作redis实践_03
Redis 客户端
概述
Redis 是一种C/S 架构的分布式缓存数据库,它有自带的命令行客户端,也有对应的Java或其它语言客户端,可以在这些客户端中通过一些API对redis进行读写操作。
准备工作
第一步:创建工程。
创建maven父工程,例如03-redis,并在此工程下创建两个子工程,一个为sca-jedis,一个为sca-tempate,例如:
第二步:添加父工程依赖
修改父工程pom.xml文件,添加编译配置
<build>
<plugins>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.8.1</version>
<configuration>
<source>8</source>
<target>8</target>
</configuration>
</plugin>
</plugins>
</build>
Jedis的基本应用
简介
Jedis是Java中操作redis的一个客户端,类似通过jdbc访问mysql数据库。
准备工作
在sca-jedis 工程添加如下依赖
<dependencies>
<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>
<dependencies>
Jeids基本应用实践
在Jedis工程中的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.126.130",6379);
//jedis.auth("123456");//假如在redis.conf中设置了密码
String ping = jedis.ping();
System.out.println(ping);
}
//字符串类型练习
@Test
public void testStringOper() throws InterruptedException {
//建立链接(与redis建立链接)
Jedis jedis=new Jedis("192.168.126.130",6379);
//存储数据(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.130",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();
}
//hash类型练习(直接存储map对象)
@Test
public void testHashOper02(){
//1.建立连接
Jedis jedis=new Jedis("192.168.126.130",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();
}
/**
* 测试:redis中list结构的应用
* 基于FIFO(First In First Out)算法,借助redis实现一个队列
*/
@Test
public void testListOper01(){
//1.建立连接
Jedis jedis=new Jedis("192.168.126.130",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();
}
//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();
}
}
我们可以基于池对象,设计一个数据源,将来在业务中通过一个数据源对象,从池中获取连接,不用每次获取连接都要创建池对象,例如:
package com.jt.redis;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;
public class JedisDataSource {
private static final String IP="192.168.126.128";
private static final int PORT=6379;//redis.conf 默认端口
/**
* volatile 关键通常用于修饰属性:
* 1)保证线程其可见性(一个线程改了,其它CPU线程立刻可见)
* 2)禁止指令重排序
* 3)不能保证其原子性(不保证线程安全)
*/
private static volatile JedisPool jedisPool;
//方案1:饿汉式池对象的创建
/*static{
JedisPoolConfig config=new JedisPoolConfig();
config.setMaxTotal(16);
config.setMaxIdle(8);
jedisPool=new JedisPool(config,IP,PORT);
}
public static Jedis getConnection(){
return jedisPool.getResource();
}*/
//方案2:懒汉式池对象的创建
public static Jedis getConnection(){
if(jedisPool==null) {
synchronized (JedisDataSource.class) {
if (jedisPool == null) {
JedisPoolConfig config = new JedisPoolConfig();
config.setMaxTotal(16);
config.setMaxIdle(8);
jedisPool = new JedisPool(config, IP, PORT);
//创建对象分析
//1.开辟内存空间
//2.执行属性的默认初始化
//3.执行构造方法
//4.将创建的对象的内存地址赋值给jedisPool变量
//假如使用了volatile修饰jedisPool变量,可以保证如上几个步骤是顺序执行的
}
}
}
return jedisPool.getResource();
}
public static void close(){
jedisPool.close();
}
}
RedisTemplate基本应用
简介
RedisTemplate为SpringBoot工程中操作redis数据库的一个Java对象,此对象封装了对redis的一些基本操作。
准备工作
第一步:添加在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>
第二步:创建工程配置文件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);
}
}
RedisTemplate对象应用实践
RedisTemplate是一个专门用于实现对远端redis数据进行操作的对象,默认会采用JDK序列化方式存取数据,应用案例如下:
package com.jt.redis;
@SpringBootTest
public class RedisTemplateTests {
//这个对象在springboot工程的RedisAutoConfiguration类中已经做了配置
//此对象在基于redis存取数据时默认采用的JDK的序列化方式
@Autowired
private RedisTemplate redisTemplate;
/**
* 测试字符串数据的存取
*/
@Test
void testStringOper01(){
//自己指定key/value序列化方式
ValueOperations vo = redisTemplate.opsForValue();
//key和value默认会采用JDK的序列化方式进行存储
vo.set("token", UUID.randomUUID().toString());
Object token = vo.get("token");
System.out.println(token);
}
/**通过此方法操作redis中的hash数据*/
@Test
void testHashOper(){
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 testListOper(){
//向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 testSetOper(){
SetOperations setOperations=redisTemplate.opsForSet();
setOperations.add("setKey1", "A","B","C","C");
Object members=setOperations.members("setKey1");
System.out.println("setKeys="+members);
//........
}
@Test
void testFlushdb(){
redisTemplate.execute(new RedisCallback() {
@Override
public Object doInRedis(RedisConnection redisConnection) throws DataAccessException {
//redisConnection.flushDb();
redisConnection.flushAll();
return "flush ok";
}
});
}
}
StringRedisTemplate 对象应用实践
StringRedisTemplate 是一个特殊的RedisTemplate对象,默认基于字符串序列化方式存取数据,其应用方式如下:
package com.jt.redis;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
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.HashOperations;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.TimeUnit;
@SpringBootTest
public class StringRedisTemplateTests {
/**
* 此对象为操作redis的一个客户端对象,这个对象
* 对key/value采用了字符串的序列化(StringRedisSerializer)
* 方式进行,redis数据的读写操作.
*/
@Autowired
private StringRedisTemplate stringRedisTemplate;
@Test
void testHashOper01(){
//1.获取hash操作的对象
HashOperations<String, Object, Object> vo =stringRedisTemplate.opsForHash();
//2.读写redis数据
//2.1存储一个对象
vo.put("user", "id", "100");
vo.put("user", "username", "tony");
vo.put("user", "status", "1");
//2.2获取一个对象
//2.2.1获取对象某个属性值
Object status =vo.get("user","status");
System.out.println(status);
//2.2.2获取对象某个key对应的所有值
List<Object> user = vo.values("user");
System.out.println(user);
}
@Test
void testStringOper02() throws JsonProcessingException {
//1.获取字符串操作对象(ValueOperations)
ValueOperations<String, String> vo =
stringRedisTemplate.opsForValue();
//2.读写redis中的数据
Map<String,String> map=new HashMap<>();
map.put("id","100");
map.put("title","StringRedisTemplate");
//将map对象转换为json字符串写到redis数据库
String jsonStr=//jackson (spring-boot-starter-web依赖中自带)
new ObjectMapper().writeValueAsString(map);
vo.set("blog", jsonStr);
jsonStr=vo.get("blog");
System.out.println(jsonStr);
//将json字符串转换为map对象
map=
new ObjectMapper().readValue(jsonStr, Map.class);
System.out.println(map);
}
@Test
void testStringOper01(){
//1.获取字符串操作对象(ValueOperations)
ValueOperations<String, String> vo =
stringRedisTemplate.opsForValue();
//2.读写redis中的数据
vo.set("x", "100");
vo.increment("x");
vo.set("y", "200", 1, TimeUnit.SECONDS);
String x = vo.get("x");
String y = vo.get("y");
System.out.println("x="+x+",y="+y);
}
@Test
void testGetConnection(){
RedisConnection connection =
stringRedisTemplate.getConnectionFactory()
.getConnection();
String ping = connection.ping();
System.out.println(ping);
}
}
基于业务定制RedisTemplate对象(拓展)
我们知道系统中的RedisTemplate默认采用的是JDK的序列化机制,假如我们不希望使用默认的JDK方式序列化,可以对RedisTemplate对象进行定制,指定自己的序列化方式,例如:
package com.jt;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.JsonInclude;
import com.fasterxml.jackson.annotation.JsonTypeInfo;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
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.GenericJackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializer;
import java.net.UnknownHostException;
@Configuration
public class RedisConfig {//RedisAutoConfiguration
//自定义json序列化
public RedisSerializer jsonSerializer(){
//1.定义Redis序列化,反序列化规范对象(此对象底层通过ObjectMapper完成对象序列化和反序列化)
Jackson2JsonRedisSerializer serializer=
new Jackson2JsonRedisSerializer(Object.class);
//2.创建ObjectMapper(有jackson api库提供)对象,基于此对象进行序列化和反序列化
//2.1创建ObjectMapper对象
ObjectMapper objectMapper=new ObjectMapper();
//2.2设置按哪些方法规则进行序列化
objectMapper.setVisibility(PropertyAccessor.GETTER,//get方法
JsonAutoDetect.Visibility.ANY);//Any 表示任意方法访问修饰符
//对象属性值为null时,不进行序列化存储
objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
//2.2激活序列化类型存储,对象序列化时还会将对象的类型存储到redis数据库
//假如没有这个配置,redis存储数据时不存储类型,反序列化时会默认将其数据存储到map
objectMapper.activateDefaultTyping(
objectMapper.getPolymorphicTypeValidator(),//多态校验分析
ObjectMapper.DefaultTyping.NON_FINAL,//激活序列化类型存储,类不能使用final修饰
JsonTypeInfo.As.PROPERTY);//PROPERTY 表示类型会以json对象属性形式存储
serializer.setObjectMapper(objectMapper);
return serializer;
}
//高级定制
@Bean
public RedisTemplate<Object, Object> redisTemplate(
RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
RedisTemplate<Object, Object> template = new RedisTemplate();
template.setConnectionFactory(redisConnectionFactory);
//设置key的序列化方式
template.setKeySerializer(RedisSerializer.string());
template.setHashKeySerializer(RedisSerializer.string());
//设置值的序列化方式
template.setValueSerializer(jsonSerializer());
template.setHashValueSerializer(jsonSerializer());
//更新一下RedisTemplate对象的默认配置
template.afterPropertiesSet();
return template;
}
//简单定制
// @Bean
// public RedisTemplate<Object, Object> redisTemplate(
// RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
// RedisTemplate<Object, Object> template = new RedisTemplate();
// template.setConnectionFactory(redisConnectionFactory);
// //设置key的序列化方式
// template.setKeySerializer(RedisSerializer.string());
// template.setHashKeySerializer(RedisSerializer.string());
// //设置值的序列化方式
// template.setValueSerializer(RedisSerializer.json());
// template.setHashValueSerializer(RedisSerializer.json());
// return template;
// }
}
创建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的项目业务分析及实践
分布式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");//假如redis设置了密码,连接redis时需要指定密码
Long id = jedis.incr("id");
jedis.close();
return id;
}
//自己创建线程执行任务
static void execute01(){
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();
}
}
//基于线程池执行任务
static void execute02(){
//构建一个最多只有3个线程的线程池
ExecutorService es=
Executors.newFixedThreadPool(3);
for(int i=1;i<=10;i++){
//从池中取线程执行任务
es.execute(new Runnable() {//这个任务会存储到阻塞式任务队列中
@Override
public void run() {
System.out.println(Thread.currentThread().getName()
+"->"+getId());
}
});
}
}
public static void main(String[] args) {
//execute01();
execute02();
}
}
单点登陆(SSO)
业务描述
在分布式系统中,通过会有多个服务,我们登录了一个服务以后,再访问其它服务时,不想再登录,就需要有一套单独的认证系统,我们通常会称之为单点登录系统,在这套系统中提供一个认证服务器,服务完成用户身份认证,在一些中小型分布式系统中中,我们通常会借助redis存储用户的认证信息,例如:
关键代码实现
package com.jt.redis;
import redis.clients.jedis.Jedis;
import java.util.UUID;
/**
* 基于redis的单点登录设计及实现
* 1)用户登录成功以后将登录状态等信息存储到redis
* 2)用户携带token去访问资源,资源服务器要基于token从redis查询用户信息
*/
public class SSODemo01 {
/**
* 执行登录认证,将来这样的业务要写到认证服务器
* @param username
* @param password
*/
static String doLogin(String username,String password){
//1.检验数据的合法性(判定用户名,密码是否为空,密码的长度,是否有数字字母特殊符号构成)
if(username==null||"".equals(username))
throw new IllegalArgumentException("用户不能为空");
//2.基于用户名查询用户信息,并判定密码是否正确
if(!"jack".equals(username))
throw new RuntimeException("此用户不存在");
if(!"123456".equals(password))
throw new RuntimeException("密码不正确");
//3.用户存在且密码正确,将用户信息写入到redis
Jedis jedis=new Jedis("192.168.126.128", 6379);
String token= UUID.randomUUID().toString();
jedis.hset(token, "username", username);
jedis.hset(token, "permission", "sys:resource:create");
jedis.expire(token, 10);//设置key的有效时间
jedis.close();
//4.将token返回给客户端(将来使用response对象响应到客户端).
return token;
}
static String token;
/**
* 演示资源访问过程
* 1)允许匿名访问(无需登录)
* 2)登录后访问(认证通过了)
* 3)登录后必须有权限才可以访问
*/
static Object doGetResource(String token){
//1.校验token是否为空
if(token==null)
throw new IllegalArgumentException("请先登录");
//2.基于token查询redis数据,假如有对应数据说明用户登录了
Jedis jedis=new Jedis("192.168.126.128", 6379);
String username=jedis.hget(token, "username");
if(username==null)
throw new RuntimeException("登录超时,请重新登录");
String permission=jedis.hget(token, "permission");
jedis.close();
//3.检查用户是否有访问资源的权限,假如有则允许访问
if(!"sys:resource:create".equals(permission))
throw new RuntimeException("你没有权限访问这个资源");
//4.返回要访问的资源.
return "your resource";
}
public static void main(String[] args) {
//1.登录操作(用户身份认证)
token=doLogin("jack", "123456");
System.out.println(token);
//2.携带token访问资源服务器
Object result=doGetResource(token);
System.out.println(result);
}
}
简易秒杀队列
业务描述
在设计一个秒杀或抢购系统时,为了提高系统的响应速度,通常会将用户的秒杀或抢购请求先存储到一个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();
}
}
简易投票系统
业务描述
在很多系统中设计中,都会有一个活动设计,开启一个活动之前,可以对这个活动的支持力度先进行一个调查,例如基于这个活动设计一个投票系统,例如:
关键代码实现
package com.jt.redis;
import redis.clients.jedis.Jedis;
import java.util.Set;
/**
* 基于某个活动的简易投票系统设计
* 1)投票数据存储到redis (key为活动id,多个用户id的集合)
* 2)同一个用户不能执行多次投票
* 3)具体业务操作(投票,获取总票数,获取哪些人参与了投票)
*/
public class VoteDemo01 {
/**
* 获取哪些人执行了这个活动的投票
* @param activityId
* @return
*/
static Set<String> doGetMembers(String activityId){
//1.建立连接
Jedis jedis=new Jedis("192.168.126.128", 6379);
//2.获取当前活动的总票数
Set<String> smembers = jedis.smembers(activityId);
//3.释放资源
jedis.close();
return smembers;
}
/**
* 获取指定活动的投票总数
* @param activityId
* @return
*/
static Long doCount(String activityId){
//1.建立连接
Jedis jedis=new Jedis("192.168.126.128", 6379);
//2.获取当前活动的总票数
Long count=jedis.scard(activityId);
//3.释放资源
jedis.close();
return count;
}
/**
* 执行投票操作
* @param activityId
* @param userId
*/
static void doVote(String activityId,String userId){
//1.建立连接
Jedis jedis=new Jedis("192.168.126.128", 6379);
//2.执行投票
//2.1检查是否投过票
Boolean flag = jedis.sismember(activityId, userId);
//2.2执行投票或取消投票
if(flag){
//假如已经投过票,再投票就取消投票
jedis.srem(activityId, userId);
}else{
//没有投过票则执行投票
jedis.sadd(activityId, userId);
}
//3.释放资源
jedis.close();
}
public static void main(String[] args) {
String activityId="101";
String userId1="1";
String userId2="2";
String userId3="3";
//执行投票动作
doVote(activityId, userId1);
doVote(activityId, userId2);
doVote(activityId, userId3);
//获取投票的总票数
Long aLong = doCount(activityId);
System.out.println(aLong);
//获取参与投票的成员
Set<String> members= doGetMembers(activityId);
System.out.println(members);
}
}
简易购物车系统
业务描述
简易购物车业务设计如图所示:
基础指令操作,例如:
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.向购物车添加商品
//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);
}
}
SpringBoot工程中Redis与Aop技术的整合
业务描述
基于AOP与Redis技术实现mysql,redis数据库中数据操作.
项目准备工作
第一步:打开sca-template工程,添加访问MySql数据库的依赖(两个)
<!--mysql依赖-->
<dependency>
<groupId>mysql</groupId>
<artifactId>mysql-connector-java</artifactId>
</dependency>
<!--mybatis plus (简化mybatis操作)-->
<dependency>
<groupId>com.baomidou</groupId>
<artifactId>mybatis-plus-boot-starter</artifactId>
<version>3.4.2</version>
</dependency>
第二步:修改sca-template工程的配置文件,添加连接mysql数据库的配置
spring:
datasource:
url: jdbc:mysql:///jt-sso?serverTimezone=Asia/Shanghai&characterEncoding=utf8
username: root
password: root
Pojo逻辑对象定义
定义一个Menu对象,用户封装tb_menus表中的数据,例如:
package com.jt.pojo;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import org.springframework.data.annotation.Id;
import java.io.Serializable;
@TableName(value = "tb_menus")
public class Menu implements Serializable {
private static final long serialVersionUID = -577747732166248365L;
@TableId(type = IdType.AUTO)
private Long id;
private String name;
private String permission;
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String getPermission() {
return permission;
}
public void setPermission(String permission) {
this.permission = permission;
}
@Override
public String toString() {
return "Menu{" +
"id=" + id +
", name='" + name + '\'' +
", permission='" + permission + '\'' +
'}';
}
}
Dao逻辑对象设计及实现
创建用于操作数据库中tb_menus表中数据的Mapper对象,例如:
package com.jt.dao;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.jt.pojo.Menu;
import org.apache.ibatis.annotations.Mapper;
@Mapper
public interface MenuMapper extends BaseMapper<Menu> {
}
Service逻辑对象设计及实现
第一步:定义用于处理菜单业务的业务接口,例如:
package com.jt.service;
import com.jt.pojo.Menu;
import java.io.Serializable;
public interface MenuService {
/**
* 基于id查找菜单对象,先查redis,redis没有再查数据库
* @param id
* @return
*/
Menu selectById(Long id);
/**
* 向表中写入一条菜单信息,与此同时也要向redis写入一样的数据
* @param menu
* @return
*/
Menu insertMenu(Menu menu);
/**
* 更新表中数据,与此同时也要更新redis中的数据
* @param menu
* @return
*/
Menu updateMenu(Menu menu);
//.....
}
第二步:定义用于处理菜单业务的业务接口实现类,
在这个实现类中自己基于RedisTemplate对象操作Redis缓存,例如:
package com.jt.service;
import com.jt.dao.MenuMapper;
import com.jt.pojo.Menu;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import java.time.Duration;
@Service
public class MenuServiceImpl implements MenuService{
@Autowired
private MenuMapper menuMapper;
// @Autowired
// private RedisTemplate redisTemplate;
@Resource(name="redisTemplate")
private ValueOperations valueOperations;//从spring.io官方的data项目中去查这种注入方式
/**
* 基于id查询菜单信息,要求:
* 1)先查redis,redis没有去查mysql
* 2)将从mysql查询到的数据存储到redis
* @param id
* @return
*/
@Override
public Menu selectById(Long id) {
//ValueOperations valueOperations = redisTemplate.opsForValue();
Object obj=valueOperations.get(String.valueOf(id));
if(obj!=null){
System.out.println("Get Data from redis");
return (Menu)obj;
}
Menu menu=menuMapper.selectById(id);
valueOperations.set(String.valueOf(id), menu, Duration.ofSeconds(120));
return menu;
}
@Override
public Menu insertMenu(Menu menu) {
menuMapper.insert(menu);
// ValueOperations valueOperations = redisTemplate.opsForValue();
valueOperations.set(String.valueOf(menu.getId()), menu, Duration.ofSeconds(120));
return menu;
}
@Override
public Menu updateMenu(Menu menu) {
menuMapper.updateById(menu);
// ValueOperations valueOperations = redisTemplate.opsForValue();
valueOperations.set(String.valueOf(menu.getId()), menu, Duration.ofSeconds(120));
return menu;
}
}
第三步:定义用于处理菜单业务的业务接口实现类,基于AOP方式操作redis缓存,比较
与第二步写的Redis操作方式的不同,例如:
package com.jt.service;
import com.jt.dao.MenuMapper;
import com.jt.pojo.Menu;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CachePut;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
@Service
public class DefaultMenuService implements MenuService{
@Autowired
private MenuMapper menuMapper;
/**
* 由此注解描述的方法为切入点方法,此方法执行时,底层会通过AOP机制
* 先从缓存取数据,缓存有则直接返回,缓存没有则查数据,最后将查询的数据
* 还会向redis存储一份
* @param id
* @return
*/
@Cacheable(value = "menuCache",key="#id")
@Override
public Menu selectById(Long id) {
return menuMapper.selectById(id);
}
/**
* CachePut注解的意思是更新缓存
* @param menu
* @return
*/
@CachePut(value = "menuCache",key="#menu.id")
@Override
public Menu insertMenu(Menu menu) {
menuMapper.insert(menu);
return menu;
}
@CachePut(value = "menuCache",key="#menu.id")
@Override
public Menu updateMenu(Menu menu) {
menuMapper.updateById(menu);
return menu;
}
}
说明,启动AOP方式的缓存应用,需要在启动类上添加@EnableCaching注解:
第四步:定义单元测试类,基于单元测试类测试缓存应用.例如:
package com.jt;
import com.jt.pojo.Menu;
import com.jt.service.MenuService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;
import javax.annotation.Resource;
@SpringBootTest
public class MenuServiceTests {
@Autowired
@Qualifier("defaultMenuService")
//@Resource(name="defaultMenuService")
private MenuService menuService;
@Test
void testSelectById(){
Menu menu = menuService.selectById(1L);
System.out.println(menu);
}
@Test
void testUpdateMenu(){
Menu menu = menuService.selectById(1L);
menu.setName("select res");
menuService.updateMenu(menu);
}
@Test
void testInertMenu(){
Menu menu = new Menu();
menu.setName("insert res");
menu.setPermission("sys:res:insert");
menuService.insertMenu(menu);
}
}
第五步:改变AOP方式中redis数据存储时的序列化方式(假如业务上需要).其实现上要借助
CacheManager对象,例如:
package com.jt;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.CacheManager;
import org.springframework.cache.annotation.CachingConfigurerSupport;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Primary;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
/**
* 重构CacheManager对象,其目的是改变AOP方式应用redis的序列化和反序列化的方式.
*/
@Configuration
public class CacheManagerConfig {
/**
* 重构CacheManager对象
* @return
*/
@Bean
public CacheManager cacheManager(RedisConnectionFactory redisConnectionFactory) {
//定义RedisCache配置
RedisCacheConfiguration cacheConfig=
RedisCacheConfiguration.defaultCacheConfig()
//定义key的序列化方式
.serializeKeysWith(
RedisSerializationContext.
SerializationPair.fromSerializer(RedisSerializer.string()))
//定义value的序列化方式
.serializeValuesWith(
RedisSerializationContext.SerializationPair
.fromSerializer(RedisSerializer.json()));
return RedisCacheManager.builder(redisConnectionFactory)
.cacheDefaults(cacheConfig)
.build();//建造者模式(复杂对象的创建,建议使用这种方式,封装了对象的创建细节)
}
}
写好这个对象后,可以再次基于MenuService中的方法进行单元测试,检测redis数据的存储.
Controller逻辑对象设计及实现
第一步:定义Controller处理,处理客户端对菜单数据的请求操作,例如:
package com.jt.controller;
import com.jt.pojo.Menu;
import com.jt.service.MenuService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.web.bind.annotation.*;
@RestController
@RequestMapping("/menu")
public class MenuController{
@Autowired
@Qualifier("defaultMenuService")
private MenuService menuService;
@GetMapping("/{id}")
public Menu doSelectById(@PathVariable("id") Long id){
return menuService.selectById(id);
}
@PutMapping
public String doUpdate(@RequestBody Menu menu){
menuService.updateMenu(menu);
return "update ok";
}
@PostMapping
public String doInsert(@RequestBody Menu menu){
menuService.insertMenu(menu);
return "insert ok";
}
}
第二步:打开postman进行访问测试.检测redis数据存储与更新
总结(Summary)
本章节主要对Java中操作redis数据库的方式及API应用进行了分析和实践,具体方法的理解可以在实践中基于结果进行分析,逐步进行强化记忆。