当前位置：首页 > news >正文

后端面经学习自测（三）

news 文章来源：https://blog.csdn.net/mys_mys/article/details/134485782 2024/9/20 14:57:56

文章目录

- - 1、ArrayList和Linkedlist区别？
  - 2、ArrayList扩容机制？
  - 3、ArrayList和Linkedlist分别能做什么场景？
  - 4、事务特性？
  - MySQL事务
  - Redis事务
  - Spring事务
  - 5、在Spring中事务失效的场景？
  - 6、Java泛型？
  - 7、泛型擦除？
  - 8、创建线程的方式？runnable和callable的区别？
  - 9、Synchronized和Lock的区别？
  - 10、Java锁升级机制？
  - 11、为什么选择SpringBoot？
  - SpringBoot自动装配
  - 12、servlet容器？
  - JSP九大内置对象
  - cookie和session区别
  - 13、常用的限流算法？
  - 单机限流
  - 分布式限流
  - 14、Mybatis中#{}和${}区别?
  - 15、Mybatis一级缓存和二级缓存？
  - 16、Redis持久化机制？
  - 17、数据表建索引的原则？
  - 18、索引失效？
  - 索引优化
  - 19、了解过SpringBoot吗，说一下SpringBootApplication底层
  - 20、HashMap和Hashtable的区别，底层
  - 21、线程池的创建以及使用场景
  - ThreadPoolExecutor参数
  - 22、Redis为什么这么快以及使用场景
  - 缓存
  - 分布式锁
  - 23、Spirngboot的优势
  - 24、Springboot里面的容器有哪些
  - 25、Springboot常用注解
  - 26、数据库多表连接方式
  - MySQL慢查询
  - 27、MySQL的锁有哪些
  - 28、线程池，为什么使用 ThreadPoolExector ，有什么好处，具体流程，拒绝策略详细说明
  - 29、常见的Spring注解
  - 30、Autowired和Recource之间区别

1、ArrayList和Linkedlist区别？

2、ArrayList扩容机制？

https://www.yuque.com/qianmys/tbcnb5/sy2mwz7om0z8g9gd

3、ArrayList和Linkedlist分别能做什么场景？

频繁随机访问——ArrayList

频繁插入删除——LinkedList

4、事务特性？

ACID：原子性、一致性、隔离性、持久性

MySQL事务

要么全部执行成功，要么全部执行失败

四大特性ACID：原子性、一致性、隔离性、持久性

事务并发问题：脏读、幻读、不可重复读

事务隔离级别：读未提交、读已提交、可重复读、串行序列化

（需要分别解释上述特点）

Redis事务

Redis事务：一个步骤中，执行一组命令

1、Redis事务不具有原子性：Redis 不能保证所有指令同时成功和失败，只能保证事务的指令一同执行，因为对Redis来说，事务回滚带来的代价太大，影响性能

2、Redis事务不具有隔离性：Redis 事务在提交之前任何指令都不会实际的被执行，所以不存在MySQL中脏写，脏读，不可重复读，幻读等问题

Redis事务常用命令：

1、MULTI：标记一个事务块的开始；

2、EXEC：执行事务块中的所有命令；

3、DISCARD：取消事务，放弃执行事务块中的所有命令；

4、UNWATCH：取消 WATCH 命令对所有 key 的监控；

5、WATCH key [key…]：监控一个或多个key，如果事务执行之前这些key被其他事务改动，事务就会被打断；

WATCH 底层采用的是CAS乐观锁，如果我们使用WATCH监控了一些 key，那么在事务中在执行修改这些被监控的 key 数据的时候，会判断当前 key 的值是否与期望值一样，如果一样就会做修改，如果不一样就会放弃修改，当前整个事务的操作都会放弃执行

Spring事务

分类：

1、编程式事务：TransactionTemplate/TransactionManager（×）

2、声明式事务：@Transactional（√）

事务传播行为：

1、TransactionDefinition.PROPAGATION_REQUIRED（propagation_required）

如果当前存在事务，则加入该事务；如果当前没有事务，则创建一个新的事务

2、TransactionDefinition.PROPAGATION_REQUIRES_NEW（requires_new）

创建一个新的事务，如果当前存在事务，则把当前事务挂起

3、TransactionDefinition.PROPAGATION_NESTED（nested）

如果当前存在事务，则创建一个事务作为当前事务的嵌套事务来运行

如果当前没有事务，则该取值等价于1

4、TransactionDefinition.PROPAGATION_MANDATORY（mandatory）（×）

如果当前存在事务，则加入该事务；如果当前没有事务，则抛出异常

事务将不会发生回滚：

1、TransactionDefinition.PROPAGATION_SUPPORTS：如果当前存在事务，则加入该事务；如果当前没有事务，则以非事务的方式继续运行

2、TransactionDefinition.PROPAGATION_NOT_SUPPORTED：以非事务方式运行，如果当前存在事务，则把当前事务挂起

3、TransactionDefinition.PROPAGATION_NEVER：以非事务方式运行，如果当前存在事务，则抛出异常

注解：

@Transactional(rollbackFor = Exception.class)注解：事务在遇到非运行时异常时也回滚

如果不配置rollbackFor属性,那么事务只会在遇到RuntimeException的时候才会回滚

事务管理相关三个接口：

1、PlatformTransactionManager：（平台）事务管理器，Spring 事务策略的核心

2、TransactionDefinition：事务定义信息(事务隔离级别、传播行为、超时、只读、回滚规则)

3、TransactionStatus：事务运行状态

Spring 并不直接管理事务，而是提供了多种事务管理器。Spring 事务管理器的接口是：PlatformTransactionManager

@Transactional

可用在方法（public）、类、接口（×）上

@Transactional 的工作机制是基于 AOP 实现的，AOP 又是使用动态代理实现的。如果目标对象实现了接口，默认情况下会采用 JDK 的动态代理，如果目标对象没有实现了接口,会使用 CGLIB 动态代理

public类或方法上使用@Transactional注解：Spring容器在启动时为其创建一个代理对类，方法实际调用的是TransactionInterceptor 类中的 invoke()方法

事务失效：

1、@Transactional 注解只有作用到 public 方法上事务才生效，不推荐在接口上使用；

2、避免同一个类中调用 @Transactional 注解的方法，这样会导致事务失效；

3、被 @Transactional 注解的方法所在的类必须被 Spring 管理，否则不生效；

4、底层使用的数据库必须支持事务机制，否则不生效；

5、在Spring中事务失效的场景？

1、数据库不支持事务

2、事务方法未被spring管理

3、方法没有被public修饰

4、同一类中方法调用

5、未配置事务管理器

6、方法的事务传播类型不支持事务

7、不正确的捕获异常

8、错误的标注异常类型

// 同一类中方法调用
@Service
public class MyService {
private void method1() {// 先获取该类的代理对象，然后通过代理对象调用method2((MyService)AopContext.currentProxy()).method2(); 
}
@Transactionalpublic void method2() {}
}

6、Java泛型？

7、泛型擦除？

8、创建线程的方式？runnable和callable的区别？

1、继承Thread类

2、实现Runnable方法

3、实现Callable方法

4、创建线程池

9、Synchronized和Lock的区别？

10、Java锁升级机制？

在锁对象的对象头里面有一个 threadid 字段

第一次访问的时候 threadid 为空，jvm 让其持有偏向锁，并将 threadid 设置为其线程 id
再次进入的时候会先判断 threadid 是否与其线程 id 一致
1. 如果一致则可以直接使用此对象
2. 如果不一致，则升级偏向锁为轻量级锁
通过自旋循环一定次数来获取锁，执行一定次数之后，如果还没有正常获取到要使用的对象，此时就会把锁从轻量级升级为重量级锁

1、同步锁只有一个线程访问——偏向锁（减少加锁解锁的CAS操作）

2、有其他线程抢占锁——轻量级锁

3、第二个线程加入锁争用——重量级锁

11、为什么选择SpringBoot？

简化配置，方便集成其他主流框架，使开发更简单

SpringBoot自动装配

自动去把第三方组件的Bean装载到IOC容器中，不需要开发人员再去写Bean相关的配置

在springboot应用里面只需要在启动类上去加上@SpringBootApplication注解，就可以去实现自动装配，它是一个复合注解，真正去实现自动装配的注解是 @EnableAutoConfiguration这样一个注解，自动装配的实现主要依靠三个核心的关键技术：

1、引入starter启动依赖组件的时候，这个组件里面必须包含有一个 @Configuration配置类，而在这个配置类里面，我们需要通过@Bean这个注解去声明需要装配到IOC容器里面的Bean对象。

2、第三方jar包里面的配置类全路径都将放在classpath:/META-INF/spring.factories文件里面，这样的话springboot就可以知道第三方jar包里面这个配置类的位置。这个步骤主要是用到了spring里面的SpringFactoriesLoader来完成的。

3、springboot拿到所有第三方jar包里面声明的配置类以后，再通过Spring提供的ImportSelector这样一个接口（@Import注解功能），来实现对这些配置类的动态加载，从而去完成自动装配的动作

12、servlet容器？

Servlet主要负责接收用户请求 HttpServletRequest，在doGet(),doPost()中做相应的处理，并将回应HttpServletResponse反馈给用户
Servlet 可以设置初始化参数，供 Servlet 内部使用
一个 Servlet 类只会有一个实例，在它初始化时调用init()方法，销毁时调用destroy()方法
Servlet 需要在 web.xml 中配置，一个 Servlet 可以设置多个 URL 访问
Servlet 不是线程安全，因此要谨慎使用类变量

JSP九大内置对象

page页面对象
config配置对象
request请求对象
response响应对象
session会话对象
application全局对象
out输出对象
pageContext页面上下文对象
exception异常对象

cookie和session区别

1、Cookie 一般用来保存用户信息，登录一次网站后访问网站其他页面不需要重新登录

Session 主要作用就是通过服务端记录用户的状态。

典型的场景是购物车，当你要添加商品到购物车的时候，系统不知道是哪个用户操作的，因为 HTTP 协议是无状态的，服务端给特定的用户创建特定的 Session 后就可以标识这个用户并且跟踪这个用户

2、Cookie 数据保存在客户端(浏览器端)，Session 数据保存在服务器端

3、 Session 安全性更高。如果使用 Cookie 的一些敏感信息不要写入 Cookie 中，最好能将 Cookie 信息加密然后使用到的时候再去服务器端解密

13、常用的限流算法？

1、固定窗口计数器算法

使用一个counter计数，每处理一个请求counter+1，达到设定值之后，后续请求就会被拒绝

问题：无法保证突然激增的流量

2、滑动窗口计数器算法

可以把时间以一定比例分片

如接口限流每分钟处理 60 个请求，我们可以把 1 分钟分为 60 个窗口。每隔 1 秒移动一次，每个窗口一秒只能处理不大于 60(请求数)/60（窗口数）的请求。如果当前窗口的请求计数总和超过了限制的数量的话就不再处理其他请求

特点：当滑动窗口的格子划分的越多，滑动窗口的滚动就越平滑，限流的统计就会越精确

3、漏桶算法

把发请求的动作比作成注水到桶中，处理请求的过程可以比作漏桶漏水。我们往桶中以任意速率流入水，以一定速率流出水。当水超过桶流量则丢弃，因为桶容量是不变的，保证了整体的速率

实现：队列

与消息队列削峰/限流的思想是一样

4、令牌桶算法

现在桶里装的是令牌，请求在被处理之前需要拿到一个令牌，请求处理完毕之后将这个令牌丢弃（删除）。我们根据限流大小，按照一定的速率往桶里添加令牌。如果桶装满了，就不能继续往里面继续添加令牌了

单机限流

1、RateLimiter

Google Guava 自带的限流工具类
RateLimiter 基于令牌桶算法，可以应对突发流量
还提供了平滑预热限流的算法实现
- 平滑突发限流就是按照指定的速率放令牌到桶里
- 平滑预热限流会有一段预热时间，预热时间之内，速率会逐渐提升到配置的速率

2、Bucket4j

一个非常不错的基于令牌/漏桶算法的限流库
不仅支持单机限流和分布式限流，还可以集成监控，搭配 Prometheus 和 Grafana 使用
3、Resilience4j
不仅提供限流，还提供了熔断、负载保护、自动重试等保障系统高可用开箱即用的功能
Resilience4j 的生态也更好，很多网关都使用 Resilience4j 来做限流熔断的

分布式限流

1、借助中间件架限流：可以借助 Sentinel 或者使用 Redis 来自己实现对应的限流逻辑

2、网关层限流：比较常用的一种方案，直接在网关层把限流给安排上了。不过，通常网关层限流通常也需要借助到中间件/框架。就比如 Spring Cloud Gateway 的分布式限流实现RedisRateLimiter就是基于 Redis+Lua 来实现的，再比如 Spring Cloud Gateway 还可以整合 Sentinel 来做限流

为什么建议 Redis+Lua 的方式？

1、减少了网络开销：我们可以利用 Lua 脚本来批量执行多条 Redis 命令，这些 Redis 命令会被提交到 Redis 服务器一次性执行完成，大幅减小了网络开销。

2、原子性：一段 Lua 脚本可以视作一条命令执行，一段 Lua 脚本执行过程中不会有其他脚本或 Redis 命令同时执行，保证了操作不会被其他指令插入或打扰

14、Mybatis中#{}和${}区别?

1、${}是 Properties 文件中的变量占位符，它可以用于标签属性值和 sql 内部，属于静态文本替换，比如${driver}会被静态替换为com.mysql.jdbc. Driver。

2、#{}是 sql 的参数占位符，MyBatis 会将 sql 中的#{}替换为? 号，在 sql 执行前会使用 PreparedStatement 的参数设置方法，按序给 sql 的? 号占位符设置参数值，比如 ps.setInt(0, parameterValue)，#{item.name} 的取值方式为使用反射从参数对象中获取 item 对象的 name 属性值，相当于 param.getItem().getName()

15、Mybatis一级缓存和二级缓存？

1、一级缓存是mybatis中默认开启的缓存机制，它是基于线程的本地缓存，适用于单线程、读多写少的场景

2、二级缓存是基于namespace级别的缓存，可以被多个SqlSession对象共享，被多个SqlSession对象共享，适用于多线程、读写频繁的场景

16、Redis持久化机制？

RDB、AOF：

文件类型：RDB生成的是二进制文件（快照），AOF生成的是文本文件（追加日志）
安全性：缓存宕机时，RDB容易丢失较多的数据，AOF根据策略决定（默认的everysec可以保证最多有一秒的丢失）
文件恢复速度：由于RDB是二进制文件，所以恢复速度也比 AOF更快
操作的开销：每一次RDB保存都是一次全量保存，操作比较重，通常设置至少5分钟保存一次数据。而AOF的刷盘是一次追加操作，操作比较轻，通常设置策略为每一秒进行一次刷盘

17、数据表建索引的原则？

适合

字段唯一性
常用where查询的字段
常用group by和order by的字段

不适合

WHERE 条件，GROUP BY，ORDER BY 里用不到的字段
字段中存在大量重复数据（MySQL优化器对于出现比例高的索引，会忽略索引，进行全表扫描）
经常更新的字段

18、索引失效？

左或左右模糊匹配——违背了最左匹配原则
对索引列做计算、函数、类型转换操作
联合索引要遵循最左匹配原则
where，or前是索引列，or后不是索引列

索引优化

覆盖索引优化：利用覆盖索引优化，避免回表
主键索引自增：索引是按顺序存储数据的，如果主键的值是随机的值，可能会引发页分裂的现象，页分裂会导致大量的内存碎片
防止索引失效
前缀索引优化：减小索引字段大小

主管面听说会看项目源码进行解释

19、了解过SpringBoot吗，说一下SpringBootApplication底层

@SpringBootConfiguration 创建 SpringBoot 项目之后会默认在主类加上

@EnableAutoConfiguration：启用 SpringBoot 的自动配置机制
@ComponentScan：扫描被@Component (@Repository,@Service,@Controller)注解的 bean，注解默认会扫描该类所在的包下所有的类
@Configuration：允许在 Spring 上下文中注册额外的 bean 或导入其他配置类

20、HashMap和Hashtable的区别，底层

21、线程池的创建以及使用场景

1、使用构造函数 new ThreadPoolExecutor

2、使用工具类Executors

ThreadPoolExecutor参数

corePoolSize 核心线程数
maximumPoolSize 最大线程数
keepAliveTime 超出核心线程数的线程存活时间
TimeUnit unit keepAliveTime单位
BlockingQueue workQueue 工作队列，存放待处理的任务
threadFactory：创建线程的工厂类
handler：饱和策略，AbortPolicy、CallerRunsPolicy、DiscardOldestPolicy、DiscardPolicy

22、Redis为什么这么快以及使用场景

缓存

1、缓存模式

常用：使用过期时间兜底，先更新DB，后删除缓存，提升数据一致性——适合读多写少

2、缓存异常

双写？

3、缓存一致性

1、更新MySQL即可，不管Redis，以过期时间兜底

2、更新MySQL之后，操作Redis

删除√（主动删除，减少不一致）
更新（少用）

更新MySQL，删除Redis

3、异步将MySQL同步更新到Redis

引入消息队列，业务解耦，但成本大

4、为什么需要缓存？

根据局部性原理，80%的请求会落在20%的热点数据上，对于读多写少的场景，增加缓存有利于提高吞吐量和健壮性

分布式锁

特性：对称性、安全性、互斥性

set key value nx ex secondsnx

setnx命令，key是锁名字，value是持有者id，在设置一个过期时间兜底

value必须是谁申请、谁释放，在解锁时需要先进行检查

1、加上owner——谁申请、谁释放

2、lua脚本——保证原子操作

查看是否是自己的锁
如果是，释放锁

Redission：

1、如果该客户端面对的是一个redis cluster集群，首先会根据hash节点选择一台机器

发送一段lua脚本到redis上（lua脚本里面是要执行的业务逻辑）

2、第二个客户端加锁 https://www.cnblogs.com/AnXinliang/p/10019389.html

3、watch dog自动延期机制：只要客户端1一旦加锁成功，就会启动一个watch dog看门狗，是一个后台线程，会每隔10秒检查一下，如果客户端1还持有锁key，那么就会不断的延长锁key的生存时间

4、可重入加锁机制：incrby myLock 对客户端1的加锁次数，累加1

5、释放锁机制：发现加锁次数是0了，说明这个客户端已经不再持有锁了，此时就会用del myLock命令删除

23、Spirngboot的优势

1、容易与 Spring 生态系统集成，如 Spring JDBC、Spring ORM、Spring Data、Spring Security

2、提供嵌入式 HTTP 服务器，如 Tomcat 和 Jetty，可以轻松地开发和测试 web 应用程序

3、提供了多种插件 Maven方便开发

24、Springboot里面的容器有哪些

四种Web容器，分别为Tomcat，Jetty，Undertow，Netty

容器负责管理应用程序的生命周期、处理请求和响应、管理对象的生命周期

容器的主要组件：

1、SpringApplication

SpringBoot 应用程序的核心类，负责启动 SpringBoot 应用程序，并负责初始化和配置ApplicationContext 容器

步骤：

添加@SpringBootApplication 注解（包括@Configuration、@EnableAutoConfiguration 和 @ComponentScan）
使用 SpringApplication.run() 方法启动了 SpringBoot 应用程序（两个参数：应用程序的主类和命令行参数）

2、ApplicationContext

Spring Framework 的核心容器，负责管理和组织应用程序中的各个 Bean 对象，提供了依赖注入、AOP、事件机制等功能

3、DispatcherServlet

Web MVC 框架的核心组件，负责处理 HTTP 请求和响应，将请求分发给对应的 Controller，并将 Controller 的响应返回给客户端

4、WebMvcConfigurer

Spring MVC 的配置接口，提供了多个方法，可以用于配置 Spring MVC 框架的各种选项

由Spring MVC自动配置创建和初始化，可以通过实现该接口来扩展和定制Spring MVC框架的功能，如配置跨域资源共享 (CORS)

5、Filter

Java Servlet API 的核心组件之一，负责处理 HTTP 请求和响应，并可以在请求和响应之间添加各种逻辑处理

可以通过实现 Filter 接口或继承 OncePerRequestFilter 类来实现

6、Servlet

Java Servlet API 的核心组件之一，负责处理 HTTP 请求和响应

可以通过实现 Servlet 接口或继承 HttpServlet 类来实现

7、EmbeddedServletContainer

SpringBoot 内嵌的 Web 容器，负责处理 HTTP 请求和响应，并管理应用程序的生命周期

SpringBoot 支持多种内嵌的 Web 容器，例如 Tomcat、Jetty、Undertow

25、Springboot常用注解

https://javaguide.cn/system-design/framework/spring/spring-common-annotations.html

26、数据库多表连接方式

内连接

外连接（左外、右外）

MySQL慢查询

27、MySQL的锁有哪些

全局锁
表级锁：表锁、元数据锁MDL、意向锁、AUTO-INC锁
行级锁：Record Lock记录锁、Gap Lock间隙锁、Next-Key Lock临键锁、插入意向锁

28、线程池，为什么使用 ThreadPoolExector ，有什么好处，具体流程，拒绝策略详细说明

执行流程：

判断线程池里的核心线程是否都在执行任务，如果不是（核心线程空闲或者还有核心线程没有被创建）则创建一个新的工作线程来执行任务。如果核心线程都在执行任务，则进入下个流程
线程池判断工作队列是否已满，如果工作队列没有满，则将新提交的任务存储在这个工作队列里。如果工作队列满了，则进入下个流程
判断线程池里的线程是否都处于工作状态，如果没有，则创建一个新的工作线程来执行任务。如果已经满了，则交给饱和策略来处理这个任务

29、常见的Spring注解

1、@EnableWebMvc：在配置类中开启Web MVC的配置支持

2、@Controller：@Component注解的一种具体形式，还有@Service、@Repository

3、@RequestMapping：处理请求地址映射，映射web请求到某一个handler

@GetMapping、@PostMapping、@PutMapping、@PatchMapping、@DeleteMapping

4、@ResponseBody：响应请求的返回Body

5、@RequestBody：绑定HTTP请求的Body

6、@PathVariable：使用在请求handler方法的参数

7、@RestController：同时引入了@Controller和@ResponseBody两个注解

8、@ControllerAdvice：与@ExceptionHandler一起使用，可以统一处理业务异常

9、@ExceptionHandler

10、@InitBinder：日期格式的统一处理

11、@ModelAttribute：提前绑定全局user对象

12、@Transactional：使用事务

13、@CrossOrigin：支持跨域注解

14、@ExceptionHandler：异常处理

15、@Required：用于bean的setter方法上，必须在配置阶段注入

16、@Autowired：用于bean的field、setter方法以及构造方法上，显式地声明依赖，根据type来注入

17、@Qualifier：和@Autowired一起使用，指定要绑定的bean名称

18、@Configuration：Spring配置

19、@ComponentScan：指定Spring扫描注解的package

20、@Value：指定属性取值的表达式

30、Autowired和Recource之间区别

@Autowired 是 Spring 提供的注解，@Resource 是 JDK 提供的注解。
Autowired 默认的注入方式为byType（根据类型进行匹配），@Resource默认注入方式为 byName（根据名称进行匹配）
当一个接口存在多个实现类的情况下，@Autowired 和@Resource都需要通过名称才能正确匹配到对应的 Bean。Autowired 可以通过 @Qualifier 注解来显式指定名称，@Resource可以通过 name 属性来显式指定名称
@Autowired 支持在构造函数、方法、字段和参数上使用。@Resource 主要用于字段和方法上的注入，不支持在构造函数或参数上使用