java面试题之ssh

1、写出你熟悉的开源框架以及各自的作用(项目中为什么使用SSH)

答：框架：hibernate,spring,struts1/struts2. Hibernate主要用于数据持久化；封装了JDBC操作；还提供了一个易用的、高效率的对象关系映射框架； Spring 的控制反转能起到解耦合的作用； Struts 主要用于请求处理的流程控制；struts是基于MVC模式的,很好的将应用程序进行了分层，使开发者更关注于业务逻辑的实现；struts有着丰富的taglib,如能灵活运用，则能大大提高开发效率。

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

struts相关

2、简述STRUTS架构(说下Struts的工作流程、struts的工作原理)

简述：

Struts是采用Java Servlet/JavaServer Pages技术，开发Web应用程序的开放源码的framework。采用Struts能开发出基于MVC(Model-View-Controller)设计模式的应用构架。 Struts有如下的主要功能：一.包含一个controller servlet，能将用户的请求发送到相应的Action对象。二.JSP*tag库，并且在controller servlet中提供关联支持，帮助开发员创建交互式表单应用。三.提供了一系列实用对象：XML处理、通过Java reflection APIs自动处理JavaBeans属性、国际化的提示和消息。

流程：

在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组件生成动态网页,返回给客户;

3、Struts对MVC的体现 M: 在Struts中,模型由JavaBean和EJB组件组成,用来实现程序的业务逻辑部分. C: ActionServlet,RequestProcessor和Struts辅助类来实现控制器。ActionServlet是Struts中的核心控制器ActionServlet会根据在Struts配置文件中的配置将控制权转交给相应的Action类。Action 类是业务的代理,在Action类中可以调用模型组件或者编写其他业务逻辑代码来完成一项具体的业务。 V: Struts框架中的视图主要由JSP文件构成,在JSP文件中可应用Struts标签和自定义标签来表现模型组件中的数据进行简单的处理。ActionForm Bean实际上是一个遵循了特殊约定的JavaBean,在Struts中ActionForm Bean可看作为一个中间存储器在视图与控制器之间进行数据传递。

4、struts1.2和struts2.0的区别？ a、Action类： struts1.2要求Action类继承一个基类。struts2.0 Action可以是简单的JOPO对象或者（都会）继承ActionSupport基类 b、线程模式 struts1.2 Action是单例模式的并且必须是线程安全的,因为仅有一个Action的实例来处理所有的请求。 单例策略限制了Struts1.2 Action能做的事情,并且开发时特别小心。Action资源必须是线程安全的或同步的。 struts2.0 Action为每一个请求产生一个实例,因此没有线程安全问题。 c、Servlet依赖 struts1.2 Action依赖于Servlet API,因为当一个Action被调用时HttpServletRequest和HttpServletResponse被传递给execut方法。 struts2.0 Action不依赖于容器,允许Action脱离容器单独测试。如果需要,Struts2 Action仍然可以访问初始的Request和Response。 但是,其他的元素减少或者消除了直接访问HttpServletRequest和HttpServletResponse的必要性。 d、可测性 测试struts1.2 Action的一个主要问题是execute方法暴露了Servlet API(这使得测试要依赖于容器)。一个第三方扩展：struts TestCase 提供了一套struts1.2的模拟对象来进行测试。 Struts2.0 Action可以通过初始化、设置属性、调用方法来测试,“依赖注入”也使得测试更容易。

5、struts如何实现国际化

以下以两国语言(中文，英文)为例： 1. 在工程中加入Struts支持 2. 编辑ApplicationResource.properties文件,在其中加入要使用国际化的信息, 例如： lable.welcome.china=Welcome!!! 3. 创建英文资源文件ApplicationResource_en.properites 4. 创建临时中文资源文件ApplicationResource_temp.properites 例如：lable.welcom.china=中国欢迎您! 5. 对临时中文资源文件进行编码转换。可以使用myeclipse的插件,也可以在dos下执行: native2ascii -encoding gb2312 ApplicationResource_temp.properties ApplicationResource_zh_CN.properties 6. 在jsp中加入struts的bean标记库

6、 Struts框架的数据验证可分为几种类型？

表单验证（由ActionForm Bean处理）：如果用户没有在表单中输入姓名，就提交表单，将生成表单验证错误

业务逻辑验证（由Action处理）：如果用户在表单中输入的姓名为“Monster”，按照本应用的业务规则，不允许向“Monster”打招呼，因此将生成业务逻辑错误。

7、简述Form Bean的表单验证流程。

1、当用户提交了HTML表单，Struts框架自动把表单数据组装到ActionForm Bean中。

2、接下来Struts框架会调用ActionForm Bean的validate()方法进行表单验证。

3、如果validate()方法返回的ActionErrors 对象为null，或者不包含任何ActionMessage对象，就表示没有错误，数据验证通过。

4、如果ActionErrors中包含ActionMessage对象，就表示发生了验证错误，Struts框架会把ActionErrors对象保存到request范围内，然后把请求转发到恰当的视图组件，视图组件通过<html:errors>标签把request范围内的ActionErrors对象中包含的错误消息显示出来，提示用户修改错误。

8、简单叙述ActionForm Bean的作用

1、ActionForm Bean也是一种JavaBean，除了具有一些JavaBean的常规方法，还包含一些特殊的方法，用于验证HTML表单数据以及将其属性重新设置为默认值。

2、Struts框架利用ActionForm Bean来进行View组件和Controller组件之间表单数据的传递。

3、Struts框架把View组件接受到的用户输入的表单数据保存在ActionForm Bean中，把它传递给Controller组件，Controller组件可以对ActionForm Bean中的数据进行修改JSP文件使用Struts标签读取修改后的ActionForm Bean的信息，重新设置HTML表单。

9、Struts优缺点 优点：

1. 实现MVC模式，结构清晰,使开发者只关注业务逻辑的实现. 2．有丰富的tag可以用 ,Struts的标记库(Taglib)，如能灵活动用，则能大大提高开发效率 3. 页面导航 使系统的脉络更加清晰。通过一个配置文件，即可把握整个系统各部分之间的联系，这对于后期的维护有着莫大的好处。尤其是当另一批开发者接手这个项目时，这种优势体现得更加明显。 4. 提供Exception处理机制 . 5. 数据库链接池管理 6. 支持I18N 缺点 一、转到展示层时，需要配置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这种事件方式称为application event，application event和component event相比是一种粗粒度的事件

Hibernate相关

1、Hibernate框架的认识（工作原理）

Hibernate是一个轻量级的持久层开源框架,它是连接Java应用程序和关系数据库的中间件,负责Java对象和关系数据之间的映射. Hibernate内部对JDBC API进行了封装,负责Java对象的持久化. 因为它封装了所有的数据访问细节,使得业务逻辑层可以专注于实现业务逻辑. 它是一种优秀的ORM映射工具,提供了完善的对象－关系映射服务,开发过程不依赖容器,灵活性非常大,可以无缝集成到任何一个java系统中

2、 为什么要用Hibernate

1. 封装了jdbc,简化了很多重复性代码。

2. 简化了DAO层编码工作,使开发更对象化了。

3. 移植性好,支持各种数据库,如果换个数据库只要在配置文件中变换配置就可以了,不用改变hibernate代码。

4. 支持透明持久化,因为hibernate操作的是纯粹的(pojo)java类,没有实现任何接口,没有侵入性。所以说它是一个轻量级框架。

3、缓存:

session缓存:被称为Hibernate的第一级缓存.

1）Session内置不能被卸载，Session的缓存是事务范围的缓存（Session对象的生命周期通常对应一个数据库事务或者一个应用事务）。

一级缓存中，持久化类的每个实例都具有唯一的OID。

2）hibernate是一个线程对应一个session，一个线程可以看成一个用户。也就是说session级缓存(一级缓存)只能给一个线程用，别的线程用不了，一级缓存就是和线程绑定了。

缓存主要是用于查询，在同一个session中，第二次查询第一次相同的数据，第二次不会发出sql语句查询数据库，而是到缓存里取数据。

3）大批量数据添加时，会造成内存溢出的，因为save方法支持缓存，每save一个对象就往缓存里放，如果对象足够多内存肯定要溢出。一般的做法是先判断一下save了多少个对象，如果save了20个对象就对缓存手动的清理缓存，这样就不会造成内存溢出。

sessionFactory缓存: 被称为Hibernate的第二级缓存.一个实例对应一个数据存储源.它是共享的，线程安全的,是重量级的. 它需要一个很大的缓存,用来存放预定义的SQL语句以及映射元数据等.使用时需要配置

Hibernate 缓存只缓存实体对象 不缓存普通属性

4、对象的3个状态

瞬时transient：一个实体通过new操作符创建后，没有和Hibernate的Session建立关系， 也没有手动赋值过该实体的持久化标识（持久化标识可以认为映射表的主键）。 此时该实体中的任何属性的更新都不会反映到数据库表中。

持久态persistent：

例如：在service层可以实现更新数据库数据

Syuser syuser=userDao.get(Syuser.class, user.getId());

syuser.setName(user.getName());

persistent状态的对象被纳入了session管理，session就相当于Hibernate的一个缓冲区，被纳入session 管理的对象（持久化对象）时刻被hibernate所监视，persistent态的对象属性一旦发生改变，就会被 hibernate察觉，并会生成相应的sql语句（但并未立即与数据库交互），当session提交时，hibernate会 清理缓存（也叫脏数据检查），这时候就会和数据库同步（通过底层的JDBC与数据库交互）。

注释：hibernate清理缓存的方式，是采用快照比对的方式（持久化对象的每次变动都会被记录下来）

脱管detached：

detached状态的对象，数据库中存在，但未被纳入session管理。 如果对detached状态的对象加以修改，那么就还得将其纳入一个新的session对象管理，并且还要显示的 update（），update后的对象又成为了persistent状态了

detached状态的对象是如何产生的呢？

有两种方式：

1）对象被纳入session管理后，此session清空或者关闭时，这是的对象就称为detached态了

2）可手动的构造detached态的对象，通过new操作，new出来的对象，手动setId（）将id设成数据库中 已经存在的，这时的对象也是detached状态的。（一般不建议采用此法）

5、性能问题

在批操作性能和cache之间存在不可调和的矛盾， 你要熟悉hibernate一级和二级缓存机制才能写出合理批操作代码， 否则不但性能低下，还可能导致out memory。 hibernate reference文档中的Best practise也提到， Use hand-coded JDBC in bottlenecks， 也就是说在某些性能瓶颈的地方考虑使用硬编码jdbc。

（缓存使用的是内存。大批量操作时有可能会导致内存溢出，大批量可采用jdbc）

6、JDBC,Hibernate,EJB三者的区别?

EJB:我们必须遵守复杂的J2EE规范,Hibernate不强迫必须满足特定的规范. EJB只能运行在EJB容器中,Hibernate可以运行在任何java环境中. 目前,对于复杂的域模型,EJB容器提供的对象-关系映射能力有限.相比之下,Hibernate提供了完善的对象-关系映射服务. EJB虽然是一种可以移植的组件,但是实际上却受到很大的限制,因为各个产商生产CMP引擎差异,它们使用的对象-关系映射 元数据各不相同,使得EJB不能顺利的从一个EJB容器移植到另一个EJB容器当中.而Hibernate可以无缝集成到任何一个Java系统中.

JDBC:实现业务逻辑的代码和访问数据库的代码混杂在一起,使程序结构不清晰,可读性差

7、get和load的区别

1>get直接返回实体类，不存在则返回null，不会报错。

2>load返回的是代理对象(javassist.jar生成二进制码)，等代理对象被调用时，才会发出select语句。如果不存在则抛出异常（懒加载的原因，可以配置）

3>都会首先查找一级缓存（session缓存），再去查二级缓存（需要配置），最后去数据库查找。调用clear()方法，可以强制清除

4>不确定是否存在用get，确定有用load

8、Hibernate是如何延迟加载?

1. Hibernate2延迟加载实现：

a)实体对象

通过将class的lazy属性设置为true，来开启实体的延迟加载特性。如果我们运行下面的代码：

User user=(User)session.load(User.class,”1”);（1）

System.out.println(user.getName());（2）

当运行到(1)处时，Hibernate并没有发起对数据的查询，返回的是实体对象的代理类对象。在Hibernate中通过使用CGLIB,来实现动态构造一个目标对象的代理类对象，并且在代理类对象中包含目标对象的所有属性和方法，而且所有属性均被赋值为null。通过调试器显示的内存快照，我们可以看出此时真正的User对象，是包含在代理对象的CGLIB$CALBACK_0.target属性中。

当代码运行到（2）处时，此时调用user.getName()方法，这时通过CGLIB赋予的回调机制，实际上调用CGLIB$CALBACK_0.getName()方法，当调用该方法时，Hibernate会首先检查CGLIB$CALBACK_0.target属性是否为null，如果不为空，则调用目标对象的getName方法，如果为空，则会发起数据库查询。

这样，通过一个中间代理对象，Hibernate实现了实体的延迟加载，只有当用户真正发起获得实体对象属性的动作时，才真正会发起数据库查询操作。所以实体的延迟加载是用通过中间代理类完成的，所以只有session.load()方法才会利用实体延迟加载，因为只有session.load()方法才会返回实体类的代理类对象。

b)集合（Collection）

在Hibernate的延迟加载机制中，针对集合类型的应用，意义是最为重大的，因为这有可能使性能得到大幅度的提高，为此Hibernate进行了大量的努力，其中包括对JDK Collection的独立实现，我们在一对多关联中，定义的用来容纳关联对象的Set集合，并不是java.util.Set类型或其子类型，而是net.sf.hibernate.collection.Set类型，通过使用自定义集合类的实现，Hibernate实现了集合类型的延迟加载。为了对集合类型使用延迟加载，我们必须如下配置我们的实体类的关于关联的部分：

<hibernate-mapping>

<class name=”com.neusoft.entity.User” table=”user”>

…..

<set name=”addresses” table=”address” lazy=”true” inverse=”true”>

<key column=”user_id”/>

<one-to-many class=”com.neusoft.entity.Arrderss”/>

</set>

</class>

</hibernate-mapping>

通过将<set>元素的lazy属性设置为true来开启集合类型的延迟加载特性。我们看下面的代码：

User user=(User)session.load(User.class,”1”);

Collection addset=user.getAddresses();       (1)

Iterator it=addset.iterator();                (2)

while(it.hasNext()){

Address address=(Address)it.next();

System.out.println(address.getAddress());

}

当程序执行到(1)处时，这时并不会发起对关联数据的查询来加载关联数据，只有运行到(2)处时，真正的数据读取操作才会开始，这时Hibernate会根据缓存中符合条件的数据索引，来查找符合条件的实体对象。

这里我们引入了一个全新的概念——数据索引，下面我们首先将接一下什么是数据索引。在Hibernate中对集合类型进行缓存时，是分两部分进行缓存的，首先缓存集合中所有实体的id列表，然后缓存实体对象，这些实体对象的id列表，就是所谓的数据索引。当查找数据索引时，如果没有找到对应的数据索引，这时就会一条select SQL的执行，获得符合条件的数据，并构造实体对象集合和数据索引，然后返回实体对象的集合，并且将实体对象和数据索引纳入Hibernate的缓存之中。另一方面，如果找到对应的数据索引，则从数据索引中取出id列表，然后根据id在缓存中查找对应的实体，如果找到就从缓存中返回，如果没有找到，在发起select SQL查询。

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

9、如何对hibernate进行优化？

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

2. 灵活使用单向一对多关联

3. 不用一对一，用多对一取代

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

5. 一对多集合使用Bag,多对多集合使用Set

6. 继承类使用显式多态

7. 表字段要少，表关联不要怕多，有二级缓存

10、 hibernate的核心类是什么,它们的相互关系是什么?重要的方法是什么?

Configuration 接口:

配置Hibernate,根据其启动hibernate,创建SessionFactory 对象;

SessionFactory 接口:

初始化Hibernate,充当数据存储源的代理,创建session 对象,sessionFactory 是线程安全的,意味着它的同一个实例可以被应用的多个线程共享,是重量级、二级缓存;

获取session

sf.getcurrentSession() :获取和当前线程绑定的session（利于控制事务），会自动关闭。如果当前的session为空，会调用opensession（）

sf.opensession():获取最新的session，必须手动关闭。

Session 接口:

负责保存、更新、删除、加载和查询对象,是线程不安全的,避免多个线程共享同一个session,是轻量级、一级缓存;

Session如下方法: save,load,update,delete, Query q=CreateQuery(“from Customer where customerName=:customerName”) beginTransaction, close, transaction, commit

Transaction 接口:管理事务; Query 和Criteria 接口:执行数据库的查询。

Spring相关

1、Spring的理解

Spring是一个轻量级的容器,非侵入性的框架.最重要的核心概念是IOC,并提供AOP概念的实现方式,提供对持久层,事务的支持,对当前流行的一些框架(Struts,Hibernate,MVC),Sping也提供了与它们的相整合的方案. 使用Spring,我们能够减少类之间的依赖性和程序之间的耦合度,最大程度的实现松耦合,使程序更加灵活,可扩展性更强.

IOC,中文翻译为"反转控制,".DI->;"依赖注入"指的是：我们不必自己在程序代码中维护对象的依赖关系,而是通过一个xml配置文件,将类的属性和实例悄悄的注入到类里面.实现类的动态加载,使得类和类之间可以方便的切换(通过接口).

这种设计方式的思想表现为:高层模块不应该依赖低层模块,而是模块都必须依赖于抽象.程序不应改依赖于实现,而是依赖于抽象接口.应用程序不要去找容器,而是容器给我们所有想要的对象.

Spring的另一个重要的方面是支持AOP的实现: AOP的中文翻译是:面向切面编程.

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

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

2、Spring 注解

Spring 2.5 中除了提供 @Component 注释外，还定义了几个拥有特殊语义的注释，它们分别是：@Repository、@Service 和 @Controller。在目前的 Spring 版本中，这 3 个注释和 @Component 是等效的，但是从注释类的命名上，很容易看出这 3 个注释分别和持久层、业务层和控制层（Web 层）相对应。虽然目前这 3 个注释和 @Component 相比没有什么新意，但 Spring 将在以后的版本中为它们添加特殊的功能。所以，如果 Web 应用程序采用了经典的三层分层结构的话，最好在持久层、业务层和控制层分别采用 @Repository、@Service 和 @Controller 对分层中的类进行注释，而用 @Component 对那些比较中立的类进行注释。

在一个稍大的项目中，通常会有上百个组件，如果这些组件采用xml的bean定义来配置，显然会增加配置文件的体积，查找以及维护起来也不太方便。 Spring2.5为我们引入了组件自动扫描机制，他可以在类路径底下寻找标注了 @Component,@Service,@Controller,@Repository注解的类，并把这些类纳入进spring容器中管理。它的作用和在xml文件中使用bean节点配置组件时一样的。

@Service用于标注业务层组件， @Controller用于标注控制层组件（如struts中的action）, @Repository用于标注数据访问组件，即DAO组件， @Component泛指组件，当组件不好归类的时候，我们可以使用这个注解进行标注。

3、spring 的优点都有哪些？

.ioc 解耦，提高了代码的复用性，管理对象的生命周期，不会造成对象重复创建的过程，节省了jvm的内存消耗，对事物的管理，提供了对很多其他框架的支持

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

使用”org.springframework.jdbc.datasource.DriverManagerDataSource”数据源来配置数据库驱动。

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

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

org.springframework.web.context.ContextLoaderListener contextConfigLocation /WEB-INF/xyz.xml

6、AOP里面重要的几个名词概念解释

切面（Aspect）：一个关注点的模块化，这个关注点可能会横切多个对象。事务管理是J2EE应用中一个关于横切关注点的很好的例子。 在Spring AOP中，切面可以使用通用类（基于模式的风格） 或者在普通类中以 @Aspect 注解（@AspectJ风格）来实现。

连接点（Joinpoint）： 在程序执行过程中某个特定的点，比如某方法调用的时候或者处理异常的时候。 在Spring AOP中，一个连接点 总是 代表一个方法的执行。通过声明一个org.aspectj.lang.JoinPoint类型的参数可以使通知（Advice）的主体部分获得连接点信息。

通知（Advice）：在切面的某个特定的连接点（Joinpoint）上执行的动作。通知有各种类型，其中包括“around”、“before”和“after”等通知。通知的类型将在后面部分进行讨论。许多AOP框架，包括Spring，都是以拦截器做通知模型，并维护一个以连接点为中心的拦截器链。

切入点（Pointcut）：匹配连接点（Joinpoint）的断言。通知和一个切入点表达式关联，并在满足这个切入点的连接点上运行（例如，当执行某个特定名称的方法时）。切入点表达式如何和连接点匹配是AOP的核心：Spring缺省使用AspectJ切入点语法。

引入（Introduction）： （也被称为内部类型声明（inter-type declaration））。声明额外的方法或者某个类型的字段。 Spring允许引入新的接口（以及一个对应的实现）到任何被代理的对象。例如，你可以使用一个引入来使bean实现 IsModified 接口，以便简化缓存机制。

目标对象（Target Object）： 被一个或者多个切面（aspect）所通知（advise）的对象。也有人把它叫做被通知（advised） 对象。 既然Spring AOP是通过运行时代理实现的，这个对象永远是一个 被代理（proxied）对象。

AOP代理（AOP Proxy）： AOP框架创建的对象，用来实现切面契约（aspect contract）（包括通知方法执行等功能）。 在Spring中，AOP代理可以是JDK动态代理或者CGLIB代理。注意：Spring 2.0最新引入的基于模式（schema-based）风格和@AspectJ注解风格的切面声明，对于使用这些风格的用户来说，代理的创建是透明的。

织入（Weaving）： 把切面（aspect）连接到其它的应用程序类型或者对象上，并创建一个被通知（advised）的对象。这些可以在编译时（例如使用AspectJ编译器），类加载时和运行时完成。 Spring和其他纯Java AOP框架一样，在运行时完成织入。

通知的类型：

前置通知（Before advice）： 在某连接点（join point）之前执行的通知，但这个通知不能阻止连接点前的执行（除非它抛出一个异常）。

返回后通知（After returning advice）： 在某连接点（join point）正常完成后执行的通知：例如，一个方法没有抛出任何异常，正常返回。

抛出异常后通知（After throwing advice）： 在方法抛出异常退出时执行的通知。

后通知（After (finally) advice）： 当某连接点退出的时候执行的通知（不论是正常返回还是异常退出）。

环绕通知（Around Advice）： 包围一个连接点（join point）的通知，如方法调用。这是最强大的一种通知类型。环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。

环绕通知是最常用的一种通知类型。大部分基于拦截的AOP框架，例如Nanning和JBoss4，都只提供环绕通知。

切入点（pointcut）和连接点（join point）匹配的概念是AOP的关键，这使得AOP不同于其它仅仅提供拦截功能的旧技术。切入点使得定位通知（advice）可独立于OO层次。例如，一个提供声明式事务管理的around通知可以被应用到一组横跨多个对象中的方法上（例如服务层的所有业务操作）。

ioc：

ioc就是将创建对象的权利交给spring去管理 这里边涉及到的就是什么时候创建xml里的bean也就是懒加载。

反射，单例，动态代理，工厂