WebFlux

Webflux是SpringFramework5.0添加的新功能，WebFlux是追随Reactive Programming（响应式/反应式）而诞生的框架。

Flux和Mono：

1）Flux和 Mono是响应式/反应式编程中的两个基本概念。

2）Flux表示的是包含0到N个元素的异步序列；在该序列中可以包含三种不同类型的消息通知：正常的包含元素的消息、序列结束的消息和序列出错的消息。当消息通知产生时，订阅者中对应的方法：onNext()，onComplete()和onError()会被调用。

3）Mono表示的是包含0或者1个元素的异步序列；该序列中同样可以包含与 Flux相同的三种类型的消息通知。

4）Flux和Mono之间可以进行转换。对一个Flux序列进行计数操作，得到的结果是一个Mono对象；把两个Mono序列合并在一起，得到的是一个Flux对象。

SpringBoot的WebFlux案例

pom.xml

<properties>
    <java.version>1.8</java.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webflux</artifactId>
    </dependency>
    <dependency>
        <groupId>com.baomidou</groupId>
        <artifactId>mybatis-plus-boot-starter</artifactId>
        <version>3.4.1</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
    <dependency>
        <groupId>io.projectreactor</groupId>
        <artifactId>reactor-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
        <optional>true</optional>
    </dependency>
</dependencies>

<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

配置文件application.yml：

spring:
  datasource:
    url: jdbc:mysql://192.168.1.2:3306/cloud_supply?useUnicode=true&characterEncoding=utf8&serverTimezone=GMT%2B8
    username: root
    password: 123456
    driver-class-name: com.mysql.cj.jdbc.Driver
logging:
  level:
    com.what21.cloud.mapper.mapper: debug

实体对象类：

package com.what21.cloud.model;

import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Builder;
import lombok.Data;

@Data
@Builder
@TableName("t_school")
public class School {

    @TableId
    private Integer schoolId;

    private String schoolName;

    private String city;
}

mapper：

package com.what21.cloud.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.what21.cloud.model.School;
import org.apache.ibatis.annotations.Mapper;

@Mapper
public interface SchoolMapper extends BaseMapper<School> {

}

service：

package com.what21.cloud.service;

import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.what21.cloud.mapper.SchoolMapper;
import com.what21.cloud.model.School;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
public class SchoolService {

    @Autowired
    private SchoolMapper schoolMapper;

    public List<School> list() {
        return schoolMapper.selectList(null);
    }

    public School getById(Integer schoolId) {
        return schoolMapper.selectById(schoolId);
    }

    @Transactional(rollbackFor = Exception.class)
    public Integer insert(School school) {
        return schoolMapper.insert(school);
    }

    @Transactional(rollbackFor = Exception.class)
    public Integer updateRow(School school) {
        return schoolMapper.updateById(school);
    }

    @Transactional(rollbackFor = Exception.class)
    public Integer updateName(School school) {
        UpdateWrapper<School> updateWrapper = new UpdateWrapper<>();
        updateWrapper.set("school_name", school.getSchoolName());
        updateWrapper.eq("school_id", school.getSchoolId());
        return schoolMapper.update(school, updateWrapper);
    }

    @Transactional(rollbackFor = Exception.class)
    public Integer delete(Integer id) {
        return schoolMapper.deleteById(id);
    }

}

controller：

package com.what21.cloud.controller;

import com.what21.cloud.model.School;
import com.what21.cloud.service.SchoolService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

@RestController
@RequestMapping("/schools")
@Slf4j
public class SchoolController {

    @Autowired
    private SchoolService schoolService;

    @GetMapping(path="/list")
    public Flux<School> list() {
        return Flux.fromIterable(schoolService.list());
    }

    @GetMapping(path="/get/{id}")
    public Mono<School> getById(@PathVariable Integer id) {
        return Mono.just(schoolService.getById(id));
    }

    @PostMapping(path="/add")
    public Mono<Integer> insert(@RequestBody School school) {
        return Mono.just(schoolService.insert(school));
    }

    @PostMapping(path="/modify")
    public Mono<Integer> updateRow(@RequestBody School school) {
        return Mono.just(schoolService.updateRow(school));
    }

    @GetMapping(path="/delete")
    public Mono<Integer> delete(@PathVariable Integer id) {
        return Mono.just(schoolService.delete(id));
    }

}

数据库表：

CREATE TABLE `t_school` (
  `school_id` bigint(20) NOT NULL,
  `school_name` varchar(45) DEFAULT NULL,
  `city` varchar(45) DEFAULT NULL,
  PRIMARY KEY (`school_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

测试情况：

1）http://127.0.0.1:8080/schools/list

2）http://127.0.0.1:8080/schools/get/1111

3）http://127.0.0.1:8080/schools/delete/1111

4）http://127.0.0.1:8080/schools/add

5）http://127.0.0.1:8080/schools/modify