-spring-如何利用spring对filter中新增的属性进行封装

最新推荐文章于 2023-10-08 17:23:28 发布
最新推荐文章于 2023-10-08 17:23:28 发布
阅读量395 收藏 1
点赞数 2
分类专栏： Spring JAVA
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mengxiangqihangz/article/details/106393545
版权
JAVA 同时被 2 个专栏收录
11 篇文章 0 订阅
订阅专栏
Spring
1 篇文章 0 订阅
订阅专栏

问题背景：

插入一个：spring boot 如何利用log4j2 打印日志
工程源码 ： spring-boot-package

公司在接收其他平台数据的时候，走的是restful api接口，但是有两个特殊要求。

  1. 需要对整个业务参数块进行加密
  2. 开发的接口需要 提供swagger ui
  • post请求 入参示例如下
  • 业务入参如下
{
	"token":"accessToken",
	"securityKey":"ss212313",
	"data":
		{
			"IMEI":"123",
			"state":"off"
		}
}
  • 实际传参则是直接将data 中的业务数据整块加密
{
	"token":"accessToken",
	"securityKey":"ss212313",
	"data": "加密后的数据"
}

swagger要能展示入参数据结构，接收参数的对象需要与 业务入参的数据结构一致。但实际http
请求传入的参数却是加密后的字符串
问题点：如何让spring 帮我们封装解密后的数据？

如何让spring 对我们新增的属性，自动完成对象封装

先处理一个简单的，比如get请求，如何在请求处理过程中添加属性，并让spring自动将封装到入参对象中。

  1. 如下设计2个入参对象
@Data
public class CommonVo {
  private String name;
  private Integer age;
}
@Data
public class CustomerVo {
  private String name;
  private Integer age;
  private String key;
  private Son son;
  @Data
  public class Son{
    private String fieldOne;
    private String fieldTwo;
  }
}
  1. 如下图所示，在代码中为其新增属性，并在转发后的请求中，能够将新增的属性自动封装到CustomerVo对象中
    在这里插入图片描述
  2. 比较常用的操作，通常是 通过Wrapper 对ServletRequest进行封装，这种封装，要获取新增的属性，需要通过 req.getParameter(key) 来获取，spring并不会对添加到Wrapper的属性，进行自动封装
public class RequestParameterWrapper extends HttpServletRequestWrapper {

    private Map<String, String[]> params = new HashMap();

    public RequestParameterWrapper(HttpServletRequest request) {
        super(request);
        //将现有parameter传递给params
        this.params.putAll(request.getParameterMap());
    }

    public void addParameter(String name, Object value) {
        if (value != null) {
            if (value instanceof String[]) {
                params.put(name, (String[]) value);
            } else if (value instanceof String) {
                params.put(name, new String[]{(String) value});
            } else {
                params.put(name, new String[]{String.valueOf(value)});
            }
        }
    }
    @Override
    public Map<String, String[]> getParameterMap() {
        return params;
    }
    @Override
    public String getParameter(String name) {
        String[] values = params.get(name);
        if (values == null || values.length == 0) {
            return null;
        }
        return values[0];
    }
    @Override
    public String[] getParameterValues(String name) {
        return params.get(name);
    }
}
  1. 只有知道spring 封装数据的原理，才能知道如何让spring将新增的属性封装到对象中
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

从这里开始需要注意跟踪了

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

如果你在上一步直接重写 getParameterNames() 方法也可以

我继续debug下去了，然后找的wrapper中的封装的HttpServletRequest中的 parameterNames了。因此走了弯路。

整理出来，对于parameter 的修改需要重写如下4个方法
	private Map<String, String[]> params = new HashMap();

    public RequestParameterWrapper(HttpServletRequest request) {
        super(request);
        //将现有parameter传递给params
        this.params.putAll(request.getParameterMap());
    }

    public void addParameter(String name, Object value) {
        if (value != null) {
            if (value instanceof String[]) {
                params.put(name, (String[]) value);
            } else if (value instanceof String) {
                params.put(name, new String[]{(String) value});
            } else {
                params.put(name, new String[]{String.valueOf(value)});
            }
        }
    }
    @Override
    public Map<String, String[]> getParameterMap() {
        return params;
    }
    @Override
    public String getParameter(String name) {
        String[] values = params.get(name);
        if (values == null || values.length == 0) {
            return null;
        }
        return values[0];
    }
    @Override
    public String[] getParameterValues(String name) {
        return params.get(name);
    }
    @Override
    public Enumeration<String> getParameterNames() {
        return Collections.enumeration(params.keySet());
    }
效果

在这里插入图片描述

接下来看一下post请求中，json参数的封装。

post请求，@RequestBody 的数据封装，会报如下的错误

I/O error while reading input message; nested exception is java.io.IOException: Stream closed
在这里出现的原因是，@RequestBody？

先到controller中转发之前，进行调试

在这里插入图片描述

直接到 DispatcherServlet

在这里插入图片描述

插入一点

GET请求 ：

HttpServlet FrameworkServlet DispatcherServlet doGet service(HttpSer vletRequest,Htt pServletResponse) processRequest doService HttpServlet FrameworkServlet DispatcherServlet

POST请求 ：

HttpServlet FrameworkServlet DispatcherServlet doPOST service(HttpSer vletRequest,Htt pServletResponse) processRequest doService HttpServlet FrameworkServlet DispatcherServlet

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

inputBuffer.streamClosed在这里插入图片描述
回到上一步，也就是说这个InputStream是不能再次读取的。
因为buffer 不执行 flip() 方法时，只能读取一次。转发前将HttpServletRequest封装到Controller里面的时候，已经进行过一次读取。现在封装到wrapper里面又到Request里面去读取一次，肯定要报错。
也是说，对于json数据的封装，wrapper要有自己的inputStream。回到上一步继续分析
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
如何重写 getInputStream()，我的想法是看一下代码里面有没有已重写过的例子可以参考。
在这里插入图片描述

最后的wrapper如下


public class RequestParameterWrapper extends HttpServletRequestWrapper {

    private Map<String, String[]> params = new HashMap();

    public RequestParameterWrapper(HttpServletRequest request) {
        super(request);
        //将现有parameter传递给params
        this.params.putAll(request.getParameterMap());
    }

    public void addParameter(String name, Object value) {
        if (value != null) {
            if (value instanceof String[]) {
                params.put(name, (String[]) value);
            } else if (value instanceof String) {
                params.put(name, new String[]{(String) value});
            } else {
                params.put(name, new String[]{String.valueOf(value)});
            }
        }
    }
    @Override
    public Map<String, String[]> getParameterMap() {
        return params;
    }
    @Override
    public String getParameter(String name) {
        String[] values = params.get(name);
        if (values == null || values.length == 0) {
            return null;
        }
        return values[0];
    }
    @Override
    public String[] getParameterValues(String name) {
        return params.get(name);
    }
    @Override
    public Enumeration<String> getParameterNames() {
        return Collections.enumeration(params.keySet());
    }


    private JSONObject jsons = new JSONObject();

    public void addJson(String key, Object obj) {
        jsons.put(key, obj);
    }

    @Override
    public ServletInputStream getInputStream() {
        MyServletInputStream coyoteInputStream = new MyServletInputStream(new ByteArrayInputStream(jsons.toJSONString().getBytes()));
        return coyoteInputStream;
    }

    public class MyServletInputStream extends ServletInputStream {
        private final InputStream sourceStream;
        private boolean finished = false;

        public MyServletInputStream(InputStream sourceStream) {
            Assert.notNull(sourceStream, "Source InputStream must not be null");
            this.sourceStream = sourceStream;
        }
        @Override
        public int read() throws IOException {
            int data = this.sourceStream.read();
            if (data == -1) {
                this.finished = true;
            }
            return data;
        }
        @Override
        public int available() throws IOException {
            return this.sourceStream.available();
        }
        @Override
        public void close() throws IOException {
            super.close();
            this.sourceStream.close();
        }
        @Override
        public boolean isFinished() {
            return this.finished;
        }
        @Override
        public boolean isReady() {
            return true;
        }
        @Override
        public void setReadListener(ReadListener readListener) {
            throw new UnsupportedOperationException();
        }
    }
}

在这里插入图片描述

汇总

其实将controller中转发前的数据封装放到filer中，也是完全可以的，只需要判断一下，对于json参数，则按ServletInputStream中封装，其他的按parameters中封装就可以了。
我之所以写着controller层封装，是因为我的接口格式，对外只提供一个请求，然后通过字段 action进行业务转发。
其实总的来说：还是对于 HttpServletRequestWrapper 不够熟悉，所以才碰到这么多问题。

下面是对 封装请求能够重写的方法进行了一个汇总

public class RequestParameterWrapperTest extends HttpServletRequestWrapper {

    public RequestParameterWrapperTest(HttpServletRequest request) {
        super(request);
    }

    /**
     * 重写的方法，主要来自两大类
     * HttpServletRequestWrapper
     * ServletRequestWrapper
     *
     * @return
     */

    /**
     * parameter 相关，原本是 封装在RequestFacade 中的Request中的coyoteRequest[Request]中的 ParameterMap<String, String[]> parameterMap中
     * @param name
     * @return
     */
    @Override
    public String getParameter(String name) {
        return super.getParameter(name);
    }
    @Override
    public Map<String, String[]> getParameterMap() {
        return super.getParameterMap();
    }
    @Override
    public Enumeration<String> getParameterNames() {
        return super.getParameterNames();
    }
    @Override
    public String[] getParameterValues(String name) {
        return super.getParameterValues(name);
    }


    /**
     * 默认是保存在  Request 中的 Map<String, Object> attributes中
     * @param name
     * @param o
     */
    @Override
    public void setAttribute(String name, Object o) {
        super.setAttribute(name, o);
    }
    @Override
    public void removeAttribute(String name) {
        super.removeAttribute(name);
    }
    @Override
    public Object getAttribute(String name) {
        return super.getAttribute(name);
    }
    @Override
    public Enumeration<String> getAttributeNames() {
        return super.getAttributeNames();
    }


//    @Override
//    public ServletInputStream getInputStream() throws IOException {
//        return super.getInputStream();
//    }

    /**
     * header 相关
     {
     "cookie": "JSESSIONID=BEC4AAAD417148E4AA60A98AA425439C",
     "postman-token": "36f065f0-7ec0-4908-8189-4943c690b52b",
     "host": "localhost:8080",
     "connection": "keep-alive",
     "cache-control": "no-cache",
     "accept-encoding": "gzip, deflate, br",
     "user-agent": "PostmanRuntime/7.25.0",
     "accept": "*//*"
    }
     * @param name
     * @return
     */
    @Override
    public String getHeader(String name) {
        return super.getHeader(name);
    }
    @Override
    public Enumeration<String> getHeaders(String name) {
        return super.getHeaders(name);
    }
    @Override
    public Enumeration<String> getHeaderNames() {
        return super.getHeaderNames();
    }
    @Override
    public int getIntHeader(String name) {
        return super.getIntHeader(name);
    }
    @Override
    public long getDateHeader(String name) {
        return super.getDateHeader(name);
    }


    /**
     * session相关
     * @return
     */
    @Override
    public String getRequestedSessionId() {
        return super.getRequestedSessionId();
    }
    @Override
    public HttpSession getSession(boolean create) {
        return super.getSession(create);
    }
    @Override
    public HttpSession getSession() {
        return super.getSession();
    }
    @Override
    public String changeSessionId() {
        return super.changeSessionId();
    }
    @Override
    public boolean isRequestedSessionIdValid() {
        return super.isRequestedSessionIdValid();
    }
    @Override
    public boolean isRequestedSessionIdFromCookie() {
        return super.isRequestedSessionIdFromCookie();
    }
    @Override
    public boolean isRequestedSessionIdFromURL() {
        return super.isRequestedSessionIdFromURL();
    }
    @Override
    public boolean isRequestedSessionIdFromUrl() {
        return super.isRequestedSessionIdFromUrl();
    }


    // UTF-8
    @Override
    public String getCharacterEncoding() {
        return super.getCharacterEncoding();
    }
    @Override
    public void setCharacterEncoding(String enc) throws UnsupportedEncodingException {
        super.setCharacterEncoding(enc);
    }
    // [{"httpOnly":false,"maxAge":-1,"name":"JSESSIONID","secure":false,"value":"BEC4AAAD417148E4AA60A98AA425439C","version":0}]
    @Override
    public Cookie[] getCookies() {
        return super.getCookies();
    }

    // name=lisi&age=18
    @Override
    public String getQueryString() {
        return super.getQueryString();
    }
    // /demo/getAppendFieldForwoard
    @Override
    public String getRequestURI() {
        return super.getRequestURI();
    }
    // http://localhost:8080/demo/getAppendFieldForwoard
    @Override
    public StringBuffer getRequestURL() {
        return super.getRequestURL();
    }
    // /demo
    @Override
    public String getContextPath() {
        return super.getContextPath();
    }
    // /getAppendFieldForwoard
    @Override
    public String getServletPath() {
        return super.getServletPath();
    }
    // localhost
    @Override
    public String getServerName() {
        return super.getServerName();
    }
    // 8080
    @Override
    public int getServerPort() {
        return super.getServerPort();
    }

    @Override
    public String getRemoteAddr() {
        return super.getRemoteAddr();
    }
    @Override
    public String getRemoteHost() {
        return super.getRemoteHost();
    }
    @Override
    public int getRemotePort() {
        return super.getRemotePort();
    }
    @Override
    public String getRemoteUser() {
        return super.getRemoteUser();
    }

    @Override
    public Locale getLocale() {
        return super.getLocale();
    }
    @Override
    public int getLocalPort() {
        return super.getLocalPort();
    }
    @Override
    public String getLocalName() {
        return super.getLocalName();
    }
    @Override
    public String getLocalAddr() {
        return super.getLocalAddr();
    }
    @Override
    public Enumeration<Locale> getLocales() {
        return super.getLocales();
    }


    @Override
    public String getPathTranslated() {
        return super.getPathTranslated();
    }
    @Override
    public Principal getUserPrincipal() {
        return super.getUserPrincipal();
    }

    @Override
    public String getProtocol() {
        return super.getProtocol();
    }
    @Override
    public String getScheme() {
        return super.getScheme();
    }


    @Override
    public String getRealPath(String path) {
        return super.getRealPath(path);
    }


    @Override
    public String getPathInfo() {
        return super.getPathInfo();
    }
    @Override
    public String getAuthType() {
        return super.getAuthType();
    }
    @Override
    public HttpServletMapping getHttpServletMapping() {
        return super.getHttpServletMapping();
    }
    @Override
    public String getMethod() {
        return super.getMethod();
    }
    @Override
    public boolean isUserInRole(String role) {
        return super.isUserInRole(role);
    }
    @Override
    public boolean authenticate(HttpServletResponse response) throws IOException, ServletException {
        return super.authenticate(response);
    }
    @Override
    public void login(String username, String password) throws ServletException {
        super.login(username, password);
    }
    @Override
    public void logout() throws ServletException {
        super.logout();
    }
    @Override
    public Collection<Part> getParts() throws IOException, ServletException {
        return super.getParts();
    }
    @Override
    public Part getPart(String name) throws IOException, ServletException {
        return super.getPart(name);
    }
    @Override
    public <T extends HttpUpgradeHandler> T upgrade(Class<T> httpUpgradeHandlerClass) throws IOException, ServletException {
        return super.upgrade(httpUpgradeHandlerClass);
    }
    @Override
    public PushBuilder newPushBuilder() {
        return super.newPushBuilder();
    }
    @Override
    public Map<String, String> getTrailerFields() {
        return super.getTrailerFields();
    }
    @Override
    public boolean isTrailerFieldsReady() {
        return super.isTrailerFieldsReady();
    }
    @Override
    public ServletRequest getRequest() {
        return super.getRequest();
    }
    @Override
    public void setRequest(ServletRequest request) {
        super.setRequest(request);
    }
    @Override
    public int getContentLength() {
        return super.getContentLength();
    }
    @Override
    public long getContentLengthLong() {
        return super.getContentLengthLong();
    }
    @Override
    public String getContentType() {
        return super.getContentType();
    }
    @Override
    public BufferedReader getReader() throws IOException {
        return super.getReader();
    }
    @Override
    public boolean isSecure() {
        return super.isSecure();
    }
    @Override
    public RequestDispatcher getRequestDispatcher(String path) {
        return super.getRequestDispatcher(path);
    }
    @Override
    public ServletContext getServletContext() {
        return super.getServletContext();
    }
    @Override
    public AsyncContext startAsync() throws IllegalStateException {
        return super.startAsync();
    }
    @Override
    public AsyncContext startAsync(ServletRequest servletRequest, ServletResponse servletResponse) throws IllegalStateException {
        return super.startAsync(servletRequest, servletResponse);
    }
    @Override
    public boolean isAsyncStarted() {
        return super.isAsyncStarted();
    }
    @Override
    public boolean isAsyncSupported() {
        return super.isAsyncSupported();
    }
    @Override
    public AsyncContext getAsyncContext() {
        return super.getAsyncContext();
    }
    @Override
    public boolean isWrapperFor(ServletRequest wrapped) {
        return super.isWrapperFor(wrapped);
    }
    @Override
    public boolean isWrapperFor(Class<?> wrappedType) {
        return super.isWrapperFor(wrappedType);
    }
    @Override
    public DispatcherType getDispatcherType() {
        return super.getDispatcherType();
    }
}
mengxiangqihangz
关注
专栏目录
Disruptor-Spring-Boot-Starter：Disruptor的启动器
01-30
可实现对具备不同 事件规则 ruleExpression 的事件对象进行专责处理；就如 Filter，该组件实现的Handler采用了同样的原理； / Event-DC-Output / TagA-Output / ** = inDbPostHandler该配置表示； Event =事件DC-...
实现Filter类，重写doFilter方法，获取请求body的实现
最新发布
qazwsx081的专栏
12-11 622
上一篇写的是在Spring WebFlux中的WebFilter中实现filter方法，并获取请求body的实现，这篇是Java Servlet API中的，用于在Servlet容器中实现过滤器。关键类是RequestWrapper。
Filter过滤器中获取token和get、post请求中的参数【json和application/x-www-form-urlencoded请求体类型】请求体再次封装写回到request中
zzfgwj的博客
02-28 2160
Filter过滤器中获取token和get、post请求中的参数【json和application/x-www-form-urlencoded请求体类型】请求体再次封装写回到request中
requestBody只能读取一次&filter无法捕获异常
weixin_46220076的博客
07-20 353
requestBody只能读取一次&filter无法捕获异常
springboot过滤器doFilter方法中如何将流读取一次后重新写入，复制流代码实例
gb4215287的博客
10-08 428
springboot过滤器doFilter方法中如何将流读取一次后重新写入，复制流代码实例
走进AngularJs(七) 过滤器（filter）
aigenglong0649的博客
12-15 258
　　过滤器（filter）正如其名，作用就是接收一个输入，通过某个规则进行处理，然后返回处理后的结果。主要用在数据的格式化上，例如获取一个数组中的子集，对数组中的元素进行排序等。ng内置了一些过滤器，它们是：currency(货币)、date(日期)、filter(子串匹配)、json(格式化json对象)、limitTo(限制个数)、lowercase(小写)、uppercase(大写...
JSP spring boot / cloud 使用filter防止XSS
10-19
通过创建一个自定义的Filter类XssFilter，在其doFilter方法中，我们可以对请求进行如下处理： 1. 获取请求中的数据，包括请求头（requestHeader）、请求体（requestBody）和请求参数（requestParameter）。 2. 利用...
spring-web
11-05
Spring-Web模块也包含对Servlet Filter和Listener的支持，如`CharacterEncodingFilter`用于设置请求和响应的编码，`HttpPutFormContentFilter`帮助处理PUT请求中的表单数据。`ContextLoaderListener`用于初始化全局...
spring-Ldap
09-03
理解并熟练使用 Spring-Ldap 需要对 LDAP 基础和 Spring 框架有一定的了解。可以通过官方文档、Stack Overflow 讨论、教程博客等资源深入学习。此外，了解 Spring Data LDAP（Spring Data 的 LDAP 模块）也是一个...
SpringBoot统一处理返回结果和异常情况
weixin_48630372的博客
11-25 1万+
原因 在springboot项目里我们希望接口返回的数据包含至少三个属性： code：请求接口的返回码，成功或者异常等返回编码，例如定义请求成功。 message：请求接口的描述，也就是对返回编码的描述。 data：请求接口成功，返回的结果。 { "code":20000, "message":"成功", "data":{ "info":"测试成功" } } 开发环境 工具：IDEA SpringBoot版本：2.2.2.RELEASE 依赖 <dependency&
结合spring进行异常封装
西楚小羽的专栏
08-16 2274
java为我们提供了非常完美的异常处理机制 从上面这幅图可以看出，Throwable是java语言中所有错误和异常的超类（万物即可抛）。它有两个子类：Error、Exception。       其中Error为错误，是程序无法处理的，如OutOfMemoryError、ThreadDeath等，出现这种情况你唯一能做的就是听之任之，交由JVM来处理，不过JVM在大多数情况
关于servlet inputstream stream closed异常，以及HttpServletRequestWrapper 上传文件的问题
smlie_shuihan的博客
08-06 4723
项目场景： 现有需求提供出一些接口对第三方使用，在接口签名的过程中出现了问题。 问题描述： 通过AOP获得请求中@RequestBody数据时，出现 "stream closed"异常的问题。 java.io.IOException: Stream closed 原因分析： 在进入AOP前，spring框架在使用 对象类型转换器(converter)时，已经使用过一次body了（获取body是以流的形式），所以在切面中处理再想获取body体数据时，发生"stream closed"异常。 &
filter在spring框架中使用配置文件参数的方法
小白龙的博客
04-30 3608
配置好了 filter,该如何吧配置文件的参数读取出来显示呢? 有人第一会想到直接在Filter中 使用 @Value 注解注入再用参数接收不就行了,如: @Value("${weixin.appid}") String appid; 但是,很遗憾,这样是注入不进来的,因为 我们的Filter 并不是一个bean,也就是说并没有纳入到spring容器中进行管理,也就无从谈起自动装配了,所以 @...
解决HttpServletRequest的输入流只能读取一次的问题
weixin_34021089的博客
12-24 1357
背景 通常对安全性有要求的接口都会对请求参数做一些签名验证，而我们一般会把验签的逻辑统一放到过滤器或拦截器里，这样就不用每个接口都去重复编写验签的逻辑。 在一个项目中会有很多的接口，而不同的接口可能接收不同类型的数据，例如表单数据和json数据，表单数据还好说，调用request的getParameterMap就能全部取出来。而json数据就有些麻烦了，因为json数据放在body中，我们需要通过...
Java并发线程之ThreadLocal使用严重 [http-nio-8080-exec-4] org.apache.catalina.core.StandardWrapperValve.invoke
ImmerTry 敢于尝试
05-22 2万+
使用 ThreadLocal 在项目中 出现报错 严重 [http-nio-8080-exec-4] org.apache.catalina.core.StandardWrapperValve.invoke 具体问题可以查看我提问题的链接https://bbs.csdn.net/topics/392383155 这里贴上我的解决方法 package com.gem.struts.c...
【Java】异常 java.io.IOException: Stream closed 的解决办法
热门推荐
极品小肥羊的博客
07-13 5万+
在程序执行过程中，如果我们遇见了以下异常：java.io.IOException: Stream closed. 即stream已经被关闭，我们分析一下就很容易知道原因了，即stream已经被关闭。那么最有可能的情况就是你多次关闭了Stream。 例如： try { InputStream is = new xxx(); // other codes is.close(
spring filter 过滤器 注入 对象 属性
wangshfa的专栏
08-01 5964
配置一： Java代码              DelegatingFilterProxy           class>org.springframework.web.filter.DelegatingFilterProxyclass>                          targetBeanName               myFilte
.net 把拦截器里面获取的参数传到controller里面_Net Core中使用Quartz.Net
weixin_42461035的博客
12-19 520
一、介绍　　Quartz.Net是根据Java的Quartz用C#改写而来，最新的版本是3.0.6，源码在https://github.com/quartznet/quartznet。主要作用是做一些周期性的工作，或者定时工作。比如每天凌晨2点对前一天的数据统计。二、简单的案例　　以WebApi项目举例，用VS脚手架功能新建WebApi项目。public void ConfigureService...
解决POST请求中文乱码：Spring MVC配置UTF-8过滤器
在Java Web环境中，解决这个问题的一个常见方法是在`web.xml`配置文件中添加一个过滤器（Filter），以确保所有POST请求都以特定的字符集（如UTF-8）进行编码和解码。 过滤器（Filter）是Servlet技术的一部分，它...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值