整合营销服务商
电脑端+手机端+微信端=数据同步管理
免费咨询热线：
电脑端+手机端+微信端=数据同步管理
免费咨询热线：
于封装的原则，API 的设计者会将部分成员（属性、字段、方法等）隐藏以保证健壮性。但总有需要直接访问这些私有成员的情况。
为了访问一个类型的私有成员，除了更改 API 还有就是使用反射技术：
public class MyApi
{
public MyApi()
{
_createdAt=DateTime.Now;
}
private DateTime _createdAt;
public int ShowTimes { get; private set; }
public void ShowCreateTime()
{
Console.WriteLine(_createdAt);
ShowTimes++;
}
}
void Main()
{
var api=new MyApi();
var field=api.GetType().GetField("_createdAt", BindingFlags.NonPublic | BindingFlags.Instance);
var value=field.GetValue(api);
Console.WriteLine(value);
}这种写法并不优雅：
笔者基于“动态类型技术”探索出了一种相对来说比较优雅的方案用于美化上述代码，并为其命名为 ReflectionDynamicObject ：
void Main()
{
var api=new MyApi();
dynamic wrapper=ReflectionDynamicObject.Wrap(api);
Console.WriteLine(wrapper._createdAt);
}除了支持获取值，ReflectionDynamicObject 还支持赋值：
void Main()
{
var api=new MyApi();
dynamic wrapper=ReflectionDynamicObject.Wrap(api);
wrapper._createdAt=new DateTime(2022, 2, 2, 22, 22, 22);
api.ShowCreateTime();
}除了字段，当然也支持对属性的操作：
void Main()
{
var api=new MyApi();
dynamic wrapper=ReflectionDynamicObject.Wrap(api);
wrapper.ShowTimes=100;
Console.WriteLine(wraper.ShowTimes);
}在对属性的支持上，ReflectionDynamicObject 使用了“快速反射”技术，将取值和复制操作生成了委托以优化性能。
ReflectionDynamicObject 派生自 DynamicObject ，其内部通过反射技术获取到所有的属性和字段并对其 getter 和 setter 方法进行存储并通过 TryGetMember 和 TrySetMember 方法经运行时调用。
public sealed class ReflectionDynamicObject : DynamicObject
{
private readonly object _instance;
private readonly Accessor _accessor;
private ReflectionDynamicObject(object instance)
{
_instance=instance ?? throw new ArgumentNullException(nameof(instance));
_accessor=GetAccessor(instance.GetType());
}
public static ReflectionDynamicObject Wrap(Object value)
{
if (value==null) throw new ArgumentNullException(nameof(value));
return new ReflectionDynamicObject(value);
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
if (_accessor.TryFindGetter(binder.Name, out var getter))
{
result=getter.Get(_instance);
return true;
}
return base.TryGetMember(binder, out result);
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
if (_accessor.TryFindSetter(binder.Name, out var setter))
{
setter.Set(_instance, value);
return true;
}
return base.TrySetMember(binder, value);
}
#region 快速反射
private interface IGetter
{
object Get(object instance);
}
private interface ISetter
{
void Set(object instance, object value);
}
private class Getter : IGetter
{
private FieldInfo _field;
public Getter(FieldInfo field)
{
_field=field ?? throw new ArgumentNullException(nameof(field));
}
public object Get(object instance)
{
return _field.GetValue(instance);
}
}
private class Setter : ISetter
{
private FieldInfo _field;
public Setter(FieldInfo field)
{
_field=field ?? throw new ArgumentNullException(nameof(field));
}
public void Set(object instance, object value)
{
_field.SetValue(instance, value);
}
}
private class Getter<T1, T2> : IGetter
{
private readonly Func<T1, T2> _getter;
public Getter(Func<T1, T2> getter)
{
_getter=getter ?? throw new ArgumentNullException(nameof(getter));
}
public object Get(object instance)
{
return _getter((T1)instance);
}
}
private class Setter<T1, T2> : ISetter
{
private readonly Action<T1, T2> _setter;
public Setter(Action<T1, T2> setter)
{
this._setter=setter ?? throw new ArgumentNullException(nameof(setter));
}
public void Set(object instance, object value)
{
this._setter.Invoke((T1)instance, (T2)value);
}
}
private class Accessor
{
public Accessor(Type type)
{
this._type=type ?? throw new ArgumentNullException(nameof(_type));
var getter=new SortedDictionary<string, IGetter>();
var setter=new SortedDictionary<string, ISetter>();
var fields=_type.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (var field in fields)
{
getter[field.Name]=new Getter(field);
setter[field.Name]=new Setter(field);
}
var props=_type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
foreach (var item in props)
{
if (item.CanRead)
{
var method=item.GetMethod;
var funcType=typeof(Func<,>).MakeGenericType(item.DeclaringType, item.PropertyType);
var func=method.CreateDelegate(funcType);
var getterType=typeof(Getter<,>).MakeGenericType(item.DeclaringType, item.PropertyType);
var get=(IGetter)Activator.CreateInstance(getterType, func);
getter[item.Name]=get;
}
if (item.CanWrite)
{
var method=item.SetMethod;
var actType=typeof(Action<,>).MakeGenericType(item.DeclaringType, item.PropertyType);
var act=method.CreateDelegate(actType);
var setterType=typeof(Setter<,>).MakeGenericType(item.DeclaringType, item.PropertyType);
var set=(ISetter)Activator.CreateInstance(setterType, act);
setter[item.Name]=set;
}
}
_getters=getter;
_setters=setter;
}
private readonly Type _type;
private readonly IReadOnlyDictionary<string, IGetter> _getters;
private readonly IReadOnlyDictionary<string, ISetter> _setters;
public bool TryFindGetter(string name, out IGetter getter)=> _getters.TryGetValue(name, out getter);
public bool TryFindSetter(string name, out ISetter setter)=> _setters.TryGetValue(name, out setter);
}
private static Dictionary<Type, Accessor> _accessors=new Dictionary<Type, Accessor>();
private static object _accessorsLock=new object();
private static Accessor GetAccessor(Type type)
{
if (_accessors.TryGetValue(type, out var accessor)) return accessor;
lock (_accessorsLock)
{
if (_accessors.TryGetValue(type, out accessor)) return accessor;
accessor=new Accessor(type);
var temp=new Dictionary<Type, Accessor>(_accessors);
temp[type]=new Accessor(type);
_accessors=temp;
return accessor;
}
}
#endregion
}基于复杂度的考虑，ReflectionDynamicObject 并未添加对“方法”的支持。这也就意味着对方法的调用是缺失的。虽然动态行为让程序摆脱了对字符串的依赖，但是该实现对“重构”的支持仍然不友好。
Liquid 主题引擎 是笔者根据 Liquid 语言和 Shopify 主题机制并采用 Fluid 模板引擎实现的一套 HTML 主题引擎。该引擎允许最终用户自由地修改自己的主题模板而不会对宿主造成影响。最终目标是做到多语言、多主题、高扩展性以及所见即所得。
在编写 Liquid 主题引擎 时，笔者需要重写 Fluid 模板引擎的 render 标签让子视图从 snippets 文件夹加载。在实现该标签时，需要访问 TemplateContext 的 LocalScope 和 RootScope 字段，不幸的是上述字段被标记为了 internal ，无法在外部程序集中访问到。于是便有了 ReflectionDynamicObject ，帮助笔者完成对 LocalScope 和 RootScope 的访问。
今日内容
Tomcat8的优化
看懂Java底层字节码
编码的优化建议
tomcat服务器在JavaEE项目中使用率非常高，所以在生产环境对tomcat的优化也变得非 常重要了。
对于tomcat的优化，主要是从2个方面入手，一是，tomcat自身的配置，另一个是
tomcat所运行的jvm虚拟机的调优。
下面我们将从这2个方面进行讲解。
1.1、Tomcat配置优化1.1.1、部署安装tomcat8 下载并安装：
https://tomcat.apache.org/download-80.cgi
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
#将<Valve的内容注释掉
<!‐‐ ‐‐>
#保存退出即可
#启动tomcat
cd /tmp/apache‐tomcat‐8.5.34/bin/
./startup.sh && tail ‐f …/logs/catalina.out
#打开浏览器进行测试访问http://192.168.40.133:8080/
点击“Server Status”，输入用户名、密码进行登录，tomcat/tomcat
进入之后即可看到服务的信息。
1.1.2、禁用AJP连接
在服务状态页面中可以看到，默认状态下会启用AJP服务，并且占用8009端口。
什么是AJP呢？
AJP（Apache JServer Protocol）
AJPv13协议是面向包的。WEB服务器和Servlet容器通过TCP连接来交互；为了节省SOCKET创建的昂贵代价，WEB服务器会尝试维护一个永久TCP连接到servlet容器，并且在多个请求和响应周期过程会重用连接。
我们一般是使用Nginx+tomcat的架构，所以用不着AJP协议，所以把AJP连接器禁用。修改conf下的server.xml文件，将AJP服务禁用掉即可。
<Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />
重启tomcat，查看效果。
可以看到AJP服务以及不存在了。
1.1.3、执行器（线程池）
在tomcat中每一个用户请求都是一个线程，所以可以使用线程池提高性能。
修改server.xml文件：
<!‐‐将注释打开‐‐> <Executor name="tomcatThreadPool" namePrefix="catalina‐exec‐" maxThreads="500" minSpareThreads="50" prestartminSpareThreads="true" maxQueueSize="100"/> <!‐‐ 参数说明： maxThreads：最大并发数，默认设置 200，一般建议在 500 ~ 1000，根据硬件设施和业务来判断 minSpareThreads：Tomcat 初 始 化 时 创 建 的 线 程 数 ， 默 认 设 置 25 prestartminSpareThreads： 在 Tomcat 初始化的时候就初始化 minSpareThreads 的参数值，如果不等于 true，minSpareThreads 的值就没啥效果了 maxQueueSize，最大的等待队列数，超过则拒绝请求 ‐‐> <!‐‐在Connector中设置executor属性指向上面的执行器‐‐> <Connector executor="tomcatThreadPool" port="8080" protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443" />
保存退出，重启tomcat，查看效果。
在页面中显示最大线程数为-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：
<Connector executor="tomcatThreadPool" port="8080" protocol="org.apache.coyote.http11.Http11Nio2Protocol" connectionTimeout="20000" redirectPort="8443" />
可以看到已经设置为nio2了。
1.2、部署测试用的java web项目
为了方便测试性能，我们将部署一个java web项目，这个项目本身和本套课程没有什么关系，仅仅用于测试。
注意：这里在测试时，我们使用一个新的tomcat，进行测试，后面再对其进行优化 调整，再测试。
1.2.1、创建dashboard数据库
在资料中找到sql脚本文件dashboard.sql，在linux服务器上执行。
cat dashboard.sql | mysql ‐uroot ‐proot
创建完成后，可以看到有3张表。
1.2.2、部署web应用
在资料中找到itcat-dashboard-web.war，上传到linux服务器，进行部署安装。
cd /tmp/apache‐tomcat‐8.5.34/webapps rm ‐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.Driver jdbc.url=jdbc:mysql://node01:3306/dashboard? useUnicode=true&characterEncoding=utf8&autoReconnect=true&allowMultiQueri es=true jdbc.username=root jdbc.password=root
重新启动tomcat。
访问首页，查看是否已经启动成功：http://192.168.40.133:8080/index
1.3、使用Apache JMeter进行测试
Apache Jmeter是开源的压力测试工具，我们借助于此工具进行测试，将测试出tomcat
的吞吐量等信息。
1.3.1、下载安装
下载地址：http://jmeter.apache.org/download_jmeter.cgi
安装：直接将下载好的zip压缩包进行解压即可。
进入bin目录，找到jmeter.bat文件，双机打开即可启动。
1.3.2、修改主题和语言
默认的主题是黑色风格的主题并且语言是英语，这样不太方便使用，所以需要修改下主题和中文语言。
主题修改完成。
接下来设置语言为简体中文。
1.3.3、创建首页的测试用例
第一步：保存测试用例
第二步：添加线程组，使用线程模拟用户的并发
1000个线程，每个线程循环10次，也就是tomcat会接收到10000个请求。
第三步：添加http请求
第四步：添加请求监控
1.3.4、启动、进行测试
1.3.5、聚合报告
在聚合报告中，重点看吞吐量。
1.4、调整tomcat参数进行优化
通过上面测试可以看出，tomcat在不做任何调整时，吞吐量为73次/秒。
1.4.1、禁用AJP服务
可以看到，禁用AJP服务后，吞吐量会有所提升。
当然了，测试不一定准确，需要多测试几次才能看出是否有提升。
1.4.2、设置线程池
通过设置线程池，调整线程池相关的参数进行测试tomcat的性能。
1.4.2.1、最大线程数为500，初始为50
<Executor name="tomcatThreadPool" namePrefix="catalina‐exec‐" maxThreads="500" minSpareThreads="50" prestartminSpareThreads="true"/>
测试结果：
吞吐量为128次/秒，性能有所提升。
1.4.2.2、最大线程数为1000，初始为200
<Executor name="tomcatThreadPool" namePrefix="catalina‐exec‐" maxThreads="1000" minSpareThreads="200" prestartminSpareThreads="true"/>
吞吐量为151，性能有所提升。
1.4.2.3、最大线程数为5000，初始为1000
是否是线程数最多，速度越快呢？ 我们来测试下。
<Executor name="tomcatThreadPool" namePrefix="catalina‐exec‐" maxThreads="5000" minSpareThreads="1000" prestartminSpareThreads="true"/>
可以看到，虽然最大线程已经设置到5000，但是实际测试效果并不理想，并且平均的响 应时间也边长了，所以单纯靠提升线程数量是不能一直得到性能提升的。
1.4.2.4、设置最大等待队列数
默认情况下，请求发送到tomcat，如果tomcat正忙，那么该请求会一直等待。这样虽然 可以保证每个请求都能请求到，但是请求时间就会边长。
有些时候，我们也不一定要求请求一定等待，可以设置最大等待队列大小，如果超过就不等待了。这样虽然有些请求是失败的，但是请求时间会虽短。典型的应用：12306。
<!‐‐最大等待数为100‐‐> <Executor name="tomcatThreadPool" namePrefix="catalina‐exec‐" maxThreads="500" minSpareThreads="100" prestartminSpareThreads="true" maxQueueSize="100"/>
测试结果：
平均响应时间：3.1秒响应时间明显缩短
错误率：49.88%
错误率提升到一半，也可以理解，最大线程为500，测试的并发为1000 吞吐量：238次/秒
吞吐量明显提升
结论：响应时间、吞吐量这2个指标需要找到平衡才能达到更好的性能。
1.4.3、设置nio2的运行模式
将最大线程设置为500进行测试：
<Executor name="tomcatThreadPool" namePrefix="catalina‐exec‐" maxThreads="500" minSpareThreads="50" prestartminSpareThreads="true"/> <!‐‐ 设置nio2 ‐‐> <Connector executor="tomcatThreadPool" port="8080" protocol="org.apache.coyote.http11.Http11Nio2Protocol" connectionTimeout="20000" redirectPort="8443" />
可以看到，平均响应时间有缩短，吞吐量有提升，可以得出结论：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"
测试结果与默认的JVM参数结果接近。（执行了2次测试，结果是第二次测试的结果）
1.5.2、查看gc日志文件
将gc.log文件上传到gceasy.io查看gc中是否存在问题。
在报告中显示，在5次GC时，系统所消耗的时间大于用户时间，这反应出的服务器的性能存在瓶颈，调度CPU等资源所消耗的时间要长一些。
问题二：
可以关键指标中可以看出，吞吐量表现不错，但是gc时，线程的暂停时间稍有点长。
问题三：
通过GC的统计可以看出：
年轻代的gc有74次，次数稍有多，说明年轻代设置的大小不合适需要调整
FullGC有8次，说明堆内存的大小不合适，需要调整
问题四：
从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
从测试结果来看，吞吐量以及响应时间均有提升。
查看gc日志：
可以看到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"
测试结果：
可以看到，吞吐量有所提升，评价响应时间也有所缩短。
1.5.5、小结
通过上述的测试，可以总结出，对tomcat性能优化就是需要不断的进行调整参数，然后 测试结果，可能会调优也可能会调差，这时就需要借助于gc的可视化工具来看gc的情 况。再帮我我们做出决策应该调整哪些参数。
前面我们通过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.txt javap用法: javap <options> <classes> 其中, 可能的选项包括: ‐help ‐‐help ‐? ‐version ‐v ‐verbose ‐l ‐public ‐protected ‐package ‐p ‐private ‐c ‐s ‐sysinfo ‐constants ‐classpath <path> ‐cp <path> ‐bootclasspath <path>
查看Test1.txt文件，内容如下：
Classfile /F:/code/itcast‐jvm/itcast‐jvm‐ test/target/classes/cn/itcast/jvm/Test1.class
Last modified 2018‐9‐27; size 577 bytes
MD5 checksum 4214859db3543c0c783ec8a216a4795f Compiled from "Test1.java"
public class cn.itcast.jvm.Test1 minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1=Methodref #5.#23 // java/lang/Object."<init>": ()V
#2=Fieldref #24.#25 // java/lang/System.out:Ljava/io/PrintStream;
#3=Methodref #26.#27 // java/io/PrintStream.println: (I)V
#28=Utf8 cn/itcast/jvm/Test1
#29=Utf8 java/lang/Object
#30=Utf8 java/lang/System
#31=Utf8 out
#32=Utf8 Ljava/io/PrintStream;
#33=Utf8 java/io/PrintStream
#34=Utf8 println
#35=Utf8 (I)V
{
public cn.itcast.jvm.Test1(); descriptor: ()V
flags: ACC_PUBLIC Code:
stack=1, locals=1, args_size=1 0: aload_0
1: invokespecial #1 // Method
java/lang/Object."<init>":()V
4: return LineNumberTable:
line 3: 0 LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this Lcn/itcast/jvm/Test1;
public static void main(java.lang.String[]); descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=4, args_size=1 0: iconst_2
1: istore_1
2: iconst_5
3: istore_2
4: iload_2
5: iload_1
6: isub
7: istore_3
8: getstatic #2 // Field java/lang/System.out:Ljava/io/PrintStream;
11: iload_3
12: invokevirtual #3 // Method
java/io/PrintStream.println:(I)V
15: return LineNumberTable:
line 6: 0
line 7: 2
line 8: 4
line 9: 8
line 10: 15
LocalVariableTable:
Start
0 Length
16 Slot
0 Name
args Signature
[Ljava/lang/String;
2 14 1 a I
4 12 2 b I
8 8 3 c I
}
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 Type Value 说明 CONSTANT_Class 7 类或接口的符号引用 CONSTANT_Fieldref 9 字段的符号引用 CONSTANT_Methodref 10 类中方法的符号引用 CONSTANT_InterfaceMethodref 11 接口中方法的符号引用 CONSTANT_String 8 字符串类型常量 CONSTANT_Integer 3 整形常量 CONSTANT_Float 4 浮点型常量 CONSTANT_Long 5 长整型常量 CONSTANT_Double 6 双精度浮点型常量 CONSTANT_NameAndType 12 字段或方法的符号引用 CONSTANT_Utf8 1 UTF-8编码的字符串 CONSTANT_MethodHandle 15 表示方法句柄 CONSTANT_MethodType 16 标志方法类型 CONSTANT_InvokeDynamic 18 表示一个动态方法调用点
2.3、描述符
2.3.1、字段描述符
官网：https://docs.oracle.com/javase/specs/jvms/se8/html/jvms-4.html#jvms-4.3.2
FieldType term Type Interpretation B byte signed byte C char Unicode character code point in the Basic Multilingual Plane, encoded with UTF-16 D double double-precision floating-point value F float single-precision floating-point value I int integer J long long integer LClassName; reference an instance of class ClassName S short signed short Z boolean true or false [ reference one 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表示该方法的放回值为void flags: ACC_PUBLIC, ACC_STATIC // 方法修饰符，public、static的 Code: // stack=2,操作栈的大小为2、locals=4，本地变量表大小，args_size=1, 参数 的个数 stack=2, locals=4, args_size=1 0: 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)V 15: return //返回 LineNumberTable: //行号的列表 line 6: 0 line 7: 2 line 8: 4 line 9: 8 line 10: 15 LocalVariableTable: // 本地变量表 Start 0 Length 16 Slot 0 Name args Signature [Ljava/lang/String; 2 14 1 a I 4 12 2 b I 8 8 3 c I } SourceFile: "Test1.java"
2.4.1、图解
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.class
MD5 checksum 901660fc11c43b6daadd0942150960ed Compiled from "Test2.java"
public class cn.itcast.jvm.Test2 minor version: 0
major version: 52
flags: ACC_PUBLIC, ACC_SUPER
Constant pool:
#1=Methodref #8.#27 // java/lang/Object."<init>": ()V
#2=Class #28 // cn/itcast/jvm/Test2
#3=Methodref #2.#27 // cn/itcast/jvm/Test2."
<init>":()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=Utf8 Test2.java
#27=NameAndType #9:#10 // "<init>":()V
#28=Utf8 cn/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=Utf8 java/lang/Object
#36=Utf8 java/lang/System
#37=Utf8 out
#38=Utf8 Ljava/io/PrintStream;
#39=Utf8 java/io/PrintStream
#40=Utf8 println
#41=Utf8 (I)V
{
public cn.itcast.jvm.Test2(); descriptor: ()V
flags: ACC_PUBLIC Code:
stack=1, locals=1, args_size=1 0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: return LineNumberTable:
line 3: 0 LocalVariableTable:
Start Length Slot Name Signature
0 5 0 this Lcn/itcast/jvm/Test2;
public static void main(java.lang.String[]); descriptor: ([Ljava/lang/String;)V
flags: ACC_PUBLIC, ACC_STATIC
Code:
stack=2, locals=1, args_size=1
0: new #2 // class cn/itcast/jvm/Test2
3: dup
4: invokespecial #3 // Method "<init>":()V
7: invokevirtual #4 // Method method1:()V
10: new #2 // class cn/itcast/jvm/Test2
13: dup
14: invokespecial #3 // Method "<init>":()V
17: invokevirtual #5 // Method method2:()V
20: return LineNumberTable:
line 6: 0
line 7: 10
line 8: 20 LocalVariableTable:
Start Length Slot Name Signature
0 21 0 args [Ljava/lang/String;
public void method1(); descriptor: ()V flags: ACC_PUBLIC Code:
stack=2, locals=3, args_size=1 0: iconst_1
1: istore_1
2: iload_1
3: iinc 1, 1
6: istore_2
7: getstatic #6 // Field java/lang/System.out:Ljava/io/PrintStream;
10: iload_2
11: invokevirtual #7 // Method java/io/PrintStream.println:(I)V
14: return LineNumberTable:
line 11: 0
line 12: 2
line 13: 7
line 14: 14 LocalVariableTable:
Start Length Slot Name Signature
0 15 0 this Lcn/itcast/jvm/Test2; 2 13 1 i I
7 8 2 a I
public void method2(); descriptor: ()V flags: ACC_PUBLIC Code:
stack=2, locals=3, args_size=1 0: iconst_1
1: istore_1
2: iinc 1, 1
5: iload_1
6: istore_2
7: getstatic #6 // Field java/lang/System.out:Ljava/io/PrintStream;
10: iload_2
11: invokevirtual #7 // Method java/io/PrintStream.println:(I)V
14: return LineNumberTable:
line 17: 0
line 18: 2
line 19: 7
line 20: 14 LocalVariableTable:
Start Length Slot Name Signature
0 15 0 this Lcn/itcast/jvm/Test2; 2 13 1 i I
7 8 2 a I
}
SourceFile: "Test2.java"
2.5.2、对比
i++：
0: iconst_1 //将数字1压入到操作栈 1: istore_1 //将数字1从操作栈弹出，压入到本地变量表中，下标为1 2: iload_1 //从本地变量表中获取下标为1的数据，压入到操作栈中 3: iinc 1, 1 // 将本地变量中的1，再+1 6: istore_2 // 将数字1从操作栈弹出，压入到本地变量表中，下标为2 7: getstatic #6 // Field java/lang/System.out:Ljava/io/PrintStream; 10: iload_2 //从本地变量表中获取下标为2的数据，压入到操作栈中 11: invokevirtual #7 // Method java/io/PrintStream.println:(I)V 14: return
++i：
0: iconst_1 //将数字1压入到操作栈 1: istore_1 //将数字1从操作栈弹出，压入到本地变量表中，下标为1 2: iinc 1, 1// 将本地变量中的1，再+1 5: iload_1 //从本地变量表中获取下标为1的数据（2），压入到操作栈中 6: istore_2 //将数字2从操作栈弹出，压入到本地变量表中，下标为2 7: getstatic #6 // Field java/lang/System.out:Ljava/io/PrintStream; 10: iload_2 //从本地变量表中获取下标为2的数据（2），压入到操作栈中 11: invokevirtual #7 // Method java/io/PrintStream.println:(I)V 14: 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.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<String,String> map=new HashMap<>();
for (Map.Entry<String,String> entry : map.entrySet()) { String key=entry.getKey();
String value=entry.getValue();
}
避免使用这种方式：
Map<String,String> 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()建议分开操作
者 | 靖凡无所畏惧
责编 | 屠敏
出品 | CSDN 博客
前言
相信现在很多人都是用Vue做过了各种项目，但是项目代码做完和上线并不代表这结束，还有上线以后的优化也是很重要的一点，这次的博客就来给大家说一下如何优化一下Vue的项目，让你的项目打包和运行速度更上一个台阶。
优化策略
生成打包报告
修改webpack默认配置
加载外部CDN资源
路由懒加载
开启gizp配置
生成打包报告
生成Vue的打包报告目的在于让我们先大概的了解到当前项目生成的各个文件的大小，让我们心里有数，知道哪里需要优化。
通过命令行参数形式生成报告：
//通过 vue-cli的命令选项可以生成打包报告
// --report 选项可以生成 report.html 用以分析包内容
vue-cli-service build --report通过可视化面板直接查看报告：
可以在UI面板中，通过控制台和分析面板，可以方便的查看项目中所存在的问题。
上边图片中标注的就是我们需要注意的，依赖项很多，导致打的包最终体积非常的大，相信这项目如果上线那么前端会先请求这个无比巨大的js文件，估计甲方爸爸会锤死前端人员。
通过 vue.config.js修改webpack的默认配置
通过vue-cli 3,0 工具生成的项目，默认隐藏了所有的 webpack配置项，目的是为了屏幕项目的配置过程，让程序员的工作重心放到具体的功能和逻辑的实现上。
如果程序员有修改 webpack默认配置的需求，可以在项目根目录中 按需创建vue.config.js这个配置文件，从而对项目的打包发布过程做自定义配置，具体可以参考 https://cli.vuejs.org/zh/config/#vue-config-js
为开发模式和发布模式指定不同的打包入口：
默认情况下，Vue项目的开发模式和发布模式公用一个入口文件(src/main.js)，为了将项目的开发过程与发布过程分离，我们可以设置两种模式，各自指定打包入口文件。
开发模式入口文件：src/main-dev.js
发布模式入口文件：src/main-prod.js
通过chainWebpack自定义打包入口：
module.exports={
lintOnSave: false,
chainWebpack:config=>{
//生产环境
config.when(process.env.NODE_ENV==='production',config=>{
//注意main-prod.js是已经存在的文件
config.entry('app').clear.add('./src/main-prod.js')
})
//开发环境
config.when(process.env.NODE_ENV==='development',config=>{
//注意main-dev.js是已经存在的文件
config.entry('app').clear.add('./src/main-dev.js')
})
}
}
因为开发生产环境不同，所以在main.js文件中内容就可能不同，为了解决耦合，我们就把main.js 重新划分成了两个文件 分别是main-dev.js 和 main-prod.js
通过externals加载外部CDN资源:
默认情况下，通过import语法导入的第三方依赖包，最终会打包合并到同一个文件中，从而导致打包成功后，单文件体积过大的问题。
vue.config.js的配置externals节点：
module.exports={
lintOnSave: false,
chainWebpack:config=>{
//生产环境
config.when(process.env.NODE_ENV==='production',config=>{
config.entry('app').clear.add('./src/main-prod.js')
config.set('externals',{
vue:'Vue',
'vue-router':'VueRouter',
axios:'axios',
lodash:'_',
echarts:'echarts',
nprogress:'NProgress',
'vue-quill-editor':'VueQuillEditor'
})
})
//开发环境
config.when(process.env.NODE_ENV==='development',config=>{
config.entry('app').clear.add('./src/main-dev.js')
})
}
}通过设置externals这个节点，指定哪些包直接去window上去查找使用，而不会将这些指定的包再次打包起来，这样就可以减小最终生成的js的文件体积。
去除main.js中引入的第三方包的样式表：
将这些样式表也统统的从main.js文件中去除，统一由CDN进行引入。
在public/index.html中添加 css和js的CDN地址：
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="utf-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width,initial-scale=1.0">
<link rel="icon" href="<%=BASE_URL %>favicon.ico">
<title><%=htmlWebpackPlugin.options.title %></title>
<!-- nprogress 的样式表文件 -->
<link rel="stylesheet" href="https://cdn.staticfile.org/nprogress/0.2.0/nprogress.min.css" />
<!-- 富文本编辑器 的样式表文件 -->
<link rel="stylesheet" href="https://cdn.staticfile.org/quill/1.3.4/quill.core.min.css" />
<link rel="stylesheet" href="https://cdn.staticfile.org/quill/1.3.4/quill.snow.min.css" />
<link rel="stylesheet" href="https://cdn.staticfile.org/quill/1.3.4/quill.bubble.min.css" />
<script src="https://cdn.staticfile.org/vue/2.6.11/vue.min.js"></script>
<script src="https://cdn.staticfile.org/vue-router/3.1.6/vue-router.min.js"></script>
<script src="https://cdn.staticfile.org/axios/0.19.2/axios.min.js"></script>
<script src="https://cdn.staticfile.org/lodash.js/4.17.15/lodash.min.js"></script>
<script src="https://cdn.staticfile.org/echarts/4.7.0/echarts.min.js"></script>
<script src="https://cdn.staticfile.org/nprogress/0.2.0/nprogress.min.js"></script>
<!-- 富文本编辑器的 js 文件 -->
<script src="https://cdn.staticfile.org/quill/1.3.4/quill.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/vue-quill-editor@3.0.6/dist/vue-quill-editor.js"></script>
</head>
<body>
<noscript>
<strong>We're sorry but <%=htmlWebpackPlugin.options.title %> doesn't work properly without JavaScript enabled. Please enable it to continue.</strong>
</noscript>
<div id="app"></div>
<!-- built files will be auto injected -->
</body>
</html>我们通过CDN去引用css样式的话，我们项目生成的包中就不会存在这些css文件，可以减小项目的体积，并且，我们还将 指定的js文件也通过CDN的方式来引用，这样这些js就会注册到windows全局中，这样就对应到了vue.config.js配置externals节点的内容了。
引入CDN效果对比：
未使用CDN：
使用CDN后：
甲方爸爸打人的力度轻了许多。
路由懒加载
当项目打包构建的时候，js包会变得非常巨大，影响页面加载，如果我们能够把不同路由对应的组件分割成不同的代码块，然后当路由被访问的时候才加载对应的组件，这样就更加高效了。
安装@bable/plugin-syntax-dynamic-import包
在babel.config.js配置文件中声明该插件
将路由改为按需加载的形式：
const Login==> import(/* webpackChunkName: "login_home_welcome" */ '../components/Login.vue')
const Home==> import(/* webpackChunkName: "login_home_welcome" */ '../components/Home.vue')
const Welcome==> import(/* webpackChunkName: "login_home_welcome" */ '../components/Welcome.vue')其中webpackChunkName 指定了 打包的文件名字，让 Login.vue 、Home.vue 、 Welcome.vue 统一打到 指定的包中。
开启gizp配置：
这一项应该由后端小哥来做，使用gizp可以减少文件体积，使得传输速度更快，我们就拿Express来展示一下如何去做。
//安装相应的包
npm install compression -D
//导入包
const compression=require('compression')
//启用中间件
app.use(compression)这样我们请求包的体积就会变得更小，有助于提升我们项目运行的速度。
最终效果展示
最终在我们经过上述一系列的操作以后，我们最终生产环境打出来的包体积只有356.2KB，这样我们项目在上线以后，就可以减轻首页假死的问题，同时因为请求的文件小了很多，所以运行速度也会加快，大家赶快去优化一下自己的项目吧。
版权声明：本文为CSDN博主「靖凡无所畏惧」的原创文章，遵循CC 4.0 BY-SA版权协议。原文：https://blog.csdn.net/wjf1997/article/details/106248699
*请认真填写需求信息，我们会在24小时内与您取得联系。
