1.Redis入门案例
Redis命令:Redis概述与命令
1.1 导入jar包
<!--spring整合redis -->
<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.data</groupId>
<artifactId>spring-data-redis</artifactId>
</dependency>
1.2 入门案例
package com.jt.redis;
import org.junit.jupiter.api.Test;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.Transaction;
import redis.clients.jedis.params.SetParams;
import java.time.chrono.JapaneseDate;
public class TestRedis {
/**
* 1.redis配置文件3处修改
* 2.Linux系统防火墙
* 3.检查redis启动方式 redis-server redis.conf
* */
@Test
public void testSet() throws InterruptedException {
String host = "192.168.126.129"; //本地ip地址
int port = 6379; //redis启动后的端口号
Jedis jedis = new Jedis(host,port);
//命令怎么敲,代码就怎么写
jedis.set("2011", "redis入门案例"); //set添加
System.out.println(jedis.get("2011"));//get获取数据
jedis.flushAll();//清空全部数据库
//判断数据是否存在:
//测试是否存在
if(jedis.exists("2011")){//判断数据是否存在
jedis.del("2011");//删除redis中的数据
}else{
jedis.set("num", "100");//添加数据
//自增1
jedis.incr("num");//incr 自动加1
jedis.expire("num", 20);//指定num的生效时间 单位秒
Thread.sleep(2000);//睡眠2秒
//ttl检查数据的剩余存活时间
System.out.println(jedis.ttl("num"));//检查超时时间
//取消超时时间
jedis.persist("num");
}
}
//有时我们可能会为数据添加超时时间
//原子性问题: 有时业务要求要么同时完成,要么同时失败
@Test
public void testSetEx(){
Jedis jedis = new Jedis("192.168.126.129", 6379);
//jedis.set("a","aa");//存值
//假设服务器异常,那么指定的生效时间则无法执行
//jedis.expire("a",60);//指定a的生效时间 60秒
jedis.setex("a", 20, "100");//setex把赋值操作和生效操作合二为一
System.out.println(jedis.get("a"));
}
/**
* 需求1:如果该数据不存在时,才会赋值.
* 需求2: 如果数据存在时,进行修改, 并且为他设定超时时间 满足原子性要求.
*
*/
@Test
public void testSetNX(){
Jedis jedis = new Jedis("192.168.126.129", 6379);
jedis.set("a", "111");//存值
jedis.setnx("a", "123");//指定的数据不存在时,为数据设置指定的值。
System.out.println(jedis.get("a"));//获取a的值,并输出
// 需求2:
// if (jedis.expire("a"){//数据存在
// jedis.setex("a", 123, "60");//存值
// }
SetParams params = new SetParams();//创建对象
params.xx().ex(60);//nx数据不存在 赋值,xx数据存在 赋值,ex 秒 px毫秒
//判断数据是否存在,如果不存在就赋值
jedis.set("b", "bb", params);//b存在,就赋值
}
// hash类型
// 默认hash是无序的
@Test
public void testHash(){
Jedis jedis = new Jedis("192.168.126.129", 6379);
//hset 为对象添加数据
jedis.hset("user", "id", "100");
jedis.hset("user", "name", "qingfeng");
jedis.hset("user", "age", "18");
//hkeys 获取hash中的所有字段
System.out.println(jedis.hkeys("user"));
//hget获取对象的属性值
System.out.println(jedis.hget("user", "name"));
//hmget 获取hash里面指定字段的值
System.out.println(jedis.hmget("user", "id"));
//hgetAll 获取hash全部元素和值
System.out.println(jedis.hgetAll("user"));
//hstrlen 获取hash中指定key的值的长度
System.out.println(jedis.hstrlen("user","name"));
}
//队列:先进先出 方向相反
//栈: 先进后出 方向相同 注意可变参数类型
@Test
public void testList(){
Jedis jedis = new Jedis("192.168.126.129", 6379);
//L 4,3, 2,1 R
//lpush从队列的左边入队一个或多个元素
//jedis.lpush("list", "1,2,3,4"); 注意可变参数类型
jedis.lpush("list", "1","2","3","4");
//rpop 从队列的右端出队一个元素
System.out.println(jedis.rpop("list"));
}
@Test
public void testTx(){
Jedis jedis = new Jedis("192.168.126.129", 6379);
//开启事务
//multi 标记一个事务开始
Transaction transaction = jedis.multi();
try {
transaction.set("a", "a");
transaction.set("b", "b");
transaction.set("b", "b");
//提交事务
transaction.exec();//exec 执行所有multi之后发的命令
}catch (Exception e){
transaction.discard(); //discard丢弃所有multi之后发的命令,回滚
}
}
}
2.SpringBoot整合Redis
2.1 编辑pro配置文件
2.2 编辑配置类
package com.jt.config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import redis.clients.jedis.Jedis;
@Configuration //标识为一个配置类,一般整合第三方
@PropertySource("classpath:/properties/redis.properties")
public class RedisConfig {
@Value("${redis.host}")
private String host;
@Value("${redis.port}")
private Integer port;
@Bean //将该方法的返回值,交给Spring容器管理
public Jedis jedis(){
return new Jedis(host,port);
}
}
使用方法:
@Autowired
private Jedis jedis;
@Test
public void testSpringBootRedis(){
jedis.set("abc", "abc");
System.out.println(jedis.get("abc"));
}
3 JSON格式转化
3.1 业务说明
由于程序需要与JSON串进行数据的交互,所以通过API进行转化
3.2 代码如下
加深理解:
先在测试类中创建TestJSON方便理解
package com.jt.json;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.jt.pojo.ItemDesc;
import org.junit.jupiter.api.Test;
import java.util.Date;
public class TestJOSN {
/**
* json格式:
* 1.object格式 {key:value,key2:value2}
* 2.数组格式 [value,value2,value3]
* 3.嵌套格式 value可以进行嵌套.
*
* 任务: 实现对象与JSON串之间的转化.
* 面试题: 常量是否有线程安全性问题?
* (没有,多个线程共享资源,加了final不能被修改)
*/
//定义常量,final不能被修改,不加final可能会有安全性问题
private static final ObjectMapper MAPPER = new ObjectMapper();
@Test
public void ObjectToJSON() throws JsonProcessingException {
//创建对象
ItemDesc itemDesc = new ItemDesc();
//给对象赋值
itemDesc.setItemId(100L)
.setItemDesc("JSON测试")
.setCreated(new Date())
.setUpdated(itemDesc.getCreated());
//将对象转换为JSON,调用的对象get方法,形成属性/属性值
String json = MAPPER.writeValueAsString(itemDesc);
System.out.println(json);
//将JSON串,转化为对象 反射的机制 反射会实例化对象
//怎么给对象赋值?调用对象的set方法为属性赋值
ItemDesc itemDesc2 = MAPPER.readValue(json, ItemDesc.class);
System.out.println(itemDesc2.toString()+""+itemDesc2.getCreated());
}
}
运行测试:
加深结构理解:
package com.jt.json;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.jt.pojo.ItemDesc;
import org.junit.jupiter.api.Test;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
public class TestJOSN {
/**
* json格式:
* 1.object格式 {key:value,key2:value2}
* 2.数组格式 [value,value2,value3]
* 3.嵌套格式 value可以进行嵌套.
*
* 任务: 实现对象与JSON串之间的转化.
* 面试题: 常量是否有线程安全性问题?
* (没有,多个线程共享资源,加了final不能被修改)
*/
//定义常量,final不能被修改,不加final可能会有安全性问题
private static final ObjectMapper MAPPER = new ObjectMapper();
@Test
public void ObjectToJSON() throws JsonProcessingException {
//创建对象
ItemDesc itemDesc = new ItemDesc();
//给对象赋值
itemDesc.setItemId(100L)
.setItemDesc("JSON测试")
.setCreated(new Date())
.setUpdated(itemDesc.getCreated());
//将对象转换为JSON,调用的对象get方法,形成属性/属性值
String json = MAPPER.writeValueAsString(itemDesc);
System.out.println(json);
//将JSON串,转化为对象 反射的机制 反射会实例化对象
//怎么给对象赋值?调用对象的set方法为属性赋值
ItemDesc itemDesc2 = MAPPER.readValue(json, ItemDesc.class);
System.out.println(itemDesc2.toString()+""+itemDesc2.getCreated());
}
//2.加深印象:
//新建测试数据,封装到List集合
public List<ItemDesc> getList(){
List<ItemDesc> list = new ArrayList<>();
ItemDesc itemDesc = new ItemDesc();
//第一个对象
itemDesc.setItemId(100L)
.setItemDesc("bbb")
.setCreated(new Date())
.setUpdated(new Date());
//第二个对象
ItemDesc itemDesc2 = new ItemDesc();
itemDesc2.setItemId(100L)
.setItemDesc("bbb")
.setCreated(new Date())
.setUpdated(new Date());
list.add(itemDesc);
list.add(itemDesc2);
return list;
}
@Test
public void ListToJSON() throws JsonProcessingException {
List<ItemDesc> list = getList();
//转换为JSON串
String json = MAPPER.writeValueAsString(list);
//输出JSON串
System.out.println(json);
//将JSON还原回对象
List<ItemDesc> list2 = MAPPER.readValue(json, List.class);//传的是集合,转换回来还是集合
System.out.println(list2);
}
}
测试运行结果:
3.3 JSON转化工具API
说明: 在jt-common中添加工具API
工具类不需要交给容器管理
package com.jt.util;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
public class ObjectMapperUtil {
//创建一个Object对象,通过这个对象进行数据的转换
private static final ObjectMapper MAPPER = new ObjectMapper();
//1.对象转化为JSON
public static String toJSON(Object obj){
try {
//没有问题就return把数据返回
return MAPPER.writeValueAsString(obj);
} catch (JsonProcessingException e) {
//将检查异常,转化成运行时异常
e.printStackTrace();
//抛出异常
throw new RuntimeException(e);
}
}
//2.JSON转化为对象
//传递什么样的类型,返回什么样的对象???
//<T> 类型的定义
public static <T> T toObject(String json, Class<T> target){// Class<T> target 泛型
try {
//JSON转化为对象
return MAPPER.readValue(json, target);
} catch (JsonProcessingException e) {
//将检查异常,转化成运行时异常
e.printStackTrace();
//抛出异常
throw new RuntimeException(e);
}
}
}
4 商品分离缓存实现
4.1 编辑工具ItemCatServiceImpl
修改 ItemCatController
@RequestMapping("/item/cat/list")
public List<EasyUITree> findItemCatList(Long id){
//查询商品分类信息 1级菜单
//如果用户没有点击按钮 将不会传递Id值,应该设定默认值
long parentId = (id==null?0:id); //0 一级菜单 判断是否点击,点击了就传值
// return itemCatService.findItemCatList(parentId);
return itemCatService.findItemCatCache(parentId);
}
/**
*
* 1.将商品分类信息添加到缓存中
* 2.数据结构: k-v结构 ITEM_CAT_PARENT::0 - JSON
* 3.业务流程:
* 1.先查缓存 true/false
* 2.false 用户第一次查询数据库, 将结果保存到redis缓存中
* 3.true 查询缓存
* AOP机制
*/
@Autowired(required = false)
private Jedis jedis;//该参数不是最终结构,后期需要优化
@Override
public List<EasyUITree> findItemCatCache(long parentId) {
//起始时间
long startTime = System.currentTimeMillis();
//准备一个空集合
List<EasyUITree> treeList = new ArrayList<>();
//1.定义key
String key = "ITEM_CAT_PARENT::" + parentId;
//2.判断数据是否存在
if(jedis.exists(key)){
//根据key查询json
String json = jedis.get(key);
//json转化为对象
treeList = ObjectMapperUtil.toObject(json, treeList.getClass());
//结束查询时间
long endTime = System.currentTimeMillis();
//输出查询结果
System.out.println("redis查询! 耗时:"+(endTime-startTime));
}else{
//数据不存在,查询数据库
treeList = findItemCatList(parentId);
//将数据库记录,转化为JSON
String json = ObjectMapperUtil.toJSON(treeList);
// 将数据保存到redis中
jedis.set(key, json);
//结束查询时间
long endTime = System.currentTimeMillis();
//输出查询结果
System.out.println("查询数据库!! 耗时:"+(endTime-startTime));
}
return treeList;
}
4.2 Redis效果展现
5 Spring中AOP复习
5.1 什么是AOP
名称解释: 面向切面编程
作用: 在不修改源码的条件下,对方法 功能进行了额外了扩展.
意义: 降低了代码的耦合性.
公式: AOP = 切入点表达式 + 通知方法
5.2 切入点表达式
1.bean(“包名.类名”)
具体某个类 按类匹配 粗粒度
2.within(“包名.类名”)
可以使用通配符 几个类一起匹配 粗粒度
3.execution(返回值类型 包名.类名.方法名(参数列表))
细粒度
4.注解方式 @annotation(注解的类型)
细粒度
5.3 通知方法
1.before
目标方法执行之前执行.
2.afterReturning
目标方法执行之后执行
3.afterThrowing
目标方法抛出异常时执行
4.after
不管上述操作如何运行,最终都要执行.
上述的4大通知,都不能控制目标方法是否执行,一般只会做程序的监控.
5.around
在目标方法执行前后 都要执行. 可以控制目标方法的执行轨迹.
5.4 AOP入门案例
5.5 代码测试理解
把控制类 ItemCatController 刚刚修改的内容还原
@RequestMapping("/item/cat/list")
public List<EasyUITree> findItemCatList(Long id){
//查询商品分类信息 1级菜单
//如果用户没有点击按钮 将不会传递Id值,应该设定默认值
long parentId = (id==null?0:id); //0 一级菜单 判断是否点击,点击了就传值
return itemCatService.findItemCatList(parentId);
//return itemCatService.findItemCatCache(parentId);
}
在jt_common中创建RedisAOP 类
package com.jt.aop;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;
@Component //将我们的对象交给Spring容器管理
@Aspect //表示AOP切面
public class RedisAop {
/**
* 1.定义切入点表达式
* bean: 被spring容器管理的对象称之为 bean
* 1.1 bean(bean的ID) 按类匹配 1个
* bean(itemCatServiceImpl)
*
* 1.2 within(包名.类名) 按类匹配 一堆
* within(com.jt.service.*)
*
* 1.3 execution(返回值类型 包名.类名.方法名(参数列表))
* execution(* com.jt.service..*.*(..)) 万能的表达式
* service. 一级
* service.. 多级
* 解释: 返回值为任意类型 com.jt.service包所有的子孙包的类
* 类中的任意方法,任意参数
* execution(Integer com.jt.service..*.add*(int)) //只能是包装类型
* execution(int com.jt.service..*.add*(int)) 只能是基本类型
*/
//@Pointcut("execution(* com.jt.service..*.*(..))")
@Pointcut("bean(itemCatServiceImpl)")
public void pointCut(){
}
//Aop如何与目标方法进行关联? JoinPoint(连接点)
//如何理解什么是连接点? 被切入点拦截的方法(连接点=方法)
//ProceedingJoinPoint is only supported for around advice
//只有环绕通知可以控制目标方法
@Before("pointCut()") //乌龟的屁股 规定
public void before(JoinPoint joinPoint){ //前置通知
//获取目标方法的名称
String methodName = joinPoint.getSignature().getName();
//获取目标类的名称
String className = joinPoint.getSignature().getDeclaringTypeName();
//获取目标的参数
Object[] args = joinPoint.getArgs();
//获取目标的对象
Object target = joinPoint.getTarget();
//输出
System.out.println(methodName);
System.out.println(className);
System.out.println(args);
System.out.println(target);
System.out.println("我是一个前置通知");
}
@Around("pointCut()")
public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
System.out.println("环绕开始");
Object result = joinPoint.proceed(); //执行下一个通知,目标方法
System.out.println("环绕结束");
return result;
}
}