姓  名： 郑 清
求职意向： Java开发工程师
专业技能:

熟练使用Java面向对象编程，具有良好的编程习惯以及CSDN技术文档编写习惯；
熟练使用Eclipse/IDEA等开发工具；
熟练SVN，Maven，Git等项目管理工具;
熟练Spring，SpringMVC，Hibernate，MyBatis等开源框架技术；
掌握SpringBoot+SpringCloud微服务架构；
掌握MySql数据库及其优化，了解Oracle
掌握Redis中央缓存和ES，Lucene全文检索，分布式文件系统FastDFS；
掌握HTML，CSS，JavaScript，Ajax，Bootstrap， jQuery，EasyUI，layui，Vue，Node.js等前端开发技术；
掌握FreeMarker，Velocity，Thymeleaf等模板引擎技术
了解Linux常用命令及阿里云部署项目；
了解Docker，Nginx；
了解微信公众号、小程序的开发；
具体所会的技术点可查看个人技术博客（百度直接搜索：郑清 csdn）
GitHub开源项目：https://github.com/zhengqingya

证	书：
证书名称：英语托业桥B类五级
项目经验:
---------------------------------------------   项目一：   ---------------------------------------------------
项目名称： 骐达网	

项目描述： 该系统主要为用户提供代理服务，比如提供代理雨伞，代理快递，代理订餐，图书借阅等服务，主要有用户模块，服务模块，评论模块，订单模块，资讯模块，基础数据模块等

项目架构： Spring+SpringMVC+MyBatis+Layui

负责模块： 用户模块，登录模块，后台页面搭建

技术要点：

1）基础数据的CRUD

2）MyBatis-generator代码生成器技术

3）QQ第三方登录

4）使用百度地图的API完成校园雨伞的接送路线

5）基于Layui的后台页面搭建

6）Lucene查询，关键字高亮显示

7）EasyPoi完成报表的导入导出
---------------------------------------------   项目二：   ---------------------------------------------------
项目名称： 诚欣云	

项目描述： 该系统是为了拓宽线上销售渠道，增加销售额委托我司开发的一个线上销售系统，主要有产品模块，用户模块，支付模块，订单模块，基础模块等

项目架构： SpringBoot+SpringCloud+Vue

负责模块： 产品模块，基础模块

技术要点：

1）基础模块的CRUD

2）分布式文件系统(FastDFS)实现对图片的统一管理

3）ES建立产品索引库提高对产品页面的查询效率

4）Velocity模板实现产品主页和详情页面静态化

5）数据库采用垂直分表，反三范式优化

6）Redis对产品的大数据字段进行中央缓存

7）阿里云第三方短信实现登录注册
---------------------------------------------   项目三：   ---------------------------------------------------
项目名称： 华天水地	

项目描述： 该系统主要管理对仓库货物的进货，销售和预定等操作，实现了对库存货物的实时更新，方便管理员管理。整个项目主要有登陆模块，基础模块，客户模块，报表模块，产品模块等

项目架构： Spring+SpringMVC+SpringDataJPA+Shiro+EasyUI+echarts

负责模块： 报表模块和权限设计

技术要点：

1）员工和部门的基本信息管理

2）使用echarts完成从产品 订单 月份等不同维度的图表展示

3）使用Shiro权限框架分配给不同登录用户的角色

4）使用poi技术实现产品的批量导入导出

5）IDEA使用EasyCode代码生成器
---------------------------------------------   项目四：   ---------------------------------------------------
项目名称： 新龙机构管理平台	

项目描述： 该系统主要用于让客户更加了解该机构，提高机构知名度和专业度。有登陆模块，权限模块，基础模块，用户模块等

项目架构： Spring+SpringMVC+H-ui.admin

负责模块： 基础模块，登陆模块

技术要点：

1）基础数据的操作维护

2）使用FreeMarker实现页面静态化

3）QQ邮箱验证登陆

4）阿里云第三方短信

5）WebService第三方服务完成天气预报的查询
自我评价：
  软件技术专业，接触过C、Python、nodejs、Java、Android等多项技术栈，喜欢开源技术，GitHub上放有个人开源项目，具有良好的编程能力和逻辑思维能力，熟悉计算机相关专业知识，有较强解决问题能力和适应能力，思维敏捷，自学能力较强。有编写技术文档的习惯，csdn个人博客中心(https://blog.csdn.net/qq_38225558)。性格开朗，容易相处，有良好的团队合作意识和责任意识，抗压能力强，热爱技术分享以及关注新技术，具有geek精神。

很多时候面试中恨不得你会造火箭，工作中也就让你拧拧螺丝。为了不在面试中吃亏，面试前突击多看看面试题还是狠有必要的。这是一份常见Java面试题分类汇总，希望对大家有用！

 

初级面试题

 

Java面试题-基础篇一

Java面试题-基础篇二

Java面试题-集合框架篇三

Java面试题-基础篇四

Java面试题-基础篇五

Java面试题-javaweb篇六

Java面试题-javaweb篇七

Java面试题-框架篇八

Java面试题-框架篇九

Java面试题-持久层十

Java面试题-数据库篇十一

Java面试题-数据库篇十二

Java面试题-多线程篇十三

Java面试题-泛型篇十四

Java面试题-web篇十五

Java面试题-并发篇十六

Java面试题-算法篇十七

 

 

中级面试题

 

SSH框架面试题集锦

探讨Java中最常见的十道面试题(超经典)

Java中高级面试题

数据库面试常问的一些基本概念

Java中高级面试题（1）

Java中高级面试题（2）

Java中高级面试题（3）

Java中高级面试题（4）

Java中高级面试题（5）

Java中高级面试题（6）

spring面试题及答案解析（7）

Java中级面试题及答案解析（8）

Java中级面试题及答案解析（9）

Java中级面试题及答案解析（10）

 

 

笔试题库

 

Java笔试题库（01期）

Java笔试题库（03期）

Java笔试题库（04期）

Java笔试题库（05期）

Java笔试题库（06期）

Java笔试题库（07期）

Java笔试题库（08期）

Java笔试题库（09期）

Java笔试题库（10期）

【新玩儿法】Java笔试题库11期

【新玩法儿】Java笔试题库12期

【新玩法儿】Java笔试题库13期

 

 

 

面试后续补充

JVM面试题

Java 面试中遇到的坑

Java面试中遇到的坑【填坑篇】

Java面试中遇到的坑【篇二】

面试必问：Spring循环依赖的三种方式

面试中常问的List去重问题，你都答对了吗？

面试中的单例问题

漫画 | Redis常见面试问题（一）

漫画 | Redis常见面试问题（二）

面试问烂的 Spring AOP 原理、SpringMVC 过程

面试被问烂的 Spring IOC(求求你别再问了)

HTTP相关面试题

Java 面试题：百度前200页都在这里了

20个高级Java面试题汇总

 

 

面试经验

浅谈后端面试指南

当你收到面试通知后，通过如下的准备可以大大提升面试成功率

如何在面试中介绍自己的项目经验

 

 

面试中关于设计模式的见解

设计模式是什么鬼（初探）

设计模式是什么鬼（原型）

设计模式是什么鬼（单例）

设计模式是什么鬼（适配器）

设计模式是什么鬼（策略）

设计模式是什么鬼（状态）

设计模式是什么鬼（模板方法）

设计模式是什么鬼（门面）

设计模式是什么鬼（装饰）

设计模式是什么鬼（中介）

设计模式是什么鬼（组合）

设计模式是什么鬼（迭代器）

设计模式是什么鬼（备忘录）

设计模式是什么鬼（责任链）

设计模式是什么鬼（观察者）

设计模式是什么鬼（代理）

设计模式是什么鬼（工厂方法）

设计模式是什么鬼（桥接）

设计模式是什么鬼（抽象工厂）

设计模式是什么鬼（建造者）

设计模式是什么鬼（命令模式）

设计模式是什么鬼（访问者）

设计模式是什么鬼（解释器）

设计模式什么鬼？（终章）

 

 

后话，这些题不过是帮助您回顾所学，如果您看了这些题后获取了理想的职位，那也一定是您长期以来刻苦学习的结果。这些题型很多得益于热心的技术人的提供，如果您在参与面试笔试过程中发现了一些不错的题，非常欢迎您提供给我，我会整理出来分享给大家。

 

 

本篇完，欢迎微信扫码关注我的公众号Java知音，专注于Java技术分享，可以经常在微信上看一些不错的技术文章！

 

微信搜索：“二十同学” 公众号，欢迎关注一条不一样的成长之路

JAVA面试精选【Java基础第一部分】

JAVA面试精选【Java基础第二部分】

JAVA面试精选【Java基础第三部分】

JAVA面试精选【Java算法与编程一】

JAVA面试精选【Java算法与编程二】

 

Java高级工程师—面试(1)

Java高级工程师—面试(2)

Java高级工程师—面试(3)

BAT/网易等面试心得

阿里历年面试题

Java中高级面试题

数据库性能优化

 

1.面向对象和面向过程的区别

面向过程

优点：性能比面向对象高，因为类调用时需要实例化，开销比较大，比较消耗资源;比如单片机、嵌入式开发、Linux/Unix等一般采用面向过程开发，性能是最重要的因素。

缺点：没有面向对象易维护、易复用、易扩展
面向对象

优点：易维护、易复用、易扩展，由于面向对象有封装、继承、多态性的特性，可以设计出低耦合的系统，使系统更加灵活、更加易于维护

缺点：性能比面向过程低

2.Java的四个基本特性（抽象、封装、继承，多态）

抽象：就是把现实生活中的某一类东西提取出来，用程序代码表示，我们通常叫做类或者接口。抽象包括两个方面：一个是数据抽象，一个是过程抽象。数据抽象也就是对象的属性。过程抽象是对象的行为特征。

封装：把客观事物封装成抽象的类，并且类可以把自己的数据和方法只让可信的类或者对象操作，对不可信的进行封装隐藏。封装分为属性的封装和方法的封装。

继承：是对有着共同特性的多类事物，进行再抽象成一个类。这个类就是多类事物的父类。父类的意义在于抽取多类事物的共性。

多态：允许不同类的对象对同一消息做出响应。方法的重载、类的覆盖正体现了多态。

3.重载和重写的区别

重载：发生在同一个类中，方法名必须相同，参数类型不同、个数不同、顺序不同，方法返回值和访问修饰符可以不同，发生在编译时。

重写：发生在父子类中，方法名、参数列表必须相同，返回值小于等于父类，抛出的异常小于等于父类，访问修饰符大于等于父类；如果父类方法访问修饰符为private则子类中就不是重写。

4.构造器Constructor是否可被override

构造器不能被重写，不能用static修饰构造器，只能用public

private protected这三个权限修饰符，且不能有返回语句。

5.访问控制符public,protected,private,以及默认的区别

private只有在本类中才能访问；

public在任何地方都能访问；

protected在同包内的类及包外的子类能访问；

默认不写在同包内能访问。

6是否可以继承String类

String类是final类故不可以继承，一切由final修饰过的都不能继承。

7.String和StringBuffer、StringBuilder的区别

可变性

String类中使用字符数组保存字符串，private

final char value[]，所以string对象是不可变的。StringBuilder与StringBuffer都继承自AbstractStringBuilder类，在AbstractStringBuilder中也是使用字符数组保存字符串，char[]

value，这两种对象都是可变的。
线程安全性

String中的对象是不可变的，也就可以理解为常量，线程安全。AbstractStringBuilder是StringBuilder与StringBuffer的公共父类，定义了一些字符串的基本操作，如expandCapacity、append、insert、indexOf等公共方法。StringBuffer对方法加了同步锁或者对调用的方法加了同步锁，所以是线程安全的。StringBuilder并没有对方法进行加同步锁，所以是非线程安全的。
性能

每次对String 类型进行改变的时候，都会生成一个新的String 对象，然后将指针指向新的String 对象。StringBuffer每次都会对

StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。相同情况下使用

StirngBuilder 相比使用

StringBuffer 仅能获得10%~15% 左右的性能提升，但却要冒多线程不安全的风险。

8.hashCode和equals方法的关系

equals相等，hashcode必相等；hashcode相等，equals可能不相等。

9.抽象类和接口的区别

语法层次

抽象类和接口分别给出了不同的语法定义。
设计层次

抽象层次不同，抽象类是对类抽象，而接口是对行为的抽象。抽象类是对整个类整体进行抽象，包括属性、行为，但是接口却是对类局部（行为）进行抽象。抽象类是自底向上抽象而来的，接口是自顶向下设计出来的。
跨域不同

抽象类所体现的是一种继承关系，要想使得继承关系合理，父类和派生类之间必须存在"is-a"

关系，即父类和派生类在概念本质上应该是相同的。对于接口则不然，并不要求接口的实现者和接口定义在概念本质上是一致的，仅仅是实现了接口定义的契约而已，"like-a"的关系。

10.自动装箱与拆箱

装箱：将基本类型用它们对应的引用类型包装起来；

拆箱：将包装类型转换为基本数据类型；

Java使用自动装箱和拆箱机制，节省了常用数值的内存开销和创建对象的开销，提高了效率，由编译器来完成，编译器会在编译期根据语法决定是否进行装箱和拆箱动作。

11.什么是泛型、为什么要使用以及泛型擦除

泛型，即“参数化类型”。

创建集合时就指定集合元素的类型，该集合只能保存其指定类型的元素，避免使用强制类型转换。

Java编译器生成的字节码是不包涵泛型信息的，泛型类型信息将在编译处理是被擦除，这个过程即类型擦除。泛型擦除可以简单的理解为将泛型java代码转换为普通java代码，只不过编译器更直接点，将泛型java代码直接转换成普通java字节码。

类型擦除的主要过程如下：

1）.将所有的泛型参数用其最左边界（最顶级的父类型）类型替换。

2）.移除所有的类型参数。

12.Java中的集合类及关系图

List和Set继承自Collection接口。

Set无序不允许元素重复。HashSet和TreeSet是两个主要的实现类。

List有序且允许元素重复。ArrayList、LinkedList和Vector是三个主要的实现类。

Map也属于集合系统，但和Collection接口没关系。Map是key对value的映射集合，其中key列就是一个集合。key不能重复，但是value可以重复。HashMap、TreeMap和Hashtable是三个主要的实现类。

SortedSet和SortedMap接口对元素按指定规则排序，SortedMap是对key列进行排序。

13.HashMap实现原理

具体原理参考文章：
http://zhangshixi.iteye.com/blog/672697
http://www.admin10000.com/document/3322.html

14.HashTable实现原理

具体原理参考文章：
http://www.cnblogs.com/skywang12345/p/3310887.html
http://blog.csdn.net/chdjj/article/details/38581035

15.HashMap和HashTable区别

1）.HashTable的方法前面都有synchronized来同步，是线程安全的；HashMap未经同步，是非线程安全的。

2）.HashTable不允许null值(key和value都不可以) ；HashMap允许null值(key和value都可以)。

3）.HashTable有一个contains(Object

value)功能和containsValue(Object

value)功能一样。

4）.HashTable使用Enumeration进行遍历；HashMap使用Iterator进行遍历。

5）.HashTable中hash数组默认大小是11，增加的方式是old*2+1；HashMap中hash数组的默认大小是16，而且一定是2的指数。

6）.哈希值的使用不同，HashTable直接使用对象的hashCode； HashMap重新计算hash值，而且用与代替求模。

16.ArrayList和vector区别

ArrayList和Vector都实现了List接口，都是通过数组实现的。

Vector是线程安全的，而ArrayList是非线程安全的。

List第一次创建的时候，会有一个初始大小，随着不断向List中增加元素，当List 认为容量不够的时候就会进行扩容。Vector缺省情况下自动增长原来一倍的数组长度，ArrayList增长原来的50%。

17.ArrayList和LinkedList区别及使用场景

区别

ArrayList底层是用数组实现的，可以认为ArrayList是一个可改变大小的数组。随着越来越多的元素被添加到ArrayList中，其规模是动态增加的。

LinkedList底层是通过双向链表实现的， LinkedList和ArrayList相比，增删的速度较快。但是查询和修改值的速度较慢。同时，LinkedList还实现了Queue接口，所以他还提供了offer(),

peek(), poll()等方法。
使用场景

LinkedList更适合从中间插入或者删除（链表的特性）。

ArrayList更适合检索和在末尾插入或删除（数组的特性）。

18.Collection和Collections的区别

java.util.Collection 是一个集合接口。它提供了对集合对象进行基本操作的通用接口方法。Collection接口在Java 类库中有很多具体的实现。Collection接口的意义是为各种具体的集合提供了最大化的统一操作方式。

java.util.Collections 是一个包装类。它包含有各种有关集合操作的静态多态方法。此类不能实例化，就像一个工具类，服务于Java的Collection框架。

19.Concurrenthashmap实现原理

具体原理参考文章：
http://www.cnblogs.com/ITtangtang/p/3948786.html
http://ifeve.com/concurrenthashmap/

20.Error、Exception区别

Error类和Exception类的父类都是throwable类，他们的区别是：

Error类一般是指与虚拟机相关的问题，如系统崩溃，虚拟机错误，内存空间不足，方法调用栈溢等。对于这类错误的导致的应用程序中断，仅靠程序本身无法恢复和和预防，遇到这样的错误，建议让程序终止。

Exception类表示程序可以处理的异常，可以捕获且可能恢复。遇到这类异常，应该尽可能处理异常，使程序恢复运行，而不应该随意终止异常。

21.Unchecked

Exception和Checked Exception，各列举几个#
Unchecked Exception:

a. 指的是程序的瑕疵或逻辑错误，并且在运行时无法恢复。

b. 包括Error与RuntimeException及其子类，如：OutOfMemoryError,

UndeclaredThrowableException, IllegalArgumentException,

IllegalMonitorStateException, NullPointerException, IllegalStateException,

IndexOutOfBoundsException等。

c. 语法上不需要声明抛出异常。

Checked Exception:

a. 代表程序不能直接控制的无效外界情况（如用户输入，数据库问题，网络异常，文件丢失等）

b. 除了Error和RuntimeException及其子类之外，如：ClassNotFoundException,

NamingException, ServletException, SQLException, IOException等。

c. 需要try catch处理或throws声明抛出异常。

22.Java中如何实现代理机制(JDK、CGLIB)

JDK动态代理：代理类和目标类实现了共同的接口，用到InvocationHandler接口。

CGLIB动态代理：代理类是目标类的子类，用到MethodInterceptor接口。

23.多线程的实现方式

继承Thread类、实现Runnable接口、使用ExecutorService、Callable、Future实现有返回结果的多线程。

24.线程的状态转换

25.如何停止一个线程

参考文章：
http://www.cnblogs.com/greta/p/5624839.html

26.什么是线程安全

线程安全就是多线程访问同一代码，不会产生不确定的结果。

27.如何保证线程安全

对非安全的代码进行加锁控制；

使用线程安全的类；

多线程并发情况下，线程共享的变量改为方法级的局部变量。

28.synchronized如何使用

synchronized是Java中的关键字，是一种同步锁。它修饰的对象有以下几种：

1). 修饰一个代码块，被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象；

2). 修饰一个方法，被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象；

3). 修改一个静态的方法，其作用的范围是整个静态方法，作用的对象是这个类的所有对象；

4). 修改一个类，其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。

29.synchronized和Lock的区别

主要相同点：Lock能完成synchronized所实现的所有功能

主要不同点：Lock有比synchronized更精确的线程语义和更好的性能。Lock的锁定是通过代码实现的，而synchronized是在JVM层面上实现的，synchronized会自动释放锁，而Lock一定要求程序员手工释放，并且必须在finally从句中释放。Lock还有更强大的功能，例如，它的tryLock方法可以非阻塞方式去拿锁。Lock锁的范围有局限性，块范围，而synchronized可以锁住块、对象、类。

30.多线程如何进行信息交互

void notify() 唤醒在此对象监视器上等待的单个线程。

void notifyAll() 唤醒在此对象监视器上等待的所有线程。

void wait() 导致当前的线程等待，直到其他线程调用此对象的notify()方法或notifyAll()方法。

void wait(long timeout) 导致当前的线程等待，直到其他线程调用此对象的notify()方法或notifyAll()方法，或者超过指定的时间量。

void wait(long timeout, int nanos) 导致当前的线程等待，直到其他线程调用此对象的notify()方法或notifyAll()方法，或者其他某个线程中断当前线程，或者已超过某个实际时间量。

31.sleep和wait的区别(考察的方向是是否会释放锁)

sleep()方法是Thread类中方法，而wait()方法是Object类中的方法。

sleep()方法导致了程序暂停执行指定的时间，让出cpu该其他线程，但是他的监控状态依然保持者，当指定的时间到了又会自动恢复运行状态，在调用sleep()方法的过程中，线程不会释放对象锁。而当调用wait()方法的时候，线程会放弃对象锁，进入等待此对象的等待锁定池，只有针对此对象调用notify()方法后本线程才进入对象锁定池准备。

32.多线程与死锁

死锁是指两个或两个以上的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力作用，它们都将无法推进下去。

产生死锁的原因：

一.因为系统资源不足。

二.进程运行推进的顺序不合适。

三.资源分配不当。

33.如何才能产生死锁

产生死锁的四个必要条件：

一.互斥条件：所谓互斥就是进程在某一时间内独占资源。

二.请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。

三.不剥夺条件:进程已获得资源，在末使用完之前，不能强行剥夺。

四.循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。

34.死锁的预防

打破产生死锁的四个必要条件中的一个或几个，保证系统不会进入死锁状态。

一.打破互斥条件。即允许进程同时访问某些资源。但是，有的资源是不允许被同时访问的，像打印机等等，这是由资源本身的属性所决定的。所以，这种办法并无实用价值。

二.打破不可抢占条件。即允许进程强行从占有者那里夺取某些资源。就是说，当一个进程已占有了某些资源，它又申请新的资源，但不能立即被满足时，它必须释放所占有的全部资源，以后再重新申请。它所释放的资源可以分配给其它进程。这就相当于该进程占有的资源被隐蔽地强占了。这种预防死锁的方法实现起来困难，会降低系统性能。

三.打破占有且申请条件。可以实行资源预先分配策略。即进程在运行前一次性地向系统申请它所需要的全部资源。如果某个进程所需的全部资源得不到满足，则不分配任何资源，此进程暂不运行。只有当系统能够满足当前进程的全部资源需求时，才一次性地将所申请的资源全部分配给该进程。由于运行的进程已占有了它所需的全部资源，所以不会发生占有资源又申请资源的现象，因此不会发生死锁。

四.打破循环等待条件，实行资源有序分配策略。采用这种策略，即把资源事先分类编号，按号分配，使进程在申请，占用资源时不会形成环路。所有进程对资源的请求必须严格按资源序号递增的顺序提出。进程占用了小号资源，才能申请大号资源，就不会产生环路，从而预防了死锁。

35.什么叫守护线程，用什么方法实现守护线程

守护线程是为其他线程的运行提供服务的线程。

setDaemon(boolean on)方法可以方便的设置线程的Daemon模式，true为守护模式，false为用户模式。

36.Java线程池技术及原理

参考文章：
http://www.cnblogs.com/dolphin0520/p/3932921.html

37.java并发包concurrent及常用的类

这个内容有点多，参考文章：

并发包诸类概览：http://www.raychase.net/1912

线程池：http://www.cnblogs.com/dolphin0520/p/3932921.html

锁：http://www.cnblogs.com/dolphin0520/p/3923167.html

集合：http://www.cnblogs.com/huangfox/archive/2012/08/16/2642666.html

38.volatile关键字

用volatile修饰的变量，线程在每次使用变量的时候，都会读取变量修改后的最的值。volatile很容易被误用，用来进行原子性操作。

Java语言中的volatile变量可以被看作是一种“程度较轻的

synchronized”；与

synchronized 块相比，volatile 变量所需的编码较少，并且运行时开销也较少，但是它所能实现的功能也仅是synchronized的一部分。锁提供了两种主要特性：互斥（mutual

exclusion）和可见性（visibility）。互斥即一次只允许一个线程持有某个特定的锁，因此可使用该特性实现对共享数据的协调访问协议，这样，一次就只有一个线程能够使用该共享数据。可见性必须确保释放锁之前对共享数据做出的更改对于随后获得该锁的另一个线程是可见的，如果没有同步机制提供的这种可见性保证，线程看到的共享变量可能是修改前的值或不一致的值，这将引发许多严重问题。Volatile变量具有synchronized的可见性特性，但是不具备原子特性。这就是说线程能够自动发现volatile

变量的最新值。

要使volatile变量提供理想的线程安全，必须同时满足下面两个条件：对变量的写操作不依赖于当前值；该变量没有包含在具有其他变量的不变式中。

第一个条件的限制使volatile变量不能用作线程安全计数器。虽然增量操作（x++）看上去类似一个单独操作，实际上它是一个由读取－修改－写入操作序列组成的组合操作，必须以原子方式执行，而volatile不能提供必须的原子特性。实现正确的操作需要使x 的值在操作期间保持不变，而volatile

变量无法实现这点。

每一个线程运行时都有一个线程栈，线程栈保存了线程运行时候变量值信息。当线程访问某一个对象时候值的时候，首先通过对象的引用找到对应在堆内存的变量的值，然后把堆内存变量的具体值load到线程本地内存中，建立一个变量副本，之后线程就不再和对象在堆内存变量值有任何关系，而是直接修改副本变量的值，在修改完之后的某一个时刻（线程退出之前），自动把线程变量副本的值回写到对象在堆中变量。这样在堆中的对象的值就产生变化了。

read and load 从主存复制变量到当前工作内存

use and assign 执行代码，改变共享变量值

store and write 用工作内存数据刷新主存相关内容

其中use and

assign 可以多次出现，但是这一些操作并不是原子性，也就是在read load之后，如果主内存count变量发生修改之后，线程工作内存中的值由于已经加载，不会产生对应的变化，所以计算出来的结果会和预期不一样。

39.Java中的NIO，BIO，AIO分别是什么

BIO:同步并阻塞，服务器实现模式为一个连接一个线程，即客户端有连接请求时服务器端就需要启动一个线程进行处理，如果这个连接不做任何事情会造成不必要的线程开销，当然可以通过线程池机制改善。BIO方式适用于连接数目比较小且固定的架构，这种方式对服务器资源要求比较高，并发局限于应用中，JDK1.4以前的唯一选择，但程序直观简单易理解。

NIO:同步非阻塞，服务器实现模式为一个请求一个线程，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。NIO方式适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，并发局限于应用中，编程比较复杂，JDK1.4开始支持。

AIO:异步非阻塞，服务器实现模式为一个有效请求一个线程，客户端的I/O请求都是由OS先完成了再通知服务器应用去启动线程进行处理.AIO方式使用于连接数目多且连接比较长（重操作）的架构，比如相册服务器，充分调用OS参与并发操作，编程比较复杂，JDK7开始支持。

40.IO和NIO区别

一.IO是面向流的，NIO是面向缓冲区的。

二.IO的各种流是阻塞的，NIO是非阻塞模式。

三.Java NIO的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择”通道：这些通道里已经有可以处理的输入，或者选择已准备写入的通道。这种选择机制，使得一个单独的线程很容易来管理多个通道。

41.序列化与反序列化

把对象转换为字节序列的过程称为对象的序列化。

把字节序列恢复为对象的过程称为对象的反序列化。

对象的序列化主要有两种用途：

一.把对象的字节序列永久地保存到硬盘上，通常存放在一个文件中；

二.在网络上传送对象的字节序列。

当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。

42.常见的序列化协议有哪些

Protobuf, Thrift, Hessian, Kryo

43.内存溢出和内存泄漏的区别

内存溢出是指程序在申请内存时，没有足够的内存空间供其使用，出现out of

memory。

内存泄漏是指分配出去的内存不再使用，但是无法回收。

44.Java内存模型及各个区域的OOM，如何重现OOM

这部分内容很重要，详细阅读《深入理解Java虚拟机》，也可以详细阅读这篇文章http://hllvm.group.iteye.com/group/wiki/2857-JVM

45.出现OOM如何解决

一. 可通过命令定期抓取heap dump或者启动参数OOM时自动抓取heap dump文件。

二. 通过对比多个heap dump，以及heap dump的内容，分析代码找出内存占用最多的地方。

三. 分析占用的内存对象，是否是因为错误导致的内存未及时释放，或者数据过多导致的内存溢出。

46.用什么工具可以查出内存泄漏

一. Memory

Analyzer－是一款开源的JAVA内存分析软件，查找内存泄漏，能容易找到大块内存并验证谁在一直占用它，它是基于Eclipse

RCP(Rich Client Platform)，可以下载RCP的独立版本或者Eclipse的插件。

二. JProbe－分析Java的内存泄漏。

三.JProfiler－一个全功能的Java剖析工具，专用于分析J2SE和J2EE应用程序。它把CPU、执行绪和内存的剖析组合在一个强大的应用中，GUI可以找到效能瓶颈、抓出内存泄漏、并解决执行绪的问题。

四. JRockit－用来诊断Java内存泄漏并指出根本原因，专门针对Intel平台并得到优化，能在Intel硬件上获得最高的性能。

五. YourKit-.NET & Java Profiling业界领先的Java和.NET程序性能分析工具。

六.AutomatedQA －AutomatedQA的获奖产品performance profiling和memory debugging工具集的下一代替换产品，支持Microsoft,Borland, Intel, Compaq 和 GNU编译器。可以为.NET和Windows程序生成全面细致的报告，从而帮助您轻松隔离并排除代码中含有的性能问题和内存/资源泄露问题。支持.Net 1.0,1.1,2.0,3.0和Windows 32/64位应用程序。

七.Compuware DevPartner Java Edition－包含Java内存检测,代码覆盖率测试,代码性能测试,线程死锁,分布式应用等几大功能模块

47.Java内存管理及回收算法

阅读这篇文章：http://www.cnblogs.com/hnrainll/archive/2013/11/06/3410042.html

48.Java类加载器及如何加载类(双亲委派)

阅读文章：
https://www.ibm.com/developerworks/cn/java/j-lo-classloader/（推荐）
http://blog.csdn.net/zhoudaxia/article/details/35824249

49.xml解析方式

一.DOM(JAXP

Crimson解析器)

二.SAX

三.JDOM

四.DOM4J
区别：

一.DOM4J性能最好，连Sun的JAXM也在用DOM4J。目前许多开源项目中大量采用DOM4J，例如大名鼎鼎的hibernate也用DOM4J来读取XML配置文件。如果不考虑可移植性，那就采用DOM4J.

二.JDOM和DOM在性能测试时表现不佳，在测试10M

文档时内存溢出。在小文档情况下还值得考虑使用DOM和JDOM。虽然JDOM的开发者已经说明他们期望在正式发行版前专注性能问题，但是从性能观点来看，它确实没有值得推荐之处。另外，DOM仍是一个非常好的选择。DOM实现广泛应用于多种编程语言。它还是许多其它与XML相关的标准的基础，因为它正式获得W3C

推荐(与基于非标准的Java模型相对)，所以在某些类型的项目中可能也需要它(如在JavaScript中使用DOM)。

三.SAX表现较好，这要依赖于它特定的解析方式－事件驱动。一个SAX检测即将到来的XML流，但并没有载入到内存(当然当XML流被读入时，会有部分文档暂时隐藏在内存中)。

50.Statement和PreparedStatement之间的区别

一.PreparedStatement是预编译的,对于批量处理可以大大提高效率. 也叫JDBC存储过程

二.使用

Statement 对象。在对数据库只执行一次性存取的时侯，用

Statement 对象进行处理。PreparedStatement

对象的开销比Statement大，对于一次性操作并不会带来额外的好处。

三.statement每次执行sql语句，相关数据库都要执行sql语句的编译，preparedstatement是预编译得,

preparedstatement支持批处理

四.
代码片段1:

String updateString = "UPDATE COFFEES SET SALES = 75 " + "WHERE

COF_NAME LIKE ′Colombian′";

stmt.executeUpdate(updateString);
代码片段2:

PreparedStatement updateSales = con.prepareStatement("UPDATE COFFEES SET

SALES = ? WHERE COF_NAME LIKE ? ");

updateSales.setInt(1, 75);

updateSales.setString(2, "Colombian");

updateSales.executeUpdate();

片断2和片断1的区别在于，后者使用了PreparedStatement对象，而前者是普通的Statement对象。PreparedStatement对象不仅包含了SQL语句，而且大多数情况下这个语句已经被预编译过，因而当其执行时，只需DBMS运行SQL语句，而不必先编译。当你需要执行Statement对象多次的时候，PreparedStatement对象将会大大降低运行时间，当然也加快了访问数据库的速度。

这种转换也给你带来很大的便利，不必重复SQL语句的句法，而只需更改其中变量的值，便可重新执行SQL语句。选择PreparedStatement对象与否，在于相同句法的SQL语句是否执行了多次，而且两次之间的差别仅仅是变量的不同。如果仅仅执行了一次的话，它应该和普通的对象毫无差异，体现不出它预编译的优越性。

五.执行许多SQL语句的JDBC程序产生大量的Statement和PreparedStatement对象。通常认为PreparedStatement对象比Statement对象更有效,特别是如果带有不同参数的同一SQL语句被多次执行的时候。PreparedStatement对象允许数据库预编译SQL语句，这样在随后的运行中可以节省时间并增加代码的可读性。

然而，在Oracle环境中，开发人员实际上有更大的灵活性。当使用Statement或PreparedStatement对象时，Oracle数据库会缓存SQL语句以便以后使用。在一些情况下,由于驱动器自身需要额外的处理和在Java应用程序和Oracle服务器间增加的网络活动，执行PreparedStatement对象实际上会花更长的时间。

然而，除了缓冲的问题之外，至少还有一个更好的原因使我们在企业应用程序中更喜欢使用PreparedStatement对象,那就是安全性。传递给PreparedStatement对象的参数可以被强制进行类型转换，使开发人员可以确保在插入或查询数据时与底层的数据库格式匹配。

当处理公共Web站点上的用户传来的数据的时候，安全性的问题就变得极为重要。传递给PreparedStatement的字符串参数会自动被驱动器忽略。最简单的情况下，这就意味着当你的程序试着将字符串“D'Angelo”插入到VARCHAR2中时，该语句将不会识别第一个“，”，从而导致悲惨的失败。几乎很少有必要创建你自己的字符串忽略代码。

在Web环境中，有恶意的用户会利用那些设计不完善的、不能正确处理字符串的应用程序。特别是在公共Web站点上,在没有首先通过PreparedStatement对象处理的情况下，所有的用户输入都不应该传递给SQL语句。此外，在用户有机会修改SQL语句的地方，如HTML的隐藏区域或一个查询字符串上，SQL语句都不应该被显示出来。

51.servlet生命周期及各个方法

参考文章http://www.cnblogs.com/xuekyo/archive/2013/02/24/2924072.html

52.servlet中如何自定义filter

参考文章http://www.cnblogs.com/javawebsoa/archive/2013/07/31/3228858.html

53.JSP原理

参考文章http://blog.csdn.net/hanxuemin12345/article/details/23831645

54.JSP和Servlet的区别

(1)JSP经编译后就变成了“类servlet”。

(2)JSP由HTML代码和JSP标签构成，更擅长页面显示；Servlet更擅长流程控制。

(3)JSP中嵌入JAVA代码，而Servlet中嵌入HTML代码。

55.JSP的动态include和静态include

(1)动态include用jsp:include动作实现，如<jsp:include page="abc.jsp" flush="true" />，它总是会检查所含文件中的变化，适合用于包含动态页面，并且可以带参数。会先解析所要包含的页面，解析后和主页面合并一起显示，即先编译后包含。

(2)静态include用include伪码实现，不会检查所含文件的变化，适用于包含静态页面，如<%@

include file="qq.htm" %>，不会提前解析所要包含的页面，先把要显示的页面包含进来，然后统一编译，即先包含后编译。

56.Struts中请求处理过程

参考文章http://www.cnblogs.com/liuling/p/2013-8-10-01.html

57.MVC概念

参考文章http://www.cnblogs.com/scwyh/articles/1436802.html

58.Springmvc与Struts区别

参考文章：
http://blog.csdn.net/tch918/article/details/38305395
http://blog.csdn.net/chenleixing/article/details/44570681

59.Hibernate/Ibatis两者的区别

参考文章http://blog.csdn.net/firejuly/article/details/8190229

60.Hibernate一级和二级缓存

参考文章http://blog.csdn.net/windrui/article/details/23165845

61.简述Hibernate常见优化策略

参考文章http://blog.csdn.net/shimiso/article/details/8819114

62.Springbean的加载过程(推荐看Spring的源码)

 

63.Springbean的实例化(推荐看Spring的源码)

 

64.Spring如何实现AOP和IOC(推荐看Spring的源码)

参考文章http://www.360doc.com/content/15/0116/21/12385684_441408260.shtml

65.Springbean注入方式

参考文章http://blessht.iteye.com/blog/1162131

66.Spring的事务管理

这个主题的参考文章没找到特别好的

67.Spring事务的传播特性

参考文章http://blog.csdn.net/lfsf802/article/details/9417095

68.springmvc原理

参考文章http://blog.sina.com.cn/s/blog_7ef0a3fb0101po57.html

69.springmvc用过哪些注解

参考文章http://aijuans.iteye.com/blog/2160141

70.Restful有几种请求

参考文章，http://www.infoq.com/cn/articles/designing-restful-http-apps-roth，该篇写的比较全。

71.Restful好处

(1)客户-服务器：客户-服务器约束背后的原则是分离关注点。通过分离用户接口和数据存储这两个关注点，改善了用户接口跨多个平台的可移植性；同时通过简化服务器组件，改善了系统的可伸缩性。

(2)无状态：通信在本质上是无状态的，改善了可见性、可靠性、可伸缩性.

(3)缓存：改善了网络效率减少一系列交互的平均延迟时间，来提高效率、可伸缩性和用户可觉察的性能。

(4)统一接口：REST架构风格区别于其他基于网络的架构风格的核心特征是，它强调组件之间要有一个统一的接口。

72.Tomcat，Apache，JBoss的区别

Apache:HTTP服务器(WEB服务器)，类似IIS，可以用于建立虚拟站点，编译处理静态页面，可以支持SSL技术，支持多个虚拟主机等功能。

Tomcat:Servlet容器，用于解析jsp，Servlet的Servlet容器，是高效，轻量级的容器。缺点是不支持EJB，只能用于java应用。

Jboss:应用服务器，运行EJB的J2EE应用服务器，遵循J2EE规范，能够提供更多平台的支持和更多集成功能，如数据库连接，JCA等，其对Servlet的支持是通过集成其他Servlet容器来实现的，如tomcat和jetty。

73.memcached和redis的区别

(1)性能对比：由于Redis只使用单核，而Memcached可以使用多核，所以平均每一个核上Redis在存储小数据时比Memcached性能更高。而在100k以上的数据中，Memcached性能要高于Redis，虽然Redis最近也在存储大数据的性能上进行优化，但是比起Memcached，还是稍有逊色。

(2)内存使用效率对比：使用简单的key-value存储的话，Memcached的内存利用率更高，而如果Redis采用hash结构来做key-value存储，由于其组合式的压缩，其内存利用率会高于Memcached。

(3)Redis支持服务器端的数据操作：Redis相比Memcached来说，拥有更多的数据结构和并支持更丰富的数据操作，通常在Memcached里，你需要将数据拿到客户端来进行类似的修改再set回去。这大大增加了网络IO的次数和数据体积。在Redis中，这些复杂的操作通常和一般的GET/SET一样高效。所以，如果需要缓存能够支持更复杂的结构和操作，那么Redis会是不错的选择。

74.如何理解分布式锁

参考文章：
http://blog.csdn.net/zheng0518/article/details/51607063
http://blog.csdn.net/nicewuranran/article/details/51730131。

75.你知道的开源协议有哪些

常见的开源协议有GPL、LGPL、BSD、Apache Licence

vesion 2.0、MIT，

76.json和xml区别

XML:

(1)应用广泛，可扩展性强，被广泛应用各种场合；

(2)读取、解析没有JSON快；

(3)可读性强，可描述复杂结构。

JSON:

(1)结构简单，都是键值对；

(2)读取、解析速度快，很多语言支持；

(3)传输数据量小，传输速率大大提高；

(4)描述复杂结构能力较弱。

77.设计模式

参考文章：http://www.cnblogs.com/beijiguangyong/archive/2010/11/15/2302807.html#_Toc281750445。

78.设计模式的六大原则

 

79.用一个设计模式写一段代码或画出一个设计模式的UML

参考文章http://www.cnblogs.com/beijiguangyong/archive/2010/11/15/2302807.html#_Toc281750445

80.高内聚，低耦合方面的理解

 

81.深度优先和广度优先算法

推荐看书籍复习！可参考文章：

http://blog.csdn.net/andyelvis/article/details/1728378
http://driftcloudy.iteye.com/blog/782873

82.排序算法及对应的时间复杂度和空间复杂度

推荐看书籍复习！可参考文章：
http://www.cnblogs.com/liuling/p/2013-7-24-01.html
http://blog.csdn.net/cyuyanenen/article/details/51514443
http://blog.csdn.net/whuslei/article/details/6442755

83.排序算法编码实现

参考http://www.cnblogs.com/liuling/p/2013-7-24-01.html

84.查找算法

 

85.B+树

参考http://www.cnblogs.com/syxchina/archive/2011/03/02/2197251.html

86.KMP算法

推荐阅读数据复习！参考http://www.cnblogs.com/c-cloud/p/3224788.html

87.hash算法及常用的hash算法

参考http://www.360doc.com/content/13/0409/14/10384031_277138819.shtml

88.如何判断一个单链表是否有环

参考文章：
http://www.jianshu.com/p/0e28d31600dd
http://my.oschina.net/u/2391658/blog/693277?p={{totalPage}}

89.队列、栈、链表、树、堆、图

推荐阅读数据复习！

90.linux常用命令

参考https://blog.csdn.net/qq_18298439/article/details/81737116

91.如何查看内存使用情况

参考http://blog.csdn.net/windrui/article/details/40046413

92.Linux下如何进行进程调度

推荐阅读书籍复习，参考文章：
http://www.cnblogs.com/zhaoyl/archive/2012/09/04/2671156.html
http://blog.csdn.net/rainharder/article/details/7975387

93.产生死锁的必要条件

参考http://blog.sina.com.cn/s/blog_5e3604840100ddgq.html

94.死锁预防

参考http://blog.sina.com.cn/s/blog_5e3604840100ddgq.html

95.数据库范式

参考http://www.360doc.com/content/12/0712/20/5287961_223855037.shtml

96.数据库事务隔离级别

参考http://blog.csdn.net/fg2006/article/details/6937413

97.数据库连接池的原理

参考http://blog.csdn.net/shuaihj/article/details/14223015

98.乐观锁和悲观锁

参考http://www.open-open.com/lib/view/open1452046967245.html

99.如何实现不同数据库的数据查询分页

参考http://blog.csdn.net/yztezhl/article/details/20489387

100.SQL注入的原理，如何预防

 

101.数据库索引的实现(B+树介绍、和B树、R树区别)

参考文章：
http://blog.csdn.net/kennyrose/article/details/7532032
http://www.xuebuyuan.com/2216918.html

102.SQL性能优化

参考文章：
http://database.51cto.com/art/200904/118526.htm
http://www.cnblogs.com/rootq/archive/2008/11/17/1334727.html

103.数据库索引的优缺点以及什么时候数据库索引失效

参考文章：
http://www.cnblogs.com/mxmbk/articles/5226344.html
http://www.cnblogs.com/simplefrog/archive/2012/07/15/2592527.html
http://www.open-open.com/lib/view/open1418476492792.html
http://blog.csdn.net/colin_liu2009/article/details/7301089
http://www.cnblogs.com/hongfei/archive/2012/10/20/2732589.html

104.Redis的数据类型

参考http://blog.csdn.net/hechurui/article/details/49508735

105.OSI七层模型以及TCP/IP四层模型

参考文章：
http://blog.csdn.net/sprintfwater/article/details/8751453
http://www.cnblogs.com/commanderzhu/p/4821555.html
http://blog.csdn.net/superjunjin/article/details/7841099

106.HTTP和HTTPS区别

参考：
http://blog.csdn.net/mingli198611/article/details/8055261
http://www.mahaixiang.cn/internet/1233.html

107.HTTP报文内容

参考文章：
https://yq.aliyun.com/articles/44675
http://www.cnblogs.com/klguang/p/4618526.html
http://my.oschina.net/orgsky/blog/387759

108.get提交和post提交的区别

参考文章：
http://www.cnblogs.com/hyddd/archive/2009/03/31/1426026.html

 

109.get提交是否有字节限制，如果有是在哪限制的

 

110.TCP的三次握手和四次挥手

阅读http://www.jianshu.com/p/f7d1010fa603

111.session和cookie的区别

参考http://www.cnblogs.com/shiyangxt/archive/2008/10/07/1305506.html

112.HTTP请求中Session实现原理

参考http://blog.csdn.net/zhq426/article/details/2992488

113.redirect与forward区别

参考http://www.cnblogs.com/wxgblogs/p/5602849.html

114.TCP和UDP区别

参考http://www.cnblogs.com/bizhu/archive/2012/05/12/2497493.html

115.DDos攻击及预防

参考文章：
http://blog.csdn.net/huwei2003/article/details/45476743
http://www.leiphone.com/news/201509/9zGlIDvLhwguqOtg.htm

 

Java基础

HashMap的源码，实现原理，JDK8中对HashMap做了怎样的优化。
	
HaspMap扩容是怎样扩容的，为什么都是2的N次幂的大小。
	
HashMap，HashTable，ConcurrentHashMap的区别。
	
极高并发下HashTable和ConcurrentHashMap哪个性能更好，为什么，如何实现的。
	
HashMap在高并发下如果没有处理线程安全会有怎样的安全隐患，具体表现是什么。
	
java中四种修饰符的限制范围。
	
Object类中的方法。
	
接口和抽象类的区别，注意JDK8的接口可以有实现。
	
动态代理的两种方式，以及区别。
	
Java序列化的方式。
	
传值和传引用的区别，Java是怎么样的，有没有传值引用。
	
一个ArrayList在循环过程中删除，会不会出问题，为什么。
	
@transactional注解在什么情况下会失效，为什么。
数据结构和算法

B+树
	
快速排序，堆排序，插入排序（其实八大排序算法都应该了解
	
一致性Hash算法，一致性Hash算法的应用
JVM

JVM的内存结构。
	
JVM方法栈的工作过程，方法栈和本地方法栈有什么区别。
	
JVM的栈中引用如何和堆中的对象产生关联。
	
可以了解一下逃逸分析技术。
	
GC的常见算法，CMS以及G1的垃圾回收过程，CMS的各个阶段哪两个是Stop the world的，CMS会不会产生碎片，G1的优势。
	
标记清除和标记整理算法的理解以及优缺点。
	
eden survivor区的比例，为什么是这个比例，eden survivor的工作过程。
	
JVM如何判断一个对象是否该被GC，可以视为root的都有哪几种类型。
	
强软弱虚引用的区别以及GC对他们执行怎样的操作。
	
Java是否可以GC直接内存。
	
Java类加载的过程。
	
双亲委派模型的过程以及优势。
	
常用的JVM调优参数。
	
dump文件的分析。
	
Java有没有主动触发GC的方式（没有）。
多线程

Java实现多线程有哪几种方式。
	
Callable和Future的了解。
	
线程池的参数有哪些，在线程池创建一个线程的过程。
	
volitile关键字的作用，原理。
	
synchronized关键字的用法，优缺点。
	
Lock接口有哪些实现类，使用场景是什么。
	
可重入锁的用处及实现原理，写时复制的过程，读写锁，分段锁（ConcurrentHashMap中的segment）。
	
悲观锁，乐观锁，优缺点，CAS有什么缺陷，该如何解决。
	
ABC三个线程如何保证顺序执行。
	
线程的状态都有哪些。
	
sleep和wait的区别。
	
notify和notifyall的区别。
	
ThreadLocal的了解，实现原理。
数据库相关

常见的数据库优化手段
	
索引的优缺点，什么字段上建立索引
	
数据库连接池。
	
durid的常用配置。
计算机网络

TCP，UDP区别。
	
三次握手，四次挥手，为什么要四次挥手。
	
长连接和短连接。
	
连接池适合长连接还是短连接。
设计模式

观察者模式
	
代理模式
	
单例模式，有五种写法，可以参考文章单例模式的五种实现方式
	
可以考Spring中使用了哪些设计模式
分布式相关

分布式事务的控制。
	
分布式锁如何设计。
	
分布式session如何设计。
	
dubbo的组件有哪些，各有什么作用。
	
zookeeper的负载均衡算法有哪些。
	
dubbo是如何利用接口就可以通信的。
缓存相关

redis和memcached的区别。
	
redis支持哪些数据结构。
	
redis是单线程的么，所有的工作都是单线程么。
	
redis如何存储一个String的。
	
redis的部署方式，主从，集群。
	
redis的哨兵模式，一个key值如何在redis集群中找到存储在哪里。
	
redis持久化策略。
框架相关

SpringMVC的Controller是如何将参数和前端传来的数据一一对应的。
	
Mybatis如何找到指定的Mapper的，如何完成查询的。
	
Quartz是如何完成定时任务的。
	
自定义注解的实现。
	
Spring使用了哪些设计模式。
	
Spring的IOC有什么优势。
	
Spring如何维护它拥有的bean。

 





 

作者 | 胡书敏

责编 | 刘静

出品 | CSDN（ID：CSDNnews）

本人目前在一家知名外企担任架构师，而且最近八年来，在多家外企和互联网公司担任Java技术面试官，前后累计面试了有两三百位候选人。在本文里，就将结合本人的面试经验，针对Java初学者、Java初级开发和Java开发，给出若干准备简历和准备面试的建议。

 



Java程序员准备和投递简历的实战技巧

 

1.1 简历中应包含的要素，一个都别落下

为了让简历更吸引技术面试官或其它相关筛选简历的人，大家在准备简历应当注意“直接”两字：能让筛选人能直接地看出本人的教育背景、工作经历和项目经理，并让他们“直接”感到这份简历能纳入考虑范围。

根据这个原则，大家可以按次序在简历中列出如下表所给出的要素。


			
简历中应包含的要素
			
			

			
目的
			
		

			
基本信息，比如姓名，性别，年龄，目前所在城市，是否在职，手机和电邮等。
			
			

			
1 让招聘方了解候选人的基本信息。

			
2 以便招聘方通过手机等方式能联系到候选人。
			
		

			
按时间倒叙写教育背景，一般只需要包含高中以上，初中高中等不必写，但需包含专业和学历学位信息。
			
			

			
用专业和学历学位等信息向招聘方证明自己的技术背景。
			
		

			
总结性地列出自己所掌握的技能。比如：

			
1 有3年Java经验，有2年Spring MVC经验。

			
2有3年Oracle经验，有2年Oracle调优经验。

			
等等
			
			

			
一般这些总结点是和职务需求是一致的，这样能让招聘方直接地感受到该候选人的匹配度。

			
在这基础上，可以适当列些能成功帮到自己的总结点。
			
		

			
按倒叙列出工作过的公司，并列出在这些公司里的项目经验，这部分的技能下文会详细描述。
			
			

			
在项目经验描述里，能通过项目用到的技术经验等，具体地给出自己“匹配”该岗位的证明。
			
		

			
可以列出和应聘岗位相关的培训经历和得到过的奖励
			
			

			
这些属于加分项，同等情况下能优先录用
			
		

			
用少量篇幅列出自己的兴趣和自我总结
			
			

			
让招聘公司进一步了解候选人
			
		
1.2 该如何描述公司的工作情况

这部分一般是按时间倒叙描述，比如可以按如下的格式写：

2015年11月到2017年10月，在xx公司，职务是Java高级开发。离职理由是想进一步发展。

2012年2月到2015年11月，在xx公司，职务是Java初级开发。离职理由是想进一步发展。

按此格式写之前的公司情况

这部分的内容应当尽量靠前，在罗列公司情况时，请大家注意如下的四个要点。

第一，工作情况可以和项目经验分开写，一般会在后继的项目经验里写具体用到的技术框架以及所做过项目的细节，在这里的工作情况描述里，可以不用过于复杂，让招聘方看到你之前的公司情况即可。

第二，尽量别出现长时间的“空白期”，比如上份工作是2月份结束的，而下份工作是6月开始的。如果出现持续三个月以上的“不在职状态”，需要在简历中说明情况，比如这段时间你是换城市发展了，或辞职复习考研或复习考公务员，总之得找个能说得过去的理由。

第三，在简历上，尽量别让人感觉你每份工作都做不长，但不能以此作假。比如我见过有候选人会合并公司，比如2016年11月到2017年3月在A公司，2017年4月到10月在B公司，他为了不让招聘方感觉他换工作太频繁，在简历上就写2016年11月到2017年10月在B公司工作，而故意合并了A公司的经历。这样的话，如果遇到背景调查，会露馅，即使有些公司不做调查，在劳动手册等材料上也能反应出真实的工作情况，所以这种做法有一定的风险性。

这里推荐的做法是，不要合并公司，但可以写明理由，比如当时小王是被外派公司A以人力派遣的形式外派到B公司，但没过多久A公司因某种原因不再具备人力派遣的资质了，这时小王就不得不终止与A公司的合同转而和B公司签约，这样虽然看上去小王是换了公司，但实际上没有。通过类似的合理解释，招聘方就不再会质疑小王的工作能力和稳定性了。

第四，可以写上合适的离职理由，尤其当你短时间里换工作比较多，可能引起招聘方的质疑的情况里，更该考虑些合适的理由。

合理的离职理由可以是，想为自己提供一个更大的发展空间，或想通过升级来独当一面，以此进一步提升自己的能力，或公司因资金等方面的原因倒闭了。总之，这不是我主观上不稳定，而是由于客观原因导致我不得不换工作。

而可能会导致没面试机会的离职原因是，待遇问题（虽然大家心知肚明，但不能这样写），或无法承受大压力，或同事领导排挤。这类理由往往会暴露出候选人的缺点，所以不建议大家采用。从这意义上来讲，“合同期满”也不是一个好的离职原因，因为如果候选人能力强，那么为什么原公司不和你续约呢？

总之，在描述公司情况时，一旦出现会让招聘方感觉你能力不强或不稳定时，一定得醒目地写上足以信服的理由，这样你的简历才会有机会被继续被读下去，进而你才会有技术面试的机会。

1.3 尽量把学习培训项目和毕业设计项目往商业项目上靠

商业项目是指能挣钱的项目，和它对应的就是些不以挣钱为目的的学习项目或毕业设计项目。正因为客户付了钱，所以商业项目的要求要远远高于学习或毕业设计项目，这也是为什么招聘公司会看重商业项目而会主动过滤学习项目的原因。

比如小张在大三时帮计算机系的王老师所在的ABC软件公司干了半年的活，如果小张在简历上写：“在校期间，从x年x月到x年x月完成了xx系统，用到了xx技术”，那么这多半会被当成类似于课程设计的学习经验，但如果再加上如下关键性的描述：“这个系统是属于xx公司的xx商业项目里的一部分，我和另外三位开发人员做了半年，最终这个系统成功上线并在客户xx公司的环境里投入运营”，那这样小张的商业项目总年限里就能加上这半年时间了。

又如小李在做毕业设计时，花了7个月的时间参与了导师的一个电商商业项目，他主要的工作是设计一个调度算法，但也参与了一些诸如订单管理模块的工作。如果他就平淡地写一句，毕业设计是xx，毕业论文是xx，那么招聘方看过就算了，也不会认为小李在做毕业设计时还有过商业项目经验，这样小李未免有些吃亏。

但如果这样写：“在x年x月到x年x月的7个月里，在毕业设计中，我参与了xx公司的xx电商项目，客户方是x，我参与了订单管理和xx模块，并设计了其中的调度算法，在我的毕业论文里，详细介绍了这种做法”。文字没修改太多，但足以让小李增加7个月的商业项目经验。

我们发现大多数初级程序员的水平其实也差不多，这时就得看谁的商业项目经验丰富了。比如有次我们无法从两位候选人中权衡，因为他们的综合条件和面试情况都差不多，但其中有一位在大三阶段有段为期6个月的商业项目实习经验，另一位没有（也有可能他也有但没当成商业项目来写），这种情况下我们就录用了有实习经验的候选人了。

1.4 描述项目的技巧

我们可以根据职位需求，从如下几个方面来描述项目经验。

第一，简要描述项目的背景，比如时间范围，客户是谁，项目规模有多大。如下是范例。

从x年x月到现在（这个时间范围至少是最近半年），我参与某外汇交易系统，客户是xx银行，这个项目组的构成是，1位项目经理外加10位开发，总共的规模大概在80个人月左右。

第二，大致描述项目的需求和包含哪些模块，然后简要说下你做了哪些模块，同时说下在这个项目用到的开发工具和主要技术点，这部分的描述如下所述。

这个外汇交易系统包括挂盘撮合成交、实盘成交、反洗钱和数据批处理等模块，我主要负责了挂盘撮合成交模块，其中用到了Spring MVC架构，数据库是Oracle，用Mybatis实现的ORM，该系统是运行发布在Weblogic服务器上，我们还用了Nginx来实现负载均衡，用Redis来缓存数据。在这个项目里，我还用到了JS实现了一些前台页面。

第三，这里可以结合职位的需求，描述JD里要求的技术在项目里是如何用的。同样这里也应围绕技术，而别多写业务细节

1.5 在简历中描述项目时可以添加的亮点

我们见过不少简历，在描述项目时，也能像上文一样，能根据招聘职位的具体要求展示出自己的匹配点，这种简历属于“达标”，即可以纳入考虑范围。在这个基础上，如果大家在项目里有下表列出的亮点，一定请写上，这就是大家优于别人的地方。

1. 数据库和JVM调优；

2. 你理解的框架底层代码；

3. 项目里用到的设计模式；

4. 项目管理和部署工具；

5. 结合若干案例，讲述你分析和解决bug的技能；

6. 其它能帮助到你的加分项，比如工期紧，用到新技术等。

1.6 哪些简历可以通过筛选

从面试官角度来看，除了学历等硬件条件外，如果简历满足如下的4点要求，就一般能有面试机会了。

1. 商业项目足量，且其中包含的技能和职位介绍很匹配；

2. 最近用到的技能和职位介绍很匹配；

3. 没有过长职业空白期或不稳定等情况；

4. 一定请记住，公司只能通过简历认识到你，简历上没写清楚等同于你不行。

其实这就是我们写简历的方向，而且，在针对具体公司投递简历时，还可以以此为目标，微调简历。

 



面试时该如何讲解技术项目赢得面试官好感

 

2.1 别害怕，因为面试官什么都不知道

面试官是人，不是神，拿到你的简历的时候，是没法核实你的项目细节的（一般公司会到录用后，用背景调查的方式来核实）。更何况，你做的项目是以月为单位算的，而面试官最多用30分钟来从你的简历上了解你的项目经验，所以你对项目的熟悉程度要远远超过面试官，所以你一点也不用紧张。如果你的工作经验比面试官还丰富的话，甚至还可以控制整个面试流程（笔者在面试方面成精后也经常干这种事情，大家一定也能行）。


			
 
			
			

			
你
			
			

			
面试官
			
		

			
对你以前的项目和技能
			
			

			
很了解
			
			

			
只能听你说，只能根据你说的内容做出判断
			
		

			
在面试过程中的职责
			
			

			
在很短的时间内防守成功即可
			
			

			
如果找不出漏洞，就只能算你以前做过
			
		

			
准备时间
			
			

			
面试前你有充足的时间准备
			
			

			
一般在面试前用30分钟阅读你的简历
			
		

			
沟通过程
			
			

			
你可以出错，但别出关键性的错误
			
			

			
不会太为难你，除非你太差
			
		

			
技巧
			
			

			
你有足够的技巧，也可以从网上找到足够多的面试题
			
			

			
其实就问些通用的有规律的问题
			
		
既然面试官无法了解你的底细，那么他们怎么来验证你的项目经验和技术？下面总结了一些常用的提问方式。


			
提问方式
			
			

			
目的
			
		

			
让你描述工作经验和项目（极有可能是最近的），看看你说的是否和简历上一致
			
			

			
看你是否真的做过这些项目
			
		

			
看你简历上项目里用到的技术，比如框架、数据库，然后针对这些技术提些基本问题
			
			

			
还是验证你是否做过项目，同时看你是否了解这些技术，为进一步提问做准备
			
		

			
针对某个项目，不断深入地问一些技术上的问题，或者从不同侧面问一些技术实现，看你前后回答里面是否有矛盾
			
			

			
深入核实你的项目细节
			
		

			
针对某技术，问些项目里一定会遇到的问题，比如候选人说做过数据库，那么就会问索引方面的问题
			
			

			
通过这类问题，核实候选人是否真的有过项目经验（或者还仅仅是学习经验）
			
		
2.2 面试时的错误表现

在面试过程中，如果候选人出现如下的表现，那么很有可能过不了面试，请大家注意。

1. 面试时介绍的项目时间等情况简历上写的不一致，这就有简历造假的嫌疑；

2. 介绍项目时只介绍业务，忽略技术。因为面试官只关心技术，不关心业务；

3. 对于提到的技术，连最基本的问题也回答不上，这就说明候选人这项技术没掌握；

4. 说得太流利或太磕磕巴巴，这就说明在背词或者是表达有问题。

2.3 面试中介绍项目的范例

第一步，介绍项目基本情况。

可以这样说，这个项目是xx产品的xx模块的，有xx和xx模块，我做了xx模块，用了半年，我的组里一共有5个人。这里可以谈下业务，但别深入，因为面试官不熟悉，也不想熟悉候选人的业务，这块时间控制在1分钟之内。

第二步，介绍项目里关键技术和管理方式。

可以这样说，这个项目里，我用到了Spring框架，用到nginx等组件，项目管理用Maven，部署用jenkins，静态扫描用Sonar，任务管理和bug管理用jira，平时采用敏捷的项目迭代方式，每天有站会，大约1月一个迭代版本。这块可以根据自己的情况来介绍，时间也别太长，估计用1分钟也就够了。

第三步，结合业务讲用到的技术，但别展开：

比如有个职位介绍，里面写到需要有数据库优化的经验，那么可以说，项目里xx模块，我用到MyCat作为分库分表，（不展开技术），上线后，数据库能承受住每秒2000个并发请求（说下用好的结果）。

又如一个JD里说要用到微服务技术，那么就可以说，项目里用到了Spring Cloud框架，用到了Ribbon，Eureka等组件，容器是Docker。用好以后，在发布时会发现，各模块之间的调用耦合性大大降低。

2.4 介绍项目时的要点归纳

从上述介绍项目的范例中，可以归纳出相关要点如下。

1. 面试前，需要阅读职位介绍，挖掘用过的技能要点，然后尽可能地在介绍项目里提到这些技能关键字；

2. 在介绍项目里，结合业务，提到职位介绍里的技术，因为一旦技术结业业务，就说明你有过相关技术的实践经验，而不是仅仅只会理论；

3. 别过多介绍业务，多抛出职位介绍里的关键字。还是这句话，面试官不关心业务，你提到业务只是以此证明你在实践中用过相关技术而已；

4. 此时还在项目介绍阶段，别过多展开技能，你抛出技能关键字后，面试官自然会问的。而一旦你过多展开技术，那么面试官就有可能感觉到你思路不清晰。

 



Java面试者该准备哪些加分项技能

 

3.1框架是重点，但别让人感觉你只会山寨别人的代码

一般工作在3年内的候选人，大多仅仅是能“山寨”别人的代码，也就是说能在现有框架的基础上，照着别人写的流程，扩展出新的功能模块。比如要写个股票挂单的功能模块，是会模仿现有的下单流程，然后从前端到后端再到数据库，依样画葫芦写一遍，最多把功能相关的代码点改掉。

如果单纯使用SSM框架，大多数项目都会有痛点。比如数据库性能差，或者业务模块比较复杂，并发量比较高，用Spring MVC里的Controller无法满足跳转的需求。所以我一般还会主动问：你除了依照现有框架写业务代码时，还做了哪些改动？

我听到的回答有：增加了Redis缓存，以避免频繁调用一些不变的数据。或者，在MyBitas的xml里，select语句where条件有isnull，即这个值有就增加一个where条件，对此，会对任何一个where增加一个不带isnull的查询条件，以免该语句当传入参数都是null时，做全表扫描。或者，干脆说，后端异步返回的数据量很大，时间很长，我在项目里就调大了异步返回的最大时间，或者对返回信息做了压缩处理，以增加网络传输性能。

对于这个问题，我不在乎听到什么回答，我只关心回答符不符逻辑。一般只要答对，我就会给出“在框架层面有自己的体会，有一定的了解”，否则，我就只会给出“只能在项目经理带领下编写框架代码，对框架本身了解不多”。

其实，在准备面试时，归纳框架里的要点并不难，我就不信所有人在做项目时一点积累也没，只要你说出来，可以说，这方面你就碾压了将近7成的竞争者。

3.2 别单纯看单机版的框架，适当了解些分布式

在描述项目里框架技术时，最好你再带些分布式的技术。下面我列些大家可以准备的分布式技术。


	
反向代理方面，nginx的基本配置，比如如何通过lua语言设置规则，如何设置session粘滞。如果可以，再看些nginx的底层，比如协议，集群设置，失效转移等；
	
	

	
远程调用dubbo方面，可以看下dubbo和zookeeper整合的知识点，再深一步，了解下dubbo底层的传输协议和序列化方式；
	
	

	
消息队列方面，可以看下kafka或任意一种组件的使用方式，简单点可以看下配置，工作组的设置，再深入点，可以看下Kafka集群，持久化的方式，以及发送消息是用长连接还是短拦截。
	
 

 

 

以上仅仅是用3个组件举例，大家还可以看下Redis缓存，日志框架，MyCAT分库分表等。准备的方式有两大类，第一是要会说怎么用，这比较简单，能通过配置文件搭建成一个功能模块即可，第二是可以适当读些底层代码，以此了解下协议，集群和失效转移之类的高级知识点。 

3.3 数据库方面，别就知道增删改查，得了解性能优化

在实际项目里，大多数程序员用到的可能仅仅是增删改查，当我们用Mybatis时，这个情况更普遍。不过如果你面试时也这样表现，估计你的能力就和其它竞争者差不多了。

这方面，你可以准备如下的技能：


	
SQL高级方面，比如group by, having，左连接，子查询（带in），行转列等高级用法；
	
	

	
建表方面，你可以考虑下，你项目是用三范式还是反范式，理由是什么？
	
	

	
尤其是优化，你可以准备下如何通过执行计划查看SQL语句改进点的方式，或者其它能改善SQL性能的方式（比如建索引等）；
	
	

	
如果你感觉有能力，还可以准备些MySQL集群，MyCAT分库分表的技能。比如通过LVS+Keepalived实现MySQL负载均衡，MyCAT的配置方式。同样，如果可以，也看些相关的底层代码。
	
 

 

 

 

哪怕你在前三点表现一般，那么至少也能超越将近一般的候选人，尤其当你在SQL优化方面表现非常好，那么你在面试高级开发时，数据库层面一定是达标的，如果你连第四点也回答非常好，那么恭喜你，你在数据库方面的能力甚至达到了初级架构的级别。

3.4 Java核心方面，围绕数据结构和性能优化准备面试题

Java核心这块，网上的面试题很多，不过在此之外，大家还应当着重关注集合（即数据结构）和多线程并发这两块，在此基础上，大家可以准备些设计模式和虚拟机的说辞。

下面列些我一般会问的部分问题：


	
String a = "123"; String b = "123"; a==b的结果是什么？这包含了内存，String存储方式等诸多知识点；
	
	

	
HashMap里的hashcode方法和equal方法什么时候需要重写？如果不重写会有什么后果？对此大家可以进一步了解HashMap（甚至ConcurrentHashMap）的底层实现；
	
	

	
ArrayList和LinkedList底层实现有什么差别？它们各自适用于哪些场合？对此大家也可以了解下相关底层代码；
	
	

	
volatile关键字有什么作用？由此展开，大家可以了解下线程内存和堆内存的差别；
	
	

	
CompletableFuture，这个是JDK1.8里的新特性，通过它怎么实现多线程并发控制？
	
	

	
JVM里，new出来的对象是在哪个区？再深入一下，问下如何查看和优化JVM虚拟机内存；
	
	

	
Java的静态代理和动态代理有什么差别？最好结合底层代码来说。
	
 

 

 

 

 

 

 

通过上述的问题点，我其实不仅仅停留在“会用”级别，比如我不会问如何在ArrayList里放元素。大家可以看到，上述问题包含了“多线程并发”，“JVM优化”，“数据结构对象底层代码”等细节，大家也可以举一反三，通过看一些高级知识，多准备些其它类似面试题。

3.5 Linux方面，至少了解如何看日志排查问题

如果候选人能证明自己有“排查问题”和“解决问题”的能力，这绝对是个加分项，但怎么证明？目前大多数的互联网项目，都是部署在Linux上，也就是说，日志都是在Linux，下面归纳些实际的Linux操作。


	
能通过less命令打开文件，通过Shift+G到达文件底部，再通过?+关键字的方式来根据关键来搜索信息；
	
	

	
能通过grep的方式查关键字，具体用法是, grep 关键字 文件名，如果要两次在结果里查找的话，就用grep 关键字1 文件名 | 关键字2 --color。最后--color是高亮关键字；
	
	

	
能通过vi来编辑文件；
	
	

	
能通过chmod来设置文件的权限。
	
 

 

 

 

当然，还有更多更实用的Linux命令，但在实际面试过程中，不少候选人连一条linux命令也不知道。还是这句话，你哪怕知道些很基本的，也比一般人强了。 

3.6 通读一段底层代码，作为加分项

如何证明自己对一个知识点非常了解?莫过于能通过底层代码来说明。我在和不少工作经验在5年之内的程序员沟通时，不少人认为这很难？确实，如果要通过阅读底层代码了解分布式组件，那难度不小，但如果如下部分的底层代码，并不难懂。


	
ArrayList,LinkedList的底层代码里，包含着基于数组和链表的实现方式，如果大家能以此讲清楚扩容，“通过枚举器遍历“等方式，绝对能证明自己；
	
	

	
HashMap直接对应着Hash表这个数据结构，在HashMap的底层代码里，包含着hashcode的put，get等的操作，甚至在ConcurrentHashMap里，还包含着Lock的逻辑。我相信，如果大家在面试中，看看而言ConcurrentHashMap，再结合在纸上边说边画，那一定能征服面试官；
	
	

	
可以看下静态代理和动态代理的实现方式，再深入一下，可以看下Spring AOP里的实现代码；
	
	

	
或许Spirng IOC和MVC的底层实现代码比较难看懂，但大家可以说些关键的类，根据关键流程说下它们的实现方式。 
	
 

 

 

 

其实准备的底层代码未必要多，而且也不限于在哪个方面，比如集合里基于红黑树的TreeSet，基于NIO的开源框架，甚至分布式组件的Dubbo，都可以准备。而且准备时未必要背出所有的底层（事实上很难做到），你只要能结合一些重要的类和方法，讲清楚思路即可（比如讲清楚HashMap如何通过hashCode快速定位）。

那么在面试时，如何找到个好机会说出你准备好的上述底层代码？在面试时，总会被问到集合，Spring MVC框架等相关知识点，你在回答时，顺便说一句，“我还了解这块的底层实现”，那么面试官一定会追问，那么你就可以说出来了。

 



预估面试题，准备对应的回答

 

4.1 哪些问题面试中大概率会被问到

在面试里，不管如何引导面试官，其实如下方面的问题很大可能会被问到，所以在面试前可以提前准备。


	
职位介绍里提到的技能要点，比如职位介绍里有提到Mybatis，那么面试官一定会问相关问题；
	
	

	
你在项目介绍时抛出的技术关键字，比如你在面试过程中介绍项目时提到了Redis，那么在介绍完项目后，面试官就会问，“你项目里是如何使用Redis的？”，类似的，简历中你写的技术，也有可能会被问到；
	
	

	
Java核心，数据库，Spring框架，项目管理等基础问题，这些就不用说了，不过如果你引导得当的话，面试官会花费很多时间问你提到的技术，这块会问得比较少；
	
	

	
必要的算法题，比如排序等，其实面试官感觉你技术可以的话，这块就不怎么会问了，但准备的时候需要看这个，有备无患。
	
 

 

 

 

4.2 面试官提问的方式

以上介绍了常见问题的种类，这里介绍下面试官常用的提问方式。


	
问用法，比如直接提问，项目里你netty怎么用的？这块大家可以结合项目准备说辞；
	
	

	
问流程，比如结合业务，讲下nginx负载均衡的用法？这也可以结合项目和网上搜到的资料准备说辞；
	
	

	
问原因，比如为什么要用netty？这块就要结合项目说明了；
	
	

	
问技术点， 比如netty里零拷贝怎么回事？对此，需要对简历上提到的每个技术点，以及面试过程中将要提到的每个技术点，搜相关面试问题，并结合业务说明；
	
	

	
问基础知识，比如finally从句的用途，这就可以通过刷题来获取了。
	
 

 

 

 

 

4.3 举例说明该如何准备面试问题

下面给出准备问题的技巧。


	
斟酌面试时抛出的技能，逐一准备说辞；
	
	

	
针对技术，网上搜索问题，比如搜Spring IOC面试题，结合网上的参考答案准备说辞；
	
	

	
准备技术的实施要点，比如做了哪些配置文件，你在项目里踩过哪些坑？
	
	

	
最好结合底层代码说明。
	
 

 

 

 

如下给出两个例子，先以MyCat分库分表为例，给出介绍说辞的技巧。


	
准备业务背景，为什么要用？比如我们项目数据库并发压力大，需要用MyCat作为分库分表；
	
	

	
如何使用，无非是设置分库规则，改写SQL语句等；
	
	

	
准备下踩到的坑，比如自增长主键在每台机器上都要保证唯一；
	
	

	
然后再结合些底层代码，准备下一条SQL语句是如何分发到对应的分库上的，然后执行好以后又如何返回的；
	
	

	
再可以准备些只有做过才知道的细节，比如发布上线和清洗数据的流程；
	
	

	
网上找些MyCAT的面试题，准备相关说辞。
	
 

 

 

 

 

 

一般说到了这里，面试官就不怎么问了，哪怕你后面再被问倒，面试官也会感觉你MyCat很熟悉。

下面以Netty为例，给出相关技巧。


	
结合业务需求点，说下为什么要用这个技术，怎么用的，以及用了有什么好处？ 比如为了优化网络通讯协议，所以用基于TCP协议的Netty，业务模块里的xxx功能是用到netty；
	
	

	
准备下踩到的坑，比如在某业务场景里，我遇到了半包粘包问题，我是通过调试底层代码解决的；
	
	

	
用了Netty对项目的帮助。比如Netty是基于TCP协议的，它要比Http协议要轻，所以通讯性能高，且Netty内部的Reactor线程模型对系统的IO帮助很大；
	
	

	
基于零拷贝、读写索引和异步处理机制，准备些底层代码，在面试里说明；
	
	

	
顺带再准备下Netty的组件，工作流程等问题，这能搜到问题和相关说辞。
	
 

 

 

 

 

在讲的时候，大家甚至可以边画Netty流程图，再结合底层代码说明，这样面试官一定会对大家刮目相看。

其实这里仅仅是抛砖引玉，或者提到的技术比较高深 ，但可以讲述的技术还可以是线程池，MyBatis组件，Redis，甚至是虚拟机优化等。哪怕是初级开发，也能多少抓住一两个点，按上述思路说明。

 



面试时如何不被面试官牵着鼻子，自我把控面试的走向？

 

5.1 在介绍项目时，引导话题的技巧以及案例

在做项目介绍的时候，你可以穿插说出一些你的亮点，但请记得，不论在介绍项目还是在回答问题，你当前的职责不是说明亮点而是介绍项目，一旦你详细说，可能会让面试官感觉你跑题了。

所以这时你可以一笔带过，比如你可以说，“我们的项目对数据要求比较大，忙的时候平均每小时要处理几十万条数据”，这样就可以把面试官引入“大数据”的方向。

你在面试前可以根据职位的需求，准备好这种“一笔带过”的话。比如这个职位的需求点是Spring MVC框架，大数据高并发，要有数据库调优经验，那么介绍以往项目时，你就最好突出这些方面你的实际技能。

再给大家举个例子，比如Java虚拟机内存管理和数据库优化是绝大多数项目都要遇到的两大问题，大家都可以在叙述项目经验时说，在这个项目里，我们需要考虑内存因素，因为我们的代码只允许在2G内存环境中运行，而且对数据库性能要求比较高，所以我们经常要监控优化内存和数据库里的SQL语句。这样当面试官深入提问时，就能抛出自己准备好的虚拟机内存优化和数据库优化方面的说辞。

或者说，在项目介绍时提到，在xx模块里，我们使用了nginx做负载均衡，达到了承受百万级并发的效果，从而引出nginx的话题。

实在不行，你也可以说“我除了做开发，也做了了解需求，测试和部署的工作，因为这个项目人手比较少，压力比较大”，这样你也能展示你有过独挡一面的经历。

5.2 以Netty为例，讲述引出值钱话题的技巧

比如在介绍项目时，我提到了Netty技术，如果面试官没打断，我就问，能否介绍其中的Netty细节？得到允许后再说。

或者把技术关联到面试官可能会问的问题上，比如问及网络通讯时介绍Netty，这个事先整理一个问题列表，遇到此类问题，顺带抛出Netty说辞。

问题列表可以是，项目里你用到哪些组件？用到哪些通讯协议？如何进行模块间的交互等等，然后先回答问题本身，再扩展到Netty。但请记住，别自说自话，因为过犹不及，其它技术照此办理

5.3 以案例说明，在回答问题时引出准备过话题的技巧

比如面试官问你Spring相关问题，假设问到，你对Spring依赖注入了解多少，在说好Spring相关问题后再提一句，我们同时用Spring，以低耦合的方式整合了MyCAT组件，从而达到了分库分表的效果，这样就引出了分库分表的话题 。

或者在介绍Netty流程后，再说一句，在实际项目里，我们还遇到了因Netty底层代码而导致的OOM问题，对此，我们组负责排查和解决问题，这样就自然而然地引出了OOM内存溢出的问题。

或者在介绍完线程相关问题时，再提一句，在项目里，我们用到了线程池来管理线程，这样就引出了高并发的话题。

但在引导的时候，请注意如下的三点。

第一，面试官不接口的，应当立即停止，再说下去就属于自说自话了。

第二，还是要准备必要的基础问题，还是要刷题，还是要准备各种说辞，因为面试前的全面准备，是引导的基础。

第三，应当引导面试官问些“框架”和“性能调优”等值钱方面的技能，这样才能最大程度地展示你的能力，同样，此类问题需要面试前准备。

5.4 你可以引导的加分项

在如下的一些表格里，归纳的加分项甚至初级开发多少也能准备，其中涵盖了诸多方面。

表 Java Core方面可以准备的亮点


			
技术方面
			
			

			
可以说的亮点
			
		

			
Java集合对象
			
			

			
1 能根据项目的需求选用合适的集合对象，比如知道ArrayList和LinkedList的差异，并能合理选用。

			
2 能在合适的场合选用WeakHashMap。

			
3 可以适当讲一些集合的JDK底层实现代码。
			
		

			
异常处理方面
			
			

			
能在finally从句里写释放资源的代码
			
		

			
JDBC方面
			
			

			
1 能通过PreparedStatement的预处理方法来防止SQL注入。

			
2 能通过批处理来提升操作性能。

			
3 能通过实例讲述事务隔离级别的含义
			
		

			
多线程方面
			
			

			
1 会结合项目使用线程池

			
2 能通过锁或信号量等手段正确地处理多线程并发时的数据一致性。

			
3 熟悉各种并发组件
			
		
表 数据库方面可以准备的亮点


			
技术方面
			
			

			
可以说的亮点
			
		

			
建表
			
			

			
建表时需要根据项目的数据情况，考虑是采用三范式或是反范式。
			
		

			
SQL调优
			
			

			
1 可以通过查看日志等方式看哪些SQL需要调优。

			
2 可以通过执行计划查看SQL的所消耗的代价，并据此调优。

			
3 可以通过建索引，建分区等手段来优化SQL性能。
			
		

			
事务
			
			

			
1 可以说下JDBC或Spring里是如何管理事务的。

			
2 可以说下Spring里的声明式事务的做法和优点。

			
3 可以举例说明事务隔离级别和事务传播机制的用法。
			
		

			
分布式数据库
			
			

			
1 可以通过MyCAT进行分库分表，从而减轻对单表访问所需要的代价。

			
2 可以通过集群等方式来承担对数据库的过量的访问请求。
			
		

			
NoSQL和Hadoop
			
			

			
这两个本身就是个亮点，如果大家用过，可以结合项目来说明。
			
		
表Java Web框架方面可以准备的亮点


			
技术方面
			
			

			
可以说的亮点
			
		

			
Spring MVC/Boot架构
			
			

			
1 可以说下Spring的IOC和AOP是如何优化项目结构的。

			
2 可以说下拦截器等Spring组件对项目的帮助。

			
3 可以说下Spring Boot对项目的帮助
			
		

			
ORM，比如Mybatis
			
			

			
使用这种ORM技术时，如何优化访问和操作数据库的性能。
			
		

			
Spring和Mybatis等的整合
			
			

			
可以讲下整合框架的细节，并可以举例说明整合后的框架能很好地适应需求的变更。
			
		
表 分布式组件方面可以准备的亮点


			
技术方面
			
			

			
可以说的亮点
			
		

			
组件应用
			
			

			
1 结合配置文件等，说明怎么用的

			
2 结合业务，说下具体的效果，比如限流后有什么好处。
			
		

			
如何应对高并发的场景
			
			

			
1 如何达到负载均衡

			
2 如何进行失效转移
			
		

			
定位排查和解决问题
			
			

			
1 如何通过分析log定位问题

			
2 问题的根源和解决方法
			
		

			
健康检查和线上监控
			
			

			
1 如何通过健康检查确定系统正常运行

			
2 出了问题，如何发出警告
			
		
由此大家能看到，其实很多事先可以准备的点，其实是你没有想到，但你项目里一定用过。你据此准备，在通过上述技巧在面试中合理地找机会说出来，你面试成功的可能性一定会大大增加。

 



总结，面试准备后，结果可能就大不同

 

先从面试官的角度看下，哪些人能面试成功？

1. 最近半年的项目经历和JD匹配度很高；

2. 通过面试，JD上的技能候选人大多能掌握；

3. 候选人在Java核心，数据库和框架方面的基础技能达标；

4. 不是刺头，团队合作没问题，没有其它大问题。

但如果大家面试前不准备，或者准备不到位，那么就会面临如下的后果了：

1. 简历未必能过筛选，甚至没有面试机会；

2. 无法证明项目里用到的技术和JD高度契合；

3. 介绍项目经验时没问题，把提问的主动权交给面试官；

4. 不知道将会问哪些问题，所有问题都现场想；

5. 在面试现场，没法让面试官全面了解你的技术亮点。

但如果按照上述方法准备，大家很大程度上能得到如下的收获。

1. 能通过微调简历，得到更多的面试机会；

2. 能通过挖掘项目经验，证明自己的技能和JD契合；

3. 能知道哪些属于值钱技能，并能结合业务准值钱技能和调优技能的说辞，而且能不露痕迹地展示；

4. 不仅限于coding，更能展示项目管理（sonar等），linux，项目部署（nginx）等方面的技能；

5. 知道面试大致会问哪些问题，并由此能事先准备；

6. 能事先尽可能多地挖掘亮点，并在面试时展示。

这就是大家阅读本文后的收获，最后感谢大家看完本文。

作者简介：胡书敏，知名外企资深架构师，8年内面试过数以百计的Java工程师，5年的Java培训讲师经验，帮助众多初学者成功拿到心仪的Offer。著有《Java核心技术及面试指南》。CSDN博客专家：https://blog.csdn.net/sxeric

声明：本文为作者原创投稿，未经允许请勿转载。

【End】


0基础学习python,每天5分钟，进步一点点

https://edu.csdn.net/topic/python115?utm_source=csdn_bw




热 文 推 荐 



 



☞