<think>我们正在处理一个multipart/form
-data请求，需要在GlobalFilter中
区分普通表单字段和文件上传字段。
在
Spring WebFlux中，我们可以使用`ServerWebExchange`来获取请求体，并解析多部分数据。但是，在GlobalFilter中，由于请求体只能被读取一次，我们需要小心处理。
步骤：
1. 检查请求的内容类型是否是multipart/form
-data。
2. 如果是，则解析多部分请求体。
3. 遍历每个部分（part），判断是普通字段还是文件字段。
注意：在WebFlux中，我们使用`ServerWebExchange`的`getMultipartData`方法来获取多部分数据。但是，这个方法返回一个`Mono<MultiValueMap<String, Part>>`，因此我们需要在异步
环境中处理。
由于GlobalFilter是响应式的，我们需要以非阻塞的方式处理。
思路：
在过滤器中，我们可以将请求体转换为多部分数据，然后遍历每个部分。对于每个部分，我们可以检查其是否为文件（通过`FilePart`接口）或普通表单字段（通过`FormFieldPart`接口）。
但是，在
Spring WebFlux中，多部分数据的具体类型为：
- `FilePart` 表示文件上传部分
- `FormFieldPart` 表示普通表单字段
因此，我们可以这样
区分：
示例代码：
```java
public class MyGlobalFilter implements GlobalFilter {
@Override
public Mono<Void> filter
(ServerWebExchange exchange, WebFilterChain chain
) {
if
(isMultipartRequest
(exchange
)) {
return exchange.getMultipartData
()
.flatMap
(parts
-> {
// 遍历所有部分
for
(List<Part> partList : parts.values
()) {
for
(Part part : partList
) {
if
(part instanceof FilePart
) {
FilePart filePart =
(FilePart
) part;
// 处理文件字段
System.out.println
("File field: " + filePart.name
());
System.out.println
("Filename: " + filePart.filename
());
} else if
(part instanceof FormFieldPart
) {
FormFieldPart formField =
(FormFieldPart
) part;
// 处理普通字段
System.out.println
("Form field: " + formField.name
());
System.out.println
("Value: " + formField.value
());
}
}
}
return chain.filter
(exchange
);
}
);
} else {
return chain.filter
(exchange
);
}
}
private boolean isMultipartRequest
(ServerWebExchange exchange
) {
MediaType contentType = exchange.getRequest
().getHeaders
().getContentType
();
return contentType != null && contentType.isCompatibleWith
(MediaType.MULTIPART_FORM_DATA
);
}
}
```
但是，请注意：上面的代码在遍历过程中，我们只是打印了信息，然后继续执行过滤器链。但是，这样做有一个问题：请求体已经被消费了，后续的控制器将无法再次读取请求体（因为`getMultipartData`方法会消耗请求体）。因此，我们需要将多部分数据重新设置到请求中，以便后续使用。
在
Spring WebFlux中，我们可以使用`ServerWebExchange`的`mutate
()`方法来改变请求，将多部分数据缓存起来，这样后续的处理器可以重复使用。
然而，
Spring WebFlux提供了一个`DefaultServerWebExchange`，它允许我们通过`mutate
().multipartData
(Mono.just
(parts
))`来设置多部分数据。但是，由于我们已经解析了多部分数据，我们可以将其设置回exchange，这样后续的处理器就不需要再次解析。
修改后的代码：
```java
public class MyGlobalFilter implements GlobalFilter {
@Override
public Mono<Void> filter
(ServerWebExchange exchange, WebFilterChain chain
) {
if
(isMultipartRequest
(exchange
)) {
return exchange.getMultipartData
()
.flatMap
(parts
-> {
// 处理每个部分
for
(List<Part> partList : parts.values
()) {
for
(Part part : partList
) {
if
(part instanceof FilePart
) {
// 文件处理逻辑
} else if
(part instanceof FormFieldPart
) {
// 普通字段处理逻辑
}
}
}
// 将解析后的多部分数据重新设置到exchange中，这样后续的处理器可以直接使用
ServerWebExchange mutatedExchange = exchange.mutate
()
.request
(exchange.getRequest
().mutate
()
.body
(new CachedBodyOutputMessage
(exchange, exchange.getRequest
().getHeaders
()).writeWith
(Flux.empty
())
.build
())
.build
();
// 但是，这里有一个问题：我们如何将多部分数据设置回去？实际上，我们可以将解析的parts设置到exchange的属性中，但这不是标准做法。
// 实际上，在
Spring WebFlux中，后续的处理器会调用exchange.getMultipartData
()，而这个方法会返回我们之前解析的Mono。但是，我们这里已经解析了，所以我们需要缓存它。
// 然而，我们注意到exchange.getMultipartData
()方法返回的是一个Mono，并且它只会被解析一次。我们的操作已经解析了，所以后续调用exchange.getMultipartData
()会返回相同的Mono（如果我们没有改变exchange的话）？实际上，我们的解析操作已经消费了请求体，所以后续无法再次解析。
// 因此，我们需要将解析得到的parts设置到exchange的属性中，并提供一个自定义的multipartData解析方法？这并不容易。
// 另一种做法：我们不在过滤器中解析整个多部分数据，而是使用一个装饰器来包装请求，使其能够缓存请求体，这样后续可以多次读取。但是，这比较复杂。
// 实际上，
Spring WebFlux提供了一个`org.
springframework.web.server.ServerWebExchangeDecorator`，我们可以通过它来装饰请求，以便缓存请求体。
// 但是，考虑到复杂性，我们可能更希望将我们的处理逻辑放在一个更合适的地方，比如使用一个HandlerInterceptor或者Controller的切面，而不是GlobalFilter。
// 不过，如果我们坚持要在GlobalFilter中处理，我们可以这样做：
// 1. 使用一个装饰器来缓存请求体，然后重新读取。
// 2. 解析多部分数据，然后将其存储为exchange的一个属性，并提供一个自定义的multipartData访问方法。
// 但是，
Spring WebFlux内置了`FormPartReader`和`FilePartReader`，它们会使用exchange.getMultipartData
()。我们可以将解析后的多部分数据设置到exchange的attributes中，并覆盖getMultipartData方法？这需要自定义exchange。
// 由于这个操作比较复杂，而且容易出错，通常建议在后续的处理器中处理多部分数据（例如在控制器中），或者使用一个WebFilter来包装请求，以便缓存请求体。
// 因此，我们可能需要重新考虑：在GlobalFilter中处理多部分数据可能不是最佳实践。
// 但是，如果我们只是需要读取一些元数据（比如是否存在文件字段），而不需要读取整个文件内容，我们可以只读取元信息，然后继续传递。但是，上面的代码已经读取了整个请求体，对于大文件来说，这可能会导致内存问题。
// 所以，我们可能需要使用一个更流式的方式来处理。
// 由于这些复杂性，我们可能应该避免在GlobalFilter中处理多部分数据。如果必须处理，可以考虑使用一个专门的库或者工具来解析多部分请求，而不依赖于
Spring的解析，但这非常复杂。
// 因此，这里我们提供一个替代方案：使用一个装饰器来缓存请求体，然后重新生成请求，这样后续可以再次读取。我们可以使用`org.
springframework.core.io.buffer.DataBufferUtils`来缓存请求体。
// 但是，由于时间限制，我们这里不展开。建议在控制器中处理多部分数据。
// 所以，如果只是需要获取字段名，而不需要实际内容，我们可以尝试只读取头部信息？但多部分请求的每个部分的头部和内容是在一起的，无法只读取头部。
// 因此，我们可能需要权衡：如果确实需要在GlobalFilter中处理，我们可以使用以下方法缓存整个请求体（注意内存使用）:
return DataBufferUtils.join
(exchange.getRequest
().getBody
())
.flatMap
(dataBuffer
-> {
// 将dataBuffer转换为字节数组（注意：这可能会占用大量内存）
byte[] bytes = new byte[dataBuffer.readableByteCount
()];
dataBuffer.read
(bytes
);
DataBufferUtils.release
(dataBuffer
);
// 然后使用这些字节数组重新构建请求体，以便后续使用
ServerHttpRequest newRequest = exchange.getRequest
().mutate
()
.body
(DataBufferUtils.releaseLater
(DataBufferFactory, byte[]
))
.build
();
ServerWebExchange newExchange = exchange.mutate
().request
(newRequest
).build
();
// 然后我们使用这个新的exchange来解析多部分数据
return newExchange.getMultipartData
();
}
)
.flatMap
(parts
-> {
// 处理parts
// ... 处理逻辑
// 然后，将解析后的parts设置到新的exchange中，这样后续可以直接使用
// 但是，如何设置呢？我们可以将parts存储为exchange的一个属性，然后重写getMultipartData方法？或者，我们可以使用装饰器模式。
// 由于
Spring WebFlux的设计，我们无法直接设置multipartData，因为它是一个Mono。所以我们可以将parts存储为exchange的一个属性，然后提供一个自定义的解析器？这需要修改exchange。
// 实际上，我们可以通过装饰exchange来覆盖getMultipartData方法：
ServerWebExchange decoratedExchange = new ServerWebExchangeDecorator
(exchange
) {
private final Mono<MultiValueMap<String, Part>> monoParts = Mono.just
(parts
);
@Override
public Mono<MultiValueMap<String, Part>> getMultipartData
() {
return monoParts;
}
};
return chain.filter
(decoratedExchange
);
}
);
}
);
} else {
return chain.filter
(exchange
);
}
}
}
```
但是，上述代码非常复杂，并且需要处理内存和性能问题。因此，对于大多数情况，建议将处理逻辑放在控制器中，或者使用一个专门的HandlerInterceptor（在WebFlux中是WebFilter，但要注意顺序）来处理。
因此，如果我们不需要修改请求体，只是读取元数据，我们可以选择在解析后继续传递，但需要确保后续的处理器能够再次解析请求体（通过缓存）。但是，由于
Spring WebFlux的请求体只能被读取一次，我们需要自己缓存。
这里有一个更简单的做法：使用`org.
springframework.web.server.adapter.WebHttpHandlerBuilder`的`preventCaching`来缓存请求体，但是
Spring WebFlux并没有提供内置的请求体缓存。
因此，我们可能需要使用第三方库或者自己实现一个请求体缓存装饰器。
考虑到实现的复杂性，我们这里不展开。在实际生产
环境中，建议避免在GlobalFilter中解析多部分数据，除非必要。如果必须，可以考虑使用以下库：https://github.com/synchronoss/nio
-multipart 来手动解析。
但是，在
Spring WebFlux 5.3及以上版本，我们可以使用`PartEvent`来以流式方式处理多部分请求，但这通常用于控制器方法。
结论：
由于在GlobalFilter中处理multipart/form
-data的复杂性（特别是需要缓存请求体以便后续使用），我们建议将逻辑放在控制器中，或者使用一个专门的WebFilter（并注意顺序）来处理，并确保只解析一次，然后将结果传递给后续的处理器。
但是，如果只是需要检查请求中是否有文件字段，而不需要处理文件内容，我们可以通过检查请求的`Content
-Disposition`头部来初步判断，但这并不完全可靠，因为普通字段和文件字段的Content
-Disposition结构类似，只是文件字段会有一个filename参数。
例如，文件字段的Content
-Disposition可能为：
Content
-Disposition: form
-data; name="file"; filename="example.txt"
而普通字段为：
Content
-Disposition: form
-data; name="field"
因此，我们可以尝试只解析请求的头部，而不解析整个请求体。但是，多部分请求的每个部分都是连续的，我们需要解析整个请求体才能知道每个部分的信息。
因此，我们可能不得不解析整个请求体。
综上，我们提供一个折中方案：如果请求不大，可以缓存整个请求体，然后重新构建请求；如果请求很大，特别是包含大文件，那么这种方法会占用大量内存，不推荐。
因此，我们建议在GlobalFilter中尽量避免处理文件内容，而只处理普通字段。如果必须处理，考虑使用流式解析，并只处理元数据（例如，只读取每个部分的头部，然后跳过内容）。但是，
Spring WebFlux的Part对象在获取文件内容时是流式的，但我们在GlobalFilter中处理时，如果我们不读取文件内容，只是读取元数据，那么我们可以忽略文件内容，这样就不会占用太多内存。
实际上，在之前的代码中，我们只是访问了Part的元数据（name和filename），并没有读取文件内容。所以，当我们调用`exchange.getMultipartData
()`时，
Spring会解析整个请求体，但是文件内容不会被读取到内存中，而是以流的方式存储在FilePart中，直到我们调用`transferTo`方法。但是，我们在GlobalFilter中并没有读取文件内容，所以不会占用太多内存（除了请求体解析的元数据开销）。
但是，问题在于：我们在GlobalFilter中解析了请求体，那么后续的处理器（例如控制器）如何再次读取？答案是不能，因为请求体已经被消费了。
所以，我们必须在GlobalFilter中解析后，将解析得到的parts重新设置到exchange中，以便后续使用。而
Spring WebFlux并没有提供直接设置multipartData的方法，因此我们需要通过装饰exchange来实现。
下面是改进的做法：
```java
public class MultipartCachingWebFilter implements WebFilter {
@Override
public Mono<Void> filter
(ServerWebExchange exchange, WebFilterChain chain
) {
if
(isMultipartRequest
(exchange
)) {
return exchange.getMultipartData
()
.cache
() // 缓存解析结果
.flatMap
(parts
-> {
// 创建一个装饰过的exchange，重写getMultipartData方法，返回缓存的parts
ServerWebExchange decoratedExchange = new ServerWebExchangeDecorator
(exchange
) {
@Override
public Mono<MultiValueMap<String, Part>> getMultipartData
() {
return Mono.just
(parts
);
}
};
return chain.filter
(decoratedExchange
);
}
);
} else {
return chain.filter
(exchange
);
}
}
private boolean isMultipartRequest
(ServerWebExchange exchange
) {
// 同上
}
}
```
然后，我们可以在GlobalFilter中，在这个MultipartCachingWebFilter之后，再添加我们自己的GlobalFilter，这样在我们的GlobalFilter中，我们可以调用`exchange.getMultipartData
()`，它会返回缓存的parts，而不会再次解析请求体。
因此，我们可以将问题分解为两个过滤器：
1. 一个负责解析多部分数据并缓存（MultipartCachingWebFilter）
2. 我们的业务GlobalFilter，它从exchange中获取缓存的parts，然后进行
区分处理。
这样，我们的业务GlobalFilter就可以安全地访问parts了。
示例：
```java
// 第一个过滤器：解析并缓存多部分数据
public class MultipartCachingFilter implements WebFilter {
@Override
public Mono<Void> filter
(ServerWebExchange exchange, WebFilterChain chain
) {
if
(isMultipartRequest
(exchange
)) {
return exchange.getMultipartData
()
.flatMap
(parts
-> {
// 装饰exchange，使得后续getMultipartData
()直接返回结果
ServerWebExchange decoratedExchange = new ServerWebExchangeDecorator
(exchange
) {
private final Mono<MultiValueMap<String, Part>> cachedParts = Mono.just
(parts
);
@Override
public Mono<MultiValueMap<String, Part>> getMultipartData
() {
return cachedParts;
}
};
return chain.filter
(decoratedExchange
);
}
);
} else {
return chain.filter
(exchange
);
}
}
}
// 第二个过滤器：我们的业务过滤器
public class MyGlobalFilter implements GlobalFilter {
@Override
public Mono<Void> filter
(ServerWebExchange exchange, WebFilterChain chain
) {
if
(isMultipartRequest
(exchange
)) {
return exchange.getMultipartData
()
.flatMap
(parts
-> {
for
(List<Part> partList : parts.values
()) {
for
(Part part : partList
) {
if
(part instanceof FilePart
) {
// 文件字段
FilePart filePart =
(FilePart
) part;
System.out.println
("File field: " + filePart.name
() + ", filename: " + filePart.filename
());
} else if
(part instanceof FormFieldPart
) {
FormFieldPart fieldPart =
(FormFieldPart
) part;
System.out.println
("Form field: " + fieldPart.name
() + ", value: " + fieldPart.value
());
}
}
}
return chain.filter
(exchange
);
}
);
} else {
return chain.filter
(exchange
);
}
}
}
```
注意：我们需要确保MultipartCachingFilter在MyGlobalFilter之前执行。在
Spring Boot中，我们可以通过`@Order`注解来指定顺序。
但是，请注意：在MultipartCachingFilter中，我们解析了请求体，然后在业务过滤器中，我们再次使用相同的parts。这样，请求体只被解析了一次，并且后续的控制器也可以使用`exchange.getMultipartData
()`来获取parts，因为我们装饰了exchange。
另外，注意在MultipartCachingFilter中，我们使用了`flatMap`，这意味着我们解析了整个请求体。对于大文件，虽然文件内容不会被读取到内存中（而是存储在磁盘临时文件中，具体取决于配置），但元数据（如文件名、字段名）会被解析并存储在内存中。
因此，这个方案是可行的。
总结：
在GlobalFilter中
区分multipart/form
-data请求中的普通表单字段和文件上传字段，我们需要：
1. 先解析多部分数据，并缓存解析结果（通过装饰exchange）。
2. 在业务GlobalFilter中，从exchange中获取缓存的parts，然后遍历每个part，根据其类型（FilePart或FormFieldPart）进行
区分处理。
注意：需要确保缓存多部分数据的过滤器在业务GlobalFilter之前执行。
因此，我们可以通过两个过滤器来实现。
最后，我们还需要注意
Spring Boot的
配置文件中的上传限制，如`
spring.servlet.multipart.max
-file
-size`和`
spring.servlet.multipart.max
-request
-size`（在WebFlux中，属性名可能
不同，WebFlux中对应的属性是`
spring.webflux.multipart.max
-file
-size`和`
spring.webflux.multipart.max
-request
-size`）[^1]。
另外，在处理文件上传时，要注意内存和磁盘的使用。
希望这个回答能帮助你。</think>在
Spring WebFlux 的 `GlobalFilter` 中
区分 `multipart/form
-data` 请求中的普通表单字段和文件上传字段，可以通过解析多部分数据并检查 `Part` 类型实现。以下是详细解决方案：
### 实现步骤
1. **检查请求类型**
验证请求是否为 `multipart/form
-data` 类型：
```java
MediaType contentType = exchange.getRequest
().getHeaders
().getContentType
();
boolean isMultipart = contentType != null && contentType.isCompatibleWith
(MediaType.MULTIPART_FORM_DATA
);
```
2. **解析多部分数据**
使用 `exchange.getMultipartData
()` 解析请求体：
```java
return exchange.getMultipartData
()
.flatMap
(parts
-> {
// 处理逻辑
return chain.filter
(exchange
);
}
);
```
3. **
区分字段类型**
遍历 `MultiValueMap<String, Part>`，通过 `instanceof` 判断类型：
```java
for
(List<Part> partList : parts.values
()) {
for
(Part part : partList
) {
if
(part instanceof FilePart
) {
// 文件字段处理
FilePart filePart =
(FilePart
) part;
String fileName = filePart.filename
();
// 获取文件元数据...
} else if
(part instanceof FormFieldPart
) {
// 普通表单字段处理
FormFieldPart field =
(FormFieldPart
) part;
String value = field.value
();
// 获取字段值...
}
}
}
```
### 完整代码示例
```java
import org.
springframework.core.io.buffer.DataBuffer;
import org.
springframework.http.MediaType;
import org.
springframework.http.codec.multipart.*;
import org.
springframework.web.server.ServerWebExchange;
import org.
springframework.web.server.WebFilter;
import org.
springframework.web.server.WebFilterChain;
import reactor.core.publisher.Mono;
import java.util.List;
public class MultipartFilter implements WebFilter {
@Override
public Mono<Void> filter
(ServerWebExchange exchange, WebFilterChain chain
) {
MediaType contentType = exchange.getRequest
().getHeaders
().getContentType
();
if
(contentType != null && contentType.isCompatibleWith
(MediaType.MULTIPART_FORM_DATA
)) {
return exchange.getMultipartData
()
.flatMap
(parts
-> {
parts.forEach
((name, partList
) -> {
for
(Part part : partList
) {
if
(part instanceof FilePart
) {
FilePart filePart =
(FilePart
) part;
System.out.println
("文件字段: " + name +
", 文件名: " + filePart.filename
());
} else if
(part instanceof FormFieldPart
) {
FormFieldPart field =
(FormFieldPart
) part;
System.out.println
("表单字段: " + name +
", 值: " + field.value
());
}
}
}
);
return chain.filter
(exchange
);
}
);
}
return chain.filter
(exchange
);
}
}
```
### 关键说明
1. **文件字段
(`FilePart`
)**
- 包含文件名、内容类型等元数据
- 通过 `filename
()` 获取文件名
- 通过 `content
()` 获取文件内容流（`Flux<DataBuffer>`）
2. **表单字段
(`FormFieldPart`
)**
- 包含普通文本值
- 通过 `value
()` 直接获取字段值
3. **请求体缓存问题**
- 解析后请求体会被消费，需通过装饰器缓存数据供后续使用：
```java
public class CachingExchangeDecorator extends ServerWebExchangeDecorator {
private final Mono<MultiValueMap<String, Part>> cachedParts;
public CachingExchangeDecorator
(ServerWebExchange exchange,
Mono<MultiValueMap<String, Part>> parts
) {
super
(exchange
);
this.cachedParts = parts.cache
();
}
@Override
public Mono<MultiValueMap<String, Part>> getMultipartData
() {
return cachedParts;
}
}
```
在过滤器中装饰 `exchange`：
```java
ServerWebExchange mutatedExchange = new CachingExchangeDecorator
(exchange, partsMono
);
return chain.filter
(mutatedExchange
);
```
4. **上传限制配置**
确保 `application.properties` 中配置了合理的文件大小限制[^1]：
```properties
spring.servlet.multipart.max
-file
-size=2MB
spring.servlet.multipart.max
-request
-size=20MB
```
### 注意事项
- **性能影响**：解析大文件时需注意内存消耗，建议流式处理文件内容。
- **顺序问题**：该过滤器需在
Spring 的 `MultipartResolver` 之后执行（可通过 `@Order` 调整优先级）。
- **错误处理**：添加 `onErrorResume` 处理多部分解析异常（如大小超限）。
---
### 相关问题
1. **如何避免重复解析 `multipart/form
-data` 请求体？**
使用 `ServerWebExchangeDecorator` 缓存解析结果（如上文 `CachingExchangeDecorator`），确保后续组件可直接获取数据。
2. **文件上传时如何实现流式处理？**
通过 `FilePart.content
()` 获取 `Flux<DataBuffer>`，结合 `DataBufferUtils` 写入文件或直接处理数据流，避免内存溢出。
3. **如何在过滤器中修改表单字段值？**
创建自定义 `FormFieldPart` 实现，替换原始 `Part` 后重建 `MultiValueMap`，再通过装饰器设置回 `exchange`。
4. **如何获取上传文件的元数据（如MD5）？**
在 `FilePart` 处理中，通过 `DataBufferUtils.join
(content
).map
(dataBuffer
-> {...}
)` 计算哈希或提取元数据。
[^1]: 上传文件大小限制配置示例
[^2]: 日志格式说明（仅作
参考）
扫一扫
9695
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
