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 list(){
    return this.repository.findAll();
  }

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

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

支持函数式编程

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

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

   public Mono 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 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 = 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

使用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 配置文件如下：

上述配置方式的实例化方式如下：利用 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:

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 值。

 
  
    INDIA
    Pakistan
    USA

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


  
    INDIA
    USA
    UK

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

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


  
    [email protected] 
    [email protected]

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

第一种：


  
    [email protected]
    [email protected]

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

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

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

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

也可以通过配置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