Spring框架.docx

Spring框架.docx

《Spring框架.docx》由会员分享，可在线阅读，更多相关《Spring框架.docx（31页珍藏版）》请在冰豆网上搜索。

Spring框架

AOP有三种植入切面的方法：

其一是编译期织入，这要求使用特殊的Java编译器，AspectJ是其中的代表者；其二是类装载期织入，而这要求使用特殊的类装载器，AspectJ和AspectWerkz是其中的代表者；其三为动态代理织入，在运行期为目标类添加增强生成子类的方式，SpringAOP采用动态代理织入切面。

SpringAOP使用了两种代理机制，一种是基于JDK的动态代理，另一种是基于CGLib的动态代理，之所以需要两种代理机制，很大程度上是因为JDK本身只提供基于接口的代理，不支持类的代理。

SPRING是通过动态代理来实现AOP的,SPRING内部提供了2种实现机制

1.如果是有接口声明的类进行AOP,spring调用的是java.lang.reflection.Proxy类来做处理

2.如果是没有接口声明的类呢?

SPRING通过CGLIB包和内部类来实现

1Action是不是线程安全的？

如果不是有什么方式可以保证Action的线程安全？

如果是，说明原因

不是

声明局部变量，或者扩展RequestProcessor，让每次都创建一个Action，或者在spring中用scope=”prototype”来管理

3.struts中的几个关键对象的作用（说说几个关键对象的作用）

Action：

控制器类，ActionForm：

表单对象，DynaValidatorForm：

动态form，ActonMapping：

配置文件中action节点的信息……

4.说说AOP和IOC的概念以及在spring中是如何应用的

AOP:

面向方面编程，ioc：

依赖注入；声明式事务和编程式事务积极一些通用部分

6.load（）和get（）的区别

hibernate对于load方法认为该数据在数据库中一定存在，可以放心的使用代理来延迟加载，load默认支持延迟加载，在用到对象中的其他属性数据时才查询数据库，但是万一数据库中不存在该记录，只能抛异常ObjectNotFoundEcception；所说的load方法抛异常是指在使用该对象的数据时，数据库中不存在该数据时抛异常，而不是在创建这个对象时。

由于session中的缓存对于hibernate来说是个相当廉价的资源，所以在load时会先查一下session缓存看看该id对应的对象是否存在，不存在则创建代理（load时候之查询一级缓存，不存在则创建代理）。

get（）现在一级缓存找，没有就去二级缓存找，没有就去数据库找，没有就返回null；而对于get方法，hibernate一定要获取到真实的数据，否则返回null。

7.谈谈hibernate的延迟加载和openSessionInView

延迟加载要在session范围内，用到的时候再加载；opensessioninview是在web层写了一个

filter来打开和关闭session，这样就表示在一次request过程中session一直开着，保证了延迟

加载在session中的这个前提。

8.spring的事务有几种方式？

谈谈spring事务的隔离级别和传播行为。

spring事务分两种形式，声明式事务和编程式事务，spring提供了一个事务的接口

PaltformTractionManager接口，针对不同的事务，spring进行了不同的实现,对hibernate事务

的实现HIbernateTractionManager,对JDBC的JdbcTractionManager，

DataSourceTractionManager以及JdoTractionManager。

接口platformTractionManager提供了三

个方法，获取事务，提交和回滚的方法。

一、Spring框架的优点都有什么？

Spring是分层的架构，你可以选择使用你需要的层而不用管不需要的部分

Spring是POJO编程，POJO编程使得可持续构建和可测试能力提高

依赖注入和IoC使得JDBC操作简单化

Spring是开源的免费的

Spring使得对象管理集中化合简单化

二、描述一下Spring中实现DI（DependencyInjection）的几种方式

方式一：

接口注入，在实际中得到了普遍应用，即使在IOC的概念尚未确立时，这样的方法也已经频繁出现在我们的代码中。

方式二：

Type2IoC:

Setterinjection对象创建之后，将被依赖对象通过set方法设置进去

方式三：

Type3IoC:

Constructorinjection对象创建时，被依赖对象以构造方法参数的方式注入

Spring的方式

三、简述你对IoC（InversionofControl）的理解

一个类需要用到某个接口的方法，我们需要将类A和接口B的实现关联起来，最简单的方法是类A中创建一个对于接口B的实现C的实例，但这种方法显然两者的依赖（Dependency）太大了。

而IoC的方法是只在类A中定义好用于关联接口B的实现的方法，将类A，接口B和接口B的实现C放入IoC的容器（Container）中，通过一定的配置由容器（Container）来实现类A与接口B的实现C的关联。

四、Spring对多种ORM框架提供了很好的支持，简单描述在Spring中使用Hibernate的方法。

在context中定义DataSource，创建SessionFactoy，设置参数；DAO类继承HibernateDaoSupport，实现具体接口，从中获得HibernateTemplate进行具体操作。

在使用中如果遇到OpenSessionInView的问题，可以添加OpenSessionInViewFilter或OpenSessionInViewInterceptor

五、请介绍一下Spring的事务管理

spring提供了几个关于事务处理的类：

TransactionDefinition//事务属性定义

TranscationStatus//代表了当前的事务，可以提交，回滚。

PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。

十二、解释一下Dependencyinjection（DI,依赖注入）和IOC（Inversionofcontrol,控制反转）?

参考答案：

依赖注入DI是一个程序设计模式和架构模型，一些时候也称作控制反转，尽管在技术上来讲，依赖注入是一个IOC的特殊实现，依赖注入是指一个对象应用另外一个对象来提供一个特殊的能力，例如：

把一个数据库连接已参数的形式传到一个对象的结构方法里面而不是在那个对象内部自行创建一个连接。

控制反转和依赖注入的基本思想就是把类的依赖从类内部转化到外部以减少依赖

应用控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用，传递给它。

也可以说，依赖被注入到对象中。

所以，控制反转是，关于一个对象如何获取他所依赖的对象的引用，这个责任的反转。

三十、Spring和Struts的区别？

strusts：

是一种基于MVC模式的一个web层的处理。

Spring:

提供了通用的服务，ioc/diaop,关心的不仅仅web层，应当j2ee整体的一个服务，可以很容易融合不同的技术strutshibernateibatisejbremotespringJDBCspringMVC

说说AOP和IOC的概念以及在spring中是如何应用的

spring的核心就是IOC,通过指定对象的创建办法,描述对象与服务之间的关系,而不生成对象

6.load（）和get（）的区别

load（）方法认为该数据一定存在,可以放心的使用代理来延时加载,如果使用过程中发现了问题,就抛出异常;

get（）方法一定要获取到真实的数据,否则返回null

三十二、Struts，Spring，Hibernate面试题总结

Hibernate工作原理及为什么要用？

原理：

1.读取并解析配置文件

2.读取并解析映射信息，创建SessionFactory

3.打开Sesssion

4.创建事务Transation

5.持久化操作

6.提交事务

7.关闭Session

8.关闭SesstionFactory

为什么要用：

*对JDBC访问数据库的代码做了封装，大大简化了数据访问层繁琐的重复性代码。

*Hibernate是一个基于JDBC的主流持久化框架，是一个优秀的ORM实现。

他很大程度的简化DAO层的编码工作

*hibernate使用Java反射机制，而不是字节码增强程序来实现透明性。

*hibernate的性能非常好，因为它是个轻量级框架。

映射的灵活性很出色。

它支持各种关系数据库，从一对一到多对多的各种复杂关系。

Hibernate是如何延迟加载?

当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。

Hibernate中怎样实现类之间的关系?

（如：

一对多、多对多的关系）

类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、

如何优化Hibernate？

使用双向一对多关联，不使用单向一对多

*灵活使用单向一对多关联

*不用一对一，用多对一取代

*配置对象缓存，不使用集合缓存

*一对多集合使用Bag,多对多集合使用Set

*继承类使用显式多态

*表字段要少，表关联不要怕多，有二级缓存撑腰

Struts工作机制？

为什么要使用Struts？

工作机制：

Struts的工作流程:

在web应用启动时就会加载初始化ActionServlet,ActionServlet从struts-config.xml文件中读取配置信息,把它们存放到各种配置对象当ActionServlet接收到一个客户请求时,将执行如下流程.

（1）检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径无效信息;

（2）如果ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中;

（3）根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的validate（）方法;

（4）如果ActionForm的validate（）方法返回null或返回一个不包含ActionMessage的ActuibErrors对象,就表示表单验证成功;

（5）ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的Action实例不存在,就先创建这个实例,然后调用Action的execute（）方法;

（6）Action的execute（）方法返回一个ActionForward对象,ActionServlet在把客户请求转发给ActionForward对象指向的JSP组件;

（7）ActionForward对象指向JSP组件生成动态网页,返回给客户;

为什么要用：

JSP、Servlet、JavaBean技术的出现给我们构建强大的企业应用系统提供了可能。

但用这些技术构建的系统非常的繁乱，所以在此之上，我们需要一个规则、一个把这些技术组织起来的规则，这就是框架，Struts便应运而生。

基于Struts开发的应用由3类组件构成：

控制器组件（control）、模型组件（modle）、视图组件（view）

Struts的validate框架是如何验证的？

在struts配置文件中配置具体的错误提示，再在FormBean中的validate（）方法具体调用。

说下Struts的设计模式?

MVC模式:

 web应用程序启动时就会加载并初始化ActionServlet。

用户提交表单时，一个配置好的ActionForm对象被创建，并被填入表单相应的数据，ActionServlet根据Struts-config.xml文件配置好的设置决定是否需要表单验证，如果需要就调用ActionForm的Validate（）验证后选择将请求发送到哪个Action，如果Action不存在，ActionServlet会先创建这个对象，然后调用Action的execute（）方法。

Execute（）从ActionForm对象中获取数据，完成业务逻辑，返回一个ActionForward对象，ActionServlet再把客户请求转发给ActionForward对象指定的jsp组件，ActionForward对象指定的jsp生成动态的网页，返回给客户。

spring工作机制及为什么要用?

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

2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.

3.DispatcherServlet请请求提交到目标Controller

4.Controller进行业务逻辑处理后，会返回一个ModelAndView

5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象

6.视图对象负责渲染返回给客户端。

为什么用：

AOP让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。

使用AOP后，公共服务  （比如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。

IOC允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。

正如单词倒置所表明的，IOC就像反     过来的JNDI。

没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straightconstruction），每一个对象都是用    其协作对象构造的。

因此是由容器管理协作对象（collaborator）。

Spring即使一个AOP框架，也是一IOC容器。

Spring最好的地方是它有助于您替换对象。

有了Spring，只要用JavaBean属性和配置文件加入依赖性（协作对象）。

然后可以很容易地在需要时替换具有类似接口的协作对象。

3、简单描述Springframework与Struts的不同之处，整合Spring与Struts有哪些方法，哪种最好，为什么？

Spring是完整的一站式框架，而Struts仅是MVC框架，且着重于MVC中的C。

Spring有三种方式整合Struts：

使用Spring的ActionSupport类整合Struts；使用Spring的DelegatingRequestProcessor覆盖Struts的RequestProcessor；将StrutsAction管理委托给Spring框架，动作委托最好。

（详见使用Spring更好地处理Struts动作）

5、Spring对多种ORM框架提供了很好的支持，简单描述在Spring中使用Hibernate的方法，并结合事务管理。

在context中定义DataSource，创建SessionFactoy，设置参数；DAO类继承HibernateDaoSupport，实现具体接口，从中获得HibernateTemplate进行具体操作。

在使用中如果遇到OpenSessionInView的问题，可以添加OpenSessionInViewFilter或OpenSessionInViewInterceptor。

（详见Springframework2.0Reference的12.2节Hibernate）

声明式事务需声明事务管理器，在context中设置指定属性，用确定和。

三十四、请你谈谈SSH整合

SSH：

Struts（表示层）+Spring（业务层）+Hibernate（持久层）

Struts：

Struts是一个表示层框架，主要作用是界面展示，接收请求，分发请求。

在MVC框架中，Struts属于VC层次，负责界面表现，负责MVC关系的分发。

（View：

沿用JSP，HTTP，Form，Tag，Resourse；Controller：

ActionServlet，struts-config.xml，Action）

Hibernate：

Hibernate是一个持久层框架，它只负责与关系数据库的操作。

Spring：

Spring是一个业务层框架，是一个整合的框架，能够很好地黏合表示层与持久层。

三十八、请介绍一下Spring框架中Bean的作用域

1、singleton作用域

当一个bean的作用域设置为singleton，那么SpringIOC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。

换言之，当把一个bean定义设置为singleton作用域时，SpringIOC容器只会创建该bean定义的唯一实例。

这个单一实例会被存储到单例缓存（singletoncache）中，并且所有针对该bean的后续请求和引用都将返回被缓存的对象实例，这里要注意的是singleton作用域和GOF设计模式中的单例是完全不同的，单例设计模式表示一个ClassLoader中只有一个class存在，而这里的singleton则表示一个容器对应一个bean，也就是说当一个bean被标识为singleton时候，spring的IOC容器中只会存在一个该bean。

2、prototype

prototype作用域部署的bean，每一次请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean（）方法）都会产生一个新的bean实例，相当于一个new的操作，对于prototype作用域的bean，有一点非常重要，那就是Spring不能对一个prototypebean的整个生命周期负责，容器在初始化、配置、装饰或者是装配完一个prototype实例后，将它交给客户端，随后就对该prototype实例不闻不问了。

不管何种作用域，容器都会调用所有对象的初始化生命周期回调方法，而对prototype而言，任何配置好的析构生命周期回调方法都将不会被调用。

清除prototype作用域的对象并释放任何prototypebean所持有的昂贵资源，都是客户端代码的职责。

（让Spring容器释放被singleton作用域bean占用资源的一种可行方式是，通过使用bean的后置处理器，该处理器持有要被清除的bean的引用。

）

四十、Spring框架有哪几部分组成？

Spring框架有七个模块组成组成，这7个模块（或组件）均可以单独存在，也可以与其它一个或多个模块联合使用，主要功能表现如下：

☞Spring核心容器（Core）：

提供Spring框架的基本功能。

核心容器的主要组件是BeanFactory，她是工厂模式的实现。

BeanFactory使用控制反转（Ioc）模式将应用程序的配置和依赖性规范与实际的应用代码程序分开。

☞SpringAOP：

通过配置管理特性，SpringAOP模块直接面向方面的编程功能集成到了Spring框架中，所以可以很容易的使Spring框架管理的任何对象支持AOP。

SpringAOP模块为基于Spring的应用程序中的对象提供了事务管理服务。

通过使用SpringAOP，不用依赖于EJB组件，就可以将声明性事务管理集成到应用程序中。

☞SpringORM：

Spring框架集成了若干ORM框架,从而提供了ORM的对象关系工具,其中包括JDO、Hibernate、iBatis和TopLink。

所有这些都遵从Spring的通用事务和DAO异常层结构。

☞SpringDAO：

JDBCDAO抽象层提供了有意义的异常层次的结构，可用该结构来管理异常处理和不同数据供应商抛出的异常错误信息。

异常层次结构简化了错误处理，并且大大的降低了需要编写的异常代码数量（例如，打开和关系连接）。

SpringDAO的面向JDBC的异常遵从通用的DAO异常层结构。

☞SpringWEB：

Web上下文模块建立在上下文模块（Context）的基础之上，为基于Web服务的应用程序提供了上下文的服务。

所以Spring框架支持JakartaStruts的集成。

Web模块还简化了处理多部分请求及将请求参数绑定到域对象的工作。

☞Spring上下文（Context）：

Spring上下文是一个配置文件，向Spring框架提供上下文信息。

Spring上下文包括企业服务，例如JNDI、EJB、电子邮件、国际化校验和调度功能。

☞SpringMVC：

Spring的MVC框架是一个全功能的构建Web应用程序的MVC实现。

通过策略接口，MVC框架变成为高度可配置的，MVC容纳的大量视图技术，包括JSP、Velocity、Tiles、iText和Pol

四十一、使用Spring有什么好处

Spring能有效地组织你的中间层对象,。

如果你仅仅使用了Struts或其他的包含了J2EE特有APIs的framework，你会发现Spring关注了遗留下的问题，。

◆Spring能消除在许多工程上对Singleton的过多使用。

根据我的经验，这是一个主要的问题，它减少了系统的可测试性和面向对象特性。

◆Spring能消除使用各种各样格式的属性定制文件的需要,在整个应用和工程中，可通过一种一致的方法来进行配置。

曾经感到迷惑，一个特定类要查找迷幻般的属性关键字或系统属性,为此不得不读Javadoc乃至源编码吗？

有了Spring，你可很简单地看到类的JavaBean属性。

倒置控制的使用（在下面讨论）帮助完成这种简化。

◆Spring能通过接口而不是类促进好的编程习惯，减少编程代价到几乎为零。

◆Spring被设计为让使用它创建的应用尽可能少的依赖于他的APIs。

在Spring应用中的大多数业务对象没有依赖于Spring。

◆使用Spring构建的应用程序易于单元测试。

◆Spring能使EJB的使用成为一个实现选择,而不是应用架构的必然选择。

你能选择用POJOs或localEJBs来实现业务接口，却不会影响调用代码。

◆Spring帮助你解决许多问题而无需使用EJB。

Spring能提供一种EJB的替换物，它们适于许多web应用。

例如,Spring能使用AOP提供声明性事务而不通过使用EJB容器，如果你仅仅需要与单个的数据库打交道，甚至不需要JTA实现。

■Spring为数据存取提供了一致的框架,不论是使用JDBC或O/Rmapping产品（如Hibernate）。

Spring确实使你能通过最简单可行的解决办法解决你的问题。

这些特性是有很大价值的。

总结起来，Spring有如下优点：

◆低侵入式设计，代码污染极低

◆独立于各种应用服务器，可以真正实现WriteOnce,RunAnywhere的承诺

◆Spring的DI机制降低了业务对象替换的复杂性