[TOC]

282、如何重新加载Spring Boot上的更改，而无需重新启动服务器？……………. 104
283、SpringBoot中监视器是什么？……………………………………………………….. 104
284、如何集成Spring Boot和ActiveMQ？ ……………………………………………… 104
285、springboot集成mybatis过程？……………………………………………………….. 104
286、发布 Spring Boot 用户应用程序自定义配置的最好方法是什么？………….. 104
287、springcloud和dubbo的区别？………………………………………………………… 104

1、说出一些数据库优化方面的经验?(重点)

1) 从 JDBC 编程的角度讲,用 PreparedStatement 一般来说比 Statement 性能高,因为在使用时,SQL 语句被预编译并存储在 PreparedStatement 对象中.然后可以使用
PreparedStatement 对象多次高效地执行该语句.
2) 有外键约束会影响插入和删除性能,如果程序能够保证数据的完整性,那在设计数据库时就可以去掉外键.（比喻：就好比免检产品,就是为了提高效率,充分相信产品的制造商）
3) 表中允许适当冗余,譬如,主题帖的回复数量和最后回复时间等,将姓名和密码单独从用户表中独立出来等,这些都是分析了业务的特点后,对数据库中表做了优化后的解决方案.也就是说在有些情况下,我们设计数据库可以适度的违反三个范式的设计原则,来获得更好的程序性能.
4) sql 语句全部大写,特别是列名和表名都大写.因为数据库中的语句执行机制是这样的：sql 语句à发给 oracle 服务器à语法检查和编译成为内部指令à缓存和执行指令.而数据库在对语句进行检查和编译时,会自动将 sql 语句转换成大写,并且根据 SQL 缓存的特点,不要拼凑条件,而是用?（占位符参数）和 PreparedStatment 来执行参数化的 sql 语句.
5) 还有索引对查询性能的改进.当经常查询索引列中的数据时,需要在表上创建索引.索引占用磁盘空间,并且降低添加、删除和更新行的速度.在多数情况下,索引用于数据检索的速度优势大大超过它的不足之处.但是,如果应用程序非常频繁地更新数据或磁盘空间有限, 则可能需要限制索引的数量

2、你有优化 SQL 查询数据经验吗？如有能说一下你一般用那些什么方式进行优化？

1) 用索引提高效率
2) 选择最有效率的表名顺序(ORACLE 的解析器按照从右到左的顺序处理 FROM 子句中的表名,FROM 子句中写在最后的表(基础表 driving table)将被最先处理)
3) WHERE 子句中的连接顺序：ORACLE 采用自下而上的顺序解析 WHERE 子句,根据这个原理,表之间的连接必须写在其他 WHERE 条件之前, 那些可以过滤掉最大数量记录的条件必须写在 WHERE 子句的末尾

4) SELECT 子句中避免使用 ‘ * ‘：需要写全查询的字段列名.

3、什么是事务,事务的四个特性是什么？有哪些隔离级别？

1) 事务（Transaction）：是数据库操作的最小工作单元,是作为单个逻辑工作单元执行的一系列操作；这些操作作为一个整体一起向系统提交,要么都执行、要么都不执行；事务是一组不可再分割的操作集合（工作逻辑单元）；
2) 事务具有 4 个属性,通常称为 ACID 特性：
2 .1 原子性（atomicity）：事务是一个完整的操作.事务的各步操作是不可分的；要么都执行、要么都不执行.
2.2 一致性（consistency）：当事务完成时,数据必须处于一致状态.
2.3 隔离性（isolation）：对数据进行修改的所有并发事务是彼此隔离的,这表明事务必须是独立的,它不应以任何方式依赖于或影响其他事务.
2.4 持久性（durability）：事务完成后,它对数据库的修改被永久保存,事务日志能保持事务的永久性.
3) 隔离级别分为：Read Uncommitted(读未提交)、Read Committed(读提交)、Repeatable Read(可以重复读)、Serializable(序列化)这 4 种级别

4、数据库中,数据类型 char 与 varchar2 有什么区别？性能方面各有什么优势？

char 表示的是固定长度,所占存储空间为你定义时的大小,数据量较大的时候以char 字段为查询条件时查询得快一些.
Varchar2 表示的是实际长度的数据类型,所占存储空间为实际大小,前提是不超过你定义时的长度,如果存储的字段不是定长的,用varchar2 好一些.

5、你怎么知道查询 SQL 的性能高还是低？

1）简单的通过查看执行 SQL 的运行时间.
2）可以通过查看数据库提供的语句执行计划来分析相应的数据信息,例如查看执行计划中对应的COST(即成本耗费)值,反应了运行这段 SQL 的总体估计成本,通常COST 低的执行计划要好一些

6、在开发过程中遇到过数据库锁吗？怎样解锁？

1）如果 oracle 中有事务未提交,又打开一个窗口去提交一个新的事务则可能会产生数据库锁.
2）解锁的方式：
a) 结束当前的 session（会话,此处指和数据库的通讯）自动解锁例如,退出当前数据库连接所用的工具或应用程序.
b) 利用 dba 权限强行关闭掉了执行 Lock 操作的 Session.
示例：通过以上查询知道了 sid 和 SERIAL#(流水号)就可以开杀（就是去关掉会话,俗称杀掉会话）了
—查询出对应会话操作的 sid 和 serial

SELECT sid, serial#, username, osuser FROM v$session;
—根据指定的 sid 和 serial 来关闭对应的会话（杀会话的意思）
ALTER SYSTEM KILL SESSION ‘sid,serial’;

7、怎样处理并发数据? (重点)

就数据库操作来说是通过加锁的概念来确保并发数据操作下事务的完整性和数据库的一致性
数据库主要有共享锁和排它锁.当你在修改数据的时候,别人也可以查看,但是他不能修改数据并提交,只能优先你的操作,等你向数据库提交了数据之后他才能执行增删改的操作, 这就是排它锁.共享锁就是你和另外一个用户可以同时共享数据（查看）,但是你和他都不能修改.

8、 delete from table 与 truncate table 的区别？drop table 呢

1) Truncate 是数据定义语言(DDL)做的修改是不能回滚的,就是不可恢复的操作.用了这个命令后就收回了表空间.Delete 是数据操作语言(DML)删除是要把数据写入系统回滚段(rollback segement)中以便恢复时使用.
2) 两者都是删除表中的数据而不会影响到表的结构和定义.
3) 使用 drop 的话就会删除表的结构

9、 union 和 union all 有什么不同?

UNION 在进行表连接后会筛选掉重复的记录,所以在表连接后会对所产生的结果集进行排序运算,删除重复的记录再返回结果.
而 UNION ALL 只是简单的将两个结果合并后就返回.这样,如果返回的两个结果集中有重复的数据,那么返回的结果集就会包含重复的数据了.
从效率上说,UNION ALL 要比 UNION 快很多,所以,如果可以确认合并的两个结果集中不包含重复的数据的话,那么就使用 UNION ALL,

10、 JDBC 访问数据库的步骤？(重点)

1) 加载 JDBC 驱动
2) 与数据库建立连接
3) 发送 SQL 语句,并得到返回结果
4) 处理返回结果
5) 关闭资源

11、大数据量下的分页解决方法.

答：最好的办法是利用 sql 语句进行分页,这样每次查询出的结果集中就只包含某页的数据内容.在 sql 语句无法实现分页的情况下,可以考虑对大的结果集通过游标定位方式来获取某页的数据.
不同的数据库下的分页方案各不一样,下面是主流的三种数据库的分页 sql：

sql server:

String sql =
“select top “ + pageSize + “ from students where id not in” +
“(select top “ + pageSize (pageNumber-1) + “ id from students order by id)” + “order by id”;

mysql:

String sql =
“select from students order by id limit “ + pageSize(pageNumber-1) + “,” + pageSize;

oracle:

String sql = “select from “ +
(select ,rownum rid from (select from students order by postime desc) where rid<=” + pagesizepagenumber + “) as t” + “where t>” + pageSize*(pageNumber-1);

12、简述建立索引的作用和索引的分类 ?

索引的作用：通过使用索引,大大提高数据库的检索速度,改善数据库性能. 索引分类：
1) 唯一索引：唯一索引不允许两行具有相同的索引值
2) 主键索引：在数据库关系图中为表定义一个主键自动创建主键索引,主键索引是唯一索引的特殊类型
3) 聚集索引：在聚集索引中表中各行的事物顺序与键值的逻辑(索引)顺序相同且唯一
4) 非聚集索引：非聚集索引建立在索引页上,在查询数据时可以从索引中找到记录存放的位置
5) 复合索引：在创建索引时,并不是只能对其中一列创建索引,与创建主键一样,可以将多个列组合作为索引,这种索引称为复合索引
6) 全文索引：全文索引是一种特殊类型的基于标记的功能性索引,由 SQL Server 中全文引擎服务创建和维护

13、什么是存储过程,有什么优缺点(重点)

存储过程（Stored Procedure）是一组为了完成特定功能的 SQL 语句集,是由流程控制和SQL 语句书写的命名语句块,经编译和优化后存储在数据库服务器中,应用程序使用时只要调用即可,可以通过指定存储过程的名字并给出参数（如果该存储过程带有参数）来调用.

使用存储过程有以下的优点：

a) 具有良好的安全性：可保证数据的安全性和完整性.通过存储过程可以使没有权限直接访问相应数据库对象的用户受控制的间接地执行数据库相关操作,从而保证数据的安全.
b) 执行速度快,效率高：在运行存储过程前,数据库已对其进行了语法和句法分析,并给出了优化执行方案.这种已经编译好的过程可极大地改善 SQL 语句的性能.由于执行 SQL 语句的大部分工作已经完成,所以存储过程能以极快的速度执行.
c) 减少网络流量：可以降低网络的通信量.
d) 模块化程序设计：存储过程可以封装业务逻辑,并存入数据服务器中,当业务逻辑发生变化时,无需修改调用存储过程的应用程序,只需修改存储过程即可.

使用存储过程的缺点是：

a) 相对而言,调试比较麻烦
b) 移植问题,数据库端代码当然是与具体数据库相关的.
c) 代码可读性差

14、存储过程与 SQL 的区别？

存储过程是一组预编译的 SQL 语句,经编译后存储在数据库中,可包含一个或多个 SQL 语句.能够完成一定功能的子程序,需要的时候用户通过指定存储过程的名字并给出参数（如果该存储过程带有参数）来执行它.存储过程可以包含数据操作语言,逻辑和调用函数等；它又可分为系统存储过程和用户自定义的存储过程.
SQL 指结构化查询语言,是一种 ANSI 的标准计算机语言.

15、如何创建视图？

语法：create view 视图名 AS ）非常适合不需要大量数据存储的会话应用.
2、URL 重写
URL 可以在后面附加参数,和服务器的请求一起发送,服务器根据相应的参数来判断是否为同一个客户端发送的请求,一般可以直接使用 HTTP 会话 API 执行 URL 重写,会自动附加相应的 sessionid,该技术主要使用场景是客户端的浏览器禁用 cookie 导致 session 无法使用的情况.
3、Cookie 技术
服务器通过 cookie 对象来保存 session 对象的 id,用来保证客户端每次发送请求过来都会带上 sessionid 以保证服务器可以识别不同客户端的请求,是 session 机制实现的前提,如果用户禁用 cookie 就只能使用 url 重写来保证 sessionid 的传递了.
4、Session 技术
根据session 对象的 sessionid（唯一标识）即可识别不同的客户端请求

147、 Web 应用中的四大作用域（注意不要和四种会话跟踪技术搞混淆了）(重点)

page 是代表与一个页面相关的对象和属性.一个页面由一个编译好的 Java Servlet 类

（可以带有任何的 include 指令,但是没有 include 动作）表示.这既包括 servlet 又包括被编译成 servlet 的 JSP 页面
request 是代表与Web 客户机发出的一个请求相关的对象和属性.一个请求可能跨越多个页面,涉及多个Web 组件（由于 forward 指令和 include 动作的关系）
session 是代表与用于某个 Web 客户机的一个用户体验相关的对象和属性.一个
Web 会话可以也经常会跨越多个客户机请求
application 是代表与整个Web 应用程序相关的对象和属性.这实质上是跨越整个
Web 应用程序,包括多个页面、请求和会话的一个全局作用域

148、什么是 Cookie？

Cookie,有时也用其复数形式 cookies,指某些网站为了辨别用户身份、进行session 跟踪而储存在用户本地终端上的数据（通常经过加密）.
Cookie 是由服务器端生成,发送给客户端浏览器的,浏览器会将其保存成某个目录下的文本文件.

149、在 JSP 中如何设置 Cookie？(重点)

Cookie cookie = new Cookie(“cookieName”,”cookieValue”);
其中 cookieName 为 Cookie 对象的名称,未来获取 Cookie 的时候需要使用.cookieValue 为
Cookie
对象的值也就是储存用户的信息如用户名、密码等.

150、 Cookie 的应用场景？

1. 对特定对象的追踪,如访问者的访问次数,最后访问时间、路径等
2. 统计网页浏览记录.
3. 在Cookie 有效期内,记录用户登入信息.

4. 实现各种个性化服务,如针对不同用户喜好以不同的风格展示不同的内容
提示：由于Cookie 保存在客户端,所以使用Cookie 存在一定的风险,所以不建议在Cookie
中保存比较重要或敏感的内容.

151、 cookie 与 session 有什么区别?(重点)

1) session 是服务器端保存用户信息,cookie 是在客户端保存用户信息.
2) session 中保存的是对象,cookie 保存的是字符串.
3) session 对象随会话结束而关闭,cookie 可以长期保存在客户端
4) cookie 通常用于保存不重要的用户信息,重要的信息使用 session 保存.第五章

152、说出数据连接池的工作机制是什么? (重点)

数据库连接是一种关键的有限的昂贵的资源,这一点企业级应用程序中体现得尤为突出. 对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性,影响到程序的性能指标. 数据库连接池正是针对这个问题提出来的.
数据库连接池负责分配、管理和释放数据库连接,它允许应用程序重复使用一个现有的数据库连接,而再不是重新建立一个；释放空闲时间超过最大空闲时间的数据库连接来避免因为没有释放数据库连接而引起的数据库连接遗漏.这项技术能明显提高对数据库操作的性
能.
具体工作机制如下：
数据库连接池在初始化时将创建一定数量的数据库连接放到连接池中,这些数据库连接的数量是由最小数据库连接数来设定的.无论这些数据库连接是否被使用,连接池都将一直保证至少拥有这么多的连接数量.连接池的最大数据库连接数量限定了这个连接池能占有的最大连接数,当应用程序向连接池请求的连接数超过最大连接数量时,这些请求将被加入到等待队列中.

数据库连接池的最小连接数和最大连接数的设置要考虑到下列几个因素：
1) 最小连接数是连接池一直保持的数据库连接,所以如果应用程序对数据库连接的使用量不大,将会有大量的数据库连接资源被浪费；
2) 最大连接数是连接池能申请的最大连接数,如果数据库连接请求超过此数,后面的数据库连接请求将被加入到等待队列中,这会影响之后的数据库操作.
3) 如果最小连接数与最大连接数相差太大,那么最先的连接请求将会获利,之后超过最小连接数量的连接请求等价于建立一个新的数据库连接.不过,这些大于最小连接数的数据库连接在使用完不会马上被释放,它将被放到连接池中等待重复使用或是空闲超时后被释放.

153、什么是 MVC 设计模式(重点)

MVC 模式是一种流行的软件的设计模式,MVC 模式将应用程序实现分为 3 个不同的基本部分.模型,视图和控制器.
模型(Model):表示数据和业务处理.在 MVC 的三个部件中,模型拥有最多的处理任务. 被模型返回的数据是中立的,就是说模型与数据格式无关,这样一个模型能为多个视图提供数据,由于应用于模型的代码只需写一次就可以被多个视图重用,所以减少了代码的重复性.对应的组件是java Bean( java 类).
视图(view): 是用户看到并与之交互的界面.MVC 一个最大的好处就是它能为应用程序处理很多不同的视图,在视图中其实没有真正的处理发生,不管这些数据是什么,作为视图来讲,它只是作为一种输出数据并允许用户操作的方式.对应的组件是 JSP 或 HTML 文件.视图提供可交互的界面,向客户显示模型数据.
控制器(Controller): 接收用户的输入并调用模型组件去完成用户的请求.当用户提交一个请求时,控制器本身不做执行业务处理.它只是接收请求并决定调用哪个模型组件去处理请求,然后确定用哪个视图来显示模型处理返回的数据.对应的组件可以是 Servlet. 控制器

响应客户的请求,根据客户的请求来操作模型,并把模型的响应结果经由视图展现给客户.
MVC 最重要的特点就是把显示和数据分离,提高代码的可重用性.
MVC 的处理过程:
首先控制器接收用户的请求,并决定应该调用哪个模型来处理,然后模型处理用户的请求并返回数据,最后控制器确定相应的视图将模型返回的数据呈现给用户.

154、 MVC 设计模式的优缺点：(重点)

1) 优点：
各司其职、互不干涉；有利于开发中的分工；有利于组建的重用；
2) 缺点：
系统结构和实现复杂；视图与控制器过于紧密；
不适用于小型甚至中型应用程序；第七章

155、什么是 Servlet

Servlet 是一种服务器端的 Java 应用程序,具有独立于平台和协议的特性,可以生成动态的Web 页面. 它承担处理客户请求（Web 浏览器或其他 HTTP 客户程序）与服务器响应
（HTTP 服务器上的数据库或应用程序）的工作. Servlet 是位于Web 服务器内部的服务器端的Java 应用程序,与传统的从命令行启动的Java 应用程序不同,Servlet 由Web 服务器进行加载,该Web 服务器必须包含支持 Servlet 的Java 虚拟机.

156、说一说 Servlet 的生命周期? (重点)

servlet 有良好的生命周期的定义,包括加载和实例化、初始化、处理请求以及服务结束四个阶段.WEB 容器加载Servlet,生命周期开始.首先服务器调用 Servlet 的构造方法执行实例化操作,然后容器调用 Servlet 的 init 方法执行初始化操作,请求到达时运行 Servlet 的

service 方法,service 方法自动调用与请求类型对应的 doXXX 方法（doGet,doPost）等来处理请求,当服务器决定将 Servlet 实例销毁前调用其 destroy 方法（用于释放 Servlet 占用资源,例如流、数据库连接等）.

157、服务器如何响应 Web 客户请求？

HttpServlet 容器响应Web 客户请求流程如下：
1） Web 客户向 Servlet 容器发出 Http 请求；
2） Servlet 容器解析Web 客户的 Http 请求；
3） Servlet 容器创建一个 HttpRequest 对象,在这个对象中封装 Http 请求信息；
4） Servlet 容器创建一个 HttpResponse 对象；
5） Servlet 容器调用 HttpServlet 的service 方法,把 HttpRequest 和 HttpResponse 对象作为 service 方法的参数传给 HttpServlet 对象；
6） HttpServlet 调用 HttpRequest 的有关方法,获取 HTTP 请求信息；
7） HttpServlet 调用 HttpResponse 的有关方法,生成响应数据；
8） Servlet 容器把 HttpServlet 的响应结果传给Web 客户.

158、什么情况下调用 doGet( )和 doPost( )？

Jsp 页面中的form 表单标签里的method 属性为get 时调用doGet( ),为post 时调用
doPost( ).

159、 JSP 和 Servlet 有哪些相同点和不同点,他们之间的联系是什么？ (重点)

JSP 是 Servlet 技术的扩展,本质上是 Servlet 的简易方式,更强调应用的外表表达.JSP 编译后是”类 servlet”.Servlet 和JSP 最主要的不同点在于,Servlet 的应用逻辑是在Java 文件中,并且完全从表示层中的 HTML 里分离开来.而JSP 的情况是Java 和 HTML 可以组合成

一个扩展名为.jsp 的文件.JSP 侧重于展示内容,Servlet 主要用于控制逻辑.

160、如何实现 servlet 的单线程模式

通过 page 指令设置<%@ page isThreadSafe=”false”%>,默认 Servlet 支持多线程模式,即有多个客户端同时请求同一个 Servlet,服务器上的 Servlet 只会产生一个实例,但是会启动多个线程来响应客户请求,但是这样会导致线程安全问题,编程时建议不要在 Servlet 中定义成员属性来共享数据,以避免出现数据同步的问题.

161、在 servlets 和 JSP 之间能共享 session 对象吗？

当然可以,session 作用域中的内容,可以在多个请求中共享数据.例如可以在Servlet 中通过request.getSession( )来得到HttpSession 对象,然后将相应数据存储到该 session 对象中,在其它 jsp 页面上都可以通过内置对象 session 来获取存入的值,即使这些页面是通过重定向方式跳转过去的,也可以得到值.Session 本来就是用来保障在同一客户端和服务器之间多次请求之间的数据能够共享的一种机制.第八章

162、 EL 隐式对象有哪些？

1）.作用域访问对象
pageScope：与页面作用域（page）中属性相关联的 Map 类
requestScope：与请求作用域（request）中属性相关联的 Map 类
sessionScope：与会话作用域（session）中属性相关联的 Map 类
applicationScope：与应用程序作用域（application）中属性相关联的 Map 类
使用例子：request.setAttribute(“Student”,stu);当使用 EL 表达式访问某个属性值时候,应该指定查找范围 , 如 ${requestScope.Student} 如果不指定查找范围 , 会按照page->request->session->application 的顺序查找
注意：必须将对象保存在作用域中,才可以用 EL 表达式访问对象.

2）.参数访问对象
param 按照参数名称访问单一请求值的 Map 对象
paramValues 按照参数名称访问数组请求值的 Map 对象
参数访问对象是和页面输入参数有关的隐式对象,通过它们可以得到用户的请求参
数：
比如登录页面表单有个表单项提交用户
名,
在登录处理页面可以通过 ${param.userName} 访问它
3）.JSP 隐式对象
pageContext 提供对页面信息的 JSP 内置对象的访问

163、 jsp 乱码如何解决,给出三种以上的对应解决方案,并给出对应的程序案例；

1） JSP 页面显示乱码
<%@ page contentType=”text/html; charset=gb2312″%>
2）表单提交中文时出现乱码
request.seCharacterEncoding(“gb2312″)对请求进行统一编码
3）数据库连接出现乱码
要涉及中文的地方全部是乱码, 解决办法：在数据库的数据库 URL 中加上
useUnicode=true&characterEncoding=GBK 就 OK 了.
4）通过过滤器完成
5）在 server.xml 中的设置编码格式

164、请简述 Cookie, Session 和 Application 它们的区别. (重点)

1) Cookie 会在客户端硬盘上创建 Cookie 文件
2) Session 大部分情况下会在服务器端硬盘上写入 Cookie 文件
3) Cookie 安全性最低
4) Application 表示 Servlet 上下文环境,在整个 WEB 应用中只有一个Application 对象,用于存储些全局性的数据

165、 Hibernate 使用步骤(重点)

1) 导入 hibernate 的jar 文件和数据库的jar 文件
2) 编写 hibernate 配置文件,hibernate.cfg.xml,默认放在 src 目录,此文件保存数据库的连接信息,hibernate 全局属性信息,以及关联的实体映射文件.
3) 编写实体及实体映射文件.如果是在 3.2 以上版本,则可用注解的方式,可不需要编写.hbm.xml 文件.

编写完了配置文件之后,具体的使用步骤如下：

1) 读取并解析配置文件
2) 读取并解析映射信息,创建 SessionFactory
3) 打开 Session
4) 创建事务 Transaction
5) 持久化操作
6) 提交事务
7) 关闭 Session
8) 关闭 SessionFactory

2) 上面这些步骤是在单独使用 Hibernate 的步骤,如果通过spring 集成 Hibernate,则代码更加的简单.例如使用 Spring 的AOP 声明式事务,则不需要手工开启和关闭
Session 及提交或回滚事务.

166、 Hibernate 中实体对象的三种状态. (重点)

1) 瞬时状态
2) 持久状态
3)
游离状态

http://www.cnblogs.com/jyh317/p/3666566.html

167、介绍一下 Hibernate 的二级缓存(重点) 按照以下思路来回答：
（1）首先说清楚什么是缓存,（2）再说有了 hibernate 的 Session 就是一级缓存, 即有了一级缓存,为什么还要有二级缓存,（3）最后再说如何配置 Hibernate 的二级缓存.

1) 缓存就是把以前从数据库中查询出来和使用过的对象保存在内存中（一个数据结构中）,这个数据结构通常是或类似 Hashmap,当以后要使用某个对象时,先查询缓存中是否有这个对象,如果有则使用缓存中的对象,如果没有则去查询数据库,并将查询出来的对象保存在缓存中,以便下次使用.
2) Hibernate 的Session 就是一种缓存,我们通常将之称为 Hibernate 的一级缓存,当想使用session 从数据库中查询出一个对象时,Session 也是先从自己内部查看是否存在这个对象,存在则直接返回,不存在才去访问数据库,并将查询的结果保存在自己内部.由于 Session 代表一次会话过程,一个 Session 与一个数据库连接相关连,所以 Session 最好不要长时间保持打开,通常仅用于一个事务当中,在事务结束时就应关闭.并且 Session 是线程不安全的,被多个线程共享时容易出现问题.通常只有那种全局意义上的缓存才是真正的缓存应用,才有较大的缓存价值,因此,Hibernate 的 Session 这一级缓存的缓存作用并不明显,应用价值不大.Hibernate 的二级缓存就是要为Hibernate 配置一种全局缓存,

让多个线程和多个事务都可以共享这个缓存.我们希望的是一个人使用过,其他人也可以使用,session 没有这种效果.
3) 二级缓存是独立于 Hibernate 的软件部件,属于第三方的产品,多个厂商和组织都提供有缓存产品,例如,EHCache 和 OSCache 等等.在 Hibernate 中使用二级缓存,首先就要在hibernate.cfg.xml 配置文件中配置使用哪个厂家的缓存产品,接着需要配置该缓存产品自己的配置文件,最后要配置 Hibernate 中的哪些实体对象要纳入到二级缓存的管理中.
明白了二级缓存原理和有了这个思路后,很容易配置起 Hibernate 的二级缓存.扩展知识：一个 SessionFactory 可以关联一个二级缓存,也即一个二级缓存只能负责缓存一个数据
库中的数据,当使用 Hibernate 的二级缓存后,注意不要有其他的应用或SessionFactory
来更改当前数据库中的数据,这样缓存的数据就会与数据库中的实际数据不一致.

168、 Hibernate 的数据加载方式

1) 即时加载
2) 延迟加载
① 集合类型的延迟加载
② 实体对象的延迟加载
③ 属性延迟加载区别：
1) 即时加载,当实体加载完后,立即加载其关联数据.
2) 延迟加载就是当真正需要数据的时候,才真正执行数据加载操作.

169、 Hibernate 如何延迟加载？(重点)

延迟加载机制是为了避免一些无谓的性能开销而提出来的,所谓延迟加载就是当在真正需要数据的时候,才真正执行数据加载操作.在 Hibernate 中提供了对实体对象的延迟加载以及对集合的延迟加载,另外在 Hibernate3 中还提供了对属性的延迟加载.下面我们就分别介绍这些种类的延迟加载的细节.

1) 实体对象的延迟加载：
2) 集合类型的延迟加载：
3) 属性延迟加载：（需要对该实体类做字节码增强操作,否则无法生效）
4) 实体属性延时加载

170、 Hibernate 中怎样实现类之间的关系？（如：一对多、多对多关系）

类与类之间的关系主要体现在表与表之间的关系进行操作,它们都是对对象进行操作,

我们程序中把所有的表与类都映射在一起,它们通过配置文件中的 many-to-one、
one-to-many、many-to-many.
最常用的关系是双向一对多关系,也即主从表之间的关系：双向一对多关系中,在这表这边配置：
Set 集合,one-to-many
在从表这边配置 many-to-one

171、如何优化 Hibernate？(重点)

1) 灵活使用单向一对多关联
2) 不用一对一、用多对一取代
3) 配置对象缓存,不使用集合缓存
4) 一对多集合使用 Bag,多对多集合使用 Set
5) 继承类使用显示多态
6) 表字段要少,表关联不要怕多,有二级缓存撑腰
7) 使用双向一对多关联,不是单向一对多

172、说下 Hibernate 缓存机制(重点)

内部缓存在 Hibernate 中又叫一级缓存,属于应用事务级缓存二级缓存：
1) 应用级缓存
2) 分布式缓存
条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非关键数据
3) 第三方缓存的实现

173、 hibernate 的工作原理

从以下四个方面来说明工作原理：

1) hibernate 如何连接数据库？

配置文件 Hibernate.cfg.xml 文件中定义了和数据库进行连接的信息,包括数据库方<br />言.jdbc 驱动.用户名.密码和 URL 等.Configuration 类借助 dom4j 的 xml 解析器进行 xml 的解析设置环境,然后使用这些环境属性来生成 sessionfactory.这样 sessionfactory 生成的 session 就能够成功获得数据库的连接.

2) hibernate 如何进行数据库写操作？

当保存一个 pojo 持久化对象时,触发 Hibernate 保存事件监听器进行处理.Hibernate 通过映射文件获得对象对应的数据库.表名以及属性对应的数据库列名,然后通过反射机制获得持久化对象的各个属性,最终组织向数据库插入新对象的 SQL 的insert 语句.调用

session.save（）保存数据后这个对象会被标识为持久化状态放在 session,当事务进行提交时才真正执行insert 语句.

3) hibernate 如何从数据中载入对象？

当需要读取读取文件时,Hibernate 先尝试从 session 缓存中读取,如果 session 缓存数据不存在或是脏数据并且配置了二级缓存,Hibernate 尝试从二级缓存中检索数据；否则<br />Hibernate 会根据对象类型·主键等信息组织select 语句到数据库中读取,再把select 结果组织成对象返回.

4) hibernate 如何进行数据库查询操作？

Hibernate 提供SQL、HQL、Criteria 查询方式.HQL 是其中运用最广泛的查询方式.用户使用 session.createQuery（）函数以一条 HQL 语句为参数创建 Query 查询对象后,Hibernate 会使用 Anltr 库把 HQL 语句解析成 jdbc 可以识别的 sql 语句.如果设置了查询缓存,那么执行Query.list（）时,Hibernate 会先对查询缓存进行查询,如果查询缓存不存在,再使用 select 语句查询数据库.

174、 cascade 属性和 inverse 属性的作用和区别？

1) Cascade 指的是关联对象之间的级联操作
2) Inverse 指的是关联关系的控制方向

175、 hibernate 中 get( )与 load( )区别**(重点)
**
请注意如果没有匹配的数据库记录,load( ) 方法可能抛出无法恢复的异常(unrecoverable exception). 如果类的映射使用了代理(proxy),load( )方法会返回一个未初始化的代理,直到你调用该代理的某方法时才会去访问数据库. 若你希望在某对象中创建一个指向另一个对象的关联,又不想在从数据库中装载该对象时同时装载相关联的那个对象, 那么这种操作方式就用得上的了. 如果为相应类映射关系设置了 batch-size, 那么使用这种操作方式允许多个对象被一批装载（因为返回的是代理,无需从数据库中抓取所有对象的数据）. 如果你不确定是否有匹配的行存在,应该使用 get( )方法,它会立刻访问数据库,如果没有对应的行,会返回 null.

176、 Hibernate 支持两种查询方式：

1) HQL(Hibernate Query Languge)查询：是一种面向对象的查询语言.（应用较为广泛）
2) Criteria 查询又称为“对象查询“：用面向对象的方式将构造查询的过程做了封装.

177、为什么使用 HQL 查询？

HQL 是一种面向对象的查询语言,支持属性查询、参数查询、关联查询、分页查询等特性,还支持统计函数.还有如下优点：
1) 使用 HQL 可以避免使用 JDBC 查询的一些弊端.
2) 不需要在编写繁复的 SQL 语句,我们将针对实体类及其属性进行查询.
3) 查询结果是直接存放到 List 中的对象,不需要再次封装.
4) HQL 还独立于数据库,对不同的数据库根据 Hibernate dialect 属性的配置自动生成不同的
SQL 语句执行

178、使用 HQL 步骤以及 HQL 优化(重点)

步骤
1) 得到 session
2) 编写 HQL 语句
3) 创建 Query 对象
4) 执行查询,得到结果优化:
1 避免 or 操作
2 避免使用 not
3 避免 like 的特殊形式
4 避免 having 子句
5 避免使用 distinct

179、 Spring 是什么？

Spring 是一个开源的控制反转（Inversion of Control,IoC）和面向切面（AOP）的容器框架.它的主要目的是使现有技术更加易用,推荐编码最佳实现,从而简化企业开发.
Spring 目前已经发展为一个功能丰富而易用的集成框架,其核心是一个完整的控制反转（IoC）的轻量级容器,用户可以使用他建立自己的应用程序.在容器上,Spring 提供了大量实用的服务.将很多高质量的开源项目集成到统一的框架上.
Spring 致力于 Java EE 应用的各种解决方案,而不是仅仅专注于某一层面的方案.可以说,Spring 是企业应用开发的“一站式”选择,Spring 贯穿表示层、业务层、持久层.然
而,Spring 并不想取代那些已有的框架,而以高度的开发性与他们无缝整合.

180、使用 Spring 的好处？(重点)

在我看来,在项目中引入Spring 可以带来以下的好处：

1) 降低组件之间的耦合度,实现软件各层之间的解耦合；
2) 可以使用容器提供的众多服务,如：事务管理服务,消息服务等等；
3) 容器提供单例模式支持,开发人员不再需要自己编写代码实现；
4) 容器提供了 AOP 技术,利用它很容易实现如权限拦截等功能；
5) 容器提供了众多辅助类,使用这些类能够加快应用的开发；
6) Spring 对于主流的应用框架提供了集成支持.

181、什么是依赖,什么是依赖注入？ (重点)

依赖：两个元素中一个定义发生改变则会引起另一个元素发生改变,则称这两个元素之间存在依赖关系.
控制反转(IoC)：在传统的程序设计过程中,都是在应用内部创建及维护依赖的对象. 控制反转就是应用本身不负责依赖对象的创建及维护,依赖对象的创建及维护是由外部容器负责的.这样控制权就由应用转移到外部容器,控制权的转移就是控制反转.
依赖注入：是指在运行期,由外部容器动态地将依赖对象注入到组件中.
依赖注入让 Bean 与Bean 之间以配置文件组织在一起,而不是以硬编码的方式耦合在一起.

182、 Spring 如何实现 IOC 容器功能(重点)

Spring 设计的核心是org.springframework.beans 包,它的设计目标是与JavaBean 组件一起使用.这个包通常不是由用户直接使用,而是由服务器将其作其他多数底层中介.下一个最高级抽象是 BeanFactory 接口,它是工厂设计模式的实现,允许通过名称创建和检索对
象.BeanFactory 也可以管理对象之间的关系.
BeanFactory 支持两种对象模型
1）单态模型提供了具有特定名的对象的共享实例,可以在查询时对其进行检索.Singleton 是默认的也是最常用的对象模型.对于无状态服务对象很理想.
2）原型模型确保每次检索都会创建单独的对象.在每个用户都需要自己的对象时,
原型模型最适合.
bean 工厂的概念是 Spring 作为 IOC 容器的基础.IOC 将处理事情的责任从应用程序转移到框架.Spring 框架使用 JavaBean 属性和配置数据来指定必须设置的依赖关系.

183、什么是 AOP(Aspect-oriented programming 面向切面编程) (重点)

面向方面编程也叫面向切面编程,即 AOP,是一种编程技术,它允许程序员对横切关注点或横切典型的职责分界线的行为（例如日志和事务管理）进行模块化.AOP 的核心构造是方

面,它将那些影响多个类的行为封装到可重用的模块中.
AOP 和 IOC 是补充性的技术,它们都是运用模块化方式解决企业应用程序开发中的复杂问题.在典型的面向对象的开发方式中,可能要将日志记录语句放在所有方法和 Java 类中才能实现日志功能.在AOP 方式中,,可以反过来将日志服务模块化,并以声明的方式将它们应用到需要的日志组件上.当然,优势就是 Java 类不需要知道日志服务的存在,也不需要知道日志服务的存在,也不需要考虑相关的代码.所以,用 Spring AOP 编写的应用程序代码是松散耦合的.
AOP 的功能完全集成到了 Spring 事务管理、日志和其他各种特性的上下文中.

184、 Spring AOP 原理(重点)

Spring 采用 JDK 动态代理模式来实现 AOP 机制.
Spring AOP 采用动态代理的过程：
(1) 将切面使用动态代理的方式动态织入到目标对象（被代理类）,形成一个代理对象；
(2) 目标对象如果没有实现代理接口,那么 Spring 会采用 CGLib 来生成代理对象, 该代理对象是目标对象的子类；
(3) 目标对象如果是 final 类,并且也没实现代理接口,就不能运用 AOP.

185、 AOP 核心概念

1、Aspect（切面）
切面,是对交叉业务逻辑的统称.
2、Joinpoint（连接点）
连接点,指切面可以织入到目标对象的位置（方法,属性等）.
3、Advice（通知）
通知,指切面的具体实现.
4、Pointcut（切入点）
切入点,指通知应用到哪些类的哪些方法或属性之上的规则.
5、Introduction（引入）
引入,指动态地给一个对象增加方法或属性的一种特殊的通知.
6、Weaving（织入）
织入,指将通知插入到目标对象.
7、Target（目标对象）
目标对象,指需要织入切面的对象.
8、Proxy（代理对象）
代理对象,指切面织入目标对象之后形成的对象.

186、 Spring 自动装配的优缺点(重点)

优点：
1) 自动装配能显著减少配置的数量.不过,采用 bean 模板（见这里）也可以达到同样的目的.
2) 自动装配可以使配置与 java 代码同步更新.例如,如果你需要给一个java 类增加一个依赖,那么该依赖将被自动实现而不需要修改配置.因此强烈推荐在开发过程中采用自动装配,而在系统趋于稳定的时候改为显式装配的方式.
缺点：
1) 尽管自动装配比显式装配更神奇,但是,正如上面所提到的,Spring 会尽量避免在装配不明确的时候进行猜测,因为装配不明确可能出现难以预料的结果,而且 Spring 所管理的对象之间的关联关系也不再能清晰的进行文档化.
2) 对于那些根据 Spring 配置文件生成文档的工具来说,自动装配将会使这些工具没法生成依赖信息.

187、 Spring 依赖检查机制

Spring 的依赖检查能够帮助检查在一个Bean 上的所有特定类型属性是否都已经设置依赖注入.只要在 dependency-check 的属性中指定依赖检查模式就可以了.
依赖检查的几种模式：
1） none：不执行任何依赖检查.任何属性都可以保持未设置状态,为默认；
2） simple：检查任意简单类型（原始（例如 int、double 等,还包括 String 类型）和集合类型）的属性是否设置,未设置将抛出UnsatisfiedDependencyexception 异常；
3） objects：检查任意对象类型属性是否设置,未设置将抛出
UnsatisfiedDependencyexception 异常；
4） all：检查任意类型的属性是否设置,未设置将抛出 UnsatisfiedDependencyexception 异常.

188、实际开发过程中为什么拆分 Spring 配置文件？

1）、当项目规模大的时候,配置文件可读性、可维护性差,庞大的 Spring 配置文件难以阅读.
2）、团队开发时,多人修改同一配置文件容易发生冲突,降低开发效率.

189、采用何种策略拆分 Spring 配置文件？

1）、如每个开发人员负责一模块采用公用配置（包含数据源、事务等）+每个系统模块一个单独配置文件（包含 dao、service 及 action）形式
2）、如采用分层负责或者 DAO 配置代码由代码生成工具生成时,我们采用公用配置（包含数据源、事务等）+ DAO Bean 配置 + 业务逻辑 Bean 配置 + Action Bean 配置形式

190、 Spring 对持久层的支持：(重点)

① JDBC,② O/R Mapping（Hibernate,TopLink 等）
Spring 对持久层支持采用的策略：
1、Spring 对持久层“不发明重复的轮子”,即没有重新实现新的持久层方案,对现有持久层方案做封装,更利于使用.
2、采用DAO 模式
3、提供了大量的模板类来简化编程（HibernateDaoSupport,JdbcTemplate 等）
4、重新设计了一套完善的异常体系结构
① 类型丰富,细化异常类型
② 全都是运行时异常（RuntimeException）

191、 Spring 的事务机制(重点)

Spring 支持声明式事务.声明式事务管理采用非侵入式的设计,可以分离业务逻辑和事务管理逻辑,具有良好的适应性.
Spring 使用事务服务代理和事务管理器（如 HibernateTransactionManager）来支持事务服务.
相对于 EJB 规范,Spring 对事务的边界多了一种嵌套事务（PROPAGATION_NESTED）.
PROPAGATION_NESTED 含义：
如果客户端启动了事务 T1,那么 Bean 启动一个嵌套在 T1 中的子事务T2；
如果客户端没有启动事务,那么 Bean 会启动一个新的事务,类似于 REQUIRED_NEW

192、什么是声明式事务.

用在 Spring 配置文件中声明式的处理事务来代替硬代码式的处理事务.这样的好处是,事务管理不侵入开发的组件,具体来说,业务逻辑对象就不会意识到正在事务管理之中,事实上也应该如此,因为事务管理是属于系统层面的服务,而不是业务逻辑的一部分,如果想要改变事
务管理策略的话,也只需要在定义文件（即配置文件）中重新配置即可;在不需要事务管理的时候,只要在设定文件上修改一下,即可移去事务管理服务,无需改变代码重新编译,这样维护起来极其方便.

193、 Spring 如何使用声明式事务管理 Hibernate 的事务

1）配置 Hibernate 的事务管理器.
2）定义事务通知,需要指定一个事务管理器
3）使用 AOP,定义哪些方法应用这些规则

194、 SpringMVC 工作机制？(重点)

1) spring mvc 请所有的请求都提交给DispatcherServlet,它会委托给应用系统的其他模块负责对请求进行真正的处理工作.

1) DispatcherServlet 查询一个或多个 HandleMapping,找到处理请求的Controller
2) DispatchServlet 请求提交到目标Controller
3) Controller 进行业务逻辑处理后,会返回一个 ModelAndView
4) Dispatcher 查询一个或多个 ViewResolver 视图解析器,找到 ModelAndView 对象指定的视图对象
5) 视图对象负责渲染返回给客户端.

195、什么是 POJO 类(重点)

使用 POJO 名称是为了不和 EJB 混淆起来, 而且简称比较直接. 其中有一些属性及其
getter setter 方法的类,有时可以作为value object 或 dto(Data Transform Object)来使用.当然, 如果你有一个简单的运算属性也是可以的,但不允许有业务方法,也不能携带有connection 之类的方法.

错误的认识：（了解一下错误的说法,主要是需要记住正确的说法）

   POJO 是这样的一种“纯粹的”JavaBean,在它里面除了 JavaBean 规范的方法和属性没有<br /> 别的东西,即 private 属性以及对这个属性方法的 public 的 get 和 set 方法.我们会发现这样的   JavaBean   很“单纯”,它只能装载数据,作为数据存储的载体,而不具有业务逻辑处理的能力.

真正的意思：（正确意义）

   POJO = “Plain Old Java Object”,是 MartinFowler 等发明的一个术语,用来表示 普通的<br /> Java 对象,不是JavaBean, EntityBean  或者 SessionBean.POJO 不但当任何特殊的角色,也不<br /> 实现任何特殊的 Java 框架的接口如,EJB, JDBC 等等.即 POJO 是一个简单的普通的 Java 对<br /> 象,它包含业务逻辑或持久逻辑等,但不是 JavaBean、EntityBean 等,不具有任何特殊角色和<br /> 不继承或不实现任何其它 Java 框架的类或接口.<br />

196、你熟悉的应用服务器有哪些？

BEA WebLogic Server,
IBM WebSphere Application Server, Oracle9i Application Server, jBoss,
Tomcat

197、什么是 Web 服务（web service）

Web 服务是一种可以用来解决跨网络应用集成问题的开发模式,是基于网络的、分布式的模块化组件,它执行特定的任务遵守具体的技术规范,这些规范使得Web Service 能与其他兼容的组件进行互操作.设计WEB 服务时应该把握的几个关键性原则：松散耦合、定义良好的接口、合适的粒度.web 服务体系结构的三种角色是：服务提供者、服务代理机构、服务使用者

198、 Web 服务的优点有哪些？(重点)

1) 封装性：
Web 服务是一种部署在Web 应用上的组件,具备良好的封装性.对使用者而言,仅看到服务描述,而该服务的具体实现、运行平台都是透明的,调用者无须关心,也无法关
心.Web 服务作为整体提供服务.

2) 松散耦合：

当Web 服务的实现方式发生改变时,调用者是无法感受到这种改变的.对调用者而言,只要服务实现的接口不发生变化,具体实现的改变时完全透明的.
使用标准协议：
Web 服务所有的公共协议都是用标准协议描述、传输和交换.这些标准协议在各种平台上完全相同.

3) 高度整合的能力：

由于Web 服务采用简单、易理解的标准Web 协议作为通信协议,完全屏蔽了不同平台的差异,无论是 CORBA、DOM 还是 EJB,都可以通过这种标准协议进行互操作,实现系统的最高可整合性.

4) 高度的开放性：

Web 服务可以与其他的 Web 服务进行交互,具有语言和平台型,支持 CORBA,EJB,DCOM
等多种组件标准,支持各种通讯协议,如 HTTP、SMTP 和 RMI 等.

199、 Java 领域中的主流框架有哪些？

MVC 框架：Struts1,、Struts2、SpringMVC
ORM 框架：Hibernate、TopLink、ibatis、MyBatis
Ajax 框架：DWR、JQuery
其它框架：Spring、Xfire、SSH（spring,hibernate,struts 三个框架的集成）
Hibernate:
是一个优秀的持久化框架,负责简化将对象数据保存到数据库中,或从数据库中读取数据并封装到对象的工作.
Struts2:
以 webwork 优秀的设计思想为核心,吸收了Struts1 框架的部分优点,提供了一个更加整洁的 MVC 设计模式实现的 Web 应用程序框架;它引入了几个新的框架特性:从逻辑中分离出横切关注点的拦截器,减少或者消除配置文件,贯穿整个框架的强大表达式语言,支持可变更和可重用的基于 MVC 模式的标签 API.
Spring:
Spring 的出现改变了 Java 世界,它的目标是使现有的 JavaEE 技术更容易使用和促进良好的编程习惯.它是一个轻量级的框架,渗透了 JavaEE 技术的方方面面,它主要作为依赖注入容器和 AOP 实现存在.还提供了声明式事务,对 DAO 层的支持等简化开发的功能.Spring 还可以很方便的与Struts2.hibernate 等框架集成.

200、如何实现自定义 MVC 框架？

MVC 是一种流行的软件设计模式,代表一种多层的应用程序实现方式,MVC 模式将应用程序实现分为三个不同的基本部分：模型层 M、视图层 V、控制器 C

自定义 MVC 的主要实现核心就是：定义一个 Servlet 来控制模型层 M 和视图层 V 的相互调用
实现思路：
例子：如果我们做一个登录请求 http://localhost:8080:projectName/login.action
1) 客户端向服务器发送这样的一个登录请求时,自定义MVC 框架的servlet 主控制器就会对请求的 url 进行解析得到客户端请求的 Action 名称：“login”
2) servlet 主控制器就根据解析得到的 Action 名称“login”,反射实例化对应的
LoginAction 业务控制器
3) LoginAction 在执行其execute 方法后返回对应的导航信息 result
4) Servlet 主控制器根据result 中的信息转发或重定向到对应的视图（JSP） 实现流程：
1) 编写对应的 XML 配置文件,文件名可以自定义,配置内容包括：
a) Action 的名称ActionName 和Action 类的全限定名ActionClassName
b) Action 对应的result 信息,包括是转发还是重定向和对应的视图组件（jsp）路径
2) 在 Web.xml 中配置主控制器（ActionServlet）,对应的拦截路径为*.action,并把配置文件的位置用初始化参数配置给 Servlet 主控制器
3) 初始化主控制器 Servlet,解析 MyMVC.xml 配置文件,把配置文件中的信息保存到
ActionMapping 对象中
4) 创建一个Action 接口,在 Action 接口中定义一个execute( )方法.让所有的Action 实现这个接口

201、 Struts 2 中如何解决中文乱码问题？(重点)

在配置文件中定义如下常量值配置：

<constant name=”struts.i18n.encoding” value=”UTF-8”/>

注意：只能解决 post 请求的乱码问题,针对 get 请求的乱码和 jsp 中的处理方式一致（需编写相应的代码处理）.

202、 Struts 2 配置文件中的 package 元素与 Java 中的包有什么异同之处？

答：相同点：都是基于方便管理的理念,Struts2 配置文件中的 package 为了更好的管理Action 配置项, 例如区分不同模块中定义的同名的Action 配置,Java 中的包用于更好的管理类,例如不同包中定义的同名的类
不同点：
1) package 是用于管理Action,而 Java 中的包用于管理 class 类；
2) package 可以被继承,减少 XML 中的冗余配置,而 Java 中的包没有继承的概念；

203、 Struts 2 开发 Action 有几种模式,Action 的作用是什么？(重点)

有三种模式：

1）实现 Action 接口
2）继承 ActionSupport 类
3）普通的 Java 类（体现 Struts2 的设计理念：表示 action 是非侵入设计,我的 Acton
不需要框架的支持,与框架减耦,可以脱离框架而存在（Struts2 的设计理念））

Action 的作用：

1）封装工作单元
2）数据转移的场所
3）返回相应视图结果的字符串

204、在 struts.xml 中可以不为 action 指定 class 属性吗？struts2 配置中有哪些默认的属性？

可以,如果没有为 action 指定 class,默认是 com.opensymphony.xwork2.ActionSupport

默认属性：
如果没有为 action 指定 class 属性,则默认值是
com.opensymphony.xwork2.ActionSupport
如果没有为 action 指定 method 属性,则默认值是 execute( )
注意：ActionSupport 的execute 方法里面就一句话return “success”;
如果没有指定 result 的 name 属性,则默认值是 success
如果没有指定 result 的 type 属性,则默认值是 dispatcher

action 中默认都有一个拦截器的引用,即：;
注意：
1）一旦我们为该包中的某个 action 显式指定了某个拦截器,则默认拦截器不会起作用,所以此时要显式的引进默认的拦截器；
2）每个包只能指定一个默认拦截器,每个默认拦截器只针对当前包下有效.

205、简要阐述 struts2 的执行流程. (重点)

Struts 2 框架本身大致可以分为 3 个部分：核心控制器 FilterDispatcher、业务控制器Action 和用户实现的企业业务逻辑组件.核心控制器 FilterDispatcher 是 Struts 2 框架的基础, 包含了框架内部的控制流程和处理机制.业务控制器Action 和业务逻辑组件是需要用户来自己实现的.用户在开发Action 和业务逻辑组件的同时,还需要编写相关的配置文件,供核心控制器FilterDispatcher 来使用. Struts 2 的工作流程相对于Struts 1 要简单,与WebWork 框架基本相同,所以说 Struts 2 是WebWork 的升级版本.
基本简要流程如下：
1、客户端浏览器发出 HTTP 请求.
2、根据 web.xml 配置,该请求被 FilterDispatcher 接收.

3、根据struts.xml 配置,找到需要调用的Action 类和方法, 并通过IoC 方式,将值注入给
Aciton.
4、Action 调用业务逻辑组件处理业务逻辑,这一步包含表单验证.
5、Action 执行完毕,根据 struts.xml 中的配置找到对应的返回结果result,并跳转到相应页面.
6、返回 HTTP 响应到客户端浏览器

206、 Struts 2 结构体系的运行原理（重点）

1) 由容器创建 HttpServlet 请求,这个请求经过一系列的过滤器,最终到 Struts 2 的核心过滤器（FilterDispatcher）；
2) 核心过滤器解析请求的 URL 获得一个ActionMapper 实例,如果不存在,就抛出请求路径无效异常；
3) 核心过滤器根据 ActionMapper 生成一个ActionProxy（Action 代理类）
4) ActionProxy 从配置管理 ConfigurationManager 获取struts.xml 的配置（struts.xml 中配置了每个 Action 所需通过的拦截器）
5) ActionProxy 根据 struts.xm 的配置生成一个 ActionIncocation（action 调度者）

6) ActionIncocation 就会以递归的方式顺序调用配置中的 Interceptor（拦截器）,
执行顺序（1、2、3）
7) ActionIncocation 调用完所有的拦截器后就进入我们的Action
8) Action 执行完后返回一个result
9) 使用result 的信息生成对应的 Template（模板）视图（jsp、FreeMarKey、Velocity等）

10) ActionIncocation 再次反向调用所有配置的 Intercepto（r
2、1）

拦截器）,执行顺序（3、

11) 执行完所有的 interceptor（拦截器）后就会生成 Http 响应信息
12) Http 响应信息再通过过滤器转给客户端

207、 Struts 2 核心接口和类

1) ActionMapper

ActionMapper 提供了在请求和 Action 调用请求之间的映射.ActionMapper 根据请求的
URI 来查找是否存在对应的 Action 调用请求,如果有则返回一个描述 Action 映射的
ActionMapping 对象；没有找到匹配的 Action 调用返回 null.

2) ActionMapping

ActionMapping 本质上是一个数据传输对象.它保存了调用Action 的映射信息,其中必须保存 Action 的命名空间的信息和 name 属性信息

3) ActionProxy

ActionProxy 在XWork 和真正的 Action 之间充当代理,在执行Action 的过程中,因为使用代理而非直接操纵对象,所以可以在 Action 执行前后执行额外的操作.
ActionProxy 创建了ActionInvocation 对象

4) ActionInvocation

ActionInvocation 表示Action 的执行状态,它保存拦截器（按配置顺序）,Action 的实例.ActionInvocation 是由ActionProxy 创建,通过调用 invoke( ) 方法开始 Action 的执行,执行的顺序为按配置顺序执行拦截器,拦截器执行完毕后执行Action,Action 执行结束返回结果字符串,匹配相应的 Result 后,再一次执行拦截器.

5) Inserceptor（拦截器）

拦截器是一种可以在请求处理前或者之后执行的Struts2 组件.拦截器是Struts2 的重要特性,Struts2 框架的绝大多数功能都是通过拦截器来完成的

208、说说对 Struts 2 拦截器的理解？(重点)

Struts2 拦截器是在访问某个 Action 或Action 的某个方法,字段之前或之后实施拦截,并且 Struts2 拦截器是可插拔的,拦截器是ＡＯＰ的一种实现.Struts2 拦截器栈就是将拦截器按一定的顺序联结成一条链.在访问被拦截的方法或字段时,Struts2 拦截器链中的拦截器就会按其之前定义的顺序被调用.
209、 拦截器工作原理

拦截器的工作原理:
Struts2 拦截器是一种 AOP 设计思想的体现,以链式执行,对真正要执行的方法(execute)进行拦截,首先按照 Action 配置的拦截器顺序依次执行相应的拦截器,调用完后再执行 Action 及 result 跳转,然后再次执行拦截器(与先前调用相反的顺序),在此链式的执行过程中,任何一个拦截器都可以直接返回,从而终止余下的拦截器或 Action 及reuslt 的执行.

210、 Struts2 内置的拦截器

1) Params 拦截器

Params 拦截器提供了框架必不可少的功能,将请求中的数据设置到Action 中的属性
上

2) staticParams 拦截器

staticParams 拦截器是将在配置文件中通过 action 元素的子元素 param 设置的参数设置到对应的Action 的属性中

3) servletConfig 拦截器

servletConfig 拦截器提供了一种将源于Servlet API 的各种对象注入到Action 当中的简洁方法.Action 必须实现对应的接口.servletConfig 拦截器才能将对应的Servlet 对象注入到 Action 中

4) fileUpdload 拦截器

fileUpload 拦截器将文件和元数据从多重请求（multipart/form-date）转换为常规的请求数据,以便能将他们设置在对应的 Action 属性上

5) validation 拦截器

validation 拦截器执行数据验证

6) workflow 拦截器

workflow 拦截器提供当数据验证错误时终止执行流程的功能

7) exception 拦截器

3) exception 拦截器捕获异常,并且能够根据类型将捕获的异常映射到用户自定义的错误页面.该拦截器应该位于所定义的所有拦截器的第一位.

211、 Struts2 自定义拦截器？(重点)

1) 实现接口 com.opensymphony.xwork2.interceptor.Interceptor.该接口提供了三个方法,如下所示：
Ø init( )：该拦截器被初始化之后,在该拦截器执行拦截之前,系统回调该方法,对于每个拦截器而言,此方法只执行一次.
Ø destroy( )：该方法跟 init( )方法对应.在拦截器实例被销毁之前,系统将回调该方法
Ø intercept(Actioninvocation invocation) throws Exception：该方法是用户需要实现的拦截动作.该方法会返回一个字符串作为逻辑视图
2) 继承 com.opensymphony.xwork2.interceptor.AbstractInterceptor 类是更简单的一种实现拦截器的方式,Abstractinterceptor 类提供了 init( )和 destroy( )方法的空实现, 这样,我们只要实现 intercept( )方法,就可以创建自己的拦截器

212、 struts2 如何防止用户表单重复提交？ **(重点)
**
第一步：在表单中加入
第二步,使用 token 栏截器,定义 invalid.token 结果集

213、 Struts 2 中如何创建自定义类型转换器

要创建自定义类型转换器类,需要编写一个类来继承Struts 2 提供一个自定义类型转换器基类,org.apache.struts2.util.StrutsTypeConverter.这是个抽象类,定义了两个抽象方法,用于不同的转换方向,分别为：
public Object convertFromString(Map context,String [] values,Class toType)：将一个或多个字符串值转换为指定的类型.
public String convertToString(Map context,Object object)：将指定对象转化为字符串.

214、 Struts2 国际化资源文件的范围

1) 全局资源文件
所有包的所有 Action 类都可以访问
导致资源文件变得非常庞大臃肿,不便于维护
2) 包范围资源文件
对应包下创建 package_language_country.properties
处于该包及子包下的 action 才可以访问该文件
3) Action 范围资源文件
命名格式 ActionClassName_language_country.properties
只有单个 Action 可以访问

215、 OGNL 和 EL 有什么异同？(重点)

相同点：OGNL 和EL 都是表达式语言,用来获取相应对象或其属性的值差异点：

1) 在获取集合中对象的方式不同：

EL 表达式是 jsp 规范的标准,可以直接在 jsp 页面上使用
OGNL 是 Strut2 框架用来解决视图输出内容而集成的技术,在页面上只能使用 Struts2 标签输出内容,不能直接使用
2) 是否可以调用方法：OGNL 可以直接调用对象中的方法,EL 表达式只能输出对象的属性（其实是调用对象提供的 getter 方法）
3) 取值的方式不同：EL 表达式使用${XXXX}方式取值
ONGL 取值的方式是:
如果是根元素：
如果非根元素:
还有就是：

216、 OGNL 中访问根元素和非根元素有什么区别？

区别：访问根对象,直接书写对象的属性,访问其他非根对象必须使用“#”前缀
Struts2 中集成的OGNL 可以直接访问Action 对象中的属性的原因是：Action 是ValueStack

的栈顶元素,ValueStack 是OGNL 的根元素,而ValueSatck 的栈顶元素（也就是 Action 对象）享有了其根元素的所有特性.

217、 OGNL 在 Struts 2 中的作用(重点)

1) 表达式语言
将表单或 Struts 2 标签与特定的Java 数据绑定起来,用来将数据移入、移出框架
2) 类型转换
数据进入和流出框架,页面中数据的字符串版本和 Java 数据类型之间都发生转换

218、值栈 ValueStack 的原理与生命周期？

1）ValueStack 贯穿整个 Action 的生命周期,保存在request 域中,所以 ValueStack 和
request 的生命周期一样.当 Struts2 接受一个请求时,会迅速创建 ActionContext,
ValueStack,action.然后把 action 存放进ValueStack,所以 action 的实例变量可以被
OGNL 访问. 请求来的时候,action、ValueStack 的生命开始,请求结束,action、
ValueStack 的生命结束；
2）action 是多例的,和 Servlet 不一样,Servelt 是单例的；
3）每个 action 的都有一个对应的值栈,值栈存放的数据类型是该 action 的实例,以及该
action 中的实例变量,Action 对象默认保存在栈顶；
4）ValueStack 本质上就是一个 ArrayList；
5）关于 ContextMap,Struts 会把下面这些映射压入 ContextMap 中：
parameters : 该 Map 中包含当前请求的请求参数
request : 该 Map 中包含当前 request 对象中的所有属性
session : 该 Map 中包含当前 session 对象中的所有属性
application : 该 Map 中包含当前 application 对象中的所有属性
attr : 该 Map 按如下顺序来检索某个属性: request, session, application

6）使用 OGNL 访问值栈的内容时,不需要#号,而访问request、session、application、attr
时,需要加#号；
7）注意： Struts2 中,OGNL 表达式需要配合 Struts 标签才可以使用.如：
8）在 struts2 配置文件中引用 ognl 表达式 ,引用值栈的值 ,此时使用的”$”,而不是#或者%;

219、权限管理怎么做的,用到了几张表? (重点)

权限管理这里我们用到了五张表,三张主表 user(用户表),role(角色表),privilege(权限表),两张

关系表,user-role,privilege-role, 关系表是为了解决 user 与 role、privilege 与 role 之间的多对多的关系,user 可以有若干个 role,role 可以给很多 user 使用,role 可以有若干个privilege,privilege 可以赋给很多role.

220、电商项目里 redis 用到了哪些地方? (重点)

1,redis 生成商品 ID.
2,页面查询条件的缓存,(好处:页面初始化数据快速加载,提升用户体验度)
3,redis 集群(为了承载更大的数据量和redis 服务器的稳定,我们使用的redis-Cluster 方案,采用了 6 台节点(服务器)进行同时使用.三台主机,三天客机,如果主机发生宕机(挂掉)的情况,那么客机直接戴特使用,主机恢复后,主机机会继续使用)
4,session 共享,(因为我们的项目服务器架构方案是集群,并且是通过Nginx 进行转发,所以我们的用户 session 需要使用redis 来进行共享,缓存 session 信息)
5,购物车在登录的情况下,用的是 redis 来存储购物车.非登录的情况下,使用的 cookie 来缓存购物车(cookie 保存时间一个月).

221、 freemarker 静态页面怎么做的,与 jsp 动态页面的区别? (重点)

因为商品详情页面访问量较大,为了节省网络资源,提高用户体验,因此我们使用 freeMarker
技术将商品详情页静态化
Freemarker 使用步骤:
1. 创建 Configuration 对象
Configuration configuration = new Configuration( ); 2.设置模版存放的目录
String templateUrl =
“F:/qnsport2017/parent/qnsport-console/src/main/webapp/WEB-I NF/template/“;
3. 加载模版目录和设置读取模版的编码方式
configuration.setDirectoryForTemplateLoading(new File(templateUrl)); configuration.setDefaultEncoding(“utf-8”);
4. 获取模版对象
Template template = configuration.getTemplate(“temp.html”); 5.创建数据
Map rootMap = new HashMap( );
rootMap.put(“name”, “hello freemaker”); 6.创建输出文件
Writer out = new FileWriter(“C:/freemaker/demo1.html”); 7.通过模版输出数据
template.process(rootMap, out); 8.关流
out.close( );
静态页面与 jsp 动态页面的区别:
静态页面就是把页面上所有东西都设定好,写死的,然后放上去,不管是谁在任何时候看到的页面内容都是一样的,一成不变（除非手动修改页面内容）.静态 html 页面文件,可以直接用本地的浏览器打开.
动态页面的内容一般都是依靠服务器端的程序来生成的,不同人,不同时候访问页面,显示的

内容都可能不同.网页设计者在写好服务器端的页面程序后,不需要手工控制,页面内容会按照页面程序的安排自动更改变换.

222、讲讲购物车的设计方案. (重点)

企业级购物车设计方案,面向对象的设计模型,购物车包含购物项,购物项包含最小销售单元
sku(sku=颜色*尺码),在非登录的情况下我们购物车是存储在 cookie 里,保存时间为一个月,在登录的情况下,使用redis 来存储购物车,使用redis 的 list 来存储购物车,hash 来存储购物项.

223、 FastDFS 如何搭建的?怎么用的? (重点)

搭建:
1,配置基本环境2,安装Tracker 服务3,配置Tracker 服务4,安装storage 服务5,配置storage
服务,6 测试.
参考网址:详细的安装步骤以及 jar 网址: http://www.linuxidc.com/Linux/2016-04/130371.htm 使用:
1,先启动 fastDFS(代码 . fastDFS.sh)
2,查看 FastDFS 文件系统的服务
3, 查看 trackerd 进程是否启动成功,trackerd 进程是保存图片的存储路径( 代码 ps aux|grep trackerd)
4,查看 storaged 进程是否启动成功,storaged 进程是用来保存图,以及图片的副本.(代码
ps aux|grep storage)

224、 ArrayList,HashMap,HashSet 初始化容量为多少?如果超出自己扩容多少?

ArrayList 初始化容量为:10,如果超出,扩容为原容量的 0.5 倍+1,第一次扩容为 16
HashMap 初始化容量为:16,如果超出,扩容为原容量的 1 倍,第一次扩容为 32
HashSet 初始化容量为: 16,如果超出,扩容为原容量的 1 倍,第一次扩容为 32

225、说说 redis 的五种数据类型(重点)

List(列表),Hash(哈希),String(字符串),Set(集合),Zset(sorted set,有序集合)在项目中,我们前三者用的相对较多.

226、 Solr 在项目里用到了哪些地方? (重点)

1,因为电商网站的检索,我们不可能去用一个 like 模糊查询,我们使用的 solr 用来缓存商品上架数据.
2,使用了第三方的 IK 分词器进行分词,配置扩展字典和停词字典.
3,对查询的条件进行高亮显示.
4,为了维护项目的稳定性,以及提供更好的服务能力,我们这里 solr 使用的是集群方案,并且在solr 集群方案下我们使用的是大数据的zookeeper 框架来作为服务器中间件,对solr 服务器进行监听,给客户端提供服务.
追问:那你跟我说说zookeeper
因为 solr 集群依赖的是 zookeeper 服务中间件,所以就算宕机,也不会影响我们整个服务的使用,然后 zookeeper 也是使用的集群方案.三台机器进行的集群,根据 zookeeper 集群的特点,一

台 leader,两台 follower.

227、电商项目高并发这块,你们怎么做的? (重点)

在高并发处理这方面,我们使用的是 Nginx 服务器来做负载均衡和反向代理.并且 Nginx 我们也是搭建的两台服务器,并且使用 keepalived 来维护Nginx 的高可用(HA 机制)

228、使用过 log4j 吗?log4j 中有哪些优先级?

使用过.
1.static Level DEBUG :
DEBUG Level 指出细粒度信息事件对调试应用程序是非常有帮助的. 2.static Level INFO
INFO level 表明消息在粗粒度级别上突出强调应用程序的运行过程. 3.static Level WARN
WARN level 表明会出现潜在错误的情形. 4.static Level ERROR
ERROR level 指出虽然发生错误事件,但仍然不影响系统的继续运行. 5.static Level FATAL
FATAL level 指出每个严重的错误事件将会导致应用程序的退出.

另外,还有两个可用的特别的日志记录级别:
1.static Level ALL
ALL Level 是最低等级的,用于打开所有日志记录. 2.static Level OFF
OFF Level 是最高等级的,用于关闭所有日志记录.

日志记录器（Logger）的行为是分等级的：
分为 OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL 或者自定义的级别.
一般我们只使用这四种,优先级从高到低分别是 ERROR、WARN、INFO、DEBUG.

229、实现多线程的方法? (重点)

第一种是继承 Thread 类,实现 run( )方法,不可以抛异常,没有返回值第二种是实现Runnable 接口,实现 run( )方法,不可以抛异常,无返回值代码
(1) 继承 Thread 类,重写run 函数创建：
class xx extends Thread{ public void run( ){
Thread.sleep(1000) //线程休眠1000 毫秒,sleep 使线程进入Block 状态,并释放资
源
}}
开启线程：

对象.start( ) //启动线程,run 函数运行
(2) 实现 Runnable 接口,重写 run 函数开启线程：
Thread t = new Thread(对象) //创建线程对象t.start( )
(3) 实现 Callable 接口,重写 call 函数
Callable 是类似于 Runnable 的接口,实现 Callable 接口的类和实现 Runnable 的类都是可被其它线程执行的任务.
Callable 和Runnable 有几点不同:
①Callable 规定的方法是 call( ),而 Runnable 规定的方法是run( ).
②Callable 的任务执行后可返回值,而Runnable 的任务是不能返回值的
③call( )方法可抛出异常,而run( )方法是不能抛出异常的.
④运行 Callable 任务可拿到一个 Future 对象,Future 表示异步计算的结果,它提供了检查计算是否完成的方法,以等
待计算的完成,并检索计算的结果.通过 Future 对象可了解任务执行情况,可取消任务的执行,还可获取任务执行的结果

230、手写 MySQL,Oracle 分页(重点)

MySQL:
常用分页:select from content order by id desc limit 0,10;
Limit 是 MySQL 中特有的分页语法举例:
Select from tableName limit 5; //返回前五行
Select from tableName limit 0,5;//同样也是返回前五行Select from tableName limit 5,10;//返回 6-15 行

Oracle:
—分页查询一
select from (select a1.,rownum rn from (select from student) a1 where rownum <=5) where rn>=2;
—分页查询二
select a1. from (select student.,rownum rn from student where rownum <=5) a1 where rn >=3;
—分页查询三
select a1. from (select student.*,rownum rn from student) a1 where rn between 3 and 5;

231、手写一个单例(重点)

1,枚举写法
public enum Singleton { INSTANCE;
public void whateverMethod( ) {
}

}
2,懒汉(线程不安全) public class Singleton {
private static Singleton instance; private Singleton ( ){}

public static Singleton getInstance( ) { if (instance == null) {
instance = new Singleton( );
}
return instance;
}
}
3,懒汉(线程安全) public class Singleton {
private static Singleton instance; private Singleton ( ){}
public static synchronized Singleton getInstance( ) { if (instance == null) {
instance = new Singleton( );
}
return instance;
}
}
当然,还几种方式(共七种),谷歌搜索都可.

232、 Spring 与 SpringMVC 的区别(重点)

springmvc 只是 spring 其中的一部分.
spring 可以支持 hibernate ,mybatis ,JDBC
支持事务管理, 注解功能,表达式语言,测试
springmvc 就是一个简单的 web 框架,可以代替 SSH 框架. springmvc 比 struts2 性能优一些.

233、将 Map 转换为 List

Map map = new HashMap( ); map.put(“A”, “ABC”);
map.put(“K”, “KK”);
map.put(“L”, “LV”);

// 将 Map Key 转化为 List
List mapKeyList = new ArrayList(map.keySet( )); System.out.println(“mapKeyList:”+mapKeyList);

// 将 Map Key 转化为 List

List mapValuesList = new ArrayList(map.values( )); System.out.println(“mapValuesList:”+mapValuesList);

234、拦截器和过滤器的区别(重点)

1,拦截器是基于 java 的反射机制的,而过滤器是基于函数回调.
2,拦截器不依赖与servlet 容器,过滤器依赖与 servlet 容器.
3,拦截器只能对 action 请求起作用,而过滤器则可以对几乎所有的请求起作用.
4,拦截器可以访问 action 上下文、值栈里的对象,而过滤器不能访问.
5,在 action 的生命周期中,拦截器可以多次被调用,而过滤器只能在容器初始化时被调用一次

235、请讲下堆与栈. (重点)

定义变量赋值赋值,以及随着方法的调用(参数为基本数据类型),会在栈中内存中开辟空间,栈中也会有相应的数据,但是方法调用结束后,会有弹栈的效果,若方法参数为引用数据类型,会在栈中有数据,随着方法调用结束,也会有弹栈的效果,同时在堆中也会有数据.
追问:那么堆中内存什么时候释放?
1,手动设置 null
2,变量的生命周期结束,有GC 回收(GC 指的就是垃圾回收)
变量的生命周期: 就是一个变量在程序执行过程中的“有效期”,比如说全局变量,那它在整个程序执行过程中都有效,及它的生命周期是整个程序执行过程,而对于一些在函数里定义的局部变量,它只是在调用函数是有效,函数调用结束,它的生命周期也完了

236、如何判断 List 集合是否为空? (重点)

if(null == list || list.size( ) ==0 ){
//为空的情况
}else{
//不为空的情况
}

237、 list.isEmpty( )和 list.size( )==0 有什么区别? (重点)

没有区别,isEmpty( )判断有没有元素,而size( )返回有几个元素,如果判断一个集合有无元素,建议用 isEmpty( )方法比较符合.

238、 list !=null 与 ! list.isEmpty( )有什么区别? (重点)

这就相当与,你要要到商店买东西
list！=null 首先判断是否有商店
！list.isEmpty( ) 没有判断商店是否存在,而是判断商店是否有东西总结用法：如果连商店都没有,何来的的东西可卖
所以一般的判断是
if(list!=null && !list.isEmpty( )){
//不为空的情况
}else{

  //为空的情况<br />}<br /> <br />

239、怎么给 tomcat 增加内存? (重点)

在 bin/catalina.bat（windows 系统 tomcat）或者 bin/catalina.sh（Linux 系统 tomcat）中设置变量,示例如下：
JAVA_OPTS=”-server -XX:PermSize=64M -XX:MaxPermSize=128m -Xms800m -Xmx800m
-XX:MaxNewSize=256m”
Xms 是最小内存,Xmx 是最大内存,

240、 JDBC,Mybatis,Hibernate 的区别是什么? (重点)

1）从层次上看,JDBC 是较底层的持久层操作方式,而 Hibernate 和 MyBatis 都是在 JDBC
的基础上进行了封装使其更加方便程序员对持久层的操作.
2）从功能上看,JDBC 就是简单的建立数据库连接,然后创建 statement,将 sql 语句传给statement 去执行,如果是有返回结果的查询语句,会将查询结果放到 ResultSet 对象中,通过对ResultSet 对象的遍历操作来获取数据；Hibernate 是将数据库中的数据表映射为持久层的Java对象,对 sql 语句进行修改和优化比较困难；MyBatis 是将 sql 语句中的输入参数和输出参数映射为 java 对象,sql 修改和优化比较方便.
3）从使用上看,如果进行底层编程,而且对性能要求极高的话,应该采用 JDBC 的方式；如果要对数据库进行完整性控制的话建议使用 Hibernate；如果要灵活使用 sql 语句的话建议采用 MyBatis 框架.

241、什么时候用 Hibernate,Mybatis(重点)

Hibernate 作为留下的 Java orm 框架,它确实编程简易,需要我们提供映射的规则,完全可以通过 IDE 生成,同时无需编写 sql 确实开发效率优于 Mybatis.此外 Hibernate 还提供了缓存, 日志,级联等强大的功能,但是 Hibernate 的缺陷也是十分明显,多表关联复杂 sql,数据系统权限限制,根据条件变化的 sql,存储过程等场景使用 Hibernate 十分不方便,而性能又难以通过
sql 优化,所以注定了 Hibernate 只适用于在场景不太复杂,要求性能不太苛刻的时候使用.
如果你需要一个灵活的,可以动态生成映射关系的框架,那么Mybatis 确实是一个最好的选择.它几乎可以替代 jdbc,拥有动态列,动态表名,存储过程支持,同时提供了简易的缓存,日志,级联.但是它的缺陷是需要你提供映射规则和 sql,所以开发工作量比 hibernate 要大些.

242、 Struts2 与 SpringMVC 的区别? (重点)

1 机制不同
springmvc 的入口是 servlet,struts2 的入口是 filter,导致了二者的机制不同；
2 性能不同
spring 会稍微比struts 快.spring mvc 是基于方法的设计,而sturts 是基于类,每次发一次请求都会实例一个 action,每个 action 都会被注入属性,而spring 基于方法,粒度更细,但要小心把握像在servlet 控制数据一样.spring mvc 是方法级别的拦截,拦截到方法后根据参数上的注解,把 request 数据注入进去,在 spring mvc 中,一个方法对应一个 request 上下文.而 struts2

框架是类级别的拦截,每次来了请求就创建一个 Action,然后调用 setter getter 方法把 request 中的数据注入；struts2 实际上是通过setter getter 方法与 request 打交道的；struts2 中,一个Action 对象对应一个request 上下文.
Struts2 处理请求是为每个请求都创建一个单独的Action 类,Action 类当中的Field 属性参数作为输入和输出参数用 IOC 来依赖注入的方式,是基于类的,入口是 filter.
而SpringMVC 则采用输入Request 和Reponse 作为参数,返回ModelAndView 的方式,是单例的模式,且是基于方法的模式,入口是 servlet,速度比 struts2 快.

243、集合的三种遍历方式

/
迭代器遍历集合
迭代器 Iterator 是一个接口

作用是绑定集合迭代集合中的元素.
特殊之处：在迭代期间可以移除迭代器指向的集合的元素
boolean hasNext( )
检查集合列表中是否还有元素未进行遍历,检查的方式从第一个依次向后检
查
Object next( )
获得当前遍历到的元素
void remove( )
从迭代器指向的 collection 中移除迭代器遍历到的当前元素.

[注意：如果使用迭代器遍历集合元素,迭代器必须依附于集合.
简单而言：有一个迭代器对象,就必须有一个与之关联的集合对象
]

[注意：在迭代期间集合本身不能操作移除功能]

/

import java.util.*;

class IteratorDemo
{
public static void main(String[] args)
{
//System.out.println(“Hello World!”);

Collection c = new ArrayList( ); c.add(“蜡笔小新”);
c.add(5);

c.add(“淘气”);

// 将集合与迭代器绑定[] Iterator ite = c.iterator( );

while(ite.hasNext( )){

// 获取集合中的元素
Object obj = ite.next( ); System.out.println(obj);
// 移除迭代器指向的集合中的元素
ite.remove( );

//c.remove(“淘气”);
/
ConcurrentModificationException 并发修改异常
/
}
System.out.println(c);

}
}
foreach
/
增强 for 循环进行遍历

[集合修改本身元素]
/

import java.util.*; class ForeachDemo
{
public static void main(String[] args)
{
//System.out.println(“Hello World!”);

Collection c = new ArrayList( ); c.add(“路飞”);
c.add(“娜美”);
c.add(“ 鸣人 “); for(Object obj : c){

// c.remove(“鸣人”);// ConcurrentModificationException System.out.println(obj);
}
}
}
for
/
普通 for 循环
注意：需要获得脚标需要将集合转化为数组
/
import java.util.*; class ForDemo
{
public static void main(String[] args)
{
//System.out.println(“Hello World!”); Collection c = new ArrayList( );
c.add(“貂蝉”);
c.add(“西施”);
c.add(“王昭君”);
c.add(“杨玉环”);

// 将集合转换为数组
Object[] arr = c.toArray( );

for(int i = 0; i < arr.length; i++){ c.remove(“ 王昭君 “); System.out.println(arr[i]);
}
}
}

244、 SpringMVC 的运行原理(重点)

1. 客户端请求提交到 DispatcherServlet
2. 由 DispatcherServlet 控制器查询一个或多个 HandlerMapping, 找到处理请求的
Controller
3. DispatcherServlet 将请求提交到 Controller
4. Controller 调用业务逻辑处理后,返回 ModelAndView
5. DispatcherServlet 查询一个或多个ViewResoler 视图解析器,找到ModelAndView 指定的视图
6. 视图负责将结果显示到客户端

245、你觉得 Redis 有哪些优点?有哪些缺点? (重点)

优点:
1 读写性能优异
2 支持数据持久化,支持 AOF 和 RDB 两种持久化方式
3 支持主从复制,主机会自动将数据同步到从机,可以进行读写分离.
4 数据结构丰富：除了支持 string 类型的 value 外还支持 string、hash、set、sortedset、list 等数据结构.

缺点:
1 Redis 不具备自动容错和恢复功能,主机从机的宕机都会导致前端部分读写请求失败,需要等待机器重启或者手动切换前端的 IP 才能恢复.
2 主机宕机,宕机前有部分数据未能及时同步到从机,切换 IP 后还会引入数据不一致的问题,降低了系统的可用性.
3 redis 的主从复制采用全量复制,复制过程中主机会 fork 出一个子进程对内存做一份快照,并将子进程的内存快照保存为文件发送给从机,这一过程需要确保主机有足够多的空余内存.若快照文件较大,对集群的服务能力会产生较大的影响,而且复制过程是在从机新加入集群或者从机和主机网络断开重连时都会进行,也就是网络波动都会造成主机和从机间的一次全量的数据复制,这对实际的系统运营造成了不小的麻烦.
4 Redis 较难支持在线扩容,在集群容量达到上限时在线扩容会变得很复杂.为避免这一问题,运维人员在系统上线时必须确保有足够的空间,这对资源造成了很大的浪费.

246、 Mybatis 如何处理结果集

通过获取到所有的返回的列名字,反射获取目标对象中这个名字对应的属性,调用 set 方法,进行赋值

247、内存溢出这块怎么解决? (重点)

原因分析
1. 内存中加载的数据量过于庞大,如一次从数据库取出过多数据；

解决思路：
第一步,修改 JVM 启动参数,直接增加内存.(-Xms,-Xmx 参数一定不要忘记加.) 第二步,检查错误日志,查看“OutOfMemory”错误前是否有其它异常或错误. 第三步,对代码进行走查和分析,找出可能发生内存溢出的位置.
使用工具：
常用的有 BoundsCheaker、Deleaker、Visual Leak Detector 等

248、 Mybatis 的缓存(重点)

映射语句文件中的所有 select 语句将会被缓存.
映射语句文件中的所有 insert,update 和 delete 语句会刷新缓存. 缓存会使用 Least Recently Used(LRU,最近最少使用的)算法来收回.
根据时间表(比如 no Flush Interval,没有刷新间隔), 缓存不会以任何时间顺序来刷新.

缓存会存储列表集合或对象(无论查询方法返回什么)的 1024 个引用.
缓存会被视为是 read/write(可读/可写)的缓存,意味着对象检索不是共享的,而且可以安全地被调用者修改,而不干扰其他调用者或线程所做的潜在修改.
所有的这些属性都可以通过缓存元素的属性来修改.

249、线程池有哪些优点? (重点)

1 可以降低资源的消耗,通过重复使用已经创建的线程,可以降低创建线程和销毁线程带来的消耗；
2 提高响应速度,当任务到达时,不需要等待线程创建就能立即执行；
3 提高线程的可管理性,线程是稀缺资源,如果无限制的创建和销毁,不光会带来资源的消耗,还会降低系统的稳定性,通过线程池,可以对线程进行统一的分配,调优和监控.

250、电商项目里文件上传怎么做的? (重点)

我们文件上传使用的是异步上传,这里在前台用到 jQuery.form.js 这个框架来做图片的异步提交,在后台我们使用的是 springmvc,首先需要配置文件上传解析(支
持),MultParFile 必须跟文件上传项的 name 对应,然后获得图片名称,和扩展名调用封装
fastDFS 工具把图片上传到fastDFS.并且返回图片在服务器上面的路径,然后创建 json 对象添加图片路径,然后再把 json 回写到客户端,在前端的回调函数里面接受到后台传递过来的 json 数据,然后找到 img 标签,添加src 属性.(然后把文件上传到了本地,获取本地的服务器据对路径,然后再把图片上传到本地服务器)

251、电商项目里 zookeeper 是什么? (重点)

zookeeper 是在 Hadoop 大数据领域的服务中间件,它的第一个作用是存储数据(少量的),第二个作用是对客户端提供监听.

252、 Ajax 的应用场景有哪些? (重点)

1. 表单驱动的交互
2. 深层次的树的导航
3. 快速的用户与用户间的交流响应
4. 类似投票、yes/no 等无关痛痒的场景
5. 对数据进行过滤和操纵相关数据的场景
6. 普通的文本输入提示和自动完成的场景

253、 Ajax 的工作原理(重点)

Ajax 的工作原理相当于在用户和服务器之间加了—个中间层,使用户操作与服务器响应异步化.并不是所有的用户请求都提交给服务器,像—些数据验证和数据处理等都交给Ajax 引擎自己来做, 只有确定需要从服务器读取新数据时再由 Ajax 引擎代为向服务器提交请求.
Ajax 其核心只有JavaScript、XMLHTTPRequest 和 DOM,在旧的交互方式中,由用户触发一个HTTP 请求到服务器,服务器对其进行处理后再返回一个新的HTHL 页到客户端, 每当服务器处理客户端提交的请求时,客户都只能空闲等待,并且哪怕只是一次很小的交互、只需从服务器端得到很简单的一个数据,都要返回一个完整的 HTML 页,而用户每次都要浪费时间和带宽

去重新读取整个页面.而使用 Ajax 后用户从感觉上几乎所有的操作都会很快响应没有页面重载（白屏）的等待

254、简要阐述 Ajax 的实现步骤(重点)

get 请求
1 创建一个XMLHttpRequest 对象
2 调用该对象的open 方法
3 如果是 get 请求,设置回调函数 onreadystatechange = callback 4 Send
如果是 post 请求
1 创建一个XMLHttpRequest 对象
2 调用该对象的open 方法
3 调用 setRequestHeader(“Content-Type”, “application/x-www-form-urlencoded”);
4 设置回调函数onreadystatechange = callback 5 Send

255、 Redis 与 mysql 的区别? (重点)

mysql 是持久化存储,存放在磁盘里面,检索的话,会涉及到一定的 IO,为了解决这个瓶颈,于是出现了缓存
Mysql 是一个中小型的网络数据库,比oracle 和sqlserver 小, 但是并发能力远超过桌面数据库. redis 是一个支持网络、可基于内存亦可持久化的日志型、Key-Value 数据库.
可以认为redis 比 mysql 简化很多.
mysql 支持集群.
现在大量的软件使用redis 作为mysql 在本地的数据库缓存,然后再适当的时候和mysql 同步.

256、为什么使用 redis 来生成商品 ID?(重点)

使得主键 id 字段能够持续自增、在高并发的场景下,id 值不重复, redis 本身单线程，不会出现并发问题.

257、 Mybatis 中#与$的区别? (重点)

#{}表示一个占位符号,通过#{}可以实现 preparedStatement 向占位符中设置值,自动进行 java 类型和 jdbc 类型转换,#{}可以有效防止 sql 注入. #{}可以接收简单类型值或 pojo 属性值. 如果parameterType 传输单个简单类型值,#{}括号中可以是 value 或其它名称.

${}表示拼接sql 串,通过${}可以将 parameterType 传入的内容拼接在sql 中且不进行 jdbc 类型转换, ${}可以接收简单类型值或 pojo 属性值,如果 parameterType 传输单个简单类型值,${}括号中只能是value

258、怎么防止表单重复提交(重点)

1>用 JavaScript 控制 Form 表单只能提交一次
var isCommitted = false;//表单是否已经提交标识,默认为 false function dosubmit( ){
if(isCommitted==false){
isCommitted = true;//提交表单后,将表单是否已经提交标识设置为 true return true;//返回 true 让表单正常提交
}else{
return false;//返回 false 那么表单将不提交 } 2>利用 Session 防止表单重复提交
具体的做法：在服务器端生成一个唯一的随机标识号,专业术语称为 Token(令牌),同时在当前用户的Session 域中保存这个Token.然后将Token 发送到客户端的Form 表单中,在Form 表单中使用隐藏域来存储这个 Token,表单提交的时候连同这个 Token 一起提交到服务器端,然后在服务器端判断客户端提交上来的 Token 与服务器端生成的 Token 是否一致,如果不一致,那就是重复提交了,此时服务器端就可以不处理重复提交的表单.如果相同则处理表单提交,处理完后清除当前用户的 Session 域中存储的标识号.
在下列情况下,服务器程序将拒绝处理用户提交的表单请求：
存储 Session 域中的Token(令牌)与表单提交的 Token(令牌)不同.
当前用户的 Session 中不存在 Token(令牌).
用户提交的表单数据中没有 Token(令牌)

259、 @Controller 和@Service 的区别,控制器上能写@Service 吗?

Controller 是控制器,负责业务的调用
Service 是业务层逻辑层,负责具体业务的功能处理控制器上不能写@Service

260、 Java 中交互方式同步与异步是什么?区别是什么? (重点)

同步交互：指发送一个请求,需要等待返回,然后才能够发送下一个请求,有个等待过程；异步交互：指发送一个请求,不需要等待返回,随时可以再发送下一个请求,即不需要等待.
区别：一个需要等待,一个不需要等待,在部分情况下,我们的项目开发中都会优先选择不需要等待的异步交互方式.

261、 Freemarker 生成商品静态页之后,如果商品的数据需要修改怎么办? (重点)

Freemarker 根本不支持Java 脚本代码,而是使用el 表达式来展示数据.FreeMarker 的设计初衷就是：模板 + 数据模型 = 输出,模板只负责在页面中展示,不涉及任何逻辑代码,而所有的逻辑都是由数据模型来处理
我们在每一次点击上架就会生成一次新的静态页面来替换原来的静态页面

262、 JDK1.7 与 JDK1.8 的区别?

结合回答方式总结:
（扣扣索索）企业软件一般不会在太新的 JRE 上运行,所以我没有很深入了解 JDK8.

（自信的说）不过我知道,JDK8 支持 Lambda 表达式.这说明 JDK8 开始支持函数式编程.
（看考官不满意）以后很多地方不用匿名内部类这种形式了,简单了很多（罗利啰嗦一大堆）
（考官提示,interface 的 default 你怎么看？）
（恍然大悟状）啊,对对对
（赶紧补充）接口可以有默认实现之后,我认为有几个好处.
1. 实现可以继承了,这样就减少了很多无谓的继承,可以简单的进行组合.
2. 类库设计方便了,接口以后可以安全的扩展了

263、聚合函数有哪些? (重点)

AVG( ) 返回某列的平均值COUNT( ) 返回某列的行数MAX( ) 返回某列的最大值MIN( ) 返回某列的最小值SUM( ) 返回某个列之和

264、 JUnit4 中@AfterClass@BeforClass@after@before 的区别对比(重点)

@Before：初始化方法对于每一个测试方法都要执行一次（注意与 BeforeClass 区别,后者是对于所有方法执行一次）
@After：释放资源对于每一个测试方法都要执行一次（注意与 AfterClass 区别,后者是对于所有方法执行一次）
@Test：测试方法,在这里可以测试期望异常和超时时间
@Test(expected=ArithmeticException.class)检查被测方法是否抛出 ArithmeticException 异常
@Ignore：忽略的测试方法
@BeforeClass：针对所有测试,只执行一次,且必须为 static void @AfterClass：针对所有测试,只执行一次,且必须为 static void 一个 JUnit4 的单元测试用例执行顺序为：
@BeforeClass -> @Before -> @Test -> @After -> @AfterClass;
每一个测试方法的调用顺序为：
@Before -> @Test -> @After;

265、悲观锁乐观锁的区别? (重点)

悲观锁(Pessimistic Lock), 顾名思义,就是很悲观,每次去拿数据的时候都认为别人会修改,所以每次在拿数据的时候都会上锁,这样别人想拿这个数据就会 block 直到它拿到锁.传统的关系型数据库里边就用到了很多这种锁机制,比如行锁,表锁等,读锁,写锁等,都是在做操作之前先上锁.

乐观锁(Optimistic Lock), 顾名思义,就是很乐观,每次去拿数据的时候都认为别人不会修改,所以不会上锁,但是在更新的时候会判断一下在此期间别人有没有去更新这个数据,可以使用版本号等机制.乐观锁适用于多读的应用类型,这样可以提高吞吐量,像数据库如果提供类似于write_condition 机制的其实都是提供的乐观锁.

两种锁各有优缺点,不可认为一种好于另一种,像乐观锁适用于写比较少的情况下,即冲突真的很少发生的时候,这样可以省去了锁的开销,加大了系统的整个吞吐量.但如果经常产生冲突,上层应用会不断的进行retry,这样反倒是降低了性能,所以这种情况下用悲观锁就比较合适.

266、项目为什么使用垂直应用架构?

我们的项目对性能的要求很高,使用的是垂直应用架构,项目分为前台和后台,consolr 是我们的后台,partal 是我们的前台,前台后台共用我们的service 和 dao.(core 工程)

项目架构方案,在以前开发项目的时候是 all in one 传统的项目都是在 ORM 完成所有的业务逻辑,但是我们为了增加项目的性能和提高运行速度,这个时候我们只有去增加它的服务器节点,如果你的节点增加的越多,那么这个时候增加的节点所带来的项目加速是越小的,所以呢,我们的项目是使用的垂直应用架构,这个就解决了传统架构方案的缺点,这样一来,节点越多,我们的效果越好.

267、说说你对springboot的理解（什么是springboot）

用来简化spring应用的初始搭建以及开发过程使用特定的方式来进行配置（properties或yml文件）
创建独立的spring引用程序 main方法运行
内嵌web服务器，如tomcat，jetty等。
简化maven配置，只需要继承工程
自动配置spring添加对应功能starter自动化配置

268、 Spring Boot 的核心配置文件有哪几个？它们的区别是什么？

Spring Boot 的核心配置文件是 application 和 bootstrap 配置文件。
application 配置文件这个容易了解，主要用于 Spring Boot 项目的自动化配置。
bootstrap 配置文件有以下几个应用场景。
使用 Spring Cloud Config 配置中心时，这时需要在 bootstrap 配置文件中增加连接到配置中心的配置属性来加载外部配置中心的配置信息；
少量固定的不能被覆盖的属性；
少量加密/解密的场景。

269、 Spring Boot 的配置文件有哪几种格式？它们有什么区别？

properties 和 yml，它们的区别主要是书写格式不同，前者是键值对，后者是靠缩进的方式来决定层级关系的，另外yml 格式不支持@PropertySource注解导入配置。

270、 Spring Boot 的核心注解是哪个？它主要由哪几个注解组成的？

启动类上面的注解是@SpringBootApplication，它也是 Spring Boot 的核心注解，主要组合包含了以下 3 个注解：
@SpringBootConfiguration：组合了 @Configuration 注解，实现配置文件的功能。
@EnableAutoConfiguration：打开自动配置的功能，也可以关闭某个自动配置的选项，如关闭数据源自动配置功能： @SpringBootApplication(exclude = { DataSourceAutoConfiguration.class })。
@ComponentScan：Spring组件扫描。

271、你如何了解 Spring Boot 中的 Starters？

Starters可以了解为启动器，它包含了一系列可以集成到应用里面的依赖包，你可以一站式集成 Spring 及其余技术，而不需要四处找示例代码和依赖包。如你想使用 Spring JPA 访问数据库，只需加入 spring-boot-starter-data-jpa 启动器依赖就能使用了。
Starters包含了许多项目中需要用到的依赖，它们能快速持续的运行，都是一系列得到支持的管理传递性依赖，常用的starter有以下几个：
spring-boot-starter-web 嵌入tomcat和web开发需要servlet与jsp支持 spring-boot-starter-data-jpa 数据库支持
spring-boot-starter-data-redis redis数据库支持
spring-boot-starter-data-solr solr支持
mybatis-spring-boot-starter 第三方的mybatis集成starter

272、 Spring Boot 有哪几种读取配置的方式？

Spring Boot 可以通过 @PropertySource,@Value,@Environment, @ConfigurationProperties 来绑定变量。

273、什么是微服务，你知道哪些微服务框架

以前的模式是，所有的代码在同一个工程中，部署在同一个服务器中，同一个项目的不同模块不同功能互相抢占资源。微服务将工程根据不同的业务规则拆分成微服务，微服务部署在不同的机器上，服务之间进行相互调用。Java微服务的框架有 dubbo（只能用来做微服务），spring cloud（提供了服务的发现，断路器等）

274、什么是服务熔断？什么是服务降级？

熔断机制是应对雪崩效应的一种微服务链路保护机制。当某个微服务不可用或者响应时间太长时，会进行服务降级，进而熔断该节点微服务的调用，快速返回“错误”的响应信息。当检测到该节点微服务调用响应正常后恢复调用链路。在SpringCloud框架里熔断机制通过Hystrix实现，Hystrix会监控微服务间调用的状况，当失败的调用到一定阈值，缺省是5秒内调用20次，如果失败，就会启动熔断机制。
服务降级，一般是从整体负荷考虑。就是当某个服务熔断之后，服务器将不再被调用，此时客户端可以自己准备一个本地的fallback回调，返回一个缺省值。这样做，虽然水平下降，但好歹可用，比直接挂掉强。
Hystrix相关注解
@EnableHystrix：开启熔断
@HystrixCommand(fallbackMethod=”XXX”)：声明一个失败回滚处理函数XXX，当被注解的方法执行超时（默认是1000毫秒），就会执行fallback函数，返回错误提示。

275、 Eureka和zookeeper都可以提供服务注册与发现的功能，请说说两个的区别？

Zookeeper保证了CP（C：一致性，P：分区容错性），Eureka保证了AP（A：高可用）
1）当向注册中心查询服务列表时，我们可以容忍注册中心返回的是几分钟以前的信息，但不能容忍直接down掉不可用。也就是说，服务注册功能对高可用性要求比较高，但zk会出现这样一种情况，当master节点因为网络故障与其他节点失去联系时，剩余节点会重新选leader。问题在于，选取leader时间过长，30 ~ 120s，且选取期间zk集群都不可用，这样就会导致选取期间注册服务瘫痪。在云部署的环境下，因网络问题使得zk集群失去master节点是较大概率会发生的事，虽然服务能够恢复，但是漫长的选取时间导致的注册长期不可用是不能容忍的。
2）Eureka保证了可用性，Eureka各个节点是平等的，几个节点挂掉不会影响正常节点的工作，剩余的节点仍然可以提供注册和查询服务。而Eureka的客户端向某个Eureka注册或发现时发生连接失败，则会自动切换到其他节点，只要有一台Eureka还在，就能保证注册服务可用，只是查到的信息可能不是最新的。除此之外，Eureka还有自我保护机制，如果在15分钟内超过85%的节点没有正常的心跳，那么Eureka就认为客户端与注册中心发生了网络故障，此时会出现以下几种情况：
①、Eureka不在从注册列表中移除因为长时间没有收到心跳而应该过期的服务。
②、Eureka仍然能够接受新服务的注册和查询请求，但是不会被同步到其他节点上（即保证当前节点仍然可用）
③、当网络稳定时，当前实例新的注册信息会被同步到其他节点。因此，Eureka可以很好的应对因网络故障导致部分节点失去联系的情况，而不会像Zookeeper那样使整个微服务瘫痪。

276、 springcloud如何实现服务的注册和发现？

在发布时，指定对应的服务名（服务名包括了IP地址和端口）将服务注册到注册中心（eureka或者zookeeper），这一过程是springcloud自动实现只需要在main方法添加@EnableDisscoveryClient 同一个服务修改端口就可以启动多个实例
调用方法：传递服务名称通过注册中心获取所有的可用实例，通过负载均衡策略调用（ribbon和feign）对应的服务。

277、 ribbon和feign区别与联系

Ribbon添加maven依赖 spring-starter-ribbon 使用@RibbonClient(value=”服务名称”) 使用RestTemplate调用远程服务对应的方法
feign添加maven依赖 spring-starter-feign 服务提供方提供对外接口调用方使用在接口上使用@FeignClient(“指定服务名”)
Ribbon和Feign都是用于调用其他服务的，不过方式不同。
启动类使用的注解不同，Ribbon用的是@RibbonClient，Feign用的是@EnableFeignClients。2.服务的指定位置不同，Ribbon是在@RibbonClient注解上声明，Feign则是在定义抽象方法的接口中使用@FeignClient声明。3.调用方式不同，Ribbon需要自己构建http请求，模拟http请求然后使用RestTemplate发送给其他服务，步骤相当繁琐。Feign则是在Ribbon的基础上进行了一次改进，采用接口的方式，将需要调用的其他服务的方法定义成抽象方法即可，不需要自己构建http请求。不过要注意的是抽象方法的注解、方法签名要和提供服务的方法完全一致。

278、 springcloud断路器的作用

当一个服务调用另一个服务由于网络原因或者自身原因出现问题时，调用者就会等待被调用者的响应，当更多的服务请求到这些资源时，导致更多的请求等待，这样就会发生连锁效应（雪崩效应），断路器就是解决这一问题，断路器有完全打开状态，一定时间内，达到一定的次数无法调用，并且多次检测没有恢复的迹象，断路器完全打开，那么下次请求就不会请求到该服务；半开状态，短时间内，有恢复迹象，断路器会将部分请求发给该服务，当能正常调用时，断路器关闭。关闭状态，当服务一直处于正常状态，能正常调用，断路器关闭。

279、 Zookeeper是什么框架？

分布式的、开源的分布式应用程序协调服务，原本是Hadoop、Hbase的一个重要组件，它为分布式应用提供一致性服务的软件，包括：配置维护、域名服务、分布式同步、组服务等。Zookeeper的功能很强大，应用场景很多，Zookeeper主要是做注册中心用。基于Dubbo框架开发的提供者、消费者都向Zookeeper注册自己的URL，消费者还能拿到并订阅提供者的注册URL，一边在后续程序的执行中去调用提供者。而提供者发生了变动，也会通过Zookeeper向订阅的消费者发送通知。

280、常见的starter会包几个方面的内容？分别是什么？

常见的starter会包括下面四个方面的内容
自动配置文件，根据classpath是否存在指定的类来决定是否要执行该功能的自动配置。
spring.factories，非常重要，指导Spring Boot找到指定的自动配置文件。
endpoint：可以理解为一个admin，包含对服务的描述、界面、交互(业务信息的查询)。
health indicator:该starter提供的服务的健康指标。

281、 Spring boot starter的工作原理

1）Spring Boot 在启动时扫描项目所依赖的JAR包，寻找包含spring.factories文件的JAR
2）根据spring.factories配置加载AutoConfigure类
3）根据 @Conditional注解的条件，进行自动配置并将Bean注入Spring Context

282、如何重新加载Spring Boot上的更改，而无需重新启动服务器？
这可以使用DEV工具来实现。通过这种依赖关系，您可以节省任何更改，嵌入式tomcat将重新启动。 Spring Boot有一个开发工具（DevTools）模块，它有助于提高开发人员的生产力。Java开发人员面临的一个主要挑战是将文件更改自动部署到服务器并自动重启服务器。
开发人员可以重新加载Spring Boot上的更改，而无需重新启动服务器。这将消除每次手动部署更改的需要。Spring Boot在发布它的第一个版本时没有这个功能。
这是开发人员最需要的功能。DevTools模块完全满足开发人员的需求。该模块将在生产环境中被禁用。它还提供H2数据库控制台以更好地测试应用程序。
org.springframework.boot
spring-boot-devtools
true
283、 Spring Boot中的监视器是什么？
Spring boot actuator是spring启动框架中的重要功能之一。Spring boot监视器可帮助您访问生产环境中正在运行的应用程序的当前状态。有几个指标必须在生产环境中进行检查和监控。即使一些外部应用程序可能正在使用这些服务来向相关人员触发警报消息。监视器模块公开了一组可直接作为HTTP URL访问的REST端点来检查状态。
284、如何集成Spring Boot和ActiveMQ？
对于集成Spring Boot和ActiveMQ，我们使用spring-boot-starter-activemq依赖关系。它只需要很少的配置，并且不需要样板代码。

285、 springboot集成mybatis过程
1）添加mybatis的starter maven依赖
org.mybatis.spring.boot
mybatis-spring-boot-starter
1.2.0
2）在mybatis的接口中添加@Mapper注解
3）在application.yml配置数据源信息
286、发布 Spring Boot 用户应用程序自定义配置的最好方法是什么？
@Value 的问题在于，可以通过应用程序分配你配置值，但是更好的操作是采取集中的方法，可以使用 @ConfigurationProperties 定义一个配置组件。
JavaEE面试题总结20190217 - 图1
按照上述写法，在 application.properties 中应该如下配置参数。
JavaEE面试题总结20190217 - 图2
287、 springcloud和dubbo的区别
SpringCloud和Dubbo都是现在主流的微服务架构，SpringCloud是Apache旗下的Spring体系下的微服务解决方案，Dubbo是阿里系的分布式服务治理框架，从技术维度上,其实SpringCloud远远的超过Dubbo,Dubbo本身只是实现了服务治理,而SpringCloud现在以及有21个子项目以后还会更多，但是由于RPC以及注册中心元数据等原因,在技术选型的时候我们只能二者选其一。
服务的调用方式Dubbo使用的是RPC远程调用,而SpringCloud使用的是 Rest API,其实更符合微服务官方的定义，服务的注册中心来看,Dubbo使用了第三方的ZooKeeper作为其底层的注册中心,实现服务的注册和发现,SpringCloud使用Spring Cloud Netflix Eureka实现注册中心,当然SpringCloud也可以使用ZooKeeper实现,但一般我们不会这样做。
服务网关,Dubbo并没有本身的实现,只能通过其他第三方技术的整合,而SpringCloud有Zuul路由网关,作为路由服务器,进行消费者的请求分发,SpringCloud还支持断路器,与git完美集成分布式配置文件支持版本控制,事务总线实现配置文件的更新与服务自动装配等等一系列的微服务架构要素。

JavaEE面试题总结20190217

1、 说出一些数据库优化方面的经验?(重点)

2、 你有优化 SQL 查询数据经验吗？如有能说一下你一般用那些什么方式进行优化？

3、 什么是事务,事务的四个特性是什么？有哪些隔离级别？

4、 数据库中,数据类型 char 与 varchar2 有什么区别？性能方面各有什么优势？

5、 你怎么知道查询 SQL 的性能高还是低？

6、 在开发过程中遇到过数据库锁吗？怎样解锁？

7、 怎样处理并发数据? (重点)