精华内容
下载资源
问答
  • tomcat设置编码utf8

    2017-05-10 19:48:00
    1.Java类: CharacterEncodingFilter import javax.servlet.*; import java.io.IOException; public class CharacterEncodingFilter implements Filter { ... private String encoding = "UTF-8"; ...

    1.       Java类: CharacterEncodingFilter

     import javax.servlet.*;

    import java.io.IOException;

     

     public class CharacterEncodingFilter implements Filter {

     

        private String encoding = "UTF-8";

        private boolean forceEncoding = true;

     

        /**

         * Set the encoding to use for requests. This encoding will be

         * passed into a ServletRequest.setCharacterEncoding call.

         * <p>Whether this encoding will override existing request

         * encodings depends on the "forceEncoding" flag.

         */

        public void setEncoding(String encoding) {

            this.encoding = encoding;

        }

     

        /**

         * Set whether the encoding of this filter should override existing

         * request encodings. Default is "false", i.e. do not modify encoding

         * if ServletRequest.getCharacterEncoding returns a non-null value.

         */

        public void setForceEncoding(boolean forceEncoding) {

            this.forceEncoding = forceEncoding;

        }

     

        public void init(FilterConfig filterConfig) throws ServletException {

            this.encoding = filterConfig.getInitParameter("encoding");

            String force = filterConfig.getInitParameter("forceEncoding");

            this.forceEncoding = (force == null) || Boolean.valueOf(force).booleanValue() ;

        }

     

        public void doFilter(ServletRequest servletRequest,

                             ServletResponse servletResponse,

                             FilterChain filterChain) throws IOException, ServletException {

            if (this.forceEncoding || servletRequest.getCharacterEncoding() == null) {

                servletRequest.setCharacterEncoding(this.encoding);

            }

            filterChain.doFilter(servletRequest, servletResponse);

        }

     

        public void destroy() {

     

        }

     

    }

     

    2.       在web.xml配置文件里加Filters Configurations

     <!-- Filters Configurations        -->

           <filter>

                  <filter-name>CHARACTER_ENCODING</filter-name>

                  <filter-class>

                         common.encoding.CharacterEncodingFilter</filter-class>

                  <init-param>

                         <param-name>encoding</param-name>

                         <param-value>UTF-8</param-value>

                  </init-param>

                  <init-param>

                         <param-name>forceEncoding</param-name>

                         <param-value>true</param-value>

                  </init-param>

           </filter>

           <filter-mapping>

                  <filter-name>CHARACTER_ENCODING</filter-name>

                  <url-pattern>/*</url-pattern>

           </filter-mapping>

     

    3.数据库建立为UTF-8格式 
    4.项目右键属性为UTF-8格式 
    5.所有页面申明为UTF-8 
    6.JDBC URL设为:UTF-8 

    jdbc:MySQL://localhost:3306/databaseuse?useUnicode=true&characterEncoding=utf-8 
    7.数据库Driver选择UTF-8格式 
    8.Tomcat编码改成UTF-8 


    在server.xml里面增加URIEncoding="UTF-8"

    <Connector port="8080" maxHttpHeaderSize="8192" maxThreads="150" minSpareThreads="25" maxSpareThreads="75" enableLookups="false" redirectPort="8443" acceptCount="100" connectionTimeout="20000" disableUploadTimeout="true" URIEncoding="UTF-8" />

    转载于:https://www.cnblogs.com/panxuejun/p/6837784.html

    展开全文
  • 报错回顾MySQL 中 utf8 的趣事utf8mb4 才是真正的UTF-8utf8 的简史总结记得去年我在往 MySQL 存入 emoji ??表情时,一直出错,无法导入。后来找到办法,通过把 utf8 改成 utf8mb4 就可以了,当时并没有深究。图片...
    • 报错回顾
    • MySQL 中 utf8 的趣事
    • utf8mb4 才是真正的UTF-8
    • utf8 的简史
    • 总结

    283345bb85e05814d7fecbaae0a48d1b.png


    记得去年我在往 MySQL 存入 emoji ??表情时,一直出错,无法导入。后来找到办法,通过把 utf8 改成 utf8mb4 就可以了,当时并没有深究。

    ae7eb05730e88875d6e9a42eddf1151b.png
    图片来自 Pexels

    一年后,我看到一篇文章讲到 emoji 文字占 4 个字节,通常要用 utf-8 去接收才行,其他编码可能会出错。

    我突然想到去年操作 MySQL 把 utf8 改成 utf8mb4 的事儿。

    嗯?他本身不就是 utf8 编码么!那我当时还改个锤子?难道,MySQL 的 utf8 不是真正的 UTF-8 编码吗??! 卧槽,这 MySQL 有 Bug!

    带着疑问查询了很多相关材料,才发现这竟然是 MySQL 的一个历史遗留问题。我笑了,没想到这么牛 B 的 MySQL 也会有这段往事。

    报错回顾

    将 emoji 文字直接写入 SQL 中,执行 insert 语句报错 :

    INSERT INTO `csjdemo`.`student` (`ID`, `NAME`, `SEX`, `AGE`, `CLASS`, `GRADE`, `HOBBY`)
       VALUES ('20''陈哈哈?''男''20''181班''9年级''看片儿');
    [Err] 1366 - Incorrect string value: '\xF0\x9F\x98\x93' for column 'NAME' at row 1

    改了数据库编码、系统编码以及表字段的编码格式→utf8mb4 之后,就可以了:

    INSERT INTO `student` (`ID`, `NAME`, `SEX`, `AGE`, `CLASS`, `GRADE`, `HOBBY`)
       VALUES (null'陈哈哈??''男''20''181班''9年级''看片儿');
    cf51133e0e93f84feef41814e36ce984.png

    MySQL 中 utf8 的趣事

    MySQL 的“utf8”实际上不是真正的 UTF-8。

    在 MySQL 中,“utf8”编码只支持每个字符最多三个字节,而真正的 UTF-8 是每个字符最多四个字节。

    在 utf8 编码中,中文是占 3 个字节,其他数字、英文、符号占一个字节。

    但 emoji 符号占 4 个字节,一些较复杂的文字、繁体字也是 4 个字节。所以导致写入失败,应该改成 utf8mb4。

    9de3943535e7887696b5697bac070fb8.png

    如上图中所示,这是编码改成 utf8mb4 后入库的数据,大家可以清晰的对比一下所占的字符数、字节数。

    正因如此,4 字节的内容往 utf8 编码中插入,肯定是不行的,插不进去啊,是吧(大潘摊手)。

    74d51ccd2001bbacd0bc05903df9be18.gif

    MySQL 一直没有修复这个 Bug,他们在 2010 年发布了一个叫作“utf8mb4”的字符集,巧妙的绕过了这个问题。

    当然,他们并没有对新的字符集广而告之(可能是因为这个 Bug 让他们觉得很尴尬),以致于现在网络上仍然在建议开发者使用“utf8”,但这些建议都是错误的。

    utf8mb4 才是真正的UTF-8

    是的,MySQL 的“utf8mb4”才是真正的“UTF-8”。

    MySQL 的“utf8”是一种“专属的编码”,它能够编码的 Unicode 字符并不多。

    在这里 Mark 一下: 所有在使用“utf8”的 MySQL 和 MariaDB 用户都应该改用“utf8mb4”,永远都不要再使用“utf8”。

    933ea850b3c363fa981d0a7e8e8611fc.gif

    那么什么是编码?什么是 UTF-8?我们都知道,计算机使用 0 和 1 来存储文本,比如字符“C”被存成“01000011”。

    那么计算机在显示这个字符时需要经过两个步骤 :

    • 计算机读取“01000011”,得到数字 67,因为 67 被编码成“01000011”。
    • 计算机在 Unicode 字符集中查找 67,找到了“C”。

    同样的 :

    • 我的电脑将“C”映射成 Unicode 字符集中的 67。
    • 我的电脑将 67 编码成“01000011”,并发送给 Web 服务器。

    几乎所有的网络应用都使用了 Unicode 字符集,因为没有理由使用其他字符集。

    Unicode 字符集包含了上百万个字符。最简单的编码是 UTF-32,每个字符使用 32 位。

    这样做最简单,因为一直以来,计算机将 32 位视为数字,而计算机最在行的就是处理数字。但问题是,这样太浪费空间了。

    UTF-8 可以节省空间,在 UTF-8 中,字符“C”只需要 8 位,一些不常用的字符,比如“?”需要 32 位。其他的字符可能使用 16 位或 24 位。

    一篇类似本文这样的文章,如果使用 UTF-8 编码,占用的空间只有 UTF-32 的四分之一左右。

    utf8 的简史

    为什么 MySQL 开发者会让“utf8”失效?我们或许可以从 MySQL 版本提交日志中寻找答案。

    MySQL 从 4.1 版本开始支持 UTF-8,也就是 2003 年,而今天使用的 UTF-8 标准(RFC 3629)是随后才出现的。

    旧版的 UTF-8 标准(RFC 2279)最多支持每个字符 6 个字节。2002 年 3 月 28 日,MySQL 开发者在第一个 MySQL 4.1 预览版中使用了 RFC 2279。

    同年 9 月,他们对 MySQL 源代码进行了一次调整:“UTF8 现在最多只支持 3 个字节的序列”。

    是谁提交了这些代码?他为什么要这样做?这个问题不得而知。

    在迁移到 Git 后(MySQL 最开始使用的是 BitKeeper),MySQL 代码库中的很多提交者的名字都丢失了。2003 年 9 月的邮件列表中也找不到可以解释这一变更的线索。

    不过我们可以试着猜测一下:2002 年,MySQL 做出了一个决定:如果用户可以保证数据表的每一行都使用相同的字节数,那么 MySQL 就可以在性能方面来一个大提升。

    为此,用户需要将文本列定义为“CHAR”,每个“CHAR”列总是拥有相同数量的字符。

    如果插入的字符少于定义的数量,MySQL 就会在后面填充空格,如果插入的字符超过了定义的数量,后面超出部分会被截断。

    MySQL 开发者在最开始尝试 UTF-8 时使用了每个字符 6 个字节,CHAR(1) 使用 6 个字节,CHAR(2) 使用 12 个字节,并以此类推。

    应该说,他们最初的行为才是正确的,可惜这一版本一直没有发布。但是文档上却这么写了,而且广为流传,所有了解 UTF-8 的人都认同文档里写的东西。

    c402327a46309428b969a83b0fa66520.png

    不过很显然,MySQL 开发者或厂商担心会有用户做这两件事 :

    • 使用 CHAR 定义列(在现在看来,CHAR 已经是老古董了,但在那时,在 MySQL 中使用 CHAR 会更快,不过从 2005 年以后就不是这样子了)。
    • 将 CHAR 列的编码设置为“utf8”。

    我的猜测是 MySQL 开发者本来想帮助那些希望在空间和速度上双赢的用户,但他们搞砸了“utf8”编码。

    所以结果就是没有赢家。那些希望在空间和速度上双赢的用户,当他们在使用“utf8”的 CHAR 列时,实际上使用的空间比预期的更大,速度也比预期的慢。

    而想要正确性的用户,当他们使用“utf8”编码时,却无法保存像“?”这样的字符,因为“?”是 4 个字节的。

    在这个不合法的字符集发布了之后,MySQL 就无法修复它,因为这样需要要求所有用户重新构建他们的数据库。

    最终,MySQL 在 2010 年重新发布了“utf8mb4”来支持真正的 UTF-8。

    总结

    主要是目前网络上几乎所有的文章都把 “utf8” 当成是真正的 UTF-8,包括之前我写的文章以及做的项目(捂脸);因此希望更多的朋友能够看到这篇文章。

    相信还有很多跟我在同一条船上的人,这是必然的。

    所以,大家以后再搭建 MySQL、MariaDB 数据库时,记得将数据库相应编码都改为 utf8mb4。

    终有一天,接你班儿的程序员你的领导现这个问题后,一定会在心里默默感到你的技术牛B。

    展开全文
  • JVM优化 - 第三天今日内容Tomcat8的优化看懂Java底层字节码编码的优化建议1、Tomcat8优化tomcat服务器在JavaEE项目中使用率非常高,所以在生产环境对tomcat的优化也变得非 常重要了。对于tomcat的优化,主要是从2个...

    JVM优化 - 第三天

    今日内容

    Tomcat8的优化

    看懂Java底层字节码

    编码的优化建议

    1、Tomcat8优化

    tomcat服务器在JavaEE项目中使用率非常高,所以在生产环境对tomcat的优化也变得非 常重要了。

    对于tomcat的优化,主要是从2个方面入手,一是,tomcat自身的配置,另一个是

    tomcat所运行的jvm虚拟机的调优。

    下面我们将从这2个方面进行讲解。

    1.1、Tomcat配置优化1.1.1、部署安装tomcat8 下载并安装:

    https://tomcat.apache.org/download-80.cgi

    7612198a26411dff80a0f205641cfc04.png

    cd /tmp

    wget http://mirrors.tuna.tsinghua.edu.cn/apache/tomcat/tomcat‐ 8/v8.5.34/bin/apache‐tomcat‐8.5.34.tar.gz

    tar ‐xvf apache‐tomcat‐8.5.34.tar.gz cd apache‐tomcat‐8.5.34/conf

    #修改配置文件,配置tomcat的管理用户

    vim tomcat‐users.xml #写入如下内容:

    #保存退出

    #如果是tomcat7,配置了tomcat用户就可以登录系统了,但是tomcat8中不行,还需要修改另一个配置文件,否则访问不了,提示403

    vim webapps/manager/META‐INF/context.xml

    #将

    #保存退出即可

    #启动tomcat

    cd /tmp/apache‐tomcat‐8.5.34/bin/

    ./startup.sh && tail ‐f …/logs/catalina.out

    #打开浏览器进行测试访问http://192.168.40.133:8080/

    3aa8a132b90586633121a73a10b461a4.png

    点击“Server Status”,输入用户名、密码进行登录,tomcat/tomcat

    000cd58aeb892059f87035d29f9ac28d.png
    9e175021368a77f0d02b94ce0fd92a52.png

    进入之后即可看到服务的信息。

    1.1.2、禁用AJP连接

    在服务状态页面中可以看到,默认状态下会启用AJP服务,并且占用8009端口。

    ec839a6e542c1d8fafb1d6959d38e60c.png

    什么是AJP呢?

    AJP(Apache JServer Protocol)

    AJPv13协议是面向包的。WEB服务器和Servlet容器通过TCP连接来交互;为了节省SOCKET创建的昂贵代价,WEB服务器会尝试维护一个永久TCP连接到servlet容器,并且在多个请求和响应周期过程会重用连接。

    8bf3ea5dd4cc9a383113b49c2b747814.png

    我们一般是使用Nginx+tomcat的架构,所以用不着AJP协议,所以把AJP连接器禁用。修改conf下的server.xml文件,将AJP服务禁用掉即可。

    b958e73a5ef1729f438a5a0e2b703e43.png

    重启tomcat,查看效果。

    afef0e01156808ad9ff6e6fc147de888.png

    可以看到AJP服务以及不存在了。

    1.1.3、执行器(线程池)

    在tomcat中每一个用户请求都是一个线程,所以可以使用线程池提高性能。

    修改server.xml文件:

    保存退出,重启tomcat,查看效果。

    96109a46c3e5b5f0e35613d2c5f26594.png

    在页面中显示最大线程数为-1,这个是正常的,仅仅是显示的问题,实际使用的指定的值。

    也有人遇到这样的问

    题:https://blog.csdn.net/weixin_38278878/article/details/80144397

    1.1.4、3种运行模式

    tomcat的运行模式有3种:

    1.bio

    默认的模式,性能非常低下,没有经过任何优化处理和支持.

    2.nio

    nio(new I/O),是Java SE 1.4及后续版本提供的一种新的I/O操作方式(即java.nio包及其子包)。Java nio是一个基于缓冲区、并能提供非阻塞I/O操作的Java API,因此nio 也被看成是non-blocking I/O的缩写。它拥有比传统I/O操作(bio)更好的并发运行性能。

    3.apr

    安装起来最困难,但是从操作系统级别来解决异步的IO问题,大幅度的提高性能.

    推荐使用nio,不过,在tomcat8中有最新的nio2,速度更快,建议使用nio2. 设置nio2:

    a9877978f59c927c8b58f828de043fb2.png

    可以看到已经设置为nio2了。

    1.2、部署测试用的java web项目

    为了方便测试性能,我们将部署一个java web项目,这个项目本身和本套课程没有什么关系,仅仅用于测试。

    注意:这里在测试时,我们使用一个新的tomcat,进行测试,后面再对其进行优化 调整,再测试。

    1.2.1、创建dashboard数据库

    在资料中找到sql脚本文件dashboard.sql,在linux服务器上执行。

    cat dashboard.sql | mysql ‐uroot ‐proot

    创建完成后,可以看到有3张表。

    825d41a1c1d5bce47915f2714db381c4.png

    1.2.2、部署web应用

    在资料中找到itcat-dashboard-web.war,上传到linux服务器,进行部署安装。

    cd /tmp/apache‐tomcat‐8.5.34/webappsrm ‐rf * mkdir ROOT cd ROOT/rz上传war包jar ‐xvf itcat‐dashboard‐web.war rm ‐rf itcat‐dashboard‐web.war#修改数据库配置文件cd /tmp/apache‐tomcat‐8.5.34/webapps/ROOT/WEB‐INF/classes vim jdbc.properties#这里根据自己的实际情况进行配置jdbc.driverClassName=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://node01:3306/dashboard? useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueri es=truejdbc.username=rootjdbc.password=root

    重新启动tomcat。

    访问首页,查看是否已经启动成功:http://192.168.40.133:8080/index

    efc4ef6fe85bc4e5a8025b11821ce291.png

    1.3、使用Apache JMeter进行测试

    Apache Jmeter是开源的压力测试工具,我们借助于此工具进行测试,将测试出tomcat

    的吞吐量等信息。

    1.3.1、下载安装

    下载地址:http://jmeter.apache.org/download_jmeter.cgi

    ed0b5967fb9b035eeaaa365301a6b309.png

    安装:直接将下载好的zip压缩包进行解压即可。

    a352af0ddd251388f24f2033f2e81ec7.png

    进入bin目录,找到jmeter.bat文件,双机打开即可启动。

    69445a90d936faf950944ae93f0b3d83.png
    4e6e5f3d4252e1886ce07396c37c72d7.png
    e551552bc970bf8da2e916f9c9f2087d.png

    1.3.2、修改主题和语言

    默认的主题是黑色风格的主题并且语言是英语,这样不太方便使用,所以需要修改下主题和中文语言。

    6d6fc91c35624dcbe328c56b34b204f5.png
    b458c5f2f861d481c9519a0d47c0bacb.png
    2df2b2a160d208e439854603c557ec04.png

    主题修改完成。

    接下来设置语言为简体中文。

    3eb544ef1e08f2fcec80b4f86b1c6540.png

    1.3.3、创建首页的测试用例

    第一步:保存测试用例

    20421be07c5963e702fb178ae1e8b2a1.png

    第二步:添加线程组,使用线程模拟用户的并发

    74d97e2aa4af20cdc0baeeab86f4fc4f.png
    939e38fbaddb9efe7aec3cb4c3ef9055.png

    1000个线程,每个线程循环10次,也就是tomcat会接收到10000个请求。

    第三步:添加http请求

    3cc59d252649235dd014ea7482761d63.png
    408a253bdc6873787b5ff9e2d62bfbce.png

    第四步:添加请求监控

    b8687183677197b1d2eb4118347e75be.png
    23c2b9895f7139034a9975150c0617c0.png

    1.3.4、启动、进行测试

    522faece5d66f2afba4157733b7d8de3.png

    1.3.5、聚合报告

    在聚合报告中,重点看吞吐量。

    4c5a98f7eebc5a88324764fd5639a21e.png

    1.4、调整tomcat参数进行优化

    通过上面测试可以看出,tomcat在不做任何调整时,吞吐量为73次/秒。

    1.4.1、禁用AJP服务

    390a285d89c351df45cecfa102880bfc.png
    a6f0b25badfa77bb88156357ca3fbc1b.png

    可以看到,禁用AJP服务后,吞吐量会有所提升。

    当然了,测试不一定准确,需要多测试几次才能看出是否有提升。

    1.4.2、设置线程池

    通过设置线程池,调整线程池相关的参数进行测试tomcat的性能。

    1.4.2.1、最大线程数为500,初始为50

    测试结果:

    63de7b9f6dc933467501a47442240c4e.png

    吞吐量为128次/秒,性能有所提升。

    1.4.2.2、最大线程数为1000,初始为200

    8024ea933ecdd8ad2755996d899cd029.png

    吞吐量为151,性能有所提升。

    1.4.2.3、最大线程数为5000,初始为1000

    是否是线程数最多,速度越快呢? 我们来测试下。

    d8972029d1ea2c096af103ae3dbbd88d.png

    可以看到,虽然最大线程已经设置到5000,但是实际测试效果并不理想,并且平均的响 应时间也边长了,所以单纯靠提升线程数量是不能一直得到性能提升的。

    1.4.2.4、设置最大等待队列数

    默认情况下,请求发送到tomcat,如果tomcat正忙,那么该请求会一直等待。这样虽然 可以保证每个请求都能请求到,但是请求时间就会边长。

    有些时候,我们也不一定要求请求一定等待,可以设置最大等待队列大小,如果超过就不等待了。这样虽然有些请求是失败的,但是请求时间会虽短。典型的应用:12306。

    aa58202fcc4ef6b7ed5b0fabaf7ea998.png

    测试结果:

    平均响应时间:3.1秒响应时间明显缩短

    错误率:49.88%

    错误率提升到一半,也可以理解,最大线程为500,测试的并发为1000 吞吐量:238次/秒

    吞吐量明显提升

    结论:响应时间、吞吐量这2个指标需要找到平衡才能达到更好的性能。

    1.4.3、设置nio2的运行模式

    将最大线程设置为500进行测试:

    a3a6558be479c8d2f7aafce37354c4f1.png

    可以看到,平均响应时间有缩短,吞吐量有提升,可以得出结论:nio2的性能要高于

    nio。

    1.5、调整JVM参数进行优化

    接下来,测试通过jvm参数进行优化,为了测试一致性,依然将最大线程数设置为500, 启用nio2运行模式。

    1.5.1、设置并行垃圾回收器

    #年轻代、老年代均使用并行收集器,初始堆内存64M,最大堆内存512M JAVA_OPTS="‐XX:+UseParallelGC ‐XX:+UseParallelOldGC ‐Xms64m ‐Xmx512m ‐ XX:+PrintGCDetails ‐XX:+PrintGCTimeStamps ‐XX:+PrintGCDateStamps ‐ XX:+PrintHeapAtGC ‐Xloggc:../logs/gc.log"
    921cc7a0d2eb25cb5ba2df61014baf63.png

    测试结果与默认的JVM参数结果接近。(执行了2次测试,结果是第二次测试的结果)

    1.5.2、查看gc日志文件

    将gc.log文件上传到gceasy.io查看gc中是否存在问题。

    19e46048126a46a2b181ae488c8246db.png

    在报告中显示,在5次GC时,系统所消耗的时间大于用户时间,这反应出的服务器的性能存在瓶颈,调度CPU等资源所消耗的时间要长一些。

    问题二:

    267a72c4c4bdedb42eebaf48cab81d3d.png

    可以关键指标中可以看出,吞吐量表现不错,但是gc时,线程的暂停时间稍有点长。

    问题三:

    ab41b08f9eff6edcbd0b679c0a80a498.png

    通过GC的统计可以看出:

    年轻代的gc有74次,次数稍有多,说明年轻代设置的大小不合适需要调整

    FullGC有8次,说明堆内存的大小不合适,需要调整

    问题四:

    df323a46f12a7e8ed7522d4101667ca4.png

    从GC原因的可以看出,年轻代大小设置不合理,导致了多次GC。

    1.5.3、调整年轻代大小

    JAVA_OPTS="‐XX:+UseParallelGC ‐XX:+UseParallelOldGC ‐Xms128m ‐Xmx1024m ‐ XX:NewSize=64m ‐XX:MaxNewSize=256m ‐XX:+PrintGCDetails ‐ XX:+PrintGCTimeStamps ‐XX:+PrintGCDateStamps ‐XX:+PrintHeapAtGC ‐ Xloggc:../logs/gc.log"

    将初始堆大小设置为128m,最大为1024m

    初始年轻代大小64m,年轻代最大256m

    8b464a1f1159adb78571b0a706f8565d.png

    从测试结果来看,吞吐量以及响应时间均有提升。

    查看gc日志:

    ad0833f9691b7a77656031cf6b9f35c1.png
    2d93dc57e3a09ad8cec9048b539c3423.png

    可以看到GC次数要明显减少,说明调整是有效的。

    1.5.4、设置G1垃圾回收器

    #设置了最大停顿时间100毫秒,初始堆内存128m,最大堆内存1024m JAVA_OPTS="‐XX:+UseG1GC ‐XX:MaxGCPauseMillis=100 ‐Xms128m ‐Xmx1024m ‐ XX:+PrintGCDetails ‐XX:+PrintGCTimeStamps ‐XX:+PrintGCDateStamps ‐ XX:+PrintHeapAtGC ‐Xloggc:../logs/gc.log"

    测试结果:

    e2ea2daed691ea1a3fb4d78ba9484b5f.png
    8f43bf14fd3ec8787cfc4ebf46c63645.png

    可以看到,吞吐量有所提升,评价响应时间也有所缩短。

    1.5.5、小结

    通过上述的测试,可以总结出,对tomcat性能优化就是需要不断的进行调整参数,然后 测试结果,可能会调优也可能会调差,这时就需要借助于gc的可视化工具来看gc的情 况。再帮我我们做出决策应该调整哪些参数。

    2、JVM字节码

    前面我们通过tomcat本身的参数以及jvm的参数对tomcat做了优化,其实要想将应用程 序跑的更快、效率更高,除了对tomcat容器以及jvm优化外,应用程序代码本身如果写 的效率不高的,那么也是不行的,所以,对于程序本身的优化也就很重要了。

    对于程序本身的优化,可以借鉴很多前辈们的经验,但是有些时候,在从源码角度方面 分析的话,不好鉴别出哪个效率高,如对字符串拼接的操作,是直接“+”号拼接效率高还 是使用StringBuilder效率高?

    这个时候,就需要通过查看编译好的class文件中字节码,就可以找到答案。

    我们都知道,java编写应用,需要先通过javac命令编译成class文件,再通过jvm执行,

    jvm执行时是需要将class文件中的字节码载入到jvm进行运行的。

    2.1、通过javap命令查看class文件的字节码内容

    首先,看一个简单的Test1类的代码:

    package cn.itcast.jvm;public class Test1 {public static void main(String[] args) {int a = 2; int b = 5; int c = b ‐ a;System.out.println(c);}}

    通过javap命令查看class文件中的字节码内容:

    javap ‐v Test1.class > Test1.txtjavap用法: javap 其中, 可能的选项包括:‐help‐‐help‐?‐version‐v‐verbose‐l‐public‐protected‐package‐p‐private‐c‐s‐sysinfo‐constants‐classpath ‐cp ‐bootclasspath 

    查看Test1.txt文件,内容如下:

    Classfile /F:/code/itcast‐jvm/itcast‐jvm‐ test/target/classes/cn/itcast/jvm/Test1.classLast modified 2018‐9‐27; size 577 bytesMD5 checksum 4214859db3543c0c783ec8a216a4795f Compiled from "Test1.java"public class cn.itcast.jvm.Test1 minor version: 0major version: 52flags: ACC_PUBLIC, ACC_SUPERConstant pool:#1 = Methodref#5.#23// java/lang/Object."": ()V#2 = Fieldref#24.#25// java/lang/System.out:Ljava/io/PrintStream;#3 = Methodref#26.#27// java/io/PrintStream.println: (I)V#28 = Utf8cn/itcast/jvm/Test1#29 = Utf8java/lang/Object#30 = Utf8java/lang/System#31 = Utf8out#32 = Utf8Ljava/io/PrintStream;#33 = Utf8java/io/PrintStream#34 = Utf8println#35 = Utf8(I)V{public cn.itcast.jvm.Test1(); descriptor: ()Vflags: ACC_PUBLIC Code:stack=1, locals=1, args_size=1 0: aload_01: invokespecial #1// Methodjava/lang/Object."":()V4: return LineNumberTable:line 3: 0 LocalVariableTable:StartLengthSlotNameSignature050thisLcn/itcast/jvm/Test1;public static void main(java.lang.String[]); descriptor: ([Ljava/lang/String;)Vflags: ACC_PUBLIC, ACC_STATICCode:stack=2, locals=4, args_size=1 0: iconst_21: istore_12: iconst_53: istore_24: iload_25: iload_16: isub7: istore_38: getstatic#2// Field java/lang/System.out:Ljava/io/PrintStream;11: iload_312: invokevirtual #3// Methodjava/io/PrintStream.println:(I)V15: return LineNumberTable:line6:0line7:2line8:4line9:8line 10: 15LocalVariableTable:Start0Length16Slot0NameargsSignature[Ljava/lang/String;2141aI4122bI883cI}SourceFile: "Test1.java"

    内容大致分为4个部分:

    第一部分:显示了生成这个class的java源文件、版本信息、生成时间等。第二部分:显示了该类中所涉及到常量池,共35个常量。

    第三部分:显示该类的构造器,编译器自动插入的。

    第四部分:显示了main方的信息。(这个是需要我们重点关注的)

    2.2、常量池

    官网文档:

    https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.4-140

    Constant TypeValue说明CONSTANT_Class7类或接口的符号引用CONSTANT_Fieldref9字段的符号引用CONSTANT_Methodref10类中方法的符号引用CONSTANT_InterfaceMethodref11接口中方法的符号引用CONSTANT_String8字符串类型常量CONSTANT_Integer3整形常量CONSTANT_Float4浮点型常量CONSTANT_Long5长整型常量CONSTANT_Double6双精度浮点型常量CONSTANT_NameAndType12字段或方法的符号引用CONSTANT_Utf81UTF-8编码的字符串CONSTANT_MethodHandle15表示方法句柄CONSTANT_MethodType16标志方法类型CONSTANT_InvokeDynamic18表示一个动态方法调用点

    2.3、描述符

    2.3.1、字段描述符

    官网:https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.3.2

    FieldType termTypeInterpretationBbytesigned byteCcharUnicode character code point in the Basic Multilingual Plane, encoded with UTF-16Ddoubledouble-precision floating-point valueFfloatsingle-precision floating-point valueIintintegerJlonglong integerLClassName;referencean instance of class ClassNameSshortsigned shortZbooleantrue or false[referenceone array dimension

    2.3.2、方法描述符

    官网:https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.3.3

    示例:

    The method descriptor for the method:

    Object m(int i, double d, Thread t) {...}

    is:

    (IDLjava/lang/Thread;)Ljava/lang/Object;

    2.4、解读方法字节码

    public static void main(java.lang.String[]);descriptor: ([Ljava/lang/String;)V//方法描述,V表示该方法的放回值为voidflags: ACC_PUBLIC, ACC_STATIC// 方法修饰符,public、static的Code:// stack=2,操作栈的大小为2、locals=4,本地变量表大小,args_size=1, 参数的个数stack=2, locals=4, args_size=10: iconst_2//将数字2值压入操作栈,位于栈的最上面1: istore_1//从操作栈中弹出一个元素(数字2),放入到本地变量表中,位于下标为1的位置(下标为0的是this)2: iconst_5//将数字5值压入操作栈,位于栈的最上面3: istore_2//从操作栈中弹出一个元素(5),放入到本地变量表中,位于第下标为2个位置4: iload_2//将本地变量表中下标为2的位置元素压入操作栈(5)5: iload_1//将本地变量表中下标为1的位置元素压入操作栈(2)6: isub//操作栈中的2个数字相减7: istore_3 // 将相减的结果压入到本地本地变量表中,位于下标为3的位置// 通过#2号找到对应的常量,即可找到对应的引用8: getstatic#2// Field java/lang/System.out:Ljava/io/PrintStream;11: iload_3 //将本地变量表中下标为3的位置元素压入操作栈(3)// 通过#3号找到对应的常量,即可找到对应的引用,进行方法调用12: invokevirtual #3// Method java/io/PrintStream.println:(I)V15: return //返回LineNumberTable://行号的列表line6:0line7:2line8:4line9:8line 10: 15 LocalVariableTable: // 本地变量表Start0Length16Slot0NameargsSignature[Ljava/lang/String;2141aI4122bI883cI}SourceFile: "Test1.java"

    2.4.1、图解

    5ed6d953f4c6722df573dc5c569ad1d3.png
    5a1934cf229a5a6b2d8da54fb946ebc5.png
    0529e1afa06ffbea32963a515806508c.png

    2.5、研究 i++ 与 ++i 的不同

    我们都知道,i++表示,先返回再+1,++i表示,先+1再返回。它的底层是怎么样的呢? 我们一起探究下。

    编写测试代码:

    public class Test2 {public static void main(String[] args) {new Test2().method1(); new Test2().method2();}public void method1(){int i = 1; int a = i++;System.out.println(a); //打印1}public void method2(){int i = 1; int a = ++i;System.out.println(a);//打印2}}

    2.5.1、查看class字节码

    Classfile /F:/code/itcast‐jvm/itcast‐jvm‐ test/target/classes/cn/itcast/jvm/Test2.classMD5 checksum 901660fc11c43b6daadd0942150960ed Compiled from "Test2.java"public class cn.itcast.jvm.Test2 minor version: 0major version: 52flags: ACC_PUBLIC, ACC_SUPERConstant pool:#1 = Methodref#8.#27// java/lang/Object."": ()V#2 = Class#28// cn/itcast/jvm/Test2#3 = Methodref#2.#27// cn/itcast/jvm/Test2."":()V#4 = Methodref#2.#29// cn/itcast/jvm/Test2.method1: ()V#5 = Methodref#2.#30// cn/itcast/jvm/Test2.method2: ()V#6 = Fieldref#31.#32// java/lang/System.out:Ljava/io/PrintStream;#7 = Methodref#33.#34// java/io/PrintStream.println: (I)V#26=Utf8Test2.java#27=NameAndType#9:#10// "":()V#28=Utf8cn/itcast/jvm/Test2#29=NameAndType#20:#10// method1:()V#30=NameAndType#24:#10// method2:()V#31=Class#36// java/lang/System#32=NameAndType#37:#38// out:Ljava/io/PrintStream;#33=Class#39// java/io/PrintStream#34=NameAndType#40:#41// println:(I)V#35=Utf8java/lang/Object#36=Utf8java/lang/System#37=Utf8out#38=Utf8Ljava/io/PrintStream;#39=Utf8java/io/PrintStream#40=Utf8println#41=Utf8(I)V{public cn.itcast.jvm.Test2(); descriptor: ()Vflags: ACC_PUBLIC Code:stack=1, locals=1, args_size=1 0: aload_01: invokespecial #1// Method java/lang/Object."":()V4: return LineNumberTable:line 3: 0 LocalVariableTable:StartLengthSlotNameSignature050thisLcn/itcast/jvm/Test2;public static void main(java.lang.String[]); descriptor: ([Ljava/lang/String;)Vflags: ACC_PUBLIC, ACC_STATICCode:stack=2, locals=1, args_size=10: new#2// class cn/itcast/jvm/Test23: dup4: invokespecial #3// Method "":()V7: invokevirtual #4// Method method1:()V10: new#2// class cn/itcast/jvm/Test213: dup14: invokespecial #3// Method "":()V17: invokevirtual #5// Method method2:()V20: return LineNumberTable:line 6: 0line 7: 10line 8: 20 LocalVariableTable:StartLengthSlotNameSignature0210args[Ljava/lang/String;public void method1(); descriptor: ()V flags: ACC_PUBLIC Code:stack=2, locals=3, args_size=1 0: iconst_11: istore_12: iload_13: iinc1, 16: istore_27: getstatic#6// Field java/lang/System.out:Ljava/io/PrintStream;10: iload_211: invokevirtual #7// Method java/io/PrintStream.println:(I)V14: return LineNumberTable:line 11: 0line 12: 2line 13: 7line 14: 14 LocalVariableTable:StartLengthSlotNameSignature0150thisLcn/itcast/jvm/Test2; 2131iI782aIpublic void method2(); descriptor: ()V flags: ACC_PUBLIC Code:stack=2, locals=3, args_size=1 0: iconst_11: istore_12: iinc1, 15: iload_16: istore_27: getstatic#6// Field java/lang/System.out:Ljava/io/PrintStream;10: iload_211: invokevirtual #7// Method java/io/PrintStream.println:(I)V14: return LineNumberTable:line 17: 0line 18: 2line 19: 7line 20: 14 LocalVariableTable:StartLengthSlotNameSignature0150thisLcn/itcast/jvm/Test2; 2131iI782aI}SourceFile: "Test2.java"

    2.5.2、对比

    i++:

    0: iconst_1//将数字1压入到操作栈1: istore_1//将数字1从操作栈弹出,压入到本地变量表中,下标为12: iload_1//从本地变量表中获取下标为1的数据,压入到操作栈中3: iinc1, 1 // 将本地变量中的1,再+16: istore_2// 将数字1从操作栈弹出,压入到本地变量表中,下标为2 7: getstatic#6// Fieldjava/lang/System.out:Ljava/io/PrintStream;10: iload_2//从本地变量表中获取下标为2的数据,压入到操作栈中11: invokevirtual #7// Method java/io/PrintStream.println:(I)V14: return

    ++i:

    0: iconst_1//将数字1压入到操作栈1: istore_1//将数字1从操作栈弹出,压入到本地变量表中,下标为12: iinc1, 1// 将本地变量中的1,再+15: iload_1//从本地变量表中获取下标为1的数据(2),压入到操作栈中6: istore_2 //将数字2从操作栈弹出,压入到本地变量表中,下标为27: getstatic#6// Field java/lang/System.out:Ljava/io/PrintStream;10: iload_2 //从本地变量表中获取下标为2的数据(2),压入到操作栈中11: invokevirtual #7// Method java/io/PrintStream.println:(I)V14: return

    区别:

    i++

    只是在本地变量中对数字做了相加,并没有将数据压入到操作栈

    将前面拿到的数字1,再次从操作栈中拿到,压入到本地变量中

    ++i

    将本地变量中的数字做了相加,并且将数据压入到操作栈将操作栈中的数据,再次压入到本地变量中

    小结:可以通过查看字节码的方式对代码的底层做研究,探究其原理。

    2.6、字符串拼接

    字符串的拼接在开发过程中使用是非常频繁的,常用的方式有三种:

    +号拼接: str+“456”

    StringBuilder拼接

    StringBuffer拼接

    StringBuffer是保证线程安全的,效率是比较低的,我们更多的是使用场景是不会涉及到 线程安全的问题的,所以更多的时候会选择StringBuilder,效率会高一些。

    那么,问题来了,StringBuilder和“+”号拼接,哪个效率高呢?接下来我们通过字节码的 方式进行探究。

    首先,编写个示例:

    package cn.itcast.jvm;public class Test3 {public static void main(String[] args) {new Test3().m1();new Test3().m2();public void m1(){String s1 = "123"; String s2 = "456"; String s3 = s1 + s2; System.out.println(s3);}public void m2(){String s1 = "123"; String s2 = "456";StringBuilder sb = new StringBuilder(); sb.append(s1);sb.append(s2);String s3 = sb.toString(); System.out.println(s3);}}}

    从解字节码中可以看出,m1()方法源码中是使用+号拼接,但是在字节码中也被编译成了

    StringBuilder方式。

    所以,可以得出结论,字符串拼接,+号和StringBuilder是相等的,效率一样。

    接下来,我们再看一个案例:

    package cn.itcast.jvm; public class Test4 {public static void main(String[] args) { new Test4().m1();new Test4().m2();}public void m1(){ String str = "";for (int i = 0; i < 5; i++) { str = str + i;}System.out.println(str);}public void m2(){StringBuilder sb = new StringBuilder(); for (int i = 0; i < 5; i++) {sb.append(i);}System.out.println(sb.toString());}}

    m1() 与 m2() 哪个方法的效率高? 依然是通过字节码的方式进行探究。

    可以看到,m1()方法中的循环体内,每一次循环都会创建StringBuilder对象,效率低于

    m2()方法。

    2.7、小结

    使用字节码的方式可以很好查看代码底层的执行,从而可以看出哪些实现效率高,哪些 实现效率低。可以更好的对我们的代码做优化。让程序执行效率更高。

    3、代码优化

    优化,不仅仅是在运行环境进行优化,还需要在代码本身做优化,如果代码本身存在性 能问题,那么在其他方面再怎么优化也不可能达到效果最优的。

    3.1、尽可能使用局部变量

    调用方法时传递的参数以及在调用中创建的临时变量都保存在栈中速度较快,其他变 量,如静态变量、实例变量等,都在堆中创建,速度较慢。另外,栈中创建的变量,随 着方法的运行结束,这些内容就没了,不需要额外的垃圾回收。

    3.2、尽量减少对变量的重复计算

    明确一个概念,对方法的调用,即使方法中只有一句语句,也是有消耗的。所以例如下 面的操作:

    for (int i = 0; i < list.size(); i++){...}

    建议替换为:

    int length = list.size();

    for (int i = 0,i < length; i++)

    {...}

    这样,在list.size()很大的时候,就减少了很多的消耗。

    3.3、尽量采用懒加载的策略,即在需要的时候才创建

    String str = "aaa";if (i == 1){list.add(str);}//建议替换成if (i == 1){String str = "aaa"; list.add(str);}

    3.4、异常不应该用来控制程序流程

    异常对性能不利。抛出异常首先要创建一个新的对象,Throwable接口的构造函数调用 名为fillInStackTrace()的本地同步方 法,fillInStackTrace()方法检查堆栈,收集调用跟踪信息。只要有异常被抛出,Java虚拟机就必须调整调用堆栈,因为在处理过程中创建 了一个新的对象。异常只能用于错误处理,不应该用来控制程序流程。

    3.5、不要将数组声明为public static final

    因为这毫无意义,这样只是定义了引用为static final,数组的内容还是可以随意改变的, 将数组声明为public更是一个安全漏洞,这意味着这个数组可以被外部类所改变。

    3.6、不要创建一些不使用的对象,不要导入一些不使用的类

    这毫无意义,如果代码中出现"The value of the local variable i is not used"、“The import java.util is never used”,那么请删除这些无用的内容

    3.7、程序运行过程中避免使用反射

    反射是Java提供给用户一个很强大的功能,功能强大往往意味着效率不高。不建议在程序运行过程中使用尤其是频繁使用反射机制,特别是 Method的invoke方法。

    如果确实有必要,一种建议性的做法是将那些需要通过反射加载的类在项目启动的时候 通过反射实例化出一个对象并放入内存。

    3.8、使用数据库连接池和线程池

    这两个池都是用于重用对象的,前者可以避免频繁地打开和关闭连接,后者可以避免频 繁地创建和销毁线程。

    3.9、容器初始化时尽可能指定长度

    容器初始化时尽可能指定长度,如:new ArrayList<>(10); new HashMap<>(32); 避免容器长度不足时,扩容带来的性能损耗。

    3.10、ArrayList随机遍历快,LinkedList添加删除快

    3.11、使用Entry遍历Map

    Map map = new HashMap<>();for (Map.Entry entry : map.entrySet()) { String key = entry.getKey();String value = entry.getValue();}

    避免使用这种方式:

    Map map = new HashMap<>(); for (String key : map.keySet()) {String value = map.get(key);}

    3.12、不要手动调用System.gc();

    3.13、String尽量少用正则表达式

    正则表达式虽然功能强大,但是其效率较低,除非是有需要,否则尽可能少用。

    replace() 不支持正则

    replaceAll() 支持正则

    如果仅仅是字符的替换建议使用replace()。

    3.14、日志的输出要注意级别

    // 当 前 的 日 志 级 别 是 error LOGGER.info("保存出错!" + user);

    3.15、对资源的close()建议分开操作

    try{XXX.close();YYY.close();}catch (Exception e){...}// 建议改为try{XXX.close();}catch (Exception e){...}try{YYY.close();}catch (Exception e){...}
    展开全文
  • tomcat设置编码格式utf8

    千次阅读 2019-01-15 10:07:28
    设置Tomcat接收请求的编码格式,只对POST方式提交的数据有效,对GET方式提交的数据无效!   要设置GET的编码,可以修改server.xml文件中,相应的端口的Connector的属性:URIEncoding="UTF-8",这样,...

    利用request.setCharacterEncoding("UTF-8");来设置Tomcat接收请求的编码格式,只对POST方式提交的数据有效,对GET方式提交的数据无效!
     

    要设置GET的编码,可以修改server.xml文件中,相应的端口的Connector的属性:URIEncoding="UTF-8",这样,GET方式提交的数据才会被正确解码。

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

     

     

    tomcat8以后默认编码格式是utf-8;7之前的都是iso8859-1

     

    如果默认情况下,tomcat使用的的编码方式:iso8859-1

     

    修改tomcat下的conf/server.xml文件

    找到如下代码:    
    <Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" />
    这段代码规定了Tomcat监听HTTP请求的端口号等信息。

    可以在这里添加一个属性:URIEncoding,将该属性值设置为UTF-8,即可让Tomcat(默认ISO-8859-1编码)以UTF-8的编码处理get请求。

    修改完成后:

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

     

    展开全文
  • 一:form在前台以post方式提交数据: ...应该是Tomcat的问题,然后去修改Tomcat的配置文件server.xml,添加URIEncoding="UTF-8" connectionTimeout="20000" redirectPort="8443" URIEncoding="UTF-8"/> 然后就好了
  • Tomcat设置编码UTF-8

    2020-04-10 15:31:35
    打开Tomcat目录,切换到tomcat的conf目录,编辑server.xml, 2.编辑serverl.xml,在下图位置加上URIEncoding="utf-8" 3.重新启动Tomcat
  • tomcat设置编码UTF-8

    2015-10-20 11:34:06
    &lt;Connector port="8090" protocol="HTTP/1.1"   connectionTimeout="20000"   redirectPort="8443" URIEncoding="UTF-8"/&gt;
  • tomcat设置UTF-8编码

    万次阅读 2018-05-20 11:00:39
    需要修改tomcat里的config.xml来修改,方法如下2种:第一种:1、在myclipse里,右键部署在tomcat里的项目,如下图所示,点击“浏览部署...utf-8",注意:别修改成注释里面的(也就是被&lt;!- --&gt; ...
  • 中文乱码问题及tomcat设置编码utf-8

    千次阅读 2017-01-12 09:52:04
    利用request.setCharacterEncoding("UTF-8");来设置Tomcat接收请求的编码格式,只对POST方式提交的数据有效,对GET方式提交的数据无效! 要设置GET的编码,可以修改server.xml文件中,相应的端口的Connector的
  • 设置Tomcat编码(UTF-8)

    2017-05-05 09:34:00
    Tomcat的默认编码是ISO-8859-1,如果有是get请求时,会出现乱码,这种情况可以修改Tomcat编码解决。...在tomcat的conf目录下,编辑server.xml配置文件,在Connector节点,加上URIEncoding="UTF-8" ...
  • tomcat设置utf-8编码

    2018-02-08 08:32:30
    默认情况下,tomcat使用的的编码方式:iso8859-1修改tomcat下的conf/server.xml文件找到如下代码: 1&lt;Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000&...
  • 项目中tomcat设置utf8解码,当对外的url接口(如ReceiveAction)接收到gbk编码请求时候会自动被tomcat解码为utf8, 此时中文直接request.getParameter("content")出来就是乱码,无法直接转换回gbk,怎么转换都是...
  • tomcat服务器server.xml文件设置编码 说明:(1)tomcat8以后默认编码格式是utf-8;7之前的都是iso8859-1; <Connector connectionTimeout="20000" port="8080" protocol=...
  • IDEA TOMCAT设置UTF-8编码

    千次阅读 2019-06-27 09:14:41
    输入-Dfile.encoding=utf-8
  • Tomcat怎么设置UTF-8编码

    万次阅读 2016-10-10 20:34:00
    1.首先在Tomcat安装目录下面的conf文件夹下面找到server.xml文件,打开进行编辑 2.找到代码段  connectionTimeout="20000"  ... redirectPort="8443" /> ...在后面加上UTF-8 如下所示   connectionTim
  • 修改tomcat默认编码格式:   修改tomcat下的conf/server.xml文件,找到如下代码:    &lt;Connector port="8080" protocol="HTTP/1.1"  connectionTimeout="20000"  ...
  • tomcat 启动编码设置UTF-8,乱码)

    千次阅读 2019-09-16 09:15:34
    参考博客: 1.tomcat 启动编码设置:...2.Tomcat乱码问题 catalina.bat设置UTF-8 控制台出现乱码https://blog.csdn.net/zhaoxny/article/details/79926333 ...
  • Homepage URLhttp://flysky-1.at.vwdhosting.netFTP server name:ftp://flysky-1@ftp6.vwdhosting.net Login:flysky-1Password:k%x5WY(0zp? CSDN 论坛 http://www.csdn.net/ 中国最有名的技术论坛,《程序员》杂志...
  • 设置tomcat服务器编码utf-8编码

    千次阅读 2019-06-10 17:49:12
    在测试环境出现的数据,在本地不显示,打断点发现是传入的数据乱码了,于是需要在接收数据的服务器上面设置encode编码,针对get请求。 URIEncoding="UTF-8" <Connector connectionTimeout="20000" port="8080...
  • 设置TomcatUTF-8编码

    2016-09-18 18:12:08
    设置TomcatUTF-8编码
  • <Connector URIEncoding="UTF-8" connectionTimeout="20000" port="8080" protocol="HTTP/1.1" redirectPort="8443"/> 转载于:https://www.cnblogs.com/lijiale/p/5420120.html

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,850
精华内容 740
关键字:

tomcat设置编码utf8