Spring5学习笔记（十三）—— Spring5框架新功能

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

8.1、整合日志框架

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

2、Spring5已经移除了Log4jConfigListener，官方建议使用Log4j2

3、Spring5框架整合Log4j2

• 第一步：引入jar包

  

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

  <?xml version="1.0" encoding="UTF-8"?>
  <!--日志级别以及优先级排序: OFF > FATAL > ERROR > WARN > INFO > DEBUG > TRACE > ALL -->
  <!--Configuration后面的status用于设置log4j2自身内部的信息输出，可以不设置，当设置成trace时，可以看到log4j2内部各种详细输出-->
  <configuration status="INFO">
      <!--先定义所有的appender-->
      <appenders>
          <!--输出日志信息到控制台-->
          <console name="Console" target="SYSTEM_OUT">
              <!--控制日志输出的格式-->
              <PatternLayout pattern="%d{yyyy-MM-dd HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
          </console>
      </appenders>
      <!--然后定义logger，只有定义了logger并引入的appender，appender才会生效-->
      <!--root：用于指定项目的根日志，如果没有单独指定Logger，则会使用root作为默认的日志输出-->
      <loggers>
          <root level="info">
              <appender-ref ref="Console"/>
          </root>
      </loggers>
  </configuration>
  

8.2、@Nullable注解

1、Spring5框架核心容器支持@Nullable注解

2、@Nullable注解可以使用在方法上面，属性上面，参数上面，表示方法返回可以为空，属性值可以为空，参数值可以为空

• 注解用在方法上面，方法返回值可以为空

  

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

  

• 注解使用在属性上面，属性值可以为空

  

8.3、函数式注册对象

Spring5框架核心容器支持函数式风格GenericApplicationContext

//函数式风格创建对象，交给Spring进行管理
@Test
public void testGenericApplicationContext(){

    //1、创建GenericApplicationContext对象
    GenericApplicationContext context = new GenericApplicationContext();
    //2、调用context的方法对象注册
    context.refresh();
    context.registerBean("user1",User.class,()->new User());
    //3、获取在Spring注册的对象
    User user = (User) context.getBean("user1");
    System.out.println(user);
}

8.4、整合JUnit5单元测试框架

1、Spring5框架支持整合JUnit5

2、整合JUnit4

• 第一步：引入Spring5相关针对测试依赖的jar包

  

  

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

  @RunWith(SpringJUnit4ClassRunner.class)//单元测试框架
  @ContextConfiguration("classpath:bean2.xml")//加载配置文件
  public class JTest4 {
      @Autowired
      private UserService userService;
  
      @Test
      public void test1() {
          userService.accountMoney();
      }
  }
  

3、Spring5整合JUnit5

• 第一步：引入JUnit5的jar包

  

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

  @ExtendWith(SpringExtension.class)
  @ContextConfiguration("classpath:bean2.xml")
  public class JTest5 {
      @Autowired
      private UserService userService;
  
      @Test
      public void test1() {
          userService.accountMoney();
      }
  }
  

4、使用一个复合注解替代上面两个注解完成整合

@SpringJUnitConfig(locations = "classpath:bean2.xml")
public class JTest5 {
    @Autowired
    private UserService userService;

    @Test
    public void test1() {
        userService.accountMoney();
    }
}

8.5、Webflux

8.5.1、SpringWebflux介绍

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

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

3、异步非阻塞

• 异步和同步
• 非阻塞和阻塞

上面都是针对对象不一样

• 异步和同步针对调用者
  • 调用者发送请求，如果等着对方回应之后才去做其他事情就是同步。
  • 如果发送请求之后不等着对方回应就去做其他事情就是异步。
• 非阻塞和阻塞针对被调用者
  • 被调用者收到请求之后，做完请求任务之后才给出反馈就是阻塞，阻塞需要等待。
  • 受到请求之后马上给出反馈然后再去做事情就是非阻塞，非阻塞不需要等待。

4、Webflux特点

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

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

5、比较SpringMVC 和Webflux

①两个框架都可以使用注解方式，都运行在Tomcat等容器中

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

8.5.2、响应式编程

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

8.5.2.1、Java实现响应式编程

1、Java8及其之前版本

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

public class ObserverDemo extends Observable {

    public static void main(String[] args) {
        ObserverDemo observer = new ObserverDemo();
        //添加观察者
        observer.addObserver((o,arg)->{
            System.out.println("发生变化");
        });
        observer.addObserver((o,arg)->{
            System.out.println("收到被观察者通知，准备改变");
        });
        //数据变化
        observer.setChanged();
        //通知
        observer.notifyObservers();
    }
}

8.5.2.2、Reactor实现响应式编程

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

2、Reactor有两个核心类：Mono和Flux，这两个类实现接口Publisher，提供吩咐操作符。

• Flux对象实现发布者，返回N个元素；
• Mono对象实现翻发布者，返回0或者1个元素。

3、Mono和Flux都是数据流的发布者，使用Mono和Flux都可以发出三种数据信号：

• 元素值
• 错误信号
• 完成信号

错误信号和完成信号都代表终止信号，终止信号用于告诉订阅者数据流结束了。错误信号终止数据流同时把错误信息传递给订阅者。

4、代码演示Mono和Flux

①引入依赖

<dependency>
    <groupId>io.projectreactor</groupId>
    <artifactId>reactor-core</artifactId>
    <version>3.1.5.RELEASE</version>
</dependency>

②编程代码

public class TestReactor {
    public static void main(String[] args) {
        //just方法直接声明
        Flux.just(1,2,3,4);
        Mono.just(1);

        //其他方法
        Integer[] array = {1,2,3,4};
        Flux.fromArray(array);

        List<Integer> list = Arrays.asList(array);
        Flux.fromIterable(list);

        Stream<Integer> stream = list.stream();
        Flux.fromStream(stream);
    }
}

5、三种信号特点：

• 错误信号和完成信号都是终止信号，不能共存的。
• 如果没有发送任何元素值，而是直接发送错误或者完成信号，表示是空数据流。
• 如果没有错误信号，没有完成信号，表示是无限数据流。

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

//just方法直接声明
Flux.just(1,2,3,4).subscribe(System.out::print);
Mono.just(1).subscribe(System.out::print);

7、操作符

• 对数据流进行一道道操作，成为操作符，比如工厂流水线

①map：元素映射为新元素

②flatMap：元素映射为流

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

8.5.2.3、SpringWebflux执行流程和核心API

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

2、Netty

①BIO：阻塞方式

②NIO：非阻塞方式

3、SpringWebflux执行过程和SPringMVC相似的

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

②接口WebHandler有一个方法：

4、SpringWebflux里面DispatchHandler，负责请求的处理

• HandlerMapping：请求查询到处理的方法
• HandlerAdapter：真正负责请求处理
• HandlerResultHandler：响应处理结果

5、SpringWebflux实现函数式编程，两个接口：

• RouterFunction：路由处理
• HandlerFunction：处理函数

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

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

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

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

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

②配置启动的端口号

③创建包和相关类

• 创建一个实体类

【User.java】

public class User {
    private String uname;
    private String gender;
    private Integer age;

    public User(String uname, String gender, Integer age) {
        this.uname = uname;
        this.gender = gender;
        this.age = age;
    }
}

• 创建接口定义操作的方法

//用户操作接口
public interface UserService {
    //根据id查询用户
    Mono<User> getUserById(int id);

    //查询所有用户
    Flux<User> getAllUser();
    
    //添加用户
    Mono<Void> savaUserInfo(Mono<User> user);
}

• 接口实现类

@Repository
public class UserServiceImpl implements UserService {

    //创建map集合存储数据
    private final Map<Integer, User> users = new HashMap<>();

    public UserServiceImpl() {
        this.users.put(1, new User("lucy","男",20));
        this.users.put(2, new User("mary","女",30));
        this.users.put(3, new User("Jack","女",25));
    }

    //根据id查询
    @Override
    public Mono<User> getUserById(int id) {
        return Mono.justOrEmpty(this.users.get(id));
    }

    //查询多个用户
    @Override
    public Flux<User> getAllUser() {
        return Flux.fromIterable(this.users.values());
    }

    //添加用户
    @Override
    public Mono<Void> savaUserInfo(Mono<User> userMono) {
        return userMono.doOnNext(person -> {
            //向map集合里面放值
            int id = users.size() + 1;
            users.put(id, person);
        }).thenEmpty(Mono.empty());
    }
}

• 创建controller

@RestController
public class UserController {
    //注入service
    @Autowired
    private UserService userService;

    //id查询
    @GetMapping("/user/{id}")
    public Mono<User> getUserById(@PathVariable int id) {
        return userService.getUserById(id);
    }

    //查询所有
    @GetMapping("/user")
    public Flux<User> getUsers() {
        return userService.getAllUser();
    }

    //添加
    @PostMapping("/savauser")
    public Mono<Void> savaUser(@RequestBody User user) {
        Mono<User> userMono = Mono.just(user);
        return userService.savaUserInfo(userMono);
    }
}

说明：

• SpringMVC方式实现，同步阻塞的方式，基于springMVC+Servlet+Tomcat。
• SpringWebflux方式实现，异步非阻塞方式，基于SpringWebflux+Reactor+Netty。

8.5.2.5、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(ServerRequest request) {
        //调用service方法得到结果
        Flux<User> users = this.userService.getAllUser();
        return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(users,User.class);
    }

    //添加
    public Mono<ServerResponse> savaUser(ServerRequest request) {
        //得到user对象
        Mono<User> userMono = request.bodyToMono(User.class);
        return ServerResponse.ok().build(this.userService.savaUserInfo(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 Exception{
      Server server = new Server();
      server.createReactorServer();
      System.out.println("enter to exit");
      System.in.read();
  }
  

④使用WebClient调用

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

        //根据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.getUname());

        //查询所有
        Flux<User> results = webClient.get().uri("/users")
                .accept(MediaType.APPLICATION_JSON).retrieve().bodyToFlux(User.class);
        results.map(stu -> stu.getUname())
                .buffer().doOnNext(System.out::println).blockFirst();
    }
}