Spring汇总

 

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

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

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

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

Spring是开源的免费的

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

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

方式一：接口注入，在实际中得到了普遍应用，即使在IOC的概念尚未确立时，这样的方法也已经频繁出现在我们的代码中。
方式二：Type2 IoC: Setter injection对象创建之后，将被依赖对象通过set方法设置进去
方式三：Type3 IoC: Constructor injection对象创建时，被依赖对象以构造方法参数的方式注入
Spring的方式

三、简述你对IoC（Inversion of Control）的理解

 

一个类需要用到某个接口的方法，我们需要将类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等都是这个类的子类。

 

一般事务定义步骤：

 

TransactionDefinition td = new TransactionDefinition();

TransactionStatus ts = transactionManager.getTransaction(td);

try

{ //do sth

transactionManager.commit(ts);

}

catch(Exception e){transactionManager.rollback(ts);}

 

spring提供的事务管理可以分为两类：编程式的和声明式的。编程式的，比较灵活，但是代码量大，存在重复的代码比较多；声明式的比编程式的更灵活。

 

编程式主要使用transactionTemplate。省略了部分的提交，回滚，一系列的事务对象定义，需注入事务管理对象.

void add()

{

transactionTemplate.execute( new TransactionCallback(){

pulic Object doInTransaction(TransactionStatus ts)

{ //do sth}

}

}

 

声明式：

 

使用TransactionProxyFactoryBean:

 

 

PROPAGATION_REQUIRED PROPAGATION_REQUIRED PROPAGATION_REQUIRED,readOnly

 

围绕Poxy的动态代理 能够自动的提交和回滚事务

org.springframework.transaction.interceptor.TransactionProxyFactoryBean

 

PROPAGATION_REQUIRED–支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

 

PROPAGATION_SUPPORTS–支持当前事务，如果当前没有事务，就以非事务方式执行。

 

PROPAGATION_MANDATORY–支持当前事务，如果当前没有事务，就抛出异常。

 

PROPAGATION_REQUIRES_NEW–新建事务，如果当前存在事务，把当前事务挂起。

 

PROPAGATION_NOT_SUPPORTED–以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

 

PROPAGATION_NEVER–以非事务方式执行，如果当前存在事务，则抛出异常。

 

PROPAGATION_NESTED–如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。

 

 

六、如何在Spring的applicationContext.xml里面使用JNDI而不是datasource?

可以使用”org.springframework.jndi.JndiObjectFactoryBean”来实现。示例如下：


java:comp/env/jdbc/appfuse

七、Spring里面如何配置数据库驱动？

使用org.springframework.jdbc.datasource.DriverManagerDataSource”数据源来配置数据库驱动。示例如下：


org.hsqldb.jdbcDriver


jdbc:hsqldb:db/appfuse

sa

八、Spring里面applicationContext.xml文件能不能改成其他文件名？

ContextLoaderListener是一个ServletContextListener, 它在你的web应用启动的时候初始化。缺省情况下， 它会在WEB-INF/applicationContext.xml文件找Spring的配置。 你可以通过定义一个元素名字为”contextConfigLocation”来改变Spring配置文件的位置。示例如下：

org.springframework.web.context.ContextLoaderListener

contextConfigLocation
/WEB-INF/xyz.xml

九、如何在web应用里面配置spring?

在J2EE的web应用里面配置spring非常简单，最简单的只需要把spring得ContextLoaderListener添加到你的web.xml文件里面就可以了，示例如下：

org.springframework.web.context.ContextLoaderListener

十、Spring里面如何定义hibernate mapping？

添加hibernate mapping 文件到web/WEB-INF目录下的applicationContext.xml文件里面。示例如下：


org/appfuse/model/User.hbm.xml

 

十一、两种依赖注入的类型都是什么？

两种依赖注入的类型分别是setter注入和构造方法注入。

setter注入： 一般情况下所有的java bean, 我们都会使用setter方法和getter方法去设置和获取属性的值，示例如下：
public class namebean {
String      name;
public void setName(String a) {
name = a; }
public String getName() {
return name; }
}
我们会创建一个bean的实例然后设置属性的值，spring的配置文件如下：


tom


Spring会调用setName方法来只是name熟悉为tom
构造方法注入：构造方法注入中，我们使用带参数的构造方法如下：
public class namebean {
String name;
public namebean(String a) {
name = a;
}
}
我们会在创建bean实例的时候以new namebean(”tom”)的方式来设置name属性, Spring配置文件如下：


My Bean Value


使用constructor-arg标签来设置构造方法的参数。

 

十二、解释一下Dependency injection(DI,依赖注入)和IOC(Inversion of control,控制反转)?

参考答案：依赖注入DI是一个程序设计模式和架构模型， 一些时候也称作控制反转，尽管在技术上来讲，依赖注入是一个IOC的特殊实现，依赖注入是指一个对象应用另外一个对象来提供一个特殊的能力，例如：把一个数据库连接已参数的形式传到一个对象的结构方法里面而不是在那个对象内部自行创建一个连接。控制反转和依赖注入的基本思想就是把类的依赖从类内部转化到外部以减少依赖
应用控制反转，对象在被创建的时候，由一个调控系统内所有对象的外界实体，将其所依赖的对象的引用，传递给它。也可以说，依赖被注入到对象中。所以，控制反转是，关于一个对象如何获取他所依赖的对象的引用，这个责任的反转。

 

十三、spring中的BeanFactory与ApplicationContext的作用和区别？

作用：

1. BeanFactory负责读取bean配置文档，管理bean的加载，实例化，维护bean之间的依赖关系，负责bean的声明周期。
2. ApplicationContext除了提供上述BeanFactory所能提供的功能之外，还提供了更完整的框架功能：

a. 国际化支持
b. 资源访问：Resource rs = ctx. getResource(”classpath:config.properties”), “file:c:/config.properties”
c. 事件传递：通过实现ApplicationContextAware接口
3. 常用的获取ApplicationContext的方法：
FileSystemXmlApplicationContext：从文件系统或者url指定的xml配置文件创建，参数为配置文件名或文件名数组
ClassPathXmlApplicationContext：从classpath的xml配置文件创建，可以从jar包中读取配置文件
WebApplicationContextUtils：从web应用的根目录读取配置文件，需要先在web.xml中配置，可以配置监听器或者servlet来实现

org.springframework.web.context.ContextLoaderListener


context
org.springframework.web.context.ContextLoaderServlet
1

这两种方式都默认配置文件为web-inf/applicationContext.xml，也可使用context-param指定配置文件

contextConfigLocation
/WEB-INF/myApplicationContext.xml

十四、如何在web环境中配置applicationContext.xml文件?

org.springframework.web.context.ContextLoaderListener


或：

context

org.springframework.web.context.ContextLoaderServlet

1

通过如下方法取出applicationContext实例:
ApplicationContext ac=WebApplicationContextUtils.getWebApplicationContext(this.getServletContext);

 

十五、如何配置spring+struts?

在struts-config.xml加入一个插件，通过它加载applicationContext.xml
在struts-config.xml修改action-mapping标记，具体action交给了DelegateActionProxyØ
通过DelegateActionProxy进入一spring的环境。u
在spring的applicationContext.xml加入Ø

 

十六、spring+hibernate的配置文件中的主要类有那些?如何配置?

在myeclipse中先加入spring环境再加入hibernate环境。
如果spring与hibernate结合在一起可以不需要hibernate.cfg.xml文件是否正确?
spring+hibernate的配置文件中的主要类有那些?如何配置?
dataSource
sessionFactory:hibernate.cfg.xml
transactionManager
userDao (extends HibernateDaoSupport)
sessionFactory
facade
proxy
sessionFactory
transactionManager
facade

 

十七、在spring中如何配容器的事务管理，相关的类有那些?

Datasouce
transactionManager
userDao要注入
Datasouce
Proxy代理
Target:userDao：代理对象(目标对象)
transactionAttributes(那些方法需要事务处理)
transactionManager(事务处理服务)

十八、在spring中如何配代码的事务管理?

Datasouce
transactionManager
userDao要注入
Datasouce
transactionManager
通过如下类实现
TransactionTemplate
JdbcTemplate

 

十九、在spring中有几种事务管理，分别是什么?

代码管理的事务处理
TransactonTemplate的execute方法中的内部类TransactionCallback中的doInTransaction方法中使用。
public void make()
{
TransactionTemplate jtm=new TransactionTemplate(this.getTransactionManager());
jtm.execute(new myClass1());
}
public class myClass1 implements TransactionCallback
{

public Object doInTransaction(TransactionStatus trans)
{
JdbcTemplate jdbc=new JdbcTemplate(dataSource);
jdbc.execute(”insert into customer(customerName) values(’b’)”);
jdbc.execute(”insert into customer(customerName) values(’b’)”);
return null;
}
}
容器管理的事务处理

二十、spring的jdbc与传统的jdbc有什么区别，其核心类有那些?

Spring的jdbc:节省代码，不管连接(Connection)，不管事务、不管异常、不管关闭(con.close() ps.close )

JdbcTemplate(dataSource):增、删、改、查
TransactionTemplate(transactionManager):进行事务处理

二十一、spring与ejb2.0的事务管理比较的优缺点?

测试:
Spring:pojo
Ejb:二个接口一个类,一堆配置文件
事务类型
Spring:jdbc jta  hibernate
Ejb:jta
成本
Spring:普通容器(tomcat jboss)
Ejb:weblogic jboss
开发的周期:
Spring远比ejb快.

 

二十二、spring的配置的主要标签是什么?有什么作用?

 

二十三、如何在spring中实现国际化?

在applicationContext.xml加载一个bean


message


在src目录下建多个properties文件Ø
对于非英文的要用native2asciiØ -encoding gb2312 源  目转化文件相关内容
其命名格式是message_语言_国家。Ø
页面中的中显示提示信息，键名取键值。Ø
当给定国家，系统会自动加载对应的国家的properties信息。Ø
通过applictionContext.getMessage(“键名”,”参数”,”区域”)取出相关的信息。Ø

二十四、Spring如何实现事件处理?

事件
Extends ApplicationEvent
监听器
Implements ApplicationListener
事件源
Implements ApplicationContextAware
在applicationContext.xml中配置事件源、监听器
先得到事件源，调用事件源的方法，通知监听器。

二十五、如何加入Spring到web框架中？

在web.xml中加入如下同容,在启动web服务器时加载/WEB-INF/applicationContext.xml中的内容。

context

org.springframework.web.context.ContextLoaderServlet

1

通过如下类得到ApplicationContext实例
WebApplicationContextUtils.getWebApplicationContext

 

二十六、Spring如何实现资源管理?

使用
applicationContext.getResource(“classpath:文件名”):在src根目录下，在类路径下
applicationContext.getResource(“classpath:/chap01/文件名”): 以src根目录下的基准往下走。
applicationContext.getResource(“file:c:/a.properties”)：在系统文件目录下。

 

二十七、Spring中ApplicationContext的作用是什么？

beanFactory
国际化(getMesage)
资源管理:可以直接读取一个文件的内容(getResource)
加入web框架中(加入一个servlet或监听器)
事件处理

 

二十八、spring中的核心类有那些，各有什么作用?

 

BeanFactory：产生一个新的实例，可以实现单例模式
BeanWrapper：提供统一的get及set方法
ApplicationContext:提供框架的实现，包括BeanFactory的所有功能

 

二十九、aop中的关键名词有些那些，相互关系是什么?

 

拦截器: 代理
装备(advice)
目标对象
关切点:条件
连接点:方法、属性

三十、Spring和Struts的区别？

strusts：是一种基于MVC模式的一个web层的处理。
Spring:提供了通用的服务，ioc/di aop,关心的不仅仅web层，应当j2ee整体的一个服务，可以很容易融合不同的技术struts hibernate ibatis ejb remote springJDBC springMVC

 

三十一、struts+spring面试题

1.struts
Action是不是线程安全的？如果不是，有什么方式可以保证Action的线程安全？如果是，说明原因

2.MVC，分析一下struts是如何实现MVC的

3.struts中的几个关键对象的作用(说说几个关键对象的作用)

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

5.Hibernate有哪几种查询数据的方式

6.load()和get()的区别

回答：
1.Struts1 Action是单例模式并且必须是线程安全的，因为仅有Action的一个实例来处理所有的请求。单例策略限制了Struts1 Action能作的事，并且要在开发时特别小心。Action资源必须是线程安全的或同步的。
Struts2 Action对象为每一个请求产生一个实例，因此没有线程安全问题。（实际上，servlet容器给每个请求产生许多可丢弃的对象，并且不会导致性能和垃圾回收问题）

2.struts是用一组类,servlet 和jsp规范实现mvc的

3.ActionFrom ActionServlet Action struts-config.xml

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

5.3种,hql 条件查询() 原生sql

6.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是如何延迟加载?

* Hibernate2延迟加载实现：a)实体对象  b)集合（Collection）
* Hibernate3 提供了属性的延迟加载功能

当Hibernate在查询数据的时候，数据并没有存在与内存中，当程序真正对数据的操作时，对象才存在与内存中，就实现了延迟加载，他节省了服务器的内存开销，从而提高了服务器的性能。
Hibernate中怎样实现类之间的关系?(如：一对多、多对多的关系)
类与类之间的关系主要体现在表与表之间的关系进行操作，它们都市对对象进行操作，我们程序中把所有的表与类都映射在一起，它们通过配置文件中的many-to-one、one-to-many、many-to-many、

说下Hibernate的缓存机制

* 内部缓存存在Hibernate中又叫一级缓存，属于应用事物级缓存
* 二级缓存：

a)应用及缓存

b)分布式缓存

条件：数据不会被第三方修改、数据大小在可接受范围、数据更新频率低、同一数据被系统频繁使用、非关键数据

c)  第三方缓存的实现
Hibernate的查询方式
Sql、Criteria,object comptosition
Hql：

* 属性查询
* 参数查询、命名参数查询
* 关联查询
* 分页查询
* 统计函数

如何优化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类组件构成：控制器组件、模型组件、视图组件
Struts的validate框架是如何验证的？
在struts配置文件中配置具体的错误提示，再在FormBean中的validate()方法具体调用。

说下Struts的设计模式
MVC模式:  web应用程序启动时就会加载并初始化ActionServler。用户提交表单时，一个配置好的ActionForm对象被创建，并被填入表单相应的数据，ActionServler根据Struts-config.xml 文件配置好的设置决定是否需要表单验证，如果需要就调用ActionForm的Validate（）验证后选择将请求发送到哪个Action，如果 Action不存在，ActionServlet会先创建这个对象，然后调用Action的execute（）方法。Execute（）从 ActionForm对象中获取数据，完成业务逻辑，返回一个ActionForward对象，ActionServlet再把客户请求转发给 ActionForward对象指定的jsp组件，ActionForward对象指定的jsp生成动态的网页，返回给客户。

单例模式

Factory(工厂模式)：

定义一个基类===》实现基类方法（子类通过不同的方法）===》定义一个工厂类（生成子类实例）

===》开发人员调用基类方法

Proxy(代理模式)

spring工作机制及为什么要用?
1.spring mvc请所有的请求都提交给DispatcherServlet,它会委托应用系统的其他模块负责负责对请求进行真正的处理工作。
2.DispatcherServlet查询一个或多个HandlerMapping,找到处理请求的Controller.
3.DispatcherServlet请请求提交到目标Controller
4.Controller进行业务逻辑处理后，会返回一个ModelAndView
5.Dispathcher查询一个或多个ViewResolver视图解析器,找到ModelAndView对象指定的视图对象
6.视图对象负责渲染返回给客户端。

为什么用：
AOP 让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务   （比 如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。

IOC 允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的，IOC 就像反      过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每一个对象都是用     其协作对象构造的。因此是由容器管理协作对象（collaborator）。

Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，只要用 JavaBean 属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的协作对象。

三十三、一些Spring和Hibernate的面试题(附答案)

1、 简述你对IoC（Inversion of Control）的理解，描述一下Spring中实现DI（Dependency Injection）的几种方式。

2、 Spring的Bean有多种作用域，包括：

singleton、prototype、request、session、global session、application、自定义

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

4、 Hibernate中的update()和saveOrUpdate()的区别

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

答案：

1、好莱坞原则€€€€不要打电话找我，我会打给你的。IoC将创建的职责从应用程序代码搬到了框架中。Spring对Setter注入和构造方法注入提供支持。（详见http://martinfowler.com/articles/injection.html，以及http: //www.redsaga.com/spring_ref/2.0/html/beans.html#beans-factory- collaborators）

2、 除application（详见Spring framework 2.0 Reference的3.4节bean的作用域）

3、 Spring是完整的一站式框架，而Struts仅是MVC框架，且着重于MVC中的C。Spring有三种方式整合Struts：使用 Spring 的 ActionSupport 类整合 Struts；使用 Spring 的 DelegatingRequestProcessor 覆盖 Struts 的 RequestProcessor；将 Struts Action 管理委托给 Spring 框架，动作委托最好。（详见使用Spring 更好地处理Struts 动作）

Spring 2.0新增一种方式：AutowiringRequestProcessor。（详见http://www.javaeye.com/topic/24239）

4、 saveOrUpdate()方法可以实现update()的功能，但会多些步骤，具体如下：

如果对象在该session中已经被持久化，不进行操作；

对象的标识符属性(identifier property)在数据库中不存在或者是个暂时的值，调用save()方法保存它；

如果session中的另一个对象有相同的标识符抛出一个异常；

以上皆不符合则调用update()更新之。

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

在使用中如果遇到OpenSessionInView的问题，可以添加OpenSessionInViewFilter或OpenSessionInViewInterceptor。（详见Spring framework 2.0 Reference的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框架中如何更加高效的使用JDBC

使用Spring框架提供的模板类JdbcTemplete可以是JDBC更加高效

代码如下：JdbcTemplate template = new JdbcTemplate(myDataSource);

DAO类的例子：

public class StudentDaoJdbc implements StudentDao {
private JdbcTemplate jdbcTemplate;

public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
this.jdbcTemplate = jdbcTemplate;
}
more..
}

配置文件：

 

三十六、Spring如何创建一个数据连接池.

${db.driver}


${db.url}


${db.username}


${db.password}

 

 

三十七、Spring如何配置一个bean来从JNDI得到DataSource

java:comp/env/jdbc/myDatasource

 

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

 

在spring2.0之前bean只有2种作用域即：singleton(单例)、non-singleton（也称 prototype），Spring2.0以后，增加了session、request、global session三种专用于Web应用程序上下文的Bean。因此，默认情况下Spring2.0现在有五种类型的Bean。

这里的scope就是用来配置spring bean的作用域，它标识bean的作用域。

在spring2.0之前bean只有2种作用域即：singleton(单例)、non-singleton（也称 prototype），Spring2.0以后，增加了session、request、global session三种专用于Web应用程序上下文的Bean。因此，默认情况下Spring2.0现在有五种类型的Bean。当然，Spring2.0对 Bean的类型的设计进行了重构，并设计出灵活的Bean类型支持，理论上可以有无数多种类型的Bean，用户可以根据自己的需要，增加新的Bean类型，满足实际应用需求。

1、singleton作用域

当一个bean的作用域设置为singleton，那么Spring IOC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。换言之，当把一个bean定义设置为singleton作用域时，Spring IOC容器只会创建该bean定义的唯一实例。这个单一实例会被存储到单例缓存（singleton cache）中，并且所有针对该bean的后续请求和引用都将返回被缓存的对象实例，这里要注意的是singleton作用域和GOF设计模式中的单例是完全不同的，单例设计模式表示一个ClassLoader中只有一个class存在，而这里的singleton则表示一个容器对应一个bean，也就是说当一个bean被标识为singleton时候，spring的IOC容器中只会存在一个该bean。

配置实例：

或者

2、prototype

prototype作用域部署的bean，每一次请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean()方法）都会产生一个新的bean实例，相当于一个new的操作，对于prototype作用域的bean，有一点非常重要，那就是Spring不能对一个 prototype bean的整个生命周期负责，容器在初始化、配置、装饰或者是装配完一个prototype实例后，将它交给客户端，随后就对该prototype实例不闻不问了。不管何种作用域，容器都会调用所有对象的初始化生命周期回调方法，而对prototype而言，任何配置好的析构生命周期回调方法都将不会被调用。清除prototype作用域的对象并释放任何prototype bean所持有的昂贵资源，都是客户端代码的职责。（让Spring容器释放被singleton作用域bean占用资源的一种可行方式是，通过使用 bean的后置处理器，该处理器持有要被清除的bean的引用。）

配置实例：

或者

3、request

request表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP request内有效，配置实例：

request、session、global session使用的时候，首先要在初始化web的web.xml中做如下配置：

如果你使用的是Servlet 2.4及以上的web容器，那么你仅需要在web应用的XML声明文件web.xml中增加下述ContextListener即可：

…

org.springframework.web.context.request.RequestContextListener

…

如果是Servlet2.4以前的web容器,那么你要使用一个javax.servlet.Filter的实现：

..

requestContextFilter
org.springframework.web.filter.RequestContextFilter


requestContextFilter
/*

…

接着既可以配置bean的作用域了：

4、session

session作用域表示该针对每一次HTTP请求都会产生一个新的bean，同时该bean仅在当前HTTP session内有效，配置实例：

配置实例：

和request配置实例的前提一样，配置好web启动文件就可以如下配置：

5、global session

global session作用域类似于标准的HTTP Session作用域，不过它仅仅在基于portlet的web应用中才有意义。Portlet规范定义了全局Session的概念，它被所有构成某个 portlet web应用的各种不同的portlet所共享。在global session作用域中定义的bean被限定于全局portlet Session的生命周期范围内。如果你在web中使用global session作用域来标识bean，那么，web会自动当成session类型来使用。

配置实例：

和request配置实例的前提一样，配置好web启动文件就可以如下配置：

6、自定义bean装配作用域

在spring 2.0中作用域是可以任意扩展的，你可以自定义作用域，甚至你也可以重新定义已有的作用域（但是你不能覆盖singleton和 prototype），spring的作用域由接口org.springframework.beans.factory.config.Scope来定义，自定义自己的作用域只要实现该接口即可，下面给个实例：

我们建立一个线程的scope，该scope在表示一个线程中有效，代码如下：

publicclass MyScope implements Scope …{
privatefinal ThreadLocal threadScope = new ThreadLocal() …{
protected Object initialValue() …{
returnnew HashMap();
}
};
public Object get(String name, ObjectFactory objectFactory) …{
Map scope = (Map) threadScope.get();
Object object = scope.get(name);
if(object==null) …{
object = objectFactory.getObject();
scope.put(name, object);
}
return object;
}
public Object remove(String name) …{
Map scope = (Map) threadScope.get();
return scope.remove(name);
}
publicvoid registerDestructionCallback(String name, Runnable callback) …{
}
public String getConversationId() …{
// TODO Auto-generated method stub
returnnull;
}
}

 

三十九、

请介绍一下Spring框架中Bean的生命周期

 

一、Bean的定义
Spring通常通过配置文件定义Bean。如：

xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xsi:schemaLocation=”http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.0.xsd”>


HelloWorld

这个配置文件就定义了一个标识为 HelloWorld 的Bean。在一个配置文档中可以定义多个Bean。

二、Bean的初始化
有两种方式初始化Bean。
1、在配置文档中通过指定init-method 属性来完成
在Bean的类中实现一个初始化Bean属性的方法，如init()，如：
public class HelloWorld{
public String msg=null;
public Date date=null;

public void init() {
msg=”HelloWorld”;
date=new Date();
}
……
}
然后，在配置文件中设置init-mothod属性：

2、实现 org.springframwork.beans.factory.InitializingBean接口
Bean实现InitializingBean接口，并且增加 afterPropertiesSet() 方法：

public class HelloWorld implement InitializingBean {
public String msg=null;
public Date date=null;

public void afterPropertiesSet() {
msg=”向全世界问好！”;
date=new Date();
}
……
}

那么，当这个Bean的所有属性被Spring的BeanFactory设置完后，会自动调用afterPropertiesSet()方法对Bean进行初始化，于是，配置文件就不用指定 init-method属性了。

三、Bean的调用
有三种方式可以得到Bean并进行调用：
1、使用BeanWrapper
HelloWorld hw=new HelloWorld();
BeanWrapper bw=new BeanWrapperImpl(hw);
bw.setPropertyvalue(”msg”,”HelloWorld”);
system.out.println(bw.getPropertyCalue(”msg”));

2、使用BeanFactory
InputStream is=new FileInputStream(”config.xml”);
XmlBeanFactory factory=new XmlBeanFactory(is);
HelloWorld hw=(HelloWorld) factory.getBean(”HelloWorld”);
system.out.println(hw.getMsg());

3、使用ApplicationConttext
ApplicationContext actx=new FleSystemXmlApplicationContext(”config.xml”);
HelloWorld hw=(HelloWorld) actx.getBean(”HelloWorld”);
System.out.println(hw.getMsg());

四、Bean的销毁
1、使用配置文件中的 destory-method 属性
与初始化属性 init-methods类似，在Bean的类中实现一个撤销Bean的方法，然后在配置文件中通过 destory-method指定，那么当bean销毁时，Spring将自动调用指定的销毁方法。

2、实现 org.springframwork.bean.factory.DisposebleBean接口
如果实现了DisposebleBean接口，那么Spring将自动调用bean中的Destory方法进行销毁，所以，Bean中必须提供Destory方法。

 

四十、通过xml配置文件

bean配置在xml里面，spring提供多种方式读取配置文件得到ApplicationContext.

第一种方式：FileSystemXmlApplicationContext

通过程序在初始化的时候，导入Bean配置文件，然后得到Bean实例:
ApplicationContext ac = new FileSystemXmlApplicationContext(”applicationContext.xml”)
ac.getBean(”beanName”);

第二种方式：WebApplicationContextUtil

在B/S系统中,通常在web.xml初始化bean的配置文件，然后由WebAppliCationContextUtil得到ApplicationContext.例如：
ApplicationContext ctx = WebApplicationContextUtils.getRequiredWebApplicationContext(ServletContext sc);
ApplicationContext ctx =   WebApplicationContextUtils.getWebApplicationContext(ServletContext sc);

其中 servletContext sc 可以具体 换成 servlet.getServletContext()或者 this.getServletContext() 或者 request.getSession().getServletContext();

另外，由于spring是注入的对象放在ServletContext中的，所以可以直接在ServletContext取出WebApplicationContext 对象：

WebApplicationContext webApplicationContext = (WebApplicationContext) servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);

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

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

☞ Spring 核心容器（Core）：提供Spring框架的基本功能。核心容器的主要组件是BeanFactory，她是工厂模式的实现。BeanFactory使用控制反转（Ioc）模式将应用程序的配置和依赖性规范与实际的应用代码程序分开。

☞ Spring AOP：通过配置管理特性，Spring AOP模块直接面向方面的编程功能集成到了Spring框架中，所以可以很容易的使Spring框架管理的任何对象支持 AOP。Spring AOP模块为基于Spring的应用程序中的对象提供了事务管理服务。通过使用Spring AOP，不用依赖于EJB组件，就可以将声明性事务管理集成到应用程序中。

☞ Spring ORM：Spring框架集成了若干ORM框架,从而提供了ORM的对象关系工具,其中包括 JDO、Hibernate、iBatis和TopLink。所有这些都遵从Spring的通用事务和DAO异常层结构。

☞ Spring DAO：JDBC DAO抽象层提供了有意义的异常层次的结构，可用该结构来管理异常处理和不同数据供应商抛出的异常错误信息。异常层次结构简化了错误处理，并且大大的降低 了需要编写的异常代码数量（例如，打开和关系连接）。Spring DAO的面向JDBC的异常遵从通用的DAO异常层结构。

☞ Spring WEB：Web上下文模块建立在上下文模块（Context）的基础之上，为基于Web服务的应用程序提供了上下文的服务。所以Spring框架支持 Jakarta Struts的集成。Web模块还简化了处理多部分请求及将请求参数绑定到域对象的工作。

☞ Spring上下文（Context）：Spring上下文是一个配置文件，向Spring框架提供上下文信息。Spring上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化校验和调度功能。

☞ Spring MVC：Spring的MVC框架是一个全功能的构建Web应用程序的MVC实现。通过策略接口，MVC框架变成为高度可配置的，MVC容纳的大量视图技术，包括JSP、Velocity、Tiles、iText和Pol

 

 

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

 

◆Spring能有效地组织你的中间层对象,无论你是否选择使用了EJB。如果你仅仅使用了Struts或其他的包含了J2EE特有APIs的framework，你会发现Spring关注了遗留下的问题，。

◆Spring能消除在许多工程上对Singleton的过多使用。根据我的经验，这是一个主要的问题，它减少了系统的可测试性和面向对象特性。
◆Spring能消除使用各种各样格式的属性定制文件的需要,在整个应用和工程中，可通过一种 一致的方法来进行配置。曾经感到迷惑，一个特定类要查找迷幻般的属性关键字或系统属性,为此不得不读Javadoc乃至源编码吗？有了Spring，你可 很简单地看到类的JavaBean属性。倒置控制的使用(在下面讨论)帮助完成这种简化。
◆Spring能通过接口而不是类促进好的编程习惯，减少编程代价到几乎为零。
◆Spring被设计为让使用它创建的应用尽可能少的依赖于他的APIs。在Spring应用中的大多数业务对象没有依赖于Spring。
◆使用Spring构建的应用程序易于单元测试。
◆Spring能使EJB的使用成为一个实现选择,而不是应用架构的必然选择。你能选择用POJOs或local EJBs来实现业务接口，却不会影响调用代码。
◆Spring帮助你解决许多问题而无需使用EJB。Spring能提供一种EJB的替换物，它们适于许多web应用。例如,Spring能使用AOP提供声明性事务而不通过使用EJB容器，如果你仅仅需要与单个的数据库打交道，甚至不需要JTA实现。
■Spring为数据存取提供了一致的框架,不论是使用JDBC或O/R mapping产品（如Hibernate）。
Spring确实使你能通过最简单可行的解决办法解决你的问题。这些特性是有很大价值的。
总结起来，Spring有如下优点：
◆低侵入式设计，代码污染极低
◆ 独立于各种应用服务器，可以真正实现Write Once,Run Anywhere的承诺
◆Spring的DI机制降低了业务对象替换的复杂性
◆Spring并不完全依赖于Spring，开发者可自由选用Spring框架的部分或全部

 

四十二、Spring面试：什么是Spring, 它有什么特点

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

◆轻量——从大小与开销两方面而言Spring都是轻量的。完整的Spring框架可以在一个大小只有1MB多的JAR文件里发布。并 且Spring所需的处理开销也是微不足道的。此外，Spring是非侵入式的：典型地，Spring应用中的对象不依赖于Spring的特定类。

◆控制反转——Spring通过一种称作控制反转（IoC）的技术促进了松耦 合。当应用了IoC，一个对象依赖的其它对象会通过被动的方式传递进来，而不是这个对象自己创建或者查找依赖对象。你可以认为IoC与JNDI相反——不 是对象从容器中查找依赖，而是容器在对象初始化时不等对象请求就主动将依赖传递给它。
◆面向切面——Spring提供了面向切面编程的丰富支持，允许通过分离应用的 业务逻辑与系统级服务（例如审计（auditing）和事务（）管理）进行内聚性的开发。应用对象只实现它们应该做的——完成业务逻辑——仅此而已。它们 并不负责（甚至是意识）其它的系统级关注点，例如日志或事务支持。
◆容器——Spring包含并管理应用对象的配置和生命周期，在这个意义上它是 一种容器，你可以配置你的每个bean如何被创建——基于一个可配置原型（prototype），你的bean可以创建一个单独的实例或者每次需要时都生 成一个新的实例——以及它们是如何相互关联的。然而，Spring不应该被混同于传统的重量级的EJB容器，它们经常是庞大与笨重的，难以使用。
◆框架——Spring可以将简单的组件配置、组合成为复杂的应用。在Spring中，应用对象被声明式地组合，典型地是在一个XML文件里。Spring也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。

四十三、

主题：spring面试题 对DI , AOP概念的理解

今天有一哥们去面试 ，哥们说自己会ssh
面试官就问了几个spring的概念性的问题 ，哥们平时只专注于写代码，回来后一脸的无奈

本人总结了一些ssh常见的面试题 例举如下
强调在回答的时候不要光回答概念，要思维扩散性的讲些相关的东西

spring 的优点？
1.降低了组件之间的耦合性 ，实现了软件各层之间的解耦
2.可以使用容易提供的众多服务，如事务管理，消息服务等
3.容器提供单例模式支持
4.容器提供了AOP技术，利用它很容易实现如权限拦截，运行期监控等功能
5.容器提供了众多的辅助类，能加快应用的开发
6.spring对于主流的应用框架提供了集成支持，如hibernate，JPA，Struts等
7.spring属于低侵入式设计，代码的污染极低
8.独立于各种应用服务器
9.spring的DI机制降低了业务对象替换的复杂性
10.Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可以自由选择spring的部分或全部

什么是DI机制？
依赖注入（Dependecy Injection）和控制反转（Inversion of Control）是同一个概念，具体的讲：当某个角色
需要另外一个角色协助的时候，在传统的程序设计过程中，通常由调用者来创建被调用者的实例。但在spring中
创建被调用者的工作不再由调用者来完成，因此称为控制反转。创建被调用者的工作由spring来完成，然后注入调用者
因此也称为依赖注入。
spring以动态灵活的方式来管理对象 ， 注入的两种方式，设置注入和构造注入。
设置注入的优点：直观，自然
构造注入的优点：可以在构造器中决定依赖关系的顺序。

什么是AOP？
面向切面编程（AOP）完善spring的依赖注入（DI），面向切面编程在spring中主要表现为两个方面
1.面向切面编程提供声明式事务管理
2.spring支持用户自定义的切面

面向切面编程（aop）是对面向对象编程（oop）的补充，
面向对象编程将程序分解成各个层次的对象，面向切面编程将程序运行过程分解成各个切面。
AOP从程序运行角度考虑程序的结构，提取业务处理过程的切面，oop是静态的抽象，aop是动态的抽象，
是对应用执行过程中的步骤进行抽象，，从而获得步骤之间的逻辑划分。

aop框架具有的两个特征：
1.各个步骤之间的良好隔离性
2.源代码无关性

四十四、1.我所知道的aop
初看aop,上来就是一大堆术语，而且还有个拉风的名字，面向切面编程，都说是OOP的一种有益补充等等。一下子让你不知所措，心想着：怪不得很多人都和我说aop多难多难。当我看进去以后，我才发现：它就是一些java基础上的朴实无华的应用，包括ioc，包括许许多多这样的名词，都是万变不离其宗而已。
2.为什么用aop
1就是为了方便，看一个国外很有名的大师说，编程的人都是“懒人”，因为他把自己做的事情都让程序做了。用了aop能让你少写很多代码，这点就够充分了吧
2就是为了更清晰的逻辑，可以让你的业务逻辑去关注自己本身的业务，而不去想一些其他的事情，这些其他的事情包括：安全，事物，日志等。
3.那些aop的术语
初看这么多术语，一下子都不好接受，慢慢来，很快就会搞懂。
1.通知（Advice）
就是你想要的功能，也就是上面说的 安全，事物，日志等。你给先定义好把，然后在想用的地方用一下。
2.连接点（JoinPoint）
这个更好解释了，就是spring允许你使用通知的地方，那可真就多了，基本每个方法的前，后（两者都有也行），或抛出异常时都可以是连接点，spring只支持方法连接点.其他如aspectJ还可以让你在构造器或属性注入时都行，不过那不是咱关注的，只要记住，和方法有关的前前后后（抛出异常），都是连接点。
3.切入点（Pointcut）
上面说的连接点的基础上，来定义切入点，你的一个类里，有15个方法，那就有几十个连接点了对把，但是你并不想在所有方法附近都使用通知（使用叫织入，以后再说），你只想让其中的几个，在调用这几个方法之前，之后或者抛出异常时干点什么，那么就用切点来定义这几个方法，让切点来筛选连接点，选中那几个你想要的方法。
4.切面（Aspect）
切面是通知和切入点的结合。现在发现了吧，没连接点什么事情，连接点就是为了让你好理解切点，搞出来的，明白这个概念就行了。通知说明了干什么和什么时候干（什么时候通过方法名中的before,after，around等就能知道），而切入点说明了在哪干（指定到底是哪个方法），这就是一个完整的切面定义。
5.引入（introduction）
允许我们向现有的类添加新方法属性。这不就是把切面（也就是新方法属性：通知定义的）用到目标类中吗
6.目标（target）
引入中所提到的目标类，也就是要被通知的对象，也就是真正的业务逻辑，他可以在毫不知情的情况下，被咱们织入切面。而自己专注于业务本身的逻辑。
7.代理(proxy)
怎么实现整套aop机制的，都是通过代理，这个一会给细说。
8.织入(weaving)
把切面应用到目标对象来创建新的代理对象的过程。有3种方式，spring采用的是运行时，为什么是运行时，后面解释。
关键就是：切点定义了哪些连接点会得到通知

4.我所理解的aop原理
spring用代理类包裹切面，把他们织入到Spring管理的bean中。也就是说代理类伪装成目标类，它会截取对目标类中方法的调用，让调用者对目标类的调用都先变成调用伪装类，伪装类中就先执行了切面，再把调用转发给真正的目标bean。
现在可以自己想一想，怎么搞出来这个伪装类，才不会被调用者发现（过JVM的检查，JAVA是强类型检查，哪里都要检查类型）。
1.实现和目标类相同的接口，我也实现和你一样的接口，反正上层都是接口级别的调用，这样我就伪装成了和目标类一样的类（实现了同一接口，咱是兄弟了），也就逃过了类型检查，到java运行期的时候，利用多态的后期绑定（所以spring采用运行时），伪装类（代理类）就变成了接口的真正实现，而他里面包裹了真实的那个目标类，最后实现具体功能的还是目标类，只不过伪装类在之前干了点事情（写日志，安全检查，事物等）。
这就好比，一个人让你办件事，每次这个时候，你弟弟就会先出来，当然他分不出来了，以为是你，你这个弟弟虽然办不了这事，但是他知道你能办，所以就答应下来了，并且收了点礼物（写日志），收完礼物了，给把事给人家办了啊，所以你弟弟又找你这个哥哥来了，最后把这是办了的还是你自己。但是你自己并不知道你弟弟已经收礼物了，你只是专心把这件事情做好。

顺着这个思路想，要是本身这个类就没实现一个接口呢，你怎么伪装我，我就压根没有机会让你搞出这个双胞胎的弟弟，那么就用第2种代理方式，创建一个目标类的子类，生个儿子，让儿子伪装我

2.生成子类调用，这次用子类来做为伪装类，当然这样也能逃过JVM的强类型检查，我继承的吗，当然查不出来了，子类重写了目标类的所有方法，当然在这些重写的方法中，不仅实现了目标类的功能，还在这些功能之前，实现了一些其他的（写日志，安全检查，事物等）。
这次的对比就是，儿子先从爸爸那把本事都学会了，所有人都找儿子办事情，但是儿子每次办和爸爸同样的事之前，都要收点小礼物（写日志），然后才去办真正的事。当然爸爸是不知道儿子这么干的了。 这里就有件事情要说，某些本事是爸爸独有的(final的)，儿子学不了，学不了就办不了这件事，办不了这个事情，自然就不能收人家礼了。

前一种兄弟模式，spring会使用JDK的java.lang.reflect.Proxy类，它允许Spring动态生成一个新类来实现必要的接口，织入通知，并且把对这些接口的任何调用都转发到目标类。

后一种父子模式，spring使用CGLIB库生成目标类的一个子类，在创建这个子类的时候，spring织入通知，并且把对这个子类的调用委托到目标类。
相比之下，还是兄弟模式好些，他能更好的实现松耦合，尤其在今天都高喊着面向接口编程的情况下，父子模式只是在没有实现接口的时候，也能织入通知，应当做一种例外。

四十五、我的前一篇文章呢对 JDK 的动态代理说了一番，也花了不少时间来写那边文章。有时候觉得心里的想法要靠笔杆子（键盘）来表达出来，至少说精确表达还是有一定难得的。也许这就是草根阶层的笔民与作家之间的差距吧。 OK ， Whatever 感慨少发。切入正题 :AOP.

有时候我怀疑自己到底是个完美主义者还是个做事慢性子的人，总觉得做什么之前得想好了。先做什么在做什么。比如讲 AOP 吧，估计两篇文章下来都没正经的说给大家写了个 Spring 框架下的小例子，搞几行代码怎么的。可回头想想，代码 – 网上一大堆 ; 例子 — 参考书写的比我周全。我还不如讲点 WHY 少点 HOW 就跟打球一样基本功好了，什么动作都好做。基本功不行，运球过半场都成问题。

先从 AOP 的概念说起吧，我们不再去看 Spring-framework 的参考手册。那些太专业，人家限于篇幅都是以最精辟最简短的词语来写，目的达到了，可问题来了真正有几个人能把 Cross cutting concern Aspect 等等概念说的大众化，普通话。让没接触过 Spring 不知道 Spring 为何物的 JAVA 初学者们一目了然呢？

我们平常所接触的 OOP 都是一个纵向的编程理念，从上往下先做什么后做什么。比如你上网购物，你得先登录然后你在购买，这是一个流程。假如登录时需要安全性检查、事务、记录日志等，（其实这些都不属于我们的业务逻辑）。所以我们就不该把这些不属于业务逻辑的代码散布在业务逻辑类之中。此时我们添加一个横向的编程。等业务逻辑到这一步我们就通过横向方法实现（也是面向切面的实现）。你所需要实现的横向功能（或者说需求吧）就是所谓的 cross cutting concern （横切关注点这个概念比较抽象，谁给大家细说说参考手册中对这个也是很模糊一带而过）。

而 Aspect 就是将 cross cutting concern 模块化，抽取出来形成的一个具体的类。之前你肯能需要在每一个需要进行安全性检查的类中都去自己实现检查，而现在不同。 AOP 将它模块化，所有的安全性检查都交给 Aspect 来做，你的类中就只管实现自己所需要的业务逻辑了从而你的代码清晰，功能明确！有人可能要问了，那我自己写的类怎么调用这些安全性检查呢？答案是： Spring 会帮你实现（不然还那么麻烦用什么框架呢）。想起代理了吗？（我在前一篇文章《从 JDK 动态代理说 Spring 的 AOP 》说的比较详细，可以去看看）。

需要的功能我们抽取出来了 ( 就是说得到切面 Aspect 了 ) ，之后就得去设计具体的方法了（比如需要验证，那我们就写一个验证方法呗）。此时 Advice 就应运而生了，我们在具体的 Aspect 类中去设计具体的方法（也是设计 Advice ，现在应该明白 Advice 的大概了吧其实它就是一个方法。只是 Spring 给它取名曰：通知）。比如我要写一个用验证的安全类 Security （负责所有的验证功能） , 当中有个方法叫 checkSecurity(), 在调用其他方法之前调用它那它就成了前置通知（ before 的概念有了吗？），之后调用就是后置通知（ after ）异常时调用就成（ Throws 通知）。等等 ..

通知设计完之后我们需要调用啊，可是不是所有的方法都需要这一方法（如果不管三七二十一所有方法通过这横切面就需要调用，那效率何在？这不比收费站，你过就得给钱啊。呵呵 有车的朋友应该感受比较深刻），这时就需要进行判断了。判断的依据就是 Pointcut ，比如我只需要对方法名称开头为 add 的方法调用，那此时的 Pointcut 或许就定义为 add* 了。这下该明白什么是 PC 了吧，他就是一套表达式，常用的就支持正则表达式 通过他来进行方法的筛选，类似过滤器。

通知我们设计好了，也进行了筛选了现在就是将刷选的通添加到我的 Target Object 了（这一步 Spring 是通过代理实现的）。这个添加的过程就是所谓的 Weave ， Spring 给了个很酷的名字“织入”。而 TO （目标对象）就是需要调用通知的那个类（暂且说类吧，形象点），而 TO 中那个可以触发通知的方法就是所谓的 JoinPoint 。

为了形象话，我把这一些概念组合起来画了个简单的示意图对照那个看文章会更加容易理解的。（JAVAEYE好像不让传本地图片上来，我就在附件里吧。就是麻烦点了）

说了这么多，其实要真正理解 AOP 还是那两个关键字眼：代理（ Proxy ） . 这个明白了，那就是你熟练与否的问题了。而熟练就是你花时间多少的问题了。

当然，可能说了这么多，写了这么多错误是难免的。若有疏忽之处还望各位指点指点，有什么需要可以给我留言，发邮件什么的。。。奋斗在编程行列的兄弟们（好像 MM 很少哦这一行）努力吧。朋友都说“我们都成宅男了，当然前提是长得帅哦 呵呵（玩笑玩笑）” 看完这个之后你在去对照你的 Spring 开发手册再回过头去看，你会发现会更加的容易理解至少很形象化。

 

四十六、Spring面试题1

1.Spring框架的优点都有什么？

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

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

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

Spring是开源的免费的

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

2.描述一下Spring中实现DI（Dependency Injection）的几种方式

方式一：接口注入，在实际中得到了普遍应用，即使在IOC的概念尚未确立时，这样的方法也已经频繁出现在我们的代码中。
方式二：Type2 IoC: Setter injection对象创建之后，将被依赖对象通过set方法设置进去
方式三：Type3 IoC: Constructor injection对象创建时，被依赖对象以构造方法参数的方式注入
Spring的方式

3.简述你对IoC（Inversion of Control）的理解

一个类需要用到某个接口的方法，我们需要将类A和接口B的实现关联起来，最简单的方法是类A中创建一个对于接口B的实现C的实例，但这种方法显然两者的依赖（Dependency）太大了。而IoC的方法是只在类A中定义好用于关联接口B的实现的方法，将类A，接口B和接口B的实现C放入IoC的 容器（Container）中，通过一定的配置由容器（Container）来实现类A与接口B的实现C的关联。

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

在context中定义DataSource，创建SessionFactoy，设置参数；DAO类继承HibernateDaoSupport，实现具体接口，从中获得HibernateTemplate进行具体操作。在使用中如果遇到OpenSessionInView的问题，可以添加OpenSessionInViewFilter或OpenSessionInViewInterceptor。

5.请介绍一下Spring的事务管理

spring提供了几个关于事务处理的类：
TransactionDefinition //事务属性定义
TranscationStatus //代表了当前的事务，可以提交，回滚。
PlatformTransactionManager这个是spring提供的用于管理事务的基础接口，其下有一个实现的抽象类AbstractPlatformTransactionManager,我们使用的事务管理类例如DataSourceTransactionManager等都是这个类的子类。

一般事务定义步骤：

TransactionDefinition td = new TransactionDefinition();
TransactionStatus ts = transactionManager.getTransaction(td);
try
{ //do sth
transactionManager.commit(ts);
}
catch(Exception e){transactionManager.rollback(ts);}

spring提供的事务管理可以分为两类：编程式的和声明式的。编程式的，比较灵活，但是代码量大，存在重复的代码比较多；声明式的比编程式的更灵活。

编程式主要使用transactionTemplate。省略了部分的提交，回滚，一系列的事务对象定义，需注入事务管理对象.
void add()
{
transactionTemplate.execute( new TransactionCallback(){
pulic Object doInTransaction(TransactionStatus ts)
{ //do sth}
}
}

声明式：

使用TransactionProxyFactoryBean:

PROPAGATION_REQUIRED PROPAGATION_REQUIRED PROPAGATION_REQUIRED,readOnly

围绕Poxy的动态代理 能够自动的提交和回滚事务
org.springframework.transaction.interceptor.TransactionProxyFactoryBean

PROPAGATION_REQUIRED–支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

PROPAGATION_SUPPORTS–支持当前事务，如果当前没有事务，就以非事务方式执行。

PROPAGATION_MANDATORY–支持当前事务，如果当前没有事务，就抛出异常。

PROPAGATION_REQUIRES_NEW–新建事务，如果当前存在事务，把当前事务挂起。

PROPAGATION_NOT_SUPPORTED–以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

PROPAGATION_NEVER–以非事务方式执行，如果当前存在事务，则抛出异常。

PROPAGATION_NESTED–如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。

6.如何在Spring的applicationContext.xml里面使用JNDI而不是datasource?

可以使用”org.springframework.jndi.JndiObjectFactoryBean”来实现。示例如下：


java:comp/env/jdbc/appfuse

7.Spring里面如何配置数据库驱动？

使用”org.springframework.jdbc.datasource.DriverManagerDataSource”数据源来配置数据库驱动。示例如下：


org.hsqldb.jdbcDriver


jdbc:hsqldb:db/appfuse

sa

8.Spring里面applicationContext.xml文件能不能改成其他文件名？

ContextLoaderListener是一个ServletContextListener, 它在你的web应用启动的时候初始化。缺省情况下， 它会在WEB-INF/applicationContext.xml文件找Spring的配置。 你可以通过定义一个元素名字为”contextConfigLocation”来改变Spring配置文件的位置。示例如下：

org.springframework.web.context.ContextLoaderListener

contextConfigLocation
/WEB-INF/xyz.xml

9.如何在web应用里面配置spring?

在J2EE的web应用里面配置spring非常简单，最简单的只需要把spring得ContextLoaderListener添加到你的web.xml文件里面就可以了，示例如下：

org.springframework.web.context.ContextLoaderListener

10.Spring里面如何定义hibernate mapping？

添加hibernate mapping 文件到web/WEB-INF目录下的applicationContext.xml文件里面。示例如下：


org/appfuse/model/User.hbm.xml

 

四十七、spring工作原理：

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

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

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

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

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

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

四十八、

、为什么要用spring:

AOP 让开发人员可以创建非行为性的关注点，称为横切关注点，并将它们插入到应用程序代码中。使用 AOP 后，公共服务   （比 如日志、持久性、事务等）就可以分解成方面并应用到域对象上，同时不会增加域对象的对象模型的复杂性。

IOC 允许创建一个可以构造对象的应用环境，然后向这些对象传递它们的协作对象。正如单词 倒置 所表明的，IOC 就像反      过来的 JNDI。没有使用一堆抽象工厂、服务定位器、单元素（singleton）和直接构造（straight construction），每一个对象都是用     其协作对象构造的。因此是由容器管理协作对象（collaborator）。

Spring即使一个AOP框架，也是一IOC容器。 Spring 最好的地方是它有助于您替换对象。有了 Spring，只要用 JavaBean 属性和配置文件加入依赖性（协作对象）。然后可以很容易地在需要时替换具有类似接口的协作对象。

四十九、

请你谈谈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的事务管理：

事务就是对一系列的数据库操作（比如插入多条数据）进行统一的提交或回滚操作，如果插入成功，那么一起成功，如果中间有一条出现异常，那么回滚之前的所有操作。

这样可以防止出现脏数据，防止数据库数据出现问题。

开发中为了避免这种情况一般都会进行事务管理。Spring中也有自己的事务管理机制，一般是使用TransactionMananger进行管理，可以通过Spring的注入来完成此功能。

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

TransactionDefinition //事务属性定义

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

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

一般事务定义步骤：

TransactionDefinition td = new TransactionDefinition();

TransactionStatus ts = transactionManager.getTransaction(td);

try

{ //do sth

transactionManager.commit(ts);

}

catch(Exception e){transactionManager.rollback(ts);}

spring提供的事务管理可以分为两类：编程式的和声明式的。编程式的，比较灵活，但是代码量大，存在重复的代码比较多；声明式的比编程式的更灵活。

编程式主要使用transactionTemplate。省略了部分的提交，回滚，一系列的事务对象定义，需注入事务管理对象.

void add(){

transactionTemplate.execute( new TransactionCallback(){

pulic Object doInTransaction(TransactionStatus ts)

{ //do sth}

}

}

声明式：

使用TransactionProxyFactoryBean:

PROPAGATION_REQUIRED PROPAGATION_REQUIRED PROPAGATION_REQUIRED,readOnly

围绕Poxy的动态代理 能够自动的提交和回滚事务

org.springframework.transaction.interceptor.TransactionProxyFactoryBean

PROPAGATION_REQUIRED–支持当前事务，如果当前没有事务，就新建一个事务。这是最常见的选择。

PROPAGATION_SUPPORTS–支持当前事务，如果当前没有事务，就以非事务方式执行。

PROPAGATION_MANDATORY–支持当前事务，如果当前没有事务，就抛出异常。

PROPAGATION_REQUIRES_NEW–新建事务，如果当前存在事务，把当前事务挂起。

PROPAGATION_NOT_SUPPORTED–以非事务方式执行操作，如果当前存在事务，就把当前事务挂起。

PROPAGATION_NEVER–以非事务方式执行，如果当前存在事务，则抛出异常。

PROPAGATION_NESTED–如果当前存在事务，则在嵌套事务内执行。如果当前没有事务，则进行与PROPAGATION_REQUIRED类似的操作。

五、Spring里面如何配置数据库驱动？

使用”org.springframework.jdbc.datasource.DriverManagerDataSource”数据源来配置数据库驱动。示例如下：

org.hsqldb.jdbcDriver

jdbc:hsqldb:db/appfuse

sa