JavaEE_post乱码和乱码的解决方法

本文章讲解项目中 post 乱码与get 乱码的处理方法

1.post 乱码

解决方法在web.xml中加入以下代码

实质：servlet 中的拦截器 filter

<!-- post乱码过虑器 --><filter><filter-name>CharacterEncodingFilter</filter-name><filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class><init-param><param-name>encoding</param-name><param-value>utf-8</param-value></init-param></filter><filter-mapping><filter-name>CharacterEncodingFilter</filter-name><url-pattern>/*</url-pattern></filter-mapping>

filter 处理类org.springframework.web.filter.CharacterEncodingFilter,

需要引入Spring的 jar包 spring-web-3.2.0 RELEASE.jar

该类的源码（见最下面）,有兴趣的同学可以参考下，比较简单（so easy）

2.get 乱码

对于get 请求中文参数出现乱码解决方法有两个

(1)修改tomcat 配置文件添加编码与工程编码一致;

<Connector URIEncoding="utf-8" connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/>

(2)另外一种方法对参数进行重新编码

String userName =  new String(request.getParamter("userName").getBytes("ISO8859-1"),"utf-8")

 

ISO8859-1是tomcat默认编码，需要将tomcat编码后的内容按utf-8编码

Post 拦截器源码：

CharacterEncodingFilter.java

/* * Copyright 2002-2007 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.springframework.web.filter;import java.io.IOException;import javax.servlet.FilterChain;import javax.servlet.ServletException;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;/** * Servlet 2.3/2.4 Filter that allows one to specify a character encoding for * requests. This is useful because current browsers typically do not set a * character encoding even if specified in the HTML page or form. * * <p>This filter can either apply its encoding if the request does not * already specify an encoding, or enforce this filter's encoding in any case * ("forceEncoding"="true"). In the latter case, the encoding will also be * applied as default response encoding on Servlet 2.4+ containers (although * this will usually be overridden by a full content type set in the view). * * @author Juergen Hoeller * @since 15.03.2004 * @see #setEncoding * @see #setForceEncoding * @see javax.servlet.http.HttpServletRequest#setCharacterEncoding * @see javax.servlet.http.HttpServletResponse#setCharacterEncoding */public class CharacterEncodingFilter extends OncePerRequestFilter {private String encoding;private boolean forceEncoding = false;/** * Set the encoding to use for requests. This encoding will be passed into a * {@link javax.servlet.http.HttpServletRequest#setCharacterEncoding} call. * <p>Whether this encoding will override existing request encodings * (and whether it will be applied as default response encoding as well) * depends on the {@link #setForceEncoding "forceEncoding"} flag. */public void setEncoding(String encoding) {this.encoding = encoding;}/** * Set whether the configured {@link #setEncoding encoding} of this filter * is supposed to override existing request and response encodings. * <p>Default is "false", i.e. do not modify the encoding if * {@link javax.servlet.http.HttpServletRequest#getCharacterEncoding()} * returns a non-null value. Switch this to "true" to enforce the specified * encoding in any case, applying it as default response encoding as well. * <p>Note that the response encoding will only be set on Servlet 2.4+ * containers, since Servlet 2.3 did not provide a facility for setting * a default response encoding. */public void setForceEncoding(boolean forceEncoding) {this.forceEncoding = forceEncoding;}@Overrideprotected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)throws ServletException, IOException {if (this.encoding != null && (this.forceEncoding || request.getCharacterEncoding() == null)) {request.setCharacterEncoding(this.encoding);if (this.forceEncoding) {response.setCharacterEncoding(this.encoding);}}filterChain.doFilter(request, response);}}

OncePerRequestFilter.java

/* * Copyright 2002-2012 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.springframework.web.filter;import java.io.IOException;import javax.servlet.FilterChain;import javax.servlet.ServletException;import javax.servlet.ServletRequest;import javax.servlet.ServletResponse;import javax.servlet.http.HttpServletRequest;import javax.servlet.http.HttpServletResponse;import org.springframework.web.context.request.async.WebAsyncManager;import org.springframework.web.context.request.async.WebAsyncUtils;import org.springframework.web.util.WebUtils;/** * Filter base class that aims to guarantee a single execution per request * dispatch, on any servlet container. It provides a {@link #doFilterInternal} * method with HttpServletRequest and HttpServletResponse arguments. * * <p>As of Servlet 3.0, a filter may be invoked as part of a * {@link javax.servlet.DispatcherType.REQUEST REQUEST} or * {@link javax.servlet.DispatcherType.ASYNC ASYNC} dispatches that occur in * separate threads. A filter can be configured in {@code web.xml} whether it * should be involved in async dispatches. However, in some cases servlet * containers assume different default configuration. Therefore sub-classes can * override the method {@link #shouldNotFilterAsyncDispatch()} to declare * statically if they shouuld indeed be invoked, <em>once</em>, during both types * of dispatches in order to provide thread initialization, logging, security, * and so on. This mechanism complements and does not replace the need to * configure a filter in {@code web.xml} with dispatcher types. * * <p>Sub-classes may use {@link #isAsyncDispatch(HttpServletRequest)} to * determine when a filter is invoked as part of an async dispatch, and * use {@link #isAsyncStarted(HttpServletRequest)} to determine when the * request has been placed in async mode and therefore the current dispatch * won't be the last one. * * <p>Yet another dispatch type that also occurs in its own thread is * {@link javax.servlet.DispatcherType.ERROR ERROR}. Sub-classes can override * {@link #shouldNotFilterErrorDispatch()} if they wish to declare statically * if they should be invoked <em>once</em> during error dispatches. * * <p>The {@link #getAlreadyFilteredAttributeName} method determines how to * identify that a request is already filtered. The default implementation is * based on the configured name of the concrete filter instance. * * @author Juergen Hoeller * @author Rossen Stoyanchev * @since 06.12.2003 */public abstract class OncePerRequestFilter extends GenericFilterBean {/** * Suffix that gets appended to the filter name for the * "already filtered" request attribute. * @see #getAlreadyFilteredAttributeName */public static final String ALREADY_FILTERED_SUFFIX = ".FILTERED";/** * This <code>doFilter</code> implementation stores a request attribute for * "already filtered", proceeding without filtering again if the * attribute is already there. * @see #getAlreadyFilteredAttributeName * @see #shouldNotFilter * @see #doFilterInternal */public final void doFilter(ServletRequest request, ServletResponse response, FilterChain filterChain)throws ServletException, IOException {if (!(request instanceof HttpServletRequest) || !(response instanceof HttpServletResponse)) {throw new ServletException("OncePerRequestFilter just supports HTTP requests");}HttpServletRequest httpRequest = (HttpServletRequest) request;HttpServletResponse httpResponse = (HttpServletResponse) response;String alreadyFilteredAttributeName = getAlreadyFilteredAttributeName();boolean hasAlreadyFilteredAttribute = request.getAttribute(alreadyFilteredAttributeName) != null;if (hasAlreadyFilteredAttribute || skipDispatch(httpRequest) || shouldNotFilter(httpRequest)) {// Proceed without invoking this filter...filterChain.doFilter(request, response);}else {// Do invoke this filter...request.setAttribute(alreadyFilteredAttributeName, Boolean.TRUE);try {doFilterInternal(httpRequest, httpResponse, filterChain);}finally {// Remove the "already filtered" request attribute for this request.request.removeAttribute(alreadyFilteredAttributeName);}}}private boolean skipDispatch(HttpServletRequest request) {if (isAsyncDispatch(request) && shouldNotFilterAsyncDispatch()) {return true;}if ((request.getAttribute(WebUtils.ERROR_REQUEST_URI_ATTRIBUTE) != null) && shouldNotFilterErrorDispatch()) {return true;}return false;}/** * The dispatcher type {@code javax.servlet.DispatcherType.ASYNC} introduced * in Servlet 3.0 means a filter can be invoked in more than one thread over * the course of a single request. This method returns {@code true} if the * filter is currently executing within an asynchronous dispatch. * * @param request the current request * @see WebAsyncManager#hasConcurrentResult() */protected boolean isAsyncDispatch(HttpServletRequest request) {return WebAsyncUtils.getAsyncManager(request).hasConcurrentResult();}/** * Whether request processing is in asynchronous mode meaning that the * response will not be committed after the current thread is exited. * * @param request the current request * @see WebAsyncManager#isConcurrentHandlingStarted() */protected boolean isAsyncStarted(HttpServletRequest request) {return WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted();}/** * Return the name of the request attribute that identifies that a request * is already filtered. * <p>Default implementation takes the configured name of the concrete filter * instance and appends ".FILTERED". If the filter is not fully initialized, * it falls back to its class name. * @see #getFilterName * @see #ALREADY_FILTERED_SUFFIX */protected String getAlreadyFilteredAttributeName() {String name = getFilterName();if (name == null) {name = getClass().getName();}return name + ALREADY_FILTERED_SUFFIX;}/** * Can be overridden in subclasses for custom filtering control, * returning <code>true</code> to avoid filtering of the given request. * <p>The default implementation always returns <code>false</code>. * @param request current HTTP request * @return whether the given request should <i>not</i> be filtered * @throws ServletException in case of errors */protected boolean shouldNotFilter(HttpServletRequest request) throws ServletException {return false;}/** * The dispatcher type {@code javax.servlet.DispatcherType.ASYNC} introduced * in Servlet 3.0 means a filter can be invoked in more than one thread * over the course of a single request. Some filters only need to filter * the initial thread (e.g. request wrapping) while others may need * to be invoked at least once in each additional thread for example for * setting up thread locals or to perform final processing at the very end. * <p>Note that although a filter can be mapped to handle specific dispatcher * types via {@code web.xml} or in Java through the {@code ServletContext}, * servlet containers may enforce different defaults with regards to * dispatcher types. This flag enforces the design intent of the filter. * * <p>The default return value is "true", which means the filter will not be * invoked during subsequent async dispatches. If "false", the filter will * be invoked during async dispatches with the same guarantees of being * invoked only once during a request within a single thread. */protected boolean shouldNotFilterAsyncDispatch() {return true;}/** * Whether to filter error dispatches such as when the servlet container * processes and error mapped in {@code web.xml}. The default return value * is "true", which means the filter will not be invoked in case of an error * dispatch. */protected boolean shouldNotFilterErrorDispatch() {return true;}/** * Same contract as for <code>doFilter</code>, but guaranteed to be * just invoked once per request within a single request thread. * See {@link #shouldNotFilterAsyncDispatch()} for details. * <p>Provides HttpServletRequest and HttpServletResponse arguments instead of the * default ServletRequest and ServletResponse ones. */protected abstract void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain)throws ServletException, IOException;}

GenericFilterBean.java

/* * Copyright 2002-2011 the original author or authors. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * *      http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */package org.springframework.web.filter;import java.util.Enumeration;import java.util.HashSet;import java.util.Set;import javax.servlet.Filter;import javax.servlet.FilterConfig;import javax.servlet.ServletContext;import javax.servlet.ServletException;import org.apache.commons.logging.Log;import org.apache.commons.logging.LogFactory;import org.springframework.beans.BeanWrapper;import org.springframework.beans.BeansException;import org.springframework.beans.MutablePropertyValues;import org.springframework.beans.PropertyAccessorFactory;import org.springframework.beans.PropertyValue;import org.springframework.beans.PropertyValues;import org.springframework.beans.factory.BeanNameAware;import org.springframework.beans.factory.DisposableBean;import org.springframework.beans.factory.InitializingBean;import org.springframework.context.EnvironmentAware;import org.springframework.core.env.Environment;import org.springframework.core.io.Resource;import org.springframework.core.io.ResourceEditor;import org.springframework.core.io.ResourceLoader;import org.springframework.util.Assert;import org.springframework.util.StringUtils;import org.springframework.web.context.ServletContextAware;import org.springframework.web.context.support.StandardServletEnvironment;import org.springframework.web.context.support.ServletContextResourceLoader;import org.springframework.web.util.NestedServletException;/** * Simple base implementation of {@link javax.servlet.Filter} which treats * its config parameters (<code>init-param</code> entries within the * <code>filter</code> tag in <code>web.xml</code>) as bean properties. * * <p>A handy superclass for any type of filter. Type conversion of config * parameters is automatic, with the corresponding setter method getting * invoked with the converted value. It is also possible for subclasses to * specify required properties. Parameters without matching bean property * setter will simply be ignored. * * <p>This filter leaves actual filtering to subclasses, which have to * implement the {@link javax.servlet.Filter#doFilter} method. * * <p>This generic filter base class has no dependency on the Spring * {@link org.springframework.context.ApplicationContext} concept. * Filters usually don't load their own context but rather access service * beans from the Spring root application context, accessible via the * filter's {@link #getServletContext() ServletContext} (see * {@link org.springframework.web.context.support.WebApplicationContextUtils}). * * @author Juergen Hoeller * @since 06.12.2003 * @see #addRequiredProperty * @see #initFilterBean * @see #doFilter */public abstract class GenericFilterBean implementsFilter, BeanNameAware, EnvironmentAware, ServletContextAware, InitializingBean, DisposableBean {/** Logger available to subclasses */protected final Log logger = LogFactory.getLog(getClass());/** * Set of required properties (Strings) that must be supplied as * config parameters to this filter. */private final Set<String> requiredProperties = new HashSet<String>();private FilterConfig filterConfig;private String beanName;private Environment environment = new StandardServletEnvironment();private ServletContext servletContext;/** * Stores the bean name as defined in the Spring bean factory. * <p>Only relevant in case of initialization as bean, to have a name as * fallback to the filter name usually provided by a FilterConfig instance. * @see org.springframework.beans.factory.BeanNameAware * @see #getFilterName() */public final void setBeanName(String beanName) {this.beanName = beanName;}/** * {@inheritDoc} * <p>Any environment set here overrides the {@link StandardServletEnvironment} * provided by default. * <p>This {@code Environment} object is used only for resolving placeholders in * resource paths passed into init-parameters for this filter. If no init-params are * used, this {@code Environment} can be essentially ignored. * @see #init(FilterConfig) */public void setEnvironment(Environment environment) {this.environment = environment;}/** * Stores the ServletContext that the bean factory runs in. * <p>Only relevant in case of initialization as bean, to have a ServletContext * as fallback to the context usually provided by a FilterConfig instance. * @see org.springframework.web.context.ServletContextAware * @see #getServletContext() */public final void setServletContext(ServletContext servletContext) {this.servletContext = servletContext;}/** * Calls the <code>initFilterBean()</code> method that might * contain custom initialization of a subclass. * <p>Only relevant in case of initialization as bean, where the * standard <code>init(FilterConfig)</code> method won't be called. * @see #initFilterBean() * @see #init(javax.servlet.FilterConfig) */public void afterPropertiesSet() throws ServletException {initFilterBean();}/** * Subclasses can invoke this method to specify that this property * (which must match a JavaBean property they expose) is mandatory, * and must be supplied as a config parameter. This should be called * from the constructor of a subclass. * <p>This method is only relevant in case of traditional initialization * driven by a FilterConfig instance. * @param property name of the required property */protected final void addRequiredProperty(String property) {this.requiredProperties.add(property);}/** * Standard way of initializing this filter. * Map config parameters onto bean properties of this filter, and * invoke subclass initialization. * @param filterConfig the configuration for this filter * @throws ServletException if bean properties are invalid (or required * properties are missing), or if subclass initialization fails. * @see #initFilterBean */public final void init(FilterConfig filterConfig) throws ServletException {Assert.notNull(filterConfig, "FilterConfig must not be null");if (logger.isDebugEnabled()) {logger.debug("Initializing filter '" + filterConfig.getFilterName() + "'");}this.filterConfig = filterConfig;// Set bean properties from init parameters.try {PropertyValues pvs = new FilterConfigPropertyValues(filterConfig, this.requiredProperties);BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);ResourceLoader resourceLoader = new ServletContextResourceLoader(filterConfig.getServletContext());bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, this.environment));initBeanWrapper(bw);bw.setPropertyValues(pvs, true);}catch (BeansException ex) {String msg = "Failed to set bean properties on filter '" +    filterConfig.getFilterName() + "': " + ex.getMessage();logger.error(msg, ex);throw new NestedServletException(msg, ex);}// Let subclasses do whatever initialization they like.initFilterBean();if (logger.isDebugEnabled()) {logger.debug("Filter '" + filterConfig.getFilterName() + "' configured successfully");}}/** * Initialize the BeanWrapper for this GenericFilterBean, * possibly with custom editors. * <p>This default implementation is empty. * @param bw the BeanWrapper to initialize * @throws BeansException if thrown by BeanWrapper methods * @see org.springframework.beans.BeanWrapper#registerCustomEditor */protected void initBeanWrapper(BeanWrapper bw) throws BeansException {}/** * Make the FilterConfig of this filter available, if any. * Analogous to GenericServlet's <code>getServletConfig()</code>. * <p>Public to resemble the <code>getFilterConfig()</code> method * of the Servlet Filter version that shipped with WebLogic 6.1. * @return the FilterConfig instance, or <code>null</code> if none available * @see javax.servlet.GenericServlet#getServletConfig() */public final FilterConfig getFilterConfig() {return this.filterConfig;}/** * Make the name of this filter available to subclasses. * Analogous to GenericServlet's <code>getServletName()</code>. * <p>Takes the FilterConfig's filter name by default. * If initialized as bean in a Spring application context, * it falls back to the bean name as defined in the bean factory. * @return the filter name, or <code>null</code> if none available * @see javax.servlet.GenericServlet#getServletName() * @see javax.servlet.FilterConfig#getFilterName() * @see #setBeanName */protected final String getFilterName() {return (this.filterConfig != null ? this.filterConfig.getFilterName() : this.beanName);}/** * Make the ServletContext of this filter available to subclasses. * Analogous to GenericServlet's <code>getServletContext()</code>. * <p>Takes the FilterConfig's ServletContext by default. * If initialized as bean in a Spring application context, * it falls back to the ServletContext that the bean factory runs in. * @return the ServletContext instance, or <code>null</code> if none available * @see javax.servlet.GenericServlet#getServletContext() * @see javax.servlet.FilterConfig#getServletContext() * @see #setServletContext */protected final ServletContext getServletContext() {return (this.filterConfig != null ? this.filterConfig.getServletContext() : this.servletContext);}/** * Subclasses may override this to perform custom initialization. * All bean properties of this filter will have been set before this * method is invoked. * <p>Note: This method will be called from standard filter initialization * as well as filter bean initialization in a Spring application context. * Filter name and ServletContext will be available in both cases. * <p>This default implementation is empty. * @throws ServletException if subclass initialization fails * @see #getFilterName() * @see #getServletContext() */protected void initFilterBean() throws ServletException {}/** * Subclasses may override this to perform custom filter shutdown. * <p>Note: This method will be called from standard filter destruction * as well as filter bean destruction in a Spring application context. * <p>This default implementation is empty. */public void destroy() {}/** * PropertyValues implementation created from FilterConfig init parameters. */@SuppressWarnings("serial")private static class FilterConfigPropertyValues extends MutablePropertyValues {/** * Create new FilterConfigPropertyValues. * @param config FilterConfig we'll use to take PropertyValues from * @param requiredProperties set of property names we need, where * we can't accept default values * @throws ServletException if any required properties are missing */public FilterConfigPropertyValues(FilterConfig config, Set<String> requiredProperties)throws ServletException {Set<String> missingProps = (requiredProperties != null && !requiredProperties.isEmpty()) ?new HashSet<String>(requiredProperties) : null;Enumeration<?> en = config.getInitParameterNames();while (en.hasMoreElements()) {String property = (String) en.nextElement();Object value = config.getInitParameter(property);addPropertyValue(new PropertyValue(property, value));if (missingProps != null) {missingProps.remove(property);}}// Fail if we are still missing properties.if (missingProps != null && missingProps.size() > 0) {throw new ServletException(    "Initialization from FilterConfig for filter '" + config.getFilterName() +    "' failed; the following required properties were missing: " +    StringUtils.collectionToDelimitedString(missingProps, ", "));}}}}