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也提供了很多基础功能（事务管理、持久化框架集成等等），将应用逻辑的开发留给了你。

  • 核心技术 IoC 和 AOP
    • 数据访问 （持久层解决方案）
    • Web层解决方案 SpringMVC
    • 集成 （整合其他开源框架）

⚫ Spring 主要核心是：
(1)控制反转(IOC)：传统的 java 开发模式中，当需要一个对象时，我们会自己使用 new 或者
getInstance 等直接或者间接调用构造方法创建一个对象，而在 Spring 开发模式中，Spring
容器使用了工厂模式为我们创建了所需要的对象，我们使用时不需要自己去创建，直接调用
Spring 为我们提供的对象即可，这就是控制反转的思想。实例化一个 java 对象有三种方式：
使用类构造器，使用静态工厂方法，使用实例工厂方法，当使用 spring 时我们就不需要关心
通过何种方式实例化一个对象，spring 通过控制反转机制自动为我们实例化一个对象。
(2)依赖注入(DI)：Spring 使用 Java Bean 对象的 Set 方法或者带参数的构造方法为我们在创
建所需对象时将其属性自动设置所需要的值的过程就是依赖注入的基本思想。
(3)面向切面编程(AOP)：在面向对象编程(OOP)思想中，我们将事物纵向抽象成一个个的对
象。而在面向切面编程中，我们将一个个对象某些类似的方面横向抽象成一个切面，对这个
切面进行一些如权限验证，事物管理，记录日志等公用操作处理的过程就是面向切面编程的
思想。
在 Spring 中，所有管理的对象都是 JavaBean 对象，而 BeanFactory 和 ApplicationContext 就 是spring框架的两个IOC 容器，现在一般使用ApplicationContext，其不但包含了BeanFactory
的作用，同时还进行更多的扩展。

⚫ 谈谈你对Spring的理解
spring的出现是为了解耦，传统程序设计，我们直接在对象内部通过new进⾏创
建对象或者getInstance等直接或者间接调⽤构造⽅法创建⼀个对象，这样各个
层的耦合性较⾼，要知道java语⾔可是⾼内聚，低耦合的；但是在Spring开发模
式中，Spring容器使⽤了⼯⼚模式为我们创建了所需要的对象（这个过程就是DI
通过setter⽅法在配置中注⼊对象），我们使⽤时不需要⾃⼰去创建，直接调⽤
Spring为我们提供的对象即可，这就是控制反转的思想。实例化⼀个java对象有
三种⽅式：使⽤类构造器，使⽤静态⼯⼚⽅法，使⽤实例⼯⼚⽅法，当使⽤
spring时我们就不需要关⼼通过何种⽅式实例化⼀个对象，spring通过控制反转
机制⾃动为我们实例化⼀个对象。

⚫ 使⽤Spring框架的好处是什么？
轻量：Spring 是轻量的，基本的版本⼤约2MB。
控制反转：Spring通过控制反转实现了松散耦合，对象们给出它们的依赖，
⽽不是创建或查找依赖的对象们。
⾯向切⾯的编程(AOP)：Spring⽀持⾯向切⾯的编程，并且把应⽤业务逻辑
和系统服务分开。
容器：Spring 包含并管理应⽤中对象的⽣命周期和配置。
MVC框架：Spring的WEB框架是个精⼼设计的框架，是Web框架的⼀个很
好的替代品。
事务管理：Spring 提供⼀个持续的事务管理接⼝，可以扩展到上⾄本地事
务下⾄全局事务（JTA）。
异常处理：Spring 提供⽅便的API把具体技术相关的异常（⽐如由JDBC，
Hibernate or JDO抛出的）转化为⼀致的unchecked 异常。
⚫ Spring由哪些模块组成?
以下是Spring 框架的基本模块：
Core module
Bean module
Context module
Expression Language module
JDBC module
ORM module
OXM module
Java Messaging Service(JMS) module
Transaction module
Web module
Web-Servlet module
Web-Struts module
Web-Portlet module
⚫ 核⼼容器（应⽤上下⽂) 模块。
这是基本的Spring模块，提供spring 框架的基础功能，BeanFactory 是 任何以
spring为基础的应⽤的核⼼。Spring 框架建⽴在此模块之上，它使Spring成为⼀个
容器。
⚫ BeanFactory – BeanFactory 实现举例。
Bean ⼯⼚是⼯⼚模式的⼀个实现，提供了控制反转功能，⽤来把应⽤的配置和依
赖从正真的应⽤代码中分离。
最常⽤的BeanFactory 实现是XmlBeanFactory 类。
⚫ XMLBeanFactory
最常⽤的就是org.springframework.beans.factory.xml.XmlBeanFactory ，它根据
XML⽂件中的定义加载beans。该容器从XML ⽂件读取配置元数据并⽤它去创建
⼀个完全配置的系统或应⽤。

⚫ 解释对象/关系映射集成模块。
Spring 通过提供ORM模块，⽀持我们在直接JDBC之上使⽤⼀个对象/关系映射映
射(ORM)⼯具，Spring ⽀持集成主流的ORM框 架，如Hiberate,JDO和 iBATIS
SQL Maps。Spring的事务管理同样⽀持以上所有ORM框架及JDBC。
⚫ 解释WEB 模块。
Spring的WEB模块是构建在application context 模块基础之上，提供⼀个适合web
应⽤的上下⽂。这个模块也包括⽀持多 种⾯向web的任务，如透明地处理多个⽂
件上传请求和程序级请求参数的绑定到你的业务对象。它也有对Jakarta Struts的
⽀持。
⚫ Spring配置⽂件
Spring配置⽂件是个XML ⽂件，这个⽂件包含了类信息，描述了如何配置它们，
以及如何相互调⽤。
⚫ 什么是Spring IOC 容器？
答：1、IOC就是控制反转，是指创建对象的控制权的转移，以前创建对象的主动
权在⾃⼰⼿⾥，现在将这种权利交给了Spring容器，并由Spring的配置⽂件来创
建实例并管理各个实例之间的依赖关系，有利于对象的松散关系。
⚫ IOC的优点是什么？
IOC 或 依赖注⼊把应⽤的代码量降到最低。它使应⽤容易测试，单元测试不再需
要单例和JNDI查找机制。最⼩的代价和最⼩的侵⼊性使松散耦合得以实现。IOC
容器⽀持加载服务时的饿汉式初始化和懒加载。
⚫ Spring中IOC的作⽤与原理？对象创建的过程。
15. ApplicationContext通常的实现是什么?
FileSystemXmlApplicationContext ：此容器从⼀个XML⽂件中加载
beans的定义，XML Bean 配置⽂件的全路径名必须提供给它的构造函数。
ClassPathXmlApplicationContext：此容器也从⼀个XML⽂件中加载
beans的定义，这⾥，你需要正确设置classpath因为这个容器将在classpath
⾥找bean配置。
WebXmlApplicationContext：此容器加载⼀个XML⽂件，此⽂件定义了
⼀个WEB应⽤的所有bean。
⚫ Bean ⼯⼚和 Application contexts 有什么区别？
Application contexts提供⼀种⽅法处理⽂本消息，⼀个通常的做法是加载⽂件资源
（⽐如镜像），它们可以向注册为监听器的 bean发布事件。另外，在容器或容器
内的对象上执⾏的那些不得不由bean⼯⼚以程序化⽅式处理的操作，可以在
Application contexts中以声明的⽅式处理。Application contexts实现了
MessageSource接⼝，该接⼝ 的实现以可插拔的⽅式提供获取本地化消息的⽅
法。
⚫ ⼀个Spring的应⽤看起来象什么？
⼀个定义了⼀些功能的接⼝。
这实现包括属性，它的Setter ， getter ⽅法和函数等。
Spring AOP。
Spring 的XML 配置⽂件。
使⽤以上功能的客户端程序。
⚫ spring中的核⼼类有那些，各有什么作⽤？
答：BeanFactory：产⽣⼀个新的实例，可以实现单例模式
BeanWrapper：提供统⼀的get及set⽅法
ApplicationContext:提供框架的实现，包括BeanFactory的所有功能
依赖注⼊
⚫ 什么是Spring的依赖注⼊？
依赖注⼊，是IOC的⼀个⽅⾯，是个通常的概念，它有多种解释。这概念是说你不
⽤创建对象，⽽只需要描述它如何被创建。你不在代码⾥直接组装你的组件和服
务，但是要在配置⽂件⾥描述哪些组件需要哪些服务，之后⼀个容器（IOC容器）
负责把他们组装起来。
⚫ 有哪些不同类型的IOC（依赖注⼊）⽅式？
构造器依赖注⼊：构造器依赖注⼊通过容器触发⼀个类的构造器来实现的，
该类有⼀系列参数，每个参数代表⼀个对其他类的依赖。
Setter⽅法注⼊：Setter⽅法注⼊是容器通过调⽤⽆参构造器或⽆参static⼯ ⼚ ⽅法实例化bean之后，调⽤该bean的setter⽅法，即实现了基于setter的依
赖注⼊。
⚫ Spring常⻅创建对象的注解？
答：@Component@Controller@ Service@ Repository
⚫ 什么是Spring beans?
Spring beans 是那些形成Spring应⽤的主⼲的java对象。它们被Spring IOC容器初
始化，装配，和管理。这些beans通过容器中配置的元数据创建。⽐如，以XML⽂
件中 的形式定义。
Spring 框架定义的beans都是单件beans。在bean tag中有个属性”singleton”，如
果它被赋为 TRUE，bean 就是单件，否则就是⼀个 prototype bean。默认是
TRUE，所以所有在Spring框架中的beans 缺省都是单 件。
⚫ ⼀个 Spring Bean 定义 包含什么？
⼀个Spring Bean 的定义包含容器必知的所有配置元数据，包括如何创建⼀个
bean，它的⽣命周期详情及它的依赖。
⚫ 如何给Spring 容器提供配置元数据?
这⾥有三种重要的⽅法给Spring 容器提供配置元数据。
XML配置⽂件。
基于注解的配置。
基于java的配置。
⚫ 你怎样定义类的作⽤域?
当定义⼀个 在Spring⾥，我们还能给这个bean声明⼀个作⽤域。它可以通
过bean 定义中的scope属性来定 义。如，当Spring要在需要的时候每次⽣产⼀个
新的bean实例，bean的scope属性被指定为prototype。另⼀⽅⾯，⼀个bean每次
使⽤的时候必须返回同⼀个实例，这个bean的scope 属性 必须设为 singleton。
⚫ 解释Spring⽀持的⼏种bean的作⽤域。
Spring框架⽀持以下五种bean的作⽤域：
singleton : bean在每个Spring ioc 容器中只有⼀个实例。
prototype：⼀个bean的定义可以有多个实例。
request：每次http请求都会创建⼀个bean，该作⽤域仅在基于web的
Spring ApplicationContext情形下有效。
session：在⼀个HTTP Session中，⼀个bean定义对应⼀个实例。该作⽤
域仅在基于web的Spring ApplicationContext情形下有效。
global-session：在⼀个全局的HTTP Session中，⼀个bean定义对应⼀个
实例。该作⽤域仅在基于web的Spring ApplicationContext情形下有效。
缺省的Spring bean 的作⽤域是Singleton.
⚫ Spring框架中的单例bean是线程安全的吗?
不，Spring框架中的单例bean不是线程安全的。
⚫ 解释Spring框架中bean的⽣命周期。
Spring容器 从XML ⽂件中读取bean的定义，并实例化bean。
Spring根据bean的定义填充所有的属性。
如果bean实现了BeanNameAware 接⼝，Spring 传递bean 的ID 到
setBeanName⽅法。
如果Bean 实现了 BeanFactoryAware 接⼝， Spring传递beanfactory 给
setBeanFactory ⽅法。
如果有任何与bean相关联的BeanPostProcessors，Spring会在
postProcesserBeforeInitialization()⽅法内调⽤它们。
如果bean实现IntializingBean了，调⽤它的afterPropertySet⽅法，如果
bean声明了初始化⽅法，调⽤此初始化⽅法。
如果有BeanPostProcessors 和bean 关联，这些bean的
postProcessAfterInitialization() ⽅法将被调⽤。
如果bean实现了 DisposableBean，它将调⽤destroy()⽅法。
⚫ 哪些是重要的bean⽣命周期⽅法？ 你能重载它们
吗？
有两个重要的bean ⽣命周期⽅法，第⼀个是setup ， 它是在容器加载bean的时候
被调⽤。第⼆个⽅法是 teardown 它是在容器卸载类的时候被调⽤。
The bean 标签有两个重要的属性（init-method和destroy-method）。⽤它们你可
以⾃⼰定制初始化和注销⽅法。它们也有相应的注解（@PostConstruct和
@PreDestroy）。
⚫ 什么是Spring的内部bean？
当⼀个bean仅被⽤作另⼀个bean的属性时，它能被声明为⼀个内部bean，为了定
义inner bean，在Spring 的 基于XML 的 配置元数据中，可以在 或
元素内使⽤ 元素，内部bean通常是匿名的，它们的
Scope⼀般是prototype。
⚫ 在 Spring中如何注⼊⼀个java集合？
Spring提供以下⼏种集合的配置元素：
类型⽤于注⼊⼀列值，允许有相同的值。
类型⽤于注⼊⼀组值，不允许有相同的值。
类型⽤于注⼊⼀组键值对，键和值都可以为任意类型。
类型⽤于注⼊⼀组键值对，键和值都只能为String类型。
⚫ 什么是bean装配?
装配，或bean 装配是指在Spring 容器中把bean组装到⼀起，前提是容器需要知道
bean的依赖关系，如何通过依赖注⼊来把它们装配到⼀起。
⚫ 什么是bean的⾃动装配？
Spring 容器能够⾃动装配相互合作的bean，这意味着容器不需要<constructor￾arg>和配置，能通过Bean⼯⼚⾃动处理bean之间的协作。
⚫ 解释不同⽅式的⾃动装配 。
有五种⾃动装配的⽅式，可以⽤来指导Spring容器⽤⾃动装配⽅式来进⾏依赖注
⼊。
no：默认的⽅式是不进⾏⾃动装配，通过显式设置ref 属性来进⾏装配。
byName：通过参数名 ⾃动装配，Spring容器在配置⽂件中发现bean的
autowire属性被设置成byname，之后容器试图匹配、装配和该bean的属性具
有相同名字的bean。
byType:：通过参数类型⾃动装配，Spring容器在配置⽂件中发现bean的
autowire属性被设置成byType，之后容器试图匹配、装配和该bean的属性具
有相同类型的bean。如果有多个bean符合条件，则抛出错误。
constructor：这个⽅式类似于byType， 但是要提供给构造器参数，如果
没有确定的带参数的构造器参数类型，将会抛出异常。
autodetect：⾸先尝试使⽤constructor来⾃动装配，如果⽆法⼯作，则使
⽤byType⽅式。
⚫ ⾃动装配有哪些局限性 ?
⾃动装配的局限性是：
重写： 你仍需⽤ 和 配置来定义依赖，意味着
总要重写⾃动装配。
基本数据类型：你不能⾃动装配简单的属性，如基本数据类型，String字符
串，和类。
模糊特性：⾃动装配不如显式装配精确，如果有可能，建议使⽤显式装配。
⚫ 你可以在Spring中注⼊⼀个null 和⼀个空字符串吗？
可以。
⚫ 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());
⚫ 什么是基于Java的Spring注解配置? 给⼀些注解的例
⼦.
基于Java的配置，允许你在少量的Java注解的帮助下，进⾏你的⼤部分Spring配
置⽽⾮通过XML⽂件。
以@Configuration 注解为例，它⽤来标记类可以当做⼀个bean的定义，被Spring
IOC容器使⽤。另⼀个例⼦是@Bean注解，它表示此⽅法将要返回⼀个对象，作
为⼀个bean注册进Spring应⽤上下⽂。
⚫ 什么是基于注解的容器配置?
相对于XML⽂件，注解型的配置依赖于通过字节码元数据装配组件，⽽⾮尖括号
的声明。
开发者通过在相应的类，⽅法或属性上使⽤注解的⽅式，直接组件类中进⾏配
置，⽽不是使⽤xml表述bean的装配关系。
⚫ 怎样开启注解装配？
注解装配在默认情况下是不开启的，为了使⽤注解装配，我们必须在Spring配置⽂
件中配置 context:annotation-config/元素。
⚫ @Required 注解
这个注解表明bean的属性必须在配置的时候设置，通过⼀个bean定义的显式的属
性值或通过⾃动装配，若@Required注解的bean属性未被设置，容器将抛出
BeanInitializationException。
⚫ @Autowired 注解
@Autowired 注解提供了更细粒度的控制，包括在何处以及如何完成⾃动装配。它
的⽤法和@Required⼀样，修饰setter⽅法、构造器、属性或者具有任意名称和/或
多个参数的PN⽅法。
⚫ @Qualifier 注解
当有多个相同类型的bean却只有⼀个需要⾃动装配时，
将@Qualifier 注解和@Autowire 注解结合使⽤以消除这
种混淆，指定需要装配的确切的bean。
⚫ @Controller 注解
该注解表明该类扮演控制器的⻆⾊，Spring不需要你继承任何其他控制器基类或引
⽤Servlet API。
⚫ @RequestMapping 注解
该注解是⽤来映射⼀个URL到⼀个类或⼀个特定的⽅处理法上。
⚫ 在Spring框架中如何更有效地使⽤JDBC?
使⽤SpringJDBC 框架，资源管理和错误处理的代价都会被减轻。所以开发者只需
写statements 和 queries从数据存取数据，JDBC也可以在Spring框架提供的模板
类的帮助下更有效地被使⽤，这个模板叫JdbcTemplate （例⼦⻅这⾥here）
⚫ JdbcTemplate
JdbcTemplate 类提供了很多便利的⽅法解决诸如把数据库数据转变成基本数据类
型或对象，执⾏写好的或可调⽤的数据库操作语句，提供⾃定义的数据错误处
理。
⚫ Spring对DAO的⽀持
Spring对数据访问对象（DAO）的⽀持旨在简化它和数据访问技术如JDBC，
Hibernate or JDO 结合使⽤。这使我们可以⽅便切换持久层。编码时也不⽤担⼼
会捕获每种技术特有的异常。
⚫ 使⽤Spring通过什么⽅式访问Hibernate?
在Spring中有两种⽅式访问Hibernate：
控制反转 Hibernate Template和 Callback。
继承 HibernateDAOSupport提供⼀个AOP 拦截器。
⚫ Spring⽀持的ORM
Spring⽀持以下ORM：
Hibernate
iBatis
JPA (Java Persistence API)
TopLink
JDO (Java Data Objects)
OJB
47.如何通过HibernateDaoSupport将Spring和
Hibernate结合起来？
⽤Spring的 SessionFactory 调⽤ LocalSessionFactory。集成过程分三步：
配置the Hibernate SessionFactory。
继承HibernateDaoSupport实现⼀个DAO。 在AOP⽀持的事务中装配。
⚫ Spring⽀持的事务管理类型
答：有两种⽅式：
1、编程式事务，在代码中硬编码。(不推荐使⽤) 2、声明式事务，在配置⽂件中配置（推荐使⽤）
声明式事务⼜分为两种：
a、基于XML的声明式事务
b、基于注解的声明式事务
⚫ Spring框架的事务管理有哪些优点？
它为不同的事务API 如 JTA，JDBC，Hibernate，JPA 和JDO，提供⼀个
不变的编程模式。
它为编程式事务管理提供了⼀套简单的API⽽不是⼀些复杂的事务API如
它⽀持声明式事务管理。
它和Spring各种数据访问抽象层很好得集成。
⚫ 解释AOP
aop是⾯向切⾯编程，是⼀种思想。是OOP的有益补充。1、 在不修改原有核⼼
业务代码的前提下，可以对代码进⾏增强（改变）
2、 程序员开发时，可以把精⼒集中在核⼼业务代码逻辑上。事务等问题可以最后
再加上也不迟。
3、 AOP的核⼼技术：动态代理
在⾯向对象编程(OOP)思想中，我们将事物纵向抽象成⼀个个的对象。⽽在⾯向
切⾯编程中，我们将⼀个个对象某些类似的⽅⾯横向抽象成⼀个切⾯，对这个切
⾯进⾏⼀些如权限验证，事物管理，记录⽇志等公⽤操作处理的过程就是⾯向切
⾯编程的思想。

⚫ 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）的通知，如方法调用。这是最强大的一种通知类型。 环绕通知可以在方法调用前后完成自定义的行为。它也会选择是否继续执行连接点或直接返回它们自己的返回值或抛出异常来结束执行。

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

作用域

singleton
当一个bean的作用域为singleton, 那么Spring IoC容器中只会存在一个共享的bean实例，并且所有对bean的请求，只要id与该bean定义相匹配，则只会返回bean的同一实例。
prototype
Prototype作用域的bean会导致在每次对该bean请求（将其注入到另一个bean中，或者以程序的方式调用容器的getBean() 方法）时都会创建一个新的bean实例。根据经验，对所有有状态的bean应该使用prototype作用域，而对无状态的bean则应该使用 singleton作用域
request
在一次HTTP请求中，一个bean定义对应一个实例；即每次HTTP请求将会有各自的bean实例， 它们依据某个bean定义创建而成。该作用 域仅在基于web的Spring ApplicationContext情形下有效。
session
在一个HTTP Session中，一个bean定义对应一个实例。该作用域仅在基于web的Spring
ApplicationContext情形下有效。
global session
在一个全局的HTTP Session中，一个bean定义对应一个实例。典型情况下，仅在使用portlet
context的时候有效。该作用域仅在基于 web的Spring ApplicationContext情形下有效。

⚫ Bean的初始化方式有哪些？
⚫ Bean的调用方式有哪些？
⚫ Bean的销毁方式有哪些？

⚫ Spring事务隔离级别和传播机制？
传播机制
1、propagation_required（xml文件中为required)
当前方法必须在一个具有事务的上下文中运行，如有客户端有事务在进行，那么被调用端将在该事务中运行，否则的话重新开启一个事务。（如果被调用端发生异常，那么调用端和被调用端事务都将回滚）
2、propagation_supports(xml文件中为supports）
当前方法不必需要具有一个事务上下文，但是如果有一个事务的话，它也可以在这个事务中运行
3、propagation_mandatory(xml文件中为mandatory）
表示当前方法必须在一个事务中运行，如果没有事务，将抛出异常
4、propagation_nested(xml文件中为nested)
如果当前方法正有一个事务在运行中，则该方法应该运行在一个嵌套事务中，被嵌套的事务可以独立于被封装的事务中进行提交或者回滚。如果封装事务存在，并且外层事务抛出异常回滚，那么内层事务必须回滚，反之，内层事务并不影响外层事务。如果封装事务不存在，则同propagation_required的一样
5、propagation_never（xml文件中为never)
当方法务不应该在一个事务中运行，如果存在一个事务，则抛出异常
6、propagation_requires_new(xml文件中为requires_new）
当前方法必须运行在它自己的事务中。一个新的事务将启动，而且如果有一个现有的事务在运行的话，则这个方法将在运行期被挂起，直到新的事务提交或者回滚才恢复执行。
7、propagation_not_supported（xml文件中为not_supported）
方法不应该在一个事务中运行。如果有一个事务正在运行，他将在运行期被挂起，直到这个事务提交或者回滚才恢复执行
隔离级别
1、isolation_default
使用数据库默认的事务隔离级别
2、isolation_read_uncommitted
允许读取尚未提交的修改，可能导致脏读、幻读和不可重复读
3、isolation_read_committed
允许从已经提交的事务读取，可防止脏读、但幻读，不可重复读仍然有可能发生
4、isolation_repeatable_read
对相同字段的多次读取的结果是一致的，除非数据被当前事务自生修改。可防止脏读和不可重复读，但幻读仍有可能发生
5、isolation_serializable
完全服从acid隔离原则，确保不发生脏读、不可重复读、和幻读，但执行效率最低。
几种常用数据库的默认隔离级别
MySQL
mysql默认的事务处理级别是'REPEATABLE-READ',也就是可重复读。
Oracle
oracle数据库支持READ COMMITTED 和 SERIALIZABLE这两种事务隔离级别。
默认系统事务隔离级别是READ COMMITTED,也就是读已提交。

posted on 2021-03-28 17:26  凹凹凸凸  阅读(57)  评论(0)  编辑  收藏  举报

导航