1.springmvc的核心是什么，请求的流程是怎么处理的，控制反转怎么实现的；
1 ，用户发送请求至前端控制器DispatcherServlet
2、DispatcherServlet收到请求调用HandlerMapping处理器映射器
3，处理器（过滤器）如果有，返回DispatcherServlet处理，没有则返回404页面
4，DispatcherServlet调用 handlerAdapter 处理器
5，handlerAdapter 适配处理器（controller） 后端处理器
6，controller 处理完成返回你modelView
7，hendlerAdapter 将controller 返回的结果返回给DispatcherServlet
8，DispatcherServlet 将modelAndView传给viewReslover
9，ViewReslover 解析返回具体的view
10，DispatcherServlet响应用户
2.spring里面的aop的原理是什么；
IOC（反转控制）：对成员变量的赋值控制权从代码中转到配置文件中；
AOP：Aspect（切面） Oriented（面向） Programming（编程），面向切面编程
3.springmvc的核心是什么，请求的流程是怎么处理的，控制反转怎么实现的
核心：
控制反转和面向切面
请求处理流程：
1、首先用户发送请求到前端控制器，前端控制器根据请求信息（如URL）来决定选择哪一个页面控制器进行处理并把请求委托给它，即以前的控制器的控制逻辑部分；
2、页面控制器接收到请求后，进行功能处理，首先需要收集和绑定请求参数到一个对象，并进行验证，然后将命令对象委托给业务对象进行处理；处理完毕后返回一个ModelAndView（模型数据和逻辑视图名）；
3、前端控制器收回控制权，然后根据返回的逻辑视图名，选择相应的视图进行渲染，并把模型数据传入以便视图渲染；
4、前端控制器再次收回控制权，将响应返回给用户。
控制反转如何实现：
我们每次使用spring框架都要配置xml文件，这个xml配置了bean的id和class。
spring中默认的bean为单实例模式，通过bean的class引用反射机制可以创建这个实例。
因此，spring框架通过反射替我们创建好了实例并且替我们维护他们。
A需要引用B类，spring框架就会通过xml把B实例的引用传给了A的成员变量。
4.mybatis如何处理结果集
MyBatis的结果集是通过反射来实现的。并不是通过get/set方法。在实体类中无论是否定义get/set()方法，都是可以接收到的。
如果面试只是考你这个点的话就恭喜了。如果继续深问流程，那就需要自己找一些源码来阅读了。
5.spring中Bean的作用域及生命周期
singleton：
Spring IoC容器中只会存在一个共享的Bean实例，无论有多少个Bean引用它，始终指向同一对象。Singleton作用域是Spring中的缺省作用域。
prototype：
每次通过Spring容器获取prototype定义的bean时，容器都将创建一个新的Bean实例，每个Bean实例都有自己的属性和状态，而singleton全局只有一个对象。
request：
在一次Http请求中，容器会返回该Bean的同一实例。而对不同的Http请求则会产生新的Bean，而且该bean仅在当前Http Request内有效。
session：
在一次Http Session中，容器会返回该Bean的同一实例。而对不同的Session请求则会创建新的实例，该bean实例仅在当前Session内有效。
global Session：
在一个全局的Http Session中，容器会返回该Bean的同一个实例，仅在使用portlet context时有效。
生命周期
-
- Bean，也就是我们通常说的new。
- Spring上下文对实例化的Bean进行配置，也就是IOC注入。
- Bean实现了BeanNameAware接口，会调用它实现的setBeanName(String beanId)方法，此处传递的是Spring配置文件中Bean的ID。
- Bean实现了BeanFactoryAware接口，会调用它实现的setBeanFactory()，传递的是Spring工厂本身（可以用这个方法获取到其他Bean）。
- Bean实现了ApplicationContextAware接口，会调用setApplicationContext(ApplicationContext)方法，传入Spring上下文。
- Bean关联了BeanPostProcessor接口，将会调用postProcessBeforeInitialization(Object obj, String s)方法，BeanPostProcessor经常被用作是Bean内容的更改，并且由于这个是在Bean初始化结束时调用After方法，也可用于内存或缓存技术。
- Bean在Spring配置文件中配置了init-method属性会自动调用其配置的初始化方法。
- Bean关联了BeanPostProcessor接口，将会调用postAfterInitialization(Object obj, String s)方法。
- Bean不再需要时，会经过清理阶段，如果Bean实现了DisposableBean接口，会调用其实现的destroy方法。
- Bean的Spring配置中配置了destroy-method属性，会自动调用其配置的销毁方法。
6.对Spring中依赖注入两种方式的认识
两种注入方式为：构造方法注入和设值注入
-
- JavaBean的写法更相似，程序员更容易理解、接受，通过setter方式设定依赖关系显得更加直观、明显;
- Spring在创建Bean实例时，需要同时实例化其依赖的全部实例，因而会产生浪费。而使用设置注入，则避免这下问题;
- Bean，构造注入更有用处，因为没有setter方法，所有的依赖关系全部在构造器内设定，因此，不用担心后续代码对依赖关系的破坏。
- ;而其他的依赖关系的注入，则考虑采用set注入。
7.Spring框架中都用到了哪些设计模式？
- AOP和remoting中被用的比较多。
- spring配置文件中定义的bean默认为单例模式。
- Spring提供了DispatcherServlet来对请求进行分发。
- BeanFactory / ApplicationContext接口的核心理念。
- BeanFactory用来创建对象的实例。
8.BeanFactory 和ApplicationContext的区别
BeanFactory和ApplicationContext都是接口，并且ApplicationContext是BeanFactory的子接口。
BeanFactory是Spring中最底层的接口，提供了最简单的容器的功能，只提供了实例化对象和拿对象的功能。而ApplicationContext是Spring的一个更高级的容器，提供了更多的有用的功能。
ApplicationContext提供的额外的功能：国际化的功能、消息发送、响应机制、统一加载资源的功能、强大的事件机制、对Web应用的支持等等。
加载方式的区别：BeanFactory采用的是延迟加载的形式来注入Bean；ApplicationContext则相反的，它是在Ioc启动时就一次性创建所有的Bean,好处是可以马上发现Spring配置文件中的错误，坏处是造成浪费。
9.Spring的核心模块
- Core【核心容器】：核心容器提供了Spring的基本功能。核心容器的核心功能是用IOC容器来管理类的依赖关系。
- AOP【面向切面】：Spring的AOP模块提供了面向切面编程的支持。SpringAOP采用的是纯Java实现，采用基于代理的AOP实现方案，AOP代理由IOC容器负责生成、管理，依赖关系也一并由IOC容器管理。
- ORM【对象实体映射】：提供了与多个第三方持久层框架的良好整合。
- DAO【持久层模块】： Spring进一步简化DAO开发步骤，能以一致的方式使用数据库访问技术，用统一的方式调用事务管理，避免具体的实现侵入业务逻辑层的代码中。
- Context【应用上下文】：它是一个配置文件，为Spring提供上下文信息，提供了框架式的对象访问方法。
- Web【Web模块】：提供了基础的针对Web开发的集成特性。
- MVC【MVC模块】：提供了Web应用的MVC实现。Spring的MVC框架并不是仅仅提供一种传统的实现，它提供了一种清晰的分离模型。
10.redis常用的五种数据类型
1.String（字符串）
String是简单的 key-value 键值对，value 不仅可以是 String，也可以是数字。它是Redis最基本的数据类型，一个redis中字符串value最多可以是512M。
2.Hash（哈希）
Redis hash 是一个键值对集合，对应Value内部实际就是一个HashMap，Hash特别适合用于存储对象。
3.List（列表）
Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素导列表的头部（左边）或者尾部（右边）。
底层实现为一个双向链表，即可以支持反向查找和遍历，更方便操作，不过带来了部分额外的内存开销，Redis内部的很多实现，包括发送缓冲队列等也都是用的这个数据结构。
4.Set（集合）
Redis的Set是String类型的无序集合，它的内部实现是一个 value永远为null的HashMap，实际就是通过计算hash的方式来快速排重的，这也是set能提供判断一个成员是否在集合内的原因。
5.zset(有序集合)
Redis zset 和 set 一样也是String类型元素的集合,且不允许重复的成员，不同的是每个元素都会关联一个double类型的分数，用来排序。
11，MVC的各个部分都有那些技术来实现?如何实现?
MVC是Model－View－Controller的简写。Model代表的是应用的业务逻辑（通过JavaBean，EJB组件实现），View是应用的表示面（由JSP页面产生），Controller是提供应用的处理过程控制（一般是一个Servlet），通过这种设计模型把应用逻辑，处理过程和显示逻辑分成不同的组件实现。这些组件可以进行交互和重用。
12.Spring 有什么优势？
- / 低耦合 （降低组件之间的耦合度，实现软件各层之间的解耦）
- MyBatis、Hibernate）
- Java 开发难度
- 框架中包括了 J2EE 三层的每一层的解决方案（一站式）
13.Spring IoC 和 DI 分别是什么？
IoC：Inverse of Control（控制反转），读作 “反转控制”，更好理解，不是什么技术，而是一种设计思想，就是将原本在程序中手动创建对象的控制权，交由Spring框架来管理。
- ：若要使用某个对象，需要自己去负责对象的创建
- ：若要使用某个对象，只需要从 Spring 容器中获取需要使用的对象，不关心对象的创建过程，也就是把创建对象的控制权反转给了Spring框架
- ：Don’t call me ,I’ll call you
- 这就是一种控制反转的理念，上述的例子已经很好的说明了问题，我们再来描述一下控制反转的概念：控制反转是一种通过描述（在 Java 中可以是 XML 或者注解）并通过第三方（Spring）去产生或获取特定对象的方式。
- ① 降低对象之间的耦合；② 我们不需要理解一个类的具体实现，只需要知道它有什么用就好了（直接向 IoC 容器拿）
DI：Dependency Injection（依赖注入）
指 Spring 创建对象的过程中，将对象依赖属性（简单值，集合，对象）通过配置设值给该对象
两者的区别
IoC 和 DI 其实是同一个概念的不同角度描述，DI 相对 IoC 而言，明确描述了 “被注入对象依赖 IoC 容器配置依赖对象”。
你也可以简单的理解为：IoC 是目的，是一种思想，而 DI 是手段，是一种设计模式。
14.IoC 是如何实现的
最后我们简单说说IoC是如何实现的。想象一下如果我们自己来实现这个依赖注入的功能，我们怎么来做？ 无外乎：
- JuiceMaker依赖的是哪个Source，拿到类名
- API，基于类名实例化对应的对象实例
- setter，传递给 JuiceMaker
我们发现其实自己来实现也不是很难，Spring实际也就是这么做的。这么看的话其实IoC就是一个工厂模式的升级版！当然要做一个成熟的IoC框架，还是非常多细致的工作要做，Spring不仅提供了一个已经成为业界标准的Java IoC框架，还提供了更多强大的功能，所以大家就别去造轮子啦！希望了解IoC更多实现细节不妨通过学习Spring的源码来加深理解！
15.Spring 配置 Bean 有几种方式？
在 Spring 中提供了 3 种方法进行配置：
- XML 文件中显式配置
- Java 的接口和类中实现配置
- Bean 的发现机制和自动装配原则
方式选择的原则
在现实的工作中，这 3 种方式都会被用到，并且在学习和工作之中常常混合使用，所以这里给出一些关于这 3 种优先级的建议：
1.最优先：通过隐式 Bean 的发现机制和自动装配的原则。
基于约定由于配置的原则，这种方式应该是最优先的
2.其次：Java 接口和类中配置实现配置
在没有办法使用自动装配原则的情况下应该优先考虑此类方法
- XML 配置的泛滥，也更为容易。
- IoC 容器初始化一个学生类，容器将无法知道使用哪个子类去初始化，这个时候可以使用 Java 的注解配置去指定。
3.最后：XML 方式配置
在上述方法都无法使用的情况下，那么也只能选择 XML 配置的方式。
- XML 的方式配置使用了。
16.介绍一下 Spring AOP
AOP 即 Aspect Oriented Program 面向切面编程
首先，在面向切面编程的思想里面，把功能分为核心业务功能，和周边功能。
- ，比如登陆，增加数据，删除数据都叫核心业务
- ，比如性能统计，日志，事务管理等等
周边功能在 Spring 的面向切面编程AOP思想里，即被定义为切面
在面向切面编程AOP的思想里面，核心业务功能和切面功能分别独立进行开发，然后把切面功能和核心业务功能 "编织" 在一起，这就叫 AOP
17.Spring 中 Bean 的作用域
在默认的情况下，Spring IoC 容器只会对一个 Bean 创建一个实例，但有时候，我们希望能够通过 Spring IoC 容器获取多个实例，我们可以通过 @Scope 注解或者 <bean> 元素中的 scope 属性来设置，例如：
// XML 中设置作用域 <bean id="" class="" scope="prototype" /> // 使用注解设置作用域 @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
Spring 提供了 5 种作用域，它会根据情况来决定是否生成新的对象：
| 作用域类别 | 描述 |
| singleton(单例) | 在Spring IoC容器中仅存在一个Bean实例 （默认的scope） |
| prototype(多例) | 每次从容器中调用Bean时，都返回一个新的实例，即每次调用getBean()时 ，相当于执行new XxxBean()：不会在容器启动时创建对象 |
| request(请求) | 用于web开发，将Bean放入request范围 ，request.setAttribute("xxx") ， 在同一个request 获得同一个Bean |
| session(会话) | 用于web开发，将Bean 放入Session范围，在同一个Session 获得同一个Bean |
| globalSession(全局会话) | 一般用于 Porlet 应用环境 , 分布式系统存在全局 session 概念（单点登录），如果不是 porlet 环境，globalSession 等同于 Session |
在开发中主要使用 scope="singleton"、scope="prototype"，对于MVC中的Action使用prototype类型，其他使用singleton，Spring容器会管理 Action 对象的创建,此时把 Action 的作用域设置为 prototype.
18.Spring MVC 的请求流程
每当用户在 Web 浏览器中点击链接或者提交表单的时候，请求就开始工作了，像是邮递员一样，从离开浏览器开始到获取响应返回，它会经历很多站点，在每一个站点都会留下一些信息同时也会带上其他信息，下图为 Spring MVC 的请求流程：
第一站：DispatcherServlet
从请求离开浏览器以后，第一站到达的就是 DispatcherServlet，看名字这是一个 Servlet，通过 J2EE 的学习，我们知道 Servlet 可以拦截并处理 HTTP 请求，DispatcherServlet 会拦截所有的请求，并且将这些请求发送给 Spring MVC 控制器。
<servlet> <servlet-name>dispatcher</servlet-name> <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>dispatcher</servlet-name> <!-- 拦截所有的请求 --> <url-pattern>/</url-pattern> </servlet-mapping>
- 的任务就是拦截请求发送给 Spring MVC 控制器。
第二站：处理器映射（HandlerMapping）
- 典型的应用程序中可能会有多个控制器，这些请求到底应该发给哪一个控制器呢？
所以 DispatcherServlet 会查询一个或多个处理器映射来确定请求的下一站在哪里，处理器映射会根据请求所携带的 URL 信息来进行决策，例如上面的例子中，我们通过配置 simpleUrlHandlerMapping 来将 /hello 地址交给 helloController 处理：
<beanid="simpleUrlHandlerMapping" class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping"> <property name="mappings"> <props> <!-- /hello 路径的请求交给 id 为 helloController 的控制器处理--> <prop key="/hello">helloController</prop> </props> </property> </bean> <bean id="helloController" class="controller.HelloController"></bean>
第三站：控制器
一旦选择了合适的控制器， DispatcherServlet 会将请求发送给选中的控制器，到了控制器，请求会卸下其负载（用户提交的请求）等待控制器处理完这些信息：
public ModelAndView handleRequest(javax.servlet.http.HttpServletRequest httpServletRequest, javax.servlet.http.HttpServletResponse httpServletResponse) throws Exception { // 处理逻辑 .... }
第四站：返回 DispatcherServlet
当控制器在完成逻辑处理后，通常会产生一些信息，这些信息就是需要返回给用户并在浏览器上显示的信息，它们被称为模型（Model）。仅仅返回原始的信息时不够的——这些信息需要以用户友好的方式进行格式化，一般会是 HTML，所以，信息需要发送给一个视图（view），通常会是 JSP。
控制器所做的最后一件事就是将模型数据打包，并且表示出用于渲染输出的视图名（逻辑视图名）。它接下来会将请求连同模型和视图名发送回 DispatcherServlet。
public ModelAndView handleRequest(javax.servlet.http.HttpServletRequest httpServletRequest, javax.servlet.http.HttpServletResponse httpServletResponse) throws Exception { // 处理逻辑 .... // 返回给 DispatcherServlet return mav; }
第五站：视图解析器
这样以来，控制器就不会和特定的视图相耦合，传递给 DispatcherServlet 的视图名并不直接表示某个特定的 JSP。（实际上，它甚至不能确定视图就是 JSP）相反，它传递的仅仅是一个逻辑名称，这个名称将会用来查找产生结果的真正视图。
DispatcherServlet 将会使用视图解析器（view resolver）来将逻辑视图名匹配为一个特定的视图实现，它可能是也可能不是 JSP
上面的例子是直接绑定到了 index.jsp 视图
第六站：视图
既然 DispatcherServlet 已经知道由哪个视图渲染结果了，那请求的任务基本上也就完成了。
它的最后一站是视图的实现，在这里它交付模型数据，请求的任务也就完成了。视图使用模型数据渲染出结果，这个输出结果会通过响应对象传递给客户端。
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8" isELIgnored="false"%> <h1>${message}</h1>
19.什么是 ORM？
对象关系映射（Object-Relational Mapping，简称ORM）是一种为了解决程序的面向对象模型与数据库的关系模型互不匹配问题的技术；
简单的说，ORM是通过使用描述对象和数据库之间映射的元数据（在Java中可以用XML或者是注解），将程序中的对象自动持久化到关系数据库中或者将关系数据库表中的行转换成Java对象，其本质上就是将数据从一种形式转换到另外一种形式。
20.为什么要使用 MyBatis ？
在我们传统的 JDBC 中，我们除了需要自己提供 SQL 外，还必须操作 Connection、Statment、ResultSet，不仅如此，为了访问不同的表，不同字段的数据，我们需要些很多雷同模板化的代码，闲的繁琐又枯燥。
而我们在使用了 MyBatis 之后，只需要提供 SQL 语句就好了，其余的诸如：建立连接、操作 Statment、ResultSet，处理 JDBC 相关异常等等都可以交给 MyBatis 去处理，我们的关注点于是可以就此集中在 SQL 语句上，关注在增删改查这些操作层面上。
并且 MyBatis 支持使用简单的 XML 或注解来配置和映射原生信息，将接口和 Java 的 POJOs(Plain Old Java Objects,普通的 Java对象)映射成数据库中的记录。
21.MyBatis 中占位符 # 和 $ 的区别
区别如下：
- 符号将传入的数据都当做一个字符串，会对自动传入的数据加一个双引号
- 符号将传入的数据直接显示生成SQL中。
- 符号存在预编译的过程，，对问号赋值，防止SQL注入。
- 符号是直译的方式，一般用在orderby {列名} 语句中。
- #号就不要用$符号
22.MyBatis 缓存结构
在 Web 系统中，最重要的操作就是查询数据库中的数据。但是有些时候查询数据的频率非常高，这是很耗费数据库资源的，往往会导致数据库查询效率极低，影响客户的操作体验。于是我们可以将一些变动不大且访问频率高的数据，放置在一个缓存容器中，用户下一次查询时就从缓存容器中获取结果。
- 拥有自己的缓存结构，可以用来缓解数据库压力，加快查询速度。
- 一级缓存是一个 SqlSession 级别，同一个 SqlSession 只能访问自己的一级缓存的数据
- sqlSession，是 mapper 级别的缓存，对于 mapper 级别的缓存不同的sqlsession是可以共享的。
23.MVC 三种模式
在早期 Java Web 的开发中，统一把显示层、控制层、数据层的操作全部交给 JSP 或者 JavaBean 来进行处理，我们称之为 Model1：
- 和 Java Bean 之间严重耦合，Java 代码和 HTML 代码也耦合在了一起
- Java ，还要有高超的前端水平
正因为上面的种种弊端，所以很快这种方式就被 Servlet + JSP + Java Bean 所替代了，早期的 MVC 模型（Model2）就像下图这样：
首先用户的请求会到达 Servlet，然后根据请求调用相应的 Java Bean，并把所有的显示结果交给 JSP 去完成，这样的模式我们就称为 MVC 模式。
- 代表 模型（Model）
模型是什么呢？ 模型就是数据，就是 dao,bean
- 代表 视图（View）
视图是什么呢？ 就是网页, JSP，用来展示模型中的数据
- 代表 控制器（controller)
控制器是什么？ 控制器的作用就是把不同的数据(Model)，显示在不同的视图(View)上，Servlet 扮演的就是这样的角色。
24.什么是 Spring Boot ？
- “习惯优于配置” （项目中存在大量的配置，此外还内置一个习惯性的配置，让你无须）的理念让你的项目快速运行起来。
- Maven 整合了所有的 jar 包一样，Spring Boot 整合了所有框架
25.使用 Spring Boot 有什么好处？
回顾我们之前的 SSM 项目，搭建过程还是比较繁琐的，需要：web.xml，加载 spring 和 spring mvc
而使用 Spring Boot 来开发项目则只需要非常少的几个配置就可以搭建起来一个 Web 项目，并且利用 IDEA 可以自动生成生成，这简直是太爽了...
26. Mybatis 与 Hibernate 的区别
越来越多的企业在用Mybatis，它的市场占有率越来越高。与之相比，Hibernate的市场占有率却在走低
- 是一个完全的 ORM 框架，Mybatis 是一个不完全的 ORM 框架
Hibernate 自动化程度高，只需配置 OR 映射关系，不需要写 Sql 语句，怎么执行由框架底层控制。
Mybatis 虽然将 Sql 与 Java 对象做了关系映射，但需要程序员自己写 Sql。
- 学习门槛高，Mybatis 学习门槛较低
Hibernate 学习门槛高，精通门槛更高，设计 O/R 映射和 Hibernate 调优都需要很强的经验和能力。
Mybatis 比较容易上手和掌握，重点关注 Sql 语句即可；
- 灵活度差但数据库无关性好，Mybatis 灵活度高，但牺牲了数据库无关性
Hibernate 不能干预具体 Sql 的执行，但数据库无关性好，切换不同数据库时只需要切换数据库类型即可。
Mybatis 可严格控制 Sql 的执行性能，灵活度高，适合于软件的需求变化快而且多的软件，但灵活的前提是牺牲了数据库的无关性，如果要实现支持多种数据库的软件则需要自定义多套 Sql 映射文件，工作量大。
27.Hibernate工作原理及为什么要使用Hibernate？
工作原理：
1.读取并解析配置文件
2.读取并解析映射信息，创建SessionFactory
3.打开Session
4.创建事务Transation
5.持久化操作
6.提交事务
7.关闭Session
8.关闭SesstionFactory
为什么要使用Hibernate（即它的优点）：
1. 对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。
2. Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。他很大程度的简化DAO层的编码工作
3. hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。
4. hibernate映射的灵活性很出色。它支持各种关系数据库，从一对一到多对多的各种复杂关系。
28.Hibernate中get和load方法的区别
hibernate对于load方法认为该数据在数据库中一定存在，可以放心的使用代理来延迟加载，如果在使用过程中发现了问题，只能抛异常；
hibernate对于get方法，hibernate一定要获取到真实的数据，否则返回null。
具体介绍：
● 对于get方法，hibernate会确认一下该id对应的数据是否存在，首先在session缓存中查找，然后在二级缓存中查找，还没有就查询数据库，数据库中没有就返回null。
● load方法加载实体对象的时候，根据映射文件上类级别的lazy属性的配置(默认为true)。
分情况讨论：
● 若为true,则首先在Session缓存中查找，看看该id对应的对象是否存在，不存在则使用延迟加载，返回实体的代理类对象(该代理类为实体类的子类，由CGLIB动态生成)。等到具体使用该对象(除获取OID以外)的时候，再查询二级缓存和数据库，若仍没发现符合条件的记录，则会抛出一个ObjectNotFoundException。
● 若为false,就跟get方法查找顺序一样，只是最终若没发现符合条件的记录，则会抛出一个ObjectNotFoundException。
29.Hibernate是如何延迟加载?
Hibernate3 提供了属性的延迟加载功能。当Hibernate在查询数据的时候，数据并没有存在于内存之中，而是当程序真正对数据的操作时，对象才存在于内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。
30.Hibernate中怎样实现类之间的关系?
类与类之间的关系主要体现在表与表之间的关系进行操作，它们都是对对象进行操作，我们在程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many进行操作。
31.Hibernate中的update()和saveOrUpdate()的区别？
saveOrUpdate()：
● 如果对象已经在本session中持久化了，不做任何事
● 如果另一个与本session关联的对象拥有相同的持久化标识(identifier)，抛出一个异常
● 如果对象没有持久化标识(identifier)属性，对其调用save()
● 如果对象的持久标识(identifier)表明其是一个新实例化的对象，对其调用save()
● 如果对象是附带版本信息的（通过<version>或 <timestamp>）并且版本属性的值表明其是一个新实例化的对象，调用save()。否则update() 这个对象。
update() ：是将一个游离状态的实体对象直接更新。
32.说说Hibernate的缓存机制。
● 一级缓存：内部缓存存在Hibernate中，属于应用事物级缓存。
● 二级缓存：应用级缓存、 分布式缓存。
使用场景：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非关键数据
● 引入第三方缓存（如ehcache等）。
33.如何优化Hibernate？
● 使用双向一对多关联，不使用单向一对多
● 灵活使用单向一对多关联
● 不用一对一，用多对一取代
● 配置对象缓存，不使用集合缓存
● 一对多集合使用Bag,多对多集合使用Set
● 继承类使用显式多态
● 表字段要少，表关联不要怕多，有二级缓存撑腰
34.谈谈hibernate的延迟加载和openSessionInView
延迟加载要在session范围内，用到的时候再加载；
opensessioninview是在web层写了一个filter来打开和关闭session，这样就表示在一次request过程中session一直开着，保证了延迟加载在session中的这个前提。
35.简要阐述struts2的工作流程
1、客户端浏览器发出HTTP请求。
2、根据web.xml配置，该请求被FilterDispatcher接收。
3、根据struts.xml配置，找到需要调用的Action类和方法，并通过IoC方式，将值注入给Aciton。
4、Action调用业务逻辑组件处理业务逻辑，这一步包含表单验证。
5、Action执行完毕，根据struts.xml中的配置找到对应的返回结果result，并跳转到相应页面。
6、返回HTTP响应到客户端浏览器。
36.说下Struts的设计模式
MVC模式
● web应用程序启动时就会加载并初始化ActionServlet；
● 用户提交表单时，一个配置好的ActionForm对象被创建，并被填入表单相应的数 据；
● ActionServlet根据Struts-config.xml文件配置好的设置决定是否需要表单验证，如果需要就调用ActionForm的Validate()验证后选择将请求发送到哪个Action，如果Action不存在，ActionServlet会先创建这个对象，然后调用Action的execute（）方法；
● Execute（）从ActionForm对象中获取数据，完成业务逻辑，返回一个ActionForward对 象，ActionServlet再把客户请求转发给ActionForward对象指定的jsp组件；
● ActionForward对象指定的jsp生成动 态的网页，返回给客户。
37.Struts的优缺点
优点：
● 实现MVC模式，结构清晰,使开发者只关注业务逻辑的实现.
● 有丰富的tag可以用 ,Struts的标记库(Taglib)，如能灵活动用，则能大大提高开发效率。另外，就目前国内的JSP开发者而言，除了使用JSP自带的常用标记外，很少开发自己的标记，或许Struts是一个很好的起点。
● 页面导航.页面导航将是今后的一个发展方向，事实上，这样做，使系统的脉络更加清晰。通过一个配置文件，即可把握整个系统各部分之间的联系，这对于后期的维护有着莫大的好处。尤其是当另一批开发者接手这个项目时，这种优势体现得更加明显。
● 提供Exception处理机制 .
● 数据库链接池管理
● 支持I18N
缺点：
● 转到展示层时，需要配置forward，每一次转到展示层，相信大多数都是直接转到jsp，而涉及到转向， 需要配置forward，如果有十个展示层的jsp，需要配置十次struts，而且还不包括有时候目录、文件变更，需要重新修改forward，注意，每次修改配置之后，要求重新部署整个项目，而tomcate这样的服务器，还必须重新启动服务器，如果业务变更复杂频繁的系统，这样的操作简单不可想象。现在就是这样，几十上百个人同时在线使用我们的系统，大家可以想象一下，我的烦恼有多大。
● Struts 的Action必需是thread－safe方式，它仅仅允许一个实例去处理所有的请求。所以action用到的所有的资源都必需统一同步，这个就引起了线程安全的问题。
● 测试不方便. Struts的每个Action都同Web层耦合在一起，这样它的测试依赖于Web容器，单元测试也很难实现。不过有一个Junit的扩展工具Struts TestCase可以实现它的单元测试。
● 类型的转换. Struts的FormBean把所有的数据都作为String类型，它可以使用工具Commons-Beanutils进行类型转化。但它的转化都是在Class级别，而且转化的类型是不可配置的。类型转化时的错误信息返回给用户也是非常困难的。
● 对Servlet的依赖性过强. Struts处理Action时必需要依赖ServletRequest 和ServletResponse，所有它摆脱不了Servlet容器。
● 前端表达式语言方面.Struts集成了JSTL，所以它主要使用JSTL的表达式语言来获取数据。可是JSTL的表达式语言在Collection和索引属性方面处理显得很弱。
● 对Action执行的控制困难. Struts创建一个Action，如果想控制它的执行顺序将会非常困难。甚至你要重新去写Servlet来实现你的这个功能需求。
● 对Action 执行前和后的处理. Struts处理Action的时候是基于class的hierarchies，很难在action处理前和后进行操作。
● 对事件支持不够. 在struts中，实际是一个表单Form对应一个Action类(或DispatchAction)，换一句话说：在Struts中实际是一个表单只能 对应一个事件，struts这种事件方式称为applicationevent，application event和component event相比是一种粗粒度的事件。
扫一扫
2987
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
