微服务20_多级缓存01：JVM进程缓存

最新推荐文章于 2024-03-29 07:00:00 发布
最新推荐文章于 2024-03-29 07:00:00 发布
阅读量4.3k 收藏 6
点赞数 1
分类专栏： 微服务技术栈 文章标签： springboot
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43989347/article/details/123986544
版权

微服务20_多级缓存01：JVM进程缓存

前言：什么是多级缓存？

缓存的作用是减轻数据库的压力，缩短服务相应的时间，从而提高整个并发的能力，Redis单节并发以及很高了，但是依然有上限，随着互联网的发展，用户体量越来越大，比如淘宝京东的流量能达到数亿级别的流量。那么多级缓存就是为了应对多级缓存高并发。

1、传统缓存的问题：

用户请求到达Tomcat服务器，然后优先查询redis，如果redis命中，直接返回。未命中就访问数据库。 也能很大的程度减少数据库压力。

问题：

  1. 用户请求直接进入Tomcat，再去redis查询。而Tomcat并发能力不如redis。从而Tomcat的并发性能成为了整个系统的瓶颈。
  2. redis有淘汰策略，所以说缓存有过期的可能性。当redis缓存失效时，例如雪崩、穿透情况，造成大量请求到达数据库。

2、多级缓存方案

多级缓存就是充分利用请求处理的每个缓存，分别添加缓存，减轻Tomcat的压力，提升服务性能：

  • 第一级缓存：用户通过手机访问浏览器得到渲染。 浏览器缓存。

因为浏览器可以把返回的静态资源缓存到本地的，那么下次用户访问服务器时，只需要检查有没有变化，没有变化服务器直接返回304状态码，不用返回数据了。304：说明本地有。直接渲染本地存着的页面。 减少数据的传输，提高渲染和相应的速度。

  • 第二级缓存：Nginx本地缓存。浏览器本地缓存未成功，请求Nginx服务器.Ngin之前是用来做请求代理。在这里形成第二级缓存，称为Nginx本地缓存。 也可以做业务的编写。那么将数据缓存到nging本地，用户请求来了，如果有直接返回，不用到达Tomcat。

在Nginx内部去实现对redis、Tomcat的访问等等的编写，不再单单是业务代理服务器了，变成了web业务服务了，在里面写业务逻辑了。
做成集群：一个Nginx做反向代理，集群做本地缓存，做业务的Nginx的服务器。

  • 第三级缓存：redis缓存。
  • 第四级缓存：Tomcat进程缓存。
  • 第五级缓存：最后到达数据库缓存。

解决的问题：

  1. 大多数请求由Ngin来进行处理了，减少了对Tomcat的处理，从而Tomcat不会成为服务器的瓶颈了。
  2. Tomcat也有进程缓存，很大程度减少对数据库的查询

在这里插入图片描述

一、JVM进程缓存（Tomcat内部编写进程缓存）

Tomcat服务内部添加缓存， 业务进来以后优先查询进程缓存，缓存未命中，在去查数据库。
在这里插入图片描述

1、导入商品案例

1.安装mysql

后期做数据同步需要用到MySQL的主从功能，所以需要大家在虚拟机中，利用Docker来运行一个MySQL容器。

  1. 先进行将mysql5.7.25版本的mysql压缩包，放到Linux中，进行解压
  2. 准备挂载容器。为了方便后期配置MySQL，我们先准备两个目录，用于挂载容器的数据和配置文件目录：
# 进入/tmp目录
cd /tmp
# 创建文件夹
mkdir mysql
# 进入mysql目录
cd mysql
  1. 运行docker命令，运行mysql 。进入mysql目录后，执行下面的Docker命令：
    推荐在/tmp/mysql的文件下，运行下面的命令： 因为指定挂载路径是：$pwd。当前路径下创建文件，并挂载。
docker run \
 -p 3306:3306 \
 --name mysql \
 -v $PWD/conf:/etc/mysql/conf.d \
 -v $PWD/logs:/logs \
 -v $PWD/data:/var/lib/mysql \
 -e MYSQL_ROOT_PASSWORD=123 \
 --privileged \
 -d \
 mysql:5.7.25

docker查看当前运行的容器。docker ps-a是查看所有容器

  1. 修改配置：添加字符集
    在/tmp/mysql/conf目录添加一个my.cnf文件，作为mysql的配置文件：
[mysqld]
skip-name-resolve
character_set_server=utf8
datadir=/var/lib/mysql
server-id=1000

添加后：并重启mysql： docker restart mysql

  1. 用navicat连接虚拟机的数据库：
    在这里插入图片描述
    创建表名：heima
    表字段分析：
  • 商品信息表：
CREATE TABLE `tb_item` (
  `id` bigint(20) NOT NULL AUTO_INCREMENT COMMENT '商品id',
  `title` varchar(264) NOT NULL COMMENT '商品标题',
  `name` varchar(128) NOT NULL DEFAULT '' COMMENT '商品名称',
  `price` bigint(20) NOT NULL COMMENT '价格（分）',
  `image` varchar(200) DEFAULT NULL COMMENT '商品图片',
  `category` varchar(200) DEFAULT NULL COMMENT '类目名称',
  `brand` varchar(100) DEFAULT NULL COMMENT '品牌名称',
  `spec` varchar(200) DEFAULT NULL COMMENT '规格',
  `status` int(1) DEFAULT '1' COMMENT '商品状态 1-正常，2-下架，3-删除',
  `create_time` datetime DEFAULT NULL COMMENT '创建时间',
  `update_time` datetime DEFAULT NULL COMMENT '更新时间',
  PRIMARY KEY (`id`) USING BTREE,
  KEY `status` (`status`) USING BTREE,
  KEY `updated` (`update_time`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=50002 DEFAULT CHARSET=utf8 ROW_FORMAT=COMPACT COMMENT='商品表';
  • 库存信息表：
CREATE TABLE `tb_item_stock` (
  `item_id` bigint(20) NOT NULL COMMENT '商品id，关联tb_item表',
  `stock` int(10) NOT NULL DEFAULT '9999' COMMENT '商品库存',
  `sold` int(10) NOT NULL DEFAULT '0' COMMENT '商品销量',
  PRIMARY KEY (`item_id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 ROW_FORMAT=COMPACT;

为什么要做两张表格呢？
一个商品的数量是非常多的。
一方面数据解耦，字段太多查询效率太低了。
另一方面需要数据需要缓存，那么一条整个数据去做缓存，如果一个字段做了修改，那么整条数据全部失效了，就得所有信息都得去数据库做加载。

例如：将所有信息存入一张表中，那么库存改了以后，就得重新加载该条数据。 那么如果将分为多个表，当库存修改了以后，只需要将库存表进行加载即可，不需要获取所有的商品信息了。

2.导入Demo

基于mybatis-plus快速实现单表的增删改查：

  • 分页查询商品
  • 新增商品
  • 修改商品
  • 修改库存
  • 删除商品
  • 根据id查询商品
  • 根据id查询库存

在这里插入图片描述

  1. application.yml文件：
    mysql放到了Linux的docker中了，所以说：
    数据库的URL：是自己虚拟机的ip地址。
    在这里插入图片描述
    需要修改为自己的虚拟机地址信息、还有账号和密码。

修改后，启动服务，访问：http://localhost:8081/item/10001即可查询数据

3. 商品查询页面 来调用controller的接口

商品查询是购物页面，与商品管理的页面是分离的。
商品查询页面放在Nginx反向代理服务器上面，作为静态资源服务器，用户来请求商品页面的时候，Nginx返给用户。先返回的只是静态页面，数据再从后台查询了【Nginx本地、redis、Tomcat、数据库】
部署方式如图：
在这里插入图片描述

我们需要准备一个反向代理的nginx服务器，来部署静态资源。如上图红框所示，将静态的商品页面放到nginx目录中。
页面需要的数据通过ajax向服务端（nginx业务集群）查询。

将其拷贝到一个非中文目录下，运行这个nginx服务。

运行命令：

start nginx.exe

然后访问 http://localhost/item.html?id=10001即可：

localhost 访问的是Nginx
item.html 访问的商品页面
id=10001 是具体的商品
在这里插入图片描述

请求地址是：localhost/api/item/10001
并没有添加端口，请求到了80端口的nginx服务器了

用户请求被Nginx反向代理拿到了，它不处理，而是代理到nginx业务集群中去，在去做多级缓存。 所以要完成反向代理的配置

在这里插入图片描述

4.反向代理的配置：

nginx/conf/nginx.conf

location /api
以api开头的请求，就被Nginx配置拦截到了，反向代理到负载均衡的配置：http://nginx-cluster
nginx-cluster：是业务集群，本地缓存、redis缓存、Tomcat缓存

现在，页面是假数据展示的。我们需要向服务器发送ajax请求，查询商品数据。

打开控制台，可以看到页面有发起ajax查询数据：
而这个请求地址同样是80端口，所以被当前的nginx反向代理了。
查看nginx的conf目录下的nginx.conf文件：

在这里插入图片描述


#user  nobody;
worker_processes  1;

events {
    worker_connections  1024;
}

http {
    include       mime.types;
    default_type  application/octet-stream;

    sendfile        on;
    #tcp_nopush     on;
    keepalive_timeout  65;
	
	# nginx的业务集群，做Nginx本地缓存、redis缓存、Tomcat缓存
    upstream nginx-cluster{
        server 192.168.75.111:8081;
    }
    server {
        listen       80;
        server_name  localhost;

	location /api {
            proxy_pass http://nginx-cluster;
        }

        location / {
            root   html;
            index  index.html index.htm;
        }

        error_page   500 502 503 504  /50x.html;
        location = /50x.html {
            root   html;
        }
    }
}

了解本地缓存和分布式缓存

缓存在日常开发中启动至关重要的作用，由于是存储在内存中，数据的读取速度非常快的，能大量减少对数据库的访问，减少数据库的压力。我们把缓存分为两类：

分布式缓存：例如redis

  • 优点：存储量更大、可靠性更好、可以在集群间共享。
  • 缺点：访问缓存有网咯开销。

独立于Tomcat之外的，Tomcat访问redis时要发起网络请求，所以说有网络开销。

  • 场景：缓存数量较大、可靠性要求高、需要在集群间共享

进程本地缓存：例如hashMap、GuavaCache

  • 优点：读取本地内存，没有网络开销，速度更快。
  • 缺点：存储容量有限，可靠性较低、无法共享
  • 场景：性能要求较高，缓存数据量较小

2、初始Caffeine

专业的进程缓存技术。

Caffeine是一个基于java8开发的，提供了近乎最佳命中率的高性能的本地缓存。目前Spring内部的缓存使用的就是Caffeine。
官网：ttps://github.com/ben-manes/caffeine
官方读写性能测试：
在这里插入图片描述
通过下面的例子进行学习Caffeine的使用：

    /*
      基本用法测试
     */
    @Test
    void testBasicOps() {
        // 创建缓存对象 。 创建工厂，在build构建出缓存对象。
        Cache<String, String> cache = Caffeine.newBuilder().build();

        // 存数据 gril frend女朋友的意思  key,value的形式
        cache.put("gf", "迪丽热巴");

        // 取数据，不存在则返回null
        String gf = cache.getIfPresent("gf");
        System.out.println("gf = " + gf);

        // 取数据，不存在则去数据库查询
        // 根据Key查缓存未命中，再去查数据库。存入数据库、在返回
        String defaultGF = cache.get("defaultGF", key -> {
            // 这里可以去数据库根据 key查询value
            return "柳岩";
        });
        System.out.println("defaultGF = " + defaultGF);
    }

Caffeine既然是缓存的一种，肯定需要有缓存的清除策略，不然的话内存总会有耗尽的时候。

Caffeine提供了三种缓存驱逐策略：

  • 方法一：基于容量：设置缓存的数量上限
  // 创建缓存对象
  Cache<String, String> cache = Caffeine.newBuilder()
      .maximumSize(1) // 设置缓存大小上限为 1
      .build();

在这里插入图片描述

  • 方法二：基于时间：设置缓存的有效时间
// 创建缓存对象
Cache<String, String> cache = Caffeine.newBuilder()
   // 设置缓存有效期为 10 秒，从最后一次写入开始计时 
   .expireAfterWrite(Duration.ofSeconds(10)) 
   .build();

在这里插入图片描述

  • 方法三：基于引用：设置缓存为软引用或弱引用，利用GC来回收缓存数据。性能较差，不建议使用。

注意：在默认情况下，当一个缓存元素过期的时候，Caffeine不会自动立即将其清理和驱逐。而是在一次读或写操作后，或者在空闲时间完成对失效数据的驱逐。

3、实现进程缓存

案例：实现商品的查询本地进程缓存
利用Caffeien实现下列需求：

  • 给根据id查询商品的业务添加缓存，缓存未命中时查询数据库
  • 给根据id查询商品库存的业务添加缓存，缓存未命中时查询数据库
  • 缓存初始大小为100
  • 缓存上限为10000
  1. 添加Bean对象Cache
    首先，我们需要定义两个Caffeine的缓存对象，分别保存商品、库存的缓存数据。

在item-service的com.heima.item.config包下定义CaffeineConfig类：

package com.heima.item.config;

import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.heima.item.pojo.Item;
import com.heima.item.pojo.ItemStock;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class CaffeineConfig {

    @Bean
    public Cache<Long, Item> itemCache(){
        return Caffeine.newBuilder()
                //  初始化大小为100
                .initialCapacity(100)
                // 上限是10000，分隔符方便读数据
                .maximumSize(10_000)
                .build();
    }
    
    @Bean
    public Cache<Long, ItemStock> itemStockCache(){
        return Caffeine.newBuilder()
                .initialCapacity(100)
                .maximumSize(10_000)
                .build();
    }
}
  1. 修改controller类，先进行缓存中拿数据，未中再去数据库拿数据，如果拿到数据后放到缓存后，在返回用户数据。
    然后，修改item-service中的com.heima.item.web包下的ItemController类，添加缓存逻辑：
    @Autowired
    private Cache<Long,Item> itemCache;
    @Autowired
    private Cache<Long,ItemStock> itemStockCache;
    //根据id查询商品
    @GetMapping("/{id}")
    public Item findById(@PathVariable("id") Long id){
        //  .get(先去缓存查数据，未中去数据库查缓存） key==id
        return itemCache.get(id,key->itemService.query()
                // ne 是不等于。状态码不等于3的
                .ne("status", 3)
                //eq 是等于 数据库中的“id"  == key 也就是等等与前端传过来的Id
                .eq("id", key)
                // 查一条数据过来
                .one()
        );
    }

    //根据id查询库存
    @GetMapping("/stock/{id}")
    public ItemStock findStockById(@PathVariable("id") Long id){
        return itemStockCache.get(id,key->stockService.getById(key));
    }
}

测试：

当添加缓存之前，每当刷新一下页面，就会去数据库进行查询一次：
在这里插入图片描述
添加缓存之后，只去数据库查询一次，再重新刷新页面，不会去数据库进行查询了，而是直接返回缓存信息即可。
在这里插入图片描述
在这里插入图片描述

BigTree的学习之路
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
redis多级缓存搭建资料
05-31
在大型系统中，构建多级缓存架构是常见的优化策略，它能够更有效地利用资源，减少对主数据库的压力。本资料将详细介绍如何使用Redis搭建多级缓存。 一、缓存基础知识 缓存是一种存储技术，用于临时存储经常访问的...
java缓存管理，一级缓存和二级缓存
Luffyying的博客
03-30 3182
一级缓存的生命周期和SqlSession的生命周期相同 二级缓存和整个应用的生命周期相同 一级缓存存放的结果不是查询出的结果本身，而是一个Map【无法关闭 //一级缓存中底层实现是一个Map //key：statementId和sql语句 //value：查询结果 //包含查询结果本身，还和sql语句statement的ID有关系 增删改会刷新一级缓存 执行插入会对缓存造成影响，无论是否对sqlSession进行提交 配置二级缓存的时候，要在对应的xml文件中配置 二级缓存的配置：映射文件的总开关，主配置
JVM的缓存机制(案例)
Yang_1103002408的博客
05-04 1543
JVM缓存机制原因:JVM的缓存机制所导致. 下面先来看一些Java 测试代码。 //第一组 Integer num1 = 127; Integer num2 = 127; System.out.println(num1 == num2); //------------------------------------ //第...
应用程序二级缓存的原理和基本实现
qq_42697271的博客
06-19 666
笔者最近自己实现了一遍二级缓存，对其中的一些原理有了一些体悟，在这里记录一下，当然如果有错误之处，还望各位看官不吝指教 目录一、二级缓存的实现原理二、二级缓存的简单实现1、需要依赖2、简单的实现 一、二级缓存的实现原理 二、二级缓存的简单实现 1、需要依赖 在这里插入代码片 2、简单的实现 在这里插入代码片 ...
JAVA系列：JVM内存模型之缓存一致性协议
NIO4444
09-09 1449
目录 线程之间的通信 线程之间的同步 主内存和工作内存 缓存一致性协议 总线锁 缓存锁 缓存一致性协议 CPU的优化执行 并发编程的问题 硬件架构 三大特征 原子性（Atomicity） 可见性 有序性 线程之间的通信 线程的通信是指线程之间以何种机制来交换信息。 在命令式编程中，线程之间的通信机制有两种：共享内存和消息传递。 在共享内存的并发模型里，线程之间共享程序的公共状态，线程之间通过写-读内存中的公共状态来隐式进行通信，典型的共享内存通信方式就是通过共享对.
Mybatis | Mybatis 一级缓存、二级缓存、三级自定义缓存(Redis)
苏老师的博客
11-04 7650
Mybatis 的一级缓存与二级缓存 以及自定义缓存 sqlsession mapper mybatis-redis mybatis+redis
多级缓存.pdf
最新发布
06-10
### 多级缓存详解 #### 1. 什么是多级缓存？ 多级缓存是一种高级缓存机制，旨在通过在系统中的不同层级实施缓存策略，来提高整体性能和响应时间。传统缓存策略通常较为单一，比如在收到请求后首先检查Redis缓存，...
大促多级缓存方案及库存并发操作方案.docx
12-27
在大促活动中，为了应对高并发的读取需求，多级缓存方案是解决的关键。这一方案主要结合了本地缓存和分布式缓存，如Redis，以提高系统的响应速度和处理能力。在这种场景下，读操作远超写操作，尤其是对于热卖商品，...
第六讲-缓存接入之多级缓存实现及分布式部署落地实践.pdf
04-25
在代码示例中，我们看到一个典型的多级缓存访问流程：首先尝试从JVM堆缓存中获取数据，若未命中，则查询分布式缓存，最后再回溯到数据库。这种设计既利用了本地缓存的高速访问，也利用了分布式缓存的大容量存储，...
JCS1.3开源的缓存架构
03-19
5. **多级别的缓存**：JCS 支持多级缓存，例如内存-磁盘-远程缓存，形成了一套完整的缓存解决方案。 **二、JCS 的架构设计** JCS 的核心架构包括以下几个组件： 1. **Cache Manager**：是 JCS 的核心，负责初始化...
JVM之EhCache缓存
励志成为一名优秀的全能型软件开发工程师。
03-29 1167
在查询数据的时候，数据大多来自数据库，咱们会基于SQL语句的方式与数据库交互，数据库一般会基于本地磁盘IO的形式将数据读取到内存，返回给Java服务端，Java服务端再将数据响应给客户端，做数据展示。但是MySQL这种关系型数据库在查询数据时，相对比较慢，因为有磁盘IO，有时没命中索引还需要全盘扫描。在针对一些热点数据时，如果完全采用MySQL，会存在俩问题。第一个MySQL相对很脆弱，肯能会崩，第二个MySQL查询效率慢。会采用缓存。
多级缓存之JVM进程缓存
时代各有不同，青春一脉相承。
11-05 760
传统的缓存策略一般是请求到达Tomcat后，先查询Redis，如果未命中则查询数据库，在多级缓存架构中，Nginx内部需要编写本地缓存查询、Redis查询、Tomcat查询的业务逻辑，因此这样的nginx服务不再是一个反向代理服务器，而是一个编写业务的Web服务器了。缓存在日常开发中启动至关重要的作用，由于是存储在内存中，数据的读取速度是非常快的，能大量减少对数据库的访问，减少数据库的压力。Caffeine是一个基于Java8开发的，提供了近乎最佳命中率的高性能的本地缓存库。
Mybatis缓存机制(一级缓存、二级缓存、三级缓存)
张Sir的博客
03-14 6248
Mybatis 一级缓存、二级缓存、三级缓存
什么是缓存？Mybaits一级缓存和二级缓存分别是什么，区别是什么？缓存和缓冲区的区别是什么？
weixin_52515164的博客
09-16 870
缓存（cache）是指数据交换的缓冲区，当应用程序需要读取数据时，先从数据库中将数据取出，放置在 缓冲区中，应用程序从缓冲区读取数据。在我们之前学习javase 中也存在缓存 当我们学习io流时就引入了缓存这一定义，它的存在呢主要要是使用缓冲区（buffer），我们在调用字符流、字节流的构造方法时就会底层就会创建一个长度为8192的byte数组。将读取的数据放在缓冲区的数组中，在取数据的时候就直接在缓冲区中将对应位置的数组转换为字符就可以啦。
Redis高级篇（二）多级缓存---JVM进程缓存
qq_38618691的博客
06-30 2674
JVM缓存
踩坑JVM溢出-----mybatis一二级缓存
skymouse2002的专栏
09-17 2113
根据需求开发了生产者消费者功能，生产者从Oracle数据库读取数据后，通过kafka发送给消费者，消费者从kafka中读取数据后，写入到mysql数据库中，功能需求就这样，比较简单，总量5000W数据，通过3个生产者读取写入到kafka中。 代码写完后经过简单的功能测试没问题，开始在测试环境上运行，大概运行了不到1小时发送了不到200万的数据时出现OOM   GC overhead limit ...
java 一级缓存_Java中的二级缓存
weixin_34277895的博客
02-16 616
原标题：Java中的二级缓存 简答题：1、介绍一下 Hibernate 的二级缓存答：按照以下思路来回答：1. 首先说清楚什么是缓存；2. 再说有了 hibernate的Session 就是一级缓存，即有了一级缓存，为什么还要有二级缓存；3. 最后再说如何配置 Hibernate 的二级缓存。1. 缓存就是把以前从数据库中查询出来和使用过的对象保存在内存中(一个数据结构中)，这个数据结构通常是或类...
二级缓存：本地热点缓存（本地java虚拟机的jvm缓存）
qq_20156289的博客
03-30 1033
二级缓存：本地热点缓存
Jvm堆内存的划分结构和优化，垃圾回收详解（详细解答篇）
热门推荐
sunny的专栏
10-12 1万+
jvm的结构 设置 疑问点 垃圾回收原理 方式， 触发条件。 设置等等的相关纤细介绍
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值