Java面试题5、框架

一、SpringMVC

1. SpringMVC 的工作原理
   a. 用户向服务器发送请求，请求被 springMVC 前端控制器 DispatchServlet 捕获；
   b. DispatcherServle 对请求 URL 进行解析，得到请求资源标识符（URL），然后根据该 URL 调用 HandlerMapping将请求映射到处理器 HandlerExcutionChain；
   c. DispatchServlet 根据获得 Handler 选择一个合适的 HandlerAdapter 适配器处理；
   d. Handler 对数据处理完成以后将返回一个 ModelAndView（）对象给 DisPatchServlet;
   e. Handler 返回的 ModelAndView()只是一个逻辑视图并不是一个正式的视图， DispatcherSevlet 通过ViewResolver 试图解析器将逻辑视图转化为真正的视图 View;
   h. DispatcherServle 通过 model 解析出 ModelAndView()中的参数进行解析最终展现出完整的 view 并返回给 客户端;

2. SpringMVC 常用注解都有哪些？
   @requestMapping 用于请求 url 映射。
   @RequestBody 注解实现接收 http 请求的 json 数据，将 json 数据转换为 java 对象。
   @ResponseBody 注解实现将 controller 方法返回对象转化为 json 响应给客户。

3. 如何开启注解处理器和适配器？
   我们在项目中一般会在 springmvc.xml 中通过开启 mvc:annotation-driven来实现注解处理器和适配器的开启。

4. 如何解决 get 和 post 乱码问题？
   解决 post 请求乱码:我们可以在 web.xml 里边配置一个 CharacterEncodingFilter 过滤器。 设置为 utf-8.
   解决 get 请求的乱码:有两种方法。对于 get 请求中文参数出现乱码解决方法有两个:

5. 修改 tomcat 配置文件添加编码与工程编码一致。

6. 另 外 一 种 方 法 对 参 数 进 行 重 新 编 码 String userName = New String(Request.getParameter(“userName”).getBytes(“ISO8859-1”), “utf-8”);、

二、Spring

1. 谈谈你对 Spring 的理解
   Spring 是一个开源框架，为简化企业级应用开发而生。Spring 可以是使简单的 JavaBean 实现以前只有 EJB 才能实现的功能。Spring 是一个 IOC 和 AOP 容器框架。
   Spring 容器的主要核心是：
   控制反转（IOC），传统的 java 开发模式中，当需要一个对象时，我们会自己使用 new 或者 getInstance 等直接 或者间接调用构造方法创建一个对象。而在 spring 开发模式中，spring 容器使用了工厂模式为我们创建了所需要的对 象，不需要我们自己创建了，直接调用 spring 提供的对象就可以了，这是控制反转的思想。
   依赖注入（DI），spring 使用 javaBean 对象的 set 方法或者带参数的构造方法为我们在创建所需对象时将其属 性自动设置所需要的值的过程，就是依赖注入的思想。
   面向切面编程（AOP），在面向对象编程（oop）思想中，我们将事物纵向抽成一个个的对象。而在面向切面编程 中，我们将一个个的对象某些类似的方面横向抽成一个切面，对这个切面进行一些如权限控制、事物管理，记录日志等公用操作处理的过程就是面向切面编程的思想。AOP 底层是动态代理，如果是接口采用 JDK 动态代理，如果是类采用CGLIB 方式实现动态代理。

2. Spring 中的设计模式

a. 单例模式——spring 中两种代理方式，若目标对象实现了若干接口，spring 使用 jdk 的 java.lang.reflect.Proxy类代理。若目标兑现没有实现任何接口，spring 使用 CGLIB 库生成目标类的子类。
单例模式——在 spring 的配置文件中设置 bean 默认为单例模式。
b. 模板方式模式——用来解决代码重复的问题。 比如：RestTemplate、JmsTemplate、JpaTemplate
d. 前端控制器模式——spring 提供了前端控制器 DispatherServlet 来对请求进行分发。
e. 试图帮助（view helper）——spring 提供了一系列的 JSP 标签，高效宏来帮助将分散的代码整合在试图中。
f. 依赖注入——贯穿于 BeanFactory/ApplacationContext 接口的核心理念。
g. 工厂模式——在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用同一个接口来
指向新创建的对象。Spring 中使用 beanFactory 来创建对象的实例。

3. Spring 的常用注解
   Spring 在 2.5 版本以后开始支持注解的方式来配置依赖注入。可以用注解的方式来代替 xml 中 bean 的描述。注 解注入将会被容器在 XML 注入之前被处理，所以后者会覆盖掉前者对于同一个属性的处理结果。
   注解装配在 spring 中默认是关闭的。所以需要在 spring 的核心配置文件中配置一下才能使用基于注解的装配模 式。配置方式如下：<context:annotation-config />
   常用的注解：
   @Required:该注解应用于设值方法

@Autowired：该注解应用于有值设值方法、非设值方法、构造方法和变量。

@Qualifier：该注解和@Autowired 搭配使用，用于消除特定 bean 自动装配的歧义。

4. 简单介绍一下 Spring bean 的生命周期
   bean 定义：在配置文件里面用来进行定义。
   bean 初始化：有两种方式初始化: 1.在配置文件中通过指定 init-method 属性来完成
   2.实现 org.springframwork.beans.factory.InitializingBean 接口
   bean 调用：有三种方式可以得到 bean 实例，并进行调用
   bean 销毁：销毁有两种方式
   1.使用配置文件指定的 destroy-method 属性
   2.实现 org.springframwork.bean.factory.DisposeableBean 接口

5. Spring 结构图

（1）核心容器：包括 Core、Beans、Context、EL 模块。

Core 模块：封装了框架依赖的最底层部分，包括资源访问、类型转换及一些常用工具类。

Beans 模块：提供了框架的基础部分，包括反转控制和依赖注入。其中 Bean Factory 是容器核心，本质是“工厂

设计模式”的实现，而且无需编程实现“单例设计模式”，单例完全由容器控制，而且提倡面向接口编程，而非面向实 现编程；所有应用程序对象及对象间关系由框架管理，从而真正把你从程序逻辑中把维护对象之间的依赖关系提取出 来，所有这些依赖关系都由 BeanFactory 来维护。
Context 模块：以 Core 和 Beans 为基础，集成 Beans 模块功能并添加资源绑定、数据验证、国际化、Java EE 支持、容器生命周期、事件传播等；核心接口是 ApplicationContext。

EL 模块：提供强大的表达式语言支持，支持访问和修改属性值，方法调用，支持访问及修改数组、容器和索引器， 命名变量，支持算数和逻辑运算，支持从 Spring 容器获取 Bean，它也支持列表投影、选择和一般的列表聚合等。
（2）AOP、Aspects 模块：

AOP 模块：Spring AOP 模块提供了符合 AOP Alliance 规范的面向方面的编程（aspect-oriented programming） 实现，提供比如日志记录、权限控制、性能统计等通用功能和业务逻辑分离的技术，并且能动态的把这些功能添加到需 要的代码中；这样各专其职，降低业务逻辑和通用功能的耦合。
Aspects 模块：提供了对 AspectJ 的集成，AspectJ 提供了比 Spring ASP 更强大的功能。 数据访问/集成模块：该模块包括了 JDBC、ORM、OXM、JMS 和事务管理。
事务模块：该模块用于 Spring 管理事务，只要是 Spring 管理对象都能得到 Spring 管理事务的好处，无需在代码中进行事务控制了，而且支持编程和声明性的事务管理。

JDBC 模块：提供了一个 JBDC 的样例模板，使用这些模板能消除传统冗长的 JDBC 编码还有必须的事务控制，而 且能享受到 Spring 管理事务的好处。
ORM 模块：提供与流行的“对象-关系”映射框架的无缝集成，包括 Hibernate、JPA、MyBatis 等。而且可以使 用 Spring 事务管理，无需额外控制事务。
OXM 模块：提供了一个对 Object/XML 映射实现，将 java 对象映射成 XML 数据，或者将 XML 数据映射成 java对象，Object/XML 映射实现包括 JAXB、Castor、XMLBeans 和 XStream。
JMS 模块：用于 JMS(Java Messaging Service)，提供一套 “消息生产者、消息消费者”模板用于更加简单的使 用 JMS，JMS 用于用于在两个应用程序之间，或分布式系统中发送消息，进行异步通信。
Web/Remoting 模块：Web/Remoting 模块包含了 Web、Web-Servlet、Web-Struts、Web-Porlet 模块。
Web 模块：提供了基础的 web 功能。例如多文件上传、集成 IoC 容器、远程过程访问（RMI、Hessian、Burlap）以及 Web Service 支持，并提供一个 RestTemplate 类来提供方便的 Restful services 访问。
Web-Servlet 模块：提供了一个 Spring MVC Web 框架实现。Spring MVC 框架提供了基于注解的请求资源注 入、更简单的数据绑定、数据验证等及一套非常易用的 JSP 标签，完全无缝与 Spring 其他技术协作。
Web-Struts 模块：提供了与 Struts 无缝集成，Struts1.x 和 Struts2.x 都支持
Test 模块： Spring 支持 Junit 和 TestNG 测试框架，而且还额外提供了一些基于 Spring 的测试功能，比如在测 试 Web 框架时，模拟 Http 请求的功能。

6. Spring 能帮我们做什么？
   a. Spring 能帮我们根据配置文件创建及组装对象之间的依赖关系。
   Spring 根据配置文件来进行创建及组装对象间依赖关系，只需要改配置文件即可

b. Spring 面向切面编程能帮助我们无耦合的实现日志记录，性能统计，安全控制。
Spring 面向切面编程能提供一种更好的方式来完成，一般通过配置方式，而且不需要在现有代码中添加任何额外代码，现有代码专注业务逻辑。

c. Spring 能非常简单的帮我们管理数据库事务。
采用 Spring，我们只需获取连接，执行 SQL，其他事物相关的都交给 Spring 来管理了。

d. Spring 还能与第三方数据库访问框架（如 Hibernate、JPA）无缝集成，而且自己也提供了一套 JDBC 访问模板，来方便数据库访问。

e. Spring 还能与第三方 Web（如 Struts、JSF）框架无缝集成，而且自己也提供了一套 Spring MVC框架，来方便 web 层搭建。

f. Spring 能方便的与 Java EE（如 Java Mail、任务调度）整合，与更多技术整合（比如缓存框架）。

7. 请描述一下 Spring 的事务

声明式事务管理的定义：用在 Spring 配置文件中声明式的处理事务来代替代码式的处理事务。这样的好处是，事务管理不侵入开发的组件，具体来说，业务逻辑对象就不会意识到正在事务管理之中，事实上也应该 如此，因为事务管理是属于系统层面的服务，而不是业务逻辑的一部分，如果想要改变事务管理策划的话，也 只需要在定义文件中重新配置即可，这样维护起来极其方便。
基于 TransactionInterceptor 的声明式事务管理：两个次要的属性： transactionManager，用来 指定一个事务治理器，并将具体事务相关的操作请托给它；其他一个是 Properties 类型的 transactionAttributes 属性，该属性的每一个键值对中，键指定的是方法名，方法名可以行使通配符，而值就是表现呼应方法的所运用的事务属性。

1.<beans…>
2…
3.<bean id=“transactionInterceptor”
4. class=“org.springframework.transaction.interceptor.TransactionInterceptor”>
5.
6.
7.
8. PROPAGATION_REQUIRED
9.
10.
11.
12.<bean id=“bankServiceTarget”
13. class=“footmark.spring.core.tx.declare.origin.BankServiceImpl”>
14.
15.
16.<bean id=“bankService”
17. class=“org.springframework.aop.framework.ProxyFactoryBean”>
18.
19.
20.
21.
22.
23.
24.
25…
26.
基于 TransactionProxyFactoryBean 的声明式事务管理：设置配置文件与先前比照简化了许多。我们把这类设置配置文件格式称为 Spring 经典的声明式事务治理

1.<beans…>
2…
3.<bean id=“bankServiceTarget”
4. class=“footmark.spring.core.tx.declare.classic.BankServiceImpl”>
5. 6.
7.<bean id=“bankService”
8. class=“org.springframework.transaction.interceptor.TransactionProxyFactoryBean”>
9.
10.
11.
12.
13. PROPAGATION_REQUIRED
14.
15.
16.
17…
18.
基于 命名空间的声明式事务治理：在前两种方法的基础上，Spring 2.x 引入了 命名空间，连络行使 命名空间，带给开发人员设置配备声明式事务的全新体验。

基于 @Transactional 的声明式事务管理：Spring 2.x 还引入了基于 Annotation 的体式格式，具体次要触及@Transactional 标注。@Transactional 可以浸染于接口、接口方法、类和类方法上。算作用于类上时，该类的一切public 方法将都具有该类型的事务属性。

1.@Transactional(propagation = Propagation.REQUIRED)
2. public boolean transfer(Long fromId， Long toId， double amount) {
3. return bankDao.transfer(fromId， toId， amount);
4.}

编程式事物管理的定义：在代码中显式挪用 beginTransaction()、commit()、rollback()等事务治理相关的方法，这就是编程式事务管理。Spring 对事物的编程式管理有基于底层 API 的编程式管理和基于 TransactionTemplate 的编程式事务管理两种方式。

基 于 底 层 API 的 编 程 式 管 理 ： 凭 证 PlatformTransactionManager 、 TransactionDefinition 和TransactionStatus 三个焦点接口，来实现编程式事务管理。

5.Public class BankServiceImpl implements BancService{ 6.Private BanckDao bankDao;
7.private TransactionDefinition txDefinition; 8.private PlatformTransactionManager txManager; 9…
10. public boolean transfer(Long fromId， Long toId， double amount) {
11. TransactionStatus txStatus = txManager.getTransaction(txDefinition); 12.boolean result = false;
13.try {
14.result = bankDao.transfer(fromId， toId， amount); 15.txManager.commit(txStatus);
16.} catch (Exception e) { 17.result = false; 18.txManager.rollback(txStatus);
19.System.out.println(“Transfer Error!”);
20.}
21.return result;
22.}
23.}

基于 TransactionTemplate 的编程式事务管理:为了不损坏代码原有的条理性，避免出现每一个方法中都包括相同的启动事物、提交、回滚事物样板代码的现象，spring 提供了 transactionTemplate 模板来实现编程式事务管理。
1.public class BankServiceImpl implements BankService { 2.private BankDao bankDao;
3.private TransactionTemplate transactionTemplate; 4…
5.public boolean transfer(final Long fromId， final Long toId， final double amount) { 6.return (Boolean) transactionTemplate.execute(new TransactionCallback(){
7.public Object doInTransaction(TransactionStatus status) { 8.Object result;
9.try {
10.result = bankDao.transfer(fromId， toId， amount); 11.} catch (Exception e) { 12.status.setRollbackOnly();
13.result = false; 14.System.out.println(“Transfer Error!”); 15.}
16.return result; 17.}
18.});
19.}
20.}

编程式事务与声明式事务的区别：
1）编程式事务是自己写事务处理的类，然后调用
2）声明式事务是在配置文件中配置，一般搭配在框架里面使用！

8. BeanFactory 常用的实现类有哪些？

Bean 工厂是工厂模式的一个实现，提供了控制反转功能，用来把应用的配置和依赖从正真的应用代码中分离。常 用的 BeanFactory 有 DefaultListableBeanFactory 、 XmlBeanFactory 、 ApplicationContext 等。
XMLBeanFactory，最常用的就是 org.springframework.beans.factory.xml.XmlBeanFactory ，它根据 XML 文件中的定义加载 beans。该容器从 XML 文件读取配置元数据并用它去创建一个完全配置的系统或应用。

9. 解释 Spring JDBC、Spring DAO 和 Spring ORM
   Spring-DAO 并非 Spring 的一个模块，它实际上是指示你写 DAO 操作、写好 DAO 操作的一些规范。因此， 对于访问你的数据它 既没有提供接口也没有提供实现更 没有提 供模 板。 在写一 个 DAO 的时候 ，你应 该使 用 @Repository 对其进行注解，这样底层技术(JDBC，Hibernate，JPA，等等)的相关异常才能一致性地翻译为相应
   的 DataAccessException 子类。

Spring-JDBC 提供了 Jdbc 模板类，它移除了连接代码以帮你专注于 SQL 查询和相关参数。Spring-JDBC 还 提供了一个 JdbcDaoSupport，这样你可以对你的 DAO 进行扩展开发。它主要定义了两个属性：一个 DataSource 和一个 JdbcTemplate，它们都可以用来实现 DAO 方法。JdbcDaoSupport 还提供了一个将 SQL 异常转换为
Spring DataAccessExceptions 的异常翻译器。

Spring-ORM 是一个囊括了很多持久层技术(JPA，JDO，Hibernate，iBatis)的总括模块。对于这些技术中的每一 个，Spring 都提供了集成类，这样每一种技术都能够在遵循 Spring 的配置原则下进行使用，并平稳地和 Spring 事务管理进行集成。

对 于 每 一 种 技 术 ， 配 置 主 要 在 于 将 一 个 DataSource bean 注 入 到 某 种 SessionFactory 或 者 EntityManagerFactory 等 bean 中。纯 JDBC 不需要这样的一个集成类(JdbcTemplate 除外)，因为 JDBC 仅依 赖于一个 DataSource。
如果你计划使用一种 ORM 技术，比如 JPA 或者 Hibernate，那么你就不需要 Spring-JDBC 模块了，你需要 的是这个 Spring-ORM 模块。

10. 简单介绍一下 Spring WEB 模块。
    Spring 的 WEB 模块是构建在 application context 模块基础之上，提供一个适合 web 应用的上下文。这个模块也包括支持多种面向 web 的任务，如透明地处理多个文件上传请求和程序级请求参数的绑定到你的业务对象。它也有对 Jakarta Struts 的支持。

11. Spring 配置文件有什么作用？
    Spring 配置文件是个 XML 文件，这个文件包含了类信息，描述了如何配置它们，以及如何相互调用

12. 什么是 Spring IOC 容器？
    IOC 控制反转：Spring IOC 负责创建对象，管理对象。通过依赖注入（DI），装配对象，配置对象，并且管理这些对象的整个生命周期。

13. IOC 的优点是什么？
    IOC 或 依赖注入把应用的代码量降到最低。它使应用容易测试，单元测试不再需要单例和 JNDI 查找机制。最小 的代价和最小的侵入性使松散耦合得以实现。IOC 容器支持加载服务时的饿汉式初始化和懒加载。

14. ApplicationContext 的实现类有哪些?
    FileSystemXmlApplicationContext ：此容器从一个 XML 文件中加载 beans 的定义，XML Bean 配置文件的全 路径名必须提供给它的构造函数。
    ClassPathXmlApplicationContext：此容器也从一个 XML 文件中加载 beans 的定义，这里，你需要正确设置
    classpath 因为这个容器将在 classpath 里找 bean 配置。
    WebXmlApplicationContext：此容器加载一个 XML 文件，此文件定义了一个 WEB 应用的所有 bean。