Spring5框架新功能

1、整个Spring5框架的代码基于Java8，运行时兼容JDK9，许多不建议使用的类和方法在代码库中删除。

2、Spring5.0框架自带了通用的日志封装

（1）Spring5已经移除了Log4jConfigListenner，官方建议使用Log4j2

（2）Spring5框架整合Log4j2

第一步：引入jar包

 第二步：创建log4j2.xml配置文件

 3、Spring5框架核心容器部分支持@Nullable注解

（1）@Nullable注解可以使用在方法上面，属性上面，参数上面，表示方法的返回值可以为空，属性值可以为空，参数值可以为空。

（2）注解用在方法上，方法的返回值可以为空

（3）注解使用在方法参数里面，方法参数可以为空

 （4）注解使用在属性上面，属性值可以为空

 4、Spring5核心容器支持函数式风格GenericApplicationContext

5、Spring支持整合JUnit5

（1）整合JUnit4

第一步 引入Spring相关针对测试依赖

第二步 创建测试类，使用注解方式完成

 （2）Spring5整合JUnit5

第一步 引入JUnit5的jar包

第二步 创建测试类，使用注解完成

 （3）使用一个复合注解替代上面两个注解完成整合

Spirng5框架新功能（Webflux）

1、SpringWebflux介绍

（1）是Spring5添加新的模块，用于web开发的，功能与SpringMVC类似，Webflux使用当前一种比较流行的响应式编程出现的框架。

（2）使用传统web框架，比如SpirngMVC，这些都是基于Servlet容器的。而Webflux是一种异步非阻塞的框架，异步非阻塞的框架在Servlet3.1以后才支持，核心是基于Reactor的相关API实现的。

（3）解释一下什么是异步非阻塞

* 异步同步

* 非阻塞和阻塞

** 上面都是针对的对象不一样

** 异步和同步是针对调用者，调用者发送请求，如果等着对方回应之后才去做其他的事情就是同步。如果发送请求之后不等着对方的回应就去做其他的事情就是异步。

** 阻塞和非阻塞针对被调用者，被调用者收到请求之后，做完请求任务之后才给出反馈就是阻塞。如果收到请求之后马上给出反馈，然后再去做事情就是非阻塞。

（4）Webflux特点：

        ① 非阻塞式：在有限的资源下，提高系统吞吐量和伸缩性，以Reactor为基础实现响应式编程。

        ② 函数式编程：Spirng5框架基于java8，Webflux使用Java8函数式编程方式实现路由请求。

（5）Webflux比较SpirngMVC

①：上面两个框架都可以使用注解的方式进行操作，都可以运行在Tomcat等容器中

②：SpringMVC采用命令式编程，WebFlux采用异步响应式编程

 2、响应式编程

（1）什么是响应式编程

响应式编程是一种面向数据流和变化传播的编程范式。这意味着可以在编程语言中很方便地表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播。

示例：电子表格就是响应式编程的一个例子。单元格可以包含字面值或类似"=B1+C1"的公式，而包含公式的单元格的值会依据其他单元格的值的变化而变化。

（2）Java8及其之前版本

*提供的观察者模式的两个类 Observer和Observable

3、响应式编程（Reactor实现）

（1）响应式编程操作中，Reactor是满足Reactive规范框架。

（2）Reactor有两个核心类，Mono和Flux，这两个类实现接口Publisher，这两个提供丰富操作符。Flux对象实现发布者，返回N个元素；Mono实现发布者，返回0或者1个元素。

（3）Flux和Mono都是数据流的发布者，使用Flux和Mono都可以发出三种数据的信号：元素值，错误信号，完成信号。错误信号和完成信号都代表终止信号，终止信号用于告诉订阅者数据流已经结束了，错误信号终止数据流同时把错误信息传递给订阅者。

（4）代码演示Flux和Mono

第一步：引入依赖

第二步：编程代码

 

（5）三种信号特点

* 错误信号和完成信号都是终止信号，这两种信号不能共存。

* 如果没有发送任何元素值，而是直接发送错误或者完成信号，表示是空数据流。

* 如果没有错误信号，没有完成信号，表示是无限数据流。

（6）调用just或者其他方法只是声明数据流，数据流并没有发出，只有进行订阅之后才会触发数据流，不订阅什么都不会发生

（7）操作符

 * 对数据流进行一道道操作，称为操作符，比如工厂的流水线

第一个 map： 元素映射为新元素

第二个 flatMap：元素映射为流

* 把每个元素转换成流，把转换之后的多个流合并成大的流

4、Webflux执行流程和核心API

SpringWebflux基于Reactor，默认容器是Netty，Netty是高性能的NIO框架，异步非阻塞的框架。

（1）Netty

* BIO(阻塞)

 * NIO(非阻塞)

 （2）SpringWebflux执行的过程和SpringMVC相似的

* SpringWebflux核心控制器DispatchHandler，实现接口WebHandler

* 接口WebHandler有一个方法

 

（3）SpringWebflux里面DispatcherHandler，负责请求的处理

* HanddlerMapping：请求查询到处理的方法

* HandlerAdapter：真正负责请求的处理

* HandlerResultHandler ：响应结果的处理

（4）SpringWebflux实现函数式编程。两个接口：RouterFunction（路由的处理）和HandlerFunction（处理函数）

5、SpringWebflux（基于注解编程模型）

SpringWebflux实现方式有两种：注解编程模型和函数式编程模型

使用注解编程模型方式，和之前SpringMVC使用相似的，只需要把相关的依赖配置到项目中，SpringBoot自动配置相关运行容器，默认情况下使用Netty服务器。

第一步：创建SpringBoot工程，引入Webflux相关依赖

 第二步：配置启动的端口号

 第三步：创建包和相关类

* 实体类

 * 创建接口定义操作方法

 * 接口实现类

* 创建Controller

 

 * 说明：

SpringMVC方式实现，同步阻塞的方式，基于SpringMVC+Servlet+Tomcat

SpringWebflux方式实现，异步非阻塞的方式，基于SpringWebflux+Reactor+Netty

6、SpringWebflux（基于函数式编程模型）

（1）在使用函数式编程模型操作的时候，需要自己初始化服务器

（2）基于函数式编程模型时候，有两个核心接口：RouterFunction（实现路由的功能，将请求转发给对应的handler）和HandlerFunction（处理请求生成响应的函数）。核心任务定义这两个函数接口的实现，并且启动所需要的服务器。

（3）SpringWebflux的请求和响应不再是ServletRequest和ServletResponse，而是ServerRequest和ServerResponse

第一步：把注解编程模型工程复制一份

第二步：创建Handler（具体实现方法）

public class UserHandler {

    private final UserService userService;

    public UserHandler(UserService userService) {
        this.userService = userService;
    }

    // 根据id查询
    public Mono<ServerResponse> getUserById(ServerRequest request){
        // 获取id值
        int userId = Integer.valueOf(request.pathVariable("id"));
        // 空值处理
        Mono<ServerResponse> notFound = ServerResponse.notFound().build();

        // 调用service方法得到数据
        Mono<User> userMono = this.userService.getUserById(userId);
        // 把userMono进行转换返回
        // 使用Reactor操作符flatMap
        return
                userMono
                        .flatMap(person -> ServerResponse.ok().contentType(MediaType.APPLICATION_JSON)
                                .body(fromObject(person)))
                                .switchIfEmpty(notFound);
    }

    // 查询所有
    public Mono<ServerResponse> getAllUsers(){
        // 调用service得到结果
        Flux<User> users = this.userService.getAllUser();
        return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(users,User.class);
    }

    // 添加
    public Mono<ServerResponse> saveUser(ServerRequest request){
        // 得到user对象
        Mono<User> userMono = request.bodyToMono(User.class);
        return ServerResponse.ok().build(this.userService.saveUserInfo(userMono));
    }

}

第三步：初始化服务器，编写Router

* 创建路由的方法

public class Server {

    // 1、创建Router路由
    public RouterFunction<ServerResponse> routingFunction(){
        // 创建handler对象
        UserService userService = new UserServiceImpl();
        UserHandler handler = new UserHandler(userService);
        // 设置路由
        return RouterFunctions.route(
                GET("/users/{id}").and(accept(APPLICATION_JSON)),handler::getUserById)
                .andRoute(GET("/users").and(accept(APPLICATION_JSON)),handler::getAllUsers);
    }

}

* 创建服务器完成适配

 // 2、创建服务器完成适配
 public void createReactorServer(){
        // 路由和handler适配
        RouterFunction<ServerResponse> route = routingFunction();
        HttpHandler httpHandler = toHttpHandler(route);
        ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(httpHandler);

        // 创建服务器
        HttpServer httpServer = HttpServer.create();
        httpServer.handle(adapter).bindNow();
    }

* 最终调用

public static void main(String[] args) throws IOException {
        Server server = new Server();
        server.createReactorServer();
        System.out.println("enter to exit");
        System.in.read();

    }

（4）使用WebClient调用

public class Client {

    public static void main(String[] args) {
        // 调用服务器地址
        WebClient webClient = WebClient.create("http://127.0.0.1:64200");

        // 根据id查询
        String id = "1";
        User userResult = webClient.get().uri("/users/{id}",id)
                .accept(MediaType.APPLICATION_JSON).retrieve().bodyToMono(User.class)
                .block();
        System.out.println(userResult.getName());


        // 查询所有
        Flux<User> results = webClient.get().uri("/users")
                .accept(MediaType.APPLICATION_JSON).retrieve().bodyToFlux(User.class);

        results.map(stu -> stu.getName())
                .buffer().doOnNext(System.out::println).blockFirst();

    }

}

课程总结

1、Spring框架概述

（1）轻量级开源JavaEE框架，为了解决企业复杂性，两个核心组成：IOC和AOP

（2）Spring5.2.6版本

2、IOC容器

（1）IOC底层原理（工厂、反射等）

（2）IOC接口（BeanFactory）

（3）IOC操作Bean管理（基于xml）

（4）IOC操作Bean管理（基于注解）

3、AOP

（1）AOP底层原理：动态代理，有接口（JDK动态代理），没有接口（CGLIB动态代理）

（2）术语：切入点、增强（通知）、切面

（3）基于AspectJ实现AOP操作

4、JdbcTemplate

（1）使用JdbcTemplate实现数据库curd操作

（2）使用JdbcTemplate实现数据库批量操作

5、事务管理

（1）事务概念

（2）重要概念（传播行为和隔离级别）

（3）基于注解实现声明式事务管理

（4）完全注解方式实现声明式事务管理

6、Spring5新特性

（1）整合日志框架

（2）@Nullable注解

（3）函数式注册对象

（4）整合Junit5单元测试框架

（5）SpringWebflux使用