如何在请求过滤器中获取表单参数 [英] How to get form parameters in request filter
问题描述
我正在尝试在请求过滤器中获取请求的表单参数：
@Override
public ContainerRequest过滤器（最终的ContainerRequest请求）{
final Form formParameters = request.getFormParameters（）;
//逻辑
返回请求;
}
但是，表格似乎总是空的。 HttpRequestContext.getFormParameters（） 文档说：
获取请求实体的表单参数。
此方法将确保请求实体被缓冲，以便应用程序可以使用它。
返回：
表单参数，如果有请求实体且内容类型为application / x-www-form-urlencoded，否则为实例将返回不包含任何参数。
我的资源注释为 @Consumes（application / x-www -form-urlencoded），虽然在请求过滤器之后才会匹配 - 这是为什么这不起作用？
<我尝试做一些研究，但找不到任何结论性的证据是否有可能。有这个为期4年的讨论，其中Paul Sandoz说：
如果你在泽西过滤器工作或与
HttpRequestContext您可以按如下方式获取表单参数：[到Jersey 1.1.1的断开链接HttpRequestContext.getFormParameters]
我还发现这个3年前的讨论关于如何在请求过滤器中获取multipart / form-data表单字段。其中，Paul Sandoz使用以下代码：
//缓冲区
InputStream in = request.getEntityInputStream（）;
if（in.getClass（）！= ByteArrayInputStream.class）{
//缓冲输入
ByteArrayOutputStream baos = new ByteArrayOutputStream（）;
try {
ReaderWriter.writeTo（in，baos）;
} catch（IOException ex）{
抛出新的ContainerException（ex）;
}
in = new ByteArrayInputStream（baos.toByteArray（））;
request.setEntityInputStream（in）;
}
//读取实体
FormDataMultiPart multiPart = request.getEntity（FormDataMultiPart.class）;
我尝试用表格模仿这种方法，但 request.getEntityInputStream（）的结果始终为空流。并查看 getFormParameters 的来源，该方法实际上已经做了同样的事情：
@Override
public Form getFormParameters（）{
if（MediaTypes.typeEquals（MediaType.APPLICATION_FORM_URLENCODED_TYPE， getMediaType（）））{
InputStream in = getEntityInputStream（）;
if（in.getClass（）！= ByteArrayInputStream.class）{
//缓冲区输入
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream（）;
try {
ReaderWriter.writeTo（in，byteArrayOutputStream）;
} catch（IOException e）{
抛出新的IllegalArgumentException（e）;
}
in = new ByteArrayInputStream（byteArrayOutputStream.toByteArray（））;
setEntityInputStream（in）;
}
ByteArrayInputStream byteArrayInputStream =（ByteArrayInputStream）in;
表格f = getEntity（Form.class）;
byteArrayInputStream.reset（）;
返回f;
} else {
返回新的Form（）;
}
}
我无法弄清楚是什么在哄骗实体在我到达之前输入流。泽西岛的某些东西必须消耗它，因为形式参数后来被传递到资源方法中。我在这里做错了什么，或者这是不可能的（以及为什么）？
编辑：以下是发送请求的示例：
POST / test / post-stuff HTTP / 1.1
主持人：local.my。 application.com:8443
缓存控制：无缓存
内容类型：application / x-www-form-urlencoded
form_param_1 = foo& form_param_2 = bar
这是（有点多余）请求记录：
INFO：1 *服务器入境请求
1> POST https://local.my.application.com:8443/test/post-stuff
1>主持人：local.my.application.com:8443
1>连接：保持活力
1> content-length：33
1> cache-control：no-cache
1>来源：chrome-extension：// fdmmgilgnpjigdojojpjoooidkmcomcm
1> user-agent：Mozilla / 5.0（X11; Linux x86_64）AppleWebKit / 537.36（KHTML，类似Gecko）Chrome / 28.0.1500.95 Safari / 537.36
1> content-type：application / x-www-form-urlencoded
1>接受：* / *
1> accept-encoding：gzip，deflate，sdch
1> accept-language：en-US，en; q = 0.8
1> cookie：[省略]
1>
以下是该请求的响应标头，包括 Jersey Trace ：
Content-Type→application / json; charset = UTF-8
日期→星期五，2013年8月9日18:00:17 GMT
位置→https：//local.my。 application.com:8443/test/post-stuff/
Server→Apache-Coyote / 1.1
Transfer-Encoding→chunked
X-Jersey-Trace-000→接受root资源类： / post-stuff
X-Jersey-Trace-001→匹配路径/ post-stuff - > /post \-stuff（/.*）？，[...]，（/。*）？
X-Jersey-Trace-002→接受右手路径java.util.regex.Matcher [pattern = / post \-stuff（/.*）？ region = 0,11 lastmatch = / post-stuff]：/ post-stuff - > / post-stuff：
X-Jersey-Trace-003→接受资源：post-stuff - > @Path（/ post-stuff）com.application.my.jersey.resource.TestResource@7612e9d2
X-Jersey-Trace-004→匹配路径 - >
X-Jersey-Trace-005→接受资源方法：post-stuff，POST - > com.application.my.jersey.resource.TestResource@7612e9d2
X-Jersey-Trace-006→匹配资源方法：public javax.ws.rs.core.Response com.application.my.jersey.resource.TestResource .execute（java.lang.String，java.lang.String）
X-Jersey-Trace-007→匹配的邮件正文阅读器：class com.sun.jersey.api.representation.Form，application / x- www-form-urlencoded - > com.sun.jersey.core.impl.provider.entity.FormProvider@b98df1f
X-Jersey-Trace-008→匹配的邮件正文编写者：java.lang.String@f62，application / json - > com.sun.jersey.core.impl.provider.entity.StringProvider@1c5ddffa
这是（不起眼的）servlet配置：
< servlet>
< servlet-name> jersey< / servlet-name>
< servlet-class> com.sun.jersey.spi.container.servlet.ServletContainer< / servlet-class>
< init-param>
< param-name> com.sun.jersey.config.property.packages< / param-name>
< param-value> com.application.my.jersey< / param-value>
< / init-param>
< init-param>
< param-name> com.sun.jersey.spi.container.ResourceFilters< / param-name>
< param-value> com.application.my.jersey.MyFilterFactory< / param-value>
< / init-param>
< init-param>
< param-name> com.sun.jersey.config.feature.Trace< / param-name>
< param-value> true< / param-value>
< / init-param>
< load-on-startup> 1< / load-on-startup>
< / servlet>
以下是示例资源：
@Path（/ post-stuff）
@Produces（MediaType.APPLICATION_JSON）
公共最终类TestResource {
@POST
@Consumes（MediaType.APPLICATION_FORM_URLENCODED）
public Response execute（
@FormParam（form_param_1）final String formParam1，
@FormParam（form_param_2）final String formParam2
）{
返回Response.created（URI.create（/））。entity（{}）。build（）;
}
}
我正在使用Jersey 1.17。
对于那些感兴趣的人，我正在尝试滚动我自己的必需参数验证，如 JERSEY-351 。我的解决方案这里适用于查询，cookie和标题参数 - 形式参数对我有用。
这是一个棘手的问题。我删除了其他Jersey过滤器以消除问题，但错过了隐藏在 web.xml 底部的普通servlet过滤器：
< filter>
< filter-name> myFilter< / filter-name>
< filter-class> com.application.my.MyFilter< / filter-class>
< / filter>
< filter-mapping>
< filter-name> myFilter< / filter-name>
< url-pattern> / *< / url-pattern>
< / filter-mapping>
删除此过滤器修复了问题 - 表格params出现在Jersey过滤器中。但为什么？我深入挖掘，将问题缩小到 MyFilter 中的单个陈述：
request.getParameter（some_param）
我试图通过删除<更加简化问题code> MyFilter 并在Jersey过滤器中进行相同的调用（通过注入 HttpServletRequest ） - 但表单参数仍然显示出来。在通过 org.apache.catalina.connector.RequestFacade 实例上调用 getParameter 时，问题似乎发生了进入 javax.servlet.Filter.doFilter 。事实上这是一个Tomcat错误吗？
ServletRequest.getParameter 说：
如果参数数据是在请求正文中发送的，例如HTTP POST请求，则直接通过
getInputStream读取正文（ ）或getReader（）可能会干扰此方法的执行。
所以也许反过来也是如此 - 调用 getParameter 可能会被允许干扰实体输入流？我不清楚方法的合同是否允许这种行为，以及它是否表示Tomcat，Jersey或两者都没有。
无论如何，旧的过滤器不是实际需要所以我的问题解决了，但只是删除它。
这是问题的完整复制品（Tomcat 7.0）：
web.xml ：
<？xml version =1.0encoding =UTF-8？>
< web-app xmlns：xsi =http://www.w3.org/2001/XMLSchema-instancexmlns =http://java.sun.com/xml/ns/javaeexmlns ：web =http://java.sun.com/xml/ns/javaee/web-app_2_5.xsdxsi：schemaLocation =http://java.sun.com/xml/ns/javaee http：// java.sun.com/xml/ns/javaee/web-app_3_0.xsdid =WebApp_IDversion =3.0>
< display-name> test< / display-name>
< servlet>
< servlet-name> jersey< / servlet-name>
< servlet-class> com.sun.jersey.spi.container.servlet.ServletContainer< / servlet-class>
< init-param>
< param-name> com.sun.jersey.config.property.packages< / param-name>
< param-value> com.application.my< / param-value>
< / init-param>
< init-param>
< param-name> com.sun.jersey.spi.container.ResourceFilters< / param-name>
< param-value> com.application.my.TestFilterFactory< / param-value>
< / init-param>
< init-param>
< param-name> com.sun.jersey.config.feature.Trace< / param-name>
< param-value> false< / param-value>
< / init-param>
< load-on-startup> 1< / load-on-startup>
< / servlet>
< servlet-mapping>
< servlet-name> jersey< / servlet-name>
< url-pattern> / *< / url-pattern>
< / servlet-mapping>
< filter>
< filter-name> servletFilter< / filter-name>
< filter-class> com.application.my.TestServletFilter< / filter-class>
< / filter>
< filter-mapping>
< filter-name> servletFilter< / filter-name>
< url-pattern> / *< / url-pattern>
< / filter-mapping>
< / web-app>
TestServletFilter.java ：
package com.application.my;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
公共最终类TestServletFilter实现Filter {
@Override
public void init（FilterConfig config）{}
@Override
public void doFilter（
最终ServletRequest请求，
最终ServletResponse响应，
最终FilterChain链
）抛出IOException，ServletException {
System.out.println（在+ request.getClass（）。getName（））上调用getParameter;
request.getParameter（blah）;
chain.doFilter（request，response）;
}
@Override
public void destroy（）{}
}
TestFilterFactory.java ：
package com.application.my;
import java.util.Collections;
import java.util.List;
import com.sun.jersey.api.model.AbstractMethod;
import com.sun.jersey.spi.container.ContainerRequest;
import com.sun.jersey.spi.container.ContainerRequestFilter;
import com.sun.jersey.spi.container.ContainerResponseFilter;
import com.sun.jersey.spi.container.ResourceFilter;
import com.sun.jersey.spi.container.ResourceFilterFactory;
公共最终类TestFilterFactory实现ResourceFilterFactory {
@Override
public List< ResourceFilter> create（final AbstractMethod method）{
return Collections。< ResourceFilter> singletonList（new ResourceFilter（）{
@Override
public ContainerRequestFilter getRequestFilter（）{
return new ContainerRequestFilter（） {
@Override
公共ContainerRequest过滤器（最终ContainerRequest请求）{
System.out.println（form：+ request.getFormParameters（））;
返回请求;
}
};
}
@Override
公共ContainerResponseFilter getResponseFilter（）{
返回null;
}
}）;
}
}
TestResource.java ：
package com.application.my;
import java.net.URI;
import javax.ws.rs.Consumes;
import javax.ws.rs.FormParam;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
@Path（/ post-stuff）
@Produces（MediaType.APPLICATION_JSON）
公共最终类TestResource {
@POST
@Consumes（MediaType.APPLICATION_FORM_URLENCODED）
public Response execute（
@FormParam（form_param_1）final String formParam1，
@FormParam（form_param_2）final String formParam2
）{
System.out.println（form param_1：+ formParam1）;
System.out.println（form param_2：+ formParam2）;
返回Response.created（URI.create（/））。entity（{}）。build（）;
}
}
I'm trying to get the form parameters of a request in a request filter:
@Override
public ContainerRequest filter(final ContainerRequest request) {
final Form formParameters = request.getFormParameters();
//logic
return request;
}
However, the form always seems to be empty. The HttpRequestContext.getFormParameters() documentation says:
Get the form parameters of the request entity.
This method will ensure that the request entity is buffered such that it may be consumed by the applicaton.
Returns: the form parameters, if there is a request entity and the content type is "application/x-www-form-urlencoded", otherwise an instance containing no parameters will be returned.
My resource is annotated with @Consumes("application/x-www-form-urlencoded"), although it won't have been matched until after the request filter - is that why this isn't working?
I tried doing some research but couldn't find any conclusive evidence of whether this is possible. There was this 4-year old discussion, in which Paul Sandoz says:
If you are working in Jersey filters or with the
HttpRequestContextyou can get the form parameters as follows: [broken link to Jersey 1.1.1HttpRequestContext.getFormParameters]
I also found this 3-year-old discussion about how to get multipart/form-data form fields in a request filter. In it, Paul Sandoz uses the following code:
// Buffer
InputStream in = request.getEntityInputStream();
if (in.getClass() != ByteArrayInputStream.class) {
// Buffer input
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try {
ReaderWriter.writeTo(in, baos);
} catch (IOException ex) {
throw new ContainerException(ex);
}
in = new ByteArrayInputStream(baos.toByteArray());
request.setEntityInputStream(in);
}
// Read entity
FormDataMultiPart multiPart = request.getEntity(FormDataMultiPart.class);
I tried emulating that approach for Form instead, but the result of request.getEntityInputStream() is always an empty stream. And looking at the source of getFormParameters, that method is in fact doing the same thing already:
@Override
public Form getFormParameters() {
if (MediaTypes.typeEquals(MediaType.APPLICATION_FORM_URLENCODED_TYPE, getMediaType())) {
InputStream in = getEntityInputStream();
if (in.getClass() != ByteArrayInputStream.class) {
// Buffer input
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
try {
ReaderWriter.writeTo(in, byteArrayOutputStream);
} catch (IOException e) {
throw new IllegalArgumentException(e);
}
in = new ByteArrayInputStream(byteArrayOutputStream.toByteArray());
setEntityInputStream(in);
}
ByteArrayInputStream byteArrayInputStream = (ByteArrayInputStream) in;
Form f = getEntity(Form.class);
byteArrayInputStream.reset();
return f;
} else {
return new Form();
}
}
I can't figure out what's slurping up the entity input stream before I get to it. Something in Jersey must be consuming it because the form params are later passed into the resource method. What am I doing wrong here, or is this impossible (and why)?
EDIT: Here's an example of a request being sent:
POST /test/post-stuff HTTP/1.1
Host: local.my.application.com:8443
Cache-Control: no-cache
Content-Type: application/x-www-form-urlencoded
form_param_1=foo&form_param_2=bar
Here's the (somewhat redundant) request logging:
INFO: 1 * Server in-bound request
1 > POST https://local.my.application.com:8443/test/post-stuff
1 > host: local.my.application.com:8443
1 > connection: keep-alive
1 > content-length: 33
1 > cache-control: no-cache
1 > origin: chrome-extension://fdmmgilgnpjigdojojpjoooidkmcomcm
1 > user-agent: Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/28.0.1500.95 Safari/537.36
1 > content-type: application/x-www-form-urlencoded
1 > accept: */*
1 > accept-encoding: gzip,deflate,sdch
1 > accept-language: en-US,en;q=0.8
1 > cookie: [omitted]
1 >
Here are the response headers of that request, including the Jersey Trace:
Content-Type →application/json;charset=UTF-8
Date →Fri, 09 Aug 2013 18:00:17 GMT
Location →https://local.my.application.com:8443/test/post-stuff/
Server →Apache-Coyote/1.1
Transfer-Encoding →chunked
X-Jersey-Trace-000 →accept root resource classes: "/post-stuff"
X-Jersey-Trace-001 →match path "/post-stuff" -> "/post\-stuff(/.*)?", [...], "(/.*)?"
X-Jersey-Trace-002 →accept right hand path java.util.regex.Matcher[pattern=/post\-stuff(/.*)? region=0,11 lastmatch=/post-stuff]: "/post-stuff" -> "/post-stuff" : ""
X-Jersey-Trace-003 →accept resource: "post-stuff" -> @Path("/post-stuff") com.application.my.jersey.resource.TestResource@7612e9d2
X-Jersey-Trace-004 →match path "" -> ""
X-Jersey-Trace-005 →accept resource methods: "post-stuff", POST -> com.application.my.jersey.resource.TestResource@7612e9d2
X-Jersey-Trace-006 →matched resource method: public javax.ws.rs.core.Response com.application.my.jersey.resource.TestResource.execute(java.lang.String,java.lang.String)
X-Jersey-Trace-007 →matched message body reader: class com.sun.jersey.api.representation.Form, "application/x-www-form-urlencoded" -> com.sun.jersey.core.impl.provider.entity.FormProvider@b98df1f
X-Jersey-Trace-008 →matched message body writer: java.lang.String@f62, "application/json" -> com.sun.jersey.core.impl.provider.entity.StringProvider@1c5ddffa
Here is the (unremarkable) servlet config:
<servlet>
<servlet-name>jersey</servlet-name>
<servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
<init-param>
<param-name>com.sun.jersey.config.property.packages</param-name>
<param-value>com.application.my.jersey</param-value>
</init-param>
<init-param>
<param-name>com.sun.jersey.spi.container.ResourceFilters</param-name>
<param-value>com.application.my.jersey.MyFilterFactory</param-value>
</init-param>
<init-param>
<param-name>com.sun.jersey.config.feature.Trace</param-name>
<param-value>true</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
Here's the example resource:
@Path("/post-stuff")
@Produces(MediaType.APPLICATION_JSON)
public final class TestResource {
@POST
@Consumes(MediaType.APPLICATION_FORM_URLENCODED)
public Response execute(
@FormParam("form_param_1") final String formParam1,
@FormParam("form_param_2") final String formParam2
) {
return Response.created(URI.create("/")).entity("{}").build();
}
}
I'm using Jersey 1.17.
For those interested, I'm trying to roll my own required parameter validation, as described in JERSEY-351. My solution here worked for query, cookie, and header params - form params are holding out on me.
This was a tricky one. I'd removed other Jersey filters to eliminate them from the problem, but missed a plain servlet filter hiding at the bottom of web.xml:
<filter>
<filter-name>myFilter</filter-name>
<filter-class>com.application.my.MyFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>myFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
Removing this filter fixed the issue - form params showed up in the Jersey filter. But why? I dug deeper, narrowing down the problem to a single statement in MyFilter:
request.getParameter("some_param")
I tried to simplify the problem even more by removing MyFilter and making the same call in the Jersey filter (by injecting HttpServletRequest) - but the form parameters still showed up. The issue appears to happen specifically when calling getParameter on the org.apache.catalina.connector.RequestFacade instance that gets passed into javax.servlet.Filter.doFilter. So is this in fact a Tomcat bug?
The documentation of ServletRequest.getParameter says:
If the parameter data was sent in the request body, such as occurs with an HTTP POST request, then reading the body directly via
getInputStream()orgetReader()can interfere with the execution of this method.
So maybe the reverse is true too - that calling getParameter might be allowed to interfere with the entity input stream? It's unclear to me whether the method's contract allows for this behavior, and whether it indicates a bug in Tomcat, Jersey, or neither.
Anyway, that old filter wasn't actually needed so my issue is solved but just removing it.
Here's a full reproduction of the problem (Tomcat 7.0):
web.xml:
<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" id="WebApp_ID" version="3.0">
<display-name>test</display-name>
<servlet>
<servlet-name>jersey</servlet-name>
<servlet-class>com.sun.jersey.spi.container.servlet.ServletContainer</servlet-class>
<init-param>
<param-name>com.sun.jersey.config.property.packages</param-name>
<param-value>com.application.my</param-value>
</init-param>
<init-param>
<param-name>com.sun.jersey.spi.container.ResourceFilters</param-name>
<param-value>com.application.my.TestFilterFactory</param-value>
</init-param>
<init-param>
<param-name>com.sun.jersey.config.feature.Trace</param-name>
<param-value>false</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>jersey</servlet-name>
<url-pattern>/*</url-pattern>
</servlet-mapping>
<filter>
<filter-name>servletFilter</filter-name>
<filter-class>com.application.my.TestServletFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>servletFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
</web-app>
TestServletFilter.java:
package com.application.my;
import java.io.IOException;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
public final class TestServletFilter implements Filter {
@Override
public void init(FilterConfig config) { }
@Override
public void doFilter(
final ServletRequest request,
final ServletResponse response,
final FilterChain chain
) throws IOException, ServletException {
System.out.println("calling getParameter on " + request.getClass().getName());
request.getParameter("blah");
chain.doFilter(request, response);
}
@Override
public void destroy() { }
}
TestFilterFactory.java:
package com.application.my;
import java.util.Collections;
import java.util.List;
import com.sun.jersey.api.model.AbstractMethod;
import com.sun.jersey.spi.container.ContainerRequest;
import com.sun.jersey.spi.container.ContainerRequestFilter;
import com.sun.jersey.spi.container.ContainerResponseFilter;
import com.sun.jersey.spi.container.ResourceFilter;
import com.sun.jersey.spi.container.ResourceFilterFactory;
public final class TestFilterFactory implements ResourceFilterFactory {
@Override
public List<ResourceFilter> create(final AbstractMethod method) {
return Collections.<ResourceFilter>singletonList(new ResourceFilter() {
@Override
public ContainerRequestFilter getRequestFilter() {
return new ContainerRequestFilter() {
@Override
public ContainerRequest filter(final ContainerRequest request) {
System.out.println("form: " + request.getFormParameters());
return request;
}
};
}
@Override
public ContainerResponseFilter getResponseFilter() {
return null;
}
});
}
}
TestResource.java:
package com.application.my;
import java.net.URI;
import javax.ws.rs.Consumes;
import javax.ws.rs.FormParam;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
import javax.ws.rs.core.Response;
@Path("/post-stuff")
@Produces(MediaType.APPLICATION_JSON)
public final class TestResource {
@POST
@Consumes(MediaType.APPLICATION_FORM_URLENCODED)
public Response execute(
@FormParam("form_param_1") final String formParam1,
@FormParam("form_param_2") final String formParam2
) {
System.out.println("form param_1: " + formParam1);
System.out.println("form param_2: " + formParam2);
return Response.created(URI.create("/")).entity("{}").build();
}
}
这篇关于如何在请求过滤器中获取表单参数的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
