redis高级案列case

news2024/11/27 10:44:11

案列一 双写一致性

案例二 双锁策略

package com.redis.redis01.service;

import com.redis.redis01.bean.RedisBs;
import com.redis.redis01.mapper.RedisBsMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.beans.Transient;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;

@Slf4j
@Service
public class RedisBsService {

    //定义key前缀/命名空间
    public static final String CACHE_KEY_USER = "user:";
    @Autowired
    private RedisBsMapper mapper;
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    private static ReentrantLock lock = new ReentrantLock();

    /**
     * 业务逻辑没有写错，对于中小长(qps<=1000)可以使用，但是大厂不行：大长需要采用双检加锁策略
     *
     * @param id
     * @return
     */
    @Transactional
    public RedisBs findUserById(Integer id,int type,int qps) {
        //qps<=1000
        if(qps<=1000){
            return qpsSmall1000(id);
        }
        //qps>1000
        return qpsBig1000(id, type);
    }

    /**
     * 加强补充，避免突然key失效了，或者不存在的key穿透redis打爆mysql，做一下预防，尽量不出现缓存击穿的情况，进行排队等候
     * @param id
     * @param type 0使用synchronized重锁，1ReentrantLock轻量锁
     * @return
     */
    private RedisBs qpsBig1000(Integer id, int type) {
        RedisBs redisBs = null;
        String key = CACHE_KEY_USER + id;
        //1先从redis里面查询，如果有直接返回，没有再去查mysql
        redisBs = (RedisBs) redisTemplate.opsForValue().get(key);
        if (null == redisBs) {
            switch (type) {
                case 0:
                    //加锁，假设请求量很大，缓存过期，大厂用，对于高qps的优化，进行加锁保证一个请求操作，让外面的redis等待一下，避免击穿mysql
                    synchronized (RedisBsService.class) {
                        //第二次查询缓存目的防止加锁之前刚好被其他线程缓存了
                        redisBs = (RedisBs) redisTemplate.opsForValue().get(key);
                        if (null != redisBs) {
                            //查询到数据直接返回
                            return redisBs;
                        } else {
                            //数据缓存
                            //查询mysql，回写到redis中
                            redisBs = mapper.findUserById(id);
                            if (null == redisBs) {
                                // 3 redis+mysql都没有数据，防止多次穿透(redis为防弹衣，mysql为人，穿透直接伤人，就是直接访问mysql)，优化：记录这个null值的key，列入黑名单或者记录或者异常
                                return new RedisBs(-1, "当前值已经列入黑名单");
                            }
                            //4 mysql有，回写保证数据一致性
                            //setifabsent
                            redisTemplate.opsForValue().setIfAbsent(key, redisBs,7l, TimeUnit.DAYS);
                        }
                    }
                    break;
                case 1:
                    //加锁，大厂用，对于高qps的优化，进行加锁保证一个请求操作，让外面的redis等待一下，避免击穿mysql
                    lock.lock();
                    try {
                        //第二次查询缓存目的防止加锁之前刚好被其他线程缓存了
                        redisBs = (RedisBs) redisTemplate.opsForValue().get(key);
                        if (null != redisBs) {
                            //查询到数据直接返回
                            return redisBs;
                        } else {
                            //数据缓存
                            //查询mysql，回写到redis中
                            redisBs = mapper.findUserById(id);
                            if (null == redisBs) {
                                // 3 redis+mysql都没有数据，防止多次穿透(redis为防弹衣，mysql为人，穿透直接伤人，就是直接访问mysql)，优化：记录这个null值的key，列入黑名单或者记录或者异常
                                return new RedisBs(-1, "当前值已经列入黑名单");
                            }
                            //4 mysql有，回写保证数据一致性
                            redisTemplate.opsForValue().set(key, redisBs);
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        //解锁
                        lock.unlock();
                    }
            }
        }
        return redisBs;
    }
    private RedisBs qpsSmall1000(Integer id) {
        RedisBs redisBs = null;
        String key = CACHE_KEY_USER + id;
        //1先从redis里面查询，如果有直接返回，没有再去查mysql
        redisBs = (RedisBs) redisTemplate.opsForValue().get(key);
        if (null == redisBs) {
            //2查询mysql，回写到redis中
            redisBs = mapper.findUserById(id);
            if (null == redisBs) {
                // 3 redis+mysql都没有数据，防止多次穿透(redis为防弹衣，mysql为人，穿透直接伤人，就是直接访问mysql)，优化：记录这个null值的key，列入黑名单或者记录或者异常
                return new RedisBs(-1, "当前值已经列入黑名单");
            }
            //4 mysql有，回写保证数据一致性
            redisTemplate.opsForValue().set(key, redisBs);
        }
        return redisBs;
    }

}

案列三 mysql+redis实时同步

下载canal监控端admin和服务端deployer

https://github.com/alibaba/canal/releases/tag/canal-1.1.7

image.png

登录mysql授权canal连接mysql账户

DROP USER IF EXISTS 'canal'@'%';
CREATE USER 'canal'@'%' IDENTIFIED BY 'canal';  
GRANT ALL PRIVILEGES ON *.* TO 'canal'@'%' IDENTIFIED BY 'canal';  
FLUSH PRIVILEGES;

image.png

配置canal

修改mysql ip
image.png
启动

./startup.bat

image.png

Canal客户端（Java编写）

非springboot项目

<dependency>
    <groupId>com.alibaba.otter</groupId>
    <artifactId>canal.client</artifactId>
    <version>1.1.0</version>
</dependency>

server.port=8002
#连接数据源
spring.datasource.druid.username=root
spring.datasource.druid.password=xgm@2023..
spring.datasource.druid.url=jdbc:mysql://172.16.204.51:3306/redis?serverTimezone=GMT%2B8
spring.datasource.druid.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.druid.initial-size=5

##指定缓存类型redis
#spring.cache.type=redis
##一个小时，以毫秒为单位
#spring.cache.redis.time-to-live=3600000
##给缓存的建都起一个前缀。  如果指定了前缀就用我们指定的，如果没有就默认使用缓存的名字作为前缀,一般不指定
#spring.cache.redis.key-prefix=CACHE_
##指定是否使用前缀
#spring.cache.redis.use-key-prefix=true
##是否缓存空值，防止缓存穿透
#spring.cache.redis.cache-null-values=true


#redis
spring.redis.host=172.16.204.51
spring.redis.port=6379
spring.redis.password=123456
spring.redis.database=1


# mybatis配置
mybatis:
check-config-location: true
#  mybatis框架配置文件，对mybatis的生命周期起作用
config-location: "classpath:mybatis/mybatis-config.xml"
#  配置xml路径
mapper-locations: "classpath:mybatis/mapper/*Mapper.xml"
#  配置model包路径
type-aliases-package: "com.redis.redis01.bean.*"

#日志
logging.level.root=info
#logging.level.io.lettuce.core=debug
#logging.level.org.springframework.data.redis=debug

#canal安装地址
canal.server=172.16.204.51:11111
canal.destination=example
#控制台刷新时间，每隔5秒检查一下数据库数据是否更新 根据需求设置其他时间
canal.timeout=5
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.username=canal
spring.datasource.password=canal
spring.datasource.url=jdbc:mysql://172.16.204.51:3306/redis?autoReconnect=true&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=CONVERT_TO_NULL&useSSL=false&serverTimezone=CTT&allowMultiQueries=true

package com.redis.redis01;

import com.alibaba.otter.canal.client.CanalConnector;
import com.alibaba.otter.canal.client.CanalConnectors;
import com.alibaba.otter.canal.common.utils.AddressUtils;
import com.alibaba.otter.canal.protocol.Message;
import com.alibaba.otter.canal.client.CanalConnectors;
import com.alibaba.otter.canal.client.CanalConnector;
import com.alibaba.otter.canal.common.utils.AddressUtils;
import com.alibaba.otter.canal.protocol.Message;
import com.alibaba.otter.canal.protocol.CanalEntry.Column;
import com.alibaba.otter.canal.protocol.CanalEntry.Entry;
import com.alibaba.otter.canal.protocol.CanalEntry.EntryType;
import com.alibaba.otter.canal.protocol.CanalEntry.EventType;
import com.alibaba.otter.canal.protocol.CanalEntry.RowChange;
import com.alibaba.otter.canal.protocol.CanalEntry.RowData;
import com.google.gson.Gson;
import lombok.extern.slf4j.Slf4j;
import org.json.JSONException;
import org.json.JSONObject;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;
import redis.clients.jedis.JedisPoolConfig;

import java.net.InetSocketAddress;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.TimeUnit;
@Slf4j
public class CanalTest {
    public static final Integer _60SECONDS = 60;
    public static final String REDIS_IP_ADDR = "172.16.204.51";

    private  void redisInsert(List<Column> columns) throws JSONException {
        JSONObject jsonObject = new JSONObject();
        for (Column column : columns) {
            System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated());
            jsonObject.put(column.getName(), column.getValue());
        }
        if (columns.size() > 0) {
            try (Jedis jedis = new RedisUtils().getJedis()){
                jedis.set(columns.get(0).getValue(), jsonObject.toString());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public class RedisUtils {

        public  final String REDIS_IP_ADDR = "172.16.204.51";
        public  final String REDIS_pwd = "123456";

        public JedisPool jedisPool;

        public  Jedis getJedis() throws Exception {
            JedisPoolConfig jedisPoolConfig = new JedisPoolConfig();
            jedisPoolConfig.setMaxTotal(20);
            jedisPoolConfig.setMaxIdle(10);
            jedisPool=new JedisPool(jedisPoolConfig, REDIS_IP_ADDR,6379,10000,REDIS_pwd);
            if (null != jedisPool) {
                return jedisPool.getResource();
            }
            throw new Exception("Jedispool is not ok");
        }
    }

    private void redisDelete(List<Column> columns) throws JSONException {
        JSONObject jsonObject = new JSONObject();
        for (Column column : columns) {
            jsonObject.put(column.getName(), column.getValue());
        }
        if (columns.size() > 0) {
            try (Jedis jedis = new RedisUtils().getJedis()) {
                jedis.del(columns.get(0).getValue());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    private void redisUpdate(List<Column> columns) throws JSONException {
        JSONObject jsonObject = new JSONObject();
        for (Column column : columns) {
            System.out.println(column.getName() + " : " + column.getValue() + "    update=" + column.getUpdated());
            jsonObject.put(column.getName(), column.getValue());
        }
        if (columns.size() > 0) {
            try (Jedis jedis =new RedisUtils().getJedis()){
                jedis.set(columns.get(0).getValue(), jsonObject.toString());
                System.out.println("---------update after: " + jedis.get(columns.get(0).getValue()));
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    public  void printEntry(List<Entry> entrys) throws JSONException {
        for (Entry entry : entrys) {
            if (entry.getEntryType() == EntryType.TRANSACTIONBEGIN || entry.getEntryType() == EntryType.TRANSACTIONEND) {
                continue;
            }

            RowChange rowChage = null;
            try {
                //获取变更的row数据
                rowChage = RowChange.parseFrom(entry.getStoreValue());
            } catch (Exception e) {
                throw new RuntimeException("ERROR ## parser of eromanga-event has an error,data:" + entry.toString(), e);
            }
            //获取变动类型
            EventType eventType = rowChage.getEventType();
            System.out.println(String.format("================&gt; binlog[%s:%s] , name[%s,%s] , eventType : %s",
                    entry.getHeader().getLogfileName(), entry.getHeader().getLogfileOffset(),
                    entry.getHeader().getSchemaName(), entry.getHeader().getTableName(), eventType));

            for (RowData rowData : rowChage.getRowDatasList()) {
                if (eventType == EventType.INSERT) {
                    redisInsert(rowData.getAfterColumnsList());
                } else if (eventType == EventType.DELETE) {
                    redisDelete(rowData.getBeforeColumnsList());
                } else {//EventType.UPDATE
                    redisUpdate(rowData.getAfterColumnsList());
                }
            }
        }
    }


    public static void main(String[] args) {
        System.out.println("---------O(∩_∩)O哈哈~ initCanal() main方法-----------");

        //=================================
        // 创建链接canal服务端
        CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress(REDIS_IP_ADDR,
                11111), "example", "", "");  // 这里用户名和密码如果在这写了，会覆盖canal配置文件的账号密码，如果不填从配置文件中读
        int batchSize = 1000;
        //空闲空转计数器
        int emptyCount = 0;
        System.out.println("---------------------canal init OK，开始监听mysql变化------");
        try {
            connector.connect();
            //connector.subscribe(".*\\..*");
            connector.subscribe("redis.redis_syc");   // 设置监听哪个表
            connector.rollback();
            int totalEmptyCount = 10 * _60SECONDS;
            while (emptyCount < totalEmptyCount) {
                System.out.println("我是canal，每秒一次正在监听:" + UUID.randomUUID().toString());
                Message message = connector.getWithoutAck(batchSize); // 获取指定数量的数据
                long batchId = message.getId();
                int size = message.getEntries().size();
                if (batchId == -1 || size == 0) {
                    emptyCount++;
                    try {
                        TimeUnit.SECONDS.sleep(1);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                } else {
                    //计数器重新置零
                    emptyCount = 0;
                    new CanalTest().printEntry(message.getEntries());
                }
                connector.ack(batchId); // 提交确认
                // connector.rollback(batchId); // 处理失败, 回滚数据
            }
            System.out.println("已经监听了" + totalEmptyCount + "秒，无任何消息，请重启重试......");
        } catch (JSONException e) {
            throw new RuntimeException(e);
        } finally {
            connector.disconnect();
        }
    }

}

截图
image.png

spingboot项目

        <dependency>
            <groupId>top.javatool</groupId>
            <artifactId>canal-spring-boot-starter</artifactId>
            <version>1.2.1-RELEASE</version>
        </dependency


# canal starter配置信息
canal.server=127.0.0.1:11111
canal.destination=example

logging.level.root=info
logging.level.top.javatool.canal.client.client.AbstractCanalClient=error


package com.redis.redis01.canal;


import com.redis.redis01.bean.RedisSyc;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import top.javatool.canal.client.annotation.CanalTable;
import top.javatool.canal.client.handler.EntryHandler;

@Component
@CanalTable(value = "redis_syc")
@Slf4j
public class RedisCanalClientExample implements EntryHandler<RedisSyc> {

    @Override
    public void insert(RedisSyc redisSyc) {
        EntryHandler.super.insert(redisSyc);
        log.info("新增 ---> {}",redisSyc);
    }

    @Override
    public void update(RedisSyc before, RedisSyc after) {
        EntryHandler.super.update(before, after);
        log.info("更新前 --->{} , 更新后 --->{} ", before, after);
    }

    @Override
    public void delete(RedisSyc redisSyc) {
        EntryHandler.super.delete(redisSyc);
        log.info("删除 --->{} " , redisSyc);

    }
}

image.png

私服监听

注意：canal依赖stater在中央仓库是不存在的，需要手动放进本地仓库或者你公司里面的nexus

	<!--canal依赖-->
      <dependency>
          <groupId>com.xpand</groupId>
          <artifactId>starter-canal</artifactId>
          <version>0.0.1-SNAPSHOT</version>
      </dependency>

@SpringBootApplication
@EnableCanalClient
public class CanalApplication {
  public static void main(String[] args) {
      SpringApplication.run(CanalApplication.class,args);
  }
}

@CanalEventListener
public class CanalDataEventListener {

  /***
   * 增加数据监听
   * @param eventType
   * @param rowData
   */
  @InsertListenPoint
  public void onEventInsert(CanalEntry.EventType eventType, CanalEntry.RowData rowData) {
      rowData.getAfterColumnsList().forEach((c) -> System.out.println("By--Annotation: " + c.getName() + " ::   " + c.getValue()));
  }

  /***
   * 修改数据监听
   * @param rowData
   */
  @UpdateListenPoint
  public void onEventUpdate(CanalEntry.RowData rowData) {
      System.out.println("UpdateListenPoint");
      rowData.getAfterColumnsList().forEach((c) -> System.out.println("By--Annotation: " + c.getName() + " ::   " + c.getValue()));
  }

  /***
   * 删除数据监听
   * @param eventType
   */
  @DeleteListenPoint
  public void onEventDelete(CanalEntry.EventType eventType) {
      System.out.println("DeleteListenPoint");
  }

  /***
   * 自定义数据修改监听
   * @param eventType
   * @param rowData
   */
  @ListenPoint(destination = "example", schema = "torlesse_test", table = {"tb_user", "tb_order"}, eventType = CanalEntry.EventType.UPDATE)
  public void onEventCustomUpdate(CanalEntry.EventType eventType, CanalEntry.RowData rowData) {
      System.err.println("DeleteListenPoint");
      rowData.getAfterColumnsList().forEach((c) -> System.out.println("By--Annotation: " + c.getName() + " ::   " + c.getValue()));
  }


  @ListenPoint(destination = "example",
          schema = "test_canal", //所要监听的数据库名
          table = {"tb_user"}, //所要监听的数据库表名
          eventType = {CanalEntry.EventType.UPDATE, CanalEntry.EventType.INSERT, CanalEntry.EventType.DELETE})
  public void onEventCustomUpdateForTbUser(CanalEntry.EventType eventType, CanalEntry.RowData rowData){
      getChangeValue(eventType,rowData);
  }

  public static void getChangeValue(CanalEntry.EventType eventType, CanalEntry.RowData rowData){
      if(eventType == CanalEntry.EventType.DELETE){
          rowData.getBeforeColumnsList().forEach(column -> {
              //获取删除前的数据
              System.out.println(column.getName() + " == " + column.getValue());
          });
      }else {
          rowData.getBeforeColumnsList().forEach(column -> {
              //打印改变前的字段名和值
              System.out.println(column.getName() + " == " + column.getValue());
          });

          rowData.getAfterColumnsList().forEach(column -> {
              //打印改变后的字段名和值
              System.out.println(column.getName() + " == " + column.getValue());
          });
      }
  }
}

案列四 统计千亿级别PV

UV: Unique Visitor ,独立访客数，是指在一个统计周期内，访问网站的人数之和。一般理解客户ip，需要去重
PV : Page View，浏览量，是指在一个统计周期内，浏览页面的数之和。不需要去重
DAU: Daily Active User 日活跃用户数量；去重
DNU：Daily New User，日新增用户数
MAU：Monthly New User，月活跃用户；去重
需要使用redis hyperloglog基数统计数据结构来实现
基数统计：数据集中不重复的元素的个数

模拟后台1万用户点击首页

package com.redis.redis01.service;

import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.StopWatch;
import javax.annotation.Resource;
import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

@Slf4j
@Service
public class HyperLogService {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    /**
     * 模拟后台1万用户点击首页，每个用户来自不同的ip地址
     */
    public void hyperloglogUvTest() {
        StopWatch stopWatch=new StopWatch();
        stopWatch.start();
        CountDownLatch countDownLatch=new CountDownLatch(10000);
        //主子线程传递共享连接资源redisTemplate
        ExecutorService executorService = Executors.newFixedThreadPool(200);
        executorService.execute(new Runnable() {
            @Override
            public void run() {
                //模拟1万用户
                for (int i = 0; i < 10000; i++) {
                    countDownLatch.countDown();
                    Random random = new Random();
                    String ipAddress = random.nextInt(256)
                            + "." + random.nextInt(256)
                            + "." + random.nextInt(256)
                            + "." + random.nextInt(256);
                   redisTemplate.opsForHyperLogLog().add("uv_click", ipAddress);
                    System.out.println("countDownLatch=" + countDownLatch.getCount());

                }
            }
        });
        try {
            countDownLatch.await();
            stopWatch.stop();
            Long uvClick1 = redisTemplate.opsForHyperLogLog().size("uv_click");
            //用户访问首页次数uv=10059
            System.out.println("用户访问首页次数uv=" + uvClick1);
            //共耗时=3:秒
            System.out.println("共耗时=" + stopWatch.getTotalTimeMillis()/1000+":秒");
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

    }
}

image.png

案列五 布隆过滤器方案实现

利用bitmap实现，一个bitmap=2^32bit最大能存512M，一个用户一天签到用1个bit，一年365个bit就可以实现，1千万个用户一年只需要435MB还不到一个bitmap最大存储能力
优点

  • 高效地插入和查询，内存占用 bit 空间少

缺点

  • 不能删除元素
    • 因为删除元素会导致误判率增加，因为hash冲突同一个位置可能存的东西是多个共有的，你删除一个元素的同时可能也把其他的删除了
  • 存在误判，不能精准过滤
    • 有，可能有
    • 无，绝对无
package com.redis.redis01.service;

import com.google.common.collect.Lists;
import com.redis.redis01.bean.RedisBs;
import com.redis.redis01.mapper.RedisBsMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.locks.ReentrantLock;

@Slf4j
@Service
public class BitmapService {
    @Resource
    private RedisTemplate<String, Object> redisTemplate;
    private static ReentrantLock lock = new ReentrantLock();
    @Autowired
    private RedisBsMapper redisBsMapper;

    /**
     * 场景一：布隆过滤器解决缓存穿透问题(null/黑客攻击)；利用redis+bitmap实现
     * 有可能有，没有一定没有
     *                                                    无-------------》mysql查询
     *                     有--------》redis查询----------》有-----------》返回
     * 请求-----》布隆过滤器-----------》
     *                      无-------终止
     *
     * @param type:0初始化，1常规查询
     */
    public void booleanFilterBitmap(int type, Integer id) {
        
        switch (type) {
            case 0://初始化数据
                for (int i = 0; i < 10; i++) {
                    RedisBs initBs = RedisBs.builder().id(i).name("赵三" + i).phone("1580080569" + i).build();
                    //1 插入数据库
                    redisBsMapper.insert(initBs);
                    //2 插入redis
                    redisTemplate.opsForValue().set("customer:info" + i, initBs);
                }
                //3 将用户id插入布隆过滤器中,作为白名单
                for (int i = 0; i < 10; i++) {
                    String booleanKey = "customer:booleanFilter:" + i;
                    //3.1 计算hashvalue
                    int abs = Math.abs(booleanKey.hashCode());
                    //3.2 通过abs和2的32次方取余，获得布隆过滤器/bitmap对应的下标坑位/index
                    long index = (long) (abs % Math.pow(2, 32));
                    log.info("坑位:{}", index);
                    //3.3 设置redis里面的bitmap对应类型的白名单
                    redisTemplate.opsForValue().setBit("whiteListCustomer", index, true);
                }
                break;
            case 1://常规查询
                //1 获取当前传过来的id对应的哈希值
                String inputBooleanKey = "customer:booleanFilter:" + id;
                int abs = Math.abs(inputBooleanKey.hashCode());
                long index = (long) (abs % Math.pow(2, 32));
                Boolean whiteListCustomer = redisTemplate.opsForValue().getBit("whiteListCustomer", index);
                //加入双检锁
                //加锁，大厂用，对于高qps的优化，进行加锁保证一个请求操作，让外面的redis等待一下，避免击穿mysql
                lock.lock();
                try {
                    if (null == whiteListCustomer) {
                        whiteListCustomer = redisTemplate.opsForValue().getBit("whiteListCustomer", index);
                        if (null != whiteListCustomer && whiteListCustomer) {//布隆过滤器中存在，则可能存在
                            //2 查找redis
                            Object queryCustomer = redisTemplate.opsForValue().get("customer:info" + id);
                            if (null != queryCustomer) {
                                log.info("返回客户信息:{}", queryCustomer);
                                break;
                            } else {
                                //3 redis没有查找mysql
                                RedisBs userById = redisBsMapper.findUserById(id);
                                if (null != userById) {
                                    log.info("返回客户信息:{}", queryCustomer);
                                    redisTemplate.opsForValue().set("customer:info" + id, userById);
                                    break;
                                } else {
                                    log.info("当前客户信息不存在:{}", id);
                                    break;
                                }
                            }
                        } else {//redis没有，去mysql中查询
                            //3 redis没有查找mysql
                            RedisBs userById = redisBsMapper.findUserById(id);
                            if (null != userById) {
                                log.info("返回客户信息:{}", userById);
                                redisTemplate.opsForValue().set("customer:info" + id, userById);
                                break;
                            } else {
                                log.info("当前客户信息不存在:{}", id);
                                break;
                            }
                        }

                    }
                } finally {
                    lock.unlock();
                }
                log.info("当前客户信息不存在:{}", id);

                break;
            default:
                break;
        }
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1218959.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

HT8313 D/AB切换 音频功率放大器

HT8313 D/AB切换 音频功率放大器

HT8313具有AB类和D类的自Y切换功能&#xff0c;在受到D类功放EMI干扰困扰时&#xff0c;可随时切换至AB类音频功放模式&#xff08;此时电荷泵升压功能关闭&#xff09;。 HT8313内部固定28dB增益&#xff0c;内置的关断功能使待机电流Z小化&#xff0c;还集成了输出端过流保护…
阅读更多...
翻转链表（图解）

翻转链表（图解）

LCR 024. 反转链表 - 力扣&#xff08;LeetCode&#xff09; 题目描述 给定单链表的头节点 head &#xff0c;请反转链表&#xff0c;并返回反转后的链表的头节点。 样例输入 示例 1&#xff1a; 输入&#xff1a;head [1,2,3,4,5] 输出&#xff1a;[5,4,3,2,1]示例 2&…
阅读更多...
中欧之间，从此万里有云桥

中欧之间，从此万里有云桥

相传在1271年&#xff0c;马可波罗跟随父亲和叔叔前往中国&#xff0c;他们在海上漂泊了足足四年&#xff0c;才最终抵达元大都。从此之后&#xff0c;欧亚大陆的两端在数百年间发生了一系列故事。而海上船只&#xff0c;始终是穿行中欧的交通方式。 直到20世纪&#xff0c;两座…
阅读更多...
git 指定时间代码统计

git 指定时间代码统计

指定时间代码统计 用法 13 - 17 号 代码情况 近一周 git log --since2023-11-13 00:00:00 --until2023-11-17 23:00:00 --prettytformat: --numstat | awk { add $1; subs $2; loc $1 - $2 } END { printf "added lines: %s, removed lines: %s,total lines: %s\n&…
阅读更多...
OmniGraffle Pro v7.22.3(流程图UML图)

OmniGraffle Pro v7.22.3(流程图UML图)

OmniGraffle Pro是一款非常棒的绘图软件&#xff0c;具有多种功能&#xff0c;包括&#xff1a; 绘制图表&#xff1a;OmniGraffle Pro可以创建各种类型的图表&#xff0c;包括流程图、组织图、UML图、网络图等等。它还支持导入和导出多种文件格式&#xff0c;如PDF、SVG、Vis…
阅读更多...
怎么去掉邮件内容中的回车符

怎么去掉邮件内容中的回车符

上图是Outlook 截图&#xff0c;可见1指向的总有回车符&#xff1b; 故障原因&#xff1a; 不小心误按了箭头4这个选项&#xff1b; 解决方法&#xff1a; 点击2箭头确保tab展开&#xff1b; 点击3以找到箭头4. 取消勾选或者多次点击&#xff0c;即可解决。
阅读更多...
Linux - 用户级缓冲区和系统缓冲区 - 初步理解Linux当中文件系统

Linux - 用户级缓冲区和系统缓冲区 - 初步理解Linux当中文件系统

前言 文件系统 我们先来看两个例子&#xff1a; 这个程序输出&#xff1a; 此时的输出也满足的我们预期。 我们也可以把 程序执行结果&#xff0c;输出重定向到 一个文件当中: 当我们在代码的结尾处&#xff0c;创建了子进程&#xff0c;那么输出应该还是和上述是一样的&…
阅读更多...
Vue bus事件总线的原理与使用

Vue bus事件总线的原理与使用

这里写自定义目录标题 一、 Vue Bus 总线原理二、Vue bus的使用1、创建总线&#xff1a; 在 Vue 应用中&#xff0c;可以创建一个 Vue 实例作为总线&#xff0c;用于管理事件。2、事件的发布与订阅&#xff1a; 组件通过订阅事件来监听总线上的消息&#xff0c;而其他组件则通过…
阅读更多...
Azure 机器学习：使用 Azure 机器学习 CLI、SDK 和 REST API 训练模型

Azure 机器学习：使用 Azure 机器学习 CLI、SDK 和 REST API 训练模型

目录 环境准备克隆示例存储库 示例案例在云中训练1.连接到工作区PythonAzure CLIREST API 2. 创建用于训练的计算资源4. 提交训练作业PythonAzure CLIREST API 注册已训练的模型PythonAzure CLIREST API Azure 机器学习提供了多种提交 ML 训练作业的方法。 在本文中&#xff0c…
阅读更多...
【linux】查看CPU的使用率

【linux】查看CPU的使用率

命令1&#xff1a;top top 总体系统信息 uptime&#xff1a;系统的运行时间和平均负载。tasks&#xff1a;当前运行的进程和线程数目。CPU&#xff1a;总体 CPU 使用率和各个核心的使用情况。内存&#xff08;Memory&#xff09;&#xff1a;总体内存使用情况、可用内存和缓存…
阅读更多...
监控直流防雷浪涌保护器综合方案

监控直流防雷浪涌保护器综合方案

监控系统是一种广泛应用于安防、交通、工业、军事等领域的信息系统&#xff0c;它通过摄像机、传输线路、监控中心等设备&#xff0c;实现对目标区域的实时监视和控制。然而&#xff0c;监控系统也面临着雷电的威胁&#xff0c;雷电可能通过直击雷、感应雷、雷电波侵入等途径&a…
阅读更多...
储能领域 / 通讯协议 / 技术栈 等专有名字集锦——主要收集一些储能领域的专有名词，以及相关的名词

储能领域 / 通讯协议 / 技术栈 等专有名字集锦——主要收集一些储能领域的专有名词，以及相关的名词

目录 名词解释ModbusIOT设备通讯协议 CAN/ RS-485 储能术语电池管理系统BMS电池储能系统相关概念&#xff0c;总控&#xff0c;主控&#xff0c;从控 电池相关知识拆解电池的构成逆变器 电池核心参数SOC 电池剩余容量 名词解释 英文中文biz layer业务层与业务层通信的服务CRC循…
阅读更多...
GAT里面的sofamax函数的实现：

GAT里面的sofamax函数的实现：

1.sofamx 公式&#xff1a; 2. GAT里的sofamax函数的实现&#xff1a; 1. 因为指数在x轴正轴爆炸式地快速增长&#xff0c;如果zi比较大&#xff0c;exp⁡(zi)也会非常大&#xff0c;得到的数值可能会溢出。溢出又分为下溢出&#xff08;Underflow&#xff09;和上溢出&#x…
阅读更多...
当攻防演练已成常态，企业应该相信西医还是老中医？

当攻防演练已成常态，企业应该相信西医还是老中医？

在面对疾病时&#xff0c;很多人常常会犹豫不决&#xff0c;不知道应该选择中医还是西医进行治疗。与疾病斗争的过程也是一场“战斗”&#xff0c;需要选择合适的“武器”和策略。有些人认为西医疗效快&#xff0c;能够迅速缓解症状&#xff1b;而另一些人则认为中医治疗更根本…
阅读更多...
llvm源码windows编译

llvm源码windows编译

1.克隆llvm源码： git clone --config core.autocrlf=false https://github.com/llvm/llvm-project.git 2.创建build文件夹并生成makefile 生成前置条件： cmake ,ninja,python3要先安装 cmake -S llvm -B build -G Ninja -DCMAKE_BUILD_TYPE=Release 生成成功 3.编译 进…
阅读更多...
如何用AB测试完善产品激励体系

如何用AB测试完善产品激励体系

更多技术交流、求职机会&#xff0c;欢迎关注字节跳动数据平台微信公众号&#xff0c;回复【1】进入官方交流群 用户激励体系&#xff0c;也称用户激励机制&#xff0c;是为了让用户持续使用产品&#xff0c;而设计的一套对应规则。在用户激励体系建立过程中&#xff0c;产品可…
阅读更多...
linux、windows 查看java等进程占用资源情况

linux、windows 查看java等进程占用资源情况

linux查看进程占用资源情况&#xff1a; top -o %MEM -b -n 1 | grep java | awk {print "PID: "$1" \t 虚拟内存: "$5" \t 物理内存: "$6" \t 共享内存: "$7" \t CPU使用率: "$9"% \t 内存使用率: "$10"%&…
阅读更多...
护眼台灯选购注意事项？考公专用护眼台灯推荐

护眼台灯选购注意事项？考公专用护眼台灯推荐

随着科技的发展和进步&#xff0c;台灯的外观也不在和以往一般笨重&#xff0c;而是变得越来越美观&#xff0c;而且也更方便了&#xff0c;功能也越来越多元化了。台灯作为现在我们日常学习、阅读、办公必备的一盏照明灯具&#xff0c;其光源的舒适度是非常重要的。那么挑选台…
阅读更多...
新生儿早产：原因、科普和注意事项

新生儿早产：原因、科普和注意事项

引言&#xff1a; 新生儿早产是指婴儿在孕期不满37周就出生的情况&#xff0c;这对于新生儿的健康和发育可能产生一定的影响。了解新生儿早产的原因以及如何正确应对是非常关键的。本文将科普新生儿早产的原因&#xff0c;提供相关信息&#xff0c;并为父母和监护人提供注意事…
阅读更多...
JAVAEE初阶 计算机如何工作

JAVAEE初阶 计算机如何工作

计算机的工作 一.冯诺依曼体系二.CPU基本工作流程1.逻辑门1.1电子开关1.2门电路 2.算术逻辑单元2.1 进制的理解2.2 算术单元2.3逻辑单元 3.寄存器和内存4.控制单元5.指令 一.冯诺依曼体系 二.CPU基本工作流程 1.逻辑门 1.1电子开关 1.2门电路 1.非门 2.与门 3.或门 4.异或…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023