Java面试题--spring

介绍spring框架

 

   它是一个一站式（full-stack全栈式）框架，提供了从表现层-springMVC到业务层-spring再到持久层-springdata的一套完整的解决方案。我们在项目中可以只使用spring一个框架，它就可以提供表现层的mvc框架，持久层的Dao框架。它的两大核心IoC和AOP更是为我们程序解耦和代码简洁易维护提供了支持。

Spring Framework 中有多少个模块，它们分别是什么？

Spring核心容器有core、beans、context,有aop,web,jdbc,orm等

Spring的优点？

答：1.降低了组件之间的耦合性 ，实现了软件各层之间的解耦 

2.可以使用容易提供的众多服务，如事务管理，消息服务等 

3.容器提供单例模式支持 

4.容器提供了AOP技术，利用它很容易实现如权限拦截，运行期监控等功能 

5.容器提供了众多的辅助类，能加快应用的开发 

6.spring对于主流的应用框架提供了集成支持，如hibernate，JPA，Struts等 

7.spring属于低侵入式设计，代码的污染极低 

8.独立于各种应用服务器 

9.spring的DI机制降低了业务对象替换的复杂性 

10.Spring的高度开放性，并不强制应用完全依赖于Spring，开发者可以自由选择spring 的部分或全部 

 

spring中的核心类有那些，各有什么作用？

答：BeanFactory：产生一个新的实例，可以实现单例模式

BeanWrapper：提供统一的get及set方法

ApplicationContext:提供框架的实现，包括BeanFactory的所有功能

 

Spring中用到的设计模式，并举具体示例

Spring框架中使用到了大量的设计模式，下面列举了比较有代表性的：

 

代理模式—在AOP和remoting中被用的比较多。

单例模式—在spring配置文件中定义的bean默认为单例模式。

工厂模式—BeanFactory用来创建对象的实例。

 

spring有两种代理方式：

答: 若目标对象实现了若干接口，spring使用JDK的java.lang.reflect.Proxy类代理。

      优点：因为有接口，所以使系统更加松耦合

      缺点：为每一个目标类创建接口

若目标对象没有实现任何接口，spring使用CGLIB库生成目标对象的子类。

      优点：因为代理类与目标类是继承关系，所以不需要有接口的存在。

      缺点：因为没有使用接口，所以系统的耦合性没有使用JDK的动态代理好

 

什么是Spring beans?

Spring beans 是那些形成Spring应用的主干的java对象。它们被Spring IOC容器初始化，装配，和管理。这些beans通过容器中配置的元数据创建。比如，以XML文件中 的形式定义。

 

如何给Spring 容器提供配置元数据?

这里有三种重要的方法给Spring 容器提供配置元数据。

XML配置文件。

基于注解的配置。

基于java的配置。

 

什么是bean装配?

装配，或bean 装配是指在Spring 容器中把bean组装到一起，前提是容器需要知道bean的依赖关系，如何通过依赖注入来把它们装配到一起。

什么是bean的自动装配？

Spring 容器能够自动装配相互合作的bean，这意味着容器不需要和配置，能通过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字符串，和类。

模糊特性：自动装配不如显式装配精确，如果有可能，建议使用显式装配。

 

构造方法注入和设值注入有什么区别？

请注意以下明显的区别：

 

在设值注入方法支持大部分的依赖注入，如果我们仅需要注入int、string和long型的变量，我们不要用设值的方法注入。

对于基本类型，如果我们没有注入的话，可以为基本类型设置默认值。

在构造方法注入不支持大部分的依赖注入，因为在调用构造方法中必须传入正确的构造参数，否则的话为报错。

 

设值注入不会重写构造方法的值。

在使用设值注入时有可能还不能保证某种依赖是否已经被注入，也就是说这时对象的依赖关系有可能是不完整的。而在另一种情况下，构造器注入则不允许生成依赖关系不完整的对象。

 

Spring Bean的作用域之间有什么区别？

 

Spring容器中的bean可以分为5个范围。所有范围的名称都是自说明的，但是为了避免混淆，还是让我们来解释一下：

 

singleton：这种bean范围是默认的，这种范围确保不管接受到多少个请求，每个容器中只有一个bean的实例，单例的模式由bean factory自身来维护。

prototype：原形范围与单例范围相反，为每一个bean请求提供一个实例。

request：在请求bean范围内会每一个来自客户端的网络请求创建一个实例，在请求完成以后，bean会失效并被垃圾回收器回收。

Session：与请求范围类似，确保每个session中有一个bean的实例，在session过期后，bean会随之失效。

global-session：global-session和Portlet应用相关。当你的应用部署在Portlet容器中工作时，它包含很多portlet。如果你想要声明让所有的portlet共用全局的存储变量的话，那么这全局变量需要存储在global-session中。

 

全局作用域与Servlet中的session作用域效果相同。

 

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

 

一、Bean的定义 

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

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

 

二、Bean的初始化

有两种方式初始化Bean。 

1、在配置文档中通过指定init-method 属性来完成 

2、实现 org.springframwork.beans.factory.InitializingBean接口  

 

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

三、Bean的调用 

有三种方式可以得到Bean并进行调用： 

1、使用BeanWrapper

2、使用BeanFactory

3、使用ApplicationConttext

 

四、Bean的销毁 

1、使用配置文件中的 destory-method 属性

2、实现 org.springframwork.bean.factory.DisposebleBean接口 

 

什么是 Spring 的内部 bean？

只有将 Bean 仅用作另一个 Bean 的属性时，才能将 Bean 声明为内部 Bean。内部 Bean 总是匿名的，并且它们总是作为原型 Prototype 。

 

解释什么叫延迟加载？

默认情况下，容器启动之后会将所有作用域为单例的 Bean 都创建好，但是有的业务场景我们并不需要它提前都创建好。此时，我们可以在Bean 中设置 lzay-init = "true" 。

 

这样，当容器启动之后，作用域为单例的 Bean ，就不在创建。

而是在获得该 Bean 时，才真正在创建加载。

 

Spring中AOP的应用场景、Aop原理、好处？

 

答：AOP--Aspect Oriented Programming面向切面编程；用来封装横切关注点，具体可以在下面的场景中使用:

 

Authentication 权限、Caching 缓存、Context passing 内容传递、Error handling 错误处理Lazy loading懒加载、Debugging调试、logging, tracing, profiling and monitoring 记录跟踪优化　校准、Performance optimization　性能优化、Persistence 持久化、Resource pooling　资源池、Synchronization　同步、Transactions 事务

 

原理：AOP是面向切面编程，是通过动态代理的方式为程序添加统一功能，集中解决一些公共问题。

优点：1.各个步骤之间的良好隔离性耦合性大大降低 

     2.源代码无关性，再扩展功能的同时不对源码进行修改操作 

 

Aspect 切面

AOP核心就是切面，它将多个类的通用行为封装成可重用的模块，该模块含有一组API提供横切功能。比如，一个日志模块可以被称作日志的AOP切面。根据需求的不同，一个应用程序可以有若干切面。在Spring AOP中，切面通过带有@Aspect注解的类实现

在Spring AOP 中，关注点和横切关注的区别是什么？

关注点是应用中一个模块的行为，一个关注点可能会被定义成一个我们想实现的一个功能。

横切关注点是一个关注点，此关注点是整个应用都会使用的功能，并影响整个应用，比如日志，安全和数据传输，几乎应用的每个模块都需要的功能。因此这些都属于横切关注点。

 

连接点

连接点代表一个应用程序的某个位置，在这个位置我们可以插入一个AOP切面，它实际上是个应用程序执行Spring AOP的位置。

通知

通知是个在方法执行前或执行后要做的动作，实际上是程序执行时要通过SpringAOP框架触发的代码段。

 

Spring切面可以应用五种类型的通知：

before：前置通知，在一个方法执行前被调用。

after: 在方法执行之后调用的通知，无论方法执行是否成功。

after-returning: 仅当方法成功完成后执行的通知。

after-throwing: 在方法抛出异常退出时执行的通知。

around: 在方法执行之前和之后调用的通知。

 

切点

切入点是一个或一组连接点，通知将在这些位置执行。可以通过表达式或匹配的方式指明切入点。

什么是引入?

引入允许我们在已存在的类中增加新的方法和属性。

 

什么是目标对象?

被一个或者多个切面所通知的对象。它通常是一个代理对象。也指被通知（advised）对象。

什么是代理?

代理是通知目标对象后创建的对象。从客户端的角度看，代理对象和目标对象是一样的。

有几种不同类型的自动代理？

BeanNameAutoProxyCreator

DefaultAdvisorAutoProxyCreator

Metadata autoproxying

 

什么是织入。什么是织入应用的不同点？

织入是将切面和到其他应用类型或对象连接或创建一个被通知对象的过程。

织入可以在编译时，加载时，或运行时完成。

 

解释基于XML Schema方式的切面实现。

在这种情况下，切面由常规类以及基于XML的配置实现。

解释基于注解的切面实现

在这种情况下(基于@AspectJ的实现)，涉及到的切面声明的风格与带有java5标注的普通java类一致。

 

Aop的源码分析以及执行流程

 

ApplicationContext通常的实现是什么?

FileSystemXmlApplicationContext ：此容器从一个XML文件中加载beans的定义，XML Bean 配置文件的全路径名必须提供给它的构造函数。

ClassPathXmlApplicationContext：此容器也从一个XML文件中加载beans的定义，这里，你需要正确设置classpath因为这个容器将在classpath里找bean配置。

WebXmlApplicationContext：此容器加载一个XML文件，此文件定义了一个WEB应用的所有bean。

 

Bean 工厂和 Application contexts 有什么区别？

beanFactory是最底层的容器，提供了实例化bean以及获取bean的方法。

ApplicationContext 继承beanFactory接口，提供了更多的功能，比如国际化、访问资源、aop等。

两者子装载bean的方式上有所差异：beanFactory在初始化的时候不会创建bean，有方法来获取的时候才会去创建。

ApplicationContext一开始就会创建好所有的bean。

 

有哪些不同类型的IOC（依赖注入）方式？

构造器依赖注入：构造器依赖注入通过容器触发一个类的构造器来实现的，该类有一系列参数，每个参数代表一个对其他类的依赖。

Setter方法注入：Setter方法注入是容器通过调用无参构造器或无参static工厂 方法实例化bean之后，调用该bean的setter方法，即实现了基于setter的依赖注入。

 

 哪种依赖注入方式你建议使用，构造器注入，还是 Setter方法注入？

你两种依赖方式都可以使用，构造器注入和Setter方法注入。最好的解决方案是用构造器参数实现强制依赖，setter方法实现可选依赖。

Spring中IOC的作用与原理？对象创建的过程。

Spring 中的 IoC 的实现原理，就是工厂模式加反射机制。

可以把IOC容器看作是一个工厂，这个工厂里要生产的对象都在配置文件中给出定义，然后利用编程语言的的反射编程，根据配置文件中给出的类名生成相应的对象。从实现来看，IOC是把以前在工厂方法里写死的对象生成代码，改变为由配置文件来定义，也就是把工厂和对象生成这两者独立分隔开来，目的就是提高灵活性和可维护性

 

什么是IOC，什么又是DI，他们有什么区别？

一、IOC介绍

IOC是控制反转。

创建对象实例的控制权从代码控制剥离到IOC容器控制(之前的写法，由程序代码直接操控使用new关键字)，实际就是你在xml文件控制，控制权的转移是所谓反转，侧重于原理。 

二、DI介绍

DI是依赖注入

创建对象实例时，为这个对象注入属性值或其它对象实例，侧重于实现。

三、区别

1.它们是spring核心思想的不同方面的描述。

2.依赖注入和控制反转是对同一件事情的不同描述，从某个方面讲，就是它们描述的角度不同。

依赖注入是从应用程序的角度在描述，可以把依赖注入描述完整点：应用程序依赖容器创建并注入它所需要的外部资源；

而控制反转是从容器的角度在描述，描述完整点：容器控制应用程序，由容器反向的向应用程序注入应用程序所需要的外部资源。

 

Spring注解

什么是基于Java的Spring注解配置? 给一些注解的例子.

基于Java的配置，允许你在少量的Java注解的帮助下，进行你的大部分Spring配置而非通过XML文件。

以@Configuration 注解为例，它用来标记类可以当做一个bean的定义，被Spring IOC容器使用。另一个例子是@Bean注解，它表示此方法将要返回一个对象，作为一个bean注册进Spring应用上下文。

 

什么是基于注解的容器配置?

相对于XML文件，注解型的配置依赖于通过字节码元数据装配组件，而非尖括号的声明。

开发者通过在相应的类，方法或属性上使用注解的方式，直接组件类中进行配置，而不是使用xml表述bean的装配关系。

 

怎样开启注解装配？

注解装配在默认情况下是不开启的，为了使用注解装配，我们必须在Spring配置文件中配置 元素。

@Required 注解

这个注解表明bean的属性必须在配置的时候设置，通过一个bean定义的显式的属性值或通过自动装配，若@Required注解的bean属性未被设置，容器将抛出BeanInitializationException。

@Autowired 注解

@Autowired 注解提供了更细粒度的控制，包括在何处以及如何完成自动装配。它的用法和@Required一样，修饰setter方法、构造器、属性或者具有任意名称和/或多个参数的PN方法。

@Qualifier 注解

当有多个相同类型的bean却只有一个需要自动装配时，将@Qualifier 注解和@Autowire 注解结合使用以消除这种混淆，指定需要装配的确切的bean。

 

Spring数据访问

在Spring框架中如何更有效地使用JDBC?

使用SpringJDBC 框架，资源管理和错误处理的代价都会被减轻。所以开发者只需写statements 和 queries从数据存取数据，JDBC也可以在Spring框架提供的模板类的帮助下更有效地被使用，这个模板叫JdbcTemplate （例子见这里here）

 

JdbcTemplate

JdbcTemplate 类提供了很多便利的方法解决诸如把数据库数据转变成基本数据类型或对象，执行写好的或可调用的数据库操作语句，提供自定义的数据错误处理。

 

使用Spring通过什么方式访问Hibernate?

在Spring中有两种方式访问Hibernate：

控制反转 Hibernate Template和 Callback。

继承 HibernateDAOSupport提供一个AOP 拦截器。

 

如何通过HibernateDaoSupport将Spring和Hibernate结合起来？

用Spring的 SessionFactory 调用 LocalSessionFactory。集成过程分三步：

配置the Hibernate SessionFactory。

继承HibernateDaoSupport实现一个DAO。

在AOP支持的事务中装配。

 

spring事务定义

1.事务的定义：事务是指多个操作单元组成的合集，多个单元操作是整体不可分割的，要么都操作不成功，要么都成功。其必须遵循四个原则（ACID）。

原子性（Atomicity）：即事务是不可分割的最小工作单元，事务内的操作要么全做，要么全不做；

一致性（Consistency）：在事务执行前数据库的数据处于正确的状态，而事务执行完成后数据库的数据还是应该处于正确的状态，即数据完整性约束没有被破坏；如银行转帐，A转帐给B，必须保证A的钱一定转给B，一定不会出现A的钱转了但B没收到，否则数据库的数据就处于不一致（不正确）的状态。

隔离性（Isolation）：并发事务执行之间互不影响，在一个事务内部的操作对其他事务是不产生影响，这需要事务隔离级别来指定隔离性；

持久性（Durability）：事务一旦执行成功，它对数据库的数据的改变必须是永久的，不会因比如遇到系统故障或断电造成数据不一致或丢失。

 

Spring管理事务有几种方式？具体执行流程以及原理

答：有两种方式：

1、编程式事务，在代码中硬编码。(不推荐使用)

2、声明式事务，在配置文件中配置（推荐使用）

声明式事务又分为两种：

a、基于XML的声明式事务

b、基于注解的声明式事务

 

Spring框架的事务管理有哪些优点？

它为不同的事务API 如 JTA，JDBC，Hibernate，JPA 和JDO，提供一个不变的编程模式。

它为编程式事务管理提供了一套简单的API而不是一些复杂的事务API如

它支持声明式事务管理。

它和Spring各种数据访问抽象层很好得集成。

 

Spring事务隔离级别：

spring有五大隔离级别，其在TransactionDefinition接口中定义。看源码可知，其默isolation_default（底层数据库默认级别），其他四个隔离级别跟数据库隔离级别一致。

 

ISOLATION_DEFAULT：用底层数据库的默认隔离级别，数据库管理员设置什么就是什么

ISOLATION_READ_UNCOMMITTED（未提交读）：最低隔离级别、事务未提交前，就可被其他事务读取（会出现幻读、脏读、不可重复读）

ISOLATION_READ_COMMITTED（提交读）：一个事务提交后才能被其他事务读取到（该隔离级别禁止其他事务读取到未提交事务的数据、所以还是会造成幻读、不可重复读）、sql server默认级别

 

ISOLATION_REPEATABLE_READ（可重复读）：可重复读，保证多次读取同一个数据时，其值都和事务开始时候的内容是一致，禁止读取到别的事务未提交的数据（该隔离基本可防止脏读，不可重复读（重点在修改），但会出现幻读（重点在增加与删除））（MySql默认级别，更改可通过set transaction isolation level 级别）

 

ISOLATION_SERIALIZABLE（序列化）：代价最高最可靠的隔离级别（该隔离级别能防止脏读、不可重复读、幻读）

丢失更新：两个事务同时更新一行数据，最后一个事务的更新会覆盖掉第一个事务的更新，从而导致第一个事务更新的数据丢失，这是由于没有加锁造成的；

幻读：同样的事务操作过程中，不同时间段多次（不同事务）读取同一数据，读取到的内容不一致（一般是行数变多或变少）。

 

脏读：一个事务读取到另外一个未提及事务的内容，即为脏读。

不可重复读：同一事务中，多次读取内容不一致（一般行数不变，而内容变了）。

 

你更倾向用那种事务管理类型？

大多数Spring框架的用户选择声明式事务管理，因为它对应用代码的影响最小，因此更符合一个无侵入的轻量级容器的思想。声明式事务管理要优于编程式事务管理，虽然比编程式事务管理（这种方式允许你通过代码控制事务）少了一点灵活性。

 

spring的事务传播行为：

spring事务的传播行为说的是当一个方法调用另一个方法时，事务该如何操作。

（1）PROPAGATION_REQUIRED：如果当前没有事务，就创建一个新事务，如果当前存在事务，就加入该事务，该设置是最常用的设置。

（2）PROPAGATION_SUPPORTS：支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就以非事务执行。‘

（3）PROPAGATION_MANDATORY：支持当前事务，如果当前存在事务，就加入该事务，如果当前不存在事务，就抛出异常。

（4）PROPAGATION_REQUIRES_NEW：创建新事务，无论当前存不存在事务，都创建新事务。

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

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

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

 

 

Spring事务的实现方式和实现原理：

（1）划分处理单元——IOC：

由于spring解决的问题是对单个数据库进行局部事务处理的，具体的实现首相用spring中的IOC划分了事务处理单元。并且将对事务的各种配置放到了ioc容器中（设置事务管理器，设置事务的传播特性及隔离机制）。

（2）AOP拦截需要进行事务处理的类：

Spring事务处理模块是通过AOP功能来实现声明式事务处理的，具体操作（比如事务实行的配置和读取，事务对象的抽象），用TransactionProxyFactoryBean接口来使用AOP功能，生成proxy代理对象，通过TransactionInterceptor完成对代理方法的拦截，将事务处理的功能编织到拦截的方法中。 

读取ioc容器事务配置属性，转化为spring事务处理需要的内部数据结构（TransactionAttributeSourceAdvisor），转化为TransactionAttribute表示的数据对象。 

（3）对事物处理实现（事务的生成、提交、回滚、挂起）：

spring委托给具体的事务处理器实现。实现了一个抽象和适配。适配的具体事务处理器：DataSource数据源支持、hibernate数据源事务处理支持、JDO数据源事务处理支持，JPA、JTA数据源事务处理支持。这些支持都是通过设计PlatformTransactionManager、AbstractPlatforTransaction一系列事务处理的支持。为常用数据源支持提供了一系列的TransactionManager。

（4）结合：

PlatformTransactionManager实现了TransactionInterception接口，让其与TransactionProxyFactoryBean结合起来，形成一个Spring声明式事务处理的设计体系。

 

Spring框架中的单例Beans是线程安全的么？

Spring框架并没有对单例bean进行任何多线程的封装处理。关于单例bean的线程安全和并发问题需要开发者自行去搞定。但实际上，大部分的Spring bean并没有可变的状态(比如Serview类和DAO类)，所以在某种程度上说Spring的单例bean是线程安全的。如果你的bean有多种状态的话（比如 View Model 对象），就需要自行保证线程安全。

 

 

Spring如何处理线程并发问题？

Spring使用ThreadLocal解决线程安全问题。

我们知道在一般情况下，只有有状态的Bean才可以在多线程环境下共享，在Spring中，绝大部分Bean都可以声明为singleton作用域。就是因为Spring对一些Bean(如RequestContextHolder、TransactionSynchronizationManager、LocaleContextHolder等)中非线程安全状态采用ThreadLocal进行处理，让它们也成为线程安全的状态，因为有状态的Bean就可以在多线程中共享了。

ThreadLocal和线程同步机制都是为了解决多线程中相同变量的访问冲突问题。

（1）在同步机制中，通过对象的锁机制保证同一时间只有一个线程访问变量。这时该变量是多个线程共享的，使用同步机制要求程序慎密地分析什么时候对变量进行读写，什么时候需要锁定某个对象，什么时候释放对象锁等繁杂的问题，程序设计和编写难度相对较大。

（2）而ThreadLocal则从另一个角度来解决多线程的并发访问。ThreadLocal会为每一个线程提供一个独立的变量副本，从而隔离了多个线程对数据的访问冲突。因为每一个线程都拥有自己的变量副本，从而也就没有必要对该变量进行同步了。ThreadLocal提供了线程安全的共享对象，在编写多线程代码时，可以把不安全的变量封装进ThreadLocal。

（3）概括起来说，对于多线程资源共享的问题，同步机制采用了“以时间换空间”的方式，而ThreadLocal采用了“以空间换时间”的方式。前者仅提供一份变量，让不同的线程排队访问，而后者为每一个线程都提供了一份变量，因此可以同时访问而互不影响。

 

spring源码分析

spring注解：

bean的注册：

1、xml注册

2、注解注册：标注@Configuration，说明是配置类，构造方法上添加@Bean

 

@ComponentScans

ComponentScans指定扫描的包，然后获取出来的就是这个包下，所有标注有@component、@controller、@service、@repository等注解的类。

@controller、@service、@repository都是@component的派生类

@Scope

@Scope注解  调整作用域（prototype：多实例；singleton：单实例，request：同一次请求创建一个实例，session：同一个session创建一个实例）

@Lazy懒加载：

单实例bean：默认在容器启动的时候创建对象；懒加载：容器启动不创建对象。第一次使用(获取)Bean创建对象，并初始化；

@Conditional注解

按照一定的条件进行判断，满足条件给容器中注册bean。

首先要自己写一个类，继承Condition，并实现match方法

ImportSelector可以自己定义导入哪些类，返回一个数组，返回要导入的类的全类名，需要实现ImportSelector接口，

 

factoryBean与beanFactory的区别

BeanFactory是个Factory，也就是IOC容器或对象工厂，FactoryBean是个Bean。在Spring中，所有的Bean都是由BeanFactory(也就是IOC容器)来进行管理的。但对FactoryBean而言，这个Bean不是简单的Bean，而是一个能生产或者修饰对象生成的工厂Bean,它的实现与设计模式中的工厂模式和修饰器模式类似。

bean的生命周期

bean的生命周期分为三个阶段：bean创建—初始化----销毁的过程

 

在bean创建之后，我们可以在bean的初始化和销毁的前后对bean做一些处理，加入我们自己的逻辑，以下四种方式可以让我们在bean初始化和销毁的时候执行逻辑：

1）、指定初始化和销毁方法；通过@Bean指定init-method和destroy-method；

2）、通过让Bean实现InitializingBean（定义初始化逻辑），DisposableBean（定义销毁逻辑）;

3）、可以使用JSR250；

@PostConstruct：在bean创建完成并且属性赋值完成；来执行初始化方法

@PreDestroy：在容器销毁bean之前通知我们进行清理工作

4）、BeanPostProcessor【interface】：bean的后置处理器；

在bean初始化前后进行一些处理工作；

postProcessBeforeInitialization:在初始化之前工作

postProcessAfterInitialization:在初始化之后工作

调用顺序

BeanPostProcessor.postProcessBeforeInitialization

初始化：

对象创建完成，并赋值好，调用初始化方法。。。

 

BeanPostProcessor.postProcessAfterInitialization

销毁：

单实例：容器关闭的时候

多实例：容器不会管理这个bean；容器不会调用销毁方法；

 

@Autowired：自动注入

    1）、默认优先按照类型去容器中找对应的组件:applicationContext.getBean(BookDao.class);找到就赋值

    2）、如果找到多个相同类型的组件，再将属性的名称作为组件的id去容器中查找

                        applicationContext.getBean("bookDao")

    3）、@Qualifier("bookDao")：使用@Qualifier指定需要装配的组件的id，而不是使用属性名，优先级最高

    4）、自动装配默认一定要将属性赋值好，没有就会报错；

        可以使用@Autowired(required=false)，这样有的话就会进行赋值，没有的话就会忽略

    5）、@Primary：让Spring进行自动装配的时候，默认使用首选的bean；

            也可以继续使用@Qualifier指定需要装配的bean的名字；@Primary与@Qualifier同时存在的时候，优先会取@Qualifier指

aop原理

我们需要在切面类上标注@EnableAspectJAutoProxy注解

1）、@EnableAspectJAutoProxy 开启AOP功能

2）、@EnableAspectJAutoProxy 会给容器中注册一个组件

    AnnotationAwareAspectJAutoProxyCreator

3）、AnnotationAwareAspectJAutoProxyCreator是一个后置处理器；

4）、容器的创建流程：

     1）、registerBeanPostProcessors（）注册后置处理器；创建

         AnnotationAwareAspectJAutoProxyCreator对象

     2）、finishBeanFactoryInitialization（）初始化剩下的单实例bean

           1）、创建业务逻辑组件和切面组件

           2）、AnnotationAwareAspectJAutoProxyCreator拦截组件的创建过程

           3）、组件创建完之后，判断组件是否需要增强

              是：切面的通知方法，包装成增强器（Advisor）;给业务逻辑组件创建一个代理对象

             （cglib）；

5）、执行目标方法：

     1）、代理对象执行目标方法

     2）、CglibAopProxy.intercept()；

           1）、得到目标方法的拦截器链（增强器包装成拦截器MethodInterceptor）

           2）、利用拦截器的链式机制，依次进入每一个拦截器进行执行；

           3）、效果：

              正常执行：前置通知-》目标方法-》后置通知-》返回通知

              出现异常：前置通知-》目标方法-》后置通知-》异常通知

如何利用注解来实现声明式事务？

环境搭建：

1、导入相关依赖

      数据源、数据库驱动、Spring-jdbc模块

2、配置数据源、JdbcTemplate（Spring提供的简化数据库操作的工具）操作数据

3、给方法上标注 @Transactional 表示当前方法是一个事务方法；

4、 @EnableTransactionManagement 开启基于注解的事务管理功能；

      @EnableXXX  开启某一个功能

5、配置事务管理器来控制事务;

      @Bean

      public PlatformTransactionManager transactionManager()

 

事务原理：

@EnableTransactionManagement会生成两个组件

这两个组件会利用后置处理器机制在对象创建以后，包装对象，返回一个代理对象（增强器），代理对象执行方法利用拦截器链进行调用。

在目标方法执行的时候，执行拦截器链。执行目标方法。如果异常，获取到事务管理器，利用事务管理回滚操作。如果正常，利用事务管理器，提交事务。

 

扩展原理：

BeanPostProcessor：bean后置处理器，bean创建对象初始化前后进行拦截工作的

 

1、BeanFactoryPostProcessor：beanFactory的后置处理器；

     在BeanFactory标准初始化之后调用，来定制和修改BeanFactory的内容；

     所有的bean定义已经保存加载到beanFactory，但是bean的实例还未创建

BeanFactoryPostProcessor原理:

1)、ioc容器创建对象

2)、invokeBeanFactoryPostProcessors(beanFactory);

     如何找到所有的BeanFactoryPostProcessor并执行他们的方法；

        1）、直接在BeanFactory中找到所有类型是BeanFactoryPostProcessor的组件，并执行他们的方法

        2）、在初始化创建其他组件前面执行

2、BeanDefinitionRegistryPostProcessor extends BeanFactoryPostProcessor

     postProcessBeanDefinitionRegistry();

     在所有bean定义信息将要被加载，bean实例还未创建的；

     优先于BeanFactoryPostProcessor执行；

     利用BeanDefinitionRegistryPostProcessor给容器中再额外添加一些组件；

 

Spring容器创建过程

   1）、Spring容器在启动的时候，先会保存所有注册进来的Bean的定义信息；

      1）、xml注册bean；

      2）、注解注册Bean；@Service、@Component、@Bean、xxx

   2）、Spring容器会合适的时机创建这些Bean

      1）、用到这个bean的时候；利用getBean创建bean；创建好以后保存在容器中；

      2）、统一创建剩下所有的bean的时候；finishBeanFactoryInitialization()；

   3）、后置处理器；BeanPostProcessor

      1）、每一个bean创建完成，都会使用各种后置处理器进行处理；来增强bean的功能；

         AutowiredAnnotationBeanPostProcessor:处理自动注入

         AnnotationAwareAspectJAutoProxyCreator:来做AOP功能；

         xxx....

         增强的功能注解：

         AsyncAnnotationBeanPostProcessor

         ....

   4）、事件驱动模型；

      ApplicationListener；事件监听；

      ApplicationEventMulticaster；事件派发：