Springboot缓存-基本环境搭建

最新推荐文章于 2022-04-07 22:17:11 发布
最新推荐文章于 2022-04-07 22:17:11 发布
阅读量193 收藏
点赞数
分类专栏： Java框架技术
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39868387/article/details/102864266
版权

一、缓存- 搭建步骤如下

1、使用idea工具创建springboot工程
步骤：

File---->----New---->Project

在这里插入图片描述

Spring Initializr---->Next

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
选择插件
在这里插入图片描述
在这里插入图片描述
2、第二步，启动数据库并用navicat客户端连接数据库，并创建两张表，分别是：department、employee
在这里插入图片描述
3、第三步，在bean层编写实体类
在这里插入图片描述
实体类(创建javaBean封装数据)

Department.java

package spring.mystudy.springbootcache.bean;

public class Department {
	
	private Integer id;
	private String departmentName;
	
	
	public Department() {
		super();
		// TODO Auto-generated constructor stub
	}
	public Department(Integer id, String departmentName) {
		super();
		this.id = id;
		this.departmentName = departmentName;
	}
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getDepartmentName() {
		return departmentName;
	}
	public void setDepartmentName(String departmentName) {
		this.departmentName = departmentName;
	}
	@Override
	public String toString() {
		return "Department [id=" + id + ", departmentName=" + departmentName + "]";
	}
}

Employee.java

package spring.mystudy.springbootcache.bean;

public class Employee {
	
	private Integer id;
	private String lastName;
	private String email;
	private Integer gender; //性别 1男  0女
	private Integer dId;
	
	
	public Employee() {
		super();
	}

	
	public Employee(Integer id, String lastName, String email, Integer gender, Integer dId) {
		super();
		this.id = id;
		this.lastName = lastName;
		this.email = email;
		this.gender = gender;
		this.dId = dId;
	}
	
	public Integer getId() {
		return id;
	}
	public void setId(Integer id) {
		this.id = id;
	}
	public String getLastName() {
		return lastName;
	}
	public void setLastName(String lastName) {
		this.lastName = lastName;
	}
	public String getEmail() {
		return email;
	}
	public void setEmail(String email) {
		this.email = email;
	}
	public Integer getGender() {
		return gender;
	}
	public void setGender(Integer gender) {
		this.gender = gender;
	}
	public Integer getdId() {
		return dId;
	}
	public void setdId(Integer dId) {
		this.dId = dId;
	}
	@Override
	public String toString() {
		return "Employee [id=" + id + ", lastName=" + lastName + ", email=" + email + ", gender=" + gender + ", dId="
				+ dId + "]";
	}
}

3、第三步，整合MyBatis操作数据库：分两步操作：
3.1 配置数据源信息
在这里插入图片描述

application.properties

spring.datasource.url=jdbc:mysql://localhost:3306/spring_cache
spring.datasource.username=root
spring.datasource.password=123456
#spring.datasource.driver-class-name=com.mysql.jdbc.Driver

3.2 使用注解版的MyBatis；
3.2.1 @MapperScan指定需要扫描的mapper接口所在的包
在这里插入图片描述
3.3 在mapper包下，编写两个接口，分别是：
DepartmentMapper、EmployeeMapper
在这里插入图片描述

DepartmentMapper.java

package spring.mystudy.springbootcache.mapper;

import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;
import spring.mystudy.springbootcache.bean.Department;

@Mapper
public interface DepartmentMapper {

    @Select("SELECT * FROM department WHERE id = #{id}")
    Department getDeptById(Integer id);
}

EmployeeMapper.java

package spring.mystudy.springbootcache.mapper;
import org.apache.ibatis.annotations.*;
import spring.mystudy.springbootcache.bean.Employee;

@Mapper
public interface EmployeeMapper {

    @Select("SELECT * FROM employee WHERE id = #{id}")
    public Employee getEmpById(Integer id);

    @Update("UPDATE employee SET lastName=#{lastName},email=#{email},gender=#{gender},d_id=#{dId} WHERE id=#{id}")
    public void updateEmp(Employee employee);

    @Delete("DELETE FROM employee WHERE id=#{id}")
    public void deleteEmpById(Integer id);

    @Insert("INSERT INTO employee(lastName,email,gender,d_id) VALUES(#{lastName},#{email},#{gender},#{dId})")
    public void insertEmployee(Employee employee);

    @Select("SELECT * FROM employee WHERE lastName = #{lastName}")
    Employee getEmpByLastName(String lastName);
}

3.4、第四步，在src\test\java\spring\mystudy\springbootcache目录下的SpringbootCacheApplicationTests.java 编写
在这里插入图片描述

SpringbootCacheApplicationTests

package spring.mystudy.springbootcache;

import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import spring.mystudy.springbootcache.bean.Employee;
import spring.mystudy.springbootcache.mapper.EmployeeMapper;

@SpringBootTest
class SpringbootCacheApplicationTests {
    @Autowired
    EmployeeMapper employeeMapper;

    @Test
    void contextLoads() {
        Employee empById = employeeMapper.getEmpById(1);
        System.out.println(empById);
    }

}

**4、在数据库随便插入一条数据**

5、测试与运行
在这里插入图片描述
在这里插入图片描述

6、接着，我们再创建servic和controller层

如图所示：

在这里插入图片描述
servicece层

EmployeeService.java

package spring.mystudy.springbootcache.service;
import spring.mystudy.springbootcache.bean.Employee;
import spring.mystudy.springbootcache.mapper.EmployeeMapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class EmployeeService {
      @Autowired
      EmployeeMapper employeeMapper;
     public Employee getEmp(Integer id){
        System.out.println("查询"+id+"号员工");
        Employee emp = employeeMapper.getEmpById(id);
        return emp;
    }

controller层

EmployeeController.java

package spring.mystudy.springbootcache.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;
import spring.mystudy.springbootcache.bean.Employee;
import spring.mystudy.springbootcache.service.EmployeeService;

@RestController
public class EmployeeController {

    @Autowired
    EmployeeService employeeService;
    @GetMapping("/emp/{id}")
    public Employee getEmployee(@PathVariable("id") Integer id){
        Employetie employee = employeeService.getEmp(id);
        return employee;
    }

接着在数据库添加一条数据
在这里插入图片描述
然后，我们需要在全局配置文件：application.properties，加一个配置参数：
mybatis.configuration.map-underscore-to-camel-case=true
在这里插入图片描述

7、启动SpringBootApplication的启动类

在这里插入图片描述
访问出现错误
在这里插入图片描述
控制台打印错误信息：
在这里插入图片描述
解决方案：
根据提示需要在配置数据库的连接信息中，在MySQL的URL后面加上“?serverTimezone=UTC”在这里插入图片描述
再次启动：
在这里插入图片描述
访问：
http://127.0.0.1:8080/emp/1
http://127.0.0.1:8080/emp/2
http://127.0.0.1:8080/emp/3
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

基本ok

总结：
搭建基本环境
1、导入数据库文件 创建出department和employee表
2、创建javaBean封装数据
3、整合MyBatis操作数据库
3.1 配置数据源信息
3.2 使用注解版的MyBatis；
3.2.1 @MapperScan指定需要扫描的mapper接口所在的包

二、缓存-@Cacheable初始体验

快速体验缓存

步骤：
	1、开启基于注解的缓存 @EnableCaching
	2、标注缓存注解即可
		@Cacheable
		@CachePut
		默认使用的是ConcurrentMapCacheManager==ConcurrentMapCache；将数据保存在	ConcurrentMap<Object, Object>中

开发中使用缓存中间件；redis、memcached、ehcache；

2.0 实践操作
首先在启动器类上加入@EnableCaching注解
在这里插入图片描述
2.0.1 比如我们吧控制台的日志文件清空，这个缓存的注解会一次发送请求查询的
在这里插入图片描述
在这里插入图片描述
发送请求1号员工与2号员工
在这里插入图片描述
在这里插入图片描述
控制台也会打印号员工与2号员工信息
在这里插入图片描述
2.0.2 如果想要在控制台打印出1号员工和2号员工发送请求的日志信息，只需要在全局配置文件application.properties加入一个参数即可：
logging.level.spring.mystudy.springbootcache.mapper=debug

在这里插入图片描述
3个员工发送请求：
http://127.0.0.1:8080/emp/1
http://127.0.0.1:8080/emp/2
http://127.0.0.1:8080/emp/3
日志打印信息：
在这里插入图片描述
2.0.3 如果想要把相同的数据，直接从缓存中获取，不用调用方法我们可以在service层的的方法上加入一个@Cacheable注解即可
在这里插入图片描述
而CacheManager管理多个Cache组件的，对缓存的真正CRUD操作在Cache组件中，每一个缓存组件有自己唯一一个名字；

原理：

1、自动配置类；CacheAutoConfiguration
2、缓存的配置类
org.springframework.boot.autoconfigure.cache.GenericCacheConfiguration
org.springframework.boot.autoconfigure.cache.JCacheCacheConfiguration
org.springframework.boot.autoconfigure.cache.EhCacheCacheConfiguration
org.springframework.boot.autoconfigure.cache.HazelcastCacheConfiguration
org.springframework.boot.autoconfigure.cache.InfinispanCacheConfiguration
org.springframework.boot.autoconfigure.cache.CouchbaseCacheConfiguration
org.springframework.boot.autoconfigure.cache.RedisCacheConfiguration
org.springframework.boot.autoconfigure.cache.CaffeineCacheConfiguration
org.springframework.boot.autoconfigure.cache.GuavaCacheConfiguration
org.springframework.boot.autoconfigure.cache.SimpleCacheConfiguration【默认】
org.springframework.boot.autoconfigure.cache.NoOpCacheConfiguration
3、哪个配置类默认生效：SimpleCacheConfiguration；
4、给容器中注册了一个CacheManager：ConcurrentMapCacheManager
5、可以获取和创建ConcurrentMapCache类型的缓存组件；他的作用将数据保存在ConcurrentMap中；

运行流程：

1、方法运行之前，先去查询Cache（缓存组件），按照cacheNames指定的名字获取；
（CacheManager先获取相应的缓存），第一次获取缓存如果没有Cache组件会自动创建。
2、去Cache中查找缓存的内容，使用一个key，默认就是方法的参数；
key是按照某种策略生成的；默认是使用keyGenerator生成的，默认使用SimpleKeyGenerator生成key；
SimpleKeyGenerator生成key的默认策略；
如果没有参数；key=new SimpleKey()；
如果有一个参数：key=参数的值
如果有多个参数：key=new SimpleKey(params)；
3、没有查到缓存就调用目标方法；
4、将目标方法返回的结果，放进缓存中
@Cacheable标注的方法执行之前先来检查缓存中有没有这个数据，默认按照参数的值作为key去查询缓存， 如果没有就运行方法并将结果放入缓存；以后再来调用就可以直接使用缓存中的数据；

核心：

1）、使用CacheManager【ConcurrentMapCacheManager】按照名字得到Cache【ConcurrentMapCache】组件
2）、key使用keyGenerator生成的，默认是SimpleKeyGenerator

几个属性：

cacheNames/value：指定缓存组件的名字;将方法的返回结果放在哪个缓存中，是数组的方式，可以指定多个缓存；

       key：缓存数据使用的key；可以用它来指定。默认是使用方法参数的值  1-方法的返回值
               编写SpEL； #i d;参数id的值   #a0  #p0  #root.args[0]
              getEmp[2]
 
       keyGenerator：key的生成器；可以自己指定key的生成器的组件id
               key/keyGenerator：二选一使用;
 
 
       cacheManager：指定缓存管理器；或者cacheResolver指定获取解析器
 
       condition：指定符合条件的情况下才缓存；
              ,condition = "#id>0"
           condition = "#a0>1"：第一个参数的值》1的时候才进行缓存
 
       unless:否定缓存；当unless指定的条件为true，方法的返回值就不会被缓存；可以获取到结果进行判断
               unless = "#result == null"
               unless = "#a0==2":如果第一个参数的值是2，结果不缓存；
       sync：是否使用异步模式

@CacheEvict：缓存清除
key：指定要清除的数据
allEntries = true：指定清除这个缓存中所有的数据
beforeInvocation = false：缓存的清除是否在方法之前执行
默认代表缓存清除操作是在方法执行之后执行;如果出现异常缓存就不会清除
beforeInvocation = true：
代表清除缓存操作是在方法运行之前执行，无论方法是否出现异常，缓存都清除

20.4 测试一个缓存是否起效，首先我们把控制台的日志文件清空，接着，比如我们发送请求2号员工，发现控制台没有打印任何信息。说明缓存起效了！
在这里插入图片描述
在这里插入图片描述
当我们在数据库插入一条新数据
在这里插入图片描述
发送请求4号员工
在这里插入图片描述
由于4号员工是新数据，没有被缓存过的，所以能在控制台能打印日志信息
在这里插入图片描述
当第二次发送请求4号员工，发现控制台没有打印任何信息，说明4号员工已经被缓存进来了！
在这里插入图片描述

三、缓存Cacheable其他属性

缓存config
1、首先创建config层，并创建MyCacheConfig类
在这里插入图片描述

MyCacheConfig.java

package spring.mystudy.springbootcache.config;

import org.springframework.cache.interceptor.KeyGenerator;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.lang.reflect.Method;
import java.util.Arrays;

@Configuration
public class MyCacheConfig {

    @Bean("myKeyGenerator")
    public KeyGenerator keyGenerator(){
        return new KeyGenerator(){

            @Override
            public Object generate(Object target, Method method, Object... params) {
                return method.getName()+"["+ Arrays.asList(params).toString()+"]";
            }
        };
    }
}

也可以用另一种方式指定，比如：
在这里插入图片描述
比如缓存指定2号员工
在这里插入图片描述

四、缓存–CachePut

@CachePut：既调用方法，又更新缓存数据；同步更新缓存
运行时机：

1、先调用目标方法
2、将目标方法的结果缓存起来

 @CachePut(value = "emp")
    public Employee updateEmp(Employee employee){
        System.out.println("updateEmp:"+employee);
        employeeMapper.updateEmp(employee);
        return employee;
    }

测试步骤：
1、查询1号员工；查到的结果会放在缓存中；
key：1 value：lastName：张三
2、以后查询还是之前的结果
3、更新1号员工；【lastName:zhangsan；gender:0】
将方法的返回值也放进缓存了；
key：传入的employee对象 值：返回的employee对象；
4、查询1号员工？
应该是更新后的员工；
key = “#employee.id”:使用传入的参数的员工id；
key = “#result.id”：使用返回后的id
@Cacheable的key是不能用#result
为什么是没更新前的？【1号员工没有在缓存中更新】

五、@CacheEvict：缓存清除

key：指定要清除的数据
allEntries = true：指定清除这个缓存中所有的数据
beforeInvocation = false：缓存的清除是否在方法之前执行
默认代表缓存清除操作是在方法执行之后执行;如果出现异常缓存就不会清除
beforeInvocation = true：
代表清除缓存操作是在方法运行之前执行，无论方法是否出现异常，缓存都清除

service层添加

@CacheEvict(value="emp",key = "#id")
 public void deleteEmp(Integer id){
        System.out.println("deleteEmp:"+id);
        //employeeMapper.deleteEmpById(id);
        int i = 10/0;
    }

controller层添加

 @GetMapping("/delemp")
    public String deleteEmp(Integer id){
        employeeService.deleteEmp(id);
        return "success";
    }

修改数据库访问：
http://127.0.0.1:8080/emp?id=3&lastName=张三&email=lisi@123.com&gender=2&d_id=1
修改前：
在这里插入图片描述
修改后：
在这里插入图片描述

江湖侠客
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringBoot缓存管理
qq3164069700的博客
12-10 1241
前言 Spring框架支持透明地向应用程序添加缓存对缓存进行管理，其管理缓存的核心是将缓存应用于操作数据的方法（包括增删查改等），从而减少操作数据的执行次数（主要是查询，直接从缓存中读取数据），同时不会对程序本身造成任何干扰。 SpringBoot继承了Spring框架的缓存管理功能，通过使用@EnableCaching注解开启基于注解的缓存支持，SpringBoot就可以启动缓存管理的自动化配置。 接下来针对SpringBoot支持的默认缓存管理进行讲解。 SpringBoot默认缓存管理 1、
SpringBoot环境搭建
weixin_44002920的博客
08-21 186
SpringBoot环境搭建
Spring cache缓存应用与总结
二缺和傻宝宝的博客
08-21 1591
前言 现在项目中大家基本都会使用到缓存，本地缓存，Spring引入缓存，或者是直接使用三方缓存的API进行缓存的操作，基本离不开这三种，如果项目没有使用springboot的话，有些配置还需要自己手动去引入，因为没有与Spring进行自动集成，今天我们讨论的是在springboot的基础上进行缓存的使用，以redis和Spring默认缓存为例进行说明 Spring的缓存抽象 Spring Cache 只负责维护抽象层，具体的实现由自己的技术选型来决定，将缓存处理和缓存技术解除耦合。 使用Spring缓存
SpringBoot-缓存基本环境的搭建
qq_45100361的博客
08-01 421
一、创建工程 二、执行sql脚本 /* SET FOREIGN_KEY_CHECKS=0; -- ---------------------------- -- Table structure for department -- ---------------------------- DROP TABLE IF EXISTS `department`; CREATE TABLE `department` ( `id` int(11) NOT NULL AUTO_INCREMENT, `d
SpringBoot 缓存--基本环境搭建（学习笔记25）
yufang131的博客
06-12 217
1、启动原理
SpringBoot高级——缓存
热门推荐
如不來的博客
03-20 2万+
一、JSR-107规范   Java Caching定义了5个核心接口，分别是CachingProvider(缓存提供者)、CacheManager(缓存管理器)、Cache(缓存)、Entry(缓存键值对)和Expiry(缓存时效)。   CachingProvider定义了创建、配置、获取、管理和控制多个CacheManager。一个应用可以在运行期访问多个CachingProvider。  ...
springboot入门-环境搭建
qxyx1213的博客
04-07 636
一、项目简介 该项目是一个简单的电脑商城项目，自己的学习记录。 主要的功能： 用户注册和登录 用户管理（密码、个人信息、头像、收货地址） 购物车 热销商品 订单管理 主要技术： springboot + mysql + mybatis 模块开发包括： 持久层开发：相应SQL语句以及配置 业务层开发：核心功能控制、业务操作、异常处理 控制层开发：接收请求、处理响应 前端开发：JS、Query、AJAX技术连接后台 二、搭建项目 JDK：1.8版本及以上
springboot-mybatis-redis缓存集成
08-08
Spring Boot通过 starter 包，如`spring-boot-starter-web`，可以快速搭建Web服务。同时，Spring Boot还支持自动配置，使得开发者无需编写大量配置代码。 MyBatis是一个优秀的持久层框架，它允许开发者将SQL语句...
springmvc转为springboot--干货.docx
08-09
Spring Boot简化了Spring应用的初始搭建以及开发过程。它集成了大量常用的第三方库配置，如：Tomcat、JPA、Thymeleaf等，并提供了默认配置，使得开发者可以快速上手。 2. **Eclipse与STS插件**： Eclipse是一款...
springboot-shiro-redis
02-04
标题“springboot-shiro-redis”表明我们正在讨论一个基于Spring Boot的应用程序，该应用程序集成了Apache Shiro安全框架，并利用Redis作为缓存层。这是一个常见的架构选择，因为Spring Boot简化了开发流程，Shiro...
freelec-springboot2-webservice
03-30
总的来说，“freelec-springboot2-webservice”这个课程旨在帮助开发者掌握SpringBoot2环境下Web服务的开发、集成与优化。通过学习，你将能够熟练地运用SpringBoot2构建RESTful API和SOAP服务，同时了解如何保障服务...
SpringBoot笔记-下篇.pdf
05-05
1、搭建基本环境 1、导入数据库文件 创建出department和employee表 2、创建javaBean封装数据 3、整合MyBatis操作数据库 1.配置数据源信息 2.使用注解版的MyBatis； 1）、@MapperScan指定需要扫描的mapper接口所在的...
SpringBoot整合Mybatis-通用mapper使用二级缓存
【欢迎关注公众号：冬瓜白】
07-18 3671
关于Mybatis的二级缓存可以看我转载的这篇博客：https://blog.csdn.net/Dongguabai/article/details/81106876 未使用二级缓存前测试 执行了三条sql： 开启二级缓存 在yml文件中： 在Mapper接口上使用@CacheNamespace注解： 数据库entity需要序列化： 测试： 执行结果： ...
SpringBoot默认缓存相关知识点整理
滴水穿石的博客
12-08 416
一、JSR107缓存规范 为了缓存开发规范的统一，以及提升系统的扩展性，J2EE发布了JSR107缓存规范。 主要是Java Caching定义了5个接口，分别是CachingProvider、CacheManager、Cache、Entry、Expiry。 CachingProvider：可以创建、配置、获取、管理和控制多个CacheManager，一个Application在运行期间可以访问...
spring-boot-auto-configure:spring.cache.type如何生效
civil的专栏
03-26 8394
转载请标明出处： https://blog.csdn.net/bingospunky/article/details/79700773 本文出自马彬彬的博客 spring.cache.type: redis如何生效的？ 在使用spring cache时，spring已经默认支持了几种缓存实现方式，我们可以通过在spring-boot配置文件中添加spring.cach...
mybatis整合 SpringBoot（缓存机制）
坚持就是胜利的博客
01-16 2278
有了mybatis公司给我们整合的工具类那么我们就不用像以前还得去配置数据源 我们在这里只需引入依赖即可： 我们首先先创建一个简单的数据库 create database springbootmapper； CREATE TABLE `user` ( `id` int(16) unsigned NOT NULL AUTO_INCREMENT, `name` varchar(16) NOT...
@mapper注解的使用_SpringBoot整合MyBatis并使用Redis作为缓存组件的Demo
weixin_39654058的博客
11-26 275
安装流程1、安装docker & redis如果不清楚docker是什么，请查看docker的文档和简介，这里给出docker的安装过程1.1 安装虚拟机(如果有远程服务器的，请略过此步骤)本文推荐VMvare，尽管vmvare比较臃肿，但是对于新手比较友好，配置很简单 从官网下载VMvare，官网地址：https://www.vmware.com/cn.html 从官网下载centos镜...
MyBatisPlus系列之条件构造器 EntityWrapper
weixin_39868387的博客
09-19 2982
上篇：MyBatisPlus系列之通用CRUD操作 一、条件构造器 EntityWrapper 1、EntityWrapper简介 （1）Mybatis-Plus 通过 EntityWrapper（简称 EW，MP 封装的一个查询条件构造器）或者 Condition（与EW类似） 来让用户自由的构建查询条件，简单便捷，没有额外的负担，能够有效提高开发效率 （2）实体包装器，主要用于处理 sql 拼接，排序，实体参数查询等 （3）注意: 使用的是数据库字段，不是Java属性! （4）条件参数...
JVM&JUC入门
weixin_39868387的博客
11-01 2045
一、入门JVM 1、类装载器ClassLoader 负责加载class文件，class文件在文件开头有特定的文件标示，将class文件字节码内容加载到内存中，并将这些内容转换成方法区中的运行时数据结构并且ClassLoader只负责class文件的加载，至于它是否可以运行，则由Execution Engine决定 echo %JAVA_HOME% echo %PATH% echo %CLAS...
springboot magic-api 可以做 高并发项目吗
最新发布
06-13
是的，Spring Boot Magic-api 可以用于开发高并发项目。Magic-api 基于 Spring Boot，Spring Boot 本身就具有很好的性能和并发处理能力。同时，Magic-api 采用了基于注解的开发方式，提供了快速开发 API 的能力，可以让开发人员快速搭建高性能的 API 服务。 另外，Magic-api 还支持集群部署和负载均衡，可以通过 Spring Cloud、Nginx 等组件实现高可用、高并发的部署。 但是需要注意的是，实现高并发并不只是依靠框架本身的能力，还需要开发人员在代码层面上进行优化，如合理使用缓存、数据库优化、异步处理等手段，才能真正实现高并发的效果。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值