【秒杀系统】查询性能优化技术之多级缓存

多级缓存

redis缓存

减少数据库压力，减少了数据库对应磁盘的访问，缩短了平均响应时间

默认springboot自带redisTemplet不带序列化

@Component
@EnableRedisHttpSession(maxInactiveIntervalInSeconds = 3600)
public class RedisConfig {
    @Bean
    public RedisTemplate redisTemplate(RedisConnectionFactory redisConnectionFactory){
        RedisTemplate redisTemplate = new RedisTemplate();
        redisTemplate.setConnectionFactory(redisConnectionFactory);

        //首先解决key的序列化方式
        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
        redisTemplate.setKeySerializer(stringRedisSerializer);

        //解决value的序列化方式
        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper objectMapper =  new ObjectMapper();
        SimpleModule simpleModule = new SimpleModule();
        simpleModule.addSerializer(DateTime.class,new JodaDateTimeJsonSerializer());
        simpleModule.addDeserializer(DateTime.class,new JodaDateTimeJsonDeserializer());

        objectMapper.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);

        objectMapper.registerModule(simpleModule);

        jackson2JsonRedisSerializer.setObjectMapper(objectMapper);

        redisTemplate.setValueSerializer(jackson2JsonRedisSerializer);

        return redisTemplate;
    }
}

缓存热点数据

    //商品详情页浏览
    @RequestMapping(value = "/get",method = {RequestMethod.GET})
    @ResponseBody
    public CommonReturnType getItem(@RequestParam(name = "id")Integer id){
        ItemModel itemModel = null;

        //先取本地缓存
        itemModel = (ItemModel) cacheService.getFromCommonCache("item_"+id);

        if(itemModel == null){
            //根据商品的id到redis内获取
            itemModel = (ItemModel) redisTemplate.opsForValue().get("item_"+id);

            //若redis内不存在对应的itemModel,则访问下游service
            if(itemModel == null){
                itemModel = itemService.getItemById(id);
                //设置itemModel到redis内
                redisTemplate.opsForValue().set("item_"+id,itemModel);
                redisTemplate.expire("item_"+id,10, TimeUnit.MINUTES);
            }
            //填充本地缓存
            cacheService.setCommonCache("item_"+id,itemModel);
        }


        ItemVO itemVO = convertVOFromModel(itemModel);

        return CommonReturnType.create(itemVO);

    }

热点内存本地缓存

热点数据、脏读不敏感、内存可控

Guava cache

可控制的大小和超时时间

可配置的Iru策略

线程安全

//封装本地缓存操作类
public interface CacheService {
    //存方法
    void setCommonCache(String key,Object value);

    //取方法
    Object getFromCommonCache(String key);
}

@Service
public class CacheServiceImpl implements CacheService {

    private Cache<String,Object> commonCache = null;

    @PostConstruct
    public void init(){
        commonCache = CacheBuilder.newBuilder()
                //设置缓存容器的初始容量为10
                .initialCapacity(10)
                //设置缓存中最大可以存储100个KEY,超过100个之后会按照LRU的策略移除缓存项
                .maximumSize(100)
                //设置写缓存后多少秒过期
                .expireAfterWrite(60, TimeUnit.SECONDS).build();
    }

    @Override
    public void setCommonCache(String key, Object value) {
            commonCache.put(key,value);
    }

    @Override
    public Object getFromCommonCache(String key) {
        return commonCache.getIfPresent(key);
    }
}

nginx proxy cache缓存

ngijinx反向代理前置
依靠文件系统存索引|级的文件
依靠内存缓存文件地址

nginx lua缓存

lua协程机制

• 依附于线程的内存模型,切换开销小
• 遇阻塞及归还执行权,代码同步
• 无需加锁
  

nginx协程机制

nginx的每一个Worker进程都是在epoll或kqueue这种事件模型之上，封装成协程，每一个请求都有一个协程进行处理。

即使ngx_ lua须要运行Lua ，相对C有一定的开销，但依旧能保证高并发能力

nginx每个工作进程创建一个lua虚拟机，工作进程内的所有协程共享同一个vm

每个外部请求由一个lua协程处理，之间数据隔离

lua代码调用io等异步接口时，协程被挂起，上下文数据自动保存，不阻塞工作进程

io异步操作完成后还原协程上下文，代码继续执行

nginx lua插载点

OpenResty

◆ OpenResty由Nginx核心加很多第三方模块组成,默认集成了Lua开发环境,使得Nginx可以作为一个Web Server使用。

◆ 借助于Nginx的事件驱动模型和非阻塞IO ,可以实现高性能的Web应用程序。

◆ OpenResty提供 了大量组件如Mysq|、Redis、 Memcached等等使在Nginx_上开发Web应用更方便更简单。

shared dic:共享内存字典,所有worker进程可见, Iru淘汰

让访问的页面走这个nginx服务器的lua脚本，不走tomcat，免除掉tomcat一次网络RPC调用，将应用负载压力集成到 nginx 上面，缓存大小和缓存回源机制都会有短时间内的一个脏读