java实习面试题总结及部分答案2

润和软件（2017.5.17）

SQL语句

增删改查

Tomcat端口修改

Tomcat目录下，conf文件夹中server.xml  port="8080" ....../>

Sql server 分页

--top not in方式 

--ROW_NUMBER() OVER()方式     

--offset fetch next方式 

MySQL分页：

1、使用limit的方式 SELECT a FROM foo WHERE b = 1 LIMIT 100,10;

2、使用SQL_CALC_FOUND_ROWS

SELECT SQL_CALC_FOUND_ROWS a FROM foo WHERE b = 1 LIMIT 100, 10;

学习新技术（语言）的时间

根据实际情况确定，上手比较快

北京卓望（2017.5.17）

笔试

       基本素质

       Java基础

数据库设计

表的关系，字段，索引等

范式

第一范式（1NF）：强调的是列的原子性，即列不能够再分成其他几列。

第二范式（2NF）：首先是 1NF，另外包含两部分内容，一是表必须有一个主键；二是没有包含在主键中的列必须完全依赖于主键，而不能只依赖于主键的一部分。

第三范式（3NF）：首先是 2NF，另外非主键列必须直接依赖于主键，不能存在传递依赖。即不能存在：非主键列 A 依赖于非主键列 B，非主键列 B 依赖于主键的情况。

Java跨平台的原因

每个系统平台都是有自己的虚拟机（JVM）。Java是解释执行的，编译为中间码的编译器与平台无关，编译生成的中间码也与平台无关（一次编译，到处运行），中间码再由解释器解释执行，解释器是与平台相关的，也就是不同的平台需要不同的解释器。

Seesion和Cookie区别

1、cookie数据存放在客户的浏览器上，session数据放在服务器上。

2、cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗

   考虑到安全应当使用session。

3、session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能

   考虑到减轻服务器性能方面，应当使用COOKIE。

4、单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie。

堆排序（大根堆）

堆是一种数据结构，为一棵完全二叉树, 底层如果用数组存储数据的话，假设某个元素为序号为i，如果它有左子树，那么左子树的位置是2i+1，如果有右子树，右子树的位置是2i+2，如果有父节点，父节点的位置是(n-1)/2取整。堆被分为最大堆和最小堆，最大堆的任意子树根节点不小于任意子结点，最小堆的根节点不大于任意子结点。

堆排序就是利用堆来对数组排序。最大堆的最大元素一定在第0位置，构建好堆之后，交换0位置元素与顶即可。堆排序为原位排序(空间小), 且最坏运行时间是O(nlgn)，是渐进最优的比较排序算法。

事务 完整性 一致性

数据库事务(Database Transaction)，是指作为单个逻辑工作单元执行的一系列操作，要么完全地执行，要么完全地不执行。事务处理可以确保除非事务性单元内的所有操作都成功完成，否则不会永久更新面向数据的资源。一个逻辑工作单元要成为事务，必须满足所谓的ACID（原子性、一致性、隔离性和持久性）属性。事务是数据库运行中的逻辑工作单位，由DBMS中的事务管理子系统负责事务的处理。

Hibernate事务管理：

1. 调用sessionFactory不带参数的openSession方法，从连接池获得连接，Session自动把连接设为手工提交事务模式。

2. 声明事务的开始边界 Transaction tx = session.beginTransaction();

3. 提交事务 tx.commit();

 4. 撤销事务 tx.rollback();

 一个session可以对应多个事务，但是应优先考虑让一个session只对应一个事务，当一个事务结束或撤销后，就关闭session。不管事务成功与否，最后都应调用session的close关闭session。任何时候一个session只允许有一个未提交的事务，不能同时开始两个事务。

事务隔离级别

Read uncommitted 一个事务可以读取另一个未提交事务的数据；

Read committed （默认）一个事务要等另一个事务提交后才能读取数据；

Repeatable read 在开始读取数据（事务开启）时，不再允许修改操作；

Serializable 是最高的事务隔离级别，在该级别下，事务串行化顺序执行，可以避免脏读、不可重复读与幻读。

Spring

Spring是一个开源框架，Spring是于2003 年兴起的一个轻量级的Java 开发框架，由Rod Johnson创建。Spring是一个分层的JavaSE/EEfull-stack(一站式) 轻量级开源框架。

类冲突 ClassLoader

BootstrapClassLoader是用本地代码(c/c++等)实现的，它负责加载核心Java class（如rt.jar里的class）。JVM还提供了两个ClassLoader，都是用Java语言编写的，分别是ExtClassLoader**和AppClassLoader，其中ExtClassLoader负责加载Java扩展 class（如jre/lib/ext下的类），AppClassLoader负责加载应用程序自身的类（如-classpath下的class）。

类加载器首先判断JVM中是否有该类，若没有该类，则加载该类（双亲委派机制），如果有，就直接返回。

Tomcat部署多个应用

同一端口

不同端口

Tomcat目录下，conf文件夹中server.xml  port="8080" ....../>

HR面试

自我介绍

录取优势（优点）

统计加油站个数

云软集团（2017.5.18）

了解基本情况

深思数盾（2017.5.19）

笔试

       封装继承多态

浏览器内核

       接口和抽象类

       左连接和右连接区别

       SQL中Distinct作用

       文件操作

读写分离（主从结构）

原理是主数据库处理事务性增、改、删操作（INSERT、UPDATE、DELETE），而从数据库处理SELECT查询操作。数据库复制被用来把事务性操作导致的变更同步到集群中的从数据库。（MySQL Proxy）读和写的IP地址不一样。

同步包concurrent（JUC）

atomic包：主要是Atomic+数据类型，AtomicInteger 原子操作；

locks包：主要有AbstractQueuedSynchronizer(AQS)、Condition、Lock、ReadWriteLock、  ReentrantLock、ReentrantReadWriteLock；

       多线程相关的类和接口

Callable、BlockingQueue、ConcurrentHashMap、CopyOnWriteArrayList、Future、Executor、

ExecutorService、Semaphore。

ConcurrentHashMap原理

ConcurrentHashMap采用了分段锁的设计，只有在同一个分段内才存在竞态关系，不同的分段锁之间没有锁竞争。相比于对整个Map加锁的设计（Hashtable），分段锁大大的提高了高并发环境下的处理能力。ConcurrentHashMap中的分段锁称为Segment，类似于HashMap的结构，即内部拥有一个Entry数组，数组中的每个元素又是一个链表；同时又是一个ReentrantLock（Segment继承了ReentrantLock）。ConcurrentHashMap中的HashEntry相对于HashMap中的Entry有一定的差异性：HashEntry中的value以及next都被volatile修饰。并发度可以理解为程序运行时能够同时更新ConccurentHashMap且不产生锁竞争的最大线程数，实际上就是ConcurrentHashMap中的分段锁个数，即Segment[]的数组长度。ConcurrentHashMap默认的并发度为16。

主要实体类就是三个：ConcurrentHashMap（整个Hash表）Segment（桶） HashEntry（节点），桶和节点都是final类型的。

垃圾回收器分类

1、串行垃圾回收器（Serial Garbage Collector）

通过持有应用程序所有的线程进行工作。它为单线程环境设计，只使用一个单独的线程进行垃圾回收，通过冻结所有应用程序线程进行工作(STW)，所以不适合服务器环境，最适合的是简单的命令行程序。

2、并行垃圾回收器（Parallel Garbage Collector）

throughput collector。它是JVM的默认垃圾回收器。与串行垃圾回收器不同，它使用多线程进行垃圾回收。当执行垃圾回收的时候，也会冻结所有的应用程序线程。

3、并发标记扫描垃圾回收器（CMS Garbage Collector）Concurrent Mark-Sweep

使用多线程扫描堆内存，标记需要清理的实例并且清理被标记过的实例。并发标记垃圾回收器只会在下面两种情况持有应用程序所有线程。当标记的引用对象在tenured区域；在进行垃圾回收的时候，堆内存的数据被并发的改变。相比并行垃圾回收器，并发标记扫描垃圾回收器使用更多的CPU来确保程序的吞吐量。

4、G1垃圾回收器（G1 Garbage Collector）面向服务端

适用于堆内存很大的情况，将堆内存分割成不同的区域，并且并发的对其进行垃圾回收。G1可以在回收内存之后对剩余的堆内存空间进行压缩。

 “stop-the-world”机制简称STW，即在执行垃圾收集算法时,Java应用程序的其他所有除了垃圾收集帮助器线程之外的线程都被挂起。

获取类的私有属性

获取类：1、类名.class  2、实例.getClass()  3、Class.forName(“类名”)

Field fields[]=1/2/3.getDeclaredFields();//获得对象所有属性

Field field=1/2/3.getDeclaredField();//获得对象一个属性

Method getDeclaredMethod(String name, Class… parameterTypes)，返回一个 Method 对象，该对象反映此 Class 对象所表示的类或接口的指定已声明方法。

Method[] getDeclaredMethods()，返回 Method 对象的一个数组，这些对象反映此 Class 对象表示的类或接口声明的所有方法，包括公共、保护、默认（包）访问和私有方法，但不包括继承的方法。

Method getMethod(String name, Class… parameterTypes)，返回一个 Method 对象，它反映此 Class 对象所表示的类或接口的指定公共成员方法。

Method[] getMethods()，返回一个包含某些 Method 对象的数组，这些对象反映此 Class 对象所表示的类或接口（包括那些由该类或接口声明的以及从超类和超接口继承的那些的类或接口）的公共 member 方法。

在不调用类构造函数的情况下实例化对象

1、使用new关键字；2、使用clone方法；3、反射机制；4、反序列化； 5、IOC框架 Spring

1,3都会明确的显式的调用构造函数；2是在内存上对已有对象的引用，所以不会调用构造函数；4是从文件中还原类的对象，也不会调用构造函数。

主线程获取子线程结果

Future接口是Java标准API的一部分，在java.util.concurrent包中。Future接口是Java线程Future模式的实现，可以来进行异步计算。

接口方法：

1）boolean cancel(boolean mayInterruptIfRunning)：试图取消对此任务的执行。

2）boolean isCancelled()：如果在任务正常完成前将其取消，则返回 true。

3）boolean isDone()：如果任务已完成，则返回 true。

4）V get()throws InterruptedException,ExecutionException：如有必要，等待计算完成，然后获取其结果。

5）V get(long timeout,TimeUnit unit) 如有必要，最多等待为使计算完成所给定的时间之后，获取其结果（如果结果可用）。

过程：1.启动多线程任务2.处理其他事3.收集多线程任务结果，实现了非阻塞的任务调用。但是Future的结果需要通过isdone来判断是否有结果，或者使用get()函数来阻塞式获取执行结果，不能实时跟踪其他线程的结果状态。

CompletionService，内部添加了阻塞队列，从而获取future中的值，然后根据返回值作对应的处理。

线程创建3种方式

1、继承Thread类创建线程类

定义Thread类的子类，并重写该类的run方法，该run方法的方法体就代表了线程要完成的任务。把run()方法称为执行体。创建Thread子类的实例，即创建了线程对象。调用线程对象的start()方法来启动该线程。

2、通过Runnable接口创建线程类

定义runnable接口的实现类，并重写该接口的run()方法，该run()方法的方法体同样是该线程的线程执行体。创建 Runnable实现类的实例，并依此实例作为Thread的target来创建Thread对象，该Thread对象才是真正的线程对象。调用线程对象的start()方法来启动该线程。

3、通过Callable和Future创建线程

创建Callable接口的实现类，并实现call()方法，该call()方法将作为线程执行体，并且有返回值。创建Callable实现类的实例，使用FutureTask类来包装Callable对象，该FutureTask对象封装了该Callable对象的call()方法的返回值。使用FutureTask对象作为Thread对象的target创建并启动新线程。调用FutureTask对象的get()方法来获得子线程执行结束后的返回值

RPC 分布式

RPC（Remote Procedure Call Protocol）即远程过程调用协议，是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC协议假定某些传输协议的存在，如TCP或UDP，为通信程序之间携带信息数据。在OSI网络通信模型中，RPC跨越了传输层和应用层。RPC使得开发包括网络分布式多程序在内的应用程序更加容易。

RPC采用客户机/服务器模式。请求程序就是一个客户机，而服务提供程序就是一个服务器。首先，客户机调用进程发送一个有进程参数的调用信息到服务进程，然后等待应答信息。在服务器端，进程保持睡眠状态直到调用信息到达为止。当一个调用信息到达，服务器获得进程参数，计算结果，发送答复信息，然后等待下一个调用信息，最后，客户端调用进程接收答复信息，获得进程结果，然后调用执行继续进行。

调用方式：同步和异步

Java中常用的RPC框架： RMI 远程方法调用 Hessian基于HTTP的远程方法调用

Dubbo淘宝开源的基于TCP的RPC框架

 

客户端和服务端可以运行在不同的JVM中，Client只需要引入接口，接口的实现以及运行时需要的数据都在Server端，RPC的主要依赖技术是序列化、反序列化和传输协议，在JAVA里就是对象的序列化、反序列化以及序列化后数据的传输。RMI的序列化和反序列化是JAVA自带的，Hessian里的序列化和反序列化是私有的，传输协议则是HTTP，Dubbo的序列化可以多种选择，一般使用Hessian的序列化协议，传输则是TCP协议，使用了高性能的NIO框架Netty。

Web Service

Web service是一个平台独立的，低耦合的，自包含的、基于可编程的web的应用程序，可使用开放的XML标准来描述、发布、发现、协调和配置这些应用程序，用于开发分布式的互操作的应用程序。

Web Service技术， 能使得运行在不同机器上的不同应用无须借助附加的、专门的第三方软件或硬件，就可相互交换数据或集成。依据Web Service规范实施的应用之间，无论所使用的语言、平台或内部协议是什么，都可以相互交换数据。Web Service是自描述、自包含的可用网络模块，可以执行具体的业务功能。Web Service也很容易部署，因为它们基于一些常规的产业标准以及已有的一些技术，诸如标准通用标记语言下的子集XML、HTTP。Web Service减少了应用接口的花费。Web Service为整个企业甚至多个组织之间的业务流程的集成提供了一个通用机制。

字符串乱码

网页显示乱码

       确认本jsp在编辑器中保存文件内容时，使用的是utf-8的编码格式，然后在jsp页面的开始处添加<%@ pageEncoding="utf-8"%>

返回数据乱码

       response.setContentType("text/hmtl;charset=utf-8")

接收参数乱码

Get  1、是用http的url传过来的参数默认用iso-8859-1编码的，要用utf-8进行解码。new String(参数.getBytes(“ISO-8859-1”),“UTF-8”);

2、修改tomcat服务器的配置文件。修改tomcat目录下的conf/server.xml文件

maxThreads="150"   connectionTimeout="200000"

     redirecPort="8443"    URIEncoding="utf-8"/>

Post request.setCharacterEncoding("UTF-8"):

最近学习的技术

       Mybatis、Springboot、redis

京东商城（2017.5.23）

笔试

      

4、用Jprofiler,yourkit,JConsole工具

用Runtime.maxMemory(),Runtime.totalMemory(),Runtime.freeMemory()方法来查看Java中堆内存的大小。

使用命令“jmap”来获得heap dump，用“jhat”来分析heap dump。jstat

 

TLAB（Thread Local Allocation Buffer）Hotspot为了提升对象内存分配的效率，对于所创建的线程都会分配一块独立的空间

5、jstack打印出给定的java进程ID或core file或远程调试服务的Java堆栈信息。

gdb,VisualVM, Thread Dump

9、数据库事务，读写锁，原子类，同步

10、一、PreparedStatement采用预编译语句集，它内置了处理SQL注入的能力，只要使用它的setXXX方法传值即可。绑定变量

(1).代码的可读性和可维护性.

(2).PreparedStatement尽最大可能提高性能.

(3).极大地提高了安全性.

二、使用正则表达式过滤传入的参数

三、存储过程

四、权限管理

五、数据库加密

六、SQL注入检测jsky MDCSOFT SCAN等

11、Guava工程包含了若干被Google的Java项目广泛依赖的核心库，例如：集合 [collections]、缓存 [caching]、原生类型支持 [primitives support]、并发库 [concurrency libraries] 、通用注解 [common annotations] 、字符串处理 [string processing] 、I/O 等等。

Lock和synchronized区别

一、用法区别

synchronized：在需要同步的对象中加入此控制，synchronized可以加在方法上，也可以加在特定代码块中，括号中表示需要锁的对象。

lock：需要显示指定起始位置和终止位置。一般使用ReentrantLock类作为锁，多个线程中必须要使用一个ReentrantLock类作为对象才能保证锁的生效。且在加锁和解锁处需要通过lock()和unlock()显示指出。所以一般会在finally块中写unlock()以防死锁。

二、性能区别

synchronized是托管给JVM执行的，而lock是java写的控制锁的代码。

synchronized原始采用的是CPU悲观锁机制，即线程获得的是独占锁。独占锁意味着其他线程只能依靠阻塞来等待线程释放锁。而在CPU转换线程阻塞时会引起线程上下文切换，当有很多线程竞争锁的时候，会引起CPU频繁的上下文切换导致效率很低。

而Lock用的是乐观锁方式。乐观锁就是每次不加锁而是假设没有冲突而去完成某项操作，如果因为冲突失败就重试，直到成功为止。乐观锁的实现机制就是CAS操作（Compare and Swap）compareAndSetState。

三、用途区别

使用ReentrantLock情况：1.某个线程在等待一个锁的控制权的这段时间需要中断；2.需要分开处理一些wait-notify，ReentrantLock里面的Condition应用，能够控制notify哪个线程；3.具有公平锁功能，每个到来的线程都将排队等候。

JVM

索引

同步包JUC

线程池分类及区别

线程池包含线程池管理器、工作线程、任务列队、任务接口等部分。线程池管理器的作用是创建、销毁并管理线程池，将工作线程放入线程池中；工作线程是一个可以循环执行任务的线程，在没有任务是进行等待；任务列队的作用是提供一种缓冲机制，将没有处理的任务放在任务列队中；任务接口是每个任务必须实现的接口，主要用来规定任务的入口、任务执行完后的收尾工作、任务的执行状态等，工作线程通过该接口调度任务的执行。

1、newCachedThreadPool创建一个可缓存线程池，如果线程池长度超过处理需要，可灵活回收空闲线程，若无可回收，则新建线程。

2、newFixedThreadPool 创建一个定长线程池，可控制线程最大并发数，超出的线程会在队列中等待。

3、newScheduledThreadPool 创建一个定长线程池，支持定时及周期性任务执行。

4、newSingleThreadExecutor 创建一个单线程化的线程池，它只会用唯一的工作线程来执行任务，保证所有任务按照指定顺序(FIFO, LIFO, 优先级)执行。

参数：corePoolSize: 线程池维护线程的最少线程数,也是核心线程数,包括空闲线程；maximumPoolSize: 线程池维护线程的最大线程数；keepAliveTime: 线程池维护线程所允许的空闲时间；unit: 程池维护线程所允许的空闲时间的单位；workQueue: 线程池所使用的缓冲队列；handler: 线程池对拒绝任务的处理策略。

Spring常用注解 原理 命名冲突

类级别：@Component，@Repository，@Service，@Controller，@RequestMappingSpring容器根据注解的过滤规则扫描读取注解Bean定义类，并将其注册到Spring IoC容器中。

类内部：@AutoWired，@RequestParam。SpringIoC容器通过Bean后置注解处理器解析Bean内部的注解。

Spring对注解的支持主要都是通过反射来获取相应的注解，来做相应的处理。

注解（Annotation）提供了一种安全的类似注释的机制，为我们在代码中添加信息提供了一种形式化的方法，使我们可以在稍后某个时刻方便的使用这些数据（通过解析注解来使用这些数据），用来将任何的信息或者元数据与程序元素（类、方法、成员变量等）进行关联。更加直观地说明这些信息与程序业务逻辑没有关系，并且是供指定的工具或框架使用的。Annotation像一种修饰符一样，应用于包、类型、构造方法、方法、成员变量、参数及本地变量的申明语句中。

Annotation是一种接口。通过Java的反射机制相关的API来访问Annotation信息。相关类（框架或工具中的类）根据这些信息来决定如何使用该程序元素或改变它们的行为。Java语言解释器在工作时会忽略这些Annotation，因此在JVM中这些Annotation是“不起作用”的，只能通过配套的工具才能对这些Annotation类型的信息进行访问和处理。

Annotation和interface的异同：

annotition继承java.lang.annotition.Annotition接口，使用关键字@interface。

Annotation类型、方法定义是独特的、受限制的。Annotation类型的方法必须申明为无参数、无异常抛出的。

Annotation类型可以定义常量、静态成员类型（比如枚举类型定义）。Annotation类型被实现或者继承。

ArrayList和LinkedList区别

tomcat优化

内存优化

对 tomcat 启动参数优化，在 tomcat 的启动脚本 catalina.sh 中设置JAVA_OPTS 参数。

　　-server  启用jdk 的 server 版；

　　-Xms    java虚拟机初始化时的最小内存；

　　-Xmx   java虚拟机可使用的最大内存；

　　-XX:PermSize    内存永久保留区域

　　-XX:MaxPermSize   内存最大永久保留区域

并发优化

1、优化线程数：增加maxThreads和acceptCount属性（使acceptCount大于等于maxThreads）

• maxThreads：tomcat可用于请求处理的最大线程数，默认是200

• minSpareThreads：tomcat初始线程数，即最小空闲线程数

• maxSpareThreads：tomcat最大空闲线程数，超过的会被关闭

• acceptCount：当所有可以使用的处理请求的线程数都被使用时，可以放到处理队列中的请求数，超过这个数的请求将不予处理.默认100

2、使用线程池

在server.xml中增加executor节点，然后配置connector的executor属性

• namePrefix：线程池中线程的命名前缀

• maxThreads：线程池的最大线程数

• minSpareThreads：线程池的最小空闲线程数

• maxIdleTime：超过最小空闲线程数时，多的线程会等待这个时间长度，然后关闭

• threadPriority：线程优先级

缓存优化

compression 打开压缩功能

compressionMinSize   启用压缩的输出内容大小，这里面默认为2KB

compressableMimeType 压缩类型

connectionTimeout 定义建立客户连接超时的时间. 如果为 -1, 表示不限制建立客户连接的时间

UML时序图

数据库引擎

Innodb引擎提供了对数据库ACID事务的支持，并且实现了SQL标准的四种隔离级别。该引擎提供了行级锁和外键约束，设计目标是处理大容量数据库系统，是基于MySQL后台的完整数据库系统，MySQL运行时Innodb会在内存中建立缓冲池，用于缓冲数据和索引。不支持FULLTEXT类型的索引，没有保存表的行数，当SELECT COUNT(*) FROM TABLE时需要扫描全表。

MyIASM是MySQL默认的引擎，没有提供对数据库事务的支持，也不支持行级锁和外键，因此当INSERT(插入)或UPDATE(更新)数据时即写操作需要锁定整个表，效率便会低一些。MyIASM中存储了表的行数，于是SELECT COUNT(*) FROM TABLE时只需要直接读取已经保存好的值而不需要进行全表扫描。如果读多写少且不需要数据库事务的支持，那么MyIASM也是很好的选择。

Innodb的索引文件本身就是数据文件，即B+Tree的数据域存储的就是实际的数据，这种索引就是聚集索引。这个索引的key就是数据表的主键，因此InnoDB表数据文件本身就是主索引。

修改数据库引擎：将my-small.ini另存为my.ini，在[mysqld]后面添加default-storage-engine=InnoDB，重启服务，数据库默认的引擎修改为InnoDB

String能不能继承

不可以，因为String类有final修饰符，而final修饰的类是不能被继承的，实现细节不允许改变。

String被final修饰的原因：字符串常量池的需要，允许String对象缓存，HashCode安全性

Servlet生命周期

Servlet生命周期分为三个阶段：

　　1、初始化阶段，调用init()方法；

　　2、响应客户请求阶段，调用service()方法 doPost或者doGet；

3、终止阶段，调用destroy()方法。

客户端请求服务器过程：

1、Web Client 向Servlet容器（Tomcat）发出Http请求；

1. Servlet容器接收Web Client的请求；
2. Servlet容器创建一个HttpRequest对象，将Web Client请求的信息封装到这个对象中；
3. Servlet容器创建一个HttpResponse对象；
4. Servlet容器调用HttpServlet对象的service方法，把HttpRequest对象与HttpResponse对象作为参数传给 HttpServlet 对象。
5. HttpServlet调用HttpRequest对象的有关方法，获取Http请求信息。
6. HttpServlet调用HttpResponse对象的有关方法，生成响应数据。
7. Servlet容器把HttpServlet的响应结果传给Web Client。

Servlet是采用单实例多线程的方式处理请求的

1、Servlet单实例，减少了产生servlet的开销；

2、通过线程池来响应多个请求，提高了请求的响应时间；

3、Servlet容器并不关心到达的Servlet请求访问的是否是同一个Servlet，直接分配给它一个新的线程；如果是同一个Servlet的多个请求，那么Servlet的service方法将在多线程中并发的执行；

4、每一个请求由ServletRequest对象来接受请求，由ServletResponse对象来响应该请求；

DispatcherServlet

DispatcherServlet是前端控制器设计模式的实现，提供Spring Web MVC的集中访问点，而且负责职责的分派，而且与Spring IoC容器无缝集成，从而可以获得Spring的所有好处。DispatcherServlet主要用作职责调度工作，主要用于控制流程，主要职责如下：

1、截获符合特定格式的URL请求。 

2、初始化DispatcherServlet上下文对应的WebApplicationContext，并将其与业务层、持久化层的WebApplicationContext建立关联。

 3、初始化Spring MVC的各个组成组件，并装配到DispatcherServlet中。

JSP内置对象

page和pageContext区别

page：java.lang.Object对应this关键字。JSP网页本身，page对象是当前页面转换后的Servlet类的实例。

pageContext：javax.servlet.jsp.PageContext 的实例，该对象代表该JSP 页面上下文，使用该对象可以访问页面中的共享数据。常用的方法有getServletContext和getServletConfig等。

重写和重载区别

博创智软（2017.5.25）

抽象类是否有构造函数

有。抽象类的构造函数用来初始化抽象类的一些字段，而这一切都在抽象类的派生类实例化之前发生。在继承了抽象类的子类中通过super(参数列表)调用抽象类中的构造方法。

子类重写父类

子类继承父类后只能重写父类中的protected和public方法，默认没有修饰词的是default，同样可以重写，但是private方法就不能重写，即使子类中的方法名和父类的private方法一致，也只能看做是一个新的方法，而不是重写。子类重写父类的方法遵循的是“两同两小一大”原则。两同指的是方法名和形参列表相同。两小指的是子类方法的返回值类型要小于或等于父类被覆盖方法的返回值，子类方法声明抛出的异常应比父类方法抛出的异常要小或相等。一大指的是子类方法的访问权限应该比父类方法要大或相等。

JSP动态包含

静态包含：<%@ include file="被包含页面"%>

动态包含：<jsp:include page="被包含页面" flush="true">

JSP在WEB服务器中都要转换成一个Java文件，java文件再编译成一个class文件。当请求JSP页面的时候，实际上运行的是这个class文件。request对象都是相同的。

静态包含发生在：JSP---->java文件阶段。动态包含发生在：执行class文件阶段，动态加入。

静态包含：只生成一个java文件，动态包含：生成多个class文件。

动态包含：可以添加参数

1. 直接加在page后面；2、param name=“” value=“”>

动态包含总是会检查所含文件的变化，静态包含不会检查

CSS定位

 

SQL优化

Mysql分页关键词 Limit

如何学习新框架

学习书籍，文档，先搭建环境，实现小功能，再逐渐扩大范围，最后研究源码

麦子金融（2017.5.26）

 

加密算法

   MD5 RSA DES SHA SHA1

查看Linux内存CPU

    CPU top

    内存 free –m; df -h 磁盘使用情况

Mybatis中#和$区别

1. #将传入的数据都当成一个字符串，会对自动传入的数据加一个双引号；$将传入的数据直接显示生成在sql中。参数 = ${参数,jdbcType=INTEGER},

2. #方式能够很大程度防止sql注入；$方式无法防止Sql注入。

3. $方式一般用于传入数据库对象，例如传入表名。一般能用#的就别用$。

4. MyBatis排序时使用order by 动态参数时需要注意，用$而不是#。

Servlet生命周期

Filter和AOP区别

设计模式 过滤对象

Java中常见的AOP技术有两个，分别是Filter和代理模式。Filter是基于回调函数（dofilter），代理模式是基于Java反射技术，代理模式又分为静态代理和动态代理，动态代理就是拦截器的简单实现。

Filter是职责链模式的经典应用，实现了Filter接口的doFilter方法主要用于截获Request对象，把截获的请求处理后，调用FilterChain 接口的chain.doFilter方法，把处理权传递给下一个filter。FilterChain维护了一个链表，链表中存放着配置对象的链条，每次用户调用一次chain.doFilter(request, response)，链表就去取下一个配置对象，再通过配置对象得到下一个filter，然后调用该filter，接着在filter里写的逻辑就被执行。

1、filter基于回调函数doFilter，而interceptor则基于java本身的反射机制。

2、filter是依赖于servlet容器的，即只能在servlet容器中执行。而interceptor与servlet容器无关。

3、Filter的过滤范围比Interceptor大,Filter除了过滤请求外通过通配符可以保护页面，图片，文件等等，而Interceptor只能过滤请求。

4、Filter的过滤一般是在加载的时候在init方法声明,而Interceptor可以通过在xml声明是guest请求还是user请求来辨别是否过滤。

Session同步

1、利用数据库

a，建个数据库专门存放web服务器的session，或者，把数据库建在文件服务器上，用户访问web服务器时，会去数据库check一下session的情况，以达到session同步的目的。

b，把存放session的表和其他数据库表放在一起，如果有集群的话，每个数据库节点都要有这张表，并且这张session表的数据表要实时同步。

2、利用cookie

session是文件的形势存放在服务器端的，cookie是文件的形势存在客户端的。把用户访问页面产生的session放到cookie里面，就是以cookie为中转站。

优点：实现简单，方便，也不会加大数据库的负担

缺点：若客户端禁止cookie，session无法同步；cookie的安全性不高。

3、利用redis/memcached

可以利用分布式，可以把web服务器中的内存组合起来，成为一个"内存池"，不管是哪个服务器产生的sessoin都可以放到这个"内存池"中，其他的都可以使用。

优点：不会加大数据库的负担，安全性大大的提高，把session放到内存里面，比从文件中读取要快很多。

缺点：不能完全利用内存，会产生内存碎片，如果存储不足，还会产生内存溢出。

内联和外联区别

1、内连接：仅将两个表中满足连接条件的行组合起来作为结果集。在内连接中，只有在两个表中匹配的行才在结果集中出现。 关键词：INNER JOIN

格式：SELECT 列名表 FROM 表名1 [INNER] JOIN 表名2 ON或WHERE 条件表达式

2、外连接：

左连接：在内连接的基础上，还包含左表中所有不符合条件的数据行，并在其中的右表列填写NULL。 关键字：LEFT JOIN

右连接：在内连接的基础上，还包含右表中所有不符合条件的数据行，并在其中的左表列填写NULL。 关键字：RIGHT JOIN

完全连接：在内连接的基础上，还包含两个表中所有不符合条件的数据行，并在其中的左表、和右表列填写NULL。关键字：FULL JOIN

3、交叉连接：将两个表的所有行进行组合，连接后的行数为两个表的乘积数。（笛卡尔积）。 关键词：CROSS JOIN
    格式：FROM 表名1 CROSS JOIN 表名2

Application和Session作用域  会话跟踪技术

Session有效范围当前会话，从浏览器打开到浏览器关闭这个过程。

Application所有的用户都可以取得此信息，此信息在整个服务器上被保留。Application属性范围值，只要设置一次，则所有的网页窗口都可以取得数据。

Application，Session，Request都需要跨多个页，属性保存时内存开销大。如果能使用request就不使用session，能使用session的就不要使用application。

AOP动态代理JDK和CGLIB的区别

Java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler和proxy来处理。

cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP

2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP

3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换

如何强制使用CGLIB实现AOP？

 （1）添加CGLIB库，SPRING_HOME/cglib/*.jar

 （2）在spring配置文件中加入

JDK动态代理和CGLIB字节码生成的区别？

 （1）JDK动态代理只能对实现了接口的类生成代理，而不能针对类

 （2）CGLIB是针对类实现代理，主要是对指定的类生成一个子类，覆盖其中的方法

MAVEN过程

建立，配置，构建，发布，运行

SpringMVC过程

Linux 日志

       tail -f *.log |grep ‘关键词’awk -F ‘关键词’‘print{$1}’

普元（2017.5.27）

笔试

Mybatis和Hibernate区别

Android原生和H5区别

Tomcat修改端口

项目

地址处理

聊天

Kika新美互通（2017.6.1）

一面：

基本数据类型

   int long float double short char boolean char

参数传递

    值/引用

Concurrentmap原理

   分段锁segment 默认个数16

HashMap底层实现

   数组默认大小为16，小于时自动扩容,装载因子为0.75 hash(k)%length

读写分离 判断读写

AOP：动态数据源切换，就是在程序运行时，把数据源动态织入到程序中，从而选择读取主库还是从库。主要使用的技术是：annotation，Spring AOP ，反射。

数据库主机分开：定义2个数据库连接，一个是MasterDataSource,另一个是SlaveDataSource。更新数据时我们读取MasterDataSource，查询数据时我们读取SlaveDataSource。

    1. 将读写分离放在dao层，在dao层，所有的insert/update/delete都访问master库，所有的select 都访问salve库，这样对于业务层是透明的。

    2. 将读写分离放在ORM层，比如mybatis可以通过mybatis plus拦截sql语句，所有的insert/update/delete都访问master库，所有的select 都访问salve库，这样对于dao层都是透明。

3. 放在代理层，比如MySQL-Proxy，这样针对整个应用程序都是透明的。

缓存

数据库宕机支付出错

查看日志

定期查看对比

1百万个数获取前100大的数

1. 算法如下：根据快速排序划分的思想

(1) 递归对所有数据分成[a,b）b（b,d]两个区间，(b,d]区间内的数都是大于[a,b)区间内的数

(2) 对(b,d]重复(1)操作，直到最右边的区间个数小于100个。注意[a,b)区间不用划分

(3) 返回上一个区间，并返回此区间的数字数目。接着方法仍然是对上一区间的左边进行划分，分为[a2,b2）b2（b2,d2]两个区间，取（b2,d2]区间。如果个数不够，继续(3)操作，如果个数超过100的就重复1操作，直到最后右边只有100个数为止。

2.先取出前100个数，维护一个100个数的最小堆，遍历一遍剩余的元素，在此过程中维护堆就可以了。具体步骤如下：

step1：取前m个元素（例如m=100），建立一个小顶堆。保持一个小顶堆得性质的步骤，运行时间为O（lgm);建立一个小顶堆运行时间为m*O（lgm）=O(m lgm);      

step2:顺序读取后续元素，直到结束。每次读取一个元素，如果该元素比堆顶元素小，直接丢弃 如果大于堆顶元素，则用该元素替换堆顶元素，然后保持最小堆性质。最坏情况是每次都需要替换掉堆顶的最小元素，因此需要维护堆的代价为(N-m)*O(lgm);

最后这个堆中的元素就是前最大的10W个。时间复杂度为O(N lgm）。

简化：

假设数组arr保存100个数字，首先取前100个数字放入数组arr，对于第101个数字k，如果k大于arr中的最小数，则用k替换最小数，对剩下的数字都进行这种处理。

3.分块查找 先把100w个数

分成100份，每份1w个数。先分别找出每1w个数里面的最大的数，然后比较。找出100个最大的数中的最大的数和最小的数，取最大数的这组的第二大的数，与最小的数比较。

排序算法

       冒泡排序、选择排序、快速排序、堆排序

二面：

二分查找 写程序

Git原理

SpringMVC流程

垃圾回收原理

轮子科技（2017.6.1 电话面试）

HTTP状态码200 302 404 500

   200 请求成功，返回数据

    302 暂时请求重定向

    404 请求未找到

    500 服务器内部错误

StringBuffer和StringBuilder区别

==和equals区别

设置守护线程

   daemon是相于user线程而言的，可以理解为一种运行在后台的服务线程，比如时钟处理线程、idle线程、垃圾回收线程等都是daemon线程。daemon线程有个特点就是"比较次要"，程序中如果所有的user线程都结束了，那这个程序本身就结束了，不管daemon是否结束。而user线程就不是这样，只要还有一个user线程存在，程序就不会退出。用Thread中的setDaemon（start之前）就可以把线程设置为Daemon。

线程创建方式

用到的爬虫框架

Java框架

杉数科技（2017.6.2）

项目

IOC和DI区别

       IOC控制反转：创建对象实例的控制权从代码控制剥离到IOC容器控制，实际就是你在xml文件控制，侧重于原理。

DI依赖注入：创建对象实例时，为这个对象注入属性值或其它对象实例，侧重于实现。

SQL连接

SCP

       Security Copy，是Linux中功能最强大的文件传输命令，可以实现从本地到远程以及远程到本地的轻松文件传输操作。

Redis

消息队列

       在消息的传输过程中保存消息的容器，主要目的是提供路由并保证消息的传递；如果发送消息时接收者不可用，消息队列会保留消息，直到可以成功地传递它。使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ等，redis也支持MQ。

       Kafka是Apache下的一个子项目，是一个高性能跨语言分布式Publish/Subscribe消息队列系统。

       消息队列解决的是将突发大量请求转换为后端能承受的队列请求，比如你的服务器一秒能处理100个订单，但秒杀活动1秒进来1000个订单，持续10秒，在后端能力无法增加的情况下，你可以用消息队列将总共10000个请求压在队列里，后台consumer按原有能力处理，100秒后处理完所有请求（而不是直接宕机丢失订单数据）。

冒泡排序

算法题 数组连续的两个数之和相等输出序号

树 获取树的高度 遍历

前端 bootstrap

一亩田（2017.6.5）

 

轮子科技（2017.6.5 现场面试）

笔试

Static用法

线程生命周期

异常分类

因特睿（2017.6.6）

HashMap原理

多线程 synchronized

二叉搜索树

快速排序

项目

中交兴路（2017.6.7）

数据类型

spring

Sql

jquery

list

百度 商家信用部（2017.6.7）

项目 数据库

Sql题

top 5代码实现

手表离开手机10m会响，现在手机找不到了，用最少的步数找到手机