Java面试题目汇总

3年工做经验出去面试的面试问题：

1. mysql数据库的优化

1、表的设计要符合三范式。

2、添加适当的索引，索引对查询速度影响很大，必须添加索引。主键索引，惟一索引，普通索引，全文索引

3、添加适当存储过程，触发器，事务等。

4、读写分离（主从数据库）

5、对sql语句的一些优化，（查询执行速度比较慢的sql语句）

6、分表分区

分表：把一张大表分红多张表。分区：把一张表里面的分配到不一样的区域存储，

7、对mysql服务器硬件的升级操做。

 

2. mysql数据库查询使用limit，两次查询结果会不会不一致，为何？

MySQL的limit给分页带来了极大的方便，但数据量一大的时候，limit的性能就急剧降低。一样是取10条数据，下面两句就不是一个数量级别的。

 

1	select * from table limit 10000,10
2	select * from table limit 0,10

这个可能和我们的数据库的数据有关！

 

3. 如何建立索引查询数据库？

http://jingyan.baidu.com/article/da1091fbd166ff027849d687.html

这个网页里面是数据库建立索引的步骤！本身理解一下，由于在面试过程当中这个问题问的比较多！！

4、redis中的事务和mysql中的事务有什么区别？

1、Redis中的事务(transaction)是一组命令的集合。事务同命令同样都是Redis最小的执行单位，一个事务中的命令要么都执行，要么都不执行。Redis事务的实现须要用到 MULTI 和 EXEC 两个命令，事务开始的时候先向Redis服务器发送 MULTI 命令，而后依次发送须要在本次事务中处理的命令，最后再发送 EXEC 命令表示事务命令结束。

2、mysql的事务特性，要求这组操做，要不全都成功，要不全都失败，这样就避免了某个操做成功某个操做失败。利于数据的安全

 

5、zookeeper为何能够作注册中心？原理是什么？

首先咱们要知道什么是zookeeper。zookeeper是一个为分布式应用提供一致性服务的软件，它是开源的Hadoop项目中的一个子项目！

(1)配置管理
集中式的配置管理在应用集群中是很是常见的，通常商业公司内部都会实现一套集中的配置管理中心，应对不一样的应用集群对于共享各自配置的需求，而且在配置变动时可以通知到集群中的每个机器。

Zookeeper很容易实现这种集中式的配置管理，好比将APP1的全部配置配置到/APP1 znode下，APP1全部机器一启动就对/APP1这个节点进行监控(zk.exist("/APP1",true)),而且实现回调方法Watcher，那么在zookeeper上/APP1 znode节点下数据发生变化的时候，每一个机器都会收到通知，Watcher方法将会被执行，那么应用再取下数据便可(zk.getData("/APP1",false,null));

以上这个例子只是简单的粗颗粒度配置监控，细颗粒度的数据能够进行分层级监控，这一切都是能够设计和控制的。     

(2)集群管理 
应用集群中，咱们经常须要让每个机器知道集群中（或依赖的其余某一个集群）哪些机器是活着的，而且在集群机器由于宕机，网络断链等缘由可以不在人工介入的状况下迅速通知到每个机器。

Zookeeper一样很容易实现这个功能，好比我在zookeeper服务器端有一个znode叫/APP1SERVERS,那么集群中每个机器启动的时候都去这个节点下建立一个EPHEMERAL类型的节点，好比server1建立/APP1SERVERS/SERVER1(可使用ip,保证不重复)，server2建立/APP1SERVERS/SERVER2，而后SERVER1和SERVER2都watch /APP1SERVERS这个父节点，那么也就是这个父节点下数据或者子节点变化都会通知对该节点进行watch的客户端。由于EPHEMERAL类型节点有一个很重要的特性，就是客户端和服务器端链接断掉或者session过时就会使节点消失，那么在某一个机器挂掉或者断链的时候，其对应的节点就会消失，而后集群中全部对/APP1SERVERS进行watch的客户端都会收到通知，而后取得最新列表便可。

另外有一个应用场景就是集群选master,一旦master挂掉可以立刻能从slave中选出一个master,实现步骤和前者同样，只是机器在启动的时候在APP1SERVERS建立的节点类型变为EPHEMERAL_SEQUENTIAL类型，这样每一个节点会自动被编号，

咱们默认规定编号最小的为master,因此当咱们对/APP1SERVERS节点作监控的时候，获得服务器列表，只要全部集群机器逻辑认为最小编号节点为master，那么master就被选出，而这个master宕机的时候，相应的znode会消失，而后新的服务器列表就被推送到客户端，而后每一个节点逻辑认为最小编号节点为master，这样就作到动态master选举。

6、手写一个单例模式

Java的设计模式比较多，可是咱们在面试前面至少有看好几个设计面试，

1.饿汉式单例类

//饿汉式单例类.在类初始化时，已经自行实例化 public class Singleton1 {     //私有的默认构造子     private Singleton1() {}     //已经自行实例化     private static final Singleton1 single = new Singleton1();     //静态工厂方法     public static Singleton1 getInstance() {         return single;     } }

2.懒汉式单例类

//懒汉式单例类.在第一次调用的时候实例化 public class Singleton2 {     //私有的默认构造子     private Singleton2() {}     //注意，这里没有final         private static Singleton2 single=null;     //静态工厂方法     public synchronized  static Singleton2 getInstance() {          if (single == null) {                single = new Singleton2();          }           return single;     } }

3.登记式单例类

import java.util.HashMap; import java.util.Map; //登记式单例类. //相似Spring里面的方法，将类名注册，下次从里面直接获取。 public class Singleton3 {     private static Map<String,Singleton3> map = new HashMap<String,Singleton3>();     static{         Singleton3 single = new Singleton3();         map.put(single.getClass().getName(), single);     }     //保护的默认构造子     protected Singleton3(){}     //静态工厂方法,返还此类唯一的实例     public static Singleton3 getInstance(String name) {         if(name == null) {             name = Singleton3.class.getName();             System.out.println("name == null"+"--->name="+name);         }         if(map.get(name) == null) {             try {                 map.put(name, (Singleton3) Class.forName(name).newInstance());             } catch (InstantiationException e) {                 e.printStackTrace();             } catch (IllegalAccessException e) {                 e.printStackTrace();             } catch (ClassNotFoundException e) {                 e.printStackTrace();             }         }         return map.get(name);     }     //一个示意性的商业方法     public String about() {             return "Hello, I am RegSingleton.";         }         public static void main(String[] args) {         Singleton3 single3 = Singleton3.getInstance(null);         System.out.println(single3.about());     } }

 

7.maven的插件有哪些

Maven 提供如下两种类型插件：

类型	描述
构建插件	在生成过程当中执行，并在 pom.xml 中的<build/> 元素进行配置
报告插件	在网站生成期间执行，在 pom.xml 中的 <reporting/> 元素进行配置

如下是一些常见的插件列表：

插件	描述
clean	编译后的清理目标，删除目标目录
compiler	编译 Java 源文件
surefile	运行JUnit单元测试，建立测试报告
jar	从当前项目构建 JAR 文件
war	从当前项目构建 WAR 文件
javadoc	产生用于该项目的 Javadoc
antrun	从构建所述的任何阶段运行一组 Ant 任务

 

8.maven如何处理依赖冲突的问题？

下面是maven的 

解决maven传递依赖中的版本冲突

 

首先在pom.xml中添加： <reporting> <plugins> <plugin> <groupId>org.apache.maven.plugins</groupId> <artifactId> maven-project-info-reports-plugin </artifactId> </plugin> </plugins> </reporting>   若是用的是eclipse，那就用run as-build-在Goals那个框框里输入： project-info-reports:dependencies，若是实在dos环境下， 就mvn project-info-reports:dependencies。而后就会在target的文件夹下，生成一个site文件夹，里边有个dependency.html，进去就能看到详细的依赖的信息。 或者直接在eclipse中打开pom.xml文件 会看到打开的窗口中有一个dependency hie开头的选项卡。 这个选择卡页面左半部分显示了详细的jar包依赖树。右半部分则是maven将会下载的jar包。 好比咱们看到右半部分有2个asm的jar，版本不一样。 如今须要排除其中低版本的jar（好比xwork-core下的某个jar依赖的asm版本相对较低，不必定说是xwork-core依赖，而是它的依赖的依赖，即多重依赖的asm都是能够的） <dependency> <groupId>org.apache.struts.xwork</groupId> <artifactId>xwork-core</artifactId> <version>${struts.version}</version> <exclusions> <exclusion> <artifactId>asm</artifactId> <groupId>asm</groupId> </exclusion> </exclusions> </dependency> 固然咱们也能够在dependency hie开头的选项卡中右半部分直接选中那个低版本的asm.jar。 而后右键exclude maven...点击肯定会自动生成上面的。

若是你这个是步骤解决问题的步骤！在面试的时候我们是能够用语言打动面试官的

maven引入依赖的时候，有的时候会发生循环依赖的状况，形成依赖失败，例如A依赖于B，B又依赖于C，C又依赖于A，形成一种环路，这样的话会失败。 假设依赖A依赖于B,D也依赖于B，B在pom中有2个版本B1，B2（有多是直接依赖，也有多是间接依赖），那么maven会经过如下机制引入依赖：  若是A直接依赖于B1，A-B1，D间接依赖于B2，例如D-C-B2，那么maven会有优先选择依赖路径短的那个版本，即依赖B1，而不依赖B2。假设B1，B2都是间接依赖，例如A-C-B1，D-C-B2，那么在选择B的依赖版本的时候，谁在pom文件中优先声明依赖了，那么就依赖哪一个，假设A-C-B1在pom文件中优先D-C-B2声明了，那么将引入B1.

这样面试官会认为你真正作过开发，而且本身遇到这样的问题！offer就在向你招手

9.电商项目中是如何解决高并发和高可用的？

1、尽可能将请求的页面静态化 静态化的页面为.html(.htm等)不须要web服务器从新加载项解析，只须要生成一次，之后每次都直接下载到客户端，效率高不少。javaWeb静态化的技术有freemark和Velocity等。

2、fastDFS图片服务器：

将网站系统的web服务器、数据库服务器、图片和文件服务器分开，经过将服务器专业化分工，以提升网站访问速度。由于图片和文件在下载的时候不管是IIS、Apache等服务器都会有很大压力。

3、数据缓存服务器 redis

能够设置专门的数据缓存服务器，将大量数据放到缓存数据区，在访问量少得时候存入数据，减小链接直接操做数据库的开销。

4、数据库集群、库表散列（数据库的各类优化、数据库的拆分）

5、镜像（这个本人原理也是不是很明白）　　　　

镜像是大型网站常采用的提升性能和数据安全性的方式，镜像的技术能够解决不一样网络接入商和地域带来的用户访问速度差别，好比ChinaNet和EduNet之间的差别就促使了不少网站在教育网内搭建镜像站点，数据进行定时更新或者实时更新。在镜像的细节技术方面，这里不阐述太深，有不少专业的现成的解决架构和产品可选。也有廉价的经过软件实现的思路，好比Linux上的rsync等工具。

6、负载均衡（nginx）

负载均衡将是大型网站解决高负荷访问和大量并发请求采用的高端解决办法。

7、最新：CDN加速技术（这个比镜像更好用）

什么是CDN？　　　　CDN的全称是内容分发网络。其目的是经过在现有的Internet中增长一层新的网络架构，将网站的内　　　　容发布到最接近用户的网络“边缘”，使用户能够就近取得所需的内容，提升用户访问网站的响应速度。

10.nginx的做用？如何实现负载均衡的，原理是什么？

nginx的做用：1、http服务2、负载均衡3、解决高并发

这个在上课的时候老师是有文档的！

 

11.若是redis广告位节点中存入的大量数据（十万条），当添加新广告数据时，是否也要删掉十万广告对应的key？是否有其余解决方案保证能redis中数据是最新的？

Redis的做用：   1 、Redis不只仅支持简单的k/v类型的数据，同时还提供list，set，zset，hash等数据结构的存储。 

2 、Redis支持数据的备份，即master-slave模式的数据备份。
 3 、Redis支持数据的持久化，能够将内存中的数据保持在磁盘中，重启的时候能够再次加载进行使用。

 Redis经常使用数据类型

Redis最为经常使用的数据类型主要有如下：

String

Hash

List

Set

Sorted set

pub/sub

Transactions

 

12.activemq的事务管理？

在建立session时能够选择开启事务控制。所谓事务控制，即将消息生成发送，或接受，消费操做放入一个事务中。但不能同时控制发送与消费这一整个过程。由于事务都是基于一个session下的操做。 以下代码即开启了事务处理： ActiveMQSession session = connection.createSession(true,Session.CLIENT_ACKNOWLEDGE); 在事务状态下进行发送操做，消息并未真正投递到中间件，而只有进行session.commit操做以后，消息才会发送到中间件，再转发到适当的消费者进行处理。若是是调用rollback操做，则代表，当前事务期间内所发送的消息都取消掉。此时不管commit或rollback，会从新打开一个事务。 与此同时，在rollback以后，随着新的事务打开，一些持久化的消息会从新接收。缘由在于当传送模式处于持久话的状态，产生的消息如若没有被及时签收确认，则消息会被中间件持久化。此时，当客户端从新链接或新的事务开启，消息会被再次发送到客户端。 为何commit以后，不会有持久的消息从新传送呢? 缘由在于commit操做会自动将为签收确认的消息进行签收确认，若是是当前接收但未签收确认的消息，都会被确认处理。于是在commit以后不会有持久化的消息出现。

 

13.“this is a dog”是如何添加到索引库中的？(solr)

索引 Solr/Lucene采用的是一种反向索引，所谓反向索引：就是从关键字到文档的映射过程，保存这种映射这种信息的索引称为反向索引   左边保存的是字符串序列 右边是字符串的文档（Document）编号链表，称为倒排表（Posting List） 字段串列表和文档编号链表二者构成了一个字典。如今想搜索”lucene”，那么索引直接告诉咱们，包含有”lucene”的文档有：2，3，10，35，92，而无需在整个文档库中逐个查找。若是是想搜既包含”lucene”又包含”solr”的文档，那么与之对应的两个倒排表去交集便可得到：三、十、3五、92。 索引建立 假设有以下两个原始文档： 文档一：Students should be allowed to go out with their friends, but not allowed to drink beer. 文档二：My friend Jerry went to school to see his students but found them drunk which is not allowed. 建立过程大概分为以下步骤： 一：把原始文档交给分词组件(Tokenizer) 分词组件(Tokenizer)会作如下几件事情(这个过程称为：Tokenize)，处理获得的结果是词汇单元（Token） 将文档分红一个一个单独的单词 去除标点符号 去除停词(stop word) 所谓停词(Stop word)就是一种语言中没有具体含义，于是大多数状况下不会做为搜索的关键词，这样一来建立索引时能减小索引的大小。英语中停词(Stop word)如：”the”、”a”、”this”，中文有：”的，得”等。不一样语种的分词组件(Tokenizer)，都有本身的停词(stop word)集合。通过分词(Tokenizer)后获得的结果称为词汇单元(Token)。上例子中，便获得如下词汇单元(Token)： "Students"，"allowed"，"go"，"their"，"friends"，"allowed"，"drink"，"beer"，"My"，"friend"，"Jerry"，"went"，"school"，"see"，"his"，"students"，"found"，"them"，"drunk"，"allowed" 二：词汇单元(Token)传给语言处理组件(Linguistic Processor) 语言处理组件(linguistic processor)主要是对获得的词元(Token)作一些语言相关的处理。对于英语，语言处理组件(Linguistic Processor)通常作如下几点： 变为小写(Lowercase)。 将单词缩减为词根形式，如”cars”到”car”等。这种操做称为：stemming。 将单词转变为词根形式，如”drove”到”drive”等。这种操做称为：lemmatization。 语言处理组件(linguistic processor)处理获得的结果称为词(Term)，例子中通过语言处理后获得的词(Term)以下： "student"，"allow"，"go"，"their"，"friend"，"allow"，"drink"，"beer"，"my"，"friend"，"jerry"，"go"，"school"，"see"，"his"，"student"，"find"，"them"，"drink"，"allow"。 通过语言处理后，搜索drive时drove也能被搜索出来。Stemming 和 lemmatization的异同： 相同之处： Stemming和lemmatization都要使词汇成为词根形式。 二者的方式不一样： Stemming采用的是”缩减”的方式：”cars”到”car”，”driving”到”drive”。 Lemmatization采用的是”转变”的方式：”drove”到”drove”，”driving”到”drive”。 二者的算法不一样： Stemming主要是采起某种固定的算法来作这种缩减，如去除”s”，去除”ing”加”e”，将”ational”变为”ate”，将”tional”变为”tion”。 Lemmatization主要是采用事先约定的格式保存某种字典中。好比字典中有”driving”到”drive”，”drove”到”drive”，”am, is, are”到”be”的映射，作转变时，按照字典中约定的方式转换就能够了。 Stemming和lemmatization不是互斥关系，是有交集的，有的词利用这两种方式都能达到相同的转换。 三：获得的词(Term)传递给索引组件(Indexer) 利用获得的词(Term)建立一个字典 Term    Document ID student     1 allow       1 go          1 their       1 friend      1 allow       1 drink       1 beer        1 my          2 friend      2 jerry       2 go          2 school      2 see         2 his         2 student     2 find        2 them        2 drink       2 allow       2 对字典按字母顺序排序： Term    Document ID allow       1 allow       1 allow       2 beer        1 drink       1 drink       2 find        2 friend      1 friend      2 go          1 go          2 his         2 jerry       2 my          2 school      2 see         2 student     1 student     2 their       1 them        2 合并相同的词(Term)成为文档倒排(Posting List)链表 Document Frequency：文档频次，表示多少文档出现过此词(Term) Frequency：词频，表示某个文档中该词(Term)出现过几回 对词(Term) “allow”来说，总共有两篇文档包含此词(Term)，词（Term)后面的文档链表总共有两个，第一个表示包含”allow”的第一篇文档，即1号文档，此文档中，”allow”出现了2次，第二个表示包含”allow”的第二个文档，是2号文档，此文档中，”allow”出现了1次 至此索引建立完成，搜索”drive”时，”driving”，”drove”，”driven”也可以被搜到。由于在索引中，”driving”，”drove”，”driven”都会通过语言处理而变成”drive”，在搜索时，若是您输入”driving”，输入的查询语句一样通过分词组件和语言处理组件处理的步骤，变为查询”drive”，从而能够搜索到想要的文档。 搜索步骤 搜索”microsoft job”，用户的目的是但愿在微软找一份工做，若是搜出来的结果是:”Microsoft does a good job at software industry…”，这就与用户的指望偏离太远了。如何进行合理有效的搜索，搜索出用户最想要得结果呢？搜索主要有以下步骤： 一：对查询内容进行词法分析、语法分析、语言处理 词法分析：区分查询内容中单词和关键字，好比：english and janpan，”and”就是关键字，”english”和”janpan”是普通单词。 根据查询语法的语法规则造成一棵树 语言处理，和建立索引时处理方式是同样的。好比：leaned–>lean，driven–>drive 二：搜索索引，获得符合语法树的文档集合 三：根据查询语句与文档的相关性，对结果进行排序 咱们把查询语句也看做是一个文档，对文档与文档之间的相关性（relevance）进行打分（scoring），分数高比较越相关，排名就越靠前。固然还能够人工影响打分，好比百度搜索，就不必定彻底按照相关性来排名的。 如何评判文档之间的相关性？一个文档由多个（或者一个）词（Term）组成，好比：”solr”， “toturial”，不一样的词可能重要性不同，好比solr就比toturial重要，若是一个文档出现了10次toturial，但只出现了一次solr，而另外一文档solr出现了4次，toturial出现一次，那么后者颇有可能就是咱们想要的搜的结果。这就引伸出权重（Term weight）的概念。 权重表示该词在文档中的重要程度，越重要的词固然权重越高，所以在计算文档相关性时影响力就更大。经过词之间的权重获得文档相关性的过程叫作空间向量模型算法(Vector Space Model) 影响一个词在文档中的重要性主要有两个方面： Term Frequencey（tf），Term在此文档中出现的频率，ft越大表示越重要 Document Frequency（df），表示有多少文档中出现过这个Trem，df越大表示越不重要 物以希为贵，你们都有的东西，天然就不那么贵重了，只有你专有的东西表示这个东西很珍贵，权重的公式： 空间向量模型 文档中词的权重看做一个向量 Document = {term1, term2, …… ,term N} Document Vector = {weight1, weight2, …… ,weight N} 把欲要查询的语句看做一个简单的文档，也用向量表示： Query = {term1, term 2, …… , term N} Query Vector = {weight1, weight2, …… , weight N} 把搜索出的文档向量及查询向量放入N维度的空间中，每一个词表示一维： 夹角越小，表示越类似，相关性越大

补充：Lucene: 全文检索的基本原理

http://www.cnblogs.com/guochunguang/articles/3641008.html 这个里面有一些解释！lucene和solr的区别是在于：Solr是基于Lucene开发的全文检索服务器，而Lucene就是一套实现了全文检索的api，其本质就是一个全文检索的过程。全文检索就是把原始文档根据必定的规则拆分红若干个关键词，而后根据关键词建立索引，当查询时先查询索引找到对应的关键词，并根据关键词找到对应的文档，也就是查询结果，最终把查询结果展现给用户的过程。

 

14.http的三次握手？socket有几种状态？socket底层编程？

http的三次握手

TCP(Transmission Control Protocol)　传输控制协议 TCP是主机对主机层的传输控制协议，提供可靠的链接服务，采用三次握手确认创建一个链接: 位码即tcp标志位,有6种标示:SYN(synchronous创建联机) ACK(acknowledgement 确认) PSH(push传送) FIN(finish结束) RST(reset重置) URG(urgent紧急) Sequence number(顺序号码) Acknowledge number(确认号码) 在TCP/IP协议中，TCP协议提供可靠的链接服务，采用三次握手创建一个链接。  第一次握手：创建链接时，客户端发送syn包(syn=j)到服务器，并进入SYN_SEND状态，等待服务器确认；  第二次握手：服务器收到syn包，必须确认客户的SYN（ack=j+1），同时本身也发送一个SYN包（syn=k），即SYN+ACK包，此时服务器进入SYN_RECV状态； 第三次握手：客户端收到服务器的SYN＋ACK包，向服务器发送确认包ACK(ack=k+1)，此包发送完毕，客户端和服务器进入ESTABLISHED状态，完成三次握手。 完成三次握手，客户端与服务器开始传送数据.

socket有几种状态

CLOSED 没有使用这个套接字 LISTEN 套接字正在监听入境链接 SYN_SENT 套接字正在试图主动创建链接 SYN_RECEIVED 正在处于链接的初始同步状态 ESTABLISHED 链接已创建 CLOSE_WAIT 远程套接字已经关闭：正在等待关闭这个套接字 FIN_WAIT_1 套接字已关闭，正在关闭链接 CLOSING 套接字已关闭，远程套接字正在关闭，暂时挂起关闭确认 LAST_ACK 远程套接字已关闭，正在等待本地套接字的关闭确认 FIN_WAIT_2 套接字已关闭，正在等待远程套接字关闭 TIME_WAIT 这个套接字已经关闭，正在等待远程套接字的关闭传送

socket底层编程（这个能够不用了解）

http是网络上层协议。底层仍是socket短链接是发送数据时进行联接。发送完关闭（咱们作完电商项目以后这些有了解一下）

 

15.你所知道的通信协议？

在ip网络中，传输层主要协议是：tcp及udp。在web中,应用层也用http传输。 在网络io中，目前主要有：bio(阻塞)、nio(非阻塞)、aio(异步jdk7中新特性)。具体不做解析能够看相关文档。 在传输中应用层的协议及规范主要有： RMI(java原生的)，用java自身的序列化技术。 xml-rpc  用xml+http Binary-RPC  用二进制+http soap，能够说是xml-rpc的一种封装 COBRA,加入了jdk中 jms,这个是一种规范，基于队列模型的 主要的实现框架，能够组合使用。 activeMQ:是jms的一种实现 mina:基本是包装了nio.Apache MINA is a network application framework which helps users develop high performance and high scalability network applications easily。It provides an abstract · event-driven · asynchronous API over various transports such as TCP/IP and UDP/IP via Java NIO. Hessian:Hessian是一个轻量级的remoting onhttp工具.采用的是二进制RPC协议，由于采用的是二进制协议，因此它很适合于发送二进制数据.本身实现序列化。 Burlap:和Hessian差很少,基于xml-RPC的实现 mule esb: 直接看官方文档http://www.mulesoft.org/  基于总线模型 spring-Remoting 重量级的 Jboss-Remoting 重量及的 EJB3

 

16、redis集群中，某个节点宕机怎么办？你碰见过吗？你的解决思路是什么？

redis集群：通常的是至少是2台服务器，主从服务器！若是redis集群的主服务器挂了，没有关系还有备服务器

 

其余面试问题汇总：

 

1、hibernate 和mybetis的异同之处?

 Mybatis和hibernate不一样，它不彻底是一个ORM框架，由于MyBatis须要程序员本身编写Sql语句，不过mybatis能够经过XML或注解方式灵活配置要运行的sql语句，并将java对象和sql语句映射生成最终执行的sql，最后将sql执行的结果再映射生成java对象。
 
    Mybatis学习门槛低，简单易学，程序员直接编写原生态sql，可严格控制sql执行性能，灵活度高，很是适合对关系数据模型要求不高的软件开发，例如互联网软件、企业运营类软件等，由于这类软件需求变化频繁，一但需求变化要求成果输出迅速。可是灵活的前提是mybatis没法作到数据库无关性，若是须要实现支持多种数据库的软件则须要自定义多套sql映射文件，工做量大。
 
    Hibernate对象/关系映射能力强，数据库无关性好，对于关系模型要求高的软件（例如需求固定的定制化软件）若是用hibernate开发能够节省不少代码，提升效率。可是Hibernate的缺点是学习门槛高，要精通门槛更高，并且怎么设计O/R映射，在性能和对象模型之间如何权衡，以及怎样用好Hibernate须要具备很强的经验和能力才行。
总之，按照用户的需求在有限的资源环境下只要能作出维护性、扩展性良好的软件架构都是好架构，因此框架只有适合才是最好。 

 

2、用户在app订阅业务,使用什么设计模式实现?应用场景是什么?

观察者模式又叫作发布-订阅(Publish/Subscribe)模式。观察者模式定义了一种一对多地依赖模式，让多个观察者同时监听某一个主题对象。这个主题对象在状态发生变化时，会通知全部的观察者对象，使它们可以自动更新本身。这里的主题对象就是指通知者，又叫作发布者。观察者又叫订阅者。

3、springmvc 如何声明一个controller? 注解

若是不基于注解：   该类须要继承  CommandController   或者 其余不少 参见  spring帮助

            若是基于注解：在类名前  加上         @controller   

      补充：将类名前加上该注解，当spring启动  或者web服务启动  spring会自动扫描全部包（固然，这个能够设置）

         做用:  就是告诉服务器  这个类是MVC中的C    这个类能够接收用户请求    处理用户请求

 

 

4、设计模式有哪些?单例,工厂,观察者.观察者模式的应用场景?

常见的设计模式：单例模式、工厂模式、观察者模式、装饰模式与适配器模式、桥接模式、代理模式

 

 

5、怎么声明事物?在spring配置文件中声明

spring支持编程式事务管理和声明式事务管理两种方式。

        编程式事务管理使用TransactionTemplate或者直接使用底层的PlatformTransactionManager。对于编程式事务管理，spring推荐使用TransactionTemplate。

        声明式事务管理创建在AOP之上的。其本质是对方法先后进行拦截，而后在目标方法开始以前建立或者加入一个事务，在执行完目标方法以后根据执行状况提交或者回滚事务。声明式事务最大的优势就是不须要经过编程的方式管理事务，这样就不须要在业务逻辑代码中掺琐事务管理的代码，只需在配置文件中作相关的事务规则声明(或经过基于@Transactional注解的方式)，即可以将事务规则应用到业务逻辑中。

       显然声明式事务管理要优于编程式事务管理，这正是spring倡导的非侵入式的开发方式。声明式事务管理使业务代码不受污染，一个普通的POJO对象，只要加上注解就能够得到彻底的事务支持。和编程式事务相比，声明式事务惟一不足地方是，后者的最细粒度只能做用到方法级别，没法作到像编程式事务那样能够做用到代码块级别。可是即使有这样的需求，也存在不少变通的方法，好比，能够将须要进行事务管理的代码块独立为方法等等。

         声明式事务管理也有两种经常使用的方式，一种是基于tx和aop名字空间的xml配置文件，另外一种就是基于@Transactional注解。显然基于注解的方式更简单易用，更清爽。

 

 

6、编写匹配字符串(求质数)的程序

http://blog.csdn.net/xianfajushi/article/details/50133965

7、分词技术

1、       为何要进行中文分词？

词是最小的可以独立活动的有意义的语言成分，英文单词之间是以空格做为天然分界符的，而汉语是以字为基本的书写单位，词语之间没有明显的区分标记，所以，中文词语分析是中文信息处理的基础与关键。

Lucene中对中文的处理是基于自动切分的单字切分，或者二元切分。除此以外，还有最大切分（包括向前、向后、以及先后相结合）、最少切分、全切分等等。

 

IK分析器的分词原理本质上是词典分词。如今内存中初始化一个词典，而后在分词过程当中逐个读取字符，和字典中的字符相匹配，把文档中的全部的词语拆分出来的过程。

8、不开启服务，页面怎么实现热更新！

把项目打成war包发在服务器里面，直接运行

 

面试问题分类：

1、Java基础
1.String类为何是final的。

 

2.HashMap的源码，实现原理，底层结构。
3.反射中，Class.forName和classloader的区别
4.session和cookie的区别和联系，session的生命周期，多个服务部署时session管理。
5.Java中的队列都有哪些，有什么区别。
6.Java的内存模型以及GC算法
7.Java7、Java8的新特性
8.Java数组和链表两种结构的操做效率，在哪些状况下(从开头开始，从结尾开始，从中间开始)，哪些操做(插入，查找，删除)的效率高
9.Java内存泄露的问题调查定位：jmap，jstack的使用等等

2、框架
1.struts1和struts2的区别

Struts 1要求Action类要扩展自一个抽象基类。Struts 1的一个共有的问题是面向抽象类编程而不是面向接口编程。 Struts 2的Action类实现了一个Action接口，连同其余接口一块儿实现可选择和自定义的服务。Struts 2提供一个名叫ActionSupport的基类实现通常使用的接口。虽然，Action接口不是必须的。任何使用execute方法的POJO对象能够 被看成Struts 2的Action对象使用。  程模型 Struts 1 Action类是单例类，因只有一个示例控制全部的请求。单例类策略形成了必定的限制且给开发带来了额外的烦恼。Action资源必须是程安全或者同步 的。 Struts 2 Action对象每个请求都实例化对象，因此没有程安全的问题。（实践中，servlet容器生许多丢的对象对于每个请求，多于一个的对象并不影响垃 圾收集） Servlet 依赖 Struts 1的Action类依赖于servlet API以HttpServletRequest和HttpServletResponse做参数传给execute方法当Action被调用时。 Struts 2的Action不和容器有关。Servlet上下文被表现简单的Maps，容许Action被独立的测试。Struts 2的Action能够访问最初的请求和相应，若是须要的话。然而，其余的架构元素少或者排除直接访问HttpServletRequest或者 HttpServletResponse的须要。  易测性 测试Struts 1的主要障碍是execute方法暴露了Servlet API。第三方的扩展，Struts测试用例，提供Struts 1的集合对象。 Struts 2的Action能够经过实例化Action测试，设置属性，而后调用方法。依赖注入的支持也是测试变得更简单。 接受输入 Struts 1使用ActionForm对象捕获输入。象Action同样，全部的ActionForm必须扩展基类。因其余的JavaBean不能做 ActionForm使用，开发者常常建立多余的类捕获输入。DynaBeans能够被用来做替代ActionForm的类建立。可是开发者能够从新描述 已经存在的JavaBean。 Struts 2 Action属性做输入属性，排除第二个输入对象的须要。输入属性可能有丰富的对象类型这些类型有他们本身的属性。Action的属性能够经过标签库访 问。Struts 2也支持ActionForm形式。丰富的对象类型，包含业务或者域对象，能够被看成输入或者输出对象使用。馍型驱动特性简化标签对POJO输入对象的引 用。 表达式语言 Struts 1整和JSTL，因此它使用JSTL的表达式语言。表达式语言有基本的图形对象移动，可是相对很弱的集合和被索引的属性支持。 Struts 2使用JSTL，可是框架也支持更大和更灵活的表达式，叫作“对象图形符号语言”（OGNL）。 将值绑定要视图上 Struts 1使用标准JSP机制来绑定对象到页面上下文。 Struts 2使用“ValueStack”技术了标签库能够不用连接你的视图到对象的表现类型访问值。ValueStack策略容许重用视图。 类型转换 Struts 1的ActionForm属性常常都是String的。Struts 1使用Commons-Beanutils类型转换。转换每个类，不是每个实例配置。 Struts 2使用OGNL类型转换。框架包含转换器基本的和共同的对象类型和原始类型。 验证 Struts 1支持手动验证凭借ActionForm的validate方法，或者经过扩展的公用验证器。类能够有不一样的验证上下文未相同的类，可是不能不能包括验证 子对象。 Struts 2支持手动验证凭借validate方法和XWork验证框架。Xwork验证框架支持一连串的验证子属性使用的验证了属性类的类型和严正上下文而定义。 Action执行的控制 Struts 1支持独立的请求处理器对于每个模型，可是全部在模型中的Action必须共享同一个生命周期。 Struts 2支持在每个Action基础上凭借拦截栈建立不一样的生命周期。自定义栈能够被建立且使用不一样的所需 的Action

2.struts2和springMVC的区别

①springmvc的入口是一个servlet即前端控制器，而struts2入口是一个filter过虑器。 ②springmvc是基于方法开发，传递参数是经过方法形参，能够设计为单例或多例(建议单例)，struts2是基于类开发，传递参数是经过类的属性，只能设计为多例。 ③Struts采用值栈存储请求和响应的数据，经过OGNL存取数据， springmvc经过参数解析器是将request对象内容进行解析成方法形参，将响应数据和页面封装成ModelAndView对象，最后又将模型数据经过request对象传输到页面。 Jsp视图解析器默认使用jstl。 ④ Struts2有漏洞，springmvc目前尚未漏洞出现。若是使用struts2，建议下载最新包。

3.spring框架中须要引用哪些jar包，以及这些jar包的用途

Spring3.X之后jar包进行了重构，取消了原来2.X版本中的总的spring.jar包，而是把总包中的功能所有分开打包。正在向osgi靠拢。 Spring官网提供了共20个包，各个包的做用以下： org.springframework.aop-3.0.6.RELEASE Spring的面向切面编程,提供AOP(面向切面编程)实现 org.springframework.asm- 3.0.6.RELEASE Spring独立的asm程序,Spring2.5.6的时候须要asmJar 包3.0.6开始提供他本身独立的asmJar org.springframework.aspects- 3.0.6.RELEASE Spring提供对AspectJ框架的整合 org.springframework.beans-3.0.6.RELEASE SpringIoC(依赖注入)的基础实现 org.springframework.context.support-3.0.6.RELEASE Spring-context的扩展支持,用于MVC方面 org.springframework.context-3.0.6.RELEASE Spring提供在基础IoC功能上的扩展服务，此外还提供许多企业级服务的支持，如邮件服务、任务调度、JNDI定位、EJB集成、远程访问、缓存以及各类视图层框架的封装等 org.springframework.core-3.0.6.RELEASE Spring3.0.6的核心工具包 org.springframework.expression-3.0.6.RELEASE Spring表达式语言 org.springframework.instrument.tomcat-3.0.6.RELEASE Spring3.0.6对Tomcat的链接池的集成 org.springframework.instrument-3.0.6.RELEASE Spring3.0.6对服务器的代理接口 org.springframework.jdbc-3.0.6.RELEASE 对JDBC的简单封装 org.springframework.jms-3.0.6.RELEASE 为简化JMS API的使用而做的简单封装 org.springframework.orm-3.0.6.RELEASE 整合第三方的ORM框架，如hibernate,ibatis,jdo，以及 spring的JPA实现 org.springframework.oxm-3.0.6.RELEASE Spring 对Object/XMl的映射支持,可让Java与XML之间来回切换 org.springframework.test-3.0.6.RELEASE 对Junit等测试框架的简单封装 org.springframework.transaction-3.0.6.RELEASE 为JDBC、Hibernate、JDO、JPA等提供的一致的声明式和编程式事务管理 org.springframework.web.portlet-3.0.6.RELEASE 基于protlet的MVC实现 org.springframework.web.servlet-3.0.6.RELEASE 基于servlet的MVC实现 org.springframework.web.struts-3.0.6.RELEASE 整合Struts的时候的支持 org.springframework.web-3.0.6.RELEASE SpringWeb下的工具包   作Spring还必须依赖第三方包： ① Spring 工程依赖的公共包 commons-logging-1[1].0.4.jar（只要是作Spring都须要这个包，不然工程起不来） ② 使用SpringAOP功能时依赖的包  aspectjweaver-1[1].5.3.jar aopalliance-1.0.jar  (下载：http://mirrors.ibiblio.org/maven2/aopalliance/aopalliance/1.0/) ③ 使用SpringJDBC功能时依赖的包 commons-dbcp.jar (下载：http://commons.apache.org/dbcp/download_dbcp.cgi) commons-pool.jar (下载：http://mirrors.ibiblio.org/maven2/commons-pool/commons-pool/) commons-collections-2.1.1.jar

4.srpingMVC的原理

1. 客户端请求提交到DispatcherServlet 2. 由DispatcherServlet控制器查询一个或多个HandlerMapping，找处处理请求的Controller 3. DispatcherServlet将请求提交到Controller 4. Controller调用业务逻辑处理后，返回ModelAndView 5. DispatcherServlet查询一个或多个ViewResoler视图解析器，找到ModelAndView指定的视图 6. 视图负责将结果显示到客户端 DispatcherServlet是整个Spring MVC的核心。它负责接收HTTP请求组织协调Spring MVC的各个组成部分。其主要工做有如下三项：        1. 截获符合特定格式的URL请求。        2. 初始化DispatcherServlet上下文对应的WebApplicationContext，并将其与业务层、持久化层的WebApplicationContext创建关联。        3. 初始化Spring MVC的各个组成组件，并装配到DispatcherServlet中。

 

5.springMVC注解的意思

@Controller  @Controller 负责注册一个bean 到spring 上下文中，bean 的ID 默认为 类名称开头字母小写,你也能够本身指定，以下  方法一：  @Controller  public class TestController {}    方法二：             @Controller("tmpController")  public class TestController {}    @RequestMapping    1.@RequestMapping用来定义访问的URL，你能够为整个类定义一个 @RequestMapping，或者为每一个方法指定一个。  把@RequestMapping放在类级别上，这可令它与方法级别上的 @RequestMapping注解协同工做，取得缩小选择范围的效果。  例如：  @RequestMapping("/test")  public class TestController {}  则，该类下的全部访问路径都在/test之下。    2.将@RequestMapping用于整个类不是必须的，若是没有配置，全部的方法 的访问路径配置将是彻底独立的，没有任何关联。    3.完整的参数项为：@RequestMapping(value="",method = {"",""},headers={},params={"",""})，各参数说明以下： value :String[] 设置访问地址  method: RequestMethod[]设置访问方式，字符数组，查看RequestMethod 类，包括GET, HEAD, POST, PUT, DELETE, OPTIONS, TRACE,经常使用 RequestMethod.GET，RequestMethod.POST  headers:String[] headers通常结合method = RequestMethod.POST使用  params: String[] 访问参数设置，字符数组 例如：userId=id    4.value的配置还能够采用模版变量的形式 ，例如：@RequestMapping (value="/owners/{ownerId}", method=RequestMethod.GET)，这点将在介 绍@PathVariable中详细说明。    5.@RequestMapping params的补充说明，你能够经过设置参数条件来限制 访问地址，例如params="myParam=myValue"表达式，访问地址中参数只有 包含了该规定的值"myParam=myValue"才能匹配得上，相似"myParam"之类 的表达式也是支持的，表示当前请求的地址必须有该参数(参数的值能够是 任意)，"!myParam"之类的表达式代表当前请求的地址不能包含具体指定的 参数"myParam"。    6.有一点须要注意的，若是为类定义了访问地址为*.do,*.html之类的，则 在方法级的@RequestMapping，不能再定义value值，不然会报错，例如  Java代码   @RequestMapping("/bbs.do")   public class BbsController {       @RequestMapping(params = "method=getList")       public String getList() {        return "list";       }   @RequestMapping(value= "/spList")   public String getSpecialList() {        return "splist";       }   }     如上例：/bbs.do?method=getList 能够访问到方法getList() ；而访 问/bbs.do/spList则会报错.    @PathVariable  1.@PathVariable用于方法中的参数，表示方法参数绑定到地址URL的模板 变量。  例如：  Java代码   @RequestMapping(value="/owners/{ownerId}",  method=RequestMethod.GET)   public String findOwner(@PathVariable String ownerId, Model  model) {     Owner owner = ownerService.findOwner(ownerId);       model.addAttribute("owner", owner);       return "displayOwner";   }     2.@PathVariable用于地址栏使用{xxx}模版变量时使用。  若是@RequestMapping没有定义相似"/{ownerId}" ，这种变量，则使用在 方法中@PathVariable会报错。      @ModelAttribute  1.应用于方法参数,参数能够在页面直接获取，至关于 request.setAttribute(,)  2.应用于方法,将任何一个拥有返回值的方法标注上 @ModelAttribute，使 其返回值将会进入到模型对象的属性列表中.  3.应用于方法参数时@ModelAttribute("xx"),须关联到Object的数据类型 ，基本数据类型 如：int,String不起做用  例如：  Java代码   @ModelAttribute("items")//<——①向模型对象中添加一个名为items的 属性   public List<String> populateItems() {           List<String> lists = new ArrayList<String>();           lists.add("item1");           lists.add("item2");           return lists;   }   @RequestMapping(params = "method=listAllBoard")   public String listAllBoard(@ModelAttribute("currUser")User user,  ModelMap model) {           bbtForumService.getAllBoard();           //<——②在此访问模型中的items属性           System.out.println("model.items:" + ((List<String>) model.get("items")).size());           return "listBoard";   }     在 ① 处，经过使用 @ModelAttribute 注解，populateItem() 方法将在 任何请求处理方法执行前调用，Spring MVC 会将该方法返回值以“items ”为名放入到隐含的模型对象属性列表中。  因此在 ② 处，咱们就能够经过 ModelMap 入参访问到 items 属性，当执 行 listAllBoard() 请求处理方法时，② 处将在控制台打印 出“model.items:2”的信息。固然咱们也能够在请求的视图中访问到模型 对象中的 items 属性。      @ResponseBody  这个注解能够直接放在方法上，表示返回类型将会直接做为HTTP响应字节 流输出(不被放置在Model，也不被拦截为视图页面名称)。能够用于ajax。    @RequestParam  @RequestParam是一个可选参数，例如：@RequestParam("id") 注解，因此 它将和URL所带参数 id进行绑定  若是入参是基本数据类型（如 int、long、float 等），URL 请求参数中 必定要有对应的参数，不然将抛出  org.springframework.web.util.NestedServletException 异常，提示无 法将 null 转换为基本数据类型.    @RequestParam包含3个配置 @RequestParam(required = ,value="",  defaultValue = "")  required :参数是否必须，boolean类型,可选项，默认为true  value: 传递的参数名称，String类型,可选项，若是有值，对应到设置方 法的参数  defaultValue:String类型,参数没有传递时为参数默认指定的值    @SessionAttributes session管理  Spring 容许咱们有选择地指定 ModelMap 中的哪些属性须要转存到  session 中，以便下一个请求属对应的 ModelMap 的属性列表中还能访问 到这些属性。这一功能是经过类定义处标注 @SessionAttributes 注解来 实现的。@SessionAttributes 只能声明在类上，而不能声明在方法上。    例如    @SessionAttributes("currUser") // 将ModelMap 中属性名为currUser 的属性  @SessionAttributes({"attr1","attr2"})  @SessionAttributes(types = User.class)  @SessionAttributes(types = {User.class,Dept.class})  @SessionAttributes(types = {User.class,Dept.class},value={"attr1","attr2"})    @CookieValue 获取cookie信息  @RequestHeader 获取请求的头部信息

 

6.spring中beanFactory和ApplicationContext的联系和区别

BeanFacotry是spring中比较原始的Factory。如XMLBeanFactory就是一种典型的BeanFactory。原始的BeanFactory没法支持spring的许多插件，如AOP功能、Web应用等。    ApplicationContext接口,它由BeanFactory接口派生而来，于是提供BeanFactory全部的功能。ApplicationContext以一种更向面向框架的方式工做以及对上下文进行分层和实现继承，ApplicationContext包还提供了如下的功能：    • MessageSource, 提供国际化的消息访问     • 资源访问，如URL和文件     • 事件传播     • 载入多个（有继承关系）上下文 ，使得每个上下文都专一于一个特定的层次，好比应用的web层

7.spring注入的几种方式

接口注入 Setter方法注入 构造方法注入 spring4能够注解注入@Autowired

 

8.spring如何实现事物管理的

是经过AOP对配置的方法进行栏截，而后再调用事务管理器中的预设代码对事务进行管理，再委托被拦截方法完成原有的任务。

9.springIOC和AOP的原理
10.hibernate中的1级和2级缓存的使用方式以及区别原理
11.spring中循环注入的方式

什么是循环注入？举个列子我有一个类A，A有一个构造器里面的参数是类B，而后类B里面有个构造器参数是类C，类C里面有个构造器参数是类A，就是咱们会发现其实引用循环了A 里面有B的引用，B里面有C的引用，C里面又有A的引用。

 

循环依赖又分为构造器循环依赖和set循环依赖： 首先讲一下构造器的循环依赖： public class A   {   public A(B b)   {   }   }     public class B   {   public B(C c)   {   }   }       public class C   {   public C(A a)   {   }   }   当咱们用spring来加载A的时候spring的流程是这样的： 1：spring建立A首先去当前建立池中去查找当前A是否在建立，若是发明没有建立则准备其构造器须要的参数B，而后把建立A的标识放入当前建立池中。 2：spring建立B首先去当前建立池中去查找当前B是否在建立，若是发现没有建立则准备其构造器须要的参数C，而后把建立B的标识放入当前建立池中。 3：spring建立C首先去当前建立池中去查找当前C是否在建立，若是发现没有建立则准备其构造器须要的参数A，而后把建立C的标识放入当前建立池中。 4：spring建立C须要的A，这个时候会发如今当前建立池中已经有A的标识，A正在建立中则抛出BeanCurrentlyInCreationException。 构造器的循环注入是没有办法解决的，因此只能咱们避免.   接下来看下set方式的循环注入: set方式的循环注入分2种状况，第一种状况是能够解决的循环注入就是单列状况下。第二种状况就是没法解决的循环注入就是多列状况下，下面分析一下缘由： 先看第一种状况，仍是拿上面的ABC3个类来讲明问题，只不过此次不是构造器里面的参数，而是换成他们的成员变量，而后经过set方式类注入,这里代码就不写了直接讲下： 单列下set方式的注入流程是这样的： 1：spring建立A，首先根据其无参构造器建立一个对象A，而后提早暴露出建立出来的这个A对象，而后再当前的建立池中放入建立A的标识，而后进行set方法注入B。 2：spring建立B，首先根据其无参构造器建立一个对象B，而后提早暴露出建立出来的这个B对象，而后在当前的建立池中放入建立B的标识，而后进行set方法的注入C。 3：spring建立C，首先根据其无参构造器建立一个对象C，而后提早暴露出建立处理的这个C对象，而后在当前的建立池中放入建立C的标识，而后进行set方法的注入A。 4：在第三步注入A的时候因为提早暴露出来了建立出来的A对象因此不会报BeanCurrentlyInCreationException的错误。 多列下set方式的循环注入不能解决的缘由是在多列的状况下，当建立对象的时候spring不会提早暴露建立处理的对象A，这样的话则会和构造器循环注入出现同样的状况最终致使报错

3、多线程
1.Java建立线程以后，直接调用start()方法和run()的区别

Thread类中run()和start()方法的区别以下： run()方法:在本线程内调用该Runnable对象的run()方法，能够重复屡次调用； start()方法:启动一个线程，调用该Runnable对象的run()方法，不能屡次启动一个线程；   当你调用start()方法时你将建立新的线程，而且执行在run()方法里的代码。可是若是你直接调用run()方法，它不会建立新的线程也不会执行调用线程的代码

2.经常使用的线程池模式以及不一样线程池的使用场景

http://blog.163.com/wm_at163/blog/static/132173490201242984518354/
3.newFixedThreadPool此种线程池若是线程数达到最大值后会怎么办，底层原理。
4.多线程之间通讯的同步问题，synchronized锁的是对象，衍伸出和synchronized相关不少的具体问题，例如同一个类不一样方法都有synchronized锁，一个对象是否能够同时访问。或者一个类的static构造方法加上synchronized以后的锁的影响。
5.了解可重入锁的含义，以及ReentrantLock 和synchronized的区别
6.同步的数据结构，例如concurrentHashMap的源码理解以及内部实现原理，为何他是同步的且效率高
7.atomicinteger和volatile等线程安全操做的关键字的理解和使用
8.线程间通讯，wait和notify
9.定时线程的使用
10.场景：在一个主线程中，要求有大量(不少不少)子线程执行完以后，主线程才执行完成。多种方式，考虑效率。

4、网络通讯
1.http是无状态通讯，http的请求方式有哪些，能够本身定义新的请求方式么。
2.socket通讯，以及长链接，分包，链接异常断开的处理。
3.socket通讯模型的使用，AIO和NIO。
4.socket框架netty的使用，以及NIO的实现原理，为何是异步非阻塞。
5.同步和异步，阻塞和非阻塞。

5、Linux
1.经常使用的linux下的命令
2.大的log文件中，统计异常出现的次数、排序，或者指定输出多少行多少列的内容。(主要考察awk)
3.linux下的调查问题思路：内存、CPU、句柄数、过滤、查找、模拟POST和GET请求等等场景
4.shell脚本中#！的做用

6、数据库MySql
1.MySql的存储引擎的不一样
2.单个索引、联合索引、主键索引
3.Mysql怎么分表，以及分表后若是想按条件分页查询怎么办(若是不是按分表字段来查询的话，几乎效率低下，无解)
4.分表以后想让一个id多个表是自增的，效率实现
5.MySql的主从实时备份同步的配置，以及原理(从库读主库的binlog)，读写分离
6.写SQL语句。。。
7.索引的数据结构，B+树
8.事物的四个特性，以及各自的特色（原子、隔离）等等，项目怎么解决这些问题

7、设计模式(写代码)
1.单例模式：饱汉、饿汉。以及饿汉中的延迟加载
2.工厂模式、装饰者模式、观察者模式。

8、算法
1.使用随机算法产生一个数，要求把1-1000W之间这些数所有生成。（考察高效率，解决产生冲突的问题）
2.两个有序数组的合并排序
3.一个数组的倒序
4.计算一个正整数的正平方根
5.说说常见的查找排序算法
9、缓存
1.为何用缓存，用过哪些缓存，redis和memcache的区别
2.redis的数据结构
3.redis的持久化方式，以及项目中用的哪一种，为何
4.redis集群的理解，怎么动态增长或者删除一个节点，而保证数据不丢失。

 赢在格局，不失风雅。