天天向上

面试官你好，我是XXX,来自于XXX。之前就职于XX科技有限公司，担任软件开发工程师一职。在职期间主要负责XX公司XX项目与研发。对线上问题处理，项目与数据库性能调优等问题都有自己的理解。对行业相关的研发设计流程也十分熟悉。因此决定面试咱们公司Java开发岗位。希望能获此机会，谢谢。

发布计划：先进行DDL(增加字段时不要加非空约束，否则会对之前有影响)，再发布代码，先发布服务提供方，再发布服务调用方

生产环境cpu飙升

启动耗时长

List

HashMap

HashSet

ConcurrentHashMap

HashTable

LinkedHashMap

TreeMap

vector

Stack

面试题

1.在实际开发中，对于需要多次或大量拼接的操作，在不考虑线程安全问题时，我们就应该尽可能使用 StringBuilder 进行 append 操作.
如果提前知道需要拼接 String 的个数，就应该直接使用带参构造器指定 capacity，以减少扩容的次数

2.对于程序中大量使用存在的字符串时，尤其存在很多已经重复的字符串时，使用 intern()方法能够节省内存空间

EXPLAIN

索引失效

设计索引原则

结构

索引种类,结构(覆盖索引,索引下推,回表)

调优(刷盘调优、exists与in、limit深分页优化、io优化：只查询需要的字段，减少数据传输量、索引优化：查询字段全走索引，减少回表查询 )

降低锁粒度、降低锁持有时间（insert与update）

普通索引,联合索引(B+树,数据页,explain)

批量操作,单线程变多线程,分页查询

数据量大:分库分表,冷热分离

union all效率高于union

列的原子性

行的唯一性

非主键值直接依赖主键列,不能间接依赖

分库分表标准:

面试题

分库分表问题:

分库方案

主主(双向同步)

主从

主备(故障切换)

redo log(重做日志、事务持久性)

undo log(回滚日志、事务原子性、保存相反的操作，进行insert会存delete)

bin log(二进制日志、备份数据)

relay log(中继日志)

底层实现

读未提交、读已提交、可重复读、串行化

问题

底层实现

实现过程

延伸

按照对数据操作类型

锁粒度划分

对待锁态度

按照加锁方式

其他

指关于数据库对象（如表、列、索引、视图、存储过程等）的信息(名字、数据类型、长度、精度等)，这些信息描述了这些对象的结构和属性

exists与in

MySQL自增ID用完了该怎么办?

数据库Hash索引与B+数索引区别

DI

切面执行顺序

SpringBoot启动流程

SpringBoot的starter加载

autowire和resource区别

BeanFactory与ApplicationContext

controller和service实在IOC同一个容器中吗?

Bean生命周期

Bean作用域

监听器 > 过滤器 > 拦截器 > servlet执行 > 拦截器 > 过滤器 > 监听器

通过三级缓存解决

工厂、模板、代理、单例

启动注解

缓存注解

常用注解

事务失效

事务传播特性

事务隔离级别

长事务

分布式事务

string (字符串) 
list (列表) 
 hash (字典) 
 set (集合) -> 用户标签,生成随机数抽奖
 zset (有序集合)  ->排行榜，社交需求，比如用户点赞

项目中如何用,用过哪些数据类型

主从同步

单线程为什么快

缓存雪崩,缓存穿透,缓存击穿

单机

高可用

1.setnx + expire(分开执行)

2.setnx + value值是过期时间

3.set的扩展命令（set ex px nx）

4.set ex px nx + 校验唯一随机值,再删除(避免误删)

5.Redisson

6.Redisson + RedLock

1. volatile-lru：从设置过期时间的数据集(server.db[i].expires)中挑选出最近最少使用的数据淘汰。没有设置过期时间的key不会被淘汰，这样就可以在增加内存空间的同时保证需要持久化的数据不会丢失

2. volatile-ttl：除了淘汰机制采用LRU，策略基本上与volatile-lru相似，从设置过期时间的数据集(server.db[i].expires)中挑选将要过期的数据淘汰，ttl值越大越优先被淘汰

3. volatile-random：从已设置过期时间的数据集(server.db[i].expires)中任意选择数据淘汰。当内存达到限制无法写入非过期时间的数据集时，可以通过该淘汰策略在主键空间中随机移除某个key

4. allkeys-lru：从数据集(server.db[i].dict)中挑选最近最少使用的数据淘汰，该策略要淘汰的key面向的是全体key集合，而非过期的key集合

5. allkeys-random：从数据集(server.db[i].dict)中选择任意数据淘汰

6. no-enviction：禁止驱逐数据，也就是当内存不足以容纳新入数据时，新写入操作就会报错，请求可以继续进行，线上任务也不能持续进行，采用no-enviction策略可以保证数据不被丢失，这也是系统默认的一种淘汰策略

策略选择

1.由于Redis在写入日志之前，不对命令进行语法检查，所以只记录执行成功的命令，避免出现记录错误命令的情况

2.而且在命令执行后再写日志不会阻塞当前的写操作。

AOF

RDB

混合

含义

解决方案

解耦

削峰

异步

幂等性

生产者

队列

消费者

RabbitMQ

kafka

rocketMQ

其他

Synchronized
与Reentrantlock

volatile

参数

痛点

JMM(Java内存模型)

1.获取client；
2.具体实现（查询条件主要封在QueryBuilder中，分页、排序、字段过滤、高亮主要封装在SourceBuilder中）

//1，构建QueryBuilder请求对象
QueryBuilder queryBuilder = QueryBuilders.matchQuery("title", "小米");
//2，构建SearchRequest请求对象，指定索引库
SearchRequest searchRequest = new SearchRequest("huizi");
//3,构建SearchSourceBuilder查询对象
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
//4，构建QueryBuilder对象指定查询方式和查询条件
//5,将QuseryBuilder对象设置到SearchSourceBuilder对象中
 sourceBuilder.query(queryBuilder);
//字段过滤
sourceBuilder.fetchSource(new String[]{"title","price","band","category","id"},new String[]{"images"});
//排序
sourceBuilder.sort("price", SortOrder.DESC);
//分页
sourceBuilder.from(0);
sourceBuilder.size(2);
//5，将SearchSourceBuilder设置到SearchRequest中
searchRequest.source(sourceBuilder);
try {
     //6,调用方法查询数据
     SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
     //7,解析返回结果
     SearchHit[] hits = searchResponse.getHits().getHits();
     for (int i = 0; i < hits.length; i++) {
          System.out.println("返回的结果： " + hits[i].getSourceAsString());
      }
} catch (IOException e) {
     e.printStackTrace();
}

1.获取client；
2.具体实现（查询条件主要封在QueryBuilder中，分页、排序、字段过滤、高亮主要封装在SourceBuilder中）

//多索引查询
SearchRequest searchRequest = new SearchRequest(new String[]{"huizi","huizi2"});
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("title", "手机");
matchQueryBuilder.minimumShouldMatch("80%");
sourceBuilder.query(matchQueryBuilder);
searchRequest.source(sourceBuilder);
try {
     SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
      //7,解析返回结果
      SearchHit[] hits = searchResponse.getHits().getHits();
      for (int i = 0; i < hits.length; i++) {
           System.out.println("返回的结果： " + hits[i].getSourceAsString());
       }
} catch (IOException e) {
     e.printStackTrace();
}

1.获取client；
2.具体实现（查询条件主要封在QueryBuilder中，分页、排序、字段过滤、高亮主要封装在SourceBuilder中）

//批量查询
MultiSearchRequest request = new MultiSearchRequest();
SearchRequest firstSearchRequest = new SearchRequest(new String[]{"huizi","huizi2"});
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.matchQuery("title", "小米"));
firstSearchRequest.source(searchSourceBuilder);
request.add(firstSearchRequest);
SearchRequest secondSearchRequest = new SearchRequest(new String[]{"huizi","huizi2"});
searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.matchQuery("band", "大米"));
secondSearchRequest.source(searchSourceBuilder);
request.add(secondSearchRequest);
try {
     MultiSearchResponse multiSearchResponse = client.msearch(request, RequestOptions.DEFAULT);
     MultiSearchResponse.Item[] responses = multiSearchResponse.getResponses();
     for (MultiSearchResponse.Item respons : responses) {
           SearchHit[] hits = respons.getResponse().getHits().getHits();
           for (int i = 0; i < hits.length; i++) {
                 System.out.println("返回的结果： " + hits[i].getSourceAsString());
            }
      }
} catch (IOException e) {
     e.printStackTrace();
}

1.获取client；
2.具体实现（查询条件主要封在QueryBuilder中，分页、排序、字段过滤、高亮主要封装在SourceBuilder中）

//布尔组合
SearchRequest searchRequest = new SearchRequest("huizi");
SearchSourceBuilder sourceBuilder = new SearchSourceBuilder();
BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
//名字-小米
MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("title", "小米").minimumShouldMatch("80%");
//品牌-小米
MatchQueryBuilder matchQueryBuilder2 = QueryBuilders.matchQuery("band", "小米").operator(Operator.AND);
//分类-化妆品
 MatchQueryBuilder matchQueryBuilder3 = QueryBuilders.matchQuery("category", "化妆品");
//图片路径- jjj模糊
FuzzyQueryBuilder fuzzyQueryBuilder = QueryBuilders.fuzzyQuery("title", "小米");
//价格 必须 2699
TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("price", "2699");
//must必须
boolQueryBuilder.must(matchQueryBuilder);
//must必须
boolQueryBuilder.must(termQueryBuilder);
//mustNot不能
//        boolQueryBuilder.mustNot(matchQueryBuilder2);
//should可以
boolQueryBuilder.should(matchQueryBuilder3);
//结果中过滤
//        boolQueryBuilder.filter(fuzzyQueryBuilder);
sourceBuilder.query(boolQueryBuilder);
searchRequest.source(sourceBuilder);
try {
     SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
     SearchHit[] hits = searchResponse.getHits().getHits();
     for (int i = 0; i < hits.length; i++) {
          System.out.println("返回的结果： " + hits[i].getSourceAsString());
        }
} catch (IOException e) {
      e.printStackTrace();
}

（1）统计某个字段的数量
ValueCountBuilder vcb= AggregationBuilders.count("count_uid").field("uid");
（2）去重统计某个字段的数量（有少量误差）
CardinalityBuilder cb= AggregationBuilders.cardinality("distinct_count_uid").field("uid");
（3）聚合过滤
FilterAggregationBuilder fab= AggregationBuilders.filter("uid_filter").filter(QueryBuilders.queryStringQuery("uid:001"));
（4）按某个字段分组，相当于sql中的group by
TermsBuilder tb= AggregationBuilders.terms("group_name").field("name");
（5）求和
SumBuilder sumBuilder= AggregationBuilders.sum("sum_price").field("price");
（6）求平均
AvgBuilder ab= AggregationBuilders.avg("avg_price").field("price");
（7）求最大值
MaxBuilder mb= AggregationBuilders.max("max_price").field("price");
（8）求最小值
MinBuilder min= AggregationBuilders.min("min_price").field("price");
（9）按日期间隔分组
DateHistogramBuilder dhb= AggregationBuilders.dateHistogram("dh").field("date");
（10）获取聚合里面的结果
TopHitsBuilder thb= AggregationBuilders.topHits("top_result");
（11）嵌套的聚合
NestedBuilder nb= AggregationBuilders.nested("negsted_path").path("quests");
（12）反转嵌套
AggregationBuilders.reverseNested("res_negsted").path("kps ");
（13）拼接
.script 在后面拼接参数

searchSourceBuilder.aggregation(aggregationBuilder);
            request.source(searchSourceBuilder);

倒排索引

query

aggs

highlight

sort

from和size

post_filter

hits

took

shard

timeout

有时,循环太频繁，判断条件一直为false,JIT会激进优化从if(obj!=null)优化为if(false).这就属于：循环表达式外提(Loop Expression Hoisting)

标记一清除算法（Mark-Sweep）老年代

复制算法（copying）新生代

标记-压缩算法（Mark-Compact）老年代

空闲列表

指针碰撞

并发问题解决方案

C2 编译器优化

新生代,老年代大小比例

进入老年代年龄

调整Eden 和幸存者区比例

禁用偏向锁

1.开闭原则:对拓展开放,对修改关闭

2.单一职责原则:只做一件事

3.里氏替换原则:父类与子类的行为要保持与预期相符

4.迪米特法则:与外界耦合越少越好

5.接口隔离原则:将大接口拆分成多个以某个事务为边界的小接口

6.依赖倒置原则:面向接口编程

应用

应用

持久连接的特点是，只要任意一端没有明确提出断开连接，则保持 TCP 连接状态。

1.客户端与服务端的连接保活技术（连接复用），可以减少 TCP 连接的重复建立和断开所造成的额外开销，减轻服务器端的负载，减少响应时间
2.Connection是个逐跳首部，不会被最终传递给目标，因此，如果中间有代理服务器，最终客户端会与代理服务器建立长连接而不是目标服务器

稳定通信,三次是最低保证
同时,为了保证数据有序,服务器与客户端要交换序列

Http(类似公共协议)不会有粘包问题(没规定好数据与数据之间字符串分隔符,如前4个字节是一个包,结果获取了前7个字节数据);
自定义协议规定好分隔符或者固定长度,就可以避免

TCP(传输层):端口
IP(网络层):IP地址
ARP(网络层):地址解析协议
frame:MAC地址(通过ARP协议得到)

不知道大家有没有用过2010年左右（或许更早）2G时代的手机，可以运行那种基于J2ME的QQ，能聊天，看个空间，偷个菜（文字版）什么的。这种手机一般都有个缺点就是不能后台运行，一旦去做其他事情（玩游戏，看小说等），QQ就掉线了，就不能收到QQ消息了。如果想要实时接收到女神消息，就要一直保持打开着QQ，不能去做其他事情。这就类似于BIO，阻塞的。

后来QQ出了一个手机业务，叫超级QQ（每月10块呢），可以伪实时在线，同时更快的升级。之所以叫他伪实时在线，是因为它的实现方式是：当QQ收到消息时，腾讯会以短信的形式发到手机上，告诉你某某给你发消息了，请及时处理之类的（也可以直接回复短信，QQ上也会自动转发过去，不太相关暂时忽略）。此时再去登录QQ，就能立刻收到消息了。虽然手机同一时刻依然只能做一件事情，但是在没有QQ消息的时候也无需一直等待了，从而从容不铺去做别的事情。也就是非阻塞的了。

这个超级QQ的业务就像是NIO：人就是Selector，监听事件。短信就像是一个事件。QQ就像是Channel，建立沟通通道。人看到短信，根据短信内容，从而决定要不要打开QQ，处理消息

切换窗口：按下⌘+Tab
最大化窗口（⌃⌘+F）：本窗口视觉上占满全部屏幕，存在感最大
正常窗口：本窗口视觉上和其他本程序或者其他程序的窗口共用桌面
最小化窗口（⌘+M）：有两种设置：一种是本窗口在视觉上能见，但是最小，不占用桌面，挪动到Dock的右边，一种是“本窗口”视觉上不可见，最小化（隐藏）到Dock的程序图标中（这个隐藏和下面的⌘+H的主要区别就是⌘+M针对单独的一个窗口，⌘+H是隐藏程序的所有窗口）
隐藏程序的所有窗口（⌘+H）：整个程序从视觉上消失，不显示在屏幕的任何地方，但只是看不见而已，其他一切照旧
关闭窗口（⌘+W）：本窗口实际上被关闭，所有和本窗口相关的资源释放，如果文件有编辑会提示保存，但和本程序的其他窗口无关
关闭程序（⌘+Q）：程序实际上被关闭，本程序所有的窗口关闭，所有资源释放

⌘（command）、⎇（option）、⌃（control）、⎋（esc）、⇧（shift）、⌅（enter）
⇪（caps lock）、↩（return）、↖（home）、↘（end）、⇟（pagedown）、⇞（pageup）

编辑代码查看了调用类实现逻辑，然后可以使用后退快捷键，快速回到刚才待编辑的代码处：⌘ + ⌥ + ← / →(方向键)
查看历史文件,并且在弹出窗口内可以使用关键键快速查找：⌘ +E
统一命名：⇧   + F6