基于Springboot + Webflux响应式编程搭建Web项目

已于 2022-09-04 10:10:54 修改
阅读量583 收藏 5
点赞数 1
分类专栏： springboot 文章标签： spring boot java spring
于 2022-09-03 23:48:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_56018532/article/details/126684226
版权

目录

1、pom.xml文件

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.7.0</version>
    </parent>

    <groupId>com.coffee</groupId>
    <artifactId>webflux-demo</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
        <mybatis.verison>2.2.2</mybatis.verison>
    </properties>

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

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-r2dbc</artifactId>
        </dependency>
        <!--  r2dbc 连接池 -->
        <dependency>
            <groupId>io.r2dbc</groupId>
            <artifactId>r2dbc-pool</artifactId>
        </dependency>
        <!--r2dbc mysql 库-->
        <dependency>
            <groupId>dev.miku</groupId>
            <artifactId>r2dbc-mysql</artifactId>
            <version>0.8.2.RELEASE</version>
        </dependency>

        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
    </dependencies>

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

2、主启动类

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

@SpringBootApplication
public class WebFluxApplication {
    public static void main(String[] args) {
        SpringApplication.run(WebFluxApplication.class, args);
    }
}

3、实体类

import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import org.springframework.data.annotation.Id;
import org.springframework.data.relational.core.mapping.Column;
import org.springframework.data.relational.core.mapping.Table;

import java.io.Serializable;

@Data
@AllArgsConstructor
@NoArgsConstructor
@Table("people")
public class People implements Serializable {
    private static final long serialVersionUID = 620950479129453625L;

    @Id
    @Column("id")
    private Integer id;

    @Column("username")
    private String username;

    @Column("gender")
    private String gender;

    @Column("address")
    private String address;
}

4、dao层

import com.coffee.webflux.samples.entity.People;
import org.springframework.data.r2dbc.repository.R2dbcRepository;
import org.springframework.stereotype.Repository;

@Repository
public interface PeopleRepository extends R2dbcRepository<People, Integer> {

}

5、Handler层

方式一：使用PeopleRepository
import com.coffee.webflux.samples.dao.PeopleRepository;
import com.coffee.webflux.samples.entity.People;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Mono;

import javax.annotation.Resource;

@Component
public class PeopleRepositoryHandler {

    @Resource
    private PeopleRepository peopleRepository;

    // 查询所有
    public Mono<ServerResponse> listPeople(ServerRequest request) {
        return ServerResponse.ok()
                .contentType(MediaType.APPLICATION_JSON)
                .body(peopleRepository.findAll(), People.class);
    }

    // 根据主键查询
    public Mono<ServerResponse> findPeopleById(ServerRequest request) {
        int personId = Integer.parseInt(request.pathVariable("id"));
        return peopleRepository.findById(personId)
                .flatMap(people -> ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).bodyValue(people))
                .switchIfEmpty(ServerResponse.notFound().build());
    }

    // 根据主键删除
    public Mono<ServerResponse> deletePeople(ServerRequest request) {
        return this.peopleRepository.findById(Integer.parseInt(request.pathVariable("id")))
                .flatMap(user -> ServerResponse
                        .noContent()
                        .build(this.peopleRepository.delete(user)))
                .switchIfEmpty(ServerResponse.notFound().build());
    }

    // 插入数据
    public Mono<ServerResponse> insertPeople(ServerRequest request) {
        Mono<People> peopleMono = request.bodyToMono(People.class)
                .flatMap(people -> peopleRepository.save(people));
        return ServerResponse.ok().body(peopleMono, People.class);
    }
}
方式二：使用R2dbcEntityTemplate
import com.coffee.webflux.samples.entity.People;
import org.springframework.data.r2dbc.core.R2dbcEntityTemplate;
import org.springframework.data.relational.core.query.Query;
import org.springframework.data.relational.core.query.Update;
import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import javax.annotation.Resource;

import static org.springframework.data.relational.core.query.Criteria.where;

@Component
public class PeopleR2dbcTemplateHandler {

    @Resource
    private R2dbcEntityTemplate r2dbcEntityTemplate;

    // 查询所有
    public Mono<ServerResponse> listPeople(ServerRequest request) {
        Flux<People> peopleFlux = r2dbcEntityTemplate.select(Query.empty(), People.class);
        return ServerResponse.ok()
                .contentType(MediaType.APPLICATION_JSON)
                .body(peopleFlux, People.class);
    }

    // 根据主键查询
    public Mono<ServerResponse> findPeopleById(ServerRequest request) {
        int personId = Integer.parseInt(request.pathVariable("id"));
        Mono<People> peopleMono = r2dbcEntityTemplate.selectOne(Query.query(where("id").is(personId)), People.class);
        return peopleMono
                .flatMap(people -> ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).bodyValue(people))
                .switchIfEmpty(ServerResponse.notFound().build());
    }

    // 根据名字模糊查询
    public Mono<ServerResponse> findPeopleByUsernameContains(ServerRequest request) {
        String name = request.pathVariable("name");
        Flux<People> peopleFlux = r2dbcEntityTemplate.select(People.class)
                .matching(Query.query(where("username").like("%" + name + "%")).limit(10).offset(0))
                .all();
        return ServerResponse.ok()
                .contentType(MediaType.APPLICATION_JSON)
                .body(peopleFlux, People.class);
    }

    // 根据主键删除
    public Mono<ServerResponse> deletePeople(ServerRequest request) {
        int personId = Integer.parseInt(request.pathVariable("id"));
        Mono<Integer> deleteMono = r2dbcEntityTemplate.delete(Query.query(where("id").is(personId)), People.class);
        return ServerResponse.ok()
                .build(deleteMono.then());
    }

    // 根据主键进行更新
    public Mono<ServerResponse> updatePeople(ServerRequest request) {
        Mono<Integer> resultMono = request.bodyToMono(People.class)
                .flatMap(people -> r2dbcEntityTemplate.update(Query.query(where("id").is(people.getId())),
                        Update.update("username", people.getUsername())
                                .set("address", people.getAddress()),
                        People.class));
        return ServerResponse.ok()
                .build(resultMono.then());
    }

    // 插入数据
    public Mono<ServerResponse> insertPeople(ServerRequest request) {
        Mono<People> peopleMono = request.bodyToMono(People.class)
                .flatMap(people -> r2dbcEntityTemplate.insert(People.class).using(people));
        return ServerResponse.ok().body(peopleMono, People.class);
    }
}

6、router层

import com.coffee.webflux.samples.handler.PeopleR2dbcTemplateHandler;
import com.coffee.webflux.samples.handler.PeopleRepositoryHandler;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.server.RequestPredicates;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.RouterFunctions;
import org.springframework.web.reactive.function.server.ServerResponse;

import javax.annotation.Resource;

@Configuration
public class PeopleRouter {

    @Resource
    private PeopleRepositoryHandler peopleRepositoryHandler;

    @Resource
    private PeopleR2dbcTemplateHandler peopleR2dbcTemplateHandler;

    @Bean
    public RouterFunction<ServerResponse> peopleRepositoryRoutes() {
        return RouterFunctions.route()
                .GET("/repository/listPeople", RequestPredicates.accept(MediaType.APPLICATION_JSON), peopleRepositoryHandler::listPeople)
                .GET("/repository/getPeople/{id}", RequestPredicates.accept(MediaType.APPLICATION_JSON), peopleRepositoryHandler::findPeopleById)
                .POST("/repository/insertPeople", RequestPredicates.accept(MediaType.APPLICATION_JSON), peopleRepositoryHandler::insertPeople)
                .DELETE("/repository/deletePeople/{id}", RequestPredicates.accept(MediaType.APPLICATION_JSON), peopleRepositoryHandler::deletePeople)
                .build();
    }

    @Bean
    public RouterFunction<ServerResponse> peopleR2dbcTemplateRoutes() {
        return RouterFunctions.route()
                .GET("/template/listPeople", RequestPredicates.accept(MediaType.APPLICATION_JSON), peopleR2dbcTemplateHandler::listPeople)
                .GET("/template/listPeople/{name}", RequestPredicates.accept(MediaType.APPLICATION_JSON), peopleR2dbcTemplateHandler::findPeopleByUsernameContains)
                .GET("/template/getPeople/{id}", RequestPredicates.accept(MediaType.APPLICATION_JSON), peopleR2dbcTemplateHandler::findPeopleById)
                .POST("/template/insertPeople", RequestPredicates.accept(MediaType.APPLICATION_JSON), peopleR2dbcTemplateHandler::insertPeople)
                .POST("/template/updatePeople", RequestPredicates.accept(MediaType.APPLICATION_JSON), peopleR2dbcTemplateHandler::updatePeople)
                .DELETE("/template/deletePeople/{id}", RequestPredicates.accept(MediaType.APPLICATION_JSON), peopleR2dbcTemplateHandler::deletePeople)
                .build();
    }
}

7、application.properties

server.port=8080

spring.r2dbc.username=root
spring.r2dbc.password=root
spring.r2dbc.url=r2dbc:mysql://localhost:3306/test?characterEncoding=UTF-8&useSSL=false&allowPublicKeyRetrieval=true
spring.r2dbc.pool.enabled=true

logging.level.org.springframework.r2dbc=DEBUG

至此，整合数据库实现增删改查的一个简单响应式编程Web项目就搭建完成。详细的项目目录结构如下图：

在这里插入图片描述

david6969xin
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring Boot： 响应式编程以及 Spring Boot Webflux 快速入门
m0_46411313的博客
06-11 324
什么是响应式编程 在计算机中，响应式编程或反应式编程（英语：Reactive programming）是一种面向数据流和变化传播的编程范式。这意味着可以在编程语言中很方便地表达静态或动态的数据流，而相关的计算模型会自动将变化的值通过数据流进行传播。 例如，在命令式编程环境中，a=b+c 表示将表达式的结果赋给 a，而之后改变 b 或 c 的值不会影响 a 。但在响应式编程中，a 的值会随着 b 或 c 的更新而更新。 响应式编程是基于异步和事件驱动的非阻塞程序，只需要在程序内启动少量线程扩展，而不是水..
使用 Spring Boot 2.0 + WebFlux 实现 RESTful API功能
08-28
什么是 Spring WebFlux, 它是一种异步的, 非阻塞的, 支持背压(Back pressure)机制的Web 开发框架.下面通过本文给大家介绍使用 Spring Boot 2.0 + WebFlux 实现 RESTful API功能，需要的朋友参考下吧
WebFlux02 SpringBoot WebFlux项目骨架搭建
weixin_30375247的博客
06-26 78
1 环境搭建 　　1.1 版本说明 　　　　jdk -> 1.8 　　　　maven -3.5 　　　　springboot -> 2.0.3 　　　　开发工具 -> IDEA 　　1.2 创建项目 　　　　利用 IDEA 或者 start.spring.io 创建一个SpringBoot项目 　　　　1.2.1 选择依赖 　　　　　　 　　　　1.2...
Spring Boot集成webflux快速入门Demo
最新发布
HBLOG
04-12 553
1.webflux介绍Spring WebFlux是一个异步非阻塞式的WEB框架，它能够充分利用多核CPU的硬件资源去处理大量的并发请求，而Spring MVC是构建于Servlet API之上，使用的是同步阻塞式I/O模型，即每一个请求对应一个线程去处理。2.WebFlux 与 Spring MVC 区别WebFlux：异步非阻塞： WebFlux 基于反应式编程模型，支持非阻塞 I/O，能够充...
【SpringBoot】集成 Web Flux
qq_37921808的博客
12-13 299
前言: 必需学会SpringBoot基础知识 简介: Takes an opinionated view of building production-ready Spring applications. Spring Boot favors convention over configuration and is designed to get you up and running ...
webflux-2-项目搭建
屋顶小黑猫
03-09 273
SpringBoot 2.3.1 + jdk1.8 第一步新建项目，pom加入，这里只贴出核心的，最后会放上完整的项目地址 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-webflux</artifactId> </dependency&...
SpringBoot+maven+Mybatis+tkMybatis+WebFlux+pagehelper+Redis+thymeleaf响应式单体项目
04-24
目标：本示例说明SFM...6、如果一切正常，你会看到我们使用SpringBoot整合Spring+MyBatis+tkMabtis+pagehelper+redis+webFlux的响应式单体并高web应用项目。 目的：希望学习springboot开发SFM响应式应用的小白们。
基于springboot+vue的网上书店系统源码.zip
05-12
基于springboot+vue的网上书店系统 开发语言：Java 框架：springboot JDK版本：JDK1.8 服务器：tomcat7 数据库：mysql 5.7 数据库工具：Navicat 开发软件：eclipse/myeclipse/idea Maven包：Maven3.3.9 浏览器：...
基于SpringBoot+MyBatis前后端开发的博客网站项目源码.zip
01-06
1、基于SpringBoot+MyBatis前后端开发的博客网站项目源码.zip 2、该资源包括项目的全部源码，下载可以直接使用！ 3、本项目适合作为计算机、数学、电子信息等专业的课程设计、期末大作业和毕设项目，作为参考资料...
java基于springboot+vue的博客网站论文
06-08
java基于springboot+vue的博客网站论文 目 录 摘 要 I ABSTRACT II 目 录 II 第1章 绪论 1 1.1背景及意义 1 1.2 国内外研究概况 1 1.3 研究的内容 1 第2章 相关技术 3 2.1 B/S架构 4 2.2 Java技术介绍 6 2.3 mysql...
基于springboot+vue的商城管理系统源码+数据库（高分毕业设计）.zip
06-08
基于springboot+vue的商城管理系统源码+数据库（高分毕业设计）.zip 高分毕业设计项目，代码完整下载可用，纯手打高分毕业设计，也可作为期末大作业和课程设计，小白也可实战。 基于springboot+vue的商城管理系统...
最完整的WebFlux项目可运行
11-02
这是一个最完整Webflux项目，而且是可以运行，里面用到了redis，以及redis工具类，使用的是java10，Gradle, IDEA2018,适合java开发的人，很不错哦
WebFlux
qq_64268646的博客
10-18 1614
WebFlux
基于Spring Webflux 搭建基本代码框架2
chenbj123的博客
10-08 291
本篇文章将继续按照上篇文章基于Spring Webflux 搭建基本代码框架1，完成RouterFunction模式的改造方式。 一、主要改造点 在传统Controller模式下的代码基础上进一步做如下改造： 1、取消Controller入口层，相关入口路径定义转换为router层； 2、取消service业务逻辑层，相关业务逻辑统一收归到handler层； 3、参数校验等逻辑需要单独自行代码实现； 4、全局异常处理逻辑调整为通过WebExceptionHandler实现； 改造后的代码结构如下： 二、代
【WEB篇】Spring Boot 整合 Webflux
csp732171109的博客
04-21 2087
WebFlux Spring WebFlux 是一个异步非阻塞式的 Web 框架，它能够充分利用多核 CPU 的硬件资源去处理大量的并发请求。 WebFlux 内部使用的是响应式编程（Reactive Programming），以 Reactor 库为基础, 基于异步和事件驱动，可以让我们在不扩充硬件资源的前提下，提升系统的吞吐量和伸缩性。WebFlux 并不能使接口的响应时间缩短，它仅仅能够提升吞吐量和伸缩性。 Spring Reactor Spring Reactor 是一个反应式库，用于根据反应式流规
完美解决springboot打包成jar包，前端项目启动问题
qq_18453581的博客
07-12 2971
1.打包成jar包 spring： resources: static-locations: classpath:/public,classpath:/static,file:D:/Home/Projects/Web/ppt-report/public 2.将前端的文件放置public下面，file：D:/.....这路径是上传路径 3.启动，再也不用用外置Tomcat了，关键...
Spring WebFlux特性
小石潭记丶
09-03 702
Spring Boot 2.0 WebFlux 学习传送门：https://blog.csdn.net/jeffli1993/article/details/79941175 特性一 异步非阻塞 众所周知，SpringMVC是同步阻塞的IO模型，资源浪费相对来说比较严重，当我们在处理一个比较耗时的任务时，例如：上传一个比较大的文件，首先，服务器的线程一直在等待接收文件，在这期间它就像个傻子一样...
webFlux入门
struggle的博客
03-04 9978
1. WebFlux介绍 2. Spring WebFlux Framework 3. Hello WebFlux 4. Reactor 核心特性 5. Spring Data Redis
使用 Spring boot家族之 WebFlux 开发反应式 Web 应用(六)
伴生战骨
07-10 324
Spring 5 的 WebFlux 开发反应式 Web 应用WebFlux 简介Java 注解编程模型清单 1. Hello World 示例REST API Spring 5 是流行的 Spring 框架的下一个重大的版本升级。Spring 5 中最重要改动是把反应式编程的思想应用到了框架的各个方面，Spring 5 的反应式编程以 Reactor 库为基础。在之前的文章《使用 Reactor 进行反应式编程》中，已经对 Reactor 库进行了详细的介绍。读者如果需要了解 Reactor，可以参考之
基于springboot+vue网上书城项目
01-09
基于springboot vue网上书城项目是一个基于现代化技术的网上书城应用系统。该项目利用了springboot作为后端框架，用来处理业务逻辑和数据持久化，并且使用了vue作为前端框架，用来实现用户界面和交互操作。 该网上...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值