精华内容
下载资源
问答
  • Tomcat上部署项目后出现访问静态资源(例如:html文件,txt文件)乱码,主要分两种情况。 非Spring MVC项目 Spirng MVC项目 本文章所使用 Tomcat 版本分别为7.0.100和8.5.54 注意: 本文的 html 文件均带了<meta...

    注意: 非本人阅读请跳转到问题分析与解决一栏
    分类分析:

    • 非Spring MVC项目
    • Spirng MVC项目

    本文章所使用 Tomcat 版本分别为7.0.1008.5.54

    注意: 本文的 html 文件均带了<meta charset="utf-8">标签如果没带此标签,解析html和解析txt效果一样!!

    非Spring MVC项目

    在非spring mvc项目中出现访问静态资源乱码,如 txt 文本等,一般都是文件编码为非BOM的UTF-8,将文件编码改为UTF-8 BOM格式即可。具体信息查看下面表格:

    Tomcat文件类型文件编码是否正常访问
    7.0.100htmlUTF-8
    7.0.100htmlUTF-8 BOM
    7.0.100txtUTF-8
    7.0.100txtUTF-8 BOM
    Tomcat文件类型文件编码是否正常访问
    8.5.54htmlUTF-8
    8.5.54htmlUTF-8 BOM
    8.5.54txtUTF-8
    8.5.54txtUTF-8 BOM

    Spirng MVC项目

    如果配置了CharacterEncodingFilter且初始化了参数forceResponseEncodingforceEncodingtrue,此时每次请求静态资源时,CharacterEncodingFilter都会在响应头加上charset=UTF-8。参数为false,或未设置时,情况和上面非Spring MVC情况一致。

    <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>
            <!--初始化forceResponseEncoding为true-->
            <init-param>
                <param-name>forceResponseEncoding</param-name>
                <param-value>true</param-value>
            </init-param>
        </filter>
        <filter-mapping>
            <filter-name>characterEncodingFilter</filter-name>
            <url-pattern>/*</url-pattern>
        </filter-mapping>
    

    当设置了forceResponseEncodingforceEncodingtrue时,具体显示信息如下:

    Tomcat文件类型文件编码是否正常访问
    7.0.100htmlUTF-8
    7.0.100htmlUTF-8 BOM
    7.0.100txtUTF-8
    7.0.100txtUTF-8 BOM
    Tomcat文件类型文件编码是否正常访问
    8.5.54htmlUTF-8
    8.5.54htmlUTF-8 BOM
    8.5.54txtUTF-8
    8.5.54txtUTF-8 BOM

    问题分析与解决

    解决乱码只需加入fileEncoding参数,如下所示。(前提: 你的静态资源文件编码必须是UTF-8)

    <servlet>
            <servlet-name>default</servlet-name>
            <servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
            <init-param>
                <param-name>debug</param-name>
                <param-value>0</param-value>
            </init-param>
            <init-param>
                <param-name>listings</param-name>
                <param-value>false</param-value>
            </init-param>
            <!--fileEncoding  
            Encoding to be used to read static resources 
            [platform default]-->
            <!--增加下面初始化参数-->
            <init-param>
            	<param-name>fileEncoding</param-name>
            	<param-value>UTF-8</param-value>
            </init-param>
            <load-on-startup>1</load-on-startup>
        </servlet>
    

    影响DefaultServlet解析静态资源编码主要有两个重要的参数fileEncodinguseBomIfPresent

    	/**
         * File encoding to be used when reading static files. If none is specified
         * the platform default is used.
         */
         //读取静态文件时要使用的文件编码,如果未指定,则使用平台默认值。
        protected String fileEncoding = null;
        private transient Charset fileEncodingCharset = null;
    
        /**
         * If a file has a BOM, should that be used in preference to fileEncoding?
         * Will default to {@code BomConfig.TRUE} in {@link #init()}.
         */
         //如果文件有BOM,是否应该优先使用BOM而不是fileEncoding?将在init()中默认设置为BomConfig.TRUE。
        private BomConfig useBomIfPresent = null;
    

    init()源码:

    		//获取初始化参数fileEncoding,若没有则返回null
            fileEncoding = getServletConfig().getInitParameter("fileEncoding");
            if (fileEncoding == null) {
            	//尝试输出fileEncoding得到结果为GBK----用命令行运行测试Charset.defaultCharset()
            	//IDEA或者Eclipse运行出来的结果可能是UTF-8
                fileEncodingCharset = Charset.defaultCharset();
                fileEncoding = fileEncodingCharset.name();
            } else {
                ……
            }
    		//获取初始化参数useBomIfPresent,若没有则返回null
            String useBomIfPresent = getServletConfig().getInitParameter("useBomIfPresent");
            if (useBomIfPresent == null) {
                // Use default
                //使用默认值BomConfig.TRUE
                this.useBomIfPresent = BomConfig.TRUE;
            } else {
                ……
                }
               
    

    枚举类BomConfig源码:

    static enum BomConfig {
            /**
             * BoM is stripped if present and any BoM found used to determine the
             * encoding used to read the resource.
             */
             //如果存在BOM,则会将其剥离,并使用找到的BOM来确定用于读取资源的编码。
            TRUE("true", true, true),
            /**
             * BoM is stripped if present but the configured file encoding is used
             * to read the resource.
             */
             //BOM(如果存在)将被剥离,但配置的文件编码(fileEncoding)用于读取资源。
            FALSE("false", true, false),
    ……
    

    综上,如果未指定fileEncoding初始化参数,Tomcat将使用平台默认编码解析静态资源,而Windows默认编码为GBK,所以解码UTF-8的文件出现乱码。为什么带BOM的文件Tomcat能正常解析,那是因为参数useBomIfPresent的默认值为BomConfig.TRUE,此情况下Tomcat解析到带有BOM的文件时BOM推断出的编码优先级高于fileEncoding属性,比如前三个字节为EF BB BF,Tomcat便知道这个静态资源是UTF-8编码,于是使用UTF-8解码(即使fileEncoding = GBK)。至于为什么html能普遍解析成功,个人猜测是因为<meta charset="utf-8">标签告诉Tomcat此文件是UTF-8编码,所以Tomcat能解析成功。

    关于获取Request域中数据乱码问题

    public void init() {
            messageGET = "GET-----你好";
            messagePOST = "POST-----你好";
        }
     public void doGet(HttpServletRequest request, HttpServletResponse response) throws IOException {
            //request
            //默认request.getCharacterEncoding()返回null
            if (null == request.getCharacterEncoding()) {
                System.out.println("charset == null");
            }
            //tomcat7 ---解码url用ISO-8859-1  ----解决方法->使用tomcat8+或者修改server.xml
            //<Connector connectionTimeout="20000"  (URIEncoding="UTF-8") port="8080" protocol="HTTP/1.1" redirectPort="8443"/>
            //tomcat8 ---解码url用UTF-8
            //GET请求无法提供以下方法修改获取url参数的编码方式
    //        request.setCharacterEncoding("UTF-8");
            String s = request.getParameter("s");
            System.out.println("GET-----s: " + new String(s.getBytes(StandardCharsets.ISO_8859_1), StandardCharsets.UTF_8));
            //response
            //tomcat响应默认用ISO-8859-1
            //response.getCharacterEncoding()默认返回ISO-8859-1
            System.out.println("response: " + response.getCharacterEncoding());
            response.setCharacterEncoding("UTF-8");
            response.setContentType("text/html");
            PrintWriter out = response.getWriter();
            out.println("<html><body>");
            out.println("<h1>" + messageGET + "</h1>");
            out.println("</body></html>");
        }
    
        @Override
        protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            //request
            //默认request.getCharacterEncoding()返回null
            if (null == req.getCharacterEncoding()) {
                System.out.println("charset == null");
            }
            //POST请求通过以下方法修改读取请求体数据的编码
            req.setCharacterEncoding("UTF-8");
            if (null != req.getCharacterEncoding()) {
                System.out.println("charset == " + req.getCharacterEncoding());
            }
            //POST读取参数默认用ISO-8859-1
            String s = req.getParameter("s");
            System.out.println("POST------s: " + s);
            //response
            //响应默认用ISO-8859-1
            //response.getCharacterEncoding()默认返回ISO-8859-1
            System.out.println("response: " + resp.getCharacterEncoding());
            resp.setCharacterEncoding("UTF-8");
            resp.setContentType("text/html");
            PrintWriter out = resp.getWriter();
            out.println("<html><body>");
            out.println("<h1>" + messagePOST + "</h1>");
            out.println("</body></html>");
        }
    

    本文章仅个人学习记载,包含主观想法,并不确保正确性。如若有误,恳请指正!

    展开全文
  • 解决Tomcat请求中文乱码的问题

    万次阅读 2018-03-22 16:50:49
    Tomcat 中处理带中文参数的get请求时,照着以往的做法,发现还是乱码,这让我丈二和尚摸不着头脑,结果一查询才发现,我所使用的 Tomcat8 已经对get方式中文乱码进行了处理。

    在 Tomcat 中处理带中文参数的get请求时,照着以往的做法,发现还是乱码,这让我丈二和尚摸不着头脑,结果一查询才发现,我所使用的 Tomcat8 已经对get方式中文乱码进行了处理。Tomcat8 中终于不用为了编码而折腾了。

    原因

    在Tomcat中,所有字符默认是按ISO-8859-1的编码格式来编码的,这是欧洲使用的一种字符编码格式。在浏览器发起http请求时,将请求的url以及参数按服务器指定的UTF-8编码后发送到Tomcat,这时Tomcat并不知道发送来的字符是按什么编码的,使用默认的ISO-8859-1格式来解析字符,导致中文乱码。Tomcat Http请求中文乱码

    解决

    Tomcat8

    高版本 Tomcat 中,Tomcat8 对 GET 的默认解码为 UTF-8。只要没有对 server.xml Connector 元素进行改动(对编码部分进行参数配置),那么,Tomcat8 对 GET 的默认解码则为 UTF-8。也就不会乱码了。

    Tomcat7 及以下

    Tomcat7 及以下版本,GET 方式提交的参数编码,只支持 ISO8859-1 编码。因此,有三个解决中文参数乱码的方法: get方式传值中文乱码

    1. 在后台转换编码,如下:

      String bname = request.getParameter("bname"); 
      bname = new String(bname .getBytes("iso8859-1"),"utf-8"); 

      当然,前提是你页面编码就是 UTF-8。如果是 GBK,那上面那句代码后面就改成 GBK。

    2. 在客户端使用 encodeURI() 对中文参数进行编码,在服务器端需要进行解码this.setName(java.net.URLDecoder.decode(name, “UTF-8”));

    3. 修改tomcat的server.xml文件

      <Connector executor="tomcatThreadPool"
             port="8080" protocol="HTTP/1.1"
             connectionTimeout="20000"
             redirectPort="8443"
             <!-- 添加参数 -->
             URIEncoding="GBK" 
             useBodyEncodingForURI="true"/>

      同样的,URIEncoding 需要与页面编码保持一致。

      URIEncoding 是请求的 URL 中字符的编码,会将 URL 中 %xx 这样的 URL 按这里指定的编码格式去解码,如果不指定则会使用默认的 ISO-8859-1 。

      useBodyEncodingForURI=”true”,该属性是使用 body 体的编码格式去解析 URL 中的 %xx。

    总结

    Tomcat8 好。

    展开全文
  • 我的Tomcat版本是Tomcat7,其他版本配置的方式基本一样。 首先打开Tomcat安装目录,打开conf文件夹。 打开server.xml,在大概71行的位置 在Connector标签添加属性URIEncoding= "utf-8" 这样就可以了。 ...

    我的Tomcat版本是Tomcat7,其他版本配置的方式基本一样。

    首先打开Tomcat安装目录,打开conf文件夹。

    打开server.xml,在大概71行的位置

    在Connector标签添加属性 URIEncoding= "utf-8"

    这样就可以了。

    展开全文
  • 访问Tomcat服务器返回数据乱码

    万次阅读 2017-04-21 00:15:49
    前序: 在网络中,数据的传输,最常用的格式有两种:XML和JSON 。 Tomcat服务器

    前序:

    在网络中,数据的传输,最常用的格式有两种:XML和JSON 。

    今天在做一个app版本更新检查。流程是:
    1、Andriod客户端 向 Tomcat服务器 发起Http请求。
    2、服务器响应并返回数据。返回的数据中,包含了新版app的特性和更新内容。并通过一个Dialog 对话框的形式,来告知用户,新版的app作了那些方面的改进。也就是调用dialog.setMessage()来设置消息内容,结果发现全是乱码。
    3、之前一直没遇到这种情况,后来在QQ群了问了才知道,原来这个涉及到了编码的问题。

    客户端和服务端发送数据的过程:

    先贴个Tomcat webapps目录底下的升级文件内容图:

    这个文件,我是直接在桌面新建一个txt文档,然后强制修改文件类型为json的。之后用记事本打开,在里面编写内容。最后经过个人验证,这种做法是很有问题的,也是埋下乱码的一个伏笔。

    再贴个乱码的图:

    一、先梳理一下:客户端访问网络的流程:

    首先一定要清楚的一点:网络传递的是字节流,所以从服务器到android的转换过程如下:

    在分析这个图之前。我们先来,理一理app访问网络的一个思路:
    1、客户端使用 HttpURLConnection 向服务器请求响应。
    2、服务器接收到请求后,响应请求,并返回数据。
    3、客户端接收到数据。此时,客户端一般都是接受到一个InputStream对象(输入流)。
    4、用InputStream 生产各种对象,最后转成一个String 对象,也就是一个字符串。然后开始对这个字符串进行解析(这时候 XML和JSON 这两个格式 的解析方法 就派上用场了)。
    5、数据解析完成后,各个变量拿到自己的对象后。各干各的去了。

    但是,大家有没有想过,我们拿到的数据,是用什么编码方式得出了的数据?这也是为什么会出现乱码的关键点了。

    需要再清楚的一点:
    1、在进行XML 或者JSON 数据解析之前,我们能利用的资源,有且只有一个,也就是服务器返的唯一的一样东西—-InputStream(输入流)。
    2、 我们拿到这个输入流之后,经过一连串处理,得到一个字符串。具体怎么处理,等下看代码就行了。
    3、 接着根据字符串的格式,xml格式?还是Json格式?进行数据解析。然后拿到我们想要的东西。

    好了,废话不多说,我们还是来贴代码吧。

    有人说中文是最美的语言,但我认为是最操蛋的语言。因为无论你说什么,都他妈的可以有各种意思!

    这里给大家提供一个比较标准的Android访问网络的代码:

    private void sendRequestWithHttpURLConnection() {
            //访问网络,首要就是--开启子线程。
            new Thread(new Runnable() {
                @Override
                public void run() {
                    //下面4个变量定义在try catch块外面,是因为如果定义在try里面,finally里面就拿不到变量了,
                    //关闭不了对象,会造成内存泄露。
                    HttpURLConnection connection = null;
                    InputStream is = null;
                    BufferedReader buffer = null;
                    String result = null;
                    try {
                        //这里我访问的是我Tomcat的服务器数据。
                        URL url = new URL("http://1r667695p8.iok.la:37179/mydata/get_data.json");
                        connection = (HttpURLConnection) url.openConnection();
                        connection.setRequestMethod("GET");
                        connection.setConnectTimeout(8000);
                        connection.setReadTimeout(8000);
                        is = connection.getInputStream();
                        buffer = new BufferedReader(new InputStreamReader(is));
                        StringBuilder response = new StringBuilder();
                        String line;
                        //打开连接后,子线程会循环读buffer的数据,直到null为止。不符合条件,才会往下执行。
                        while ((line = buffer.readLine()) != null) {
                            response.append(line);
                        }
                        //转换为字符串
                        result = response.toString();
                        //字符串解析(用什么方法解析,主要看:字符串是什么格式 xml 还是json格式)
                        parseJSONWithJSONObject(result);
                    } catch (Exception e) {
                        Log.d("异常捕获", "http post error");
                    } finally {
                         //这几个一定要关闭,否则会造成内存泄漏。
                        if (buffer != null) {
                            try {
                                buffer.close();
                            } catch (IOException ignored) {
                            }
                        }
                        if (is != null) {
                            try {
                                is.close();
                            } catch (IOException ignored) {
    
                            }
                        }
                        if (connection != null) {
                            connection.disconnect();
                        }
                    }
                }
            }).start();
        }

    上面的代码,估计大家都很熟悉。但是不知道大家有没有想过这几行代码:
    从14行到18行:

    connection = (HttpURLConnection) url.openConnection();
    connection.setRequestMethod(“GET”);
    connection.setConnectTimeout(8000);
    connection.setReadTimeout(8000);
    is = connection.getInputStream();

    我们一起来看一看,14行代码打开一个连接(connection),接着设置一些参数,18行就去接收输入流了。问题来了,我们都知道,程序都是一行一行执行的。而访问网络,肯定也是需要时间的。你凭什么在18行,就可以把输入流赋值给is变量?也就是说CPU执行到

    is = connection.getInputStream();

    的时候,按照函数的返回值的思路,我们都认为,它只是一个执行connection.getInputStream()完成后的一个返回值,但是其实,is 相当于一个盒子,connection.getInputStream()应该是启动了某个操作,这个操作则不断的去获取数据,直到数据没有了。线程只是启动这个操作,之后就不管它了,线程接着往下走。

    is = connection.getInputStream();
    //这行代码是先执行getInputStream()这个方法,应该是开启了一个线程(有待验证!)

    //数据解析,代码很简单。

    private void parseJSONWithJSONObject(String result) {
            try {
                JSONObject obj = new JSONObject(result);
                String apkUrl = obj.getString("url");                 //APK下载路径
                String updateMessage = obj.getString("updateMessage");//版本更新说明
                int apkCode = obj.getInt("versionCode");              //新版APK对于的版本号
                //取得已经安装在手机的APP的版本号 versionCode
                int versionCode = getCurrentVersionCode();
    
                //对比版本号判断是否需要更新
                if (apkCode > versionCode) {
                    showDialog(updateMessage, apkUrl);
                }
    
            } catch (JSONException e) {
                LogX.d(TAG, "parse json error");
            }
        }

    对话框的方法,下图

    private void showDialog(String content, final String downloadUrl) {
            //字符串 content 可能需要先转码
            AlertDialog.Builder builder = new AlertDialog.Builder(mContext);
            builder.setTitle(R.string.dialog_choose_update_title);
            builder.setMessage(content)
                    .setPositiveButton(R.string.dialog_btn_confirm_download, new DialogInterface.OnClickListener() {
                        public void onClick(DialogInterface dialog, int id) {
                            //下载apk文件
                            goToDownloadApk(downloadUrl);
                        }
                    })
                    .setNegativeButton(R.string.dialog_btn_cancel_download, new DialogInterface.OnClickListener() {
                        public void onClick(DialogInterface dialog, int id) {
                        }
                    });
    
            AlertDialog dialog = builder.create();
            //点击对话框外面,对话框不消失
            dialog.setCanceledOnTouchOutside(false);
            dialog.show();
        }
    

    其中Sting类型的参数content 。就是我们要显示的中文了,只不过它现在还是经过编码的字符串。当我们显示到手机屏幕的时候,Android会帮我们解码。拿到对应的字符集的字。如果我们拿到的不是utf-8的编码,那么此时,我们是需要进行转码的,转成utf-8。然后给Android显示端。 (主要是要明白,解码在那个阶段地方,上面的代码没能体现出转码的地方,因为我们拿到的就是utf-8)

    二、现在来谈谈编码方式

    1、编码的问题
    在谈编码方式之前,大家先来做一个小实验:

    大家在电脑上新建一个txt类型的文档,然后双击打开,在里面输入:联通2字 。

    接着保存并退出。然后直接双击打开刚才的txt文档,你会发现,咦,怎么是乱码了!!!

    这是为什么呢?这就涉及到了编码方式的问题了。这是因为我们的保存和打开的方式并不是同一种。这样的话,解码的过程就出错了,看到的就是乱码了。我们的电脑上都有很多不同格式类型的文件,比如: txt文档、记事本、word文档等等,那么这个编码方式是由谁来确定的呢?是我们系统平台Windows、Linux,还是我们编辑的软件呢。回想一下刚才的小实验,和Android studio 中常用的xml 文件。答案肯定是编辑软件了。

    也就是说,我们在保存的时候,当前的编辑软件是先把我们的内容通过编码的方式,打包成ByteArray,然后交给系统,系统帮我们保存数据包。如果是由系统编码,那系统不累死了,而且市场上那么多类型的文件,系统怎么知道你这个软件要使用那一种编码?所以系统的责任只是保存。它不管你里面是什么,只要是数据包就ok。

    整个流程,我们可以用下面一个图来描述:

    对同一个字符,如果采用了不同字符集来编码,那么生成的值可能是不一样。比如,对同一个中文,采用不同的字符集来编码,得到的数值都不一样。那么解码的时候,如果用另一套字符集,那肯定会乱码。

    2、解码的问题

    好了,既然知道了保存的时候使用的是某一种编码方式,那么打开的时候,肯定也要使用相应的解码方式,这样才能获得正确的数据。

    三、本次乱码的问题的原因

    由上面的知识知道,保存的时候会有一个编码的过程,打开的时候会有一个解码的过程。但是,Tomcat并不提供一个打开过程,而是在启动的时候,自动去加载webapps 底下目录的资源。

    1、也就是说,这些资源(其实就是ByteArray)是被加载到内存中的,并不像我们直接使用软件去打开,所以我们不能从视觉上,直观的看到加载到内存中的数据有没有变化,或者说存不存在乱码的问题。换句话说,我们并不知道,Tomcat有没有对系统交给它的ByteArray进行解码。
    2、Tomcat在响应请求的时候,发送数据之前会不会对自己内存的数据进行编码呢?

    换句话说,如果Tomcat在加载资源的时候有进行解码,而它用了却用了自己特有的方式去解码,那么Tomcat加载到内存中的数据本身就已经成乱码了,如果在发送的时候,Tomcat再进行一次编码,那就是乱上加乱,火上浇油了。这样,客户端完全没法解码了!

    如果我们能搞清楚上面的两个问题,那么一切都会迎刃而解了。然而,理想是美好的,现实却是残酷的。由于知识所限,我们根本没法验证这些东西。

    Tomcat的整个加载流程我们可以这么来描述:

    四、问题的解决。

    虽然以上的大多数问题,我们都了解了。但是,我们根本就无法去验证。

    比如:你写了一个json类型的文件,你怎么知道你当前的编辑软件用的是什么编码格式呢?

    如下图所示:

    这时候,我想起了,我们Android Studio 中使用的编码方式是utf-8。那么我们可不可以用Android Studio 去打开我们这个json类型的文件呢?之后修改并保存。这样的话,我们保存在系统上的数据,就是采用utf-8这种编码方式了。这时候,只好动手来试一试了。
    然后我们用Android Studio去打开我们的json升级文件。

    什么鬼,怎么中文全是乱码?到这里,大家应该明白了吧,Android Studio 是使用utf-8 来编码的,解码当然也用utf-8了。换个角度来说,这也证明了,我们之前用记事本保存数据的时候,它的编码并不是utf-8。那么解码方式不对,也就乱码了!所以我们只好在Android Studio打开的方式下,手动修改下。

    修改好之后,保存。然后启动我们的Tomcat,再用APP端向服务端申请数据。

    耶,终于不是乱码了!

    从这个实验中,我们可以得出两个结论:
    1、Tomcat在发送数据的时候,是会对数据进行编码的,用的是utf-8编码。因为Android在显示的时候,是一定会对数据进行解码的。如果Tomcat不进行编码,那Android端得到的就是乱码。
    2、Tomcat加载资源的时候,肯定是会对资源进行解码的。它的解码方式也是utf-8,为什么说肯定会解码呢,因为不解码的话,数据在内存中做了各种加减乘除运算后,鬼知道你是什么了。

    小结:保存数据要编码—加载数据要解码—发送服务要编码—接收数据要解码 。四个环节的方式都要一样,这样才不会乱码。
    通过这件事情,我明白了,原来我们系统上保存的资源,都是经过编码的ByteArray
    最后给大家一个,android端向服务端post数据时,编码的转换流程图:

    张鸿洋的博客:

    Android访问服务器(TOMCAT)乱码引发的问题。链接:http://blog.csdn.net/lmj623565791/article/details/21789381

    一定要注意这句:服务器(Tomcat)默认使用iso-8859-1解码。Iso-8859-1是不支持中文的,也就是说不做处理,中文是一定乱码的。

    这里说的是:解码用的是iso-8859-1,并不是编码。很多人的博客都是乱写的。小编用的是Tomcat6.0。就没有去设置这个玩意。
    在TOMCAT的配置文件的server.xml中更改:

    展开全文
  • 解决问题的核心在于修改Tomcat的...Tomcat内置的对于get协议中的URL编码是ISO-8859-1,这个字符集不能直接支持中文等双字节的信息,而中文文件的下载链接恰恰是通过get协议进行的。 打开$tomcat安装目录$/config/se...
  • Tomcat 启动乱码设置

    千次阅读 2019-07-25 20:51:10
    tomcat 服务器乱码的问题简直了。。。乱码引起的问题各种各样,每个问题解决的关键点的不一样。这里记录下自己今天遇见的乱码 首先吐槽乱码引起的问题 访问中文名称的静态资源访问不到,简直要吐血了。解决办法...
  • /common/lib:存放所有web项目都可以访问的公共jar包(使用Common类加载器加载)。/conf:存放配置文件,最重要的是server.xml。/logs:存放日志文件。/server/webapps:来管理Tomcat-web服务用的。仅对TOMCAT可见,对...
  • Tomcat默认是按ISO-8859-1进行URL解码,ISO-8859-1并未包括中文字符,中文字符不能被正确解析了。 解决方法: 开发工具: 设置开发工具,eclipse 或者 myeclipse 编码为 utf-8 ----window --- preferences --- ...
  • 相信很多初学者在刚开始使用Tomcat的时候都被中文乱码问题所困扰过,我曾经也遇到了这个问题,苦苦搜寻各大社区,看了无数帖子,结果依然没有解决问题。原因有两个,一是我比较笨&lt;,二是确实这个问题过于基础...
  • -- 配置Tomcat插件 --&gt; &lt;plugins&gt;  &lt;plugin&gt;  &lt;groupId&gt;org.apache.tomcat.maven&lt;/groupId&gt;  &lt;artifactId&gt;tomcat7-maven-plugin&...
  • Java Web项目中,如果使用的是Tomcat服务器的话,在数据交互时,经常会出现深恶痛绝 中文乱码的问题,原因主要可以分为以下两个方面: 1.在JSP页面中,中文根本无法显示。 这种情况下,通常的原因是: 没有把...
  • 现象: cenos 部署java web 程序 ,java类中有中文 出现乱码现象   即使使用: System.getProperty("中文")   控制台都出现 ?????? 乱码,现象很奇怪   经查: 运行: 此方法 输出中发现有 ...
  • Idea结合Tomcat访问JSP页面使用response输出,出现了乱码!!!
  • Tomcat+Springmvc中文乱码问题解决方法

    千次阅读 2017-05-18 16:21:11
    请求时参数变乱码在web.xml中设置springmvc编码<filter> <filter-name>characterEncodingFilter</filter-name> <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class> ...
  • 解决办法:在连接数据库的url后增加serverTimezone=UTC字段,即: jdbc.url=jdbc\:mysql\://127.0.0.1\:3306/dqsm?useUnicode\=true&characterEncoding\=utf-8&useSSL\=false&serverTimezone=UTC .....
  • 当在浏览器中访问URL中带有特殊字符,如花括号冒号时,就会出现这个错误。 例如:http://localhost:8080/index.do?{id:123} 解决方法: 添加 tomcat.util.http.parser.HttpParser.requestTargetAllow=|{} ...
  • 昨天在开发前端程序的时候,需要在iframe的URL中携带一个参数包含中文,测试时发现乱码了。 下面是乱码的效果: 经过各种查阅,发现问题是这样引起的: Tomcat下默认的编码使用ISO8859-1,而我的页面指定...
  • tomcat 下jsp乱码的原因分析

    万次阅读 2014-11-06 14:26:36
    tomcat 下jsp乱码的原因分析。从jsp文件的编码、浏览器中页面的编码、以及tomcat本身对数据处理方式等各个方面一一阐述了乱码产生的原因以及解决乱码的基本的方法
  • •Linux CentOS7环境下Tomcat7.9 接收请求,中文乱码问题的解决2019-12-10(周二·阴天)开发工具:问题描述:成因分析解决办法 2019-12-10(周二·阴天) 这是博主个人的IT开发技术blog整理小笔记。 开发工具: ...
  •  使用 Tomcat 开发一个 Java Web 项目的时候,相信大多数人都遇到过url出现中文乱码的情况,绝大多数人为了避免出现这种问题,所以设计 url 一般都会尽量设计成都是英文字符。但总避免一种情况就是当你的系统中拥有...
  • TOMCAT中文乱码问题的解决方案

    千次阅读 2017-03-21 10:24:12
    本人在使用AliPay的支付接口时遇到notify_url正常,但是return_url乱码,后查询到notify使用的是POST请求,而return_url使用的是GET请求,针对这个情况使用useBodyEncodingForURI="true"解决问题。 注意:也可通过...
  • 服务器搭建tomcat,通过url访问视频

    千次阅读 热门讨论 2021-07-22 16:08:08
    文章目录 scp指令: 下载jdk 配置jdk环境变量: 环境成功标志 下载tomcat tomcat配置成功标志 项目访问 方式一 成功标志 方式二 进入目录 编辑`conf/web.xml` 改后 成功标志 如果文件是中文,下载会出现文件名乱码 ...
  • tomcat 请求中文乱码

    2017-07-19 16:37:57
    tomcat中设置编码格式: 在tomcat的conf目录,打开server.xml,修改: 在这一句中间添加:  URIEncoding="UTF-8" 变成:
  •    前段时间突然发现 分类 里的中文分类都无法正常打开,而英文分类可以,觉得应该是中文乱码的问题,打开WinSCP查看了一下目录发现确实是乱码了: ![](https://qiniu.scauwlt.top/6AOUJDS9(UW902AG2‘7‘OP.png)...
  • 在已经在应用filter中指定了页面编码为...原因是:Tomcat默认是按ISO-8859-1进行URL解码,ISO-8859-1并未包括中文字符,中文字符不能被正确解析了 如以下代码所示: Servlet: @WebServlet("/mylogin") public c...
  • 数据库中文乱码解决方案汇总
  • http访问Tomcat传参出现乱码

    千次阅读 2014-11-20 14:46:42
    写了一个查询数据库的程序,不熟的Tomcat6。查询条件为英文时运行正常,为中文时出现乱码。...Tomcat乱码 首先,说说JSP/Servlet中的几个编码的作用。  在JSP/Servlet中主要有以下几个地方可以设置编码,pag
  • server下新建tomcat服务,添加应用服务,启动后,访问页面jsp,jstl输出中文乱码。 eclipse已经修改编码格式为UTF-8。 解决方案: 修改tomcat的server.xml,修改代码如下: [code="xml"] ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 20,915
精华内容 8,366
关键字:

tomcat访问url乱码