javaQA.md · bobex/javaQA

# 1、	说一下spring。
Spring是一个轻量级的控制反转(IoC)、依赖注入（DI）和面向切面(AOP)的容器框架。控制反转是指程序将创建对象的控制权转交给Spring框架进行管理，由Spring通过java的反射机制根据配置文件在运行时动态的创建实例，并管理各个实例之间的依赖关系。具体的就是ApplicationContext和BeanFactory

# 2、	Springbean是怎么创建的？
 Spring支持如下三种方式创建Bean：
 1、调用构造器创建Bean
 2、调用静态工厂方法创建Bean
 3、调用实例工厂方法创建Bean。
具体请看 [spring管理bean的三种创建方式](https://blog.csdn.net/magicianjun/article/details/78737840)

# 3、springMVC的执行流程是什么样的？
springMVC是由dispatchservlet为核心的分层控制框架。首先客户端发出一个请求web服务器解析请求url并去匹配dispatchservlet的映射url，如果匹配上就将这个请求放入到dispatchservlet，dispatchservlet根据mapping映射配置去寻找相对应的handel，然后把处理权交给找到的handel，handel封装了处理业务逻辑的代码，当handel处理完后会返回一个逻辑视图modelandview给dispatchservlet，此时的modelandview是一个逻辑视图不是一个正式视图，所以dispatchservlet会通过viewresource视图资源去解析modelandview，然后将解析后的参数放到view中返回到客户端并展现。

# 4、说一下AOP
AOP为Aspect Oriented Programming的缩写，意为面向切面编程，对方法的一个增强。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高开发的效率。

# 5、介绍下redis
redis是一个使用 C 语言编写的，开源的（BSD许可）高性能非关系型（NoSQL）的键值对数据库。它支持5种类型的数据结构，如 字符串（strings）， 散列（hashes）， 列表（lists）， 集合（sets）， 有序集合（sorted sets） 与范围查询。快速的原因：单线程，使用多路I/O复用模型，非阻塞IO。
持久化：
- RDB：根据指定的规则“定时”将内存中的数据存储在硬盘上，生成的快照；
优点：如果需要进行大规模数据的恢复，且对于数据恢复的完整性不是非常敏感，那RDB 方式要比AOF 方式更加的高效。
缺点：如果你对数据的完整性非常敏感，那么RDB 方式就不太适合你，因为即使你每5 分钟都持久化一次，当Redis 故障时，仍然会有近5 分钟的数据丢失。所以，Redis 还提供了另一种持久化方式，那就是AOF。
- AOF：每次执行命令后将命令本身记录下来，每次执行命令都会将命令写入到aof文件中。
缺点：比如在同样数据规模的情况下，AOF文件要比RDB文件的体积大。而且，AOF 方式的恢复速度也要慢于RDB 方式。
默认回复是用AOF。
plus：Redis基于Reactor模式开发了网络事件处理器，这个处理器被称为文件事件处理器。它的组成结构为4部分：多个套接字、IO多路复用程序、文件事件分派器、事件处理器。因为文件事件分派器队列的消费是单线程的，所以Redis才叫单线程模型。Redis 的瓶颈并不在 CPU，而在内存和网络。如果要使用 CPU 多核，可以搭建多个 Redis 实例来解决。

Redis集群参考：[Redis集群](https://blog.csdn.net/weixin_45829957/article/details/116355899)

# 6、谈一下java集合

```shell
Collection
	List：元素有序(指的是存储时，与存放顺序保持一致)、可重复的集合
		ArrayList   线程不安全   查询 get
		LinkedList  线程不安全   新增和删除操作add
		Vector  线程安全
	Set：元素无序、不可重复的集合 
		LinkedHashSet
ArrayList和LinkedList的异同
Map
	HashTable 线程安全  适用了synchronized
	HashMap   线程不安全
		LinkedHashMap
	ConcurrentHashMap 线程安全 采用 CAS + synchronized 来保证并发安全
```

# 7、多线程有几种实现方法,都是什么?同步有几种实现方法,都是什么?
java多线程的几种实现方式：
1.继承Thread类，重写run方法   无返回值
2.实现Runnable接口，重写run方法    无返回值
3.通过Callable和FutureTask创建线程   有返回值
4.通过线程池创建线程   有返回值

同步的实现方法：
我们通常说的保持同步，其实就是对共享资源的保护
1) synchronized关键字修饰方法
2) synchronized关键字锁定代码块
3) ReentrantLock显式加锁
4) ReentrantReadWriteLock显式加锁
5) 使用ThreadLocal进行线程本地存储
6) 利用可见性实现同步-- volatile
7) 使用原子性操作（原子类）来保证同步
8) 使用SingleThreadExecutor
9) 免锁容器。 如Vector, Hashtable这些早期容易，使用了大量的synchronized方法来保证同步
一) 加锁 （上面的1，2， 3，4）
二) 线程封闭，消除对资源的共享(5)
三) 利用可见性（6）
四) 原子类（7）
五) executor框架（8）
六) 使用同步类/免锁容器（9）

# 8、什么是乐观锁，什么是悲观锁。
1）悲观锁，就是对数据的冲突采取悲观的态度，也就是假设数据肯定会冲突，所以在数据开始读取的时候，就把数据锁定住。加锁释放锁的过程会造成消耗，所以性能不高。
大多数情况下依靠数据库的锁机制实现。
```SQL
select * from stock where id=#{id} for update;
```
2）乐观锁，认为数据一般情况下不会造成冲突，所以在数据进行提交更新的时候，才会正式对数据的冲突与否进行检测，如果发现冲突了，则让用户返回错误的信息。让用户决定如何去做。
大多数基于数据版本（Version）记录机制实现。
```SQL
update stock set num=new_num, version=version+1 where id=#{id} and version=#{version};
update stock SET num = num - #{buyNum} where id = #{id} and num - #{buyNum} >= 0;
```
乐观锁的更新操作，最好用主键或者唯一索引来更新，这样是行锁，否则更新时会锁表。

# 9、mybatis一级缓存和二级缓存。
MyBatis提供了一级缓存和二级缓存
一级缓存：也称为本地缓存，用于保存用户在一次会话过程中查询的结果，用户一次会话中只能使用一个sqlSession，一级缓存是自动开启的，不允许关闭。
MyBatis一级缓存内部设计简单，只是一个没有容量限定的HashMap，在缓存的功能性上有所欠缺。
二级缓存：也称为全局缓存，是mapper级别的缓存，是针对一个表的查结果的存储，可以共享给所有针对这张表的查询的用户。也就是说对于mapper级别的缓存不同的sqlsession是可以共享的。
cacheEnabled=true
二级缓存开启后，同一个namespace下的所有操作语句，都影响着同一个Cache，即二级缓存被多个SqlSession共享，是一个全局的变量。
当开启缓存后，数据的查询执行的流程就是 二级缓存 -> 一级缓存 -> 数据库。
由于默认的MyBatis Cache实现都是基于本地的，分布式环境下必然会出现读取到脏数据，需要使用集中式缓存将MyBatis的Cache接口实现，有一定的开发成本，直接使用Redis,Memcached等分布式缓存可能成本更低，安全性也更高。

# 10.什么是幂等性
幂等性：就是用户对于同一操作发起的一次请求或者多次请求的结果是一致的，不会因为多次点击而产生了副作用。

# 11.什么是泛型。
泛型：是一种把明确类型的工作推迟到创建对象或者调用方法的时候才去明确的特殊的类型。也就是说在泛型使用过程中，操作的数据类型被指定为一个参数，而这种参数类型可以用在类、方法和接口中，分别被称为泛型类、泛型方法、泛型接口
- 1)泛型类  ArrayList类就是一个泛型类
- 2)泛型接口
- 3)泛型方法
- 4)泛型通配符
集合泛型为String类、Integer、泛型通配符?

# 12.继承和接口的关系
一个接口可以继承多个接口.
interface C extends A, B {}是可以的.
一个类可以实现多个接口:
class D implements A,B,C{}
但是一个类只能继承一个类,不能继承多个类
class B extends A{}

# 13.SpringBoot 配置加载顺序?
1.properties文件 
2.YAML文件 
3.系统环境变量 
4.命令行参数

# 14.SpringBoot启动过程
SpringBoot启动过程主要分为bootstrapContext创建、环境准备、applicationContext准备、bean加载、runner调用五个步骤

# 15.说一下MYSQL的索引

- 优势：
	检索:可以提高数据检索的效率，降低数据库的IO成本
	排序:通过索引列对数据进行排序，降低了CPU的消耗
- 劣势:
	占磁盘空间
	降低更新表的效率

**分类：**
应用层次上划分：
- 单列索引
- 组合索引
- 全文索引(MyISAM,InnoDB5.6以后)
- 空间索引

存储结构上
B树，B+树，hash索引

**索引原理**
B树和B+树
聚集索引(InnoDB)
主键索引(聚集索引)的叶子结点会存储数据行，也就是说数据和索引在一起
非聚集索引(MyISAM)
B+树叶子结点只会存储数据行（数据文件）的指针，简单来说就是数据和索引不在一起

**索引失效的情况**
1、使用!= 或者 <> 导致索引失效
2、类型不一致导致的索引失效
3、函数导致的索引失效
4、运算符导致的索引失效
5、OR引起的索引失效
6、模糊搜索导致的索引失效
7、NOT IN、NOT EXISTS导致索引失效

# 16.Mysql的索引是什么数据结构，为什么用这种结构
- B-tree： 从两个方面来回答
	- B+树的磁盘读写代价更低：B+树的内部节点并没有指向关键字具体信息的指针，因此其内部节点相对B(B-)树更小，如果把所有同一内部节点的关键字存放在同一盘块中，那么盘块所能容纳的关键字数量也越多，一次性读入内存的需要查找的关键字也就越多，相对IO读写次数就降低了。
	- 由于B+树的数据都存储在叶子结点中，分支结点均为索引，方便扫库，只需要扫一遍叶子结点即可，但是B树因为其分支结点同样存储着数据，我们要找到具体的数据，需要进行一次中序遍历按序来扫，所以B+树更加适合在区间查询的情况，所以通常B+树用于数据库索引。
- Hash：
虽然可以快速定位，但是没有顺序，IO复杂度高；
基于Hash表实现，只有Memory存储引擎显式支持哈希索引 ；
其他详见： [MySQL索引面试题](https://blog.csdn.net/weixin_45545542/article/details/117929169)
- 二叉树： 树的高度不均匀，不能自平衡，查找效率跟数据有关（树的高度），并且IO代价高。
- 红黑树： 树的高度随着数据量增加而增加，IO代价高。

# 17.ConcurrentHashMap 怎么保证线程安全
JDK 1.8 以前通过分段锁，JDK 1.8 以后通过 CAS + Synchronized

# 18.ConcurrentHashMap 在 JDK 1.8 前后的锁有什么区别
JDK1.7 中的 ConcurrentHashMap 是由 Segment 数组结构和 HashEntry 数组结构组成,Segment 继承了 ReentrantLock，所以 Segment 是一种可重入锁
JDK1.8 中的ConcurrentHashMap 选择了与 HashMap 相同的Node数组+链表+红黑树结构
锁粒度降低，并发度变高
Hashtable 是使用 synchronized来实现线程安全的

# 19.在java中wait和sleep方法的不同？
在等待时wait会释放锁，而sleep一直持有锁。Wait通常被用于线程间交互，sleep通常被用于暂停执行。

# 20.谈谈对Java中的volatile的理解。
1.不同线程对这个变量进行操作时的可见性。新值对其他线程来说是立即可见的。它会保证修改的值会立即被更新到主存中，当有其他线程读取到新值
2.它还禁止指令重排
volatile无法保证对变量的操作都是原子性的
volatile最适合一个线程写，多个线程读的场景，如果有多个线程并发写操作，仍然需要使用锁或者线程安全的容器或者原子变量来替代。

# 21.用Java实现阻塞队列。
java实现阻塞队列的方式有
1.wait()和notify()
2.并发类 
常见的：ArrayBlockingQueue
		LinkedBlockingQueue
		PriorityBlockingQueue
3.ReentrantLock和Condition

实现原理：
支持阻塞的插入方法：当队列满时，队列会阻塞插入元素的线程，直到队列不满。（put插入）
支持阻塞的移除方法：当队列为空时，获取元素的线程会等待队列变为非空。（take获取）

# 22.线程池参数有哪些？
ThreadPoolExecuter有7个参数corePoolSize 线程池核心线程大小，maximumPoolSize 线程池最大线程数量，keepAliveTime 空闲线程存活时间，unit 空闲线程存活时间单位，workQueue 工作队列，threadFactory 线程工厂，handler 拒绝策略
1.核心线程大小：线程池中会维护一个最小的线程数量，即使这些线程处理空闲状态，他们也不会被销毁，除非设置了allowCoreThreadTimeOut。这里的最小线程数量即是corePoolSize
2.最大线程数量：
3.空闲线程存活时间：
4.空闲线程存活时间单位：
5.工作队列：
ArrayBlockingQueue
LinkedBlockingQuene
SynchronousQuene
PriorityBlockingQueue
6.线程工厂
7.拒绝策略

# 23.介绍下springboot？
是一个快速开发框架，通过用MAVEN依赖的继承方式，帮助我们快速整合第三方常用框架，完全采用注解化（使用注解方式启动SpringMVC），简化XML配置，内置HTTP服务器（Tomcat，Jetty），最终以Java应用程序进行执行。

# 24.ApplicationContext和BeanFactory的区别？
1.BeanFactory是容器所有容器接口的父类，提供了最基本的bean相关的功能，而ApplicationContext是继承之BeanFactory，在BeanFactory的基础上扩展了更多的功能
2.ApplicationContext增加了SPEL语言的支持（#{xx.xx}等配置）、 消息发送、响应机制

# 25.Java @interface和interface的区别
1. interface：声明了一个Java的接口
2. @interface：是用来修饰Annotation的，它不是interface。这是关键字声明隐含了一个信息，他是继承了 java.lang.annotation.Annotation接口，而不是声明了一个interface.

# 26.有哪些类型的通知（Advice）？
- 前置通知(Before Advice）
- 返回之后通知(After Retuning Advice)
- 抛出（异常）后执行通知(After Throwing Advice)
- 后置通知(After Advice)
- 围绕通知(Around Advice)

# 27.Redis为什么这么快？
1.完全基于内存，绝大部分请求是纯粹的内存操作，非常快速。数据存在内存中，类似于 HashMap，HashMap 的优势就是查找和操作的时间复杂度都是O(1)；
2.数据结构简单，对数据操作也简单，Redis 中的数据结构是专门进行设计的；
3.采用单线程，避免了不必要的上下文切换和竞争，也不存在多进程或者多线程导致的切换而消耗 CPU，不用去考虑各种锁的问题，不存在加锁释放锁操作，没有因为可能出现死锁而导致的性能消耗；
4.使用 I/O 多路复用模型，非阻塞 IO；

# 28.介绍下nacos
- nacos注册中心的原理是通过微服务轮询向nacos发送请求。
- 通过namespace来隔离，区分dev，prod，sit环境
- 通过group来区分不同的业务
- nacos可以不通过git文件，可以通过导入或者页面配置相应的参数 自定义的一般放入bootstrap.yml(优先级高于applicaton.yml)
- nacos的生效模式 是CopyOnWrite模式  通过参数写入备份，同步备份文件实现参数生效的，缺点：不能实时一致性，占用内存

# 29.运行时异常有哪些？
NullPointerException（空指针异常）
IndexOutOfBoundsException（数组越界）
NumberFormatException（数字转换异常） 
ClassCastException（类型转换异常）
ArithemticException（数学运算异常）

# 30.说一下Redis缓存击穿、穿透、雪崩
- 1.redis缓存击穿是指某一个非常热点的key(即在客户端搜索的比较多的关键字)突然失效了,这时从客户端发送的大量的请求在redis里找不到这个key，就会去数据里找，最终导致数据库压力过大崩掉。
解决方法：
1）使用Timetask做一个定时任务 使用Timetask做定时，每隔一段时间对一些热点key进行数据库查询，将查询出的结果更新至redis中。前条件是不会给数据库过大的压力。
2）通过synchronized+双重检查机制，当发生reids穿透的时候，这时海量请求发送到数据库。这时我们的解决办法是只让只让一个线程去查询这个热点key，其它线程保持阻塞状态(可以让它们sleep几秒)。当这个进入数据库的线程查询出key对应的value时，我们再将其同步至redis的缓存当中，其它线程睡醒以后再重新去redis里边请求数据。
- 2.redis穿透是指key缓存并且数据库不存在，所以每次查询都会查询数据库从而导致数据库崩溃。
解决方法： 拉黑其ip，布隆过滤器，布谷鸟过滤器
- 3.redis雪崩是指海量的请求去查询多个key时，此时redis缓存中失效或者查不到，然后海量的请求都去都去db查询，从而导致db压力突然飙升崩溃。
解决方法：1.设置缓存时,随机初始化其失效时间 2.将value的时效设置成永不过期 3.使用Timetask做一个定时任务，在失效之前重新刷redis缓存

# 31.安全排查有哪些
Xss
xml注入
Csv注入
会话管理
日志注入
反序列化
sql注入

# 32.内存溢出OOM(Out Of Memory)
通过MemoryAnalyzer分析dump文件

# 33.HashMap是怎么实现的？
jdk1.7的HashMap是用数组+链表实现的  
jdk1.8的HashMap是用数组+链表+红黑树实现的
16个数组

# 34.为什么使用红黑树而不使用其他的树形结构？
hashMmap中不仅存在查询，还存在修改的操作。红黑树的查询和修改效率处在链表和完全平衡二叉树之间

# 35.ArrayBlockingQueue和LinkedBlockingQueue的区别
1、ArrayBlockingQueue是数组结构的，LinkedBlockingQueue是链表结构的
2、ArrayBlockingQueue读写共用一把锁，不能做到同时（任意时刻）读写；LinkedBlockingQueue读写锁是分离的，只要链表不空或没有达到容量上限就能同时读写
3、ArrayBlockingQueue使用时必须指定容量，LinkedBlockingQueue可以不指定容量

# 36.CountDownLatch允许一个或者多个线程去等待其他线程完成操作。

# 37.索引失效的场景
1.模糊查询比如用like，betweeen
2.使用数据类型不正确
3.使用函数
4.最左原则
5.有空值null；索引不存储空值，如果不限制为not null，数据库会认为索引列有可能存在空
6.对索引列进行加减乘除
7.全表扫描快于索引，也不会使用索引

# 38.索引设计原则
1.最左匹配原则
2.为经常需要排序分组的字段建立索引order groupby distinct
3.为常作为查询条件的字段建立索引
4.限制索引的数目
5.尽量选择区分度高的字段建立索引
6.索引列不能参与计算
7.尽量扩展索引，不要新建索引
8.尽量使用数据量少的索引
9.尽量使用前缀来索引
10.删除不再使用或者很少使用的索引

命中率要高

# 39.mysql如何实现读写分离
mycat实现读写分离，mysql配置实现主从复制

# 40.mysql优化
mysql  profile，慢日志 ，explain才看有没有命中

# 41.MQTT是一个客户端-服务端架构的发布/订阅模式的消息传输协议。[参考详情](http://www.360doc.com/content/22/0515/18/22355405_1031488554.shtml)

bobex/javaQA

简介

发行版

贡献者

近期动态

bobex/javaQA .gitee-modal { width: 500px !important; }

简介

发行版

贡献者

近期动态

搜索帮助

bobex/javaQA