1. Redis入门案例

1.1 导入jar包

<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.hc.redis;

import org.junit.jupiter.api.Test;

import redis.clients.jedis.Jedis;

import redis.clients.jedis.Transaction;

import redis.clients.jedis.params.SetParams;

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";
    int port=6379;
    Jedis jedis=new Jedis(host,port);
    //命令怎么敲，代码怎么写
    jedis.set("2021","redis入门案例");
    System.out.println(jedis.get("2021"));
    jedis.flushAll();
    //测试是否存在
    if(jedis.exists("2021")){
        jedis.del("2021");
    }else{
        jedis.set("num","100");
        //自增1
        jedis.incr("num");
        jedis.expire("num",20);
        Thread.sleep(2000);
        //检查我们的超时时间
        System.out.println(jedis.ttl("num"));
        //取消超时时间
        jedis.persist("num");
    }
}
//有时我们可能为数据添加超时时间
//原子性问题：有时业务要求要么同时完成，要么同时失败
@Test
public void testSetEx() throws InterruptedException {
Jedis jedis=new Jedis("192.168.126.129",6379);
jedis.set("a","aa");
//服务器异常
//jedis.expire("a",60);
jedis.setex("a",20,"100");
System.out.println(jedis.get("a"));

}

/**
 * 需求1：如果该数据不存在时，才会赋值
 * 需求2：如果数据存在时，进行修改，并且为他设定超时时间，满足原子性要求
 */
@Test
public void testSetNx() throws InterruptedException {
    Jedis jedis=new Jedis("192.168.126.129",6379);
    jedis.set("a","111");
    jedis.setnx("a","123");
    System.out.println(jedis.get("a"));
    //jedis.set("b","123");
    SetParams params=new SetParams();
    params.xx().ex(20);
    jedis.set("b","bb",params);

}
//默认hash是无序的
@Test
public void testHash(){
    Jedis jedis=new Jedis("192.168.126.129",6379);
    jedis.hset("user","id","100");
    jedis.hset("user","name","101");
    jedis.hset("user","age","18");
    System.out.println(jedis.hkeys("user"));
}
//队列:先进先出   方向相反
//栈: 先进后出    方向相同     注意可变参数类型
@Test
public void testList(){
    Jedis jedis=new Jedis("192.168.126.129",6379);
    jedis.lpush("list","1","2","3","4");
    System.out.println(jedis.rpop("list"));
}
@Test
public void testTx(){
    Jedis jedis=new Jedis("192.168.126.129",6379);
    //开启事务
    Transaction transaction=jedis.multi();
    try {
        transaction.set("a", "a");
        transaction.set("b", "b");
        transaction.set("b", "b");
        //提交事务
        transaction.exec();
    }catch (Exception e){
        transaction.discard();
    }
}
}

2. SpringBoot整合Redis

2.1 编辑pro配置文件

Redis入门案例(day12)1. Redis入门案例2. SpringBoot整合Redis3. JSON格式转化

2.2 编辑配置类

package com.hc.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);
}

}

3. JSON格式转化

3.1 业务说明

由于程序需要与JSON串进行数据的交互,所以通过API进行转化

3.2 代码如下

package com.hc.json;

import com.fasterxml.jackson.core.JsonProcessingException;

import com.fasterxml.jackson.databind.ObjectMapper;

import com.hc.pojo.ItemDesc;

import org.junit.jupiter.api.Test;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

public class TestJson {

/**
 * json格式:
 *  1.object格式  {key:value,key2:value2}
 *  2.数组格式    [value,value2,value3]
 *  3.嵌套格式    value可以进行嵌套.
 *
 * 任务:  实现对象与JSON串之间的转化.
 * 面试题: 常量是否有线程安全性问题??? 没有
 */
 
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());
}
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(200L).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();
String json=MAPPER.writeValueAsString(list);
System.out.println(json);
//将JSON还原回对象
List<ItemDesc> list2=MAPPER.readValue(json,List.class);
System.out.println(list2);
}

}

3.3 JSON转化工具API

说明: 在hc-common中添加工具API

package com.hc.util;

import com.fasterxml.jackson.core.JsonProcessingException;

import com.fasterxml.jackson.databind.ObjectMapper;

public class ObjectMapperUtil {

public static final ObjectMapper MAPPER=new ObjectMapper();
//1.对象转化为JSON
public static String toJSON(Object obj){
    try {
        return MAPPER.writeValueAsString(obj);
    } catch (JsonProcessingException e) {
        //将检查异常转化为运行异常
        e.printStackTrace();
        throw new RuntimeException(e);
    }
    
     }
//2.JSON转化为对象  传递什么样的类型,返回什么样的对象???
public static <T>T toObject(String json,Class<T> target){
    try {
        return MAPPER.readValue(json,target);
    } catch (JsonProcessingException e) {
        e.printStackTrace();
        throw new RuntimeException(e);
    }
}

}

4. 商品分离缓存实现

4.1 编辑工具ItemCatServiceImpl

/**
 *
 * 1.将商品分类信息添加到缓存中
 * 2.数据结构:  k-v结构   ITEM_CAT_PARENT::0 - JSON
 * 3.业务流程:
 *      1.先查缓存    true/false
 *      2.false  用户第一次查询数据库, 将结果保存到redis缓存中
 *      3.true   查询缓存
 *  AOP机制
 */
@Override
public List<EasyUITree> findItemCatCache(Long parentId) {
    long startTime=System.currentTimeMillis();
    //1.定义key
    String key="ITEM_CAT_PARENT::"+parentId;
    List<EasyUITree> treeList = new ArrayList<>();
    //2.判断数据是否存在
    if(jedis.exists(key)){
    String json=jedis.get(key);
    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效果展现

Redis入门案例(day12)1. Redis入门案例2. SpringBoot整合Redis3. JSON格式转化

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入门案例

Redis入门案例(day12)1. Redis入门案例2. SpringBoot整合Redis3. JSON格式转化

package com.hc.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.hc.service.*)
 * 1.3 execution(返回值类型 包名.类名.方法名(参数列表))
 *     execution(* com.hc.service..*.*(..))
 *     解释:  返回值为任意类型 com.hc.service包所有的子孙包的类
 *            类中的任意方法,任意参数
 *     execution(Integer com.hc.service..*.add*(int))
 *     execution(int com.hc.service..*.add*(int))
 */
@Pointcut("execution(* com.hc.service..*.*(..))")
public void pointCut(){

}

//如何理解什么是连接点? 被切入点拦截的方法
//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("我是一个前置通知");
}

}

6. 自定义注解实现缓存

控制缓存操作

如何设计自己定!!!

Redis入门案例(day12)1. Redis入门案例2. SpringBoot整合Redis3. JSON格式转化

1. Redis入门案例

1.1 导入jar包

1.2 入门案例

2. SpringBoot整合Redis

2.1 编辑pro配置文件

2.2 编辑配置类

3. JSON格式转化

3.1 业务说明

3.2 代码如下

3.3 JSON转化工具API

4. 商品分离缓存实现

4.1 编辑工具ItemCatServiceImpl

4.2 Redis效果展现

5.Spring中AOP复习

5.1 什么是AOP

5.2 切入点表达式

5.3 通知方法

5.4 AOP入门案例

6. 自定义注解实现缓存

继续阅读

关于Linux中搭建zookeeper集群说明1.安装zookeeper2.搭建集群3. zookeeper集群常见问题

SpringCloud之——Eureka服务注册与发现

Spring Cloud Alibaba全家桶（一）——Spring Cloud Alibaba介绍前言目录一、微服务介绍二、Spring Cloud Alibaba介绍三、Spring Cloud Alibaba环境搭建后记

关于Linux中安装zookeeper说明1. zookeeper介绍2. zookeeper下载 3. zookeeper安装

Spring Cloud Alibaba全家桶（三）——微服务负载均衡器Ribbon与LoadBalancer前言目录一、什么是Ribbon二、Nacos使用Ribbon三、Ribbon内核原理四、Spring Cloud LoadBalancer后记

分布式day061.解析js2. 商品后台的业务操作

关于Dubbo服务负载均衡策略1. Dubbo中LoadBanace 关系2. 负载均衡策略

SpringCloud之——Config

分布式与微服务系列（二）、分布式RPC框架Apache Dubbo服务一、 Apache Dubbo概述二、服务注册中心Zookeeper三、Dubbo快速入门四、Dubbo管理控制台