Spring5新特性

Spring5新特性简述

Spring5兼容Java 8和JDK 9，集成了反应式流，以方便后续提供一种颠覆性方法来实现端点和Web应用程序开发。
反应式编程不仅是此版本的主题，还是令许多程序员激动不已的重大特性。人们对能够针对负载 波动进行无缝扩展的容灾和响应式服务的需求在不断增加，Spring 5 很好地满足了这一需求。本文将介绍Java SE8和Java EE 7 API升级的
基本内容、Spring 5的新反应式编程模型、对HTTP/2支持，以及Spring通过Kotlin对函数式编程的全面支持。以及会介绍测试及性能增强和Spring 核心和容器的一些修订。

升级到Java SE 8 和 Java EE 7

以前的 Spring Framework 中一直在支持一些弃用的 Java 版本，而 Spring 5 已从旧包袱中解放出 来。为了充分利用 Java 8 特性，它的代码库已进行了改进，而且该框架要求将 Java 8 作为最低的 JDK 版本。
在 API 级别上，Spring 5 兼容 Java EE 8 技术，满足对 Servlet 4.0、Bean Validation 2.0 和全新 的 JSON Binding API 的需求。对 Java EE API 的最低要求为 V7，该版本引入了针对 Servlet、JPA 和 Bean Validation API 的次要版本。

反应式编程模型

Spring 5 最令人兴奋的新特性是它的反应式编程模型。Spring 5 Framework 基于一种反应式基础而构建，而且是完全异步和非阻塞的。只需少量的线程，新的事件循环执行模型就可以垂直扩展。
该框架采用反应式流来提供在反应式组件中传播负压的机制。负压是一个确保来自多个生产者的数据不会让使用者不堪重负的概念。
Spring WebFlux 是 Spring 5 的反应式核心，它为开发人员提供了两种为 Spring Web 编程而设计 的编程模型：一种基于注解的模型和 Functional Web Framework (WebFlux.fn)。
基于注解的模型是 Spring WebMVC 的现代替代方案，该模型基于反应式基础而构建，而 Functional Web Framework 是基于 @Controller 注解的编程模型的替代方案。这些模型都通过同一种反应式基 础来运行，后者调整非阻塞 HTTP 来适应反应式流 API。

使用注解进行编程

Web MVC 程序员应该对 Spring 5 的基于注解的编程模型非常熟悉。Spring 5 调整了 Web MVC 的 @Controller 编程模型，采用了相同的注解。
在下面的代码中 BookController 类提供了两个方法，分别响应针对某个图书列表的 HTTP 请求，以及针对具有给定 id 的图书的 HTTP 请求。请注意 resource 方法返回的对象（Mono 和 Flux）。这些对象是实现反应式流规范中的 Publisher 接口的反应式类型。它们的职责是处理数据流。Mono 对象处理一个仅含 1 个元素的流，而 Flux 表示一个包含 N 个元素的流。

@RestController
public class BookController{
  @GetMapping("/book")
  Flux<Book> list(){
    return this.repository.findAll();
  }

  @GetMapping("/book/{id}") 
  Mono<Book> findById(@PathVariable String id) { 
    return this.repository.findOne(id);
  }
}

这是针对 Spring Web 编程的注解。现在我们使用函数式 Web 框架来解决同一个问题。

支持函数式编程

Spring 5 的新函数式方法将请求委托给处理函数，这些函数接受一个服务器请求实例并返回一种反应式类型。下面BookHandler 类，其中 listBook() 和 getBook() 方法相当于 Controller 中的功能：

public class BookHandler{
 public Mono<ServerResponse> listBooks(
   ServerRequest request) { 
     return ServerResponse.ok() 
                 .contentType(APPLICATION_JSON) 
                 .body(repository.allPeople(), Book.class);
    }

   public Mono<ServerResponse> getBook(ServerRequest request) { 
     return repository.getBook(request.pathVariable("id"))
               .then(book ->ServerResponse.ok()
               .contentType(APPLICATION_JSON)
               .body(fromObject(book)))               
               .otherwiseIfEmpty(ServerResponse.notFound().build())
}

通过路由函数来匹配 HTTP 请求参数与媒体类型，将客户端请求路由到处理函数。

Bookhandler handler = new BookHndler();
RouterFunction<ServerResponse> personRoute = 
      route(
              GET("/books/{id}")
                    .and(accept(APPLICATION_JSON)), handler::getBook)
              .andRoute(
                     GET("/books")
                           .and(accept(APPLICATION_JSON)), handler::listBooks);

使用REST端点执行反应式编程
WebFlux模块为RestTemplate提供四种完全非阻塞、反应式的替代方案，名为WebClient。下面创建一个 WebClient，并调用 books 端点来请求一本给定 id 为 1234 的图书。 通过 WebClient 调用 REST 端点：

Mone<Book> book = WebClient.create("http://loclahost:8080")
                                .get()
                                .url("/book/{id}", 1234)
                                .accept(APPLICATION_JSON)
                                .exchange(request)
                                .then(response -> response.bodyToMono(Book.class));

对HTTP/2支持
HTTP/2原理：Spring Framework 5.0 提供专门的 HTTP/2 特性支持，还支持人们期望出现在 JDK 9 中的新 HTTP 客户端。
Kotlin和Spring WenFlux
Kotlin 是一种来自 JetBrains 的面向对象的语言，它支持函数式编程。它的主要优势之一是与 Java 有 非常高的互操作性。
Kotlin 的用于定义端点的路由 DSL：

@Bean
fun apiRouter() = router {
    (accept(APPLICATION_JSON) and "/api").nest {
        "/book".nest {
            GET("/", bookHandler::findAll) 
            GET("/{id}", bookHandler::findOne)
        }
        "/video".nest {
            GET("/", videoHandler::findAll)
            GET("/{genre}", videoHandler::findByGenre)
        }
    }
}

使用Lambda表达式注册Bean
作为传统 XML 和 JavaConfig 的替代方案，现在可以使用 lambda 表达式注册 Spring bean，使 bean 可以实际注册为提供者。下面代码中使用 lambda 表达式注册了一个 Book bean。

GenericApplicationContext context = new GenericApplicationContext();
    context.registerBean(Book.class,  ()-> new     Book(context.getBean(Auther.class))
);

Spring Web Mvc支持最新的API
使用JUnit5执行条件和并发测试
JUnit 和 Spring 5：Spring 5 全面接纳了函数式范例，并支持 JUnit 5 及其新的函数式测试风格。还 提供了对 JUnit 4 的向后兼容性，以确保不会破坏旧代码。
Spring 5 的测试套件通过多种方式得到了增强，但最明显的是它对 JUnit 5 的支持。JUnit 5 全面接纳了 Java 8 流和 lambda 表达式：

@Test
void givenStreamOfInts_SumShouldBeMoreThanFive(){
    assertTure(Stream.of(20, 40, 50)
      .stream()
      .mapToInt(i -> i)
      .sum() > 110, () -> "Total shoule be more than 100"
    );
}

Spring 5 继承了 JUnit 5 在 Spring TestContext Framework 内实现多个扩展 API 的灵活性。举例而言，开发人员可以使用 JUnit 5 的条件测试执行注解 @EnabledIf 和 @DisabledIf 来自动计算一 个 SpEL (Spring Expression Language) 表达式，并适当地启用或禁用测试。借助这些注解，Spring 5 支持以前很难实现的复杂的条件测试方案。Spring TextContext Framework 现在能够并发执行测试。

Spring中经典的高频面试题

1、什么是Spring框架？主要有哪些模块？

Spring 框架是一个为 Java 应用程序的开发提供了综合、广泛的基础性支持的 Java 平台。Spring 帮助 开发者解决了开发中基础性的问题，使得开发人员可以专注于应用程序的开发，不必担心 Spring 是如何 在后台进行工作的。
Spring 框架至今已集成了 20 多个模块。这些模块主要被分核心容器、数据访问/集成,、 Web、AOP（面向切面编程）、工具、消息和测试模块。

2、使用 Spring 框架能带来哪些好处？

1、Dependency Injection(DI) 方法使得构造器和 JavaBean properties 文件中的依赖关系一目了然。
2、与 EJB 容器相比较，IOC 容器更加趋向于轻量级。这样一来 IOC 容器在有限的内存和 CPU 资源的情况下进行应用程序的开发和发布就变得十分有利。
3、Spring 框架是按照模块的形式来组织的。由包和类的编号就可以看出其所属的模块，开发者仅仅需要选用他们需要的模块即可。
4、要测试一项用 Spring 开发的应用程序十分简单，因为测试相关的环境代码都已经囊括在框架中了。
5、Spring 提供了一个便捷的事务管理接口，适用于小型的本地事务处理（比如在单 DB 的环境下）和 复杂的共同事务处理（比如利用 JTA 的复杂 DB 环境）。

3、什么是控制反转(IOC)？什么是依赖注入？

在传统的编程方式中，业务逻辑的流程是由应用程序中的早已设定好关联关系的对象来决定的。在使用控制反转的情况下，业务逻辑的流程是由对象关系图来决定 的，该对象关系图由装配器负责实例化。而依赖注入是在编译阶段，还不知道所需的功能来自哪个类的情况下，将其他对象所依赖的功能对象实例化的模式。

4、在 Java 中依赖注入有哪些方式？

1.构造器注入
2.Setter 方法注入
3.接口注入

5、BeanFactory 和 ApplicationContext 有什么区别？

BeanFactory 可以理解为含有 bean 集合的工厂类。包含个种 bean 的定义，以便在接收到客户端请求时将对应的 bean 实例化。BeanFactory还能子在实例化对象的时候生成协作类之间的关系。将bean自己与bean客户端的配置中释放出来。BeanFactory还包含了bean生命周期的控制，调用客户端的初始化（initlization Methods）和销毁方法（destribution Methods）。
从表面上看，ApplicationContext和beanFactory一样具有bean定义，bean关联关系的设置，请求分发bean的功能，但applicationContext在此基础上还提供：
1、提供了支持国际化的文本消息
2、统一的资源文件读取方式
3、在监听器中注册bean事件
以下是三种较常见的 ApplicationContext 实现方式：
1、ClassPathXmlApplicationContext：从 classpath 的 XML 配置文件中读取上下文，并生成上下文定义。应用程序上下文从程序环境变量中取得。 ApplicationContext context = new ClassPathXmlApplicationContext(“application.xml”);
2、FileSystemXmlApplicationContext ：由文件系统中的 XML 配置文件读取上下文。
ApplicationContext context = new FileSystemXmlApplicationContext(“application.xml”);
3、XmlWebApplicationContext：由 Web 应用的 XML 文件读取上下文。

6、Spring 提供几种配置方式来设置元数据？

将 Spring 配置到应用开发中有以下三种方式：
1.基于 XML 的配置 ：使用xml文件标签化配置Bean的相关信息
引入pom及bean配置xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:context="http://www.springframework.org/schema/context"
       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-4.0.xsd">
    <bean id="service" class="com.wyh.spring.core.ServiceImpl"
          init-method="hello">
    </bean>
</beans>

使用XmlBeanFactory创建对象:

public class BeanFactoryDemo {
    public static void main(String[] args) {
        XmlBeanFactory xmlBeanFactory = new XmlBeanFactory(new ClassPathResource("beans.xml"));
        IService service = (IService) xmlBeanFactory.getBean("service");
        String hello = service.hello();
        System.out.println(hello);
    }
}

2.基于注解的配置
@Component 标识了一个被Spring管理的对象
@Respository 标识持久层对象
@Service 标识业务层对象
@Controller 标识表现层对象
3.基于 Java 的配置
使用configuration配置bean

@Configuration
public class Configuration {
    @Bean
    public User user() {
        return new User();
    }
}

7、如何使用 XML 配置的方式配置 Spring？

在 Spring 框架中，依赖和服务需要在专门的配置文件来实现，我常用的是 XML 格式的配置文件。这些配置文件有一个通用的格式头，然后是一系列的bean定义和专门的应用配置选项组成。
Spring 的 XML 配置方式是使用被 Spring 命名空间的所支持的一系列的 XML 标签来实现的。比如：：context、beans、jdbc、tx、aop、mvc 和 aso。

8、Spring 提供哪些配置形式？

Spring 对 Java 配置的支持是由@Configuration 注解和@Bean 注解来实现的。
@Bean 注解的方法将会实例化、配置和初始化一个新对象，由 Spring 的 IOC 容器来管理。@Configuration 所注解的类则表示这个类的主要目的是作为 bean 定义的资源。被@Configuration 声明的类可以通过在同一个类的内部调用@bean 方法来设置嵌入 bean 的依赖关系。
最简单的@Configuration 声明类请参考下面的代码：

@Configuration 
public class AppConfig{ 
  @Bean 
  public MyService myService() { 
    return new MyServiceImpl(); 
  } 
}

对于上面的@Beans 配置文件相同的 XML 配置文件如下：

<beans> 
  <bean id="myService" class="com.gupaoedu.services.MyServiceImpl"/> </beans>

上述配置方式的实例化方式如下：利用 AnnotationConfigApplicationContext 类进行实例化：

public static void main(String[] args) { 
  ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class); 
  MyService myService = ctx.getBean(MyService.class); 
  myService.doStuff();
}

要使用组件扫描，仅需用@Configuration 进行注解即可：

@Configuration 
@ComponentScan(basePackages = "com.tc") 
public class AppConfig { 
}

在上面的例子中，com.tc包首先会被扫到，然后再容器内查找被@Component 声明的类， 找到后将这些类按照 Spring bean 定义进行注册。

9、怎样用注解的方式配置 Spring？

Spring 在 2.5 版本以后开始支持用注解的方式来配置依赖注入。可以用注解的方式来替代 XML 方式的 bean 描述，可以将 bean 描述转移到组件类的内部，只需要在相关类上、方法上或者字段声明上使用注解即可。。注解注入将会被容器在 XML 注入之前被处理，所以后者会覆盖掉前者对于同一个属性的处理结果。
注解装配在Spring 中是默认关闭的。所以需要在Spring文件中配置一下才能使用基于注解的装配模式。
下面是几种比较重要的注解类型：
1.@Required：该注解应用于设值方法。
2.@Autowired：该注解应用于有值设值方法、非设值方法、构造方法和变量。 3.@Qualifier：该注解和@Autowired 注解搭配使用，用于消除特定 bean 自动装配的歧义。
4.JSR-250 Annotations：Spring 支持基于 JSR-250 注解的以下注解，@Resource、@PostConstruct 和 @PreDestroy

10、请解释 Spring Bean 的生命周期？

在一个 bean 实例被初始化时，需要执行一系列的初始化操作以达 到可用的状态。同样的，当一个 bean 不在被调用时需要进行相关的析构操作，并从 bean 容器中移除。
Spring bean factory 负责管理在 spring 容器中被创建的 bean 的生命周期。Bean 的生命周期由两组 回调（call back）方法组成。
1.初始化之后调用的回调方法。
2.销毁之前调用的回调方法
Spring 框架提供了以下四种方式来管理 bean 的生命周期事件：
1、InitializingBean 和 DisposableBean 回调接口
2、针对特殊行为的其他 Aware 接口
3、Bean 配置文件中的 customInit()方法和 destroy()方法
4、@PostConstruct 和@PreDestroy 注解方式

11、Spring Bean 作用域之间的区别？

1、singleton：这种 bean 范围是默认的，这种范围确保不管接受到多少个请求，每个Ioc容器中只有一个 bean 的实例，单例的模式由 bean factory 自身来维护。（创建起容器时就同时自动创建了一个bean的对象，不管你是否使用，他都存在了，每次获取到的对象都是同一个对象）
2、prototype：原形范围与单例范围相反，每次对该bean请求（将其注入到另一个bean中，或者调用容器的getBean()方法）时都会创建一个新的bean实例。它在我们创建容器的时候并没有实例化，而是当我们获取bean的时候才会去创建一个对象，而且我们每次获取到的对象都不是同一个对象。
注：对有状态的bean应该使用prototype作用域，而对无状态的bean则应该使用singleton作用域。
3、request：在请求 bean 范围内，每一个HTTP请求创建一个全新的实例，该实例仅在当前request内有效，可以根据需求更改实例的状态而其他请求看不到。在请求完成以后，bean 会失效并被垃圾回收器回收
4、Session：与请求范围类似，确保每个HTTP Session 中有一个 bean 的实例，仅在当前HTTP Session中有效。在 Session 过期后，bean 会 随之失效。
5、global-session：global-session 和 Portlet 应用相关，它仅仅在基于portlet的web应用中才有意义。当你的应用部署在 Portlet 容器中工作时，它包含很多 portlet。如果你想要声明让所有的 portlet 共用全局的存储变量的话，那么这全局变量需要存储在 global-session 中。（Portlet是基于Java的Web组件，由Portlet容器管理，并由容器处理请求，生产动态内容）
自定义作用域：
1、首先需要实现自定义Scope类：接口中有两个常用的方法，分别用于底层存储机制获取和删除这个对象。
2、r使用registerScope方法在Spring容器中来注册新的作用域：
void registerScope(String scopeName, Scope scope);
比如实现Scope接口的类为SimpleThreadScope，要实现的自定义的bean的作用域的名称为“thread”,那就可以这么写：

Scope threadScope = new SimpleThreadScope();
beanFactory.registerScope("thread", threadScope);

3.在实现和注册自定义的scope类之后，就可以通过如下类似的Bean定义来使用自定义的Scope:

  <bean id="..." class="..." scope="thread">

12、什么是 Spring inner beans？

正如Java 内部类是在其他类的范围内被定义的，同理，inner beans 是在其他 bean 的范围内定义的 bean。因此在 bean元素内元素被称为内部bean。

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

Spring 框架并没有对单例 bean 进行任何多线程的封装处理。关于单例 bean 的线程安全和并发问题需 要开发者自行去搞定。但实际上，大部分的 Spring bean 并没有可变的状态(比如 Service 类和 DAO类)，所以在某种程度上说 Spring 的单例 bean 是线程安全的。如果你的 bean 有多种状态的话（比如 View Model 对象），就需要自行保证线程安全。
最浅显的解决办法就是将多态 bean 的作用域由“singleton”变更为“prototype”。

14、请举例说明如何在 Spring 中注入一个 Java 集合？

Spring 提供了以下四种集合类的配置元素：
1、 list： 该标签用来装配可重复的 list 值。

<property name="customList"> 
  <list>
    <value>INDIA</value>
    <value>Pakistan</value>
    <value>USA</value>
  </list>
</property>

2、 set： 该标签用来装配没有重复的 set 值。

<property name="customSet">
  <set>
    <value>INDIA</value>
    <value>USA</value>
    <value>UK</value>
  </set>
</property>

3、map： 该标签可用来注入键和值可以为任何类型的键值对。

<property name="customMap">
  <map>
    <entry key="1" value="INDIA"/>
    <entry key="3" value="USA"/>
    <entry key="4" value="UK"/>
  </map>
</property>

4、 props： 该标签支持注入键和值都是字符串类型的键值对。

<property name="customProperies">
  <props>
    <prop key="admin">admin@gupaoedu.com</prop> 
    <prop key="support">support@gupaoedu.com</prop>
  </props>
</property>

15、如何向 Spring Bean 中注入 java.util.Properties？

第一种：

<property name="emails">
  <props>
    <prop key="admin">admin@gupaoedu.com</prop>
    <prop key="support">support@gupaoedu.com</prop>
  </props>
</property>

第二种：可用”util:”命名空间来从 properties 文件中创建出一个 properties bean，然后利用 setter 方法注 入 bean 的引用。

16、请解释 Spring Bean 的自动装配？

Spring利用依赖注入（DI），完成对IOC容器中中各个组件的依赖关系赋值；
在Spring框架中，在配置文件中可以设定bean的依赖关系，还可以自动装配bean之间的关联关系。这意味着 Spring 可以以向 Bean Factory 中注入的方式自动搞定 bean 之间的依赖关系。自动装配可以设置在每个 bean 上，也可以设定在特定的 bean 上。
三种形式：
1：xml配置文件来将一个bean设置为自动装配：

<bean id="employeeDao" class="com.tc.xxx" autowird="byName" />

2：使用Autowired注解来自动装配指定的bean，使用之前，在配置文件进行相关配置：

<context:annotation-config>

也可以通过配置AutowiredAnnotationBeanPostProcessor：

<bean class="org.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor">

它实现了BeanPostProcessor前置类在postProcessBeforeInitialization方法里调用invokeAwareInterfaces进行设置IOC容器。
配置好后，使用Autowired来标注：

@Autowired 
public EmployeeDAOImpl ( EmployeeManager manager ) { 
  this.manager = manager;
}

17、自动装配有哪些局限性？

自动装配有如下局限性：

  • 重写：你仍然需要使用property和constructor-arg设置中的依赖，意味着总是要重写自动装配。
  • 原生数据类型：你不能自动装配简单的属性，如原生类型int，long、字符串和类。
  • 模糊特性：自动装配总是没有自定义装配或者直接装配（explicit wiring）精确，因此，如果可能尽量使用自定义装配。

18、各种自动装配模式的区别？

在 Spring 框架中共有 5 种自动装配：
1.no：这是 Spring 框架的默认设置，在该设置下自动装配是关闭的，开发者需要自行在 bean 定义中用标签明确的设置依赖关系。
2.byName：该选项可以根据 bean 名称设置依赖关系。当向一个 bean 中自动装配一个属性时，容器将根据 bean 的名称自动在在配置文件中查询一个匹配的 bean。如果找到的话，就装配这个属性，如 果没找到的话就报错。
3.byType：该选项可以根据 bean 类型设置依赖关系。当向一个 bean 中自动装配一个属性时，容器将 根据 bean 的类型自动在在配置文件中查询一个匹配的 bean。如果找到的话，就装配这个属性，如果 没找到的话就报错。
4.constructor：造器的自动装配和 byType 模式类似，但是仅仅适用于与有构造器并且相同参数的 bean， 如果在容器中没有找到与构造器参数类型一致的 bean，那么将会抛出异常。
5.autodetect：该模式自动探测使用构造器自动装配或者 byType 自动装配。首先会尝试找合适的带参的构造器，如果找到的话就是用构造器自动装配，如果在 bean 内部没有找到相应的构造器或 者是无参构造器，容器就会自动选择 byTpe 的自动装配方式。

19、请举例解释@Required Annotation？

public class EmployeeFactoryBean extends AbstractFactoryBean<Object> {   
    private String designation; 
    public String getDesignation() { 
        return designation; 
    }

    @Required 
    public void setDesignation(String designation) { 
        this.designation = designation; 
    } 
}

RequiredAnnotationBeanPostProcessor 是 Spring 中的后置处理用来验证被@Required 注解的 bean 属性是否被正确的设置了。 属性是否被正确的设置了。在使用 RequiredAnnotationBeanPostProcessor 来验证 bean 属性之 前，首先要在 IOC 容器中对其进行注册：

<bean class="org.springframework.beans.factory.annotation.RequiredAnnotationBeanPostProcessor" />

但是如果没有属性被用 @Required 注解过的话，后置处理器会抛出一个 BeanInitializationException 异常。

20、请举例说明@Qualifier 注解？

@Qualifier注解意味着在被标注的bean的字段上可以自动装配。
Qualifier注解可以用来取消Spring不能取消的 bean 应用。解和@Autowired 注解搭配使用，用于消除特定 bean 自动装配的歧义。

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

1.设值注入方法支持大部分的依赖注入，如果我们仅需要注入 int、string 和 long 型的变量，我们不要用设值的方法注入。因为对于基本类型，如果我们没有注入的话，可以为基本类型设置默认值。而构造方法注入不支持大部分的依赖注入，因为在调用构造方法中必须传入正确的构造参数，否则的话为报错。
2.设值注入不会重写构造方法的值。如果我们对同一个变量同时使用了构造方法注入又使用了设置方法 注入的话，那么构造方法将不能覆盖由设值方法注入的值。很明显，因为构造方法是在对象被创建时调用。
3.在使用设值注入时有可能还不能保证某种依赖是否已经被注入，也就是说这时对象的依赖关系有可能 是不完整的。而在另一种情况下，构造器注入则不允许生成依赖关系不完整的对象。
4.在 构造 注 入 时 如 果 对 象 A 和 对 象 B 互 相 依 赖 ， 在 创 建 对 象 A 时 Spring 会 抛 出 sObjectCurrentlyInCreationException 异常，因为在 B 对象被创建之前 A 对象还没有被创建的，反之亦然。所以 Spring 用设值注入的方法解决了循环依赖的问题，因对象的设值方法是在对象被创建之前 被调用的。

22、Spring 框架中有哪些不同类型的事件？

Spring 提供了以下 5 中标准的事件：
1.上下文更新事件（ContextRefreshedEvent）：该事件会在 ApplicationContext 被初始化或者更新时发布。也可以在调用 ConfigurableApplicationContext 接口中的 refresh()方法时被触发。
2.上下文开始事件（ContextStartedEvent）：当容器调用 ConfigurableApplicationContext 的 Start() 方法开始/重新开始容器时触发该事件。
3.上下文停止事件（ContextStoppedEvent）：当容器调用 ConfigurableApplicationContext 的 Stop() 方法停止容器时触发该事件。
4.上下文关闭事件（ContextClosedEvent）：当 ApplicationContext 被关闭时触发该事件。容器被关闭时，其管理的所有单例 Bean 都被销毁。
5.请求处理事件（RequestHandledEvent）：在 Web 应用中，当一个 http 请求（request）结束触发该事件。
除了上面的事件外，可以通过扩展ApplicationEvent类来开发自定义事件。

public class CustomApplicationEvent extends ApplicationEvent { 
    public CustomApplicationEvent ( Object source, final String msg ){ 
        super(source); 
        System.out.println("Created a Custom event"); 
    } 
}

还需要创建一个监听器来监听事件：

public class CustomEventListener implements ApplicationListener < CustomApplicationEvent >{ 
    @Override public void onApplicationEvent(CustomApplicationEvent applicationEvent) { 
    } 
}

之后通过 applicationContext 接口的 publishEvent()方法来发布自定义事件：

CustomApplicationEvent customEvent = new CustomApplicationEvent(applicationContext, “Test message”); applicationContext.publishEvent(customEvent);

23、FileSystemResource 和 ClassPathResource 有何区别？

在 FileSystemResource 中需要给出 spring-config.xml 文件在你项目中的相对路径或者绝对路径。在 ClassPathResource 中 spring 会在 ClassPath 中自动搜寻配置文件，所以要把 ClassPathResource 文 件放在 ClassPath 下。
如果将 spring-config.xml 保存在了 src 文件夹下的话，只需给出配置文件的名称即可，因为 src 文件 夹是默认。
简而言之，ClassPathResource在环境变量中读取配置文件，FileSystemResource 在配置文件中读取配置文件。

24、Spring 框架中都用到了哪些设计模式？

Spring 框架中使用到了大量的设计模式，下面列举了比较有代表性的：
1、代理模式—在 AOP 和 remoting 中被用的比较多。
2、单例模式：在 spring 配置文件中定义的 bean 默认为单例模式。
3、模板模式：用来解决代码重复的问题。 比如. RestTemplate, JmsTemplate, JpaTemplate。
4、委派模式：Srping 提供了 DispatcherServlet 来对请求进行分发。
5、工厂模式：BeanFactory 用来创建对象的实例，贯穿于 BeanFactory / ApplicationContext 接口的核心理念。
代理模式：AOP 思想的底层实现技术，Spring 中采用 JDK Proxy 和 CgLib 类库。

25、请解释下 Spring 框架中的 IOC 容器？

Spring 中的 org.springframework.beans 包和 org.springframework.context 包构成了 Spring 框架 IOC 容器的基础。
BeanFactory 接口提供了一个先进的配置机制 ，使得任何类型的对象的配置成为可能 。
ApplicationContex 接口对 BeanFactory（是一个子接口）进行了扩展，在 BeanFactory 的基础上添 加了其他功能，比如与 Spring 的 AOP 更容易集成，也提供了处理 message resource 的机制（用于国 际化）、事件传播以及应用层的特别配置，比如针对 Web 应用的 WebApplicationContext。

27、在 Spring 中可以注入 null 或空字符串吗？

可以

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 212,185评论 6赞 493
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 90,445评论 3赞 385
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 157,684评论 0赞 348
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 56,564评论 1赞 284
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 65,681评论 6赞 386
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 49,874评论 1赞 290
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 39,025评论 3赞 408
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 37,761评论 0赞 268
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 44,217评论 1赞 303
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 36,545评论 2赞 327
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 38,694评论 1赞 341
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 34,351评论 4赞 332
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 39,988评论 3赞 315
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 30,778评论 0赞 21
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 32,007评论 1赞 266
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 46,427评论 2赞 360
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 43,580评论 2赞 349