Solve Chinese garbled characters in URL parameters passed by get Method

From: http://www.javaeye.com/topic/483158

Application 1: solves the problem of Chinese garbled characters in Tomcat (a simple one first)

In tomcat, we usually solve the Chinese Garbled text problem as follows:

Filter code:

Java code

1. Package filter;
3. Import java. Io .*;
4. Import javax. servlet .*;
5. Import javax. servlet. http .*;
6. Import wrapper. gethttpservletrequestwrapper;
8. Public class contenttypefilter implements filter {
10. Private string charset = "UTF-8 ";
11. Private filterconfig config;
13. Public void destroy (){
14. System. Out. println (config. getfiltername () + "destroyed ");
15. Charset = NULL;
16. Config = NULL;
17. }
19. Public void dofilter (servletrequest request, servletresponse response,
20. Filterchain chain) throws ioexception, servletexception {
21. // Set the character encoding of the Request Response
22. Request. setcharacterencoding (charset );
23. Response. setcharacterencoding (charset );
25. Httpservletrequest Req = (httpservletrequest) request;
28. System. Out. println ("---- the request is" + config. getfiltername () + "filtered ");
29. // Execute the next filter (if any, otherwise execute the target servlet)
30. Chain. dofilter (req, response );
32. System. Out. println ("---- the response is" + config. getfiltername () + "filtered ");
34. }
36. Public void Init (filterconfig config) throws servletexception {
37. This. Config = config;
38. String charset = config. getservletcontext (). getinitparameter ("charset ");
39. If (charset! = NULL & charset. Trim (). Length ()! = 0)
40. {
41. This. charset = charset;
42. }
43. }
45. }

 

Filter configuration in Web. xml:

XML Code

1. <! -- Configure the character encoding to the application initialization parameter instead of the private initialization parameter of the filter because JSP and other places may also need to use -->
2. <Context-param>
3. <Param-Name> charset </param-Name>
4. <Param-value> UTF-8 </param-value>
5. </Context-param>
7. <Filter>
8. <Filter-Name> contenttypefilter </filter-Name>
9. <Filter-class> filter. contenttypefilter </filter-class>
10. </Filter>
12. <Filter-mapping>
13. <Filter-Name> contenttypefilter </filter-Name>
14. <URL-pattern>/* </url-pattern>
15. </Filter-mapping>

Request. setcharacterencoding (charset); It must be written before request. getparameter () is used for the first time, so that the parameter can be obtained according to the character encoding that has been set.
Response. setcharacterencoding (charset); It must be written before printwriter out = request. getwriter (). In this way, the out can be output according to the configured character encoding.

Through the filter, we can ensure that the character encoding of the request and response is set before the servlet or JSP execution.

However, this does not completely solve the Chinese Garbled text problem:

For post requests, neither the "get parameter link" nor the "output link" is correct;

For GET requests, there is no problem with the "output stage", but the "get parameters stage" still shows Chinese garbled characters, so the garbled characters are directly output during output.

The reason is that the location of the parameters stored in the post and get requests is different:

Post parameters are stored in the message body of the request data packet. The get method parameters are stored in the URI field of the request line of the request packet? Start attaching it to the URI field in the form of param = Value & parame2 = value2. Request. setcharacterencoding (charset); only applies to the data in the message body and does not take effect for parameters in the URI field. We usually use the following code to complete encoding conversion:

Java code

1. String paramvalue = request. getparameter ("paramname ");
2. Paramvalue = new string (paramvalue. Trim (). getbytes ("ISO-8859-1"), charset );

But every time such a conversion is really troublesome, is there a unified solution?

Solution 1: Set the uriencoding attribute to the appropriate character encoding in the connector element of tomcat_home \ conf \ Server. xml.

Java code

1. <Connector Port = "8080" protocol = "HTTP/1.1"
2. Connectiontimeout = "20000"
3. Redirectport = "8443"
4. Uriencoding = "UTF-8"
5. />

The disadvantage is that other applications under the same Tomcat will also be affected. It is also difficult to modify the configuration of classes during each deployment.

Solution 2: Custom request wrapper wraps the request and adds the character encoding conversion to the getparameter () method.

Java code

1. Package wrapper;
3. Import java. Io. unsupportedencodingexception;
4. Import java.net. urldecoder;
6. Import javax. servlet. http. httpservletrequest;
7. Import javax. servlet. http. httpservletrequestwrapper;
9. Public class gethttpservletrequestwrapper extends httpservletrequestwrapper {
11. Private string charset = "UTF-8 ";
13. Public gethttpservletrequestwrapper (httpservletrequest request ){
14. Super (request );
15. }
17. /**
18. * Get the reference and character encoding of the decorated object
19. * @ Param request
20. * @ Param charset
21. */
22. Public gethttpservletrequestwrapper (httpservletrequest request,
23. String charset ){
24. Super (request );
25. This. charset = charset;
26. }
28. /**
29. * In fact, it is to call the getparameter method of the encapsulated request object to obtain the parameter, and then encode and convert it.
30. */
31. Public String getparameter (string name ){
32. String value = super. getparameter (name );
33. Value = NULL? Null: Convert (value );
34. Return value;
35. }
37. Public String convert (string target ){
38. System. Out. println ("Before encoding conversion:" + target );
39. Try {
40. Return new string (target. Trim (). getbytes ("ISO-8859-1"), charset );
41. } Catch (unsupportedencodingexception e ){
42. Return target;
43. }
44. }
46. }

The code for modifying the dofilter method of the filter is as follows:

Java code

1. Public void dofilter (servletrequest request, servletresponse response,
2. Filterchain chain) throws ioexception, servletexception {
3. // Set the character encoding of the Request Response
4. Request. setcharacterencoding (charset );
5. Response. setcharacterencoding (charset );
6. // Newly added code
7. Httpservletrequest Req = (httpservletrequest) request;
9. If (req. getmethod (). inclusignorecase ("get "))
10. {
11. Req = new gethttpservletrequestwrapper (req, charset );
12. }
14. System. Out. println ("---- the request is" + config. getfiltername () + "filtered ");
15. // Reference of the actual package object passed to the target servlet or JSP, instead of the original httpservletrequest object
16. Chain. dofilter (req, response );
18. System. Out. println ("---- the response is" + config. getfiltername () + "filtered ");
20. }

In this way, the getparameters method of the package is called in the servlet to obtain the parameter, and the character encoding conversion process has been completed. We do not need to convert the character encoding every time we obtain the parameter.