快乐非自愿
快乐非自愿

深度长文解析SpringWebFlux响应式框架15个核心组件源码

Spring WebFlux 介绍

Spring WebFlux 是 Spring Framework 5.0 版本引入的一个响应式 Web 框架，它与 Spring MVC 并存，提供了一种全新的编程范式，支持异步非阻塞的 Web 应用开发。WebFlux 完全基于响应式编程模型，支持 Reactive Streams 规范，可以在诸如 Netty、Undertow 以及 Servlet 3.1+ 容器上运行。

WebFlux 的核心控制器是 DispatcherHandler，它类似于 Spring MVC 中的 DispatcherServlet，负责将请求分发给相应的处理器。DispatcherHandler 通过查找 Spring 配置中的 HandlerMapping、HandlerAdapter 和 HandlerResultHandler 来处理请求。

在 WebFlux 中，Flux 和 Mono 是 Reactor 库中的两个基本概念，分别用于表示包含 0 到 N 个元素和 0 或 1 个元素的异步序列。Flux 可以用于表示一个包含多个响应式元素的流，而 Mono 用于表示单个元素的响应式流。

Spring WebFlux 支持多种编程模式，包括基于注解的控制器和函数式端点。开发者可以使用 @RestController 注解来创建响应式控制器，并使用 @GetMapping、@PostMapping 等注解来处理 HTTP 请求。同时，WebFlux 也支持使用 WebClient 作为非阻塞的 HTTP 客户端来与其它服务进行通信。

WebFlux 的并发模型与传统的 Spring MVC 有显著不同。它利用了少量的线程来处理大量的并发请求，这得益于其非阻塞的特性。当运行在 Netty 服务器上时，WebFlux 使用事件循环线程来处理请求，避免了传统 Servlet 容器中每个请求都需要一个线程的模型。

Spring WebFlux 的适用场景主要是 IO 密集型的应用，例如微服务网关，它可以显著提升对下游服务转发的吞吐量。然而，如果现有的 Spring MVC 应用能够满足性能需求，并且项目中使用了许多基于 Servlet 线程模型的库，那么可能没有必要迁移到 WebFlux。

源码层面，Spring WebFlux 的请求处理流程涉及到多个组件，包括 Netty 服务器的初始化、请求的接收、DispatcherHandler 的请求分发，以及最终的请求处理和响应。在 Netty 服务器中，请求处理涉及到 ChannelHandler，ConnectionObserver，以及 HttpHandler 等多个组件。这些组件协同工作，实现了 WebFlux 的非阻塞和响应式特性。

Spring WebFlux 都有哪些核心组件

Spring WebFlux 包含多个核心组件，它们共同构成了完整的响应式 Web 应用框架。下面是一些主要的核心组件：

  1. DispatcherHandler：这是 WebFlux 的中央调度器，类似于 Spring MVC 中的 DispatcherServlet。它负责发现和调度 HTTP 请求处理器（handlers），并处理请求映射、调用和结果处理。

  2. HandlerMapping：这个接口用于将请求映射到对应的处理器（handler）。它在应用程序上下文中被检测到，并用于确定请求应该由哪个处理器处理。

  3. HandlerAdapter：这个接口帮助 DispatcherHandler 调用任何类型的处理器，而不需要关心具体的调用方式。它为不同的处理器提供了调用策略。

  4. HandlerResultHandler：这个接口处理处理器调用后的结果，并生成最终的响应。它负责将处理器的结果转换为客户端可以接收的格式。

  5. WebFilter：WebFilter 接口定义了一组过滤器，这些过滤器可以对请求和响应进行预处理和后处理。

  6. ServerWebExchange：这个类封装了 HTTP 请求和响应的所有信息，例如请求头、请求体、URI、参数等。

  7. ServerHttpRequest 和 ServerHttpResponse：这两个类分别代表服务器接收的 HTTP 请求和发送的 HTTP 响应。

  8. WebSession：用于管理特定客户端的会话信息。

  9. Reactive Streams：WebFlux 基于 Reactive Streams 规范，使用非阻塞背压机制来处理数据流。

  10. Reactor 库：作为 Spring 5 的反应式编程基础，Reactor 提供了非阻塞的编程模型和工具，包括 Flux 和 Mono 等反应式类型。

  11. WebClient：这是 Spring 5 中引入的非阻塞、支持响应式流的 HTTP 客户端，用于与其它服务进行通信。

  12. Spring Data Reactive：提供对响应式数据访问的支持，例如 Reactive Repositories。

  13. Spring Security Reactive：提供对响应式安全访问控制的支持。

  14. HttpHandler：定义了最低级别的反应式 HTTP 请求处理合同，作为不同运行时之间的共同基础。

  15. ContextPathCompositeHandler：允许在不同的上下文路径上注册多个应用程序。

这些组件共同工作，为开发人员提供了一个强大且灵活的响应式 Web 应用开发平台。通过这些组件，开发者可以构建出能够高效处理大量并发请求的应用程序。下面针对这些组件，V 哥将一一详细介绍核心源码的实现过程，帮助兄弟们彻底理解。

1. DispatcherHandler

DispatcherHandler 是 Spring WebFlux 的核心组件，它的作用类似于 Spring MVC 中的 DispatcherServlet。它负责将传入的 HTTP 请求分发给相应的处理器（handler），并处理请求的映射、调用和结果处理。以下是对 DispatcherHandler 组件源码实现逻辑和步骤的详细分析：

初始化过程

  • ApplicationContextAware 实现：DispatcherHandler 实现了 ApplicationContextAware 接口，这意味着它可以访问到 Spring 应用上下文中的 Bean。

  • HandlerMapping、HandlerAdapter 和 HandlerResultHandler 的初始化：DispatcherHandler 在初始化时会查找 Spring 应用上下文中所有的 HandlerMapping、HandlerAdapter 和 HandlerResultHandler 并初始化它们。

    protected void initStrategies(ApplicationContext context) {
        // ... 省略部分代码 ...
        this.handlerMappings = ...;
        this.handlerAdapters = ...;
        this.resultHandlers = ...;
    }

请求处理过程

  • 获取 HandlerMappings：DispatcherHandler 会通过 handlerMappings 来查找能够处理当前请求的 HandlerMapping。

  • 映射请求到 Handler：使用找到的 HandlerMapping 将请求映射到具体的处理器（可能是一个 @Controller 方法或者一个 RouterFunction）。

  • 调用 Handler：一旦找到处理器，DispatcherHandler 会使用适当的 HandlerAdapter 来调用处理器。

  • 处理结果：处理器的执行结果会被 HandlerResultHandler 处理，生成响应。

核心方法：handle

DispatcherHandler 的核心方法是 handle，它定义了请求处理的流程：

public Mono handle(ServerWebExchange exchange) {
    // 检查是否初始化了 handlerMappings
    if (this.handlerMappings == null) {
        return createNotFoundError();
    }
    // 使用 handlerMappings 来查找 handler
    return Flux.fromIterable(this.handlerMappings)
            .concatMap(mapping -> mapping.getHandler(exchange))
            .next() // 获取第一个 handler
            .switchIfEmpty(createNotFoundError()) // 如果没有找到 handler，返回错误
            .flatMap(handler -> invokeHandler(exchange, handler)) // 调用 handler
            .flatMap(result -> handleResult(exchange, result)); // 处理结果
}

错误处理

  • createNotFoundError：如果没有找到合适的处理器，DispatcherHandler 会创建一个表示 "Not Found" 的响应。

其他组件的协同工作

  • HandlerMapping：负责将请求 URL 映射到具体的处理器。

  • HandlerAdapter：负责调用具体的处理器，Spring WebFlux 支持多种类型的处理器，HandlerAdapter 使得 DispatcherHandler 无需关心具体的调用细节。

  • HandlerResultHandler：负责处理处理器的返回值，并将其转换为 HTTP 响应。

DispatcherHandler 的设计使得它非常灵活，可以很容易地扩展新的 HandlerMapping、HandlerAdapter 或 HandlerResultHandler 来支持不同的处理器类型和返回类型。

以上就是 DispatcherHandler 组件的源码实现逻辑和步骤的分析。通过这种方式，Spring WebFlux 能够以非阻塞的方式处理 Web 请求，提高应用的性能和可伸缩性。

2. HandlerMapping

HandlerMapping 是 Spring WebFlux 中的一个接口，它定义了将请求映射到处理器（handler）的逻辑。HandlerMapping 的实现类负责根据请求的类型、URL 模式等信息来确定哪个具体的处理器应该处理当前的请求。以下是对 HandlerMapping 组件的源码实现逻辑和步骤的详细分析：

HandlerMapping 接口定义

HandlerMapping 接口定义了以下关键方法：

public interface HandlerMapping {
    Mono getHandler(ServerWebExchange exchange);
    void afterPropertiesSet();
} 
  
 
  
     
   
  •  
    getHandler：根据给定的 ServerWebExchange 对象，返回一个 Mono 对象，该 Mono 完成时包含请求的处理器。
     
    •  
  
 
  
 
  
     
   
  •  
    afterPropertiesSet：在所有属性都设置之后调用，允许 HandlerMapping 实现进行初始化。
     
    •  
  
 
  
 
  
主要实现类
 
  
 
  
Spring WebFlux 提供了几个 HandlerMapping 的实现类，主要包括：
 
  
 
  
     
   
  •  
    RequestMappingHandlerMapping：处理基于注解的映射，例如 @RequestMapping、@GetMapping 等。
     
    •  
  
 
  
 
  
     
   
  •  
    RouterFunctionMapping：处理基于 RouterFunction 的函数式路由。
     
    •  
  
 
  
 
  
     
   
  •  
    SimpleUrlHandlerMapping：处理简单的 URL 到对象的映射。
     
    •  
  
 
  
 
  
RequestMappingHandlerMapping 源码分析
 
  
 
  
RequestMappingHandlerMapping 是最常用的 HandlerMapping 实现之一，下面是它的一些关键实现逻辑：
 
  
 
  
     
   
  •  
    注册和解析：在初始化时，RequestMappingHandlerMapping 会扫描所有的 beans，查找带有 @RequestMapping 注解的方法，并注册这些方法作为请求的处理器。
     
    •  
  
 
  
 
  
     
   
  •  
    映射处理：RequestMappingHandlerMapping 使用 Pattern 对象来存储和匹配 URL 模式。
     
    •  
  
 
  
 
  
     
   
  •  
    getHandler 方法实现：
     
    •  
  
 
  
 
  
@Override
public Mono getHandler(ServerWebExchange exchange) {
    String lookupPath = getPath(exchange);
    return getHandlerInternal(exchange)
            .filter(h -> matchesRoute(lookupPath, h))
            .switchIfEmpty(Mono.defer(() -> getBestMatchingHandler(lookupPath, exchange)));
} 
  
 
  
     
   
  •  
    getPath：从 ServerWebExchange 中提取请求路径。
     
    •  
  
 
  
 
  
     
   
  •  
    getHandlerInternal：返回一个包含所有注册处理器的 Mono。
     
    •  
  
 
  
 
  
     
   
  •  
    filter 和 matchesRoute：检查处理器是否与请求路径匹配。
     
    •  
  
 
  
 
  
     
   
  •  
    getBestMatchingHandler：如果没有找到精确匹配的处理器，尝试找到最佳匹配的处理器。
     
    •  
  
 
  
 
  
映射匹配逻辑
 
  
 
  
映射匹配逻辑通常涉及以下步骤：
 
  
 
  
     
   
  •  
    路径匹配：检查请求的路径是否与注册的 URL 模式匹配。
     
    •  
  
 
  
 
  
     
   
  •  
    请求方法匹配：如果 URL 模式匹配，进一步检查请求的方法（GET、POST 等）是否与处理器支持的方法匹配。
     
    •  
  
 
  
 
  
     
   
  •  
    参数条件匹配：检查请求是否包含处理器所需的参数。
     
    •  
  
 
  
 
  
     
   
  •  
    头信息匹配：检查请求头是否满足特定的条件。
     
    •  
  
 
  
 
  
     
   
  •  
    消费和产生媒体类型匹配：检查请求的 Accept 头和 Content-Type 是否与处理器支持的媒体类型匹配。
     
    •  
  
 
  
 
  
性能优化
 
  
 
  
RequestMappingHandlerMapping 还实现了一些性能优化措施，例如缓存匹配的 URL 模式，以减少重复的模式匹配操作。
 
  
 
  
小结一下
 
  
 
  
HandlerMapping 组件是 Spring WebFlux 请求处理流程中的关键部分，它负责将进入的请求映射到正确的处理器。通过使用不同的 HandlerMapping 实现，Spring WebFlux 支持灵活的请求映射策略，以适应不同的应用场景。
 
  
 
  
3. HandlerAdapter
 
  
 
  
HandlerAdapter 接口在 Spring WebFlux 中扮演着至关重要的角色，它的作用是将 DispatcherHandler 找到的处理器（handler）适配到具体的执行逻辑上。HandlerAdapter 使得 DispatcherHandler 无需关心具体的处理器类型，只需要通过 HandlerAdapter 来调用处理器即可。以下是对 HandlerAdapter 组件的源码实现逻辑和步骤的详细分析：
 
  
 
  
HandlerAdapter 接口定义
 
  
 
  
HandlerAdapter 接口定义了以下关键方法：
 
  
 
  
public interface HandlerAdapter {
    boolean supports(Object handler);
    Mono handle(ServerWebExchange exchange, Object handler, Object... args);
}
 
  
 
  
     
   
  •  
    supports：检查给定的处理器是否被当前 HandlerAdapter 支持。
     
    •  
  
 
  
 
  
     
   
  •  
    handle：调用处理器，并返回一个 Mono 对象，表示异步的调用过程。
     
    •  
  
 
  
 
  
主要实现类
 
  
 
  
Spring WebFlux 提供了几个 HandlerAdapter 的实现类，主要包括：
 
  
 
  
     
   
  •  
    RequestMappingHandlerAdapter：支持基于注解的控制器方法，如带有 @RequestMapping 注解的方法。
     
    •  
  
 
  
 
  
     
   
  •  
    HttpHandlerAdapter：支持 HttpHandler 接口的处理器。
     
    •  
  
 
  
 
  
     
   
  •  
    ControllerEndpointHandlerAdapter：支持 ControllerEndpoint 接口的处理器，通常用于 WebFlux 函数式编程。
     
    •  
  
 
  
 
  
     
   
  •  
    RouterFunctionHandlerAdapter：支持 RouterFunction 接口，用于函数式路由。
     
    •  
  
 
  
 
  
RequestMappingHandlerAdapter 源码分析
 
  
 
  
RequestMappingHandlerAdapter 是最常用的 HandlerAdapter 实现之一，下面是它的一些关键实现逻辑：
 
  
 
  
     
   
  •  
    支持性检查：supports 方法检查给定的处理器是否是 Controller 或者 RequestMapping 注解的方法。
     
    •  
  
 
  
 
  
@Override
public boolean supports(Object handler) {
    return (handler instanceof HandlerFunction) ||
           (handler instanceof Controller) ||
           AnnotationUtils.findAnnotation(handler.getClass(), RequestMapping.class) != null;
}
 
  
 
  
调用处理器：handle 方法调用处理器，并处理返回值。
 
  
 
  
    @Override
    public Mono handle(ServerWebExchange exchange, Object handler) {
        // 调用具体的处理器
        return ((HandlerFunction) handler).handle(exchange);
    }
 
  
 
  
调用处理器的逻辑
 
  
 
  
调用处理器的逻辑通常涉及以下步骤：
 
  
 
  
     
   
  •  
    参数解析：解析请求中的参数，并将其转换为方法参数。
     
    •  
  
 
  
 
  
     
   
  •  
    调用方法：调用处理器的方法，并将解析后的参数传递给方法。
     
    •  
  
 
  
 
  
     
   
  •  
    处理返回值：处理方法的返回值，将其转换为响应。
     
    •  
  
 
  
 
  
     
   
  •  
    异步处理：如果处理器返回的是 Mono 或 Flux，HandlerAdapter 需要处理这些异步结果。
     
    •  
  
 
  
 
  
错误处理
 
  
 
  
HandlerAdapter 还负责处理调用过程中的异常，将异常转换为合适的响应。
 
  
 
  
小结一下
 
  
 
  
HandlerAdapter 组件是 Spring WebFlux 请求处理流程中的关键部分，它解耦了 DispatcherHandler 和具体的处理器实现。通过使用不同的 HandlerAdapter 实现，Spring WebFlux 支持了多种类型的处理器，包括基于注解的控制器、函数式路由以及 HttpHandler 接口的实现。这种设计提高了框架的灵活性和可扩展性。
 
  
 
  
4. HandlerResultHandler
 
  
 
  
HandlerResultHandler 组件在 Spring WebFlux 中负责处理由 HandlerAdapter 调用处理器后返回的结果。它将这些结果转换为客户端可以接收的 HTTP 响应。以下是对 HandlerResultHandler 组件的源码实现逻辑和步骤的详细分析：
 
  
 
  
HandlerResultHandler 接口定义
 
  
 
  
HandlerResultHandler 接口定义了以下关键方法：
 
  
 
  
public interface HandlerResultHandler {
    boolean supports(HandlerResult result);
    Mono handleResult(ServerWebExchange exchange, HandlerResult result);
}
 
  
 
  
     
   
  •  
    supports：检查给定的 HandlerResult 是否被当前 HandlerResultHandler 支持。
     
    •  
  
 
  
 
  
     
   
  •  
    handleResult：处理 HandlerResult，生成响应并返回一个 Mono 对象，表示异步的处理过程。
     
    •  
  
 
  
 
  
主要实现类
 
  
 
  
Spring WebFlux 提供了几个 HandlerResultHandler 的实现类，主要包括：
 
  
 
  
     
   
  •  
    ServerResponseResultHandler：处理 ServerResponse 类型的返回值。
     
    •  
  
 
  
 
  
     
   
  •  
    ResponseEntityResultHandler：处理 ResponseEntity 类型的返回值。
     
    •  
  
 
  
 
  
     
   
  •  
    ModelAndViewResultHandler：处理 ModelAndView 类型的返回值，通常用于视图渲染。
     
    •  
  
 
  
 
  
ServerResponseResultHandler 源码分析
 
  
 
  
ServerResponseResultHandler 是处理 ServerResponse 类型结果的 HandlerResultHandler 实现：
 
  
 
  
     
   
  •  
    支持性检查：supports 方法检查 HandlerResult 是否包含 ServerResponse 对象。
     
    •  
  
 
  
@Override
public boolean supports(HandlerResult result) {
    return result.getReturnValue() instanceof ServerResponse;
}
 
  
 
  
     
   
  •  
    处理结果：handleResult 方法处理 ServerResponse 对象，并生成响应。
     
    •  
  
 
  
 
  
    @Override
    public Mono handleResult(ServerWebExchange exchange, HandlerResult result) {
        ServerResponse response = (ServerResponse) result.getReturnValue();
        return response.writeTo(exchange, result.isCommitted());
    }
 
  
 
  
处理结果的逻辑
 
  
 
  
处理结果的逻辑通常涉及以下步骤：
 
  
 
  
     
   
  •  
    获取返回值：从 HandlerResult 中获取处理器的返回值。
     
    •  
  
 
  
 
  
     
   
  •  
    检查类型：根据返回值的类型，选择合适的处理逻辑。
     
    •  
  
 
  
 
  
     
   
  •  
    生成响应：将返回值转换为 HTTP 响应。例如，ServerResponse 已经包含了响应的状态码、头信息和体。
     
    •  
  
 
  
 
  
     
   
  •  
    异步处理：如果返回值是异步的（如 Mono 或 Flux），则需要处理这些异步结果。
     
    •  
  
 
  
 
  
     
   
  •  
    写入响应：将生成的响应写入到 ServerWebExchange 中。
     
    •  
  
 
  
 
  
错误处理
 
  
 
  
HandlerResultHandler 还负责处理结果处理过程中的异常，将异常转换为合适的响应。
 
  
 
  
小结一下
 
  
 
  
HandlerResultHandler 组件是 Spring WebFlux 请求处理流程中的关键部分，它负责将处理器的返回值转换为 HTTP 响应。通过使用不同的 HandlerResultHandler 实现，Spring WebFlux 支持了多种返回值类型，包括 ServerResponse、ResponseEntity 和 ModelAndView。这种设计提高了框架的灵活性和可扩展性，允许开发者以不同的方式处理响应结果。
 
  
 
  
HandlerResultHandler 的实现通常需要考虑响应的异步特性，确保即使在异步流的情况下也能正确地生成和发送响应。此外，它还需要与 ServerWebExchange 紧密协作，以便访问和操作请求和响应的上下文信息。
 
  
 
  
5. WebFilter
 
  
 
  
WebFilter 接口是 Spring WebFlux 中用于拦截和处理 Web 请求和响应的组件。它允许开发者在请求到达具体的处理器之前或之后，对请求或响应进行额外的处理，例如日志记录、安全性检查、跨域处理等。以下是对 WebFilter 组件的源码实现逻辑和步骤的详细分析：
 
  
 
  
WebFilter 接口定义
 
  
 
  
WebFilter 接口定义了以下关键方法：
 
  
 
  
public interface WebFilter {
    Mono filter(ServerWebExchange exchange, WebFilterChain chain);
}
 
  
 
  
     
   
  •  
    filter：对给定的 ServerWebExchange 对象进行处理，并通过 WebFilterChain 调用链中的下一个 WebFilter 或最终的处理器。
     
    •  
  
 
  
 
  
过滤器链
 
  
 
  
在 Spring WebFlux 中，WebFilter 通常会被组织成一个过滤器链，每个 WebFilter 都可以决定是继续过滤请求还是将请求传递给链中的下一个 WebFilter。这种链式调用模式使得过滤器的执行顺序非常重要。
 
  
 
  
主要实现类
 
  
 
  
Spring WebFlux 提供了一些内置的 WebFilter 实现类，例如：
 
  
 
  
     
   
  •  
    ServerHttpSecurity：用于安全性检查。
     
    •  
  
 
  
 
  
     
   
  •  
    CorsFilter：用于处理跨源资源共享（CORS）。
     
    •  
  
 
  
 
  
     
   
  •  
    WebFilterChain：代表过滤器链的上下文，允许调用链中的下一个 WebFilter。
     
    •  
  
 
  
 
  
过滤器链的构建
 
  
 
  
过滤器链通常在应用程序的配置中构建，例如使用 WebFilter 接口的实现类：
 
  
 
  
@Configuration
public class WebFluxConfig {
    @Bean
    public WebFilter myCustomFilter() {
        return (exchange, chain) -> {
            // 在这里可以对请求进行预处理
            return chain.filter(exchange).subscriberContext(ctx -> ctx.put("customKey", "customValue"));
        };
    }
}
 
  
 
  
WebFilter 的实现逻辑
 
  
 
  
实现 WebFilter 接口的 filter 方法通常涉及以下步骤：
 
  
 
  
     
   
  •  
    预处理：在调用 chain.filter(exchange) 之前，对 ServerWebExchange 进行任何必要的预处理，例如修改请求头、查询参数等。
     
    •  
  
 
  
 
  
     
   
  •  
    调用链：使用 WebFilterChain 的 filter 方法将请求传递给链中的下一个 WebFilter。这通常会返回一个 Mono，表示异步的过滤过程。
     
    •  
  
 
  
 
  
     
   
  •  
    后处理：在 chain.filter(exchange) 完成后，对 ServerWebExchange 进行任何必要的后处理，例如修改响应头、响应体等。
     
    •  
  
 
  
 
  
     
   
  •  
    错误处理：处理在过滤过程中可能发生的异常，并决定是抛出新的错误、返回特定的响应或继续过滤链。
     
    •  
  
 
  
 
  
异步处理
 
  
 
  
由于 filter 方法返回的是 Mono，WebFilter 的实现需要考虑异步处理。这意味着在过滤过程中，可以返回异步的响应，而不会阻塞整个请求的处理。
 
  
 
  
小结一下
 
  
 
  
WebFilter 组件是 Spring WebFlux 中用于拦截和处理 Web 请求和响应的强大工具。通过实现 WebFilter 接口并构建过滤器链，开发者可以灵活地对请求和响应进行预处理和后处理，以及实现各种横切关注点，如安全性、日志记录、CORS 处理等。这种设计提高了应用程序的模块性和可维护性，同时保持了非阻塞和异步的特性。
 
  
 
  
6. ServerWebExchange
 
  
 
  
ServerWebExchange 是 Spring WebFlux 中的一个核心组件，它封装了 HTTP 请求和响应的上下文信息，为 Web 服务器和应用程序之间提供了一个交互的接口。以下是对 ServerWebExchange 组件的源码实现逻辑和步骤的详细分析：
 
  
 
  
ServerWebExchange 接口定义
 
  
 
  
ServerWebExchange 接口定义了对 HTTP 请求和响应的访问和操作：
 
  
 
  
public interface ServerWebExchange {
    ServerHttpRequest getRequest();
    ServerHttpResponse getResponse();
    void beforeCommit();
    boolean isCommitted();
    void setCommitted(boolean committed);
    Context getContext();
}
 
  
 
  
     
   
  •  
    getRequest()：返回当前的 ServerHttpRequest 对象，包含请求的详细信息。
     
    •  
  
 
  
 
  
     
   
  •  
    getResponse()：返回当前的 ServerHttpResponse 对象，用于构造响应。
     
    •  
  
 
  
 
  
     
   
  •  
    beforeCommit()：在响应提交之前调用，允许进行一些清理或准备操作。
     
    •  
  
 
  
 
  
     
   
  •  
    isCommitted()：检查响应是否已经提交。
     
    •  
  
 
  
 
  
     
   
  •  
    setCommitted(boolean committed)：设置响应是否提交的状态。
     
    •  
  
 
  
 
  
     
   
  •  
    getContext()：返回与当前交换关联的 Context，用于存储和传递附加信息。
     
    •  
  
 
  
 
  
核心属性
 
  
 
  
ServerWebExchange 通常包含以下核心属性：
 
  
 
  
     
   
  •  
    request：ServerHttpRequest 对象，封装了 HTTP 请求的详细信息，如头信息、URI、方法等。
     
    •  
   
  •  
    response：ServerHttpResponse 对象，用于构造和发送 HTTP 响应。
     
    •  
   
  •  
    principal：可能包含当前请求的认证主体（Principal）。
     
    •  
   
  •  
    session：可能包含当前请求的会话信息。
     
    •  
   
  •  
    attributes：一个 Map，用于存储与请求相关的属性。
     
    •  
  
 
  
 
  
请求和响应的处理
 
  
 
  
ServerWebExchange 在请求和响应的处理中扮演着核心角色：
 
  
 
  
     
   
  •  
    请求获取：通过 getRequest() 方法获取请求对象，访问请求的各种信息。
     
    •  
   
  •  
    响应构造：通过 getResponse() 方法获取响应对象，构造响应的状态码、头信息和响应体。
     
    •  
   
  •  
    上下文管理：使用 Context 对象存储和传递请求和响应过程中的附加信息。
     
    •  
   
  •  
    提交管理：通过 beforeCommit()、isCommitted() 和 setCommitted() 方法管理响应的提交状态。
     
    •  
   
  •  
    过滤器链：在 WebFilter 的实现中，ServerWebExchange 对象在过滤器链中传递，每个过滤器都可以访问和修改请求和响应。
     
    •  
  
 
  
 
  
异步处理
 
  
 
  
由于 WebFlux 是响应式的，ServerWebExchange 支持异步处理：
 
  
 
  
     
   
  •  
    响应可以通过非阻塞的方式写入，例如使用 ServerHttpResponse 的异步方法。
     
    •  
   
  •  
    请求和响应的处理可以在不同的线程或事件循环中进行。
     
    •  
  
 
  
 
  
小结一下
 
  
 
  
ServerWebExchange 是 Spring WebFlux 中处理 HTTP 请求和响应的核心组件。它提供了一个统一的接口来访问和操作请求和响应数据，同时支持异步非阻塞的处理方式。通过 ServerWebExchange，开发者可以在 Web 服务器和应用程序之间进行高效的数据交换和状态管理，实现高性能的响应式 Web 应用。
 
  
 
  
ServerWebExchange 的实现通常需要考虑响应式的编程模型，确保在处理请求和构造响应时不会阻塞事件循环，从而充分利用 WebFlux 的性能优势。此外，它还提供了丰富的上下文管理功能，使得在复杂的请求处理流程中，可以方便地存储和传递附加信息。
 
  
 
  
7. ServerHttpRequest和ServerHttpResponse
 
  
 
  
ServerHttpRequest 和 ServerHttpResponse 是 Spring WebFlux 中的两个核心接口，它们分别表示服务器接收的 HTTP 请求和发送的 HTTP 响应。以下是对这两个组件的源码实现逻辑和步骤的详细分析：
 
  
 
  
ServerHttpRequest 接口定义
 
  
 
  
ServerHttpRequest 接口定义了对 HTTP 请求的访问：
 
  
 
  
public interface ServerHttpRequest {
    URI getURI();
    HttpMethod getMethod();
    String getHeader(String headerName);
    MultiValueMap getHeaders();
    DataBufferFactory bufferFactory();
    // 省略其他方法...
}
 
  
 
  
     
   
  •  
    getURI()：返回请求的 URI。
     
    •  
   
  •  
    getMethod()：返回 HTTP 方法（如 GET、POST 等）。
     
    •  
   
  •  
    getHeader(String headerName)：根据名称获取请求头的值。
     
    •  
   
  •  
    getHeaders()：返回包含所有请求头的 MultiValueMap。
     
    •  
   
  •  
    bufferFactory()：返回用于创建数据缓冲区（DataBuffer）的工厂。
     
    •  
  
 
  
 
  
ServerHttpResponse 接口定义
 
  
 
  
ServerHttpResponse 接口定义了对 HTTP 响应的构造和发送：
 
  
 
  
public interface ServerHttpResponse {
    HttpStatusSeriesStatus.Series getStatusSeries();
    void setStatusCode(HttpStatus statusCode);
    String getHeader(String headerName);
    MultiValueMap getHeaders();
    void setComplete();
    DataBufferFactory bufferFactory();
    Mono writeWith(Publisher body);
    // 省略其他方法...
}
 
  
 
  
     
   
  •  
    getStatusSeries()：返回响应的状态码系列（如 2xx、3xx 等）。
     
    •  
   
  •  
    setStatusCode(HttpStatus statusCode)：设置 HTTP 状态码。
     
    •  
   
  •  
    getHeader(String headerName)：根据名称获取响应头的值。
     
    •  
   
  •  
    getHeaders()：返回包含所有响应头的 MultiValueMap。
     
    •  
   
  •  
    setComplete()：标记响应为完成。
     
    •  
   
  •  
    writeWith(Publisher body)：发送响应体。
     
    •  
  
 
  
 
  
请求和响应的处理
 
  
 
  
ServerHttpRequest 和 ServerHttpResponse 在处理 HTTP 请求和响应中扮演着核心角色：
 
  
 
  
     
   
  •  
    请求信息获取：通过 ServerHttpRequest 的方法获取请求的 URI、方法、头信息等。
     
    •  
   
  •  
    响应构造：使用 ServerHttpResponse 的方法设置状态码、头信息，并构造响应体。
     
    •  
   
  •  
    数据缓冲区：通过 bufferFactory() 方法获取 DataBufferFactory，用于创建和管理数据缓冲区。
     
    •  
   
  •  
    异步发送：ServerHttpResponse 的 writeWith(Publisher body) 方法支持异步发送响应体。
     
    •  
   
  •  
    流式处理：支持以流式的方式读取请求体和写入响应体。
     
    •  
  
 
  
 
  
异步非阻塞
 
  
 
  
由于 WebFlux 是基于响应式编程模型的，ServerHttpRequest 和 ServerHttpResponse 支持异步非阻塞的操作：
 
  
 
  
     
   
  •  
    请求体和响应体可以通过 Publisher 形式异步读取和发送。
     
    •  
   
  •  
    响应的发送不会阻塞事件循环。
     
    •  
  
 
  
 
  
小结一下
 
  
 
  
ServerHttpRequest 和 ServerHttpResponse 是 Spring WebFlux 中处理 HTTP 请求和响应的接口。它们提供了丰富的方法来访问请求信息、构造响应，并支持异步非阻塞的操作。通过这两个接口，开发者可以构建高性能、响应式的 Web 应用，充分利用现代硬件和软件架构的优势。
 
  
 
  
在实际应用中，开发者通常不需要直接实现这些接口，而是通过框架提供的实现类来操作请求和响应。这些实现类通常会与特定的运行时环境（如 Netty）集成，以提供高效的 I/O 操作。
 
  
 
  
8. WebSession
 
  
 
  
WebSession 组件在 Spring WebFlux 中用于表示和管理 Web 会话（session）。它提供了一种机制来存储和检索与特定用户会话相关的数据。以下是对 WebSession 组件的源码实现逻辑和步骤的详细分析：
 
  
 
  
WebSession 接口定义
 
  
 
  
WebSession 接口定义了 Web 会话的基本操作：
 
  
 
  
public interface WebSession {
    String getId();
    Mono save();
    void invalidate();
    Map getAttributes();
     T getAttribute(String name);
     void setAttribute(String name, T value);
    default  Mono getAttributeOrDefault(String name, Supplier defaultValue);
    // 省略其他方法...
}
 
  
 
  
     
   
  •  
    getId()：获取会话的唯一标识符。
     
    •  
   
  •  
    save()：保存会话的更改。
     
    •  
   
  •  
    invalidate()：使会话无效，相当于会话过期。
     
    •  
   
  •  
    getAttributes()：获取会话的所有属性。
     
    •  
   
  •  
    getAttribute(String name)：根据名称获取会话属性。
     
    •  
   
  •  
    setAttribute(String name, T value)：设置会话属性。
     
    •  
  
 
  
 
  
WebSession 的实现逻辑
 
  
 
  
     
   
  •  
    会话创建：WebSession 可以在请求处理过程中创建，通常与 ServerWebExchange 关联。
     
    •  
   
  •  
    属性管理：会话属性存储在 getAttributes() 返回的 Map 中，允许存储和检索用户特定的信息。
     
    •  
   
  •  
    异步保存：save() 方法异步保存会话更改，这可能涉及将更改写入底层存储。
     
    •  
   
  •  
    会话失效：invalidate() 方法用于使会话无效，确保会话数据不再可用。
     
    •  
   
  •  
    会话 ID 管理：每个 WebSession 实例都有一个唯一的 id，用于标识特定的用户会话。
     
    •  
   
  •  
    默认值获取：getAttributeOrDefault() 方法提供了一种便捷的方式来获取属性值，如果属性不存在，则返回默认值。
     
    •  
  
 
  
 
  
会话的存储和检索
 
  
 
  
WebSession 的实现通常需要考虑以下方面：
 
  
 
  
     
   
  •  
    存储机制：会话数据可以存储在不同的介质中，例如内存、数据库或分布式缓存。
     
    •  
   
  •  
    并发处理：在多线程或异步环境中，需要确保会话数据的一致性。
     
    •  
   
  •  
    会话超时：实现会话超时逻辑，自动使过期的会话无效。
     
    •  
  
 
  
 
  
会话的创建和绑定
 
  
 
  
在请求处理过程中，WebSession 可以被创建和绑定到 ServerWebExchange：
 
  
 
  
ServerWebExchange exchange = ...;
Mono sessionMono = exchange.getSession();
sessionMono.flatMap(session -> {
    // 使用会话
    return session.save();
});
 
  
 
  
小结一下
 
  
 
  
WebSession 组件是 Spring WebFlux 中用于管理 Web 会话的接口。它提供了一种灵活的方式来存储和检索与用户会话相关的数据，同时支持异步操作和多种存储选项。通过 WebSession，开发者可以轻松实现用户会话跟踪和管理，构建具有个性化用户体验的 Web 应用。
 
  
 
  
在实际应用中，开发者可以根据需要选择不同的会话存储实现，例如使用 Spring Session 项目提供的多种存储解决方案，包括 Redis、Hazelcast、JDBC 等。这些实现通常会处理会话的创建、保存、失效等逻辑，并与 WebSession 接口进行集成。
 
  
 
  
9. Reactive Streams
 
  
 
  
Reactive Streams 是一个规范，它定义了异步流处理的接口和行为，以便在不同的库和框架之间实现互操作性。Spring WebFlux 作为响应式编程的一部分，遵循 Reactive Streams 规范。以下是对 Reactive Streams 组件的源码实现逻辑和步骤的详细分析：
 
  
 
  
Reactive Streams 核心接口
 
  
 
  
Reactive Streams 规范定义了以下几个核心接口：
 
  
 
  
     
   
  1.  
    Publisher：发布者，表示可以产生数据的源头。
     
    2.  
   
  2.  
    Subscriber：订阅者，表示接收并处理数据的消费者。
     
    3.  
   
  3.  
    Subscription：订阅关系，用于管理数据的请求和发送。
     
    4.  
   
  4.  
    Processor：处理器，是 Publisher 和 Subscriber 的结合体。
     
    5.  
  
 
  
 
  
Publisher 接口
 
  
 
  
Publisher 接口是 Reactive Streams 的核心，它定义了如何将数据推送给 Subscriber：
 
  
 
  
public interface Publisher {void subscribe(Subscriber s);}
 
  
 
  
subscribe(`Subscriber s`)：允许 Subscriber 订阅 Publisher。
 
  
 
  
Subscriber 接口
 
  
 
  
Subscriber 接口定义了如何处理从 Publisher 接收到的数据：
 
  
 
  
public interface Subscriber {
    void onSubscribe(Subscription s);
    void onNext(T t);
    void onError(Throwable t);
    void onComplete();
}
 
  
 
  
     
   
  •  
    onSubscribe(Subscription s)：当 Subscriber 订阅 Publisher 后被调用，Subscription 用于控制数据流。
     
    •  
   
  •  
    onNext(T t)：接收到新数据时调用。
     
    •  
   
  •  
    onError(Throwable t)：发生错误时调用。
     
    •  
   
  •  
    onComplete()：数据流结束时调用。
     
    •  
  
 
  
 
  
Subscription 接口
 
  
 
  
Subscription 接口用于管理 Subscriber 和 Publisher 之间的数据流：
 
  
 
  
public interface Subscription {
    void request(long n);
    void cancel();
}
 
  
 
  
     
   
  •  
    request(long n)：请求 Publisher 发送指定数量的数据项。
     
    •  
   
  •  
    cancel()：取消订阅，停止接收数据。
     
    •  
  
 
  
 
  
Processor 接口
 
  
 
  
Processor 是 Publisher 和 Subscriber 的结合体，可以接收数据并产生新的数据流：
 
  
 
  
public interface Processor extends Subscriber, Publisher {
    // 继承自 Subscriber 和 Publisher 的方法
}
 
  
 
  
源码实现逻辑
 
  
 
  
     
   
  •  
    数据流创建：使用 Publisher 创建数据流。
     
    •  
   
  •  
    订阅机制：Subscriber 通过调用 Publisher 的 subscribe 方法订阅数据流。
     
    •  
   
  •  
    数据请求：Subscriber 使用 Subscription 的 request 方法控制数据的接收速率。
     
    •  
   
  •  
    数据推送：Publisher 根据 Subscriber 的请求发送数据项给 Subscriber。
     
    •  
   
  •  
    错误和完成处理：Publisher 在发生错误或数据流结束时，分别调用 Subscriber 的 onError 或 onComplete 方法。
     
    •  
   
  •  
    取消订阅：Subscriber 可以通过调用 Subscription 的 cancel 方法取消订阅。
     
    •  
  
 
  
 
  
步骤
 
  
 
  
     
   
  •  
    初始化：创建 Publisher 和 Subscriber 对象。
     
    •  
   
  •  
    订阅：Subscriber 调用 Publisher 的 subscribe 方法。
     
    •  
   
  •  
    处理订阅：Publisher 调用 Subscriber 的 onSubscribe 方法，传入 Subscription 对象。
     
    •  
   
  •  
    请求数据：Subscriber 使用 Subscription 请求数据。
     
    •  
   
  •  
    发送数据：Publisher 根据请求发送数据给 Subscriber。
     
    •  
   
  •  
    完成或错误：Publisher 在数据发送完毕后调用 onComplete，或在发生错误时调用 onError。
     
    •  
  
 
  
 
  
小结一下
 
  
 
  
Reactive Streams 规范提供了一种异步、非阻塞的数据处理模型，Spring WebFlux 通过实现这些接口，支持响应式编程。这种模型允许系统更有效地处理并发数据流，提高性能和可伸缩性。开发者可以利用 Reactive Streams 规范提供的接口和机制，构建高效、弹性的响应式应用程序。
 
  
 
  
10. Reactor 库
 
  
 
  
Reactor 是一个基于 Reactive Streams 规范的库，用于构建异步、非阻塞的响应式应用程序。它是 Spring WebFlux 的反应式编程基础。以下是对 Reactor 库组件的源码实现逻辑和步骤的详细分析：
 
  
 
  
Reactor 核心组件
 
  
 
  
Reactor 提供了以下核心组件：
 
  
 
  
     
   
  •  
    Flux：代表一个包含 0 到 N 个元素的响应式序列。
     
    •  
   
  •  
    Mono：代表一个包含 0 到 1 个元素的响应式序列。
     
    •  
   
  •  
    Scheduler：用于控制并发和执行异步操作的调度器。
     
    •  
  
 
  
 
  
Flux 和 Mono 的实现逻辑
 
  
 
  
     
   
  •  
    数据流创建：通过静态方法（如 Flux.just(), Mono.just()）或构造函数创建 Flux 或 Mono 实例。
     
    •  
   
  •  
    操作符：Reactor 提供了丰富的操作符来处理数据流，例如 map、flatMap、filter 等。
     
    •  
   
  •  
    订阅机制：通过 subscribe() 方法订阅数据流，并提供 Subscriber 来接收数据。
     
    •  
   
  •  
    数据请求：使用 request() 方法控制数据的请求数量。
     
    •  
   
  •  
    数据推送：数据通过 onNext() 方法推送给订阅者。
     
    •  
   
  •  
    错误和完成处理：通过 onError() 和 onComplete() 方法处理数据流的错误和完成事件。
     
    •  
  
 
  
 
  
Scheduler 的实现逻辑
 
  
 
  
     
   
  •  
    调度器创建：创建 Scheduler 实例，例如使用 Schedulers.parallel() 创建并行调度器。
     
    •  
   
  •  
    任务调度：使用 schedule() 方法调度任务，返回 Mono 或 Flux。
     
    •  
   
  •  
    并发控制：Scheduler 可以控制任务的并发执行，例如限制并发数量。
     
    •  
   
  •  
    异步执行：任务在非阻塞的线程池中异步执行。
     
    •  
  
 
  
 
  
源码实现步骤
 
  
 
  
     
   
  •  
    定义数据源：创建 Flux 或 Mono 实例作为数据源。
     
    •  
   
  •  
    应用操作符：使用操作符对数据流进行转换、过滤或组合。
     
    •  
   
  •  
    错误处理：使用 onErrorResume() 或 doOnError() 等操作符处理错误。
     
    •  
   
  •  
    背压管理：使用 onBackpressureBuffer() 或 onBackpressureDrop() 等操作符处理背压。
     
    •  
   
  •  
    订阅和消费：调用 subscribe() 方法订阅数据流，并提供 Subscriber 来消费数据。
     
    •  
   
  •  
    调度任务：使用 Scheduler 调度异步任务。
     
    •  
   
  •  
    资源清理：使用 dispose() 方法在不再需要时释放资源。
     
    •  
  
 
  
 
  
小结一下
 
  
 
  
Reactor 库通过 Flux、Mono 和 Scheduler 等组件，提供了一种强大的方式来构建响应式应用程序。它遵循 Reactive Streams 规范，支持异步非阻塞的数据流处理。Reactor 的操作符丰富，可以轻松实现复杂的数据处理逻辑。同时，它还提供了灵活的并发控制和调度机制，以适应不同的应用场景。
 
  
 
  
Reactor 的设计哲学是提供声明式的数据处理能力，让开发者能够以一种直观和灵活的方式构建响应式系统。通过 Reactor，开发者可以充分利用现代硬件的多核特性，提高应用程序的性能和可伸缩性。
 
  
 
  
11. WebClient
 
  
 
  
WebClient 是 Spring WebFlux 中用于发起 HTTP 请求的非阻塞响应式客户端。它允许你以声明式的方式构建请求并处理响应。以下是对 WebClient 组件的源码实现逻辑和步骤的详细分析：
 
  
 
  
WebClient 接口定义
 
  
 
  
WebClient 提供了发起请求的方法：
 
  
 
  
public interface WebClient {
    default URI uri() {
        return URI.create(this.baseUrl);
    }

     Mono getForObject(String url, Class responseType, Object... uriVariables);
     Flux getForFlux(String url, Class elementType, Object... uriVariables);
    // 其他 HTTP 方法的重载，例如 postForObject, putForObject 等
}
 
  
 
  
     
   
  •  
    uri()：返回基础 URI。
     
    •  
   
  •  
    getForObject(String url, ...)：发起 GET 请求并期望获取对象响应。
     
    •  
   
  •  
    getForFlux(String url, ...)：发起 GET 请求并期望获取元素流响应。
     
    •  
  
 
  
 
  
WebClient.Builder 构建器
 
  
 
  
WebClient 的实例是通过 WebClient.Builder 构建的：
 
  
 
  
public final class WebClient.Builder {
    private final String baseUrl;

    public Builder(String baseUrl) {
        this.baseUrl = baseUrl;
    }

    public WebClient build() {
        return new ExchangeStrategiesDefaultWebClient(this);
    }

    // 其他配置选项，例如设置 ExchangeStrategies, ClientHttpRequestFactory 等
}
 
  
 
  
     
   
  •  
    baseUrl：定义客户端的基础 URL。
     
    •  
  
 
  
 
  
请求构建和发送
 
  
 
  
     
   
  •  
    创建 WebClient 实例：使用 WebClient.Builder 创建并配置 WebClient 实例。
     
    •  
   
  •  
    构建请求：使用 WebClient 的方法来添加请求头、查询参数、请求体等。
     
    •  
   
  •  
    发起请求：调用 HTTP 方法对应的方法（如 getForObject、postForObject）来发起请求。
     
    •  
   
  •  
    处理响应：响应以 Mono 或 Flux 的形式返回，可以进一步处理。
     
    •  
  
 
  
 
  
源码实现步骤
 
  
 
  
     
   
  •  
    配置和创建：通过 WebClient.Builder 配置基础 URL 和其他选项，然后创建 WebClient 实例。
     
    •  
  
 
  
 
  
WebClient webClient = WebClient.builder().baseUrl("http://example.com").build();
 
  
 
  
构建请求：使用 WebClient 的方法链式构建请求。
 
  
 
  
    Mono personMono = webClient.get()
        .uri("/person/{id}", id)
        .retrieve()
        .bodyToMono(Person.class);
 
  
 
  
     
   
  •  
    发起请求并获取响应：调用 retrieve() 方法并指定响应体转换的方式。
     
    •  
   
  •  
    响应体转换：使用 bodyToMono 或 bodyToFlux 等方法将响应体转换为指定类型。
     
    •  
   
  •  
    错误处理：使用 onErrorResume 或 onErrorMap 等操作符处理可能发生的错误。
     
    •  
   
  •  
    订阅和消费：订阅响应体 Mono 或 Flux 并消费数据。
     
    •  
  
 
  
 
  
并发和异步处理
 
  
 
  
WebClient 支持并发和异步处理，允许以非阻塞的方式发起多个请求：
 
  
 
  
     
   
  •  
    使用 Flux 可以处理多个响应。
     
    •  
   
  •  
    可以使用 Scheduler 来控制并发级别。
     
    •  
  
 
  
 
  
小结一下
 
  
 
  
WebClient 是 Spring WebFlux 中一个强大且灵活的组件，用于构建非阻塞的响应式 HTTP 客户端。它允许以声明式的方式构建请求，并通过 Reactive Streams 规范支持异步数据处理。WebClient 的设计使得它非常适合在响应式应用程序中使用，可以充分利用现代异步编程的优势，提高应用程序的性能和可伸缩性。
 
  
开发者可以轻松地使用 WebClient 与外部服务进行通信，获取数据，并以响应式的方式处理这些数据。通过 WebClient，Spring WebFlux 应用程序可以无缝地集成到更大的响应式系统中。
 
  
 
  
12. Spring Data Reactive
 
  
 
  
Spring Data Reactive 是 Spring Data 项目的一部分，它提供了一组用于访问响应式数据存储的抽象。它允许以声明式和响应式的方式进行数据访问和操作，支持如 MongoDB、Redis、R2DBC（Reactive Relational Database Connectivity）等响应式数据库。以下是对 Spring Data Reactive 组件的源码实现逻辑和步骤的详细分析：
 
  
 
  
Spring Data Reactive 核心概念
 
  
 
  
     
   
  •  
    Reactive Repository：扩展了 Reactive Streams 规范，提供了异步的 CRUD 操作。
     
    •  
   
  •  
    ReactiveCrudRepository：基础接口，提供基本的 CRUD 操作。
     
    •  
   
  •  
    ReactiveMongoRepository、ReactiveRedisRepository 等：特定数据库的实现。
     
    •  
  
 
  
 
  
Reactive Repository 接口定义
 
  
 
  
public interface ReactiveCrudRepository extends ReactiveRepository {
    Mono save(T entity);
    Flux findAll();
    Mono findById(ID id);
    Mono deleteById(ID id);
    // 其他方法...
}
 
  
 
  
     
   
  •  
    save(T entity)：保存实体。
     
    •  
   
  •  
    findAll()：查找所有记录。
     
    •  
   
  •  
    findById(ID id)：通过 ID 查找记录。
     
    •  
   
  •  
    deleteById(ID id)：通过 ID 删除记录。
     
    •  
  
 
  
 
  
响应式数据访问步骤
 
  
 
  
     
   
  •  
    定义实体类：创建一个实体类，使用 JPA 注解或数据库特定的注解标记字段。
     
    •  
   
  •  
    定义仓库接口：创建一个继承自 ReactiveCrudRepository 或特定数据库的 Repository 接口。
     
    •  
  
 
  
 
  
    public interface MyEntityRepository extends ReactiveCrudRepository {
        // 可以添加自定义查询方法
    }
 
  
 
  
     
   
  •  
    配置数据源：配置响应式数据源和客户端，例如配置 MongoDB 的 ReactiveMongoDatabase。
     
    •  
   
  •  
    使用仓库：在服务层注入并使用仓库接口进行数据操作。
     
    •  
   
  •  
    构建查询：使用仓库接口提供的方法或自定义查询方法构建查询。
     
    •  
   
  •  
    异步处理：处理查询结果，使用 Mono 或 Flux 的异步特性。
     
    •  
  
 
  
 
  
源码实现逻辑
 
  
 
  
     
   
  •  
    实体和仓库定义：定义数据实体和仓库接口。
     
    •  
   
  •  
    Spring 应用上下文：Spring 应用上下文扫描仓库接口并创建代理实现。
     
    •  
   
  •  
    执行查询：当调用仓库接口的方法时，代理将方法调用转换为数据库操作。
     
    •  
   
  •  
    结果封装：查询结果封装在 Mono 或 Flux 中返回。
     
    •  
   
  •  
    错误处理：处理可能发生的异常，将它们转换为合适的响应。
     
    •  
   
  •  
    响应式流控制：使用 Reactive Streams 规范控制数据流。
     
    •  
  
 
  
 
  
响应式数据库操作示例
 
  
 
  
@Service
public class MyEntityService {
    private final MyEntityRepository repository;

    @Autowired
    public MyEntityService(MyEntityRepository repository) {
        this.repository = repository;
    }

    public Mono addMyEntity(MyEntity entity) {
        return repository.save(entity);
    }

    public Flux getAllMyEntities() {
        return repository.findAll();
    }
}
 
  
 
  
小结一下
 
  
 
  
Spring Data Reactive 通过提供响应式仓库接口，简化了响应式数据访问的实现。它利用了 Reactive Streams 规范，允许以非阻塞的方式进行数据库操作，提高了应用程序的性能和可伸缩性。开发者可以轻松地定义仓库接口，并使用 Spring 提供的 CRUD 方法或自定义查询方法进行数据操作。
 
  
 
  
Spring Data Reactive 组件的设计允许它与现代响应式编程模型和框架（如 WebFlux）无缝集成，为构建响应式应用程序提供了强大的数据访问能力。通过使用 Spring Data Reactive，开发者可以构建高效、弹性的应用程序，同时保持代码的简洁性和可维护性。
 
  
 
  
13. Spring Security Reactive
 
  
 
  
Spring Security Reactive 是 Spring Security 的响应式扩展，它为响应式应用程序提供了安全和认证支持。以下是对 Spring Security Reactive 组件的源码实现逻辑和步骤的详细分析：
 
  
 
  
Spring Security Reactive 核心概念
 
  
 
  
     
   
  •  
    ServerSecurityContextRepository：用于在请求中存储和检索 SecurityContext。
     
    •  
   
  •  
    ReactiveSecurityContextHolder：管理 SecurityContext 的持有者。
     
    •  
   
  •  
    ServerSecurityConfigurer：用于配置安全上下文。
     
    •  
   
  •  
    ServerHttpSecurity：定义了响应式 HTTP 安全策略。
     
    •  
   
  •  
    ReactiveAuthenticationManager 和 ReactiveUserDetailsService：用于用户认证和用户详情服务。
     
    •  
  
 
  
 
  
ServerSecurityContextRepository 接口定义
 
  
 
  
public interface ServerSecurityContextRepository {
    Mono save(ServerSecurityContext context);
    Mono load();
    void invalidate();
}
 
  
 
  
     
   
  •  
    save：保存 ServerSecurityContext。
     
    •  
   
  •  
    load：加载 ServerSecurityContext。
     
    •  
   
  •  
    invalidate：使 ServerSecurityContext 无效。
     
    •  
  
 
  
 
  
ServerHttpSecurity 配置
 
  
 
  
public class ServerHttpSecurity {
    public ServerHttpSecurity(ReactiveAuthenticationManager authentication) {
        // ...
    }

    public SecurityWebFilterChain build() {
        // ...
    }

    public ServerHttpSecurity authorizeExchange(Consumer configurer) {
        // ...
    }

    // 其他配置方法，例如 cors, csrf, formLogin, httpBasic 等
}
 
  
 
  
     
   
  •  
    authorizeExchange：配置授权策略。
     
    •  
   
  •  
    build：构建 SecurityWebFilterChain。
     
    •  
  
 
  
 
  
响应式认证和授权步骤
 
  
 
  
     
   
  •  
    配置认证管理器：创建并配置 ReactiveAuthenticationManager。
     
    •  
   
  •  
    配置用户服务：创建并配置 ReactiveUserDetailsService。
     
    •  
   
  •  
    构建 ServerHttpSecurity：使用 ServerHttpSecurity 构建安全策略。
     
    •  
   
  •  
    配置安全上下文存储：配置 ServerSecurityContextRepository。
     
    •  
   
  •  
    注册 WebFilter：将 SecurityWebFilterChain 注册到 Web 过滤器链中。
     
    •  
   
  •  
    处理认证和授权：在请求处理过程中，Spring Security Reactive 拦截请求并处理认证和授权。
     
    •  
  
 
  
 
  
源码实现逻辑
 
  
 
  
     
   
  •  
    初始化：在应用程序启动时，Spring Security Reactive 初始化安全配置。
     
    •  
   
  •  
    请求拦截：SecurityWebFilterChain 拦截请求并根据配置的安全策略进行处理。
     
    •  
   
  •  
    认证：使用 ReactiveAuthenticationManager 进行用户认证。
     
    •  
   
  •  
    授权：根据 ServerHttpSecurity 配置的授权规则，使用 ReactiveAccessDecisionManager 进行访问控制。
     
    •  
   
  •  
    安全上下文：使用 ServerSecurityContextRepository 管理每个请求的安全上下文。
     
    •  
   
  •  
    异常处理：处理安全相关的异常，如认证失败或访问拒绝。
     
    •  
   
  •  
    响应：根据认证和授权的结果，构建响应并返回给客户端。
     
    •  
  
 
  
 
  
小结一下
 
  
 
  
Spring Security Reactive 为响应式应用程序提供了全面的安全支持。它基于 Spring Security 的核心概念，并通过响应式编程模型提供了异步、非阻塞的安全处理能力。通过 ServerHttpSecurity 的配置，开发者可以灵活地定义认证和授权策略，以满足不同应用程序的安全需求。
 
  
 
  
Spring Security Reactive 的设计允许它与 Spring WebFlux 无缝集成，为响应式 Web 应用程序提供强大的安全保障。通过使用 Spring Security Reactive，开发者可以构建安全、可靠且易于维护的响应式应用程序。
 
  
 
  
14. HttpHandler
 
  
 
  
HttpHandler 组件在 Spring WebFlux 中是一个用于处理 HTTP 请求的接口，它是响应式编程模型中最低层次的 HTTP 请求处理契约。HttpHandler 作为一个共同的接口，允许不同的运行时环境通过不同的实现来处理 HTTP 请求。以下是对 HttpHandler 组件的源码实现逻辑和步骤的详细分析：
 
  
 
  
HttpHandler 接口定义
 
  
 
  
HttpHandler 接口定义了一个 handle 方法，用于处理传入的 HTTP 请求并返回一个响应：
 
  
 
  
public interface HttpHandler {
    Mono handle(ServerHttpRequest request, ServerHttpResponse response);
}
 
  
 
  
handle(ServerHttpRequest request, ServerHttpResponse response)：处理给定的请求并构造响应。
 
  
 
  
核心职责
 
  
 
  
HttpHandler 的核心职责包括：
 
  
 
  
     
   
  •  
    接收请求：接收 ServerHttpRequest 对象，该对象封装了 HTTP 请求的详细信息。
     
    •  
   
  •  
    构造响应：根据请求信息构造 ServerHttpResponse 对象，设置状态码、响应头等。
     
    •  
   
  •  
    返回结果：返回一个 Mono 对象，表示异步的响应处理过程。
     
    •  
  
 
  
 
  
实现步骤
 
  
 
  
     
   
  •  
    创建 HttpHandler 实例：实现 HttpHandler 接口或使用现有的实现。
     
    •  
   
  •  
    处理请求：在 handle 方法中编写逻辑以处理请求，例如路由、认证、业务处理等。
     
    •  
   
  •  
    构造响应：根据请求的处理结果构造响应，设置状态码、响应头和响应体。
     
    •  
   
  •  
    返回 Mono：返回一个 Mono，表示响应已经发送或将被发送。
     
    •  
   
  •  
    错误处理：在 handle 方法中处理可能发生的异常，确保它们被适当地转换为响应。
     
    •  
  
 
  
 
  
示例实现
 
  
 
  
以下是一个简单的 HttpHandler 实现示例，它返回一个固定的响应：
 
  
 
  
public class SimpleHttpHandler implements HttpHandler {

    @Override
    public Mono handle(ServerHttpRequest request, ServerHttpResponse response) {
        String body = "Hello, World!";
        response.getHeaders().add("Content-Type", "text/plain");
        return response.writeWith(Flux.just(DataBufferUtils.wrap(body)));
    }
}
 
  
 
  
小结一下
 
  
 
  
HttpHandler 组件是 Spring WebFlux 中用于处理 HTTP 请求的基础接口。它提供了一个简单而灵活的方式来处理 HTTP 请求和构造响应。通过实现 HttpHandler 接口，开发者可以控制整个请求处理流程，包括请求解析、业务逻辑处理和响应构建。
 
  
 
  
HttpHandler 的实现可以与其他 Spring WebFlux 组件（如 DispatcherHandler、HandlerMapping、HandlerAdapter 等）结合使用，以构建一个完整的响应式 Web 应用程序。这种低层次的接口为需要高度定制的 Web 应用程序提供了强大的灵活性。
 
  
 
  
15. ContextPathCompositeHandler
 
  
 
  
ContextPathCompositeHandler 是 Spring WebFlux 中的一个组件，它允许在同一服务器上将多个应用程序映射到不同的上下文路径（context paths）。这类似于在传统的 Servlet 容器中为每个 Web 应用程序配置不同的 URL 路径。
 
  
 
  
以下是对 ContextPathCompositeHandler 组件的源码实现逻辑和步骤的详细分析：
 
  
 
  
ContextPathCompositeHandler 接口定义
 
  
 
  
ContextPathCompositeHandler 实际上不是一个接口，而是 HandlerMapping 接口的一个实现，它组合了多个 Handler 对象，每个对象都关联一个上下文路径。
 
  
 
  
主要属性
 
  
 
  
     
   
  •  
    contextPaths：存储上下文路径和对应的 Handler 映射。
     
    •  
   
  •  
    pattern：用于匹配请求路径的正则表达式。
     
    •  
  
 
  
 
  
上下文路径映射
 
  
 
  
ContextPathCompositeHandler 维护了一个映射，将每个上下文路径映射到一个 Handler：
 
  
 
  
private final Map contextPaths = new ConcurrentHashMap<>();
 
  
 
  
添加应用程序
 
  
 
  
应用程序可以在初始化时通过 ContextPathCompositeHandler 的 addHandler 方法添加到映射中：
 
  
 
  
public void addHandler(String contextPath, HttpHandler handler) {
    this.contextPaths.put(contextPath, handler);
    // 更新正则表达式模式以匹配所有注册的上下文路径
    updatePattern();
}
 
  
 
  
处理请求
 
  
 
  
ContextPathCompositeHandler 通过 getHandler 方法来确定请求应该由哪个 Handler 处理：
 
  
 
  
@Override
public Mono getHandler(ServerWebExchange exchange) {
    String path = extractContextPath(exchange);
    return Mono.justOrEmpty(contextPaths.get(path))
            .map(HandlerAdapter::new)
            .defaultIfEmpty(Mono.defer(() -> createNotFoundError(exchange)));
} 
  
 
  
     
   
  •  
    extractContextPath：提取请求的上下文路径。
     
    •  
   
  •  
    getHandler：根据上下文路径从映射中获取对应的 Handler。
     
    •  
  
 
  
 
  
正则表达式模式
 
  
 
  
ContextPathCompositeHandler 使用正则表达式来匹配请求路径：
 
  
 
  
private void updatePattern() {
    // 构建匹配所有注册上下文路径的正则表达式
    String regex = contextPaths.keySet().stream()
            .map(this::toRegex)
            .collect(Collectors.joining("|", "^(", ")$"));
    this.compiledPattern = Pattern.compile(regex);
}
 
  
 
  
错误处理
 
  
 
  
如果没有找到匹配的上下文路径，ContextPathCompositeHandler 会创建一个表示 "Not Found" 的错误处理器：
 
  
 
  
private Mono createNotFoundError(ServerWebExchange exchange) {
    return Mono.just(new HandlerAdapter() {
        @Override
        public boolean supports(Object handler) {
            return true;
        }

        @Override
        public Mono handle(ServerWebExchange exchange, Object handler) {
            return ServerResponse.notFound().build().writeTo(exchange);
        }
    });
}
 
  
 
  
小结一下
 
  
 
  
ContextPathCompositeHandler 组件是 Spring WebFlux 中用于将多个应用程序映射到不同上下文路径的 HandlerMapping 实现。它通过维护一个上下文路径到 HttpHandler 的映射，允许每个应用程序处理其自己的请求路径。通过正则表达式匹配请求路径，并使用 HandlerAdapter 来适配和调用相应的处理器。
 
  
 
  
这种设计模式使得在单个服务器实例中部署和管理多个 WebFlux 应用程序变得简单和高效，每个应用程序都可以有自己的上下文路径，而 ContextPathCompositeHandler 负责将请求路由到正确的应用程序处理器。
 
  
 
  
最后
 
  
 
  
以上是Spring WebFlux 框架核心组件的全部介绍了，希望可以帮助你全面深入的理解 WebFlux的原理。
 
  
 
  
 
   
文章转载自：威哥爱编程
 
   
原文链接：https://www.cnblogs.com/wgjava/p/18282994
 
   
体验地址：引迈 - JNPF快速开发平台_低代码开发平台_零代码开发平台_流程设计器_表单引擎_工作流引擎_软件架构
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(java,spring)

        

            

                
    
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • LocalDateTime 转 String
                        igotyback
java开发语言
                        
    importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat
    
                    
    • 
                    
  • Linux下QT开发的动态库界面弹出操作（SDL2）
                        13jjyao
QT类qt开发语言sdl2linux
                        
    需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
                        若博豆
java算法华为javascript
                        
    华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代
    
                    
    • 
                    
  • 关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
                        二挡起步
web前端期末大作业javascripthtmlcss旅游风景
                        
    ⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip
    
                    
    • 
                    
  • HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
                        二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
                        
    Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线
    
                    
    • 
                    
  • node.js学习
                        小猿L
node.jsnode.js学习vim
                        
    node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
    
                    
    • 
                    
  • SpringBlade dict-biz/list 接口 SQL 注入漏洞
                        文章永久免费只为良心
oracle数据库
                        
    SpringBladedict-biz/list接口SQL注入漏洞POC:构造请求包查看返回包你的网址/api/blade-system/dict-biz/list?updatexml(1,concat(0x7e,md5(1),0x7e),1)=1漏洞概述在SpringBlade框架中，如果dict-biz/list接口的后台处理逻辑没有正确地对用户输入进行过滤或参数化查询（PreparedSta
    
                    
    • 
                    
  • Java 重写(Override)与重载(Overload)
                        叨唧唧的

                        
    Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio
    
                    
    • 
                    
  • 简单了解 JVM
                        记得开心一点啊
jvm
                        
    目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机
    
                    
    • 
                    
  • 1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
                        Energet!c
开发语言
                        
    1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach
    
                    
    • 
                    
  • Java企业面试题3
                        马龙强_
java
                        
    1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分
    
                    
    • 
                    
  • JVM、JRE和 JDK：理解Java开发的三大核心组件
                        Y雨何时停T
Javajava
                        
    Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja
    
                    
    • 
                    
  • Java面试题精选：消息队列(二)
                        芒果不是芒
Java面试题精选javakafka
                        
    一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会
    
                    
    • 
                    
  • 白骑士的Java教学基础篇 2.5 控制流语句
                        白骑士所长
Java教学java开发语言
                        
    欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘
    
                    
    • 
                    
  • python语法——三目运算符
                        HappyRocking
pythonpython三目运算符
                        
    在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。
    
                    
    • 
                    
  • spring如何整合druid连接池？
                        惜.己
springspringjunit数据库javaidea后端xml
                        
    目录spring整合druid连接池1.新建maven项目2.新建mavenModule3.导入相关依赖4.配置log4j2.xml5.配置druid.xml1)xml中如何引入properties2)下面是配置文件6.准备jdbc.propertiesJDBC配置项解释7.配置druid8.测试spring整合druid连接池1.新建maven项目打开IDE（比如IntelliJIDEA,Ecl
    
                    
    • 
                    
  • ArrayList 源码解析
                        程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
                        
    ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添
    
                    
    • 
                    
  • Java爬虫框架（一）--架构设计
                        狼图腾-狼之传说
java框架java任务html解析器存储电子商务
                        
    一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast
    
                    
    • 
                    
  • Java：爬虫框架
                        dingcho
Javajava爬虫
                        
    一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分
    
                    
    • 
                    
  • python怎么将png转为tif_png转tif
                        weixin_39977276

                        
    发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi
    
                    
    • 
                    
  • SpringCloudAlibaba—Sentinel(限流)
                        菜鸟爪哇

                        
    前言：自己在学习过程的记录，借鉴别人文章，记录自己实现的步骤。借鉴文章：https://blog.csdn.net/u014494148/article/details/105484410Sentinel介绍Sentinel诞生于阿里巴巴，其主要目标是流量控制和服务熔断。Sentinel是通过限制并发线程的数量（即信号隔离）来减少不稳定资源的影响，而不是使用线程池，省去了线程切换的性能开销。当资源
    
                    
    • 
                    
  • springboot+vue项目实战一-创建SpringBoot简单项目
                        苹果酱0567
面试题汇总与解析springboot后端java中间件开发语言
                        
    这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
    
                    
    • 
                    
  • JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
                        跳房子的前端
前端面试javascript开发语言ecmascript
                        
    在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数
    
                    
    • 
                    
  • JAVA·一个简单的登录窗口
                        MortalTom
java开发语言学习
                        
    文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计
    
                    
    • 
                    
  • Spring MVC 全面指南：从入门到精通的详细解析
                        一杯梅子酱
技术栈学习springmvcjava
                        
    引言：SpringMVC，作为Spring框架的一个重要模块，为构建Web应用提供了强大的功能和灵活性。无论是初学者还是有一定经验的开发者，掌握SpringMVC都将显著提升你的Web开发技能。本文旨在为初学者提供一个全面且易于理解的学习路径，通过详细的知识点分析和实际案例，帮助你快速上手SpringMVC，让学习过程既深刻又高效。一、SpringMVC简介1.1什么是SpringMVC？Spri
    
                    
    • 
                    
  • Spring Boot中实现跨域请求
                        BABA8891
springboot后端java
                        
    在SpringBoot中实现跨域请求（CORS，Cross-OriginResourceSharing）可以通过多种方式，以下是几种常见的方法：1.使用@CrossOrigin注解在SpringBoot中，你可以在控制器或者具体的请求处理方法上使用@CrossOrigin注解来允许跨域请求。在控制器上应用：importorg.springframework.web.bind.annotation.
    
                    
    • 
                    
  • WebMagic：强大的Java爬虫框架解析与实战
                        Aaron_945
Javajava爬虫开发语言
                        
    文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的
    
                    
    • 
                    
  • 博客网站制作教程
                        2401_85194651
javamaven
                        
    首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java
    
                    
    • 
                                
  • 书其实只有三类
                                    西蜀石兰
类
                                    
    一个人一辈子其实只读三种书，知识类、技能类、修心类。 
 
知识类的书可以让我们活得更明白。类似十万个为什么这种书籍，我一直不太乐意去读，因为单纯的知识是没法做事的，就像知道地球转速是多少一样（我肯定不知道），这种所谓的知识，除非用到，普通人掌握了完全是一种负担，维基百科能找到的东西，为什么去记忆？ 
知识类的书，每个方面都涉及些，让自己显得不那么没文化，仅此而已。社会认为的学识渊博，肯定不是站在
    
                                
    • 
                                
  • 《TCP/IP 详解，卷1：协议》学习笔记、吐槽及其他
                                    bylijinnan
tcp
                                    
    《TCP/IP 详解，卷1：协议》是经典，但不适合初学者。它更像是一本字典，适合学过网络的人温习和查阅一些记不清的概念。 
 
这本书，我看的版本是机械工业出版社、范建华等译的。这本书在我看来，翻译得一般，甚至有明显的错误。如果英文熟练，看原版更好： 
http://pcvr.nl/tcpip/ 
 
下面是我的一些笔记，包括我看书时有疑问的地方，也有对该书的吐槽，有不对的地方请指正： 
 
1.
    
                                
    • 
                                
  • Linux—— 静态IP跟动态IP设置
                                    eksliang
linuxIP
                                    
    一.在终端输入 
vi /etc/sysconfig/network-scripts/ifcfg-eth0 
静态ip模板如下： 
DEVICE="eth0"      #网卡名称
BOOTPROTO="static" #静态IP（必须）
HWADDR="00:0C:29:B5:65:CA" #网卡mac地址
IPV6INIT=&q
    
                                
    • 
                                
  • Informatica update strategy transformation
                                    18289753290

                                    
    更新策略组件：   标记你的数据进入target里面做什么操作，一般会和lookup配合使用，有时候用0,1,1代表   forward  rejected rows被选中，rejected row是输出在错误文件里，不想看到reject输出，将错误输出到文件，因为有时候数据库原因导致某些column不能update，reject就会output到错误文件里面供查看，在workflow的
    
                                
    • 
                                
  • 使用Scrapy时出现虽然队列里有很多Request但是却不下载，造成假死状态
                                    酷的飞上天空
request
                                    
    现象就是： 
程序运行一段时间，可能是几十分钟或者几个小时，然后后台日志里面就不出现下载页面的信息，一直显示上一分钟抓取了0个网页的信息。 
刚开始已经猜到是某些下载线程没有正常执行回调方法引起程序一直以为线程还未下载完成，但是水平有限研究源码未果。 
经过不停的google终于发现一个有价值的信息，是给twisted提出的一个bugfix 
连接地址如下http://twistedmatrix.
    
                                
    • 
                                
  • 利用预测分析技术来进行辅助医疗
                                    蓝儿唯美
医疗
                                    
    2014年，克利夫兰诊所（Cleveland Clinic）想要更有效地控制其手术中心做膝关节置换手术的费用。整个系统每年大约进行2600例此类手术，所以，即使降低很少一部分成本，都可以为诊 所和病人节约大量的资金。为了找到适合的解决方案，供应商将视野投向了预测分析技术和工具，但其分析团队还必须花时间向医生解释基于数据的治疗方案意味着 什么。  
克利夫兰诊所负责企业信息管理和分析的医疗
    
                                
    • 
                                
  • java 线程(一)：基础篇
                                    DavidIsOK
java多线程线程
                                    
                                                            &nbs
    
                                
    • 
                                
  • Tomcat服务器框架之Servlet开发分析
                                    aijuans
servlet
                                    
    最近使用Tomcat做web服务器，使用Servlet技术做开发时，对Tomcat的框架的简易分析： 
 
疑问： 为什么我们在继承HttpServlet类之后，覆盖doGet(HttpServletRequest req, HttpServetResponse rep)方法后，该方法会自动被Tomcat服务器调用，doGet方法的参数有谁传递过来？怎样传递？ 
 
分析之我见： doGet方法的
    
                                
    • 
                                
  • 揭秘玖富的粉丝营销之谜 与小米粉丝社区类似
                                    aoyouzi
揭秘玖富的粉丝营销之谜
                                    
    玖富旗下悟空理财凭借着一个微信公众号上线当天成交量即破百万，第七天成交量单日破了1000万;第23天时，累计成交量超1个亿……至今成立不到10个月，粉丝已经超过500万，月交易额突破10亿，而玖富平台目前的总用户数也已经超过了1800万，位居P2P平台第一位。很多互联网金融创业者慕名前来学习效仿，但是却鲜有成功者，玖富的粉丝营销对外至今仍然是个谜。 
  
　　近日，一直坚持微信粉丝营销
    
                                
    • 
                                
  • Java web的会话跟踪技术
                                    百合不是茶
url会话Cookie会话Seession会话Java Web隐藏域会话
                                    
    会话跟踪主要是用在用户页面点击不同的页面时,需要用到的技术点 
  
会话:多次请求与响应的过程 
  
  
1,url地址传递参数,实现页面跟踪技术 
         格式:传一个参数的 
url?名=值  
    传两个参数的 
url?名=值 &名=值 
  
关键代码
    
                                
    • 
                                
  • web.xml之Servlet配置
                                    bijian1013
javaweb.xmlServlet配置
                                    
    定义： 
<servlet>
  <servlet-name>myservlet</servlet-name>
  <servlet-class>com.myapp.controller.MyFirstServlet</servlet-class>
  <init-param>
   <param-name>
    
                                
    • 
                                
  • 利用svnsync实现SVN同步备份
                                    sunjing
SVN同步E000022svnsync镜像
                                    
    1. 在备份SVN服务器上建立版本库 
   svnadmin create test 
2. 创建pre-revprop-change文件 
    cd test/hooks/ 
    cp pre-revprop-change.tmpl pre-revprop-change 
3. 修改pre-revprop-
    
                                
    • 
                                
  • 【分布式数据一致性三】MongoDB读写一致性
                                    bit1129
mongodb
                                    
    本系列文章结合MongoDB，探讨分布式数据库的数据一致性，这个系列文章包括： 
 
 数据一致性概述与CAP 
 最终一致性(Eventually Consistency) 
 网络分裂(Network Partition)问题 
 多数据中心(Multi Data Center) 
 多个写者(Multi Writer)最终一致性 
 一致性图表(Consistency Chart) 
 数据
    
                                
    • 
                                
  • Anychart图表组件-Flash图转IMG普通图的方法
                                    白糖_
Flash
                                    
    问题背景：项目使用的是Anychart图表组件，渲染出来的图是Flash的，往往一个页面有时候会有多个flash图，而需求是让我们做一个打印预览和打印功能，让多个Flash图在一个页面上打印出来。 
  
那么我们打印预览的思路是获取页面的body元素，然后在打印预览界面通过$("body").append(html)的形式显示预览效果，结果让人大跌眼镜：Flash是
    
                                
    • 
                                
  • Window 80端口被占用 WHY?
                                    bozch
端口占用window
                                    
    平时在启动一些可能使用80端口软件的时候，会提示80端口已经被其他软件占用，那一般又会有那些软件占用这些端口呢？ 
   下面坐下总结： 
        1、web服务器是最经常见的占用80端口的，例如：tomcat , apache  , IIS , Php等等； 
        2
    
                                
    • 
                                
  • 编程之美-数组的最大值和最小值-分治法（两种形式）
                                    bylijinnan
编程之美
                                    
    

import java.util.Arrays;

public class MinMaxInArray {

	/**
	 * 编程之美 数组的最大值和最小值 分治法
	 * 两种形式
	 */
	public static void main(String[] args) {
		int[] t={11,23,34,4,6,7,8,1,2,23};
		int[] 
    
                                
    • 
                                
  • Perl正则表达式
                                    chenbowen00
正则表达式perl
                                    
    首先我们应该知道 Perl 程序中，正则表达式有三种存在形式，他们分别是： 
 
 
 
匹配：m/<regexp>;/ （还可以简写为 /<regexp>;/ ，略去 m） 
 
 
 
替换：s/<pattern>;/<replacement>;/ 
 
 
 
转化：tr/<pattern>;/<replacemnt>;
    
                                
    • 
                                
  • [宇宙与天文]行星议会是否具有本行星大气层以外的权力呢?
                                    comsci

                                    
     
 
      举个例子: 地球,地球上由200多个国家选举出一个代表地球联合体的议会,那么现在地球联合体遇到一个问题,地球这颗星球上面的矿产资源快要采掘完了....那么地球议会全体投票,一致通过一项带有法律性质的议案,既批准地球上的国家用各种技术手段在地球以外开采矿产资源和其它资源........ 
 
   &
    
                                
    • 
                                
  • Oracle Profile 使用详解
                                    daizj
oracleprofile资源限制
                                    
    Oracle Profile 使用详解 转 
一、目的： 
Oracle系统中的profile可以用来对用户所能使用的数据库资源进行限制，使用Create Profile命令创建一个Profile，用它来实现对数据库资源的限制使用，如果把该profile分配给用户，则该用户所能使用的数据库资源都在该profile的限制之内。 
 
二、条件： 
创建profile必须要有CREATE PROFIL
    
                                
    • 
                                
  • How HipChat Stores And Indexes Billions Of Messages Using ElasticSearch & Redis
                                    dengkane
elasticsearchLucene
                                    
    This article is from an interview with Zuhaib Siddique, a production engineer at HipChat, makers of group chat and IM for teams. 
HipChat started in an unusual space, one you might not 
    
                                
    • 
                                
  • 循环小示例，菲波拉契序列，循环解一元二次方程以及switch示例程序
                                    dcj3sjt126com
c算法
                                    
    # include <stdio.h>

int main(void)
{
	int n;
	int i;
	int f1, f2, f3;

	f1 = 1;
	f2 = 1;

	printf("请输入您需要求的想的序列：");
	scanf("%d", &n);

	for (i=3; i<n; i
    
                                
    • 
                                
  • macbook的lamp环境
                                    dcj3sjt126com
lamp
                                    
      
sudo vim /etc/apache2/httpd.conf 
  
/Library/WebServer/Documents 
是默认的网站根目录 
  
重启Mac上的Apache服务 
    
这个命令很早以前就查过了，但是每次使用的时候还是要在网上查： 
停止服务：sudo /usr/sbin/apachectl stop 
开启服务：s
    
                                
    • 
                                
  • java ArrayList源码 下
                                    shuizhaosi888
ArrayList源码
                                    
    版本 jdk-7u71-windows-x64 
  
JavaSE7 ArrayList源码上：http://flyouwith.iteye.com/blog/2166890    
  
	/**
	 * 从这个列表中移除所有c中包含元素
	 */
	public boolean removeAll(Collection<?> c) {
    
                                
    • 
                                
  • Spring Security（08）——intercept-url配置
                                    234390216
Spring Securityintercept-url访问权限访问协议请求方法
                                    
    intercept-url配置 
目录 
1.1     指定拦截的url 
1.2     指定访问权限 
1.3     指定访问协议 
1.4     指定请求方法 
   

1.1   &n
    
                                
    • 
                                
  • Linux环境下的oracle安装
                                    jayung
oracle
                                    
    linux系统下的oracle安装 
本文档是Linux(redhat6.x、centos6.x、redhat7.x) 64位操作系统安装Oracle 11g(Oracle Database 11g Enterprise Edition Release 11.2.0.4.0 - 64bit Production)，本文基于各种网络资料精心整理而成，共享给有需要的朋友。如有问题可联系：QQ：52-7
    
                                
    • 
                                
  • hotspot虚拟机
                                    leichenlei
javaHotSpotjvm虚拟机文档
                                    
    JVM参数  
http://docs.oracle.com/javase/6/docs/technotes/guides/vm/index.html 
  
JVM工具 
http://docs.oracle.com/javase/6/docs/technotes/tools/index.html 
  
JVM垃圾回收 
http://www.oracle.com
    
                                
    • 
                                
  • 读《Node.js项目实践：构建可扩展的Web应用》 ——引编程慢慢变成系统化的“砌砖活”
                                    noaighost
Webnode.js
                                    
    读《Node.js项目实践：构建可扩展的Web应用》 
——引编程慢慢变成系统化的“砌砖活” 
眼里的Node.JS 
初初接触node是一年前的事，那时候年少不更事。还在纠结什么语言可以编写出牛逼的程序，想必每个码农都会经历这个月经性的问题：微信用什么语言写的？facebook为什么推荐系统这么智能，用什么语言写的？dota2的外挂这么牛逼，用什么语言写的？……用什么语言写这句话，困扰人也是阻碍
    
                                
    • 
                                
  • 快速开发Android应用
                                    rensanning
android
                                    
    Android应用开发过程中，经常会遇到很多常见的类似问题，解决这些问题需要花时间，其实很多问题已经有了成熟的解决方案，比如很多第三方的开源lib，参考 
Android Libraries 和 
Android UI/UX Libraries。 
 
编码越少，Bug越少，效率自然会高。 
 
但可能由于 根本没听说过、听说过但没用过、特殊原因不能用、自己已经有了解决方案等等原因，这些成熟的解决
    
                                
    • 
                                
  • 理解Java中的弱引用
                                    tomcat_oracle
java工作面试
                                    
    　不久之前，我 
面试了一些求职Java高级开发工程师的应聘者。我常常会面试他们说，“你能给我介绍一些Java中得弱引用吗？”，如果面试者这样说，“嗯，是不是垃圾回收有关的？”，我就会基本满意了，我并不期待回答是一篇诘究本末的论文描述。   　　然而事与愿违，我很吃惊的发现，在将近20多个有着平均5年开发经验和高学历背景的应聘者中，居然只有两个人知道弱引用的存在，但是在这两个人之中只有一个人真正了
    
                                
    • 
                                
  • 标签输出html标签" target="_blank">关于标签输出html标签
                                    xshdch
jsp
                                    
    http://back-888888.iteye.com/blog/1181202 
 
 
关于<c:out value=""/>标签的使用，其中有一个属性是escapeXml默认是true(将html标签当做转移字符，直接显示不在浏览器上面进行解析)，当设置escapeXml属性值为false的时候就是不过滤xml，这样就能在浏览器上解析html标签， 
&nb
    
                                
    •