JavaEE_post乱码和乱码的解决方法
2015-12-10 10:20
381 查看
本文章讲解项目中 post 乱码与get 乱码的处理方法
1.post 乱码
解决方法在web.xml中加入以下代码
实质:servlet 中的拦截器 filter
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
OncePerRequestFilter.java
GenericFilterBean.java
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; } @Override protected 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 implements Filter, 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, ", ")); } } } }
相关文章推荐
- 【Java字符串高效率】统计单词统计个数
- jdk和jre有什么区别
- Efficient Counter in Java
- Java性能调优笔记
- Struts2 Convention Plugin ( struts2 零配置 )
- [SqlHandle] java mysql语法 sql语句拼接工具简类
- Java内存与垃圾回收调优
- 基于接口设计原则-java
- java的锁机制
- struts2使用Convention Plugin在weblogic上以war包部署时,找不到Action的解决办法
- JAVA多线程实现的三种方式
- 关于spring boot jar包与war包的问题
- JAVA — 强引用 软引用 弱引用 虚引用 介绍
- java中判断字符串是否为纯数字
- 【Java EE (Struts2 + Spring + Hibernate)开发】:Hibernate(一)基本用法
- JAVA常用框架和插件
- java web项目答辩答辩题总结(书本网上语言答辩+自己的语言答辩)
- Spring整合SpringMVC
- MyEclipse工程高版本换低版本报错
- Spring+Struts2