java webflux函数式实现数据结构

我前面写的文章
java webflux注解方式写一个可供web端访问的数据接口
带大家写了个注解方式实现的webflux

首先使用函数式时您需要自己初始化服务器
使用函数式需要两个接口分别是 RouterFunction 和 HandlerFuncion
RouterFunction主要的作用就是分别一下任务例如添加直接被指派给添加的任务将任务交到对应的函数上
HandlerFuncion 这是处理请求操作的具体部分简单说就是执行你请求具体要做的内容

SpringWebflux请求和响应不再是ServletRequest和ServletResponse ，而是ServerRequest 和 ServerResponse 这两个主要是为了提供非阻塞异步支持的方法

话不多说上代码
先创建一个 Spring initiolar 项目

然后找到项目配置文件 pom.xml
引入webflux 和 web
参考代码如下

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

在这里插入图片描述
然后打开项目如下图箭头所指的这个目录

在项目创建我们项目所需要的结构包 entity,hondler,senvice
然后我们的项目就是这样的

在entity包下创建一个类叫 User 参考代码如下

package com.example.springapiweb.entity;

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

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

    public void setName(String name){
    
    
        this.name = name;
    };

    public void setGender(String gender) {
    
    
        this.gender = gender;
    }

    public void setAge(Integer age) {
    
    
        this.age = age;
    }
    public String getName(){
    
    
        return this.name;
    };
    public String getGender() {
    
    
        return this.gender;
    }
    public Integer getAge() {
    
    
        return this.age;
    }
}

简单创建了一个实体类创建了三个字段 name 用户名称 gender 性别 age 年龄写了他们对应的get set 和一个有参构造方法

然后呢我们这个项目就不直接去操作数据库啦

我们在 senvice 包下创建一个接口叫 UserService
参考代码如下

package com.example.springapiweb.senvice;

import com.example.springapiweb.entity.User;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

public interface UserService {
    
    
    //根据id查询用户
    Mono<User> getUserById(int id);
    //查询所有用户
    Flux<User> getAllUser();
    //添加用户
    Mono<Void> saveUserInfo (Mono<User> user);
}

我们在接口中定义了几个比较简单的用户操作方法

然后在 senvice 下创建一个包叫 impl 用于存放实现类在下面创建一个类叫 UserServiceImpl

参考代码如下

package com.example.springapiweb.senvice.impl;

import com.example.springapiweb.entity.User;
import com.example.springapiweb.senvice.UserService;
import org.springframework.stereotype.Repository;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;

import java.util.Map;
import java.util.HashMap;

@Repository
public class UserServiceImpl implements UserService {
    
    
    //创建map集合存储教据
    private final Map<Integer,User> users = new HashMap<>();

    //在构造方法中为map注入几条数据
    public UserServiceImpl(){
    
    
        this.users.put(1,new User("小猫猫","女",2));
        this.users.put(2,new User("小明","男",11));
        this.users.put(3,new User("服部半藏","男",32));
    }

    //根据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> saveUserInfo(Mono<User> userMono) {
    
    
        return userMono.doOnNext(person -> {
    
    
            //向map集合里面放值
            int id = users. size()+1;
            users.put(id,person);
        }).thenEmpty(Mono.empty());
    }
}

然后在hondler下创建一个类叫 UserHandler
参考代码如下

package com.example.springapiweb.hondler;

import com.example.springapiweb.entity.User;
import com.example.springapiweb.senvice.UserService;
import org.springframework.http.MediaType;
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 static org.springframework.web.reactive.function.BodyInserters.fromObject;

public class UserHandler {
    
    

    private final UserService userService;

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

    //根据id查询用户
    public Mono<ServerResponse> getUserById(ServerRequest request){
    
    
        int userid = Integer.valueOf(request.pathVariable("id"));
        Mono<User> userMono = this.userService.getUserById(userid);
        return userMono.flatMap(person -> ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(fromObject(person)));
    }

    //查询所有用户
    public Mono<ServerResponse> getAllUsers (ServerRequest request) {
    
    
        Flux<User> users = this. userService.getAllUser();
        return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON).body(users,User.class);
    }

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

}

ServerRequest 是一个函数式请求对象从里面可以调用pathVariable 拿到请求路径上的参数这里我们拿一个叫id的参数然后调用userService中的getUserById 拿到一个user类的对象通过id取回来的然后通过步骤转为json

那么这样整体的一个结构我们就搭好了

下面我们要通过 RouterFunction 做路由来进行一个调用

然后在src下创建一个类叫 Server 参考代码如下

package com.example.springapiweb;

import com.example.springapiweb.hondler.UserHandler;
import com.example.springapiweb.senvice.UserService;
import com.example.springapiweb.senvice.impl.UserServiceImpl;
import org.springframework.http.server.reactive.HttpHandler;
import org.springframework.http.server.reactive.ReactorHttpHandlerAdapter;
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 reactor.netty.http.server.HttpServer;

import java.io.IOException;

import static org.springframework.http.MediaType.APPLICATION_JSON;
import static org.springframework.web.reactive.function.server.RequestPredicates.GET;
import static org.springframework.web.reactive.function.server.RequestPredicates.accept;
import static org.springframework.web.reactive.function.server.RouterFunctions.toHttpHandler;

public class Server {
    
    
    public static void main(String[] args) throws IOException {
    
    
        Server server = new Server();
        server.createReactorServer();
        System.out.println("enter to exit");
        System.in.read();
    }
    //1创建Router路由
    public RouterFunction<ServerResponse> routingFunction() {
    
    
        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);

    }
    public void createReactorServer() {
    
    
        RouterFunction<ServerResponse> route = routingFunction();
        HttpHandler httpHandler = toHttpHandler(route);
        ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(httpHandler);
        HttpServer httpServer = HttpServer. create();
        httpServer.handle(adapter).bindNow();
    }
}

我们这个要靠main执行在main上右键选择启动
在这里插入图片描述
然后项目就起来了我们拿到系统给的端口

直接访问 http://localhost:端口/users/1
例如我这里运行结果如下
在这里插入图片描述
这里我们访问的就是 id为1的用户啦
然后我们试所有用户

也没有任何问题

java webflux函数式实现数据结构

猜你喜欢